entity.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_CURVED_SURFACE_GRID_ENTITY_HH
#define DUNE_CURVED_SURFACE_GRID_ENTITY_HH

#include <dune/common/std/optional.hh>
#include <dune/geometry/referenceelements.hh>

#include <dune/grid/common/grid.hh>

namespace Dune
{
  namespace CGeo
  {

    // Internal Forward Declarations
    // -----------------------------

    /** \class EntityBase
     *  \brief actual implementation of the entity
     *  \ingroup CurvedGeo
     *
     *  \tparam  codim  codimension of the entity
     *  \tparam  Grid   CurvedSurfaceGrid, this entity belongs to
     */
    template< int codim, class Grid >
    class EntityBase;

    /** \class Entity
     *  \brief DUNE-conform implementation of the entity
     *  \ingroup CurvedGeo
     *
     *  This class merely changes the template parameters of the entity to make
     *  DUNE happy. The actual implementation of the entity can be found in
     *  EntityBase.
     *
     *  \tparam  codim  codimension of the entity
     *  \tparam  dim    dimension of the Grid (redundant information)
     *  \tparam  Grid   CurvedSurfaceGrid, this entity belongs to
     */
    template< int codim, int dim, class Grid >
    class Entity;



    // External Forward Declarations
    // -----------------------------

    template< class Grid >
    class HierarchicIterator;

    template< class Grid, class HostIntersectionIterator >
    class IntersectionIterator;



    // EntityBase (real)
    // -----------------

    /** \copydoc EntityBase
     *
     *  This specialization implements the case, where the host grid provides
     *  the entity for this codimension, i.e., \em fake = \b false.
     *
     *  \nosubgrouping
     */
    template< int codim, class Grid >
    class EntityBase
    {
      using Traits = typename std::remove_const_t<Grid>::Traits;

    public:
      /** \name Attributes
       *  \{ */

      //! codimensioon of the entity
      static const int codimension = codim;
      //! dimension of the grid
      static const int dimension = Traits::dimension;
      //! dimension of the entity
      static const int mydimension = dimension - codimension;
      //! dimension of the world
      static const int dimensionworld = Traits::dimensionworld;

      /** \} */

      /** \name Types Required by DUNE
       *  \{ */

      //! coordinate type of the grid
      using ctype = typename Traits::ctype;

      //! type of corresponding geometry
      using Geometry = typename Traits::template Codim<codimension>::Geometry;

      /** \} */

    private:
      using HostGrid = typename Traits::HostGrid;

    public:
      /** \name Host Types
       *  \{ */

      //! type of corresponding host entity
      using HostEntity = typename HostGrid::template Codim<codimension>::Entity;

      //! type of corresponding entity seed
      using EntitySeed = typename Traits::template Codim<codimension>::EntitySeed;

      //! type of host elements, i.e., of host entities of codimension 0
      using HostElement = typename HostGrid::template Codim<0>::Entity;

      /** \} */

    private:
      using GeometryImpl = typename Traits::template Codim<codimension>::GeometryImpl;
      using HostGeometry = typename HostGrid::template Codim<codimension>::Geometry;

    public:
      /** \name Construction, Initialization and Destruction
       *  \{ */

      EntityBase () = default;

      // Construct the entity from an entity seed
      EntityBase (const Grid& grid, const EntitySeed& seed)
        : hostEntity_(grid.hostGrid().entity(seed.impl().hostEntitySeed()))
        , grid_(&grid)
      {}

      // construct the entity from a subentity of a host-entity
      EntityBase (const Grid& grid, const HostElement& hostElement, int i)
        : hostEntity_(hostElement.template subEntity<codim>(i))
        , grid_(&grid)
      {}

      // construct the entity from a host-entity and a transformed geometry
      EntityBase (const GeometryImpl& geo, const HostEntity& hostEntity)
        : hostEntity_(hostEntity)
        , grid_(&geo.grid())
        , geo_(geo)
      {}

      // construct the entity from a host-entity and a transformed geometry
      EntityBase (const GeometryImpl& geo, HostEntity&& hostEntity)
        : hostEntity_(std::move(hostEntity))
        , grid_(&geo.grid())
        , geo_(geo)
      {}

      // construct the entity from a host-entity
      EntityBase (const Grid& grid, const HostEntity& hostEntity)
        : hostEntity_(hostEntity)
        , grid_(&grid)
      {}

      // construct the entity from a host-entity
      EntityBase (const Grid& grid, HostEntity&& hostEntity)
        : hostEntity_(std::move(hostEntity))
        , grid_(&grid)
      {}

      /** \} */

      //! compare two entities
      bool equals (const EntityBase& other) const
      {
        return hostEntity_ == other.hostEntity_;
      }

    public:
      /** \name Methods Shared by Entities of All Codimensions
       *  \{ */

      //! obtain the name of the corresponding reference element
      /**
       *  This type can be used to access the DUNE reference element.
       */
      GeometryType type () const
      {
        return hostEntity().type();
      }

      //! obtain the level of this entity
      int level () const
      {
        return hostEntity().level();
      }

      //! obtain the partition type of this entity
      PartitionType partitionType () const
      {
        return hostEntity().partitionType();
      }

      GeometryImpl makeGeometry () const
      {
        auto ff = [f=grid().coordFunction(),geo=hostEntity().geometry()](const auto& local) {
          return f(geo.global(local));
        };
        return GeometryImpl(type(), ff);
      }

      //! obtain the geometry of this entity
      /**
       *  Each DUNE entity encapsulates a geometry object, representing the map
       *  from the reference element to world coordinates. Wrapping the geometry
       *  is the main objective of the CurvedSurfaceGrid.
       *
       *  The CurvedSurfaceGrid provides geometries by parametrization with local basis
       *  functions, using the CurvedGeometry.
       *
       *  \returns a new curvedgeometry object
       */
      Geometry geometry () const
      {
        if (!geo_) {
          if (grid_->useGeometryCaching())
          {
            auto const& idSet = grid_->hostGrid().localIdSet();
            auto& cached_geo = std::get<codim>(grid_->geometryCache_)[id(idSet)];

            // if geometry is already in cache
            if (cached_geo)
              geo_ = *cached_geo;
            // otherwise cache a new constructed geometry
            else {
              geo_ = makeGeometry();
              *cached_geo = *geo_;
            }
          }
          else
          {
            geo_ = makeGeometry();
          }
        }

        return Geometry(*geo_);
      }

      //! obtain number of sub-entities of the current entity
      unsigned int subEntities (unsigned int cc) const
      {
        return hostEntity().subEntities( cc );
      }

      //! return EntitySeed of host grid entity
      EntitySeed seed () const
      {
        return typename EntitySeed::Implementation(hostEntity().seed());
      }

      /** \} */


      /** \name Methods Supporting the Grid Implementation
       *  \{ */

      const Grid& grid () const
      {
        assert(grid_);
        return *grid_;
      }

      //! return the wrapped host-entity
      const HostEntity& hostEntity () const
      {
        return hostEntity_;
      }

      //! initiliaze an entity by a corresponding host-entity
      /**
       *  \param[in]  hostEntity  reference to the host entity
       */
      void initialize (const HostEntity& hostEntity)
      {
        hostEntity_ = hostEntity;
      }

      //! obtain the entity's index from a host IndexSet
      /**
       *  \internal This method is provided by the entity, because its
       *  implementation is different for fake and non-fake entities.
       *
       *  \param[in]  indexSet  host IndexSet to use
       */
      template< class HostIndexSet >
      typename HostIndexSet::IndexType
      index (const HostIndexSet& indexSet) const
      {
        return indexSet.template index<codimension>(hostEntity());
      }

      //! obtain the index of a subentity from a host IndexSet
      /**
       *  \internal This method is provided by the entity, because its
       *  implementation is different for fake and non-fake entities.
       *
       *  \param[in]  indexSet  host IndexSet to use
       *  \param[in]  i         number of the subentity
       *  \param[in]  cd        codimension of the subentity
       */
      template< class HostIndexSet >
      typename HostIndexSet::IndexType
      subIndex (const HostIndexSet& indexSet, int i, unsigned int cd) const
      {
        return indexSet.subIndex(hostEntity(), i, cd);
      }

      //! check whether the entity is contained in a host index set
      /**
       *  \internal This method is provided by the entity, because its
       *  implementation is different for fake and non-fake entities.
       *
       *  \param  indexSet  host IndexSet to use
       */
      template< class HostIndexSet >
      bool isContained (const HostIndexSet& indexSet) const
      {
        return indexSet.contains(hostEntity());
      }

      //! obtain the entity's id from a host IdSet
      /**
       *  \internal This method is provided by the entity, because its
       *  implementation is different for fake and non-fake entities.
       *
       *  \param  idSet  host IdSet to use
       */
      template< class HostIdSet >
      typename HostIdSet::IdType id (const HostIdSet& idSet) const
      {
        return idSet.template id<codimension>(hostEntity());
      }

      /** \} */

    private:
      HostEntity hostEntity_ = {};
      const Grid* grid_ = nullptr;
      mutable Std::optional<GeometryImpl> geo_;
    };


    // Entity
    // ------

    template< int codim, int dim, class Grid >
    class Entity
        : public EntityBase<codim, Grid>
    {
      using Super = EntityBase<codim, Grid>;

    public:
      // import constructors from base class
      using Super::Super;
    };


    // Entity for codimension 0
    // ------------------------

    template< int dim, class Grid >
    class Entity<0, dim, Grid>
        : public EntityBase<0, Grid>
    {
      using Super = EntityBase<0, Grid>;

      using Traits = typename std::remove_const_t<Grid>::Traits;
      using HostGrid = typename Traits::HostGrid;

    public:

      /** \name Types Required by DUNE
       *  \{ */

      //! type of corresponding local geometry
      using LocalGeometry = typename Traits::template Codim<0>::LocalGeometry;

      //! facade type for entities
      using EntityFacade = Dune::Entity<0, dim, Grid, Dune::CGeo::Entity>;

      //! type of hierarchic iterator
      using HierarchicIterator = typename Traits::HierarchicIterator;

      //! type of leaf intersection iterator
      using LeafIntersectionIterator = typename Traits::LeafIntersectionIterator;

      //! type of level intersection iterator
      using LevelIntersectionIterator = typename Traits::LevelIntersectionIterator;

      /** \} */

      // import constructors from base class
      using Super::Super;

      template< int codim >
      typename Grid::template Codim<codim>::Entity subEntity (int i) const
      {
        using EntityImpl = typename Traits::template Codim<codim>::EntityImpl;
        return EntityImpl(Super::grid(), Super::hostEntity(), i);
      }

      LevelIntersectionIterator ilevelbegin () const
      {
        using LevelIntersectionIteratorImpl = CGeo::IntersectionIterator<Grid, typename HostGrid::LevelIntersectionIterator>;
        return LevelIntersectionIteratorImpl(*this, Super::hostEntity().ilevelbegin());
      }

      LevelIntersectionIterator ilevelend () const
      {
        using LevelIntersectionIteratorImpl = CGeo::IntersectionIterator<Grid, typename HostGrid::LevelIntersectionIterator>;
        return LevelIntersectionIteratorImpl(*this, Super::hostEntity().ilevelend());
      }

      LeafIntersectionIterator ileafbegin () const
      {
        using LeafIntersectionIteratorImpl = CGeo::IntersectionIterator<Grid, typename HostGrid::LeafIntersectionIterator>;
        return LeafIntersectionIteratorImpl(*this, Super::hostEntity().ileafbegin());
      }

      LeafIntersectionIterator ileafend () const
      {
        using LeafIntersectionIteratorImpl = CGeo::IntersectionIterator<Grid, typename HostGrid::LeafIntersectionIterator>;
        return LeafIntersectionIteratorImpl(*this, Super::hostEntity().ileafend());
      }

      bool hasBoundaryIntersections () const
      {
        return Super::hostEntity().hasBoundaryIntersections();
      }

      bool isLeaf () const
      {
        return Super::hostEntity().isLeaf();
      }

      EntityFacade father () const
      {
        return Entity(Super::grid(), Super::hostEntity().father());
      }

      bool hasFather () const
      {
        return Super::hostEntity().hasFather();
      }

      LocalGeometry geometryInFather () const
      {
        return Super::hostEntity().geometryInFather();
      }

      HierarchicIterator hbegin (int maxLevel) const
      {
        using HierarchicIteratorImpl = CGeo::HierarchicIterator<Grid>;
        return HierarchicIteratorImpl(Super::grid(), Super::hostEntity().hbegin(maxLevel));
      }

      HierarchicIterator hend (int maxLevel) const
      {
        using HierarchicIteratorImpl = CGeo::HierarchicIterator<Grid>;
        return HierarchicIteratorImpl(Super::grid(), Super::hostEntity().hend(maxLevel));
      }

      bool isRegular () const
      {
        return Super::hostEntity().isRegular();
      }

      bool isNew () const
      {
        return Super::hostEntity().isNew();
      }

      bool mightVanish () const
      {
        return Super::hostEntity().mightVanish();
      }
    };

  } // namespace CGeo

} // namespace Dune

#endif // DUNE_CURVED_SURFACE_GRID_ENTITY_HH