identitygridentity.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- 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, 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;

    friend struct HostGridAccess< typename std::remove_const< GridImp >::type >;


  private:

    typedef typename GridImp::ctype ctype;

    // The codimension of this entity wrt the host grid
    constexpr static int CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension + codim;

    // 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();
    }

    unsigned int subEntities (unsigned int cc) const
    {
      return hostEntity_.subEntities(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 std::remove_const< GridImp >::type >;

  public:

    // The codimension of this entitypointer wrt the host grid
    constexpr static int CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension;

    // 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() );
    }


    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