Triangle.h 4.89 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 Triangle.h */

#ifndef AMDIS_TRIANGLE_H
#define AMDIS_TRIANGLE_H

#include "Element.h"

namespace AMDiS {

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

    ~Triangle() {}
46

47
48
49
    /// implements Element::clone
    inline Element *clone() 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
50
      return new Triangle(mesh); 
51
    }
52

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

59
    /// implements Element::getVertexOfPosition
60
    int getVertexOfPosition(GeoIndex position,
61
62
			    int positionIndex,
			    int vertexIndex) const;
63

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

93
    /// implements Element::hasSide
94
95
    bool hasSide(Element* sideElem) const;

96
    /// implements Element::sortFaceIndices
97
98
99
    const FixVec<int,WORLD>& sortFaceIndices(int face, 
					     FixVec<int,WORLD> *vec) const;

100
101
102
    /// implements Element::isLine. Returns false because this element is a Triangle
    inline bool isLine() const 
    { 
103
      return false; 
104
    }
105
 
106
107
108
    /// implements Element::isTriangle. Returns true because this element is a Triangle
    inline bool isTriangle() const 
    { 
109
      return true; 
110
    }
111
112
113
114
115

    /** \brief
     * implements Element::isTetrahedron. Returns false because this element is a 
     * Triangle
     */
116
117
    inline bool isTetrahedron() const 
    { 
118
      return false; 
119
    }
120

121
122
123
    /// implements Element::getSideOfChild()
    virtual int getSideOfChild(int child, int side, int) const 
    {
124
      FUNCNAME("Triangle::getSideOfChild()");
125
126
      TEST_EXIT_DBG(child==0 || child==1)("child must be in (0,1)\n");
      TEST_EXIT_DBG(side >= 0 && side <= 2)("side must be between 0 and 2\n");
127
      return sideOfChild[child][side];
128
    }
129

130
131
132
    /// implements Element::getVertexOfParent()
    virtual int getVertexOfParent(int child, int side, int = 0) const 
    {
133
      FUNCNAME("Triangle::getVertexOfParent()");
134
135
      TEST_EXIT_DBG(child==0 || child==1)("child must be in (0,1)\n");
      TEST_EXIT_DBG(side >= 0 && side <= 2)("side must be between 0 and 2\n");
136
      return vertexOfParent[child][side];
137
    }
138

139
140
    virtual int getPositionOfVertex(int side, int vertex) const 
    {
141
142
      static int positionOfVertex[3][3] = {{-1,0,1},{1,-1,0},{0,1,-1}};
      return positionOfVertex[side][vertex];
143
    }
144

145
146
    inline int getEdgeOfFace(int face, int edge) const 
    {
147
148
      TEST_EXIT_DBG(face == 0)("face must be zero at triangle\n");
      TEST_EXIT_DBG(edge >= 0 && edge < 3)("invalid edge\n");
149
      return edge;
150
    }
151

152
153
    std::string getTypeName() const 
    { 
154
      return "Triangle"; 
155
    }
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

  protected:
    /** \brief
     * vertexOfEdge[i][j] is the local number of the j-th vertex of the i-th 
     * edge of this element.
     */
    static const int vertexOfEdge[3][2];

    static const int sideOfChild[2][3];

    static const int vertexOfParent[2][3];
  };

}

#endif // AMDIS_TRIANGLE_H