Triangle.h 5.16 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 40 41 42 43 44 45 46 47 48 49 50
// ============================================================================
// ==                                                                        ==
// == 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"
#include "MemoryManager.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:
    MEMORY_MANAGED(Triangle);

    /** \brief
     * calls base class contructor.
     */
    Triangle(Mesh* aMesh) : Element(aMesh) {};

    /** \brief
     * implements Element::clone
     */
51 52 53
    inline Element *clone() { 
      return NEW Triangle(mesh); 
    };
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 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 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114


    /** \brief
     * implements Element::getVertexOfEdge
     */
    inline int getVertexOfEdge(int i, int j) const {
      return vertexOfEdge[i][j];
    };

    /** \brief
     * implements Element::getVertexOfPosition
     */
    int getVertexOfPosition(GeoIndex position,
			    int      positionIndex,
			    int      vertexIndex) const;

    /** \brief
     * implements Element::getGeo
     */
    inline int getGeo(GeoIndex i) const {
      switch(i) {
      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;
      }
    };

    /** \brief
     * implements Element::hasSide
     */
    bool hasSide(Element* sideElem) const;

    /** \brief
     * implements Element::sortFaceIndices
     */
    const FixVec<int,WORLD>& sortFaceIndices(int face, 
					     FixVec<int,WORLD> *vec) const;

    /** \brief
     * implements Element::isLine. Returns false because this element is a 
     * Triangle
     */
115 116 117
    inline bool isLine() const { 
      return false; 
    };
118 119 120 121 122
 
    /** \brief
     * implements Element::isTriangle. Returns true because this element is a 
     * Triangle
     */
123 124 125
    inline bool isTriangle() const { 
      return true; 
    };
126 127 128 129 130

    /** \brief
     * implements Element::isTetrahedron. Returns false because this element is a 
     * Triangle
     */
131 132 133
    inline bool isTetrahedron() const { 
      return false; 
    };
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

    /** \brief
     * implements Element::getSideOfChild()
     */
    virtual int getSideOfChild(int child, int side, int) const {
      FUNCNAME("Triangle::getSideOfChild()");
      TEST_EXIT(child==0 || child==1)("child must be in (0,1)\n");
      TEST_EXIT(side >= 0 && side <= 2)("side must be between 0 and 2\n");
      return sideOfChild[child][side];
    };

    /** \brief
     * implements Element::getVertexOfParent()
     */
    virtual int getVertexOfParent(int child, int side, int=0) const {
      FUNCNAME("Triangle::getVertexOfParent()");
      TEST_EXIT(child==0 || child==1)("child must be in (0,1)\n");
      TEST_EXIT(side >= 0 && side <= 2)("side must be between 0 and 2\n");
      return vertexOfParent[child][side];
    };

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

    inline int getEdgeOfFace(int face, int edge) const {
      TEST_EXIT(face == 0)("face must be zero at triangle\n");
      TEST_EXIT(edge >= 0 && edge < 3)("invalid edge\n");
      return edge;
    };

    // ===== Serializable implementation =====
  
168 169 170
    ::std::string getTypeName() const { 
      return "Triangle"; 
    };
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186

  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