gridview2gridpart.hh

#ifndef DUNE_FEM_GRIDPART_COMMON_GRIDVIEW2GRIDPART_HH
#define DUNE_FEM_GRIDPART_COMMON_GRIDVIEW2GRIDPART_HH
 
#include <utility>
#include <functional>
 
#include <dune/common/exceptions.hh>
 
#include <dune/grid/common/gridenums.hh>
 
#include <dune/fem/gridpart/common/gridpart.hh>
#include <dune/fem/quadrature/caching/twistutility.hh>
#include <dune/fem/space/common/dofmanager.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // Internal forward declaration
    // ----------------------------
 
    template< class GridView, class Implementation, bool storeCopy=true >
    class GridView2GridPart;
 
 
 
#ifndef DOXYGEN
 
    // GridView2GridPartTraits
    // -----------------------
 
    template< class GridView, class Implementation, bool storeCopy >
    struct GridView2GridPartTraits
    {
      typedef Implementation GridPartType;
 
      typedef GridView GridViewType;
      static const bool conforming = GridView::conforming;
 
      typedef typename GridViewType::Grid GridType;
      typedef typename GridViewType::Communication CommunicationType;
 
      typedef typename GridView::IndexSet IndexSetType;
 
      template< int codim >
      struct Codim
      {
        typedef typename GridViewType::template Codim< codim >::Entity EntityType;
        typedef typename GridType::template Codim< codim >::EntitySeed EntitySeedType;
 
        typedef typename GridViewType::template Codim< codim >::Geometry GeometryType;
        typedef typename GridViewType::template Codim< codim >::LocalGeometry LocalGeometryType;
 
        template< PartitionIteratorType pitype >
        struct Partition
        {
          typedef typename GridViewType::template Codim< codim >::template Partition< pitype >::Iterator IteratorType;
        };
      };
 
      typedef typename GridViewType::IntersectionIterator IntersectionIteratorType;
 
      typedef TwistUtility< GridType > TwistUtilityType;
 
      // partition on which indices are defined
      static const PartitionIteratorType indexSetPartitionType = All_Partition;
      // partition identifiers for default communication
      static const InterfaceType indexSetInterfaceType = InteriorBorder_All_Interface;
    };
 
#endif // #ifndef DOXYGEN
 
 
 
    // GridView2GridPart
    // -----------------
 
    template< class GridView, class Implementation, bool storeCopy >
    class GridView2GridPart
      : public GridPartInterface< GridView2GridPartTraits< GridView, Implementation, storeCopy > >
    {
      typedef GridView2GridPart< GridView, Implementation, storeCopy > ThisType;
      typedef GridView2GridPartTraits< GridView, Implementation, storeCopy > TraitsType;
      typedef GridPartInterface< TraitsType > BaseType;
 
    public:
      typedef typename BaseType::GridType GridType;
 
      typedef typename BaseType::GridViewType GridViewType;
 
      template< int codim >
      struct Codim
        : public BaseType::template Codim< codim >
      {};
 
      typedef typename BaseType::IntersectionIteratorType IntersectionIteratorType;
 
      typedef typename BaseType::IndexSetType IndexSetType;
 
      typedef typename BaseType::CommunicationType CommunicationType;
 
    private:
      typedef DofManager< GridType > DofManagerType;
 
      auto initGv( const GridView &gridView )
      {
        if constexpr ( storeCopy )
          return gridView;
        else
          return &gridView;
      }
    public:
      using BaseType::grid;
      using BaseType::boundaryId;
 
      explicit GridView2GridPart ( const GridView &gridView )
        : gridView_( initGv( gridView ) ),
          indexSet_( &this->gridView().indexSet() )
      {}
 
      explicit GridView2GridPart ( GridView &&gridView )
        : gridView_( std::move( gridView ) ),
          indexSet_( &this->gridView().indexSet() )
      {
        // this should not be called if we only store a pointer
        assert( storeCopy );
      }
 
      GridView2GridPart& operator= (const GridView2GridPart& other ) = default;
 
      GridView2GridPart ( const ThisType &rhs )
        : gridView_( rhs.gridView_ ),
          indexSet_( &gridView().indexSet() )
      {}
 
      const GridType &grid () const { return gridView().grid(); }
      GridType &grid () { return const_cast< GridType & >( gridView().grid() ); }
 
      bool isConforming() const
      {
        return gridView().isConforming();
      }
 
      const IndexSetType &indexSet () const { assert( indexSet_ ); return *indexSet_; }
 
      template< int codim >
      typename Codim< codim >::IteratorType begin () const
      {
        return begin< codim, InteriorBorder_Partition >();
      }
 
      template< int codim, PartitionIteratorType pitype >
      typename Codim< codim >::template Partition< pitype >::IteratorType begin () const
      {
        return gridView().template begin< codim, pitype >();
      }
 
      template< int codim >
      typename Codim< codim >::IteratorType end () const
      {
        return end< codim, InteriorBorder_Partition >();
      }
 
      template< int codim, PartitionIteratorType pitype >
      typename Codim< codim >::template Partition< pitype >::IteratorType end () const
      {
        return gridView().template end< codim, pitype >();
      }
 
      IntersectionIteratorType ibegin ( const typename Codim< 0 >::EntityType &entity ) const
      {
        return gridView().ibegin( entity );
      }
 
      IntersectionIteratorType iend ( const typename Codim< 0 >::EntityType &entity ) const
      {
        return gridView().iend( entity );
      }
 
      const CommunicationType &comm () const { return gridView().comm(); }
 
      template< class DataHandle, class DataType >
      void communicate ( CommDataHandleIF< DataHandle, DataType > &dataHandle,
                         InterfaceType interface, CommunicationDirection direction ) const
      {
        gridView().communicate( dataHandle, interface, direction );
      }
 
      [[deprecated("Use DofManager::sequence instead!")]]
      int sequence () const { return -1; }
 
      template < class EntitySeed >
      typename Codim< EntitySeed::codimension >::EntityType
      entity ( const EntitySeed &seed ) const
      {
        return grid().entity( seed );
      }
 
      template <class Entity>
      const Entity &convert( const Entity& entity ) const
      {
        return convert< Entity::codimension >( entity );
      }
 
      operator const GridView& () const { return gridView(); }
 
      const GridView& gridView() const
      {
        if constexpr ( storeCopy )
        {
          return gridView_;
        }
        else
        {
          assert( gridView_ );
          return *gridView_;
        }
      }
 
    protected:
      template< int codim >
      const typename Codim< codim >::EntityType &
      convert( const typename Codim< codim >::EntityType &entity ) const
      {
        return entity;
      }
 
      std::conditional_t<storeCopy, GridView, const GridView* > gridView_;
      const IndexSetType* indexSet_;
    };
 
 
    // Capabilities
    // ------------
 
    namespace GridPartCapabilities
    {
 
      // Capabilities for GridView2GridPart
      // -------------------------------------
 
      template< class GridView, class Implementation, bool storeCopy >
      struct hasGrid< GridView2GridPart< GridView, Implementation, storeCopy > >
      {
        static const bool v = true;
      };
 
      template< class GridView, class Implementation, bool storeCopy >
      struct hasSingleGeometryType< GridView2GridPart< GridView, Implementation, storeCopy > >
      {
        static const bool v = Dune::Capabilities::hasSingleGeometryType< typename GridView::Grid >::v;
        static const unsigned int topologyId
          = Dune::Capabilities::hasSingleGeometryType< typename GridView::Grid >::topologyId;
      };
 
      template< class GridView, class Implementation, bool storeCopy >
      struct isCartesian< GridView2GridPart< GridView, Implementation, storeCopy > >
      {
        static const bool v = Dune::Capabilities::isCartesian< typename GridView::Grid >::v;
      };
 
      template< class GridView, class Implementation, bool storeCopy, int codim  >
      struct hasEntity< GridView2GridPart< GridView, Implementation, storeCopy >, codim >
      {
        static const bool v = Dune::Capabilities::hasEntity< typename GridView::Grid, codim >::v;
      };
 
      template< class GridView, class Implementation, bool storeCopy, int codim >
      struct canCommunicate< GridView2GridPart< GridView, Implementation, storeCopy >, codim >
      {
        static const bool v = Dune::Capabilities::canCommunicate< typename GridView::Grid, codim >::v;
      };
 
      template< class GridView, class Implementation, bool storeCopy >
      struct isConforming< GridView2GridPart< GridView, Implementation, storeCopy > >
      {
        static const bool v = Dune::Capabilities::isLeafwiseConforming< typename GridView::Grid >::v;
      };
 
    }
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_GRIDPART_COMMON_GRIDVIEW2GRIDPART_HH