dune-geometry 3.0-git
hcubetriangulation.cc
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_GEOMETRY_REFINEMENT_HCUBETRIANGULATION_CC
4#define DUNE_GEOMETRY_REFINEMENT_HCUBETRIANGULATION_CC
5
30
31#include "base.cc"
32#include "simplex.cc"
33
34namespace Dune
35{
36 namespace RefinementImp
37 {
45 namespace HCubeTriangulation {
46
47 // ////////////
48 //
49 // Utilities
50 //
51
54
55 // ////////////////////////////////////
56 //
57 // Refine a hypercube with simplices
58 //
59
60 // forward declaration of the iterator base
61 template<int dimension, class CoordType, int codimension>
63
64 template<int dimension_, class CoordType>
66 {
67 public:
68 enum { dimension = dimension_ };
69
70 typedef CoordType ctype;
71
72 template<int codimension>
73 struct Codim;
75 typedef FieldVector<CoordType, dimension> CoordVector;
77 typedef FieldVector<int, dimension+1> IndexVector;
78
79 static int nVertices(int level);
80 static VertexIterator vBegin(int level);
81 static VertexIterator vEnd(int level);
82
83 static int nElements(int level);
84 static ElementIterator eBegin(int level);
85 static ElementIterator eEnd(int level);
86 private:
87 friend class RefinementIteratorSpecial<dimension, CoordType, 0>;
88 friend class RefinementIteratorSpecial<dimension, CoordType, dimension>;
89
91 };
92
93 template<int dimension, class CoordType>
94 template<int codimension>
95 struct RefinementImp<dimension, CoordType>::Codim
96 {
97 class SubEntityIterator;
98 typedef Dune::MultiLinearGeometry<CoordType,dimension-codimension,dimension> Geometry;
99 };
100
101 template<int dimension, class CoordType>
102 int
104 nVertices(int level)
105 {
106 return BackendRefinement::nVertices(level) * Factorial<dimension>::factorial;
107 }
108
109 template<int dimension, class CoordType>
112 vBegin(int level)
113 {
114 return VertexIterator(level);
115 }
116
117 template<int dimension, class CoordType>
120 vEnd(int level)
121 {
122 return VertexIterator(level, true);
123 }
124
125 template<int dimension, class CoordType>
126 int
128 nElements(int level)
129 {
130 return BackendRefinement::nElements(level) * Factorial<dimension>::factorial;
131 }
132
133 template<int dimension, class CoordType>
136 eBegin(int level)
137 {
138 return ElementIterator(level);
139 }
140
141 template<int dimension, class CoordType>
144 eEnd(int level)
145 {
146 return ElementIterator(level, true);
147 }
148
149 // //////////////
150 //
151 // The iterator
152 //
153
154 // vertices
155 template<int dimension, class CoordType>
156 class RefinementIteratorSpecial<dimension, CoordType, dimension>
157 {
158 public:
160 typedef typename Refinement::CoordVector CoordVector;
161 typedef typename Refinement::template Codim<dimension>::Geometry Geometry;
162
163 RefinementIteratorSpecial(int level, bool end = false);
164
165 void increment();
166
167 CoordVector coords() const;
168
169 Geometry geometry() const;
170
171 int index() const;
172 protected:
173 typedef typename Refinement::BackendRefinement BackendRefinement;
174 typedef typename BackendRefinement::template Codim<dimension>::SubEntityIterator BackendIterator;
175 enum { nKuhnSimplices = Factorial<dimension>::factorial };
176
178
182 };
183
184 template<int dimension, class CoordType>
186 RefinementIteratorSpecial(int level, bool end)
187 : level_(level), kuhnIndex(0),
188 backend(BackendRefinement::vBegin(level_)),
189 backendEnd(BackendRefinement::vEnd(level_))
190 {
191 if (end)
192 kuhnIndex = nKuhnSimplices;
193 }
194
195 template<int dimension, class CoordType>
196 void
199 {
200 ++backend;
201 if (backend == backendEnd)
202 {
203 backend = BackendRefinement::vBegin(level_);
204 ++kuhnIndex;
205 }
206 }
207
208 template<int dimension, class CoordType>
211 coords() const
212 {
213 return referenceToKuhn(backend.coords(), getPermutation<dimension>(kuhnIndex));
214 }
215
216 template<int dimension, class CoordType>
219 {
220 std::vector<CoordVector> corners(1);
221 corners[0] = referenceToKuhn(backend.coords(), getPermutation<dimension>(kuhnIndex));
222 return Geometry(GeometryType(0), corners);
223 }
224
225 template<int dimension, class CoordType>
226 int
228 index() const
229 {
230 return kuhnIndex*BackendRefinement::nVertices(level_) + backend.index();
231 }
232
233 // elements
234 template<int dimension, class CoordType>
235 class RefinementIteratorSpecial<dimension, CoordType, 0>
236 {
237 public:
241 typedef typename Refinement::template Codim<0>::Geometry Geometry;
242
243 RefinementIteratorSpecial(int level_, bool end = false);
245
246 void increment();
247
248 IndexVector vertexIndices() const;
249 int index() const;
250 CoordVector coords() const;
251
252 Geometry geometry() const;
253
254 private:
255 CoordVector global(const CoordVector &local) const;
256
257 protected:
259 typedef typename BackendRefinement::template Codim<0>::SubEntityIterator BackendIterator;
260 enum { nKuhnSimplices = Factorial<dimension>::factorial };
261
263
267 };
268
269 template<int dimension, class CoordType>
271 RefinementIteratorSpecial(int level, bool end)
272 : level_(level), kuhnIndex(0),
273 backend(BackendRefinement::eBegin(level_)),
274 backendEnd(BackendRefinement::eEnd(level_))
275 {
276 if (end)
277 kuhnIndex = nKuhnSimplices;
278 }
279 template<int dimension, class CoordType>
282 : level_(other.level_), kuhnIndex(other.kuhnIndex),
283 backend(other.backend),
284 backendEnd(other.backendEnd)
285 {}
286
287 template<int dimension, class CoordType>
288 void
291 {
292 ++backend;
293 if (backend == backendEnd)
294 {
295 backend = BackendRefinement::eBegin(level_);
296 ++kuhnIndex;
297 }
298 }
299
300 template<int dimension, class CoordType>
303 vertexIndices() const
304 {
305 IndexVector indices = backend.vertexIndices();
306
307 int base = kuhnIndex * BackendRefinement::nVertices(level_);
308 indices += base;
309
310 return indices;
311 }
312
313 template<int dimension, class CoordType>
314 int
316 index() const
317 {
318 return kuhnIndex*BackendRefinement::nElements(level_) + backend.index();
319 }
320
321 template<int dimension, class CoordType>
324 coords() const
325 {
326 return global(backend.coords());
327 }
328
329 template<int dimension, class CoordType>
332 {
333 const typename BackendIterator::Geometry &bgeo =
334 backend.geometry();
335 std::vector<CoordVector> corners(dimension+1);
336 for(int i = 0; i <= dimension; ++i)
337 corners[i] = global(bgeo.corner(i));
338
339 return Geometry(bgeo.type(), corners);
340 }
341
342 template<int dimension, class CoordType>
345 global(const CoordVector &local) const
346 {
347 return referenceToKuhn(local, getPermutation<dimension>(kuhnIndex));
348 }
349
350 // common
351 template<int dimension, class CoordType>
352 template<int codimension>
353 class RefinementImp<dimension, CoordType>::Codim<codimension>::SubEntityIterator
354 : public ForwardIteratorFacade<typename RefinementImp<dimension, CoordType>::template Codim<codimension>::SubEntityIterator, int>,
355 public RefinementIteratorSpecial<dimension, CoordType, codimension>
356 {
357 public:
359 typedef SubEntityIterator This;
360
361 SubEntityIterator(int level, bool end = false);
362
363 bool equals(const This &other) const;
364 protected:
365 using RefinementIteratorSpecial<dimension, CoordType, codimension>::kuhnIndex;
366 using RefinementIteratorSpecial<dimension, CoordType, codimension>::backend;
367 };
368
369#ifndef DOXYGEN
370 template<int dimension, class CoordType>
371 template<int codimension>
373 SubEntityIterator(int level, bool end)
374 : RefinementIteratorSpecial<dimension, CoordType, codimension>(level, end)
375 {}
376
377 template<int dimension, class CoordType>
378 template<int codimension>
379 bool
381 equals(const This &other) const
382 { return kuhnIndex == other.kuhnIndex && backend == other.backend; }
383
384#endif // DOXYGEN
385
386 } // namespace HCubeTriangulation
387 } // namespace RefinementImp
388
389 namespace RefinementImp
390 {
391 // ///////////////////////
392 //
393 // The refinement traits
394 //
395
396#ifndef DOXYGEN
397 template<unsigned topologyId, class CoordType, unsigned coerceToId,
398 int dim>
399 struct Traits<
400 topologyId, CoordType, coerceToId, dim,
401 typename std::enable_if<
402 (dim >= 2 &&
403 (GenericGeometry::CubeTopology<dim>::type::id >> 1) ==
404 (topologyId >> 1) &&
405 (GenericGeometry::SimplexTopology<dim>::type::id >> 1) ==
406 (coerceToId >> 1)
407 )>::type
408 >
409 {
410 typedef HCubeTriangulation::RefinementImp<dim, CoordType> Imp;
411 };
412#endif
413
414 } // namespace RefinementImp
415} // namespace Dune
416
417#endif // DUNE_GEOMETRY_REFINEMENT_HCUBETRIANGULATION_CC
This file contains the parts independent of a particular Refinement implementation.
This file contains the Refinement implementation for simplices (triangles, tetrahedrons....
Definition affinegeometry.hh:19
FieldVector< int, n > getPermutation(int m)
Calculate permutation from it's index.
Definition simplex.cc:325
FieldVector< CoordType, dimension > referenceToKuhn(FieldVector< CoordType, dimension > point, const FieldVector< int, dimension > &kuhn)
Map from the reference simplex to some Kuhn simplex.
Definition simplex.cc:383
Static tag representing a codimension.
Definition dimension.hh:22
generic geometry implementation based on corner coordinates
Definition multilineargeometry.hh:191
static VertexIterator vEnd(int level)
Definition hcubetriangulation.cc:120
static ElementIterator eBegin(int level)
Definition hcubetriangulation.cc:136
static ElementIterator eEnd(int level)
Definition hcubetriangulation.cc:144
FieldVector< CoordType, dimension > CoordVector
Definition hcubetriangulation.cc:75
CoordType ctype
Definition hcubetriangulation.cc:70
static int nElements(int level)
Definition hcubetriangulation.cc:128
Codim< 0 >::SubEntityIterator ElementIterator
Definition hcubetriangulation.cc:76
FieldVector< int, dimension+1 > IndexVector
Definition hcubetriangulation.cc:77
static int nVertices(int level)
Definition hcubetriangulation.cc:104
Codim< dimension >::SubEntityIterator VertexIterator
Definition hcubetriangulation.cc:74
static VertexIterator vBegin(int level)
Definition hcubetriangulation.cc:112
@ dimension
Definition hcubetriangulation.cc:68
Dune::MultiLinearGeometry< CoordType, dimension-codimension, dimension > Geometry
Definition hcubetriangulation.cc:98
Refinement::template Codim< dimension >::Geometry Geometry
Definition hcubetriangulation.cc:161
BackendRefinement::template Codim< dimension >::SubEntityIterator BackendIterator
Definition hcubetriangulation.cc:174
Refinement::BackendRefinement BackendRefinement
Definition hcubetriangulation.cc:173
RefinementImp< dimension, CoordType > Refinement
Definition hcubetriangulation.cc:159
BackendRefinement::template Codim< 0 >::SubEntityIterator BackendIterator
Definition hcubetriangulation.cc:259
Refinement::CoordVector CoordVector
Definition hcubetriangulation.cc:240
Refinement::BackendRefinement BackendRefinement
Definition hcubetriangulation.cc:258
Refinement::IndexVector IndexVector
Definition hcubetriangulation.cc:239
RefinementImp< dimension, CoordType > Refinement
Definition hcubetriangulation.cc:238
Refinement::template Codim< 0 >::Geometry Geometry
Definition hcubetriangulation.cc:241
RefinementImp< dimension, CoordType > Refinement
Definition hcubetriangulation.cc:358
SubEntityIterator This
Definition hcubetriangulation.cc:359
Unique label for each type of entities that can occur in DUNE grids.
Definition type.hh:25