geometry.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_MMESH_INTERFACE_GEOMETRY_HH
#define DUNE_MMESH_INTERFACE_GEOMETRY_HH
 
// Dune includes
#include <dune/common/fmatrix.hh>
#include <dune/common/typetraits.hh>
#include <dune/geometry/affinegeometry.hh>
#include <dune/grid/common/geometry.hh>
 
// local includes
#include <dune/mmesh/grid/pointfieldvector.hh>
#include <dune/mmesh/interface/common.hh>
 
namespace Dune {
 
template <int mydim, int coorddim, class GridImp>
class MMeshInterfaceGridGeometry {};
 
 
template <int md, class GridImp>
class MMeshInterfaceGridGeometry<md, 2, GridImp>
    : public AffineGeometry<typename GridImp::ctype, md, 2> {
 public:
  static constexpr int mydim = md;
  static constexpr int coorddim = 2;
  typedef AffineGeometry<typename GridImp::ctype, mydim, coorddim> BaseType;
  typedef FieldVector<typename GridImp::ctype, coorddim> FVector;
 
  enum { dimension = GridImp::dimension };
  enum { dimensionworld = GridImp::dimensionworld };
  enum { coorddimension = coorddim };
  enum { mydimension = mydim };
 
  MMeshInterfaceGridGeometry(
      const typename GridImp::template MMeshInterfaceEntity<0>& hostEntity)
      : BaseType(GeometryTypes::simplex(mydim), getVertices(hostEntity)) {}
 
  MMeshInterfaceGridGeometry(const std::array<FVector, 2>& points)
      : BaseType(GeometryTypes::simplex(mydim), points) {}
 
  MMeshInterfaceGridGeometry(
      const typename GridImp::template MMeshInterfaceEntity<1>& hostEntity)
      : BaseType(
            GeometryTypes::simplex(mydim),
            std::array<FVector, 1>({makeFieldVector(hostEntity->point())})) {}
 
  MMeshInterfaceGridGeometry(int i)
      : BaseType(GeometryTypes::simplex(1),
                 std::array<FVector, 2>(
                     {FVector({i == 2 ? 1.0 : 0.0, 0.0}),
                      FVector({i == 0 ? 1.0 : 0.0, i > 0 ? 1.0 : 0.0})})) {}
 
  const FVector circumcenter() const { return computeCircumcenter(*this); }
 
 private:
  static inline std::array<FVector, 2> getVertices(
      const typename GridImp::template MMeshInterfaceEntity<0>& hostEntity) {
    const auto& cgalIdx = MMeshInterfaceImpl::computeCGALIndices<
        typename GridImp::template MMeshInterfaceEntity<0>, 1>(hostEntity);
 
    std::array<FVector, 2> vertices(
        {makeFieldVector(hostEntity.first->vertex(cgalIdx[0])->point()),
         makeFieldVector(hostEntity.first->vertex(cgalIdx[1])->point())});
 
    return vertices;
  }
};
 
 
template <int md, class GridImp>
class MMeshInterfaceGridGeometry<md, 3, GridImp>
    : public AffineGeometry<typename GridImp::ctype, md, 3> {
 public:
  static constexpr int mydim = md;
  static constexpr int coorddim = 3;
  typedef AffineGeometry<typename GridImp::ctype, mydim, coorddim> BaseType;
  typedef typename GridImp::ctype ctype;
  typedef FieldVector<ctype, coorddim> FVector;
 
  enum { dimension = GridImp::dimension };
  enum { dimensionworld = GridImp::dimensionworld };
  enum { coorddimension = coorddim };
  enum { mydimension = mydim };
 
  MMeshInterfaceGridGeometry(
      const typename GridImp::template MMeshInterfaceEntity<0>& hostEntity)
      : BaseType(GeometryTypes::simplex(mydim), getVertices<0>(hostEntity)) {}
 
  MMeshInterfaceGridGeometry(const std::array<FVector, 3>& points)
      : BaseType(GeometryTypes::simplex(mydim), points) {}
 
  MMeshInterfaceGridGeometry(
      const typename GridImp::template MMeshInterfaceEntity<1>& hostEntity)
      : BaseType(GeometryTypes::simplex(mydim), getVertices<1>(hostEntity)) {}
 
  MMeshInterfaceGridGeometry(
      const typename GridImp::template MMeshInterfaceEntity<2>& hostEntity)
      : BaseType(
            GeometryTypes::simplex(mydim),
            std::array<FVector, 1>({makeFieldVector(hostEntity->point())})) {}
 
  const FVector circumcenter() const { return computeCircumcenter(*this); }
 
 private:
  template <int codim, typename Enable = std::enable_if_t<codim == 0> >
  static inline std::array<FVector, 3> getVertices(
      const typename GridImp::template MMeshInterfaceEntity<0>& hostEntity) {
    const auto& cgalIdx = MMeshInterfaceImpl::computeCGALIndices<
        typename GridImp::template MMeshInterfaceEntity<0>, 2>(hostEntity);
 
    std::array<FVector, 3> vertices;
 
    const auto& cell = hostEntity.first;
 
    // use the CGAL index convention to obtain the vertices
    for (int i = 0; i < 3; ++i)
      vertices[i] = makeFieldVector(cell->vertex(cgalIdx[i])->point());
 
    return vertices;
  }
 
  template <int codim, typename Enable = std::enable_if_t<codim == 1> >
  static inline std::array<FVector, 2> getVertices(
      const typename GridImp::template MMeshInterfaceEntity<1>& hostEntity) {
    const auto& cell = hostEntity.first;
    const auto& i = hostEntity.second;
    const auto& j = hostEntity.third;
 
    std::array<FVector, 2> vertices;
    vertices[0] = makeFieldVector(cell->vertex(i)->point());
    vertices[1] = makeFieldVector(cell->vertex(j)->point());
 
    if (cell->vertex(i)->info().id > cell->vertex(j)->info().id)
      std::swap(vertices[0], vertices[1]);
 
    return vertices;
  }
};
 
template <int md, class GridImp>
class MMeshInterfaceGridGeometry<md, 1, GridImp>
    : public AffineGeometry<typename GridImp::ctype, md, 1> {
 public:
  static constexpr int mydim = md;
  static constexpr int coorddim = 1;
  typedef AffineGeometry<typename GridImp::ctype, mydim, coorddim> BaseType;
  typedef FieldVector<typename GridImp::ctype, coorddim> FVector;
 
  enum { dimension = GridImp::dimension };
  enum { dimensionworld = GridImp::dimensionworld };
  enum { coorddimension = coorddim };
  enum { mydimension = mydim };
 
  MMeshInterfaceGridGeometry(int i)
      : BaseType(GeometryTypes::simplex(mydim), std::array<FVector, 1>({i})) {}
 
  MMeshInterfaceGridGeometry(const std::array<FVector, 2>& points)
      : BaseType(GeometryTypes::simplex(mydim), points) {}
};
 
}  // namespace Dune
 
#endif