common/entity.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_GRID_COMMON_ENTITY_HH
#define DUNE_GRID_COMMON_ENTITY_HH

#include <type_traits>

#include <dune/common/iteratorrange.hh>
#include <dune/common/typetraits.hh>

#include <dune/geometry/dimension.hh>
#include <dune/geometry/referenceelements.hh>

#include "grid.hh"
#include "rangegenerators.hh"

namespace Dune
{

  template<int cd, int dim, class GridImp, template<int,int,class> class EntityImp>
  class Entity
  {
  public:
    typedef EntityImp< cd, dim, GridImp > Implementation;

    Implementation &impl () { return realEntity; }
    const Implementation &impl () const { return realEntity; }

  protected:
    Implementation realEntity;

  public:

    //===========================================================
    //===========================================================

    typedef typename GridImp::template Codim<cd>::Geometry Geometry;

    typedef typename GridImp::template Codim<cd>::EntitySeed EntitySeed;

    constexpr static int codimension = cd;

    constexpr static int dimension = dim;

    constexpr static int mydimension = dim - cd;



    //===========================================================
    //===========================================================

    int level () const { return realEntity.level(); }

    PartitionType partitionType () const { return realEntity.partitionType(); }

    Geometry geometry () const { return realEntity.geometry(); }

    GeometryType type () const { return realEntity.type(); }

    unsigned int subEntities ( unsigned int codim ) const
    {
      return realEntity.subEntities(codim);
    }

    EntitySeed seed () const { return realEntity.seed(); }

    bool operator==(const Entity& other) const
    {
      return realEntity.equals(other.realEntity);
    }

    bool operator!=(const Entity& other) const
    {
      return !realEntity.equals(other.realEntity);
    }

    Entity()
    {}

    Entity(const Entity& other)
      : realEntity(other.realEntity)
    {}

    Entity(Entity&& other)
      : realEntity(std::move(other.realEntity))
    {}

    Entity& operator=(const Entity& other)
    {
      realEntity = other.realEntity;
      return *this;
    }

    Entity& operator=(Entity&& other)
    {
      realEntity = std::move(other.realEntity);
      return *this;
    }


    //===========================================================
    //===========================================================

    Entity(const EntityImp<cd,dim,GridImp> & e) : realEntity(e) {}

    Entity(EntityImp<cd,dim,GridImp> && e) : realEntity(std::move(e)) {}

  };

  template<int dim, class GridImp, template<int,int,class> class EntityImp>
  class Entity <0,dim,GridImp,EntityImp>
  {
  public:
    typedef EntityImp< 0, dim, GridImp > Implementation;

    Implementation &impl () { return realEntity; }
    const Implementation &impl () const { return realEntity; }

  protected:
    Implementation realEntity;

  public:

    //===========================================================
    //===========================================================

    typedef typename GridImp::template Codim<0>::Geometry Geometry;

    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;

    typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;

    template <int cd>
    struct Codim
    {
      typedef typename GridImp::template Codim<cd>::Entity Entity;
    };

    typedef typename GridImp::HierarchicIterator HierarchicIterator;

    constexpr static int codimension = 0;

    constexpr static int dimension = dim;

    constexpr static int mydimension = dim;


    //===========================================================
    //===========================================================

    int level () const { return realEntity.level(); }

    PartitionType partitionType () const { return realEntity.partitionType(); }

    Geometry geometry () const { return realEntity.geometry(); }

    unsigned int subEntities ( unsigned int codim ) const
    {
      return realEntity.subEntities(codim);
    }

    GeometryType type () const { return realEntity.type(); }

    EntitySeed seed () const { return realEntity.seed(); }

    bool operator==(const Entity& other) const
    {
      return realEntity.equals(other.realEntity);
    }

    bool operator!=(const Entity& other) const
    {
      return !realEntity.equals(other.realEntity);
    }

    Entity()
    {}

    Entity(const Entity& other)
      : realEntity(other.realEntity)
    {}

    Entity(Entity&& other)
      : realEntity(std::move(other.realEntity))
    {}

    Entity& operator=(const Entity& other)
    {
      realEntity = other.realEntity;
      return *this;
    }

    Entity& operator=(Entity&& other)
    {
      realEntity = std::move(other.realEntity);
      return *this;
    }


    //===========================================================
    //===========================================================

    template< int codim >
    typename Codim< codim >::Entity
    subEntity ( int i ) const
    {
      return realEntity.template subEntity< codim >( i );
    }

    Entity father () const
    {
      return realEntity.father();
    }

    bool hasFather () const
    {
      return realEntity.hasFather();
    }

    bool isLeaf () const
    {
      return realEntity.isLeaf();
    }

    bool isRegular() const { return realEntity.isRegular(); }

    LocalGeometry geometryInFather () const { return realEntity.geometryInFather(); }

    HierarchicIterator hbegin (int maxLevel) const
    {
      return realEntity.hbegin(maxLevel);
    }

    HierarchicIterator hend (int maxLevel) const
    {
      return realEntity.hend(maxLevel);
    }

    bool isNew () const { return realEntity.isNew(); }

    bool mightVanish () const { return realEntity.mightVanish(); }

    bool hasBoundaryIntersections () const { return realEntity.hasBoundaryIntersections(); }


    //===========================================================
    //===========================================================

    Entity(const EntityImp<0,dim,GridImp> & e) : realEntity(e) {}

    Entity(EntityImp<0,dim,GridImp> && e) : realEntity(std::move(e)) {}

  };



  //********************************************************************
  template<int cd, int dim, class GridImp, template<int,int,class> class EntityImp>
  class EntityDefaultImplementation
  {
  public:
    constexpr static int codimension = cd;

    constexpr static int dimension = dim;

    constexpr static int mydimension = dim - cd;

    typedef typename GridImp::template Codim<cd>::EntitySeed EntitySeed;

    unsigned int subEntities ( unsigned int codim ) const
    {
      typedef typename std::remove_const< GridImp >::type::ctype ctype;
      return ReferenceElements< ctype, mydimension >::general( asImp().type() ).size( codim - codimension );
    }

    GeometryType type () const { return asImp().geometry().type(); }

  private:
    EntityImp<cd,dim,GridImp>& asImp ()
    {
      return static_cast<EntityImp<cd,dim,GridImp>&>(*this);
    }
    const EntityImp<cd,dim,GridImp>& asImp () const
    {
      return static_cast<const EntityImp<cd,dim,GridImp>&>(*this);
    }
  }; // end EntityDefaultImplementation

  //********************************************************************
  template<int dim, class GridImp, template<int,int,class> class EntityImp>
  class EntityDefaultImplementation <0,dim,GridImp,EntityImp>
  {
  public:
    constexpr static int codimension = 0;

    constexpr static int dimension = dim;

    constexpr static int mydimension = dim;

    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;

    bool isRegular() const { return true; }

    unsigned int subEntities ( unsigned int codim ) const
    {
      typedef typename std::remove_const< GridImp >::type::ctype ctype;
      return ReferenceElements< ctype, mydimension >::general( asImp().type() ).size( codim - codimension );
    }

    GeometryType type () const { return asImp().geometry().type(); }

    bool isNew () const { return false; }

    bool mightVanish () const { return false; }

    bool hasBoundaryIntersections () const
    {
      typedef typename GridImp::LevelIntersectionIterator IntersectionIterator;
      IntersectionIterator end = asImp().ilevelend();
      for (IntersectionIterator it = asImp().ilevelbegin(); it != end; ++it)
        if( it->boundary() )
          return true;

      return false;
    }

  private:
    //  Barton-Nackman trick
    EntityImp<0,dim,GridImp>& asImp () { return static_cast<EntityImp<0,dim,GridImp>&>(*this); }
    const EntityImp<0,dim,GridImp>& asImp () const { return static_cast<const EntityImp<0,dim,GridImp>&>(*this); }
  };


  template< int cd, int dim, class GridImp, template<int,int,class> class EntityImp >
  auto referenceElement(const Entity< cd, dim, GridImp, EntityImp >& entity )
    -> decltype(referenceElement<typename GridImp::ctype,GridImp::template Codim<cd>::Geometry::mydimension>(entity.type()))
  {
    typedef typename GridImp::template Codim<cd>::Geometry Geo;
    return referenceElement< typename Geo::ctype, Geo::mydimension >(entity.type());
  }
}

#endif // DUNE_GRID_COMMON_ENTITY_HH