grid.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GEOGRID_GRID_HH
#define DUNE_GEOGRID_GRID_HH
 
#include <dune/common/nullptr.hh>
#include <dune/common/static_assert.hh>
 
#include <dune/grid/common/grid.hh>
 
#include <dune/grid/geometrygrid/backuprestore.hh>
#include <dune/grid/geometrygrid/capabilities.hh>
#include <dune/grid/geometrygrid/datahandle.hh>
#include <dune/grid/geometrygrid/gridfamily.hh>
#include <dune/grid/geometrygrid/identity.hh>
#include <dune/grid/geometrygrid/persistentcontainer.hh>
 
namespace Dune
{
 
  // DefaultCoordFunction
  // --------------------
 
  template< class HostGrid >
  class DefaultCoordFunction
    : public IdenticalCoordFunction< typename HostGrid::ctype, HostGrid::dimensionworld >
  {};
 
 
 
  // GeometryGrid
  // ------------
 
  template< class HostGrid, class CoordFunction = DefaultCoordFunction< HostGrid >, class Allocator = std::allocator< void > >
  class GeometryGrid
    : public GridDefaultImplementation
      < HostGrid::dimension, CoordFunction::dimRange, typename HostGrid::ctype,
          GeoGrid::GridFamily< HostGrid, CoordFunction, Allocator > >,
      public GeoGrid::ExportParams< HostGrid, CoordFunction >,
      public GeoGrid::BackupRestoreFacilities< GeometryGrid< HostGrid, CoordFunction, Allocator > >
  {
    typedef GeometryGrid< HostGrid, CoordFunction, Allocator > Grid;
 
    typedef GridDefaultImplementation
    < HostGrid::dimension, CoordFunction::dimRange, typename HostGrid::ctype,
        GeoGrid::GridFamily< HostGrid, CoordFunction, Allocator > >
    Base;
 
    friend class GeoGrid::HierarchicIterator< const Grid >;
 
    template< int, class, bool > friend class GeoGrid::EntityBase;
    template< class, bool > friend class GeoGrid::EntityPointer;
    template< int, class > friend class GeoGrid::EntityProxy;
    template< int, int, class > friend class GeoGrid::Geometry;
    template< class, class, class, PartitionIteratorType > friend class GeoGrid::GridView;
    template< class, class > friend class GeoGrid::Intersection;
    template< class, class > friend class GeoGrid::IntersectionIterator;
    template< class, class > friend class GeoGrid::IdSet;
    template< class, class > friend class GeoGrid::IndexSet;
    template< class > friend struct HostGridAccess;
 
    template< class, class > friend class GeoGrid::CommDataHandle;
 
  public:
    typedef GeoGrid::GridFamily< HostGrid, CoordFunction, Allocator > GridFamily;
    typedef typename GridFamily::Traits Traits;
 
    template< int codim >
    struct Codim;
 
    typedef typename Traits::HierarchicIterator HierarchicIterator;
    typedef typename Traits::LeafIntersectionIterator LeafIntersectionIterator;
    typedef typename Traits::LevelIntersectionIterator LevelIntersectionIterator;
 
    template< PartitionIteratorType pitype >
    struct Partition
    {
      typedef typename GridFamily::Traits::template Partition< pitype >::LevelGridView
      LevelGridView;
      typedef typename GridFamily::Traits::template Partition< pitype >::LeafGridView
      LeafGridView;
    };
 
    typedef typename Partition< All_Partition >::LevelGridView LevelGridView;
    typedef typename Partition< All_Partition >::LeafGridView LeafGridView;
 
    typedef typename Traits::LeafIndexSet LeafIndexSet;
 
    typedef typename Traits::LevelIndexSet LevelIndexSet;
 
    typedef typename Traits::GlobalIdSet GlobalIdSet;
 
    typedef typename Traits::LocalIdSet LocalIdSet;
 
    typedef typename Traits::ctype ctype;
 
    typedef typename Traits::CollectiveCommunication CollectiveCommunication;
 
    GeometryGrid ( HostGrid &hostGrid, CoordFunction &coordFunction, const Allocator &allocator = Allocator() )
      : hostGrid_( &hostGrid ),
        coordFunction_( coordFunction ),
        removeHostGrid_( false ),
        levelIndexSets_( hostGrid_->maxLevel()+1, nullptr, allocator ),
        storageAllocator_( allocator )
    {}
 
    GeometryGrid ( HostGrid *hostGrid, CoordFunction *coordFunction, const Allocator &allocator = Allocator() )
      : hostGrid_( hostGrid ),
        coordFunction_( *coordFunction ),
        removeHostGrid_( true ),
        levelIndexSets_( hostGrid_->maxLevel()+1, nullptr, allocator ),
        storageAllocator_( allocator )
    {}
 
    ~GeometryGrid ()
    {
      for( unsigned int i = 0; i < levelIndexSets_.size(); ++i )
      {
        if( levelIndexSets_[ i ] )
          delete( levelIndexSets_[ i ] );
      }
 
      if( removeHostGrid_ )
      {
        delete &coordFunction_;
        delete hostGrid_;
      }
    }
 
    int maxLevel () const
    {
      return hostGrid().maxLevel();
    }
 
    int size ( int level, int codim ) const
    {
      return levelView( level ).size( codim );
    }
 
    int size ( int codim ) const
    {
      return leafView().size( codim );
    }
 
    int size ( int level, GeometryType type ) const
    {
      return levelView( level ).size( type );
    }
 
    int size ( GeometryType type ) const
    {
      return leafView().size( type );
    }
 
    size_t numBoundarySegments () const
    {
      return hostGrid().numBoundarySegments( );
    }
    template< int codim >
    typename Codim< codim >::LevelIterator lbegin ( int level ) const
    {
      return levelView( level ).template begin< codim >();
    }
 
    template< int codim >
    typename Codim< codim >::LevelIterator lend ( int level ) const
    {
      return levelView( level ).template end< codim >();
    }
 
    template< int codim, PartitionIteratorType pitype >
    typename Codim< codim >::template Partition< pitype >::LevelIterator
    lbegin ( int level ) const
    {
      return levelView( level ).template begin< codim, pitype >();
    }
 
    template< int codim, PartitionIteratorType pitype >
    typename Codim< codim >::template Partition< pitype >::LevelIterator
    lend ( int level ) const
    {
      return levelView( level ).template end< codim, pitype >();
    }
 
    template< int codim >
    typename Codim< codim >::LeafIterator leafbegin () const
    {
      return leafView().template begin< codim >();
    }
 
    template< int codim >
    typename Codim< codim >::LeafIterator leafend () const
    {
      return leafView().template end< codim >();
    }
 
    template< int codim, PartitionIteratorType pitype >
    typename Codim< codim >::template Partition< pitype >::LeafIterator
    leafbegin () const
    {
      return leafView().template begin< codim, pitype >();
    }
 
    template< int codim, PartitionIteratorType pitype >
    typename Codim< codim >::template Partition< pitype >::LeafIterator
    leafend () const
    {
      return leafView().template end< codim, pitype >();
    }
 
    const GlobalIdSet &globalIdSet () const
    {
      if( !globalIdSet_ )
        globalIdSet_ = GlobalIdSet( hostGrid().globalIdSet() );
      assert( globalIdSet_ );
      return globalIdSet_;
    }
 
    const LocalIdSet &localIdSet () const
    {
      if( !localIdSet_ )
        localIdSet_ = LocalIdSet( hostGrid().localIdSet() );
      assert( localIdSet_ );
      return localIdSet_;
    }
 
    const LevelIndexSet &levelIndexSet ( int level ) const
    {
      assert( levelIndexSets_.size() == (size_t)(maxLevel()+1) );
      if( (level < 0) || (level > maxLevel()) )
      {
        DUNE_THROW( GridError, "LevelIndexSet for nonexisting level " << level
                                                                      << " requested." );
      }
 
      LevelIndexSet *&levelIndexSet = levelIndexSets_[ level ];
      if( !levelIndexSet )
        levelIndexSet = new LevelIndexSet( hostGrid().levelIndexSet( level ) );
      assert( levelIndexSet );
      return *levelIndexSet;
    }
 
    const LeafIndexSet &leafIndexSet () const
    {
      if( !leafIndexSet_ )
        leafIndexSet_ = LeafIndexSet( hostGrid().leafIndexSet() );
      assert( leafIndexSet_ );
      return leafIndexSet_;
    }
 
    void globalRefine ( int refCount )
    {
      hostGrid().globalRefine( refCount );
      update();
    }
 
    bool mark ( int refCount, const typename Codim< 0 >::Entity &entity )
    {
      return hostGrid().mark( refCount, getHostEntity< 0 >( entity ) );
    }
 
    int getMark ( const typename Codim< 0 >::Entity &entity ) const
    {
      return hostGrid().getMark( getHostEntity< 0 >( entity ) );
    }
 
    bool preAdapt ()
    {
      return hostGrid().preAdapt();
    }
 
    bool adapt ()
    {
      bool ret = hostGrid().adapt();
      update();
      return ret;
    }
 
    void postAdapt ()
    {
      hostGrid().postAdapt();
    }
 
    int overlapSize ( int codim ) const
    {
      return leafView().overlapSize( codim );
    }
 
    int ghostSize( int codim ) const
    {
      return leafView().ghostSize( codim );
    }
 
    int overlapSize ( int level, int codim ) const
    {
      return levelView( level ).overlapSize( codim );
    }
 
    int ghostSize ( int level, int codim ) const
    {
      return levelView( level ).ghostSize( codim );
    }
 
    template< class DataHandle, class Data >
    void communicate ( CommDataHandleIF< DataHandle, Data > &dataHandle,
                       InterfaceType interface,
                       CommunicationDirection direction,
                       int level ) const
    {
      levelView( level ).communicate( dataHandle, interface, direction );
    }
 
    template< class DataHandle, class Data >
    void communicate ( CommDataHandleIF< DataHandle, Data > &dataHandle,
                       InterfaceType interface,
                       CommunicationDirection direction ) const
    {
      leafView().communicate( dataHandle, interface, direction );
    }
 
    const CollectiveCommunication &comm () const
    {
      return hostGrid().comm();
    }
 
#if 0
    // data handle interface different between geo and interface
 
    bool loadBalance ()
    {
      const bool gridChanged= hostGrid().loadBalance();
      if( gridChanged )
        update();
      return gridChanged;
    }
 
    template< class DataHandle, class Data >
    bool loadBalance ( CommDataHandleIF< DataHandle, Data > &datahandle )
    {
      typedef CommDataHandleIF< DataHandle, Data > DataHandleIF;
      typedef GeoGrid :: CommDataHandle< Grid, DataHandleIF > WrappedDataHandle;
 
      WrappedDataHandle wrappedDataHandle( *this, datahandle );
      const bool gridChanged = hostGrid().loadBalance( wrappedDataHandle );
      if( gridChanged )
        update();
      return gridChanged;
    }
#endif
 
    template< class EntitySeed >
    typename Traits::template Codim< EntitySeed::codimension >::EntityPointer
    entityPointer ( const EntitySeed &seed ) const
    {
      typedef typename Traits::template Codim< EntitySeed::codimension >::EntityPointerImpl EntityPointerImpl;
      return EntityPointerImpl( *this, seed );
    }
 
    template< PartitionIteratorType pitype >
    typename Partition< pitype >::LevelGridView levelView ( int level ) const
    {
      typedef typename Partition< pitype >::LevelGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View( ViewImp( *this, hostGrid().levelView( level ) ) );
    }
 
    template< PartitionIteratorType pitype >
    typename Partition< pitype >::LevelGridView levelGridView ( int level ) const
    {
      return levelView<pitype>(level);
    }
 
    template< PartitionIteratorType pitype >
    typename Partition< pitype >::LeafGridView leafView () const
    {
      typedef typename Traits::template Partition< pitype >::LeafGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View( ViewImp( *this, hostGrid().leafView() ) );
    }
 
    template< PartitionIteratorType pitype >
    typename Partition< pitype >::LeafGridView leafGridView () const
    {
      return leafGridView<pitype>();
    }
 
    LevelGridView levelView ( int level ) const
    {
      typedef typename LevelGridView::GridViewImp ViewImp;
      return LevelGridView( ViewImp( *this, hostGrid().levelView( level ) ) );
    }
 
 
    LevelGridView levelGridView ( int level ) const
    {
      return levelView(level);
    }
 
    LeafGridView leafView () const
    {
      typedef typename LeafGridView::GridViewImp ViewImp;
      return LeafGridView( ViewImp( *this, hostGrid().leafView() ) );
    }
 
    LeafGridView leafGridView () const
    {
      return leafView();
    }
 
    const HostGrid &hostGrid () const
    {
      return *hostGrid_;
    }
 
    HostGrid &hostGrid ()
    {
      return *hostGrid_;
    }
 
    void update ()
    {
      // adapt the coordinate function
      GeoGrid::AdaptCoordFunction< typename CoordFunction::Interface >::adapt( coordFunction_ );
 
      const int newNumLevels = maxLevel()+1;
      const int oldNumLevels = levelIndexSets_.size();
 
      for( int i = newNumLevels; i < oldNumLevels; ++i )
      {
        if( levelIndexSets_[ i ] )
          delete levelIndexSets_[ i ];
      }
      levelIndexSets_.resize( newNumLevels, nullptr );
    }
 
    using Base::getRealImplementation;
 
  protected:
    const CoordFunction &coordFunction () const
    {
      return coordFunction_;
    }
 
    template< int codim >
    static const typename HostGrid::template Codim< codim >::Entity &
    getHostEntity( const typename Codim< codim >::Entity &entity )
    {
      return getRealImplementation( entity ).hostEntity();
    }
 
    void *allocateStorage ( std::size_t size ) const
    {
      return storageAllocator_.allocate( size );
    }
 
    void deallocateStorage ( void *p, std::size_t size ) const
    {
      storageAllocator_.deallocate( (char *)p, size );
    }
 
  private:
    HostGrid *const hostGrid_;
    CoordFunction &coordFunction_;
    bool removeHostGrid_;
    mutable std::vector< LevelIndexSet *, typename Allocator::template rebind< LevelIndexSet * >::other > levelIndexSets_;
    mutable LeafIndexSet leafIndexSet_;
    mutable GlobalIdSet globalIdSet_;
    mutable LocalIdSet localIdSet_;
    mutable typename Allocator::template rebind< char >::other storageAllocator_;
  };
 
 
 
  // GeometryGrid::Codim
  // -------------------
 
  template< class HostGrid, class CoordFunction, class Allocator >
  template< int codim >
  struct GeometryGrid< HostGrid, CoordFunction, Allocator >::Codim
    : public Base::template Codim< codim >
  {
    typedef typename Traits::template Codim< codim >::Entity Entity;
 
    typedef typename Traits::template Codim< codim >::EntityPointer EntityPointer;
 
    typedef typename Traits::template Codim< codim >::Geometry Geometry;
 
    typedef typename Traits::template Codim< codim >::LocalGeometry LocalGeometry;
 
    template< PartitionIteratorType pitype >
    struct Partition
    {
      typedef typename Traits::template Codim< codim >
      ::template Partition< pitype >::LeafIterator
      LeafIterator;
      typedef typename Traits::template Codim< codim >
      ::template Partition< pitype >::LevelIterator
      LevelIterator;
    };
 
    typedef typename Partition< All_Partition >::LeafIterator LeafIterator;
 
    typedef typename Partition< All_Partition >::LevelIterator LevelIterator;
 
  };
 
} // namespace Dune
 
#endif // #ifndef DUNE_GEOGRID_GRID_HH