entity.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_ENTITY_HH
#define DUNE_MMESH_INTERFACE_ENTITY_HH
 
// Dune includes
#include <dune/grid/common/grid.hh>
#include <dune/mmesh/interface/common.hh>
#include <dune/mmesh/interface/incidentiterator.hh>
 
namespace Dune
{
  // External forward declarations
  template<class Grid>
  struct HostGridAccess;
 
 
  //**********************************************************************
  //
  // --MMeshInterfaceGridEntity
  // --Entity
  //
  template<int codim, int dim, class GridImp>
  class MMeshInterfaceGridEntity
#ifndef DOXYGEN_SHOULD_SKIP_THIS
   : public EntityDefaultImplementation <codim,dim,GridImp,MMeshInterfaceGridEntity>
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
  {
    template <class GridImp_>
    friend class MMeshInterfaceGridLeafIndexSet;
 
    template <class GridImp_>
    friend class MMeshInterfaceGridLocalIdSet;
 
    template <class GridImp_>
    friend class MMeshInterfaceGridGlobalIdSet;
 
    friend struct HostGridAccess< typename std::remove_const< GridImp >::type >;
 
  private:
    typedef typename GridImp::ctype ctype;
 
    // equivalent entity in the host grid
    typedef typename GridImp::template MMeshInterfaceEntity<codim> MMeshInterfaceEntity;
 
    using IdType = MMeshImpl::MultiId;
 
  public:
    typedef typename GridImp::template Codim<codim>::Geometry Geometry;
 
    typedef typename GridImp::template Codim<codim>::EntitySeed EntitySeed;
 
    MMeshInterfaceGridEntity()
      : grid_(nullptr)
    {}
 
    MMeshInterfaceGridEntity(const GridImp* grid, const MMeshInterfaceEntity& hostEntity)
      : hostEntity_(hostEntity)
      , grid_(grid)
    {}
 
    MMeshInterfaceGridEntity(const GridImp* grid, MMeshInterfaceEntity&& hostEntity)
      : hostEntity_(std::move(hostEntity))
      , grid_(grid)
    {}
 
    MMeshInterfaceGridEntity(const MMeshInterfaceGridEntity& original)
      : hostEntity_(original.hostEntity_)
      , grid_(original.grid_)
    {}
 
    MMeshInterfaceGridEntity(MMeshInterfaceGridEntity&& original)
      : hostEntity_(std::move(original.hostEntity_))
      , grid_(original.grid_)
    {}
 
    MMeshInterfaceGridEntity& operator=(const MMeshInterfaceGridEntity& original)
    {
      if (this != &original)
      {
        grid_ = original.grid_;
        hostEntity_ = original.hostEntity_;
      }
      return *this;
    }
 
    MMeshInterfaceGridEntity& operator=(MMeshInterfaceGridEntity&& original)
    {
      if (this != &original)
      {
        grid_ = original.grid_;
        hostEntity_ = std::move(original.hostEntity_);
      }
      return *this;
    }
 
    // Comparator for vertices
    template <int cc = codim>
    std::enable_if_t< cc == dim, bool >
    equals(const MMeshInterfaceGridEntity& other) const
    {
      return hostEntity_ == other.hostEntity_;
    }
 
    // Comparator for edges
    template <int cc = codim>
    std::enable_if_t< cc == 1 && dim == 2, bool >
    equals(const MMeshInterfaceGridEntity& other) const
    {
      const auto& vh1 = hostEntity_.first->vertex(hostEntity_.second);
      const auto& vh2 = hostEntity_.first->vertex(hostEntity_.third);
      const auto& hostOther_ = other.hostEntity_;
      const auto& vo1 = hostOther_.first->vertex(hostOther_.second);
      const auto& vo2 = hostOther_.first->vertex(hostOther_.third);
 
      return ( (vh1 == vo1) && ( vh2 == vo2 ) ) || ( (vh1 == vo2) && ( vh2 == vo1 ) );
    }
 
    bool hasConnectedComponent () const {
      return false;
    }
 
    EntitySeed seed () const
    {
      return EntitySeed( hostEntity_ );
    }
 
    int level () const {
      // we only have one level
      return 0;
    }
 
    PartitionType partitionType () const
    {
      return grid().getMMesh().partitionHelper().partitionType( grid().entity(hostEntity_) );
    }
 
    unsigned int subEntities (unsigned int cc) const
    {
      if( dim == 1 )
        return (cc == 0) ? 0 : 2;
 
      if( dim == 2 )
        return (cc == 0) ? 0 : 3;
    }
 
    template <int cc>
    std::enable_if_t< cc == codim, typename GridImp::template Codim<cc>::Entity >
    subEntity (std::size_t i) const {
      return *this;
    }
 
    template <int cc>
    std::enable_if_t< cc == codim+1, typename GridImp::template Codim<cc>::Entity >
    subEntity (std::size_t i) const {
      DUNE_THROW(NotImplemented, "subEntity<1> for codim 1 entity");
      return typename GridImp::template Codim<cc>::Entity();
    }
 
    Geometry geometry () const
    {
      return Geometry( hostEntity_ );
    }
 
    GeometryType type () const
    {
      return GeometryTypes::simplex(dim-codim);
    }
 
    bool isInterface() const
    {
      return true;
    }
 
    bool isTip() const
    {
      if constexpr ( codim == dim )
      {
        if constexpr ( dim == 2 )
          return false;
        else
        {
          const auto& hostgrid = grid().getHostGrid();
 
          int count = 0;
          auto circulator = hostgrid.incident_edges( hostEntity_ );
          for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
          {
            // at boundary
            if (hostgrid.is_infinite(circulator))
              return false;
 
             if (grid().isInterface(*circulator))
              count++;
          }
 
          return (count == 1);
        }
      }
      else
        DUNE_THROW( NotImplemented, "isTip() for codim != dim" );
    };
 
    int boundaryFlag() const
    {
      if constexpr ( codim == dim )
        return hostEntity_->info().boundaryFlag;
      else
        DUNE_THROW( NotImplemented, "boundaryFlag() for codim != dim" );
    }
 
    std::size_t insertionLevel() const
    {
      if constexpr ( codim == dim )
        return hostEntity_->info().insertionLevel;
      else
        DUNE_THROW( NotImplemented, "boundaryFlag() for codim != dim" );
    }
 
    auto incidentVerticesBegin ( bool includeInfinite ) const
    {
      if constexpr ( codim == dim )
      {
        using Impl = typename MMeshIncidentVerticesIterator<GridImp>::Implementation;
        return MMeshIncidentVerticesIterator<GridImp>( Impl( grid_, hostEntity_, includeInfinite) );
      }
      else
        DUNE_THROW( NotImplemented, "incidentVerticesBegin() for codim != dim" );
    }
 
    auto incidentVerticesEnd ( bool includeInfinite ) const
    {
      if constexpr ( codim == dim )
      {
        using Impl = typename MMeshIncidentVerticesIterator<GridImp>::Implementation;
        return MMeshIncidentVerticesIterator<GridImp>( Impl( grid_, hostEntity_, includeInfinite, true ) );
      }
      else
        DUNE_THROW( NotImplemented, "incidentVerticesEnd() for codim != dim" );
    }
 
    auto incidentInterfaceVerticesBegin () const
    {
      if constexpr ( codim == dim )
      {
        using Impl = typename MMeshIncidentInterfaceVerticesIterator<GridImp>::Implementation;
        return MMeshIncidentInterfaceVerticesIterator<GridImp>( Impl( grid_, hostEntity_ ) );
      }
      else
        DUNE_THROW( NotImplemented, "incidentInterfaceVerticesBegin() for codim != dim" );
    }
 
    auto incidentInterfaceVerticesEnd () const
    {
      if constexpr ( codim == dim )
      {
        using Impl = typename MMeshIncidentInterfaceVerticesIterator<GridImp>::Implementation;
        return MMeshIncidentInterfaceVerticesIterator<GridImp>( Impl( grid_, hostEntity_, true ) );
      }
      else
        DUNE_THROW( NotImplemented, "incidentInterfaceVerticesEnd() for codim != dim" );
    }
 
    auto incidentInterfaceElementsBegin () const
    {
      if constexpr ( codim == dim )
      {
        using Impl = typename MMeshIncidentInterfaceElementsIterator<GridImp>::Implementation;
        return MMeshIncidentInterfaceElementsIterator<GridImp>( Impl( grid_, hostEntity_ ) );
      }
      else if constexpr ( codim == dim-1 )
      {
        using Impl = typename MMeshEdgeIncidentInterfaceElementsIterator<GridImp>::Implementation;
        return MMeshEdgeIncidentInterfaceElementsIterator<GridImp>( Impl( grid_, hostEntity_ ) );
      }
      else
        DUNE_THROW( NotImplemented, "incidentInterfaceElementsBegin() for codim <= dim-1" );
    }
 
    auto incidentInterfaceElementsEnd () const
    {
      if constexpr ( codim == dim )
      {
        using Impl = typename MMeshIncidentInterfaceElementsIterator<GridImp>::Implementation;
        return MMeshIncidentInterfaceElementsIterator<GridImp>( Impl( grid_, hostEntity_, true ) );
      }
      else if constexpr ( codim == dim-1 )
      {
        using Impl = typename MMeshEdgeIncidentInterfaceElementsIterator<GridImp>::Implementation;
        return MMeshEdgeIncidentInterfaceElementsIterator<GridImp>( Impl( grid_, hostEntity_, true ) );
      }
      else
        DUNE_THROW( NotImplemented, "incidentInterfaceElementsEnd() for codim != dim" );
    }
 
    const MMeshInterfaceEntity& hostEntity () const
    {
      return hostEntity_;
    }
 
    IdType id() const
    {
      if constexpr ( codim == dim )
        return hostEntity_->info().id;
      else
        return grid().globalIdSet().id( *this );
    }
 
    const GridImp& grid () const
    {
      return *grid_;
    }
 
  private:
    MMeshInterfaceEntity hostEntity_;
 
    const GridImp* grid_;
  };
 
 
  //***********************
  //
  //  --MMeshInterfaceGridEntity
  //
  //***********************
  template<int dim, class GridImp>
  class MMeshInterfaceGridEntity<0,dim,GridImp>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
   : public EntityDefaultImplementation<0,dim,GridImp, MMeshInterfaceGridEntity>
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
  {
    friend struct HostGridAccess< typename std::remove_const< GridImp >::type >;
 
    typedef Entity< 0, dim, GridImp, MMeshInterfaceGridEntity > EntityType;
 
  public:
    // equivalent entity in the host grid
    typedef typename GridImp::template MMeshInterfaceEntity<0> MMeshInterfaceEntity;
 
    typedef typename GridImp::template MMeshInterfaceEntity<dim> MMeshInterfaceVertex;
 
    typedef typename GridImp::template Codim<0>::Geometry Geometry;
 
    typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
 
    typedef MMeshInterfaceGridLeafIntersectionIterator<GridImp> LeafIntersectionIterator;
 
    typedef MMeshHierarchicIterator<GridImp> HierarchicIterator;
 
    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
    typedef typename GridImp::ConnectedComponent ConnectedComponent;
 
    using IdType = MMeshImpl::MultiId;
 
    // type of global coordinate
    typedef typename Geometry::GlobalCoordinate GlobalCoordinate;
 
    // type of local coordinate
    typedef typename Geometry::LocalCoordinate LocalCoordinate;
 
    using VertexStorage = std::array<GlobalCoordinate, dim+1>;
 
    MMeshInterfaceGridEntity()
      : grid_(nullptr), isLeaf_(true)
    {}
 
    MMeshInterfaceGridEntity(const GridImp* grid, const MMeshInterfaceEntity& hostEntity)
      : hostEntity_(hostEntity), grid_(grid), isLeaf_(true)
    {
      if (grid->canBeMirrored(hostEntity_))
      {
        const auto mirrored = grid_->mirrorHostEntity( hostEntity_ );
        if ( hostEntity_.first->info().insertionIndex > mirrored.first->info().insertionIndex )
          hostEntity_ = mirrored;
      }
    }
 
    MMeshInterfaceGridEntity(const GridImp* grid, MMeshInterfaceEntity&& hostEntity)
      : hostEntity_(std::move(hostEntity)), grid_(grid), isLeaf_(true)
    {
      if (grid->canBeMirrored(hostEntity_))
      {
        const auto mirrored = grid_->mirrorHostEntity( hostEntity_ );
        if ( hostEntity_.first->info().insertionIndex > mirrored.first->info().insertionIndex )
          hostEntity_ = mirrored;
      }
    }
 
    MMeshInterfaceGridEntity(const GridImp* grid, const MMeshInterfaceEntity& hostEntity, const IdType& id)
      : hostEntity_(hostEntity), id_(id), grid_(grid), isLeaf_(false)
    {}
 
    MMeshInterfaceGridEntity(const GridImp* grid, const VertexStorage& vertex)
      : id_( /*caching id*/ IdType({ std::size_t(-3), std::size_t(-2) }) ), grid_(grid), isLeaf_(false), vertex_(vertex)
    {}
 
    MMeshInterfaceGridEntity(const MMeshInterfaceGridEntity& original)
      : hostEntity_(original.hostEntity_), id_(original.id_)
      , grid_(original.grid_), isLeaf_(original.isLeaf_), vertex_(original.vertex_)
    {}
 
    MMeshInterfaceGridEntity(MMeshInterfaceGridEntity&& original)
      : hostEntity_(std::move(original.hostEntity_)), id_(original.id_)
      , grid_(original.grid_), isLeaf_(original.isLeaf_), vertex_(original.vertex_)
    {}
 
    MMeshInterfaceGridEntity& operator=(const MMeshInterfaceGridEntity& original)
    {
      if (this != &original)
      {
        grid_ = original.grid_;
        hostEntity_ = original.hostEntity_;
        isLeaf_ = original.isLeaf_;
        id_ = original.id_;
        vertex_ = original.vertex_;
      }
      return *this;
    }
 
    MMeshInterfaceGridEntity& operator=(MMeshInterfaceGridEntity&& original)
    {
      if (this != &original)
      {
        grid_ = original.grid_;
        hostEntity_ = std::move(original.hostEntity_);
        isLeaf_ = original.isLeaf_;
        id_ = original.id_;
        vertex_ = original.vertex_;
      }
      return *this;
    }
 
    // Comparator for edges
    template <int d = dim>
    std::enable_if_t< d == 1, bool >
    equals(const MMeshInterfaceGridEntity& other) const
    {
      return hostEntity_ == other.hostEntity_;
    }
 
    // Comparator for facets
    template <int d = dim>
    std::enable_if_t< d == 2, bool >
    equals(const MMeshInterfaceGridEntity& other) const
    {
      return hostEntity_ == other.hostEntity_;
    }
 
    bool operator==(const MMeshInterfaceGridEntity& other) const
    {
      return this->equals(other);
    }
 
    bool operator<(const MMeshInterfaceGridEntity& other) const
    {
      return hostEntity_ < other.hostEntity_;
    }
 
    const ConnectedComponent& connectedComponent () const
    {
      return grid_->getConnectedComponent( *this );
    }
 
    bool hasConnectedComponent () const
    {
      return grid_->hasConnectedComponent( *this );
    }
 
    auto father () const
    {
      DUNE_THROW( InvalidStateException, "MMesh entities do no have a father, but a connectedComponent instead!" );
      return *this;
    }
 
    bool hasFather () const {
      return false;
    }
 
    void bindFather( const EntityType& father ) const
    {
      father_ = &father;
    }
 
    LocalGeometry geometryInFather() const
    {
      if constexpr( dim != 1 )
        DUNE_THROW(NotImplemented, "geometryInFather() for dim != 1");
      else
      {
        assert( father_ != nullptr );
 
        auto thisPoints = this->vertex_;
 
        if( isLeaf_ )
          for ( int i = 0; i < 2; ++i )
            thisPoints[i] = geometry().corner(i);
 
        std::array< LocalCoordinate, 2 > local;
        for ( int i = 0; i < 2; ++i )
          local[i] = father_->impl().geometry().local( thisPoints[i] );
 
        return LocalGeometry( local );
      }
    }
 
    const bool isNew () const
    {
      return hasConnectedComponent();
    }
 
    void setIsNew ( bool isNew ) const
    {}
 
    const bool mightVanish () const
    {
      return hostEntity_.first->info().mightVanish;
    }
 
    void setWillVanish ( bool mightVanish ) const
    {
      hostEntity_.first->info().mightVanish = mightVanish;
    }
 
    void mark ( int refCount ) const
    {
      hostEntity_.first->info().mark = refCount;
    }
 
    int getMark () const
    {
      return hostEntity_.first->info().mark;
    }
 
    EntitySeed seed () const
    {
      return EntitySeed(hostEntity_);
    }
 
    int level () const
    {
      // we only have one level
      return 0;
    }
 
    PartitionType partitionType () const
    {
      return grid().getMMesh().partitionHelper().partitionType( grid().entity(hostEntity_) );
    }
 
    Geometry geometry () const
    {
      if (isLeaf_)
        return Geometry( hostEntity_ );
      else
        return Geometry( this->vertex_ );
    }
 
    std::size_t subEntities (std::size_t cc) const
    {
      if( dim == 1 )
        return (cc == 0) ? 1 : 2;
 
      if( dim == 2 )
        return (cc == 0) ? 1 : 3;
    }
 
    template <int cc>
    std::enable_if_t< cc == 0, typename GridImp::template Codim<cc>::Entity >
    subEntity (std::size_t i) const {
      return *this;
    }
 
    template <int cc>
    std::enable_if_t< cc == dim, typename GridImp::template Codim<cc>::Entity >
    subEntity (std::size_t i) const {
      assert( i < subEntities( cc ) );
 
      auto cgalIndex = MMeshInterfaceImpl::computeCGALIndices<MMeshInterfaceEntity, dim>( hostEntity_ );
      return MMeshInterfaceGridEntity<cc, dim, GridImp>(
        grid_, hostEntity_.first->vertex( cgalIndex[i] )
      );
    }
 
    template <int cc>
    std::enable_if_t< cc == 1 && dim == 2, typename GridImp::template Codim<cc>::Entity >
    subEntity (std::size_t i) const {
      assert( i < subEntities( cc ) );
 
      auto cgalIndex = MMeshInterfaceImpl::computeCGALIndices<MMeshInterfaceEntity, dim>( hostEntity_ );
      auto cell = hostEntity_.first;
 
      int v1 = cgalIndex[i==2 ? 1 : 0];
      int v2 = cgalIndex[i==0 ? 1 : 2];
 
      return MMeshInterfaceGridEntity<cc, dim, GridImp>(
        grid_, CGAL::Triple<decltype(cell), int, int>( cell, v1, v2 )
      );
    }
 
    MMeshInterfaceGridLeafIntersectionIterator<GridImp> ileafbegin () const {
      return MMeshInterfaceGridLeafIntersectionIterator<GridImp>(
      grid_,
      hostEntity_);
    }
 
    MMeshInterfaceGridLeafIntersectionIterator<GridImp> ileafend () const {
      return MMeshInterfaceGridLeafIntersectionIterator<GridImp>(
         grid_,
         hostEntity_,
         true);
    }
 
    MMeshInterfaceGridLeafIntersectionIterator<GridImp> ilevelbegin () const {
      return ileafbegin();
    }
 
    MMeshInterfaceGridLeafIntersectionIterator<GridImp> ilevelend () const {
      return ileafend();
    }
 
    MMeshInterfaceGridHierarchicIterator<GridImp> hbegin (int maxlevel) const {
      return MMeshInterfaceGridHierarchicIterator<GridImp>(
      grid_,
      *this,
      maxlevel);
    }
 
    MMeshInterfaceGridHierarchicIterator<GridImp> hend (int maxlevel) const {
      return MMeshInterfaceGridHierarchicIterator<GridImp>(
        grid_,
         *this,
         maxlevel,
         true);
    }
 
    bool isLeaf() const {
      return isLeaf_ && !isNew();
    }
 
    bool wasRefined () const
    {
      return false;
    }
 
    bool mightBeCoarsened () const
    {
      return false;
    }
 
    GeometryType type () const
    {
      return GeometryTypes::simplex(dim);
    }
 
    const MMeshInterfaceEntity& hostEntity () const
    {
      return hostEntity_;
    }
 
    const GridImp& grid () const
    {
      return *grid_;
    }
 
    IdType id() const
    {
      // cache id
      if (id_ == IdType())
      {
        typename IdType::VT idlist( dim+1 );
        for( std::size_t i = 0; i < this->subEntities(dim); ++i )
          if (grid_->canBeMirrored(hostEntity_))
            idlist[i] = this->subEntity<dim>(i).impl().hostEntity()->info().id;
          else
            idlist[i] = -i;
        std::sort( idlist.begin(), idlist.end() );
        id_ = IdType( idlist );
      }
 
      return id_;
    }
 
  private:
    MMeshInterfaceEntity hostEntity_;
 
    mutable IdType id_;
 
    const GridImp* grid_;
 
    bool isLeaf_;
 
  protected:
    VertexStorage vertex_;
 
    mutable const EntityType* father_;
 
  }; // end of MMeshInterfaceGridEntity codim = 0
 
} // namespace Dune
 
#endif