filteredgridpart.hh

Go to the documentation of this file.

#ifndef DUNE_FEM_GRIDPART_FILTEREDGRIDPART_HH
#define DUNE_FEM_GRIDPART_FILTEREDGRIDPART_HH
 
//- system includes
#include <cassert>
#include <memory>
 
//- dune-grid includes
#include <dune/grid/common/datahandleif.hh>
#include <dune/grid/common/gridview.hh>
 
//- dune-fem includes
#include <dune/fem/gridpart/adaptiveleafindexset.hh>
#include <dune/fem/gridpart/common/gridpart.hh>
#include <dune/fem/gridpart/common/metatwistutility.hh>
#include <dune/fem/gridpart/filteredgridpart/capabilities.hh>
#include <dune/fem/gridpart/filteredgridpart/datahandle.hh>
#include <dune/fem/gridpart/filteredgridpart/intersection.hh>
#include <dune/fem/gridpart/filteredgridpart/intersectioniterator.hh>
#include <dune/fem/gridpart/filteredgridpart/iterator.hh>
#include <dune/fem/misc/hasboundaryintersection.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // Forward declarations
    // --------------------
 
    template< class HostGridPartImp, class FilterImp, bool useFilteredIndexSet = false >
    class FilteredGridPart;
 
 
 
    // FilteredGridPartIndexSetSelector
    // --------------------------------
 
    template < class FilteredGP, class HostGP, bool useFilteredIndexSet >
    struct FilteredGridPartIndexSetSelector
    {
      typedef AdaptiveLeafIndexSet< FilteredGP > IndexSetType;
 
      static IndexSetType *create(const FilteredGP &gridPart)
      {
        return new IndexSetType( gridPart );
      }
 
      template < class IndexSetPtr >
      static const IndexSetType&
      indexSet ( const FilteredGP &gridPart, const std::unique_ptr< IndexSetPtr >& idxSetPtr )
      {
        assert( idxSetPtr );
        return *idxSetPtr;
      }
    };
 
 
    // FilteredGridPartIndexSetSelector
    // specialization for non-filtered index set,
    // i.e. host index set
    // -----------------------------------------
 
    template< class FilteredGP, class HostGP >
    struct FilteredGridPartIndexSetSelector< FilteredGP, HostGP, false >
    {
      typedef typename HostGP::IndexSetType IndexSetType;
 
      static IndexSetType *create(const FilteredGP &gridPart)
      {
        return nullptr;
      }
 
      template < class IndexSetPtr >
      static const IndexSetType&
      indexSet ( const FilteredGP &gridPart, const std::unique_ptr< IndexSetPtr >& )
      {
        return gridPart.hostGridPart().indexSet();
      }
    };
 
 
 
    // EntityGridTypeGetter
    // --------------------
 
    template< class Entity >
    struct EntityGridTypeGetter;
 
    template< int codim, int dim, class Grid, template< int, int, class > class Impl >
    struct EntityGridTypeGetter< Dune::Entity< codim, dim, Grid, Impl > >
    {
      typedef Grid Type;
    };
 
    template< class Entity >
    struct EntityGridTypeGetter< const Entity >
    {
      typedef typename EntityGridTypeGetter< Entity >::Type Type;
    };
 
 
 
    // FilteredGridPartTraits
    // ----------------------
 
    template< class HostGridPartImp, class FilterImp, bool useFilteredIndexSet >
    struct FilteredGridPartTraits
    {
      typedef FilteredGridPart< HostGridPartImp, FilterImp, useFilteredIndexSet > GridPartType;
 
      struct GridPartFamily
      {
        typedef FilterImp Filter;
        typedef HostGridPartImp HostGridPart;
 
        static const int dimension = HostGridPart::dimension;
        static const int dimensionworld = HostGridPart::dimensionworld;
 
        typedef typename HostGridPart::ctype ctype;
 
        typedef FilteredGridPartIntersectionIterator< const GridPartFamily > IntersectionIteratorImpl;
        typedef FilteredGridPartIntersection< Filter, typename HostGridPart::IntersectionType > IntersectionImpl;
 
        typedef Dune::IntersectionIterator< const GridPartFamily, IntersectionIteratorImpl, IntersectionImpl > IntersectionIterator;
        typedef Dune::Intersection< const GridPartFamily, IntersectionImpl > Intersection;
 
        template< int codim >
        struct Codim : public HostGridPart::template Codim< codim >
        {
        };
      };
 
      typedef HostGridPartImp HostGridPartType;
 
      typedef typename HostGridPartType::GridType GridType;
      typedef GridType Grid;
 
      typedef MetaTwistUtility< typename HostGridPartType :: TwistUtilityType >  TwistUtilityType ;
 
      typedef FilterImp FilterType;
 
      typedef typename FilterType::EntityType EntityType;
 
      typedef FilteredGridPartIndexSetSelector< GridPartType, HostGridPartType, useFilteredIndexSet > IndexSetSelectorType;
 
      typedef typename IndexSetSelectorType::IndexSetType IndexSetType;
 
      typedef typename HostGridPartType::Traits::IntersectionIteratorType HostIntersectionIteratorType;
 
      typedef typename GridPartFamily::IntersectionIterator IntersectionIteratorType;
 
      typedef typename GridPartFamily::Intersection IntersectionType;
 
      template< int codim >
      struct Codim : public HostGridPartType::template Codim< codim >
      {
        template< PartitionIteratorType pitype >
        struct Partition
        {
          typedef Dune::EntityIterator< codim, typename EntityGridTypeGetter< EntityType >::Type, FilteredGridPartIterator< codim, pitype, GridPartType > > IteratorType;
          typedef IteratorType Iterator;
        };
 
        typedef typename Partition< InteriorBorder_Partition >::IteratorType IteratorType;
        typedef IteratorType Iterator;
      };
 
      typedef typename HostGridPartType::CommunicationType CommunicationType;
      typedef CommunicationType Communication;
 
      static const PartitionIteratorType indexSetPartitionType = HostGridPartType::indexSetPartitionType;
 
      static const InterfaceType indexSetInterfaceType = HostGridPartType::indexSetInterfaceType;
 
      static const bool conforming = HostGridPartType::Traits::conforming;
    };
 
 
 
    //***************************************************************************
    //
    // FilteredGridPart
    //
    template< class HostGridPartImp, class FilterImp, bool useFilteredIndexSet >
    class FilteredGridPart
    : public GridPartDefault< FilteredGridPartTraits< HostGridPartImp, FilterImp, useFilteredIndexSet > >
    {
      // type of this
      typedef FilteredGridPart< HostGridPartImp, FilterImp, useFilteredIndexSet > ThisType;
      typedef GridPartDefault< FilteredGridPartTraits< HostGridPartImp, FilterImp, useFilteredIndexSet > > BaseType;
 
    public:
      //- Public typedefs and enums
      typedef FilteredGridPartTraits< HostGridPartImp, FilterImp, useFilteredIndexSet > Traits;
 
      typedef FilterImp FilterType;
 
      // type of host grid part
      typedef typename Traits::HostGridPartType HostGridPartType;
 
      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 ThisType GridViewType;
 
      template< int codim >
      struct Codim : public Traits :: template Codim< codim >
      {};
 
    private:
      typedef typename Traits::IndexSetSelectorType IndexSetSelectorType;
 
      typedef typename Codim< 0 >::EntityType EntityType;
 
    public:
      //- Public methods
      FilteredGridPart ( HostGridPartType &hostGridPart, const FilterType &filter )
      : BaseType( hostGridPart.grid() ),
        hostGridPart_( &hostGridPart ),
        filter_( new FilterType(filter) ),
        indexSetPtr_( IndexSetSelectorType::create( *this ) )
      {
      }
 
      FilteredGridPart ( const FilteredGridPart &other )
      : BaseType( other ),
        hostGridPart_( other.hostGridPart_ ),
        filter_( new FilterType( other.filter()) ),
        indexSetPtr_ ( IndexSetSelectorType::create( *this ) )
      { }
 
      FilteredGridPart& operator = (const FilteredGridPart &other )
      {
        BaseType::operator=( other );
        hostGridPart_ = other.hostGridPart_;
        filter_.reset( new FilterType( other.filter() ) );
        indexSetPtr_.reset( IndexSetSelectorType::create( *this ) );
        return *this;
      }
 
      //         if IndexSetType is from host grid part the original index set is returned
      const IndexSetType &indexSet() const
      {
        return IndexSetSelectorType::indexSet( *this, indexSetPtr_ );
      }
 
      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
      {
        typedef typename Codim< codim >::template Partition< pitype >::IteratorType IteratorType;
        typedef FilteredGridPartIterator< codim, pitype, ThisType > IteratorImpl;
        return IteratorType( IteratorImpl( *this, hostGridPart().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
      {
        typedef typename Codim< codim >::template Partition< pitype >::IteratorType IteratorType;
        typedef FilteredGridPartIterator< codim, pitype, ThisType > IteratorImpl;
        return IteratorType( IteratorImpl( *this, hostGridPart().template end< codim, pitype >() ) );
      }
 
      int level () const
      {
        return hostGridPart().level();
      }
 
      IntersectionIteratorType ibegin ( const EntityType &entity ) const
      {
        typedef typename IntersectionIteratorType::Implementation IntersectionIteratorImpl;
        return IntersectionIteratorType( IntersectionIteratorImpl( filter(), hostGridPart().ibegin( entity ) ) );
      }
 
      IntersectionIteratorType iend ( const EntityType &entity ) const
      {
        typedef typename IntersectionIteratorType::Implementation IntersectionIteratorImpl;
        return IntersectionIteratorType( IntersectionIteratorImpl( filter(), hostGridPart().iend( entity ) ) );
      }
 
      template < class DataHandleImp, class DataType >
      void communicate ( CommDataHandleIF< DataHandleImp, DataType > &dataHandle,
                         InterfaceType iftype, CommunicationDirection dir ) const
      {
        typedef CommDataHandleIF< DataHandleImp, DataType >  HostHandleType;
        FilteredGridPartDataHandle< HostHandleType, ThisType > handleWrapper( dataHandle, *this );
        hostGridPart().communicate( handleWrapper, iftype, dir );
      }
 
      template < class EntitySeed >
      typename Codim< EntitySeed::codimension >::EntityType
      entity ( const EntitySeed &seed ) const
      {
        return hostGridPart().entity( seed );
      }
 
      const FilterType &filter () const
      {
        return *filter_;
      }
 
      FilterType &filter ()
      {
        return *filter_;
      }
 
      template< class Entity >
      bool contains ( const Entity &entity ) const
      {
        return filter().contains( entity );
      }
 
      HostGridPartType &hostGridPart ()
      {
        assert( hostGridPart_ );
        return *hostGridPart_;
      }
 
      const HostGridPartType &hostGridPart () const
      {
        assert( hostGridPart_ );
        return *hostGridPart_;
      }
 
      template <class Entity>
      const Entity& convert ( const Entity &entity ) const
      {
        return hostGridPart().convert( entity );
      }
 
    private:
      HostGridPartType *hostGridPart_;
      std::unique_ptr< FilterType >   filter_;
      std::unique_ptr< IndexSetType > indexSetPtr_;
    };
 
    template< class GridPartFamily >
    struct GridIntersectionAccess< Dune::Intersection< const GridPartFamily, typename GridPartFamily::IntersectionImpl > >
    {
      typedef Dune::Intersection< const GridPartFamily, typename  GridPartFamily::IntersectionImpl > IntersectionType;
      typedef GridIntersectionAccess< typename IntersectionType::Implementation::HostIntersectionType > HostAccessType;
      typedef typename HostAccessType::GridIntersectionType GridIntersectionType;
 
      static const typename HostAccessType::GridIntersectionType &gridIntersection ( const IntersectionType &intersection )
      {
        return HostAccessType::gridIntersection( intersection.impl().hostIntersection() );
      }
    };
 
    template< class HostGridPartImp, class FilterImp, bool useFilteredIndexSet >
    struct HasBoundaryIntersection< FilteredGridPart<HostGridPartImp,FilterImp,useFilteredIndexSet> >
    {
      using GridPartType = FilteredGridPart<HostGridPartImp,FilterImp,useFilteredIndexSet>;
      using EntityType = typename GridPartType::template Codim<0>::EntityType;
      static bool apply(const EntityType &entity)
      {
        return true;
      }
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_GRIDPART_FILTEREDGRIDPART_HH