reference_element.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2021:  G-CSC, Goethe University Frankfurt
 * Authors: Andreas Vogel, Martin Stepniewski
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__UG__LIB_DISC__REFERENCE_ELEMENT__REFERENCE_ELEMENT__
#define __H__UG__LIB_DISC__REFERENCE_ELEMENT__REFERENCE_ELEMENT__
 
#include <cassert>
#include <iostream>
#include <sstream>
#include "common/common.h"
#include "common/math/ugmath.h"
#include "lib_grid/grid/grid_base_objects.h"
 
namespace ug{
 
// Reference Element Common Base Class
 
 
class ReferenceElement
{
  public:
    ReferenceElement();
 
    ReferenceObjectID roid() const
      {return m_vRefElemType[m_dim][0];}
    ReferenceObjectID roid() const {…}
 
    int dimension() const {return m_dim;}
 
    number size() const {return m_size;}
 
 
    size_t num(int dim) const {return m_vNum[dim];}
 
 
    size_t num(int dim_i, size_t i, int dim_j) const
      {return m_vSubNum[dim_i][i][dim_j];}
    size_t num(int dim_i, size_t i, int dim_j) const {…}
 
 
    int id(int dim_i, size_t i, int dim_j, size_t j) const
      {return m_id[dim_i][i][dim_j][j];}
    int id(int dim_i, size_t i, int dim_j, size_t j) const {…}
 
    size_t num(ReferenceObjectID type) const
      {return m_vNumRefElem[type];}
    size_t num(ReferenceObjectID type) const {…}
 
    ReferenceObjectID roid(int dim_i, size_t i) const
      {return m_vRefElemType[dim_i][i];}
    ReferenceObjectID roid(int dim_i, size_t i) const {…}
 
    void print_info() const;
 
  protected:
    enum{POINT = 0, EDGE = 1, FACE = 2, VOLUME= 3};
 
    enum{MAXOBJECTS = 12};
 
    enum{MAXDIM = 3};
 
    int m_dim;
 
    number m_size;
 
    size_t m_vNum[MAXDIM+1];
 
    size_t m_vSubNum[MAXDIM+1][MAXOBJECTS][MAXDIM+1];
 
    int m_id[MAXDIM+1][MAXOBJECTS][MAXDIM+1][MAXOBJECTS];
 
    size_t m_vNumRefElem[NUM_REFERENCE_OBJECTS];
 
    ReferenceObjectID m_vRefElemType[MAXDIM+1][MAXOBJECTS];
};
class ReferenceElement {…};
 
 
template <int d>
class DimReferenceElement : public ReferenceElement
{
  public:
    static const int dim = d;
 
    const MathVector<dim>* corners() const {return &m_vCorner[0];}
 
    const MathVector<dim>& corner(size_t i) const {return m_vCorner[i];}
 
    const MathVector<dim,int>* corner() const {return m_vCoInt;}
 
    void print_info() const;
 
  protected:
    enum{MAXCORNERS = 8};
 
    MathVector<dim> m_vCorner[MAXCORNERS];
    MathVector<dim, int> m_vCoInt[MAXCORNERS];
};
class DimReferenceElement : public ReferenceElement {…};
 
// Reference Element Providers
 
struct UGError_ReferenceElementMissing : public UGError
{
  UGError_ReferenceElementMissing(int dim_, ReferenceObjectID roid_)
  : UGError(""), dim(dim_), roid(roid_)
  {
    std::stringstream ss; ss << "Reference Element not found for "
              <<roid<<" (dim="<<dim<<")";
    UGError::push_msg(ss.str());
  }
  UGError_ReferenceElementMissing(int dim_, ReferenceObjectID roid_) {…}
  int dim;
  ReferenceObjectID roid;
};
struct UGError_ReferenceElementMissing : public UGError {…};
 
class ReferenceElementProvider
{
  private:
    ReferenceElementProvider();
 
  //  intentionally left unimplemented
    ReferenceElementProvider(const ReferenceElementProvider&){};
    ReferenceElementProvider& operator=(const ReferenceElementProvider&);
 
    static ReferenceElementProvider& instance()
    {
      static ReferenceElementProvider inst;
      return inst;
    }
    static ReferenceElementProvider& instance() {…}
 
    static bool add_elem(const ReferenceElement& elem);
 
    static const ReferenceElement& get_elem(ReferenceObjectID roid);
 
    static const ReferenceElement* m_vElem[NUM_REFERENCE_OBJECTS];
 
    template <int dim>
    static bool add_dim_elem(const DimReferenceElement<dim>& elem);
 
    template <int dim>
    static const DimReferenceElement<dim>& get_dim_elem(ReferenceObjectID roid)
    {
      UG_ASSERT(roid >= 0, "roid ="<<roid<<" wrong")
      UG_ASSERT(roid < NUM_REFERENCE_OBJECTS, "roid ="<<roid<<" wrong")
      static const DimReferenceElement<dim>** vDimElem = get_vector<dim>();
      UG_ASSERT(vDimElem[roid] != NULL, "Null pointer for roid ="<<roid);
      return *vDimElem[roid];
    }
    static const DimReferenceElement<dim>& get_dim_elem(ReferenceObjectID roid) {…}
 
    template <int dim>
    static const DimReferenceElement<dim>** get_vector()
    {
      static const DimReferenceElement<dim>* sVec[NUM_REFERENCE_OBJECTS];
      return sVec;
    }
    static const DimReferenceElement<dim>** get_vector() {…}
 
  public:
    template <int dim>
    inline static const DimReferenceElement<dim>& get(ReferenceObjectID roid)
    {
      return instance().get_dim_elem<dim>(roid);
    }
    inline static const DimReferenceElement<dim>& get(ReferenceObjectID roid) {…}
 
    inline static const ReferenceElement& get(ReferenceObjectID roid)
    {
      return instance().get_elem(roid);
    }
    inline static const ReferenceElement& get(ReferenceObjectID roid) {…}
};
class ReferenceElementProvider {…};
 
// Concrete Reference Elements
 
// Reference RegularVertex
 
class ReferenceVertex : public DimReferenceElement<0>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_VERTEX;
 
    static const int dim = 0;
 
    static const int numCorners = 1;
 
    static const int numEdges = 0;
 
    static const int numFaces = 0;
 
    static const int numVolumes = 0;
 
    static const int numSides = 0;
 
  public:
    ReferenceVertex();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 1.0;}
};
class ReferenceVertex : public DimReferenceElement<0> {…};
 
// Reference Edge
 
class ReferenceEdge : public DimReferenceElement<1>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_EDGE;
 
    static const int dim = 1;
 
    static const int numCorners = 2;
 
    static const int numEdges = 1;
 
    static const int numFaces = 0;
 
    static const int numVolumes = 0;
 
    static const int numSides = numCorners;
 
  public:
    ReferenceEdge();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 0.5;}
 
    inline static void check_position(const MathVector<dim>& pos)
    {
      UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0,
                "Local position "<<pos<<" outside Reference Element");
    }
    inline static void check_position(const MathVector<dim>& pos) {…}
};
class ReferenceEdge : public DimReferenceElement<1> {…};
 
// Reference Triangle
 
class ReferenceTriangle : public DimReferenceElement<2>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_TRIANGLE;
 
    static const int dim = 2;
 
    static const int numCorners = 3;
 
    static const int numEdges = 3;
 
    static const int numFaces = 1;
 
    static const int numVolumes = 0;
 
    static const int numSides = numEdges;
 
  public:
    ReferenceTriangle();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 0.5;}
 
    inline static void check_position(const MathVector<dim>& pos)
    {
      UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
                pos[1] >= 0.0 && pos[1] <= 1.0 &&
                pos[0]+pos[1] <= 1.0,
            "Local position "<<pos<<" outside Reference Element");
    }
    inline static void check_position(const MathVector<dim>& pos) {…}
};
class ReferenceTriangle : public DimReferenceElement<2> {…};
 
// Reference Quadrilateral
 
class ReferenceQuadrilateral : public DimReferenceElement<2>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_QUADRILATERAL;
 
    static const int dim = 2;
 
    static const int numCorners = 4;
 
    static const int numEdges = 4;
 
    static const int numFaces = 1;
 
    static const int numVolumes = 0;
 
    static const int numSides = numEdges;
 
  public:
    ReferenceQuadrilateral();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 1.0;}
 
    inline static void check_position(const MathVector<dim>& pos)
    {
      UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
            pos[1] >= 0.0 && pos[1] <= 1.0,
            "Local position "<<pos<<" outside Reference Element");
    }
    inline static void check_position(const MathVector<dim>& pos) {…}
};
class ReferenceQuadrilateral : public DimReferenceElement<2> {…};
 
// Reference Tetrahedron
 
class ReferenceTetrahedron : public DimReferenceElement<3>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_TETRAHEDRON;
 
    static const int dim = 3;
 
    static const int numCorners = 4;
 
    static const int numEdges = 6;
 
    static const int numFaces = 4;
 
    static const int numVolumes = 1;
 
    static const int numSides = numFaces;
 
  public:
    ReferenceTetrahedron();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 1.0/6.0;}
 
    inline static void check_position(const MathVector<dim>& pos)
    {
      UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
            pos[1] >= 0.0 && pos[1] <= 1.0 &&
            pos[2] >= 0.0 && pos[2] <= 1.0 &&
            pos[0]+pos[1]+pos[2] <= 1.0,
            "Local position "<<pos<<" outside Reference Element");
    }
    inline static void check_position(const MathVector<dim>& pos) {…}
};
class ReferenceTetrahedron : public DimReferenceElement<3> {…};
 
// Reference Pyramid
 
class ReferencePyramid : public DimReferenceElement<3>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_PYRAMID;
 
    static const int dim = 3;
 
    static const int numCorners = 5;
 
    static const int numEdges = 8;
 
    static const int numFaces = 5;
 
    static const int numVolumes = 1;
 
    static const int numSides = numFaces;
 
  public:
    ReferencePyramid();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 1.0/3.0;}
 
    inline static void check_position(const MathVector<dim>& pos)
    {
      //\todo: add check
    }
    inline static void check_position(const MathVector<dim>& pos) {…}
};
class ReferencePyramid : public DimReferenceElement<3> {…};
 
 
// Reference Prism
 
class ReferencePrism : public DimReferenceElement<3>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_PRISM;
 
    static const int dim = 3;
 
    static const int numCorners = 6;
 
    static const int numEdges = 9;
 
    static const int numFaces = 5;
 
    static const int numVolumes = 1;
 
    static const int numSides = numFaces;
 
  public:
    ReferencePrism();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 0.5;}
 
    inline static void check_position(const MathVector<dim>& pos)
    {
      UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
            pos[1] >= 0.0 && pos[1] <= 1.0 &&
            pos[0]+pos[1] <= 1.0 &&
            pos[2] >= 0.0 && pos[2] <= 1.0,
            "Local position "<<pos<<" outside Reference Element");
    }
    inline static void check_position(const MathVector<dim>& pos) {…}
};
class ReferencePrism : public DimReferenceElement<3> {…};
 
// Reference Hexahedron
 
class ReferenceHexahedron : public DimReferenceElement<3>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_HEXAHEDRON;
 
    static const int dim = 3;
 
    static const int numCorners = 8;
 
    static const int numEdges = 12;
 
    static const int numFaces = 6;
 
    static const int numVolumes = 1;
 
    static const int numSides = numFaces;
 
  public:
    ReferenceHexahedron();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 1.0;}
 
    inline static void check_position(const MathVector<dim>& pos)
    {
      UG_ASSERT(pos[0] >= 0.0 && pos[0] <= 1.0 &&
            pos[1] >= 0.0 && pos[1] <= 1.0 &&
            pos[2] >= 0.0 && pos[2] <= 1.0,
            "Local position "<<pos<<" outside Reference Element");
    }
    inline static void check_position(const MathVector<dim>& pos) {…}
};
class ReferenceHexahedron : public DimReferenceElement<3> {…};
 
// Reference Octahedron
 
class ReferenceOctahedron : public DimReferenceElement<3>
{
  public:
    static const ReferenceObjectID REFERENCE_OBJECT_ID = ROID_OCTAHEDRON;
 
    static const int dim = 3;
 
    static const int numCorners = 6;
 
    static const int numEdges = 12;
 
    static const int numFaces = 8;
 
    static const int numVolumes = 1;
 
    static const int numSides = numFaces;
 
  public:
    ReferenceOctahedron();
 
    ReferenceObjectID reference_object_id() const {return REFERENCE_OBJECT_ID;}
 
    int dimension() const {return dim;}
 
    number size() const {return 2.0/3.0;}
 
    inline static void check_position(const MathVector<dim>& pos)
    {
      //\todo: add check
    }
    inline static void check_position(const MathVector<dim>& pos) {…}
};
class ReferenceOctahedron : public DimReferenceElement<3> {…};
 
} // end namespace ug
 
#include "reference_element_traits.h"
 
#endif /* __H__UG__LIB_DISC__REFERENCE_ELEMENT__REFERENCE_ELEMENT__ */