Tetrahedron.h 7.07 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  crystal growth group                                                  ==
// ==                                                                        ==
// ==  Stiftung caesar                                                       ==
// ==  Ludwig-Erhard-Allee 2                                                 ==
// ==  53175 Bonn                                                            ==
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  http://www.caesar.de/cg/AMDiS                                         ==
// ==                                                                        ==
// ============================================================================

/** \file Tetrahedron.h */

#ifndef AMDIS_TETRAHEDRON_H
#define AMDIS_TETRAHEDRON_H

#include "Element.h"

namespace AMDiS {

  /** \ingroup Triangulation 
   * \brief
   * A Tetrahedron is a 3-dimensional Element. 
   *
   * A Tetrahedron and its refinements:
   *
   * <img src = "tetrahedron.png">
   */
  class Tetrahedron : public Element
  {
  public:
40
41
42
43
44
    
    /// calls base class contructor.
    Tetrahedron(Mesh* aMesh) 
      : Element(aMesh) 
    {}
45

46
    /// implements Element::clone
47
48
    inline Element *clone() { 
      return NEW Tetrahedron(mesh); 
49
    }
50

51
    /// implements Element::getVertexOfEdge
52
53
    inline int getVertexOfEdge(int i, int j) const {
      return vertexOfEdge[i][j];
54
    }
55

56
    /// implements Element::getVertexOfPosition
57
58
59
60
61
62
63
64
65
66
67
    int getVertexOfPosition(GeoIndex position,
			    int      positionIndex,
			    int      vertexIndex) const;


    virtual int getPositionOfVertex(int side, int vertex) const {
      static int positionOfVertex[4][4] = {{-1,0,1,2},
					   {0,-1,1,2},
					   {0,1,-1,2},
					   {0,1,2,-1}};
      return positionOfVertex[side][vertex];
68
    }
69

70
    /// implements Element::getGeo
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
    inline int getGeo(GeoIndex i) const {
      switch(i) {
      case VERTEX: case PARTS: case NEIGH:
	return 4;
	break;
      case EDGE:
	return 6;
      case FACE:
	return 4;
      case CENTER:
	return 1;
	break;
      case DIMEN:
	return 3;
	break;
      case BOUNDARY:
	return 14;
	break;
      case PROJECTION:
	return 10;
	break;
      default:
	ERROR_EXIT("invalid geo-index\n");
	return 0;
      }
96
    }
97

98
    /// implements Element::hasSide
99
100
    bool hasSide(Element* sideElem) const;

101
    /// implements Element::sortFaceIndices
102
103
104
    const FixVec<int,WORLD>& sortFaceIndices(int face, 
					     FixVec<int,WORLD> *vec) const;

105
    /// implements Element::isLine. Returns false because this element is a Tetrahedron
106
107
    inline bool isLine() const { 
      return false; 
108
    }
109
110
111
112
113

    /** \brief
     * implements Element::isTriangle. Returns false because this element is a 
     * Tetrahedron
     */
114
115
    inline bool isTriangle() const { 
      return false; 
116
    }
117
118
119
120
121
 
    /** \brief
     * implements Element::isTetrahedron. Returns true because this element is a 
     * Tetrahedron
     */
122
123
    inline bool isTetrahedron() const { 
      return true; 
124
125
    }
 
126
    std::string getTypeName() const { 
127
      return "Tetrahedron"; 
128
    }
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

  public:
    /** \brief
     * nChildEdge[el_type][ichild][dir]                                      
     * gives local index of new edge on child[ichild] part of face [2+dir] on
     * the parent  
     */
    static const unsigned char nChildEdge[3][2][2];

    /** \brief
     * nChildFace[el_type][ichild][dir]                                     
     * gives local index of sub-face on child[ichild] part of face [2+dir] on
     * the parent   
     */
    static const unsigned char nChildFace[3][2][2];

    /** \brief
     * childVertex[el_type][child][i] =
     * parent's local vertex index of new vertex i.
     * 4 stands for the newly generated vertex                            
     */
    static const int childVertex[3][2][4];
 
    /** \brief
     * childEdge[el_type][child][i] =
     * parent's local edge index of new edge i
     * new edge 2 is half of old edge 0,
     * new edges 4,5 are really new edges, and value is different:
     * childEdge[][][4,5] = index of same edge in other child
     */
    static const int childEdge[3][2][6];

    /** \brief
     * adjacentChild[position][ichild]                                      
     * gives number of the adjacent child on a neighbour element:             
     *   position = 0  same position of element and neigh at refinement edge, 
     *   position = 1  different ...                                         
     */
    static const unsigned char adjacentChild[2][2];

    /** \brief
     * childOrientation[el_type][child] =
     *   +1 if orientation is not changed during refinement, 
     *   -1 if orientation is changed during refinement
     */
    static const signed char childOrientation[3][2];

176
    /// edgeOfDOFs[i][j]: gives the local index of edge with vertices i and j 
177
178
    static const unsigned char edgeOfDOFs[4][4];

179
    ///
180
181
    static const int edgeOfFace[4][3];

182
    /// implements Element::getSideOfChild()
183
184
    virtual int getSideOfChild(int child, int side, int elType = 0) const {
      FUNCNAME("Tetrahedron::getSideOfChild()");
185
186
187
      TEST_EXIT_DBG(child==0 || child==1)("child must be in (0,1)\n");
      TEST_EXIT_DBG(side >= 0 && side <= 3)("side must be between 0 and 3\n");
      TEST_EXIT_DBG(elType >= 0 && elType <= 2)("elType must be between 0 and 2\n");
188
      return sideOfChild[elType][child][side];
189
    }
190

191
    /// implements Element::getVertexOfParent()
192
193
    virtual int getVertexOfParent(int child, int side, int elType = 0) const {
      FUNCNAME("Tetrahedron::getVertexOfParent()");
194
195
196
      TEST_EXIT_DBG(child==0 || child==1)("child must be in (0,1)\n");
      TEST_EXIT_DBG(side >= 0 && side <= 3)("side must be between 0 and 3\n");
      TEST_EXIT_DBG(elType >= 0 && elType <= 2)("elType must be between 0 and 2\n");
197
      return vertexOfParent[elType][child][side];
198
    }
199
200

    inline int getEdgeOfFace(int face, int edge) const {
201
202
      TEST_EXIT_DBG(face >= 0 && face < 4)("invalid face\n");
      TEST_EXIT_DBG(edge >= 0 && edge < 3)("invalid edge\n");
203
      return edgeOfFace[face][edge];
204
    }
205
206
207

  protected:

208
    /// vertexOfEdge[i][j] is the local number of the j-vertex of edge i
209
210
    static const int vertexOfEdge[6][2]; 

211
    /// vertexOfFace[i][j] is the local number of the j-vertex of face i
212
213
    static const int vertexOfFace[4][3];

214
    ///
215
    static const int sideOfChild[3][2][4];
216

217
    ///
218
219
220
221
222
223
    static const int vertexOfParent[3][2][4];
  };

}

#endif // AMDIS_TETRAHEDRON_H