cachingentity.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_GRID_CACHINGENTITY_HH
#define DUNE_MMESH_GRID_CACHINGENTITY_HH
 
#include <set>
 
// Dune includes
#include <dune/grid/common/grid.hh>
 
// MMesh includes
#include <dune/mmesh/grid/multiid.hh>
#include <dune/mmesh/grid/pointfieldvector.hh>
#include <dune/mmesh/grid/polygoncutting.hh>
 
namespace Dune {
 
//**********************************************************************
//
// --MMeshCachingEntity
// --Entity
//
template <int dim, class GridImp>
class MMeshCachingEntity<0, dim, GridImp>
    : public MMeshEntity<0, dim, GridImp> {
  template <class GridImp_>
  friend class MMeshLeafIndexSet;
 
  template <class GridImp_>
  friend class MMeshLocalIdSet;
 
  template <class GridImp_>
  friend class MMeshGlobalIdSet;
 
 private:
  // this type
  typedef MMeshCachingEntity<0, dim, GridImp> ThisType;
 
  // base type
  typedef MMeshEntity<0, dim, GridImp> BaseType;
 
  // type of scalars
  typedef typename GridImp::ctype ctype;
 
  // type of the host grid
  typedef typename GridImp::HostGridType HostGrid;
 
  // equivalent entity in the host grid as pointer
  typedef typename GridImp::template HostGridEntity<0> HostGridEntity;
 
  // standard MMesh entity implementation
  typedef typename GridImp::template Codim<0>::Entity MMeshEntityType;
 
  // type of ids
  typedef MMeshImpl::MultiId IdType;
 
 public:
  // geometry type
  typedef AffineGeometry<ctype, dim, dim> Geometry;
 
  // local geometry type
  typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
 
  // type of global coordinate
  typedef typename Geometry::GlobalCoordinate GlobalCoordinate;
 
  MMeshCachingEntity() = delete;
 
  explicit MMeshCachingEntity(const GridImp* mMesh,
                              const HostGridEntity& hostEntity)
      : BaseType(mMesh, hostEntity,
                 mMesh->globalIdSet().id(mMesh->entity(hostEntity))) {
    const auto geo = mMesh->entity(hostEntity).geometry();
    for (int i = 0; i < dim + 1; ++i) this->vertex_[i] = geo.corner(i);
  }
 
  bool equals(const MMeshCachingEntity& other) const {
    return this->id_ == other.id_;
  }
 
  bool operator==(const MMeshCachingEntity& other) const {
    return this->equals(other);
  }
 
  bool operator==(const MMeshEntityType& entity) const {
    return this->id_ == this->mMesh_->globalIdSet().id(entity);
  }
 
  bool operator<(const MMeshCachingEntity& other) const {
    return this->id_ < other.id_;
  }
 
  bool hasFather() const { return true; }
 
  const bool isNew() const { return false; }
 
  const bool mightVanish() const { return true; }
 
  int level() const {
    // we only have one level
    return 0;
  }
 
  PartitionType partitionType() const {
    return PartitionType::InteriorEntity; /* dummy */
  }
 
  Geometry geometry() const {
    return Geometry(GeometryTypes::simplex(dim), this->vertex_);
  }
 
  unsigned int subEntities(unsigned int cc) const {
    // we have a simplex grid
    int n = dim + 1;
    int k = dim - cc + 1;
 
    // binomial: n over k
    int binomial = 1;
    for (int i = n - k + 1; i <= n; i++) binomial *= i;
    for (long i = 2; i <= k; i++) binomial /= i;
 
    return binomial;
  }
 
  bool isLeaf() const { return false; }
 
  template <int d = dim>
  std::enable_if_t<d == 2, ctype> intersectionVolume(
      const MMeshEntityType& entity) const {
    std::array<GlobalCoordinate, 3> entityPoints;
 
    for (int i = 0; i < 3; ++i) {
      entityPoints[i] =
          makeFieldVector(entity.impl().hostEntity()->vertex(i)->point());
    }
 
    using PC = Dune::PolygonCutting<ctype, GlobalCoordinate>;
    return std::abs(
        PC::polygonArea(PC::sutherlandHodgman(this->vertex_, entityPoints)));
  }
 
  template <int d = dim>
  std::enable_if_t<d == 3, ctype> intersectionVolume(
      const MMeshEntityType& entity) const {
    DUNE_THROW(NotImplemented, "intersectionVolume in 3d");
  }
 
};  // end of MMeshCachingEntity codim = 0
 
}  // namespace Dune
 
#endif