type.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GEOMETRY_TYPE_HH
#define DUNE_GEOMETRY_TYPE_HH
 
#include <cassert>
 
#include <dune/common/exceptions.hh>
#include <dune/common/unused.hh>
 
namespace Dune
{
  class GeometryType
  {
  public:
    enum BasicType {
      simplex,       
      cube,          
      pyramid,       
      prism,         
      extended,      
      none           
    };
 
    enum Binary {
      b0001 = 1,
      b0011 = 3,
      b0101 = 5,
      b0111 = 7
    };
  private:
 
    unsigned int topologyId_;
 
    unsigned char dim_  : 7;
 
    bool none_ : 1;
 
  public:
    GeometryType ()
      : topologyId_(0), dim_(0), none_(true)
    {}
 
    GeometryType(BasicType basicType, unsigned int dim)
      : topologyId_(0), dim_(dim), none_((basicType == GeometryType::none) ? true : false)
    {
      if (dim < 2)
        return;
      switch( basicType )
      {
      case GeometryType::simplex :
        makeSimplex(dim);
        break;
      case GeometryType::cube :
        makeCube(dim);
        break;
      case GeometryType::pyramid :
        if (dim == 3)
          makePyramid();
        else
          DUNE_THROW( RangeError,
                      "Invalid basic geometry type: no pyramids for dimension " << dim << "." );
        break;
      case GeometryType::prism :
        if (dim == 3)
          makePrism();
        else
          DUNE_THROW( RangeError,
                      "Invalid basic geometry type: no prisms for dimension " << dim << "." );
        break;
      case GeometryType::none :
        break;
      default :
        DUNE_THROW( RangeError,
                    "Invalid basic geometry type: " << basicType << " for dimension " << dim << "." );
      }
    }
 
    GeometryType(unsigned int topologyId, unsigned int dim)
      : topologyId_(topologyId), dim_(dim), none_(false)
    {}
 
    template<class TopologyType>
    explicit GeometryType(TopologyType t)
      : topologyId_(TopologyType::id), dim_(TopologyType::dimension), none_(false)
    {
      DUNE_UNUSED_PARAMETER(t);
    }
 
    explicit GeometryType(unsigned int dim)
      : topologyId_(0), dim_(dim), none_(false)
    {
      assert(dim < 2);
    }
 
    // We need this constructor for "int" and "unsigned int",
    // because otherwise GeometryType(int) would try to call the
    // generic GeometryType(TopologyType) constructor
    explicit GeometryType(int dim)
      : topologyId_(0), dim_(dim), none_(false)
    {
      assert(dim < 2);
    }
 
 
    void makeVertex() {
      none_  = false;
      dim_ = 0;
      topologyId_ = 0;
    }
 
    void makeLine() {
      none_  = false;
      dim_ = 1;
      topologyId_ = 0;
    }
 
    void makeTriangle() {
      makeSimplex(2);
    }
 
    void makeQuadrilateral() {
      makeCube(2);
    }
 
    void makeTetrahedron() {
      makeSimplex(3);
    }
 
    void makePyramid() {
      none_  = false;
      dim_ = 3;
      topologyId_ = b0011;
    }
 
    void makePrism() {
      none_  = false;
      dim_ = 3;
      topologyId_ = b0101;       // (1 << (dim_-1)) - 1;
    }
 
    void makeHexahedron() {
      makeCube(3);
    }
 
    void makeSimplex(unsigned int dim) {
      none_  = false;
      dim_ = dim;
      topologyId_ = 0;
    }
 
    void makeCube(unsigned int dim) {
      none_  = false;
      dim_ = dim;
      topologyId_ = ((dim>1) ? ((1 << dim) - 1) : 0);
    }
 
    void makeNone(unsigned int dim) {
      none_ = true;
      dim_ = dim;
      topologyId_  = 0;
    }
 
    void makeFromVertices(unsigned int dim, unsigned int vertices)
    {
      switch (dim)
      {
      case 0 :
        makeVertex();
        return;
      case 1 :
        makeLine();
        return;
      case 2 :
        switch (vertices) {
        case 3 :
          makeSimplex(2);
          return;
        case 4 :
          makeCube(2);
          return;
        default :
          DUNE_THROW(NotImplemented, "2d elements with " << vertices << " corners are not supported!");
        }
      case 3 :
        switch (vertices) {
        case 4 :
          makeSimplex(3);
          return;
        case 5 :
          makePyramid();
          return;
        case 6 :
          makePrism();
          return;
        case 8 :
          makeCube(3);
          return;
        default :
          DUNE_THROW(NotImplemented, "3d elements with " << vertices << " corners are not supported!");
        }
      default :
        DUNE_THROW(NotImplemented, "makeFromVertices only implemented up to 3d");
      }
    }
 
    bool isVertex() const {
      return dim_==0;
    }
 
    bool isLine() const {
      return dim_==1;
    }
 
    bool isTriangle() const {
      return ! none_ && dim_==2 && (topologyId_ | 1) == b0001;
    }
 
    bool isQuadrilateral() const {
      return ! none_ && dim_==2 && (topologyId_ | 1) == b0011;
    }
 
    bool isTetrahedron() const {
      return ! none_ && dim_==3 && (topologyId_ | 1) == b0001;
    }
 
    bool isPyramid() const {
      return ! none_ && dim_==3 && (topologyId_ | 1) == b0011;
    }
 
    bool isPrism() const {
      return ! none_ && dim_==3 && (topologyId_ | 1) == b0101;
    }
 
    bool isHexahedron() const {
      return ! none_ && dim_==3 && (topologyId_ | 1) == b0111;
    }
 
    bool isSimplex() const {
      return ! none_ && (topologyId_ | 1) == 1;
    }
 
    bool isCube() const {
      return ! none_ && ((topologyId_ ^ ((1 << dim_)-1)) >> 1 == 0);
    }
 
    bool isNone() const {
      return none_;
    }
 
    unsigned int dim() const {
      return dim_;
    }
 
    unsigned int id() const {
      return topologyId_;
    }
 
    bool operator==(const GeometryType& other) const {
      return ( ( none_ == other.none_ )
               && ( ( none_ == true )
                    || ( ( dim_ == other.dim_ )
                         && ( (topologyId_ >> 1) == (other.topologyId_ >> 1) )
                         )
                    )
               );
    }
 
    bool operator!=(const GeometryType& other) const {
      return ! ((*this)==other);
    }
 
    bool operator < (const GeometryType& other) const {
      return ( ( none_ < other.none_ )
               || ( !( other.none_ < none_ )
                    && ( ( dim_ < other.dim_ )
                         || ( (other.dim_ == dim_)
                              && ((topologyId_ >> 1) < (other.topologyId_ >> 1) )
                              )
                         )
                    )
               );
    }
  };
 
  inline std::ostream& operator<< (std::ostream& s, const GeometryType& a)
  {
    if (a.isSimplex())
    {
      s << "(simplex, " << a.dim() << ")";
      return s;
    }
    if (a.isCube())
    {
      s << "(cube, " << a.dim() << ")";
      return s;
    }
    if (a.isPyramid())
    {
      s << "(pyramid, 3)";
      return s;
    }
    if (a.isPrism())
    {
      s << "(prism, 3)";
      return s;
    }
    if (a.isNone())
    {
      s << "(none, " << a.dim() << ")";
      return s;
    }
    s << "(other [" << a.id() << "], " << a.dim() << ")";
    return s;
  }
 
  inline std::ostream& operator<< (std::ostream& s, GeometryType::BasicType type)
  {
    switch (type) {
    case GeometryType::simplex :
      s << "simplex";
      break;
    case GeometryType::cube :
      s << "cube";
      break;
    case GeometryType::pyramid :
      s << "pyramid";
      break;
    case GeometryType::prism :
      s << "prism";
      break;
    case GeometryType::extended :
      s << "other";
    case GeometryType::none :
      s << "none";
      break;
    default :
      DUNE_THROW(Exception, "invalid GeometryType::BasicType");
    }
    return s;
  }
} // namespace Dune
 
#endif // DUNE_GEOMETRY_TYPE_HH