dune-functions  2.6-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 PreBasis>
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::PreBasis>(),
140  requireType<typename I::Node>(),
141  requireSameType<typename I::PreBasis, PreBasis>(),
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 std::vector<typename I::MultiIndex>::iterator>(
146  indexSet.indices(std::declval<typename std::vector<typename I::MultiIndex>::iterator>()))
147  );
148 };
149 
150 
151 // Concept for a PreBasis
152 template<class GridView>
153 struct PreBasis
154 {
155  using RootTreePath = decltype(TypeTree::hybridTreePath());
156 
157  template<class PB>
158  auto require(const PB& preBasis) -> decltype(
159  requireType<typename PB::GridView>(),
160  requireType<typename PB::size_type>(),
161  requireType<typename PB::MultiIndex>(),
162  requireType<typename PB::SizePrefix>(),
163  requireType<typename PB::template Node<RootTreePath>>(),
164  requireType<typename PB::template IndexSet<RootTreePath>>(),
165  requireSameType<typename PB::GridView, GridView>(),
166  const_cast<PB&>(preBasis).initializeIndices(),
167  requireConvertible<typename PB::GridView>(preBasis.gridView()),
168  requireConvertible<typename PB::template Node<RootTreePath>>(preBasis.node(RootTreePath())),
169  requireConvertible<typename PB::template IndexSet<RootTreePath>>(preBasis.template indexSet<RootTreePath>()),
170  requireConvertible<typename PB::size_type>(preBasis.size()),
171  requireConvertible<typename PB::size_type>(preBasis.size(std::declval<typename PB::SizePrefix>())),
172  requireConvertible<typename PB::size_type>(preBasis.dimension()),
173  requireConvertible<typename PB::size_type>(preBasis.maxNodeSize()),
174  requireConcept<BasisTree<typename PB::GridView>>(preBasis.node(RootTreePath())),
175  requireConcept<NodeIndexSet<PB>>(preBasis.template indexSet<RootTreePath>())
176  );
177 };
178 
179 
180 
181 // Concept for a LocalView
182 template<class GlobalBasis>
183 struct LocalView
184 {
185  template<class V>
186  auto require(const V& localView) -> decltype(
187  requireType<typename V::size_type>(),
188  requireType<typename V::GlobalBasis>(),
189  requireType<typename V::Tree>(),
190  requireType<typename V::GridView>(),
191  requireType<typename V::Element>(),
192  requireSameType<typename V::GlobalBasis, GlobalBasis>(),
193  requireSameType<typename V::GridView, typename GlobalBasis::GridView>(),
194  requireSameType<typename V::size_type, typename GlobalBasis::size_type>(),
195  requireSameType<typename V::Element, typename GlobalBasis::GridView::template Codim<0>::Entity>(),
196  const_cast<V&>(localView).bind(std::declval<typename V::Element>()),
197  const_cast<V&>(localView).unbind(),
198  requireConvertible<typename V::Tree>(localView.tree()),
199  requireConvertible<typename V::size_type>(localView.size()),
200  requireConvertible<typename V::size_type>(localView.maxSize()),
201  requireConvertible<typename V::GlobalBasis>(localView.globalBasis()),
202  requireConcept<BasisTree<typename V::GridView>>(localView.tree()),
203  0
204  );
205 };
206 
207 
208 
209 // Concept for a LocalIndexSet
210 template<class LocalView>
212 {
213  template<class I>
214  auto require(const I& indexSet) -> decltype(
215  requireType<typename I::size_type>(),
216  requireType<typename I::MultiIndex>(),
217  requireType<typename I::LocalView>(),
218  requireSameType<typename I::LocalView, LocalView>(),
219  const_cast<I&>(indexSet).bind(std::declval<typename I::LocalView>()),
220  const_cast<I&>(indexSet).unbind(),
221  requireConvertible<typename I::size_type>(indexSet.size()),
222  requireConvertible<typename I::MultiIndex>(indexSet.index(std::declval<typename I::size_type>())),
223  requireConvertible<typename I::LocalView>(indexSet.localView())
224  );
225 };
226 
227 
228 
229 // Concept for a GlobalBasis
230 template<class GridView>
232 {
233  template<class B>
234  auto require(const B& basis) -> decltype(
235  requireType<typename B::GridView>(),
236  requireType<typename B::size_type>(),
237  requireType<typename B::MultiIndex>(),
238  requireType<typename B::SizePrefix>(),
239  requireType<typename B::LocalIndexSet>(),
240  requireType<typename B::LocalView>(),
241  requireSameType<typename B::GridView, GridView>(),
242  requireConvertible<typename B::GridView>(basis.gridView()),
243  requireConvertible<typename B::LocalIndexSet>(basis.localIndexSet()),
244  requireConvertible<typename B::LocalView>(basis.localView()),
245  requireConvertible<typename B::size_type>(basis.size()),
246  requireConvertible<typename B::size_type>(basis.size(std::declval<typename B::SizePrefix>())),
247  requireConvertible<typename B::size_type>(basis.dimension()),
248  requireConcept<LocalIndexSet<typename B::LocalView>>(basis.localIndexSet()),
249  requireConcept<LocalView<B>>(basis.localView())
250  );
251 };
252 
253 } // namespace Dune::Functions::Concept
254 } // namespace Dune::Functions
255 } // namespace Dune
256 
257 
258 #endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_CONCEPTS_HH
Dune::Functions::Concept::BasisTree
Definition: concepts.hh:85
Dune::Functions::Concept::NodeIndexSet
Definition: concepts.hh:133
Dune
Definition: polynomial.hh:7
Dune::Functions::ExpandTuple
typename Imp::ExpandTupleHelper< T, ArgTuple >::Type ExpandTuple
Expand tuple arguments as template arguments.
Definition: utility.hh:91
Dune::Functions::Concept::LeafBasisNode
Definition: concepts.hh:70
Dune::Functions::Concept::BasisNode
Definition: concepts.hh:51
Dune::Functions::Concept::HasIndexAccess
Definition: concepts.hh:41
nodes.hh
Dune::Functions::Concept::HasResize
Definition: concepts.hh:21
Dune::Functions::Concept::LocalView
Definition: concepts.hh:183
Dune::Functions::LeafBasisNode
Definition: nodes.hh:189
Dune::Functions::Concept::PowerBasisNode
Definition: concepts.hh:89
utility.hh
Dune::Functions::Concept::PreBasis::RootTreePath
decltype(TypeTree::hybridTreePath()) RootTreePath
Definition: concepts.hh:155
Dune::Functions::Concept::GlobalBasis
Definition: concepts.hh:231
Dune::Functions::CompositeBasisNode
Definition: nodes.hh:232
Dune::Functions::Concept::CompositeBasisNode::FixArgs
Definition: concepts.hh:104
Dune::Functions::Concept::LocalIndexSet
Definition: concepts.hh:211
Dune::Functions::PowerBasisNode
Definition: nodes.hh:209
Dune::Functions::Concept::HasSizeMethod
Definition: concepts.hh:31
Dune::Functions::Concept::PreBasis
Definition: concepts.hh:153
Dune::Functions::BasisNodeMixin
Definition: nodes.hh:112
Dune::Functions::Concept::CompositeBasisNode
Definition: concepts.hh:101
Dune::Functions::Concept::CompositeBasisNode::FixArgs::CompositeBasisNode
typename Dune::Functions::CompositeBasisNode< ST, TP, T... > CompositeBasisNode
Definition: concepts.hh:107