gridpart.hh

#ifndef DUNE_FEM_GRIDPART_COMMON_GRIDPART_HH
#define DUNE_FEM_GRIDPART_COMMON_GRIDPART_HH
 
//- dune-common includes
#include <dune/common/bartonnackmanifcheck.hh>
#include <dune/common/exceptions.hh>
 
//- dune-grid includes
#include <dune/grid/common/datahandleif.hh>
#include <dune/grid/common/entity.hh>
#include <dune/grid/common/grid.hh>
 
//- dune-fem includes
#include <dune/fem/space/common/dofmanager.hh>
#include <dune/fem/gridpart/common/capabilities.hh>
#include <dune/fem/quadrature/caching/twistutility.hh>
#include <dune/fem/misc/boundaryidprovider.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class GridPartTraits >
    class GridPartInterface
    {
      typedef GridPartInterface< GridPartTraits > ThisType;
 
    public:
      typedef GridPartTraits Traits;
 
      typedef typename Traits::GridPartType GridPartType;
 
      typedef typename Traits::GridType GridType;
      typedef GridType Grid;
 
      typedef typename Traits::IndexSetType IndexSetType;
      typedef IndexSetType IndexSet;
 
      typedef typename Traits::CommunicationType CommunicationType;
      typedef CommunicationType Communication;
 
      typedef typename Traits::TwistUtilityType TwistUtilityType;
 
      static const PartitionIteratorType indexSetPartitionType
        = Traits::indexSetPartitionType;
      static const InterfaceType indexSetInterfaceType
        = Traits::indexSetInterfaceType;
 
      typedef typename Traits::IntersectionIteratorType IntersectionIteratorType;
      typedef IntersectionIteratorType IntersectionIterator;
 
      typedef typename IntersectionIteratorType::Intersection IntersectionType;
      typedef IntersectionType Intersection;
 
      typedef GridPartType GridViewType;
 
      typedef typename GridType::ctype ctype;
 
      // static const int dimension = GridType::dimension;
      // static const int dimensionworld = GridType::dimensionworld;
      // static const bool conforming = Traits::conforming ;
 
      static constexpr int dimension = GridType::dimension;
      static constexpr int dimensionworld = GridType::dimensionworld;
      static constexpr bool conforming = Traits::conforming ;
 
      template< int codim >
      struct Codim
      {
        typedef typename Traits::template Codim< codim >::GeometryType       GeometryType;
        typedef typename Traits::template Codim< codim >::LocalGeometryType  LocalGeometryType;
 
        typedef typename Traits::template Codim< codim >::EntityType         EntityType;
        typedef typename Traits::template Codim< codim >::EntitySeedType     EntitySeedType;
 
        // GridView typedefs interface
        typedef GeometryType       Geometry;
        typedef LocalGeometryType  LocalGeometry;
        typedef EntityType         Entity;
        typedef EntitySeedType     EntitySeed;
 
        template< PartitionIteratorType pitype >
        struct Partition
        {
          typedef typename Traits::template Codim< codim >::template Partition< pitype >::IteratorType
            IteratorType;
          // GridView typedef
          typedef IteratorType Iterator;
        };
 
        typedef typename Partition< InteriorBorder_Partition >::IteratorType IteratorType;
        // GridView typedef
        typedef IteratorType Iterator;
      };
 
      const GridType &grid () const
      {
        CHECK_INTERFACE_IMPLEMENTATION((asImp().grid()));
        return asImp().grid();
      }
      GridType &grid ()
      {
        CHECK_INTERFACE_IMPLEMENTATION((asImp().grid()));
        return asImp().grid();
      }
 
      const IndexSetType& indexSet() const
      {
        CHECK_INTERFACE_IMPLEMENTATION((asImp().indexSet()));
        return asImp().indexSet();
      }
 
      bool isConforming() const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().isConforming()) );
        return asImp().isConforming();
      }
 
      int size ( int codim ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().size( codim )) );
        return asImp().size( codim );
      }
 
      int size ( const GeometryType &type ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().size( type )) );
        return asImp().size( type );
      }
 
      template< int codim >
      typename Codim< codim >::IteratorType
      begin () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().template begin< codim >()) );
        return asImp().template begin< codim >();
      }
 
      template< int codim, PartitionIteratorType pitype >
      typename Codim< codim >::template Partition< pitype >::IteratorType
      begin () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().template begin< codim, pitype >()) );
        return asImp().template begin< codim, pitype >();
      }
 
      template< int codim >
      typename Codim< codim >::IteratorType
      end () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().template end< codim >()) );
        return asImp().template end< codim >();
      }
 
      template< int codim, PartitionIteratorType pitype >
      typename Codim< codim >::template Partition< pitype >::IteratorType
      end () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().template end< codim, pitype >()) );
        return asImp().template end< codim, pitype >();
      }
 
      [[deprecated("Do not use this since it is no longer part of the interface")]]
      int level () const
      {
        DUNE_THROW(NotImplemented,"GridPart::level has been removed!");
        return -1;
      }
 
      IntersectionIteratorType
      ibegin ( const typename Codim< 0 >::EntityType &entity ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().ibegin( entity )) );
        return asImp().ibegin( entity );
      }
 
      IntersectionIteratorType iend ( const typename Codim< 0 >::EntityType &entity ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( (asImp().iend( entity )) );
        return asImp().iend( entity );
      }
 
      [[deprecated("Use BoundaryIdProvider::boundaryId directly!")]]
      int boundaryId ( const IntersectionType &intersection ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().boundaryId( intersection ) );
        return asImp().boundaryId( intersection );
      }
 
      const CommunicationType &comm () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().comm() );
        return asImp().comm();
      }
 
      template< class DataHandleImp, class DataType >
      void communicate ( CommDataHandleIF< DataHandleImp, DataType > &data,
                         InterfaceType iftype, CommunicationDirection dir ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( (asImp().communicate( data, iftype, dir )) );
      }
 
      template < class EntitySeed >
      typename Codim< EntitySeed::codimension >::EntityType
      entity ( const EntitySeed &seed ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().entity( seed ) );
        return asImp().entity( seed );
      }
 
      template <class Entity>
      const Entity& convert( const Entity& entity ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().convert( entity ) );
        return asImp().convert( entity );
      }
 
      template<class EntityType>
      bool contains (const EntityType& e) const
      {
        return asImp().contains(e);
      }
 
      int overlapSize ( int codim ) const
      {
        DUNE_THROW( NotImplemented, "Method overlapSize() not implemented yet" );
      }
 
      int ghostSize( int codim ) const
      {
        DUNE_THROW( NotImplemented, "Method ghostSize() not implemented yet" );
      }
 
      [[deprecated("Use DofManager::sequence instead!")]]
      int sequence () const
      {
        DUNE_THROW(NotImplemented,"GridPart::sequence is not part of the interface, use DofManager::sequence instead!");
        return -1;
      }
 
      const auto& gridView() const
      {
        return asImp();
      }
 
    protected:
      GridPartInterface () = default;
 
    private:
      GridPartType &asImp () { return static_cast< GridPartType & >( *this ); }
      const GridPartType &asImp () const { return static_cast< const GridPartType & >( *this ); }
    };
 
 
 
    template< class GridPartTraits >
    class GridPartDefault
    : public GridPartInterface< GridPartTraits >
    {
      typedef GridPartDefault< GridPartTraits > ThisType;
      typedef GridPartInterface< GridPartTraits > BaseType;
 
    public:
      typedef GridPartTraits Traits;
      typedef typename Traits::GridType GridType;
      typedef typename Traits::IndexSetType IndexSetType;
 
      typedef typename Traits::IntersectionIteratorType IntersectionIteratorType;
 
      typedef typename IntersectionIteratorType::Intersection IntersectionType;
 
      typedef typename Traits::CommunicationType CommunicationType;
 
      typedef DofManager< GridType >  DofManagerType;
 
      typedef BoundaryIdProvider< GridType > BoundaryIdProviderType;
 
    protected:
      GridType       *grid_;
      DofManagerType *dofManager_;
 
      GridPartDefault ( GridType &grid )
      : grid_( &grid ),
        dofManager_( &DofManagerType :: instance( this->grid() ) )
      {}
 
      GridPartDefault ( const ThisType &other )
      : grid_( other.grid_ ),
        dofManager_( &DofManagerType :: instance( this->grid() ) )
      {}
 
      GridPartDefault& operator= ( const ThisType &other )
      {
        grid_ = other.grid_;
        dofManager_ = &DofManagerType :: instance( grid() );
        return *this;
      }
 
    public:
      const GridType &grid () const { assert( grid_ ); return *grid_; }
 
      GridType &grid () { assert( grid_ ); return *grid_; }
 
      bool isConforming() const
      {
        // default is to return the static variant
        return bool(BaseType::conforming);
      }
 
      int size ( int codim ) const
      {
        return BaseType::indexSet().size( codim );
      }
 
      int size ( const GeometryType &type ) const
      {
        return BaseType::indexSet().size( type );
      }
 
      template<class EntityType>
      bool contains (const EntityType& e) const
      {
        return BaseType::indexSet().contains(e);
      }
 
      const CommunicationType &comm () const
      {
        return grid().comm();
      }
 
      template < class EntitySeed >
      typename Traits::template Codim< EntitySeed::codimension >::EntityType
      entity ( const EntitySeed &seed ) const
      {
        return grid().entity( seed );
      }
 
      template <class Entity>
      const Entity& convert( const Entity& entity ) const
      {
        return entity;
      }
 
      [[deprecated("Use BoundaryIdProvider::boundaryId directly!")]]
      int boundaryId ( const IntersectionType &intersection ) const
      {
        return BoundaryIdProviderType::boundaryId( intersection );
      }
    };
 
    template< class Entity >
    struct GridEntityAccess;
 
    template< int codim, int dim, class Grid, template< int, int, class > class EntityImpl >
    struct GridEntityAccess< Dune::Entity< codim, dim, Grid, EntityImpl > >
    {
      typedef Dune::Entity< codim, dim, Grid, EntityImpl > EntityType;
      typedef Dune::Entity< codim, dim, Grid, EntityImpl > GridEntityType;
 
      static const GridEntityType &gridEntity ( const EntityType &entity )
      {
        return entity;
      }
    };
 
    template< class Entity >
    const typename GridEntityAccess< Entity >::GridEntityType &
    gridEntity ( const Entity &entity )
    {
      return GridEntityAccess< Entity >::gridEntity( entity );
    }
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #define DUNE_FEM_GRIDPART_COMMON_GRIDPART_HH