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