dune-geometry 3.0-git
virtualrefinement.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
4#ifndef DUNE_GEOMETRY_VIRTUALREFINEMENT_CC
5#define DUNE_GEOMETRY_VIRTUALREFINEMENT_CC
6
12#include <cassert>
13#include <typeinfo>
14
15#include <dune/common/exceptions.hh>
16#include <dune/common/fvector.hh>
17#include <dune/common/iteratorfacades.hh>
18
19#include "type.hh"
20#include "refinement.hh"
21
22namespace Dune
23{
24 // //////////////////////////////////////////
25 //
26 // The virtual base class and its iterators
27 //
28
29 //
30 // Refinement
31 //
32
33 template<int dimension, class CoordType>
36 vBegin(int level) const
37 {
38 return VertexIterator(vBeginBack(level));
39 }
40
41 template<int dimension, class CoordType>
44 vEnd(int level) const
45 {
46 return VertexIterator(vEndBack(level));
47 }
48
49 template<int dimension, class CoordType>
52 eBegin(int level) const
53 {
54 return ElementIterator(eBeginBack(level));
55 }
56
57 template<int dimension, class CoordType>
60 eEnd(int level) const
61 {
62 return ElementIterator(eEndBack(level));
63 }
64
65 //
66 // The iterators
67 //
68
69 template<int dimension, class CoordType, int codimension>
71
72 // The iterator for vertices
73 template<int dimension, class CoordType>
74 class VirtualRefinementSubEntityIteratorSpecial<dimension, CoordType, dimension>
75 {};
76
77 // The iterator for elements
78 template<int dimension, class CoordType>
79 class VirtualRefinementSubEntityIteratorSpecial<dimension, CoordType, 0>
80 {
81 public:
83 typedef typename Refinement::template Codim<0>::SubEntityIterator Common;
84 typedef typename Refinement::IndexVector IndexVector;
85
86 IndexVector vertexIndices() const;
87 };
88
89 template<int dimension, class CoordType>
92 vertexIndices() const
93 {
94 return static_cast<const Common *>(this)->backend->vertexIndices();
95 }
96
97 // The iterator common stuff
98 template<int dimension, class CoordType>
99 template<int codimension>
100 class VirtualRefinement<dimension, CoordType>::Codim<codimension>::SubEntityIterator
101 : public ForwardIteratorFacade<typename VirtualRefinement<dimension, CoordType>::template Codim<codimension>::SubEntityIterator, int>,
102 public VirtualRefinementSubEntityIteratorSpecial<dimension, CoordType, codimension>
103 {
104 public:
106 typedef typename Refinement::template Codim<codimension>::SubEntityIterator This;
107 typedef typename Refinement::template SubEntityIteratorBack<codimension> IteratorBack;
108 typedef typename Refinement::CoordVector CoordVector;
109
111 SubEntityIterator(const This &other);
113
114 This &operator=(const This &other);
115
116 bool equals(const This &other) const;
117 void increment();
118
119 int index() const;
120
121 // If you simply use an unqualified CoordVector here g++-4.2 chokes
123 CoordVector coords() const;
124 private:
125 friend class VirtualRefinementSubEntityIteratorSpecial<dimension, CoordType, codimension>;
126 IteratorBack *backend;
127 };
128
129#ifndef DOXYGEN
130 template<int dimension, class CoordType>
131 template<int codimension>
133 SubEntityIterator(IteratorBack *backend_)
134 : backend(backend_)
135 {}
136
137 template<int dimension, class CoordType>
138 template<int codimension>
140 SubEntityIterator(const This &other)
141 : backend(other.backend->clone())
142 {}
143
144 template<int dimension, class CoordType>
145 template<int codimension>
146 VirtualRefinement<dimension, CoordType>::Codim<codimension>::SubEntityIterator::
147 ~SubEntityIterator()
148 {
149 delete backend;
150 }
151
152 template<int dimension, class CoordType>
153 template<int codimension>
154 typename VirtualRefinement<dimension, CoordType>::template Codim<codimension>::SubEntityIterator &
155 VirtualRefinement<dimension, CoordType>::Codim<codimension>::SubEntityIterator::
156 operator=(const This &other)
157 {
158 delete backend;
159 backend = other.backend->clone();
160 }
161
162 template<int dimension, class CoordType>
163 template<int codimension>
164 bool
165 VirtualRefinement<dimension, CoordType>::Codim<codimension>::SubEntityIterator::
166 equals(const This &other) const
167 { return *backend == *(other.backend); }
168
169 template<int dimension, class CoordType>
170 template<int codimension>
171 void
172 VirtualRefinement<dimension, CoordType>::Codim<codimension>::SubEntityIterator::
173 increment()
174 {
175 ++*backend;
176 }
177
178 template<int dimension, class CoordType>
179 template<int codimension>
180 int
181 VirtualRefinement<dimension, CoordType>::Codim<codimension>::SubEntityIterator::
182 index() const
183 { return backend->index(); }
184
185 template<int dimension, class CoordType>
186 template<int codimension>
187 typename VirtualRefinement<dimension, CoordType>::template Codim<codimension>::SubEntityIterator::CoordVector
188 VirtualRefinement<dimension, CoordType>::Codim<codimension>::SubEntityIterator::
189 coords() const
190 { return backend->coords(); }
191#endif // DOXYGEN
192
193 //
194 // The iterator backend
195 //
196
197 template<int dimension, class CoordType, int codimension>
199
200 // The iterator backend for vertices
201 template<int dimension, class CoordType>
202 class VirtualRefinementSubEntityIteratorBackSpecial<dimension, CoordType, dimension>
203 {
204 public:
205
208 };
209
210 // The iterator backend for elements
211 template<int dimension, class CoordType>
213 {
214 public:
216 typedef typename Refinement::IndexVector IndexVector;
217
218 virtual IndexVector vertexIndices() const = 0;
219
222 };
223
224 // The iterator backend common stuff
225 template<int dimension, class CoordType>
226 template<int codimension>
227 class VirtualRefinement<dimension, CoordType>::SubEntityIteratorBack
228 : public VirtualRefinementSubEntityIteratorBackSpecial<dimension, CoordType, codimension>
229 {
230 public:
232 typedef typename Refinement::template SubEntityIteratorBack<codimension> This;
233 typedef typename Refinement::CoordVector CoordVector;
234
236
237 virtual This *clone() const = 0;
238
239 virtual bool operator==(const This &other) const = 0;
240 virtual This &operator++() = 0;
241
242 virtual int index() const = 0;
243 virtual CoordVector coords() const = 0;
244 };
245
246 // /////////////////////////////////////////////////
247 //
248 // The derived classes and their iterator backends
249 //
250
251 //
252 // The refinement implementation
253 //
254
255 template<unsigned topologyId, class CoordType,
256 unsigned coerceToId, int dimension>
258 : public Dune::VirtualRefinement<dimension, CoordType>
259 {
260 public:
263
264 template<int codimension>
266
267 int nVertices(int level) const;
268 int nElements(int level) const;
269
271 private:
274
275 typename VirtualRefinement::VertexIteratorBack *vBeginBack(int level) const;
276 typename VirtualRefinement::VertexIteratorBack *vEndBack(int level) const;
277 typename VirtualRefinement::ElementIteratorBack *eBeginBack(int level) const;
278 typename VirtualRefinement::ElementIteratorBack *eEndBack(int level) const;
279 };
280
281 template<unsigned topologyId, class CoordType,
282 unsigned coerceToId, int dimension>
283 VirtualRefinementImp<topologyId, CoordType, coerceToId, dimension> &
290
291 template<unsigned topologyId, class CoordType,
292 unsigned coerceToId, int dimension>
295
296 template<unsigned topologyId, class CoordType,
297 unsigned coerceToId, int dimension>
303
304 template<unsigned topologyId, class CoordType,
305 unsigned coerceToId, int dimension>
308 vBeginBack(int level) const
309 { return new SubEntityIteratorBack<dimension>(StaticRefinement::vBegin(level)); }
310
311 template<unsigned topologyId, class CoordType,
312 unsigned coerceToId, int dimension>
314 VirtualRefinementImp<topologyId, CoordType, coerceToId, dimension>::
315 vEndBack(int level) const
316 { return new SubEntityIteratorBack<dimension>(StaticRefinement::vEnd(level)); }
317
318 template<unsigned topologyId, class CoordType,
319 unsigned coerceToId, int dimension>
324
325 template<unsigned topologyId, class CoordType,
326 unsigned coerceToId, int dimension>
329 eBeginBack(int level) const
330 { return new SubEntityIteratorBack<0>(StaticRefinement::eBegin(level)); }
331
332 template<unsigned topologyId, class CoordType,
333 unsigned coerceToId, int dimension>
335 VirtualRefinementImp<topologyId, CoordType, coerceToId, dimension>::
336 eEndBack(int level) const
337 { return new SubEntityIteratorBack<0>(StaticRefinement::eEnd(level)); }
338
339 //
340 // The iterator backend implementation
341 //
342
343 // The iterator backend implementation specialties
344 template<unsigned topologyId, class CoordType,
345 unsigned coerceToId, int dimension, int codimension>
347
348 // The iterator backend implementation specialties for vertices
349 template<unsigned topologyId, class CoordType,
350 unsigned coerceToId, int dimension>
351 class VirtualRefinementImpSubEntityIteratorBackSpecial<topologyId, CoordType, coerceToId, dimension, dimension>
352 : public VirtualRefinement<dimension, CoordType>::template SubEntityIteratorBack<dimension>
353 {};
354
355 // The iterator backend implementation specialties for elements
356
357 template<unsigned topologyId, class CoordType,
358 unsigned coerceToId, int dimension>
359 class VirtualRefinementImpSubEntityIteratorBackSpecial<topologyId, CoordType, coerceToId, dimension, 0>
360 : public VirtualRefinement<dimension, CoordType>::template SubEntityIteratorBack<0>
361 {
362 public:
364 typedef typename VirtualRefinementImp::template SubEntityIteratorBack<0> Common;
367 typedef typename RefinementBase::IndexVector IndexVector;
368
369 IndexVector vertexIndices() const;
370 };
371
372 template<unsigned topologyId, class CoordType,
373 unsigned coerceToId, int dimension>
376 vertexIndices() const
377 {
378 IndexVector vIndices;
379 vIndices.reserve(StaticRefinement::IndexVector::dimension);
380
381 typename StaticRefinement::IndexVector sIndices = static_cast<const Common *>(this)->backend.vertexIndices();
382 for(int i = 0; i < StaticRefinement::IndexVector::dimension; ++i)
383 vIndices.push_back(sIndices[i]);
384 return vIndices;
385 }
386
387 // The shared iterator backend implementation
388 template<unsigned topologyId, class CoordType,
389 unsigned coerceToId, int dimension>
390 template<int codimension>
391 class VirtualRefinementImp<topologyId, CoordType, coerceToId, dimension>::SubEntityIteratorBack
392 : public VirtualRefinementImpSubEntityIteratorBackSpecial<topologyId, CoordType, coerceToId, dimension, codimension>
393 {
394 public:
395 typedef typename StaticRefinement::template Codim<codimension>::SubEntityIterator BackendIterator;
397 typedef typename VirtualRefinement::template SubEntityIteratorBack<codimension> Base;
399
401 SubEntityIteratorBack(const This &other);
402
403 Base *clone() const;
404
405 bool operator==(const Base &other) const;
406 Base &operator++();
407
408 int index() const;
409 CoordVector coords() const;
410
411 private:
412 friend class VirtualRefinementImpSubEntityIteratorBackSpecial<topologyId, CoordType, coerceToId, dimension, codimension>;
413 BackendIterator backend;
414 };
415
416 template<unsigned topologyId, class CoordType,
417 unsigned coerceToId, int dimension>
418 template<int codimension>
423
424 template<unsigned topologyId, class CoordType,
425 unsigned coerceToId, int dimension>
426 template<int codimension>
428 SubEntityIteratorBack(const This &other)
429 : VirtualRefinementImpSubEntityIteratorBackSpecial<topologyId, CoordType, coerceToId, dimension, codimension>(other),
430 backend(other.backend)
431 {}
432
433 template<unsigned topologyId, class CoordType, unsigned coerceToId, int dimension>
434 template<int codimension>
439
440 template<unsigned topologyId, class CoordType, unsigned coerceToId, int dimension>
441 template<int codimension>
442 bool
444 operator==(const Base &other) const
445 {
446 try {
447 return backend == dynamic_cast<const This &>(other).backend;
448 }
449 catch(std::bad_cast)
450 {
451 return false;
452 }
453 }
454
455 template<unsigned topologyId, class CoordType, unsigned coerceToId, int dimension>
456 template<int codimension>
464
465 template<unsigned topologyId, class CoordType, unsigned coerceToId, int dimension>
466 template<int codimension>
467 int
471
472 template<unsigned topologyId, class CoordType, unsigned coerceToId, int dimension>
473 template<int codimension>
478
479 // ////////////////////////
480 //
481 // The refinement builder
482 //
483
484 template<int dimension, class CoordType>
485 class RefinementBuilder;
486
497 template<int dimension, class CoordType>
500 GeometryType geometryType,
502 GeometryType coerceTo)
503 {
504 // Check that the user used valid geometry types
505 assert(geometryType.dim() == dimension && coerceTo.dim() == dimension);
506 return RefinementBuilder<dimension, CoordType>::build( geometryType.id(), coerceTo.id() );
507 }
508
509 // In principle the trick with the class is no longer necessary,
510 // but I'm keeping it in here so it will be easier to specialize
511 // buildRefinement when someone implements pyramids and prisms
512 template<int dimension, class CoordType>
514 {
515 public:
516 static
518 build(unsigned topologyId, unsigned coerceToId)
519 {
520 topologyId &= ~1;
521 coerceToId &= ~1;
522
523 const unsigned idSimplex = GenericGeometry::SimplexTopology<dimension>::type::id & ~1;
524 const unsigned idCube = GenericGeometry::CubeTopology<dimension>::type::id & ~1;
525
526 switch( topologyId )
527 {
528 //case GeometryType::simplex:
529 case idSimplex :
530 //switch( coerceTo )
531 switch( coerceToId )
532 {
533 //case GeometryType::simplex:
534 case idSimplex :
536 default :
537 break;
538 }
539 break;
540
541 //case GeometryType::cube:
542 case idCube :
543 switch( coerceToId )
544 {
545 case idSimplex :
547 case idCube :
549 default :
550 break;
551 }
552 break;
553
554 default :
555 break;
556 }
557 DUNE_THROW( NotImplemented, "No Refinement<" << topologyId << ", CoordType, "
558 << coerceToId << " >.");
559 }
560 };
561
562 template<class CoordType>
563 class RefinementBuilder<1, CoordType>
564 {
565 static const std::size_t dimension = 1;
566 public:
567 static
569 build(unsigned topologyId, unsigned coerceToId)
570 {
571 topologyId &= ~1;
572 coerceToId &= ~1;
573
574 const unsigned idSimplex = GenericGeometry::SimplexTopology<dimension>::type::id & ~1;
575
576 if (topologyId == 0 && coerceToId == 0)
578
579 DUNE_THROW( NotImplemented, "No Refinement<" << topologyId << ", CoordType, "
580 << coerceToId << " >.");
581 }
582 };
583
584 template<class CoordType>
585 class RefinementBuilder<3, CoordType>
586 {
587 static const std::size_t dimension = 3;
588 public:
589 static
591 build(unsigned topologyId, unsigned coerceToId)
592 {
593 topologyId &= ~1;
594 coerceToId &= ~1;
595
596 const unsigned idSimplex = GenericGeometry::SimplexTopology<dimension>::type::id & ~1;
597 const unsigned idCube = GenericGeometry::CubeTopology<dimension>::type::id & ~1;
598 const unsigned idPrism = GenericGeometry::PrismTopology<dimension>::type::id & ~1;
599 const unsigned idPyramid = GenericGeometry::PyramidTopology<dimension>::type::id & ~1;
600
601 switch( topologyId )
602 {
603 //case GeometryType::simplex:
604 case idSimplex :
605 //switch( coerceTo )
606 switch( coerceToId )
607 {
608 //case GeometryType::simplex:
609 case idSimplex :
611 default :
612 break;
613 }
614 break;
615
616 //case GeometryType::cube:
617 case idCube :
618 switch( coerceToId )
619 {
620 case idSimplex :
622 case idCube :
624 default :
625 break;
626 }
627 break;
628
629 //case GeometryType::prism:
630 case idPrism :
631 switch( coerceToId )
632 {
633 case idSimplex :
635 default :
636 break;
637 }
638 break;
639
640 //case GeometryType::pyramid:
641 case idPyramid :
642 switch( coerceToId )
643 {
644 case idSimplex :
646 default :
647 break;
648 }
649 break;
650
651 default :
652 break;
653 }
654 DUNE_THROW( NotImplemented, "No Refinement<" << topologyId << ", CoordType, "
655 << coerceToId << " >.");
656 }
657 };
658
659} // namespace Dune
660
661#endif // DUNE_GEOMETRY_VIRTUALREFINEMENT_CC
This file simply includes all Refinement implementations so you don't have to do them separately.
A unique label for each type of element that can occur in a grid.
Definition affinegeometry.hh:19
VirtualRefinement< dimension, CoordType > & buildRefinement(GeometryType geometryType, GeometryType coerceTo)
return a reference to the VirtualRefinement according to the parameters
Definition virtualrefinement.cc:499
Static tag representing a codimension.
Definition dimension.hh:22
Definition topologytypes.hh:215
Definition topologytypes.hh:232
Definition topologytypes.hh:249
Definition topologytypes.hh:260
Wrap each Refinement implementation to get a consistent interface.
Definition base.cc:104
static VertexIterator vEnd(int level)
Get a VertexIterator.
static ElementIterator eEnd(int level)
Get an ElementIterator.
static ElementIterator eBegin(int level)
Get an ElementIterator.
static VertexIterator vBegin(int level)
Get a VertexIterator.
static int nVertices(int level)
Get the number of Vertices.
typedef IndexVector
The IndexVector of the Refinement.
Definition base.cc:140
static int nElements(int level)
Get the number of Elements.
Unique label for each type of entities that can occur in DUNE grids.
Definition type.hh:25
unsigned int dim() const
Return dimension of the type.
Definition type.hh:321
unsigned int id() const
Return the topology id the type.
Definition type.hh:326
Definition virtualrefinement.cc:70
Refinement::template Codim< 0 >::SubEntityIterator Common
Definition virtualrefinement.cc:83
VirtualRefinement< dimension, CoordType > Refinement
Definition virtualrefinement.cc:82
Refinement::IndexVector IndexVector
Definition virtualrefinement.cc:84
VirtualRefinement< dimension, CoordType >::template Codim< codimension >::SubEntityIterator::CoordVector coords() const
Refinement::template SubEntityIteratorBack< codimension > IteratorBack
Definition virtualrefinement.cc:107
Refinement::CoordVector CoordVector
Definition virtualrefinement.cc:108
Refinement::template Codim< codimension >::SubEntityIterator This
Definition virtualrefinement.cc:106
bool equals(const This &other) const
VirtualRefinement< dimension, CoordType > Refinement
Definition virtualrefinement.cc:105
Definition virtualrefinement.cc:198
virtual ~VirtualRefinementSubEntityIteratorBackSpecial()
Definition virtualrefinement.cc:206
VirtualRefinement< dimension, CoordType > Refinement
Definition virtualrefinement.cc:215
Refinement::IndexVector IndexVector
Definition virtualrefinement.cc:216
virtual ~VirtualRefinementSubEntityIteratorBackSpecial()
Definition virtualrefinement.cc:220
Definition virtualrefinement.cc:229
Refinement::template SubEntityIteratorBack< codimension > This
Definition virtualrefinement.cc:232
Refinement::CoordVector CoordVector
Definition virtualrefinement.cc:233
VirtualRefinement< dimension, CoordType > Refinement
Definition virtualrefinement.cc:231
virtual bool operator==(const This &other) const =0
virtual CoordVector coords() const =0
virtual ~SubEntityIteratorBack()
Definition virtualrefinement.cc:235
Definition virtualrefinement.cc:259
Dune::VirtualRefinement< dimension, CoordType > VirtualRefinement
Definition virtualrefinement.cc:262
static VirtualRefinementImp< topologyId, CoordType, coerceToId, dimension > & instance()
Definition virtualrefinement.cc:284
int nVertices(int level) const
Get the number of Vertices.
Definition virtualrefinement.cc:299
Dune::StaticRefinement< topologyId, CoordType, coerceToId, dimension > StaticRefinement
Definition virtualrefinement.cc:261
int nElements(int level) const
Get the number of Elements.
Definition virtualrefinement.cc:320
Definition virtualrefinement.cc:393
VirtualRefinement::template SubEntityIteratorBack< codimension > Base
Definition virtualrefinement.cc:397
VirtualRefinementImp< topologyId, CoordType, coerceToId, dimension >::template SubEntityIteratorBack< codimension > This
Definition virtualrefinement.cc:396
StaticRefinement::template Codim< codimension >::SubEntityIterator BackendIterator
Definition virtualrefinement.cc:395
VirtualRefinement::CoordVector CoordVector
Definition virtualrefinement.cc:398
VirtualRefinementImp::template SubEntityIteratorBack< 0 > Common
Definition virtualrefinement.cc:364
VirtualRefinement< dimension, CoordType > RefinementBase
Definition virtualrefinement.cc:366
Dune::VirtualRefinementImp< topologyId, CoordType, coerceToId, dimension > VirtualRefinementImp
Definition virtualrefinement.cc:363
VirtualRefinementImp::StaticRefinement StaticRefinement
Definition virtualrefinement.cc:365
Definition virtualrefinement.cc:514
static VirtualRefinement< dimension, CoordType > & build(unsigned topologyId, unsigned coerceToId)
Definition virtualrefinement.cc:518
static VirtualRefinement< dimension, CoordType > & build(unsigned topologyId, unsigned coerceToId)
Definition virtualrefinement.cc:569
static VirtualRefinement< dimension, CoordType > & build(unsigned topologyId, unsigned coerceToId)
Definition virtualrefinement.cc:591
VirtualRefinement base class.
Definition virtualrefinement.hh:292
SubEntityIteratorBack< dimension > VertexIteratorBack
Definition virtualrefinement.hh:316
VertexIterator vEnd(int level) const
Get a VertexIterator.
Definition virtualrefinement.cc:44
ElementIterator eBegin(int level) const
Get an ElementIterator.
Definition virtualrefinement.cc:52
Codim< 0 >::SubEntityIterator ElementIterator
The ElementIterator of the VirtualRefinement.
Definition virtualrefinement.hh:299
ElementIterator eEnd(int level) const
Get an ElementIterator.
Definition virtualrefinement.cc:60
FieldVector< CoordType, dimension > CoordVector
The CoordVector of the VirtualRefinement.
Definition virtualrefinement.hh:306
VertexIterator vBegin(int level) const
Get a VertexIterator.
Definition virtualrefinement.cc:36
Codim< dimension >::SubEntityIterator VertexIterator
The VertexIterator of the VirtualRefinement.
Definition virtualrefinement.hh:297
SubEntityIteratorBack< 0 > ElementIteratorBack
Definition virtualrefinement.hh:317
codim database of VirtualRefinement
Definition virtualrefinement.hh:348