entity.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GEOGRID_ENTITY_HH
#define DUNE_GEOGRID_ENTITY_HH
 
#include <dune/common/nullptr.hh>
 
#include <dune/geometry/referenceelements.hh>
 
#include <dune/grid/common/grid.hh>
#include <dune/grid/geometrygrid/capabilities.hh>
#include <dune/grid/geometrygrid/cornerstorage.hh>
 
namespace Dune
{
 
  namespace GeoGrid
  {
 
    // Internal Forward Declarations
    // -----------------------------
 
    template< int codim, class Grid, bool fake = !(Capabilities::hasHostEntity< Grid, codim >::v) >
    class EntityBase;
 
    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)
    // -----------------
 
    template< int codim, class Grid >
    class EntityBase< codim, Grid, false >
    {
      typedef typename remove_const< Grid >::type::Traits Traits;
 
    public:
      static const int codimension = codim;
      static const int dimension = Traits::dimension;
      static const int mydimension = dimension - codimension;
      static const int dimensionworld = Traits::dimensionworld;
 
      static const bool fake = false;
 
      typedef typename Traits::ctype ctype;
 
      typedef typename Traits::template Codim< codimension >::Geometry Geometry;
    private:
      typedef typename Traits::HostGrid HostGrid;
      typedef typename Traits::CoordFunction CoordFunction;
 
    public:
      typedef typename HostGrid::template Codim< codimension >::Entity HostEntity;
      typedef typename HostGrid::template Codim< codimension >::EntityPointer HostEntityPointer;
 
      typedef typename Traits::template Codim< codimension >::EntitySeed EntitySeed;
 
      typedef typename HostGrid::template Codim< 0 >::Entity HostElement;
      typedef typename Traits::template Codim< codim >::GeometryImpl GeometryImpl;
 
    private:
      typedef typename HostGrid::template Codim< codimension >::Geometry HostGeometry;
 
      typedef GeoGrid::CoordVector< mydimension, Grid, fake > CoordVector;
 
    public:
      explicit EntityBase ( const Grid &grid )
        : geo_( grid ),
          hostEntity_( nullptr )
      {}
 
      explicit EntityBase ( const GeometryImpl &geo )
        : geo_( geo ),
          hostEntity_( nullptr )
      {}
 
      EntityBase ( const EntityBase &other )
        : geo_( other.geo_ ),
          hostEntity_( nullptr )
      {}
 
      const EntityBase &operator= ( const EntityBase &other )
      {
        geo_ = other.geo_;
        hostEntity_ = nullptr;
        return *this;
      }
 
      operator bool () const { return bool( hostEntity_ ); }
 
    public:
      GeometryType type () const
      {
        return hostEntity().type();
      }
 
      int level () const
      {
        return hostEntity().level();
      }
 
      PartitionType partitionType () const
      {
        return hostEntity().partitionType();
      }
 
      Geometry geometry () const
      {
        if( !geo_ )
        {
          CoordVector coords( hostEntity(), grid().coordFunction() );
          geo_ = GeometryImpl( grid(), type(), coords );
        }
        return Geometry( geo_ );
      }
 
      EntitySeed seed () const { return typename EntitySeed::Implementation( hostEntity().seed() ); }
      const Grid &grid () const { return geo_.grid(); }
 
      const HostEntity &hostEntity () const
      {
        assert( *this );
        return *hostEntity_;
      }
 
      void initialize ( const HostEntity &hostEntity ) { hostEntity_ = &hostEntity; }
 
      template< class HostIndexSet >
      typename HostIndexSet::IndexType
      index ( const HostIndexSet &indexSet ) const
      {
        return indexSet.template index< codimension >( hostEntity() );
      }
 
      template< class HostIndexSet >
      typename HostIndexSet::IndexType
      subIndex ( const HostIndexSet &indexSet, int i, unsigned int cd ) const
      {
        return indexSet.subIndex( hostEntity(), i, cd );
      }
 
      template< class HostIndexSet >
      bool isContained ( const HostIndexSet &indexSet ) const
      {
        return indexSet.contains( hostEntity() );
      }
 
      template< class HostIdSet >
      typename HostIdSet::IdType id ( const HostIdSet &idSet ) const
      {
        return idSet.template id< codimension >( hostEntity() );
      }
    private:
      mutable GeometryImpl geo_;
      const HostEntity *hostEntity_;
    };
 
 
 
    // EntityBase (fake)
    // -----------------
 
    template< int codim, class Grid >
    class EntityBase< codim, Grid, true >
    {
      typedef typename remove_const< Grid >::type::Traits Traits;
 
    public:
      static const int codimension = codim;
      static const int dimension = Traits::dimension;
      static const int mydimension = dimension - codimension;
      static const int dimensionworld = Traits::dimensionworld;
 
      static const bool fake = true;
      typedef typename Traits::ctype ctype;
 
      typedef typename Traits::template Codim< codimension >::Geometry Geometry;
    private:
      typedef typename Traits::HostGrid HostGrid;
      typedef typename Traits::CoordFunction CoordFunction;
 
    public:
      typedef typename HostGrid::template Codim< codimension >::Entity HostEntity;
      typedef typename HostGrid::template Codim< codimension >::EntityPointer HostEntityPointer;
 
      typedef typename Traits::template Codim< codimension >::EntitySeed EntitySeed;
 
      typedef typename HostGrid::template Codim< 0 >::Entity HostElement;
      typedef typename Traits::template Codim< codimension >::GeometryImpl GeometryImpl;
 
    private:
      typedef typename HostGrid::template Codim< 0 >::Geometry HostGeometry;
      typedef typename HostGrid::template Codim< dimension >::EntityPointer HostVertexPointer;
 
      typedef GeoGrid::CoordVector< mydimension, Grid, fake > CoordVector;
 
    public:
      EntityBase ( const Grid &grid, int subEntity )
        : geo_( grid ),
          hostElement_( nullptr ),
          subEntity_( subEntity )
      {}
 
      EntityBase ( const GeometryImpl &geo, int subEntity )
        : geo_( geo ),
          hostElement_( nullptr ),
          subEntity_( subEntity )
      {}
 
      EntityBase ( const EntityBase &other )
        : geo_( other.geo_ ),
          hostElement_( nullptr ),
          subEntity_( other.subEntity_ )
      {}
 
      const EntityBase &operator= ( const EntityBase &other )
      {
        geo_ = other.geo_;
        hostElement_ = nullptr;
        subEntity_ = other.subEntity_;
        return *this;
      }
 
      operator bool () const { return bool( hostElement_ ); }
 
      GeometryType type () const
      {
        const ReferenceElement< ctype, dimension > &refElement
          = ReferenceElements< ctype, dimension >::general( hostElement().type() );
        return refElement.type( subEntity_, codimension );
      }
 
      int level () const
      {
        return hostElement().level();
      }
 
      PartitionType partitionType () const
      {
        if( !(Capabilities::isParallel< HostGrid >::v) )
          return InteriorEntity;
 
        const ReferenceElement< ctype, dimension > &refElement
          = ReferenceElements< ctype, dimension >::general( hostElement().type() );
 
        PartitionType type = vertexPartitionType( refElement, 0 );
        if( (type != BorderEntity) && (type != FrontEntity) )
          return type;
 
        const int numVertices = refElement.size( subEntity_, codimension, dimension );
        for( int i = 1; i < numVertices; ++i )
        {
          PartitionType vtxType = vertexPartitionType( refElement, i );
          if( (vtxType != BorderEntity) && (vtxType != FrontEntity) )
            return vtxType;
          if( type != vtxType )
            return OverlapEntity;
        }
        assert( (type == BorderEntity) || (type == FrontEntity) );
        return type;
      }
 
      Geometry geometry () const
      {
        if( !geo_ )
        {
          CoordVector coords( hostElement(), subEntity_, grid().coordFunction() );
          geo_ = GeometryImpl( grid(), type(), coords );
        }
        return Geometry( geo_ );
      }
 
      EntitySeed seed () const { return typename EntitySeed::Implementation( hostElement().seed(), subEntity_ ); }
      const Grid &grid () const { return geo_.grid(); }
 
      const HostEntity &hostEntity () const
      {
        DUNE_THROW( NotImplemented, "HostGrid has no entities of codimension " << codimension << "." );
      }
 
      const HostElement &hostElement () const
      {
        assert( *this );
        return *hostElement_;
      }
 
      int subEntity () const { return subEntity_; }
 
      void initialize ( const HostElement &hostElement ) { hostElement_ = &hostElement; }
 
      template< class HostIndexSet >
      typename HostIndexSet::IndexType index ( const HostIndexSet &indexSet ) const
      {
        return indexSet.subIndex( hostElement(), subEntity_, codimension );
      }
 
      template< class HostIndexSet >
      typename HostIndexSet::IndexType
      subIndex ( const HostIndexSet &indexSet, int i, unsigned int cd ) const
      {
        const ReferenceElement< ctype, dimension > &refElement
          = ReferenceElements< ctype, dimension >::general( hostElement().type() );
        const int j = refElement.subEntity( subEntity_, codimension, i, codimension+cd );
        return indexSet.subIndex( hostElement(), j, codimension+cd );
      }
 
      template< class HostIndexSet >
      bool isContained ( const HostIndexSet &indexSet ) const
      {
        return indexSet.contains( hostElement() );
      }
 
      template< class HostIdSet >
      typename HostIdSet::IdType id ( const HostIdSet &idSet ) const
      {
        return idSet.subId( hostElement(), subEntity_, codimension );
      }
    private:
      PartitionType
      vertexPartitionType ( const ReferenceElement< ctype, dimension > &refElement, int i ) const
      {
        const int j = refElement.subEntity( subEntity_, codimension, 0, dimension );
        return hostElement().template subEntity< dimension >( j )->partitionType();
      }
 
    private:
      mutable GeometryImpl geo_;
      const HostElement *hostElement_;
      unsigned int subEntity_;
    };
 
 
 
    // Entity
    // ------
 
    template< int codim, int dim, class Grid >
    class Entity
      : public EntityBase< codim, Grid >
    {
      typedef EntityBase< codim, Grid > Base;
 
    public:
      typedef typename Base::HostEntity HostEntity;
      typedef typename Base::HostElement HostElement;
      typedef typename Base::GeometryImpl GeometryImpl;
 
      explicit Entity ( const Grid &grid )
        : Base( grid )
      {}
 
      explicit Entity ( const GeometryImpl &geo )
        : Base( geo )
      {}
 
      Entity ( const Grid &grid, int subEntity )
        : Base( grid, subEntity )
      {}
 
      Entity ( const GeometryImpl &geo, int subEntity )
        : Base( geo, subEntity )
      {}
    };
 
 
 
    // Entity for codimension 0
    // ------------------------
 
    template< int dim, class Grid >
    class Entity< 0, dim, Grid >
      : public EntityBase< 0, Grid >
    {
      typedef EntityBase< 0, Grid > Base;
 
      typedef typename remove_const< Grid >::type::Traits Traits;
 
      typedef typename Traits::HostGrid HostGrid;
 
    public:
      static const int codimension = Base::codimension;
      static const int dimension = Base::dimension;
      static const int mydimension = Base::mydimension;
      static const int dimensionworld = Base::dimensionworld;
 
      static const bool fake = Base::fake;
      typedef typename Traits::template Codim< codimension >::LocalGeometry LocalGeometry;
      typedef typename Traits::template Codim< codimension >::EntityPointer EntityPointer;
 
      typedef typename Traits::HierarchicIterator HierarchicIterator;
      typedef typename Traits::LeafIntersectionIterator LeafIntersectionIterator;
      typedef typename Traits::LevelIntersectionIterator LevelIntersectionIterator;
 
      typedef typename Base::HostEntity HostEntity;
      typedef typename Base::HostElement HostElement;
      typedef typename Base::GeometryImpl GeometryImpl;
 
      using Base::grid;
      using Base::hostEntity;
 
      explicit Entity ( const Grid &grid )
        : Base( grid )
      {}
 
      explicit Entity ( const GeometryImpl &geo )
        : Base( geo )
      {}
 
      template< int codim >
      int count () const
      {
        return hostEntity().template count< codim >();
      }
 
      template< int codim >
      typename Grid::template Codim< codim >::EntityPointer
      subEntity ( int i ) const
      {
        typedef typename Traits::template Codim< codim >::EntityPointerImpl EntityPointerImpl;
        return EntityPointerImpl( grid(), hostEntity(), i );
      }
 
      LevelIntersectionIterator ilevelbegin () const
      {
        typedef GeoGrid::IntersectionIterator< Grid, typename HostGrid::LevelIntersectionIterator > LevelIntersectionIteratorImpl;
        return LevelIntersectionIteratorImpl( *this, hostEntity().ilevelbegin() );
      }
 
      LevelIntersectionIterator ilevelend () const
      {
        typedef GeoGrid::IntersectionIterator< Grid, typename HostGrid::LevelIntersectionIterator > LevelIntersectionIteratorImpl;
        return LevelIntersectionIteratorImpl( *this, hostEntity().ilevelend() );
      }
 
      LeafIntersectionIterator ileafbegin () const
      {
        typedef GeoGrid::IntersectionIterator< Grid, typename HostGrid::LeafIntersectionIterator > LeafIntersectionIteratorImpl;
        return LeafIntersectionIteratorImpl( *this, hostEntity().ileafbegin() );
      }
 
      LeafIntersectionIterator ileafend () const
      {
        typedef GeoGrid::IntersectionIterator< Grid, typename HostGrid::LeafIntersectionIterator > LeafIntersectionIteratorImpl;
        return LeafIntersectionIteratorImpl( *this, hostEntity().ileafend() );
      }
 
      bool hasBoundaryIntersections () const
      {
        return hostEntity().hasBoundaryIntersections();
      }
 
      bool isLeaf () const
      {
        return hostEntity().isLeaf();
      }
 
      EntityPointer father () const
      {
        typedef typename Traits::template Codim< 0 >::EntityPointerImpl EntityPointerImpl;
        return EntityPointerImpl( grid(), hostEntity().father() );
      }
 
      bool hasFather () const
      {
        return hostEntity().hasFather();
      }
 
      LocalGeometry geometryInFather () const
      {
        return hostEntity().geometryInFather();
      }
 
      HierarchicIterator hbegin ( int maxLevel ) const
      {
        typedef GeoGrid::HierarchicIterator< Grid > HierarchicIteratorImpl;
        return HierarchicIteratorImpl( grid(), hostEntity().hbegin( maxLevel ) );
      }
 
      HierarchicIterator hend ( int maxLevel ) const
      {
        typedef GeoGrid::HierarchicIterator< Grid > HierarchicIteratorImpl;
        return HierarchicIteratorImpl( grid(), hostEntity().hend( maxLevel ) );
      }
 
      bool isRegular () const
      {
        return hostEntity().isRegular();
      }
 
      bool isNew () const
      {
        return hostEntity().isNew();
      }
 
      bool mightVanish () const
      {
        return hostEntity().mightVanish();
      }
    };
 
  } // namespace GeoGrid
 
} // namespace Dune
 
#endif // #ifndef DUNE_GEOGRID_ENTITY_HH