identitygridentity.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_IDENTITYGRIDENTITY_HH
#define DUNE_IDENTITYGRIDENTITY_HH
 
#include <dune/grid/common/grid.hh>
 
namespace Dune {
 
 
  // Forward declarations
 
  template<int codim, int dim, class GridImp>
  class IdentityGridEntity;
 
  template<int codim, class GridImp, typename HostEntityPointer>
  class IdentityGridEntityPointer;
 
  template<int codim, PartitionIteratorType pitype, class GridImp>
  class IdentityGridLevelIterator;
 
  template<class GridImp>
  class IdentityGridLevelIntersectionIterator;
 
  template<class GridImp>
  class IdentityGridLeafIntersectionIterator;
 
  template<class GridImp>
  class IdentityGridHierarchicIterator;
 
 
  // External forward declarations
  template< class Grid >
  struct HostGridAccess;
 
 
  //**********************************************************************
  //
  // --IdentityGridEntity
  // --Entity
  //
  template<int codim, int dim, class GridImp>
  class IdentityGridEntity :
    public EntityDefaultImplementation <codim,dim,GridImp,IdentityGridEntity>
  {
 
    template <class GridImp_>
    friend class IdentityGridLevelIndexSet;
 
    template <class GridImp_>
    friend class IdentityGridLeafIndexSet;
 
    template <class GridImp_>
    friend class IdentityGridLocalIdSet;
 
    template <class GridImp_>
    friend class IdentityGridGlobalIdSet;
 
    template<int,typename, typename>
    friend class IdentityGridEntityPointer;
 
    friend struct HostGridAccess< typename remove_const< GridImp >::type >;
 
 
  private:
 
    typedef typename GridImp::ctype ctype;
 
    // The codimension of this entitypointer wrt the host grid
    enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension + codim};
 
    // EntityPointer to the equivalent entity in the host grid
    typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::Entity HostGridEntity;
 
 
  public:
 
    typedef typename GridImp::template Codim<codim>::Geometry Geometry;
 
    typedef typename GridImp::template Codim<codim>::EntitySeed EntitySeed;
 
    IdentityGridEntity()
      : identityGrid_(nullptr)
    {}
 
    IdentityGridEntity(const GridImp* identityGrid, const HostGridEntity& hostEntity)
      : hostEntity_(hostEntity)
      , identityGrid_(identityGrid)
    {}
 
    IdentityGridEntity(const GridImp* identityGrid, HostGridEntity&& hostEntity)
      : hostEntity_(std::move(hostEntity))
      , identityGrid_(identityGrid)
    {}
 
    IdentityGridEntity(const IdentityGridEntity& original)
      : hostEntity_(original.hostEntity_)
      , identityGrid_(original.identityGrid_)
    {}
 
    IdentityGridEntity(IdentityGridEntity&& original)
      : hostEntity_(std::move(original.hostEntity_))
      , identityGrid_(original.identityGrid_)
    {}
 
    IdentityGridEntity& operator=(const IdentityGridEntity& original)
    {
      if (this != &original)
      {
        identityGrid_ = original.identityGrid_;
        hostEntity_ = original.hostEntity_;
      }
      return *this;
    }
 
    IdentityGridEntity& operator=(IdentityGridEntity&& original)
    {
      if (this != &original)
      {
        identityGrid_ = original.identityGrid_;
        hostEntity_ = std::move(original.hostEntity_);
      }
      return *this;
    }
 
    bool equals(const IdentityGridEntity& other) const
    {
      return hostEntity_ == other.hostEntity_;
    }
 
    bool hasFather () const {
      return hostEntity_.hasFather();
    }
 
    EntitySeed seed () const
    {
      return EntitySeed(hostEntity_);
    }
 
    int level () const {
      return hostEntity_.level();
    }
 
 
    PartitionType partitionType () const {
      return hostEntity_.partitionType();
    }
 
 
    template<int cc> int count () const {
      return hostEntity_.template count<cc>();
    }
 
 
    Geometry geometry () const
    {
      return Geometry( hostEntity_.geometry() );
    }
 
 
    HostGridEntity hostEntity_;
 
  private:
 
    const GridImp* identityGrid_;
 
  };
 
 
 
 
  //***********************
  //
  //  --IdentityGridEntity
  //
  //***********************
  template<int dim, class GridImp>
  class IdentityGridEntity<0,dim,GridImp> :
    public EntityDefaultImplementation<0,dim,GridImp, IdentityGridEntity>
  {
    friend struct HostGridAccess< typename remove_const< GridImp >::type >;
 
    template<int,typename, typename>
    friend class IdentityGridEntityPointer;
 
  public:
 
    // The codimension of this entitypointer wrt the host grid
    enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension};
 
    // EntityPointer to the equivalent entity in the host grid
    typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::Entity HostGridEntity;
 
    typedef typename GridImp::template Codim<0>::Geometry Geometry;
 
    typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
 
    typedef IdentityGridLevelIntersectionIterator<GridImp> LevelIntersectionIterator;
 
    typedef IdentityGridLeafIntersectionIterator<GridImp> LeafIntersectionIterator;
 
    typedef IdentityGridHierarchicIterator<GridImp> HierarchicIterator;
 
    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
 
 
    IdentityGridEntity()
      : identityGrid_(nullptr)
    {}
 
    IdentityGridEntity(const GridImp* identityGrid, const HostGridEntity& hostEntity)
      : hostEntity_(hostEntity)
      , identityGrid_(identityGrid)
    {}
 
    IdentityGridEntity(const GridImp* identityGrid, HostGridEntity&& hostEntity)
      : hostEntity_(std::move(hostEntity))
      , identityGrid_(identityGrid)
    {}
 
    IdentityGridEntity(const IdentityGridEntity& original)
      : hostEntity_(original.hostEntity_)
      , identityGrid_(original.identityGrid_)
    {}
 
    IdentityGridEntity(IdentityGridEntity&& original)
      : hostEntity_(std::move(original.hostEntity_))
      , identityGrid_(original.identityGrid_)
    {}
 
    IdentityGridEntity& operator=(const IdentityGridEntity& original)
    {
      if (this != &original)
      {
        identityGrid_ = original.identityGrid_;
        hostEntity_ = original.hostEntity_;
      }
      return *this;
    }
 
    IdentityGridEntity& operator=(IdentityGridEntity&& original)
    {
      if (this != &original)
      {
        identityGrid_ = original.identityGrid_;
        hostEntity_ = std::move(original.hostEntity_);
      }
      return *this;
    }
 
    bool equals(const IdentityGridEntity& other) const
    {
      return hostEntity_ == other.hostEntity_;
    }
 
    bool hasFather () const {
      return hostEntity_.hasFather();
    }
 
    EntitySeed seed () const
    {
      return EntitySeed(hostEntity_);
    }
 
    int level () const
    {
      return hostEntity_.level();
    }
 
 
    PartitionType partitionType () const {
      return hostEntity_.partitionType();
    }
 
 
    Geometry geometry () const
    {
      return Geometry( hostEntity_.geometry() );
    }
 
 
    template<int cc>
    int count () const
    {
      return hostEntity_.template count<cc>();
    }
 
 
    unsigned int subEntities (unsigned int codim) const
    {
      return hostEntity_.subEntities(codim);
    }
 
 
    template<int cc>
    typename GridImp::template Codim<cc>::Entity subEntity (int i) const {
      return IdentityGridEntity<cc,dim,GridImp>(identityGrid_, hostEntity_.template subEntity<cc>(i));
    }
 
 
    IdentityGridLevelIntersectionIterator<GridImp> ilevelbegin () const {
      return IdentityGridLevelIntersectionIterator<GridImp>(
        identityGrid_,
        identityGrid_->getHostGrid().levelGridView(level()).ibegin(hostEntity_));
    }
 
 
    IdentityGridLevelIntersectionIterator<GridImp> ilevelend () const {
      return IdentityGridLevelIntersectionIterator<GridImp>(
        identityGrid_,
        identityGrid_->getHostGrid().levelGridView(level()).iend(hostEntity_));
    }
 
 
    IdentityGridLeafIntersectionIterator<GridImp> ileafbegin () const {
      return IdentityGridLeafIntersectionIterator<GridImp>(
        identityGrid_,
        identityGrid_->getHostGrid().leafGridView().ibegin(hostEntity_));
    }
 
 
    IdentityGridLeafIntersectionIterator<GridImp> ileafend () const {
      return IdentityGridLeafIntersectionIterator<GridImp>(
        identityGrid_,
        identityGrid_->getHostGrid().leafGridView().iend(hostEntity_));
    }
 
 
    bool isLeaf() const {
      return hostEntity_.isLeaf();
    }
 
 
    typename GridImp::template Codim<0>::Entity father () const {
      return IdentityGridEntity(identityGrid_, hostEntity_.father());
    }
 
 
    LocalGeometry geometryInFather () const
    {
      return LocalGeometry( hostEntity_.geometryInFather() );
    }
 
 
    IdentityGridHierarchicIterator<GridImp> hbegin (int maxLevel) const
    {
      return IdentityGridHierarchicIterator<const GridImp>(identityGrid_, *this, maxLevel);
    }
 
 
    IdentityGridHierarchicIterator<GridImp> hend (int maxLevel) const
    {
      return IdentityGridHierarchicIterator<const GridImp>(identityGrid_, *this, maxLevel, true);
    }
 
 
    bool wasRefined () const
    {
      if (identityGrid_->adaptationStep!=GridImp::adaptDone)
        return false;
 
      int level = this->level();
      int index = identityGrid_->levelIndexSet(level).index(*this);
      return identityGrid_->refinementMark_[level][index];
    }
 
 
    bool mightBeCoarsened () const
    {
      return true;
    }
 
 
    // /////////////////////////////////////////
    //   Internal stuff
    // /////////////////////////////////////////
 
 
    HostGridEntity hostEntity_;
    const GridImp* identityGrid_;
 
  private:
 
    typedef typename GridImp::ctype ctype;
 
  }; // end of IdentityGridEntity codim = 0
 
 
} // namespace Dune
 
 
#endif