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

      //! 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_) {
          // mapping from local to curved global coordinates
          auto ff = [f=grid().coordFunction(),geo=hostEntity().geometry()](const auto& local) {
            return f(geo.global(local));
          };

          if (grid_->useGeometryCaching()) {
            auto const& idSet = grid_->hostGrid().localIdSet();
            auto id = idSet.id(hostEntity());

            auto& cache = std::get<codim>(grid_->geometryCache_);
            auto [it,inserted] = cache.try_emplace(id, type(), ff);

            geo_ = it->second;
          }
          else {
            geo_ = GeometryImpl(type(), ff);
          }
        }

        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_;
      }

      /** \} */

    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 IteratorImpl = CGeo::IntersectionIterator<Grid, typename HostGrid::LevelIntersectionIterator>;
        return IteratorImpl(*this, Super::hostEntity().ilevelbegin());
      }

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

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

      LeafIntersectionIterator ileafend () const
      {
        using IteratorImpl = CGeo::IntersectionIterator<Grid, typename HostGrid::LeafIntersectionIterator>;
        return IteratorImpl(*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 IteratorImpl = CGeo::HierarchicIterator<Grid>;
        return IteratorImpl(Super::grid(), Super::hostEntity().hbegin(maxLevel));
      }

      HierarchicIterator hend (int maxLevel) const
      {
        using IteratorImpl = CGeo::HierarchicIterator<Grid>;
        return IteratorImpl(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