Line data Source code
1 : /*
2 : * Copyright (c) 2010-2021: G-CSC, Goethe University Frankfurt
3 : * Authors: Andreas Vogel, Martin Stepniewski
4 : *
5 : * This file is part of UG4.
6 : *
7 : * UG4 is free software: you can redistribute it and/or modify it under the
8 : * terms of the GNU Lesser General Public License version 3 (as published by the
9 : * Free Software Foundation) with the following additional attribution
10 : * requirements (according to LGPL/GPL v3 §7):
11 : *
12 : * (1) The following notice must be displayed in the Appropriate Legal Notices
13 : * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
14 : *
15 : * (2) The following notice must be displayed at a prominent place in the
16 : * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
17 : *
18 : * (3) The following bibliography is recommended for citation and must be
19 : * preserved in all covered files:
20 : * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
21 : * parallel geometric multigrid solver on hierarchically distributed grids.
22 : * Computing and visualization in science 16, 4 (2013), 151-164"
23 : * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
24 : * flexible software system for simulating pde based models on high performance
25 : * computers. Computing and visualization in science 16, 4 (2013), 165-179"
26 : *
27 : * This program is distributed in the hope that it will be useful,
28 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 : * GNU Lesser General Public License for more details.
31 : */
32 :
33 : #ifndef __H__UG__LIB_DISC__REFERENCE_ELEMENT__REFERENCE_ELEMENT__
34 : #define __H__UG__LIB_DISC__REFERENCE_ELEMENT__REFERENCE_ELEMENT__
35 :
36 : #include <cassert>
37 : #include <iostream>
38 : #include <sstream>
39 : #include "common/common.h"
40 : #include "common/math/ugmath.h"
41 : #include "lib_grid/grid/grid_base_objects.h"
42 :
43 : namespace ug{
44 :
45 : ///////////////////////////////////////////////////////////////////////////////
46 : // Reference Element Common Base Class
47 : ///////////////////////////////////////////////////////////////////////////////
48 :
49 : /// base class for reference elements
50 : /**
51 : * Reference element interface. A reference element describes in local
52 : * coordinates the structure an element type. Physical elements of a grid are
53 : * thought to be constructed by a mapping from a reference element into the
54 : * real world space.
55 : *
56 : * Each ReferenceElement may be constructed from other (lower dimensional)
57 : * geometric objects, that are themselves a mapping from a (lower dimensional)
58 : * reference element. (E.g. a triangle is constructed by three edges and
59 : * three vertices) Thus, these relationships are also specified by the reference
60 : * element and methods of this function provide the number of constructing
61 : * sub-geometric objects and the relationship between those.
62 : *
63 : * Note, that we use one base class in order to implement all reference elements
64 : * providing enough space to store all data for each derivation. This enlarges
65 : * the memory consumption slightly but allows fast and inlined code. Since
66 : * usually only one reference element (singleton) per program is created memory
67 : * consumption is not an issue.
68 : */
69 : class ReferenceElement
70 : {
71 : public:
72 : /// Constructor filling the arrays
73 : ReferenceElement();
74 :
75 : /// returns the reference object id
76 : ReferenceObjectID roid() const
77 29 : {return m_vRefElemType[m_dim][0];}
78 :
79 : /// returns the dimension where reference element lives
80 57 : int dimension() const {return m_dim;}
81 :
82 : /// returns the size (e.g. area or volume) of the reference element
83 0 : number size() const {return m_size;}
84 :
85 : /// returns the number of geometric objects of dim
86 : /**
87 : * A reference element is constructed by several geometric objects, that
88 : * are mapped by a reference element by themselves. This method returns how
89 : * many (sub-)geometric objects of a given dimension are contained in this
90 : * reference element.
91 : *
92 : * \param[in] dim dimension
93 : * \returns number of objects of the dimension contained in the ref elem
94 : */
95 618 : size_t num(int dim) const {return m_vNum[dim];}
96 :
97 : /// returns the number of object of dim for a sub-geometric object
98 : /**
99 : * A reference element is constructed by several geometric objects, that
100 : * are mapped by a reference element by themselves. This method returns how
101 : * many (sub-)geometric objects of a given dimension are contained in a
102 : * (sub-)geometric object of this reference element.
103 : *
104 : * \param[in] dim_i dimension of sub geometric object
105 : * \param[in] i number of sub geometric object
106 : * \param[in] dim_j dimension for elems contained in the sub-object
107 : * \returns number of objects of the dimension dim_j that are
108 : * contained in the i*th (sub-)geom object of dimension dim_i
109 : */
110 : size_t num(int dim_i, size_t i, int dim_j) const
111 158 : {return m_vSubNum[dim_i][i][dim_j];}
112 :
113 : /// id of object j in dimension dim_j of obj i in dimension dim_i
114 : /**
115 : * A reference element is constructed by several geometric objects, that
116 : * are mapped by a reference element by themselves. This method returns the
117 : * id (w.r.t. this reference element) of a sub-geometric object that is
118 : * part of a sub-geometric object of the reference element
119 : *
120 : * \param[in] dim_i dimension of sub geometric object
121 : * \param[in] i id of sub geometric object
122 : * \param[in] dim_j dimension for obj contained in the sub-object
123 : * \param[in] j number of obj contained in the sub-object
124 : * \returns id of the j'th object of the dimension dim_j that are
125 : * contained in the i*th (sub-)geom object of dimension dim_i
126 : */
127 : int id(int dim_i, size_t i, int dim_j, size_t j) const
128 169 : {return m_id[dim_i][i][dim_j][j];}
129 :
130 : /// number of reference elements this element contains
131 : size_t num(ReferenceObjectID type) const
132 0 : {return m_vNumRefElem[type];}
133 :
134 : /// reference element type of obj nr i in dimension dim_i
135 : ReferenceObjectID roid(int dim_i, size_t i) const
136 10 : {return m_vRefElemType[dim_i][i];}
137 :
138 : /// print informations about the reference element
139 : void print_info() const;
140 :
141 : protected:
142 : /// to make it more readable
143 : enum{POINT = 0, EDGE = 1, FACE = 2, VOLUME= 3};
144 :
145 : /// maximum number of Objects in all dimensions
146 : enum{MAXOBJECTS = 12};
147 :
148 : /// maximum dimension
149 : enum{MAXDIM = 3};
150 :
151 : /// dimension of the reference world
152 : int m_dim;
153 :
154 : /// size of reference element
155 : number m_size;
156 :
157 : /// number of Geometric Objects of a dimension
158 : size_t m_vNum[MAXDIM+1];
159 :
160 : /// number of Geometric Objects contained in a (Sub-)Geometric Object of the Element
161 : size_t m_vSubNum[MAXDIM+1][MAXOBJECTS][MAXDIM+1];
162 :
163 : /// indices of GeomObjects
164 : int m_id[MAXDIM+1][MAXOBJECTS][MAXDIM+1][MAXOBJECTS];
165 :
166 : /// number of reference elements
167 : size_t m_vNumRefElem[NUM_REFERENCE_OBJECTS];
168 :
169 : /// type of reference elements
170 : ReferenceObjectID m_vRefElemType[MAXDIM+1][MAXOBJECTS];
171 : };
172 :
173 : /// dimension dependent base class for reference elements
174 : /**
175 : * This is the base class for reference elements with their dimension. It
176 : * simply adds to the ReferenceElement base class the corner position of the
177 : * reference element vertices in local coordinates.
178 : *
179 : * \tparam d dimension, where reference element lives
180 : */
181 : template <int d>
182 0 : class DimReferenceElement : public ReferenceElement
183 : {
184 : public:
185 : /// dimension, where the reference element is defined
186 : static const int dim = d;
187 :
188 : /// coordinates of reference corner in a vector
189 0 : const MathVector<dim>* corners() const {return &m_vCorner[0];}
190 :
191 : /// coordinates of reference corner (i = 0 ... num(0))
192 0 : const MathVector<dim>& corner(size_t i) const {return m_vCorner[i];}
193 :
194 : /// coordinates of reference corner as integer
195 54 : const MathVector<dim,int>* corner() const {return m_vCoInt;}
196 :
197 : /// print informations about the reference element
198 : void print_info() const;
199 :
200 : protected:
201 : /// maximum number of corners for fixed reference elements
202 : enum{MAXCORNERS = 8};
203 :
204 : /// coordinates of Reference Corner
205 : MathVector<dim> m_vCorner[MAXCORNERS];
206 : MathVector<dim, int> m_vCoInt[MAXCORNERS];
207 : };
208 :
209 : ///////////////////////////////////////////////////////////////////////////////
210 : // Reference Element Providers
211 : ///////////////////////////////////////////////////////////////////////////////
212 :
213 : /// Exception thrown when reference element not found
214 : struct UGError_ReferenceElementMissing : public UGError
215 : {
216 : UGError_ReferenceElementMissing(int dim_, ReferenceObjectID roid_)
217 : : UGError(""), dim(dim_), roid(roid_)
218 : {
219 : std::stringstream ss; ss << "Reference Element not found for "
220 : <<roid<<" (dim="<<dim<<")";
221 : UGError::push_msg(ss.str());
222 : }
223 : int dim;
224 : ReferenceObjectID roid;
225 : };
226 :
227 : /// Provider for Reference Elements
228 : class ReferenceElementProvider
229 : {
230 : private:
231 : /// constructor
232 : ReferenceElementProvider();
233 :
234 : // intentionally left unimplemented
235 : ReferenceElementProvider(const ReferenceElementProvider&){};
236 : ReferenceElementProvider& operator=(const ReferenceElementProvider&);
237 :
238 : /// provide instance of singleton
239 0 : static ReferenceElementProvider& instance()
240 : {
241 0 : static ReferenceElementProvider inst;
242 0 : return inst;
243 : }
244 :
245 : /// adds a Reference Element
246 : static bool add_elem(const ReferenceElement& elem);
247 :
248 : /// returns a Reference Element
249 : static const ReferenceElement& get_elem(ReferenceObjectID roid);
250 :
251 : /// vector storing all ReferenceElement
252 : static const ReferenceElement* m_vElem[NUM_REFERENCE_OBJECTS];
253 :
254 : /// adds a Reference Element
255 : template <int dim>
256 : static bool add_dim_elem(const DimReferenceElement<dim>& elem);
257 :
258 : /// returns a Reference Element
259 : template <int dim>
260 0 : static const DimReferenceElement<dim>& get_dim_elem(ReferenceObjectID roid)
261 : {
262 : UG_ASSERT(roid >= 0, "roid ="<<roid<<" wrong")
263 : UG_ASSERT(roid < NUM_REFERENCE_OBJECTS, "roid ="<<roid<<" wrong")
264 0 : static const DimReferenceElement<dim>** vDimElem = get_vector<dim>();
265 : UG_ASSERT(vDimElem[roid] != NULL, "Null pointer for roid ="<<roid);
266 0 : return *vDimElem[roid];
267 : }
268 :
269 : /// returns vector of DimReferenceElement
270 : template <int dim>
271 : static const DimReferenceElement<dim>** get_vector()
272 : {
273 : static const DimReferenceElement<dim>* sVec[NUM_REFERENCE_OBJECTS];
274 : return sVec;
275 : }
276 :
277 : public:
278 : /// returns a dimension dependent Reference Element
279 : template <int dim>
280 : inline static const DimReferenceElement<dim>& get(ReferenceObjectID roid)
281 : {
282 0 : return instance().get_dim_elem<dim>(roid);
283 : }
284 :
285 : /// returns a Reference Element
286 : inline static const ReferenceElement& get(ReferenceObjectID roid)
287 : {
288 0 : return instance().get_elem(roid);
289 : }
290 : };
291 :
292 : ///////////////////////////////////////////////////////////////////////////////
293 : ///////////////////////////////////////////////////////////////////////////////
294 : // Concrete Reference Elements
295 : ///////////////////////////////////////////////////////////////////////////////
296 : ///////////////////////////////////////////////////////////////////////////////
297 :
298 : ///////////////////////////////////////////////////////////////////////////////
299 : // Reference RegularVertex
300 : ///////////////////////////////////////////////////////////////////////////////
301 :
302 : class ReferenceVertex : public DimReferenceElement<0>
303 : {
304 : public:
305 : /// type of reference element
306 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_VERTEX;
307 :
308 : /// dimension of reference element
309 : static const int dim = 0;
310 :
311 : /// number of corners
312 : static const int numCorners = 1;
313 :
314 : /// number of eges
315 : static const int numEdges = 0;
316 :
317 : /// number of faces
318 : static const int numFaces = 0;
319 :
320 : /// number of volumes
321 : static const int numVolumes = 0;
322 :
323 : /// number of sides
324 : static const int numSides = 0;
325 :
326 : public:
327 : /// Constructor filling the arrays
328 : ReferenceVertex();
329 :
330 : /// \copydoc ug::ReferenceElement::reference_object_id()
331 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
332 :
333 : /// \copydoc ug::ReferenceElement::dimension()
334 : int dimension() const {return dim;}
335 :
336 : /// \copydoc ug::ReferenceElement::size()
337 : number size() const {return 1.0;}
338 : };
339 :
340 : ///////////////////////////////////////////////////////////////////////////////
341 : // Reference Edge
342 : ///////////////////////////////////////////////////////////////////////////////
343 :
344 : class ReferenceEdge : public DimReferenceElement<1>
345 : {
346 : public:
347 : /// type of reference element
348 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_EDGE;
349 :
350 : /// dimension of reference element
351 : static const int dim = 1;
352 :
353 : /// number of corners
354 : static const int numCorners = 2;
355 :
356 : /// number of eges
357 : static const int numEdges = 1;
358 :
359 : /// number of faces
360 : static const int numFaces = 0;
361 :
362 : /// number of volumes
363 : static const int numVolumes = 0;
364 :
365 : /// number of sides
366 : static const int numSides = numCorners;
367 :
368 : public:
369 : /// Constructor
370 : ReferenceEdge();
371 :
372 : /// \copydoc ug::ReferenceElement::reference_object_id()
373 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
374 :
375 : /// \copydoc ug::ReferenceElement::dimension()
376 : int dimension() const {return dim;}
377 :
378 : /// \copydoc ug::ReferenceElement::size()
379 : number size() const {return 0.5;}
380 :
381 : /// \copydoc ug::DimReferenceElement::check_position()
382 : inline static void check_position(const MathVector<dim>& pos)
383 : {
384 : UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0,
385 : "Local position "<<pos<<" outside Reference Element");
386 : }
387 : };
388 :
389 : ///////////////////////////////////////////////////////////////////////////////
390 : // Reference Triangle
391 : ///////////////////////////////////////////////////////////////////////////////
392 :
393 : class ReferenceTriangle : public DimReferenceElement<2>
394 : {
395 : public:
396 : /// type of reference element
397 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_TRIANGLE;
398 :
399 : /// dimension of reference element
400 : static const int dim = 2;
401 :
402 : /// number of corners
403 : static const int numCorners = 3;
404 :
405 : /// number of eges
406 : static const int numEdges = 3;
407 :
408 : /// number of faces
409 : static const int numFaces = 1;
410 :
411 : /// number of volumes
412 : static const int numVolumes = 0;
413 :
414 : /// number of sides
415 : static const int numSides = numEdges;
416 :
417 : public:
418 : /// Constructor filling the arrays
419 : ReferenceTriangle();
420 :
421 : /// \copydoc ug::ReferenceElement::reference_object_id()
422 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
423 :
424 : /// \copydoc ug::ReferenceElement::dimension()
425 : int dimension() const {return dim;}
426 :
427 : /// \copydoc ug::ReferenceElement::size()
428 : number size() const {return 0.5;}
429 :
430 : /// \copydoc ug::DimReferenceElement::check_position()
431 : inline static void check_position(const MathVector<dim>& pos)
432 : {
433 : UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
434 : pos[1] >= 0.0 && pos[1] <= 1.0 &&
435 : pos[0]+pos[1] <= 1.0,
436 : "Local position "<<pos<<" outside Reference Element");
437 0 : }
438 : };
439 :
440 : ///////////////////////////////////////////////////////////////////////////////
441 : // Reference Quadrilateral
442 : ///////////////////////////////////////////////////////////////////////////////
443 :
444 : class ReferenceQuadrilateral : public DimReferenceElement<2>
445 : {
446 : public:
447 : /// type of reference element
448 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_QUADRILATERAL;
449 :
450 : /// dimension of reference element
451 : static const int dim = 2;
452 :
453 : /// number of corners
454 : static const int numCorners = 4;
455 :
456 : /// number of eges
457 : static const int numEdges = 4;
458 :
459 : /// number of faces
460 : static const int numFaces = 1;
461 :
462 : /// number of volumes
463 : static const int numVolumes = 0;
464 :
465 : /// number of sides
466 : static const int numSides = numEdges;
467 :
468 : public:
469 : ReferenceQuadrilateral();
470 :
471 : /// \copydoc ug::ReferenceElement::reference_object_id()
472 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
473 :
474 : /// \copydoc ug::ReferenceElement::dimension()
475 : int dimension() const {return dim;}
476 :
477 : /// \copydoc ug::ReferenceElement::size()
478 : number size() const {return 1.0;}
479 :
480 : /// \copydoc ug::DimReferenceElement::check_position()
481 : inline static void check_position(const MathVector<dim>& pos)
482 : {
483 : UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
484 : pos[1] >= 0.0 && pos[1] <= 1.0,
485 : "Local position "<<pos<<" outside Reference Element");
486 0 : }
487 : };
488 :
489 : ///////////////////////////////////////////////////////////////////////////////
490 : // Reference Tetrahedron
491 : ///////////////////////////////////////////////////////////////////////////////
492 :
493 : class ReferenceTetrahedron : public DimReferenceElement<3>
494 : {
495 : public:
496 : /// type of reference element
497 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_TETRAHEDRON;
498 :
499 : /// dimension of reference element
500 : static const int dim = 3;
501 :
502 : /// number of corners
503 : static const int numCorners = 4;
504 :
505 : /// number of eges
506 : static const int numEdges = 6;
507 :
508 : /// number of faces
509 : static const int numFaces = 4;
510 :
511 : /// number of volumes
512 : static const int numVolumes = 1;
513 :
514 : /// number of sides
515 : static const int numSides = numFaces;
516 :
517 : public:
518 : /// Constructor
519 : ReferenceTetrahedron();
520 :
521 : /// \copydoc ug::ReferenceElement::reference_object_id()
522 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
523 :
524 : /// \copydoc ug::ReferenceElement::dimension()
525 : int dimension() const {return dim;}
526 :
527 : /// \copydoc ug::ReferenceElement::size()
528 : number size() const {return 1.0/6.0;}
529 :
530 : /// \copydoc ug::DimReferenceElement::check_position()
531 : inline static void check_position(const MathVector<dim>& pos)
532 : {
533 : UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
534 : pos[1] >= 0.0 && pos[1] <= 1.0 &&
535 : pos[2] >= 0.0 && pos[2] <= 1.0 &&
536 : pos[0]+pos[1]+pos[2] <= 1.0,
537 : "Local position "<<pos<<" outside Reference Element");
538 0 : }
539 : };
540 :
541 : ///////////////////////////////////////////////////////////////////////////////
542 : // Reference Pyramid
543 : ///////////////////////////////////////////////////////////////////////////////
544 :
545 : class ReferencePyramid : public DimReferenceElement<3>
546 : {
547 : public:
548 : /// type of reference element
549 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_PYRAMID;
550 :
551 : /// dimension of reference element
552 : static const int dim = 3;
553 :
554 : /// number of corners
555 : static const int numCorners = 5;
556 :
557 : /// number of eges
558 : static const int numEdges = 8;
559 :
560 : /// number of faces
561 : static const int numFaces = 5;
562 :
563 : /// number of volumes
564 : static const int numVolumes = 1;
565 :
566 : /// number of sides
567 : static const int numSides = numFaces;
568 :
569 : public:
570 : /// Constructor
571 : ReferencePyramid();
572 :
573 : /// \copydoc ug::ReferenceElement::reference_object_id()
574 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
575 :
576 : /// \copydoc ug::ReferenceElement::dimension()
577 : int dimension() const {return dim;}
578 :
579 : /// \copydoc ug::ReferenceElement::size()
580 : number size() const {return 1.0/3.0;}
581 :
582 : /// \copydoc ug::DimReferenceElement::check_position()
583 : inline static void check_position(const MathVector<dim>& pos)
584 : {
585 : //\todo: add check
586 0 : }
587 : };
588 :
589 :
590 : ///////////////////////////////////////////////////////////////////////////////
591 : // Reference Prism
592 : ///////////////////////////////////////////////////////////////////////////////
593 :
594 : class ReferencePrism : public DimReferenceElement<3>
595 : {
596 : public:
597 : /// type of reference element
598 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_PRISM;
599 :
600 : /// dimension of reference element
601 : static const int dim = 3;
602 :
603 : /// number of corners
604 : static const int numCorners = 6;
605 :
606 : /// number of eges
607 : static const int numEdges = 9;
608 :
609 : /// number of faces
610 : static const int numFaces = 5;
611 :
612 : /// number of volumes
613 : static const int numVolumes = 1;
614 :
615 : /// number of sides
616 : static const int numSides = numFaces;
617 :
618 : public:
619 : /// Constructor
620 : ReferencePrism();
621 :
622 : /// \copydoc ug::ReferenceElement::reference_object_id()
623 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
624 :
625 : /// \copydoc ug::ReferenceElement::dimension()
626 : int dimension() const {return dim;}
627 :
628 : /// \copydoc ug::ReferenceElement::size()
629 : number size() const {return 0.5;}
630 :
631 : /// \copydoc ug::DimReferenceElement::check_position()
632 : inline static void check_position(const MathVector<dim>& pos)
633 : {
634 : UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
635 : pos[1] >= 0.0 && pos[1] <= 1.0 &&
636 : pos[0]+pos[1] <= 1.0 &&
637 : pos[2] >= 0.0 && pos[2] <= 1.0,
638 : "Local position "<<pos<<" outside Reference Element");
639 0 : }
640 : };
641 :
642 : ///////////////////////////////////////////////////////////////////////////////
643 : // Reference Hexahedron
644 : ///////////////////////////////////////////////////////////////////////////////
645 :
646 : /// reference element for a hexahedron
647 : class ReferenceHexahedron : public DimReferenceElement<3>
648 : {
649 : public:
650 : /// type of reference element
651 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_HEXAHEDRON;
652 :
653 : /// dimension of reference element
654 : static const int dim = 3;
655 :
656 : /// number of corners
657 : static const int numCorners = 8;
658 :
659 : /// number of eges
660 : static const int numEdges = 12;
661 :
662 : /// number of faces
663 : static const int numFaces = 6;
664 :
665 : /// number of volumes
666 : static const int numVolumes = 1;
667 :
668 : /// number of sides
669 : static const int numSides = numFaces;
670 :
671 : public:
672 : /// Constructor filling the arrays
673 : ReferenceHexahedron();
674 :
675 : /// \copydoc ug::ReferenceElement::reference_object_id()
676 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
677 :
678 : /// \copydoc ug::ReferenceElement::dimension()
679 : int dimension() const {return dim;}
680 :
681 : /// \copydoc ug::ReferenceElement::size()
682 : number size() const {return 1.0;}
683 :
684 : /// \copydoc ug::DimReferenceElement::check_position()
685 : inline static void check_position(const MathVector<dim>& pos)
686 : {
687 : UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
688 : pos[1] >= 0.0 && pos[1] <= 1.0 &&
689 : pos[2] >= 0.0 && pos[2] <= 1.0,
690 : "Local position "<<pos<<" outside Reference Element");
691 0 : }
692 : };
693 :
694 : ///////////////////////////////////////////////////////////////////////////////
695 : // Reference Octahedron
696 : ///////////////////////////////////////////////////////////////////////////////
697 :
698 : class ReferenceOctahedron : public DimReferenceElement<3>
699 : {
700 : public:
701 : /// type of reference element
702 : static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_OCTAHEDRON;
703 :
704 : /// dimension of reference element
705 : static const int dim = 3;
706 :
707 : /// number of corners
708 : static const int numCorners = 6;
709 :
710 : /// number of edges
711 : static const int numEdges = 12;
712 :
713 : /// number of faces
714 : static const int numFaces = 8;
715 :
716 : /// number of volumes
717 : static const int numVolumes = 1;
718 :
719 : /// number of sides
720 : static const int numSides = numFaces;
721 :
722 : public:
723 : /// Constructor
724 : ReferenceOctahedron();
725 :
726 : /// \copydoc ug::ReferenceElement::reference_object_id()
727 : ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
728 :
729 : /// \copydoc ug::ReferenceElement::dimension()
730 : int dimension() const {return dim;}
731 :
732 : /// \copydoc ug::ReferenceElement::size()
733 : number size() const {return 2.0/3.0;}
734 :
735 : /// \copydoc ug::DimReferenceElement::check_position()
736 : inline static void check_position(const MathVector<dim>& pos)
737 : {
738 : //\todo: add check
739 0 : }
740 : };
741 :
742 : } // end namespace ug
743 :
744 : #include "reference_element_traits.h"
745 :
746 : #endif /* __H__UG__LIB_DISC__REFERENCE_ELEMENT__REFERENCE_ELEMENT__ */
|
