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 <memory>
 
#include <dune/common/deprecated.hh>
#include <dune/common/shared_ptr.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< int, int, class > friend class GeoGrid::Geometry;
    template< class, class, class > 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;
 
    typedef typename GridFamily::Traits::LeafGridView LeafGridView;
    typedef typename GridFamily::Traits::LevelGridView LevelGridView;
 
    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_( Dune::stackobject_to_shared_ptr(hostGrid) ),
        coordFunction_( Dune::stackobject_to_shared_ptr(coordFunction) ),
        levelIndexSets_( hostGrid_->maxLevel()+1, nullptr, allocator ),
        storageAllocator_( allocator )
    {}
 
    GeometryGrid ( std::shared_ptr<HostGrid> hostGrid, std::shared_ptr<CoordFunction> coordFunction, const Allocator &allocator = Allocator() )
      : hostGrid_( hostGrid ),
        coordFunction_( coordFunction ),
        levelIndexSets_( hostGrid_->maxLevel()+1, nullptr, allocator ),
        storageAllocator_( allocator )
    {}
 
    GeometryGrid ( std::shared_ptr<HostGrid> hostGrid, const Allocator &allocator = Allocator() )
      : hostGrid_( hostGrid ),
        coordFunction_( std::make_shared<CoordFunction>( this->hostGrid() ) ),
        levelIndexSets_( hostGrid_->maxLevel()+1, nullptr, allocator ),
        storageAllocator_( allocator )
    {}
 
    GeometryGrid ( HostGrid *hostGrid, CoordFunction *coordFunction, const Allocator &allocator = Allocator() )
      DUNE_DEPRECATED_MSG("Pass the host grid and coord function as shared_ptr instead of a raw pointer. This constructor will be removed after Dune 2.7.")
      : hostGrid_( hostGrid ),
        coordFunction_( coordFunction ),
        levelIndexSets_( hostGrid_->maxLevel()+1, nullptr, allocator ),
        storageAllocator_( allocator )
    {}
 
    GeometryGrid ( HostGrid *hostGrid, const Allocator &allocator = Allocator() )
      DUNE_DEPRECATED_MSG("Pass the host grid as shared_ptr instead of a raw pointer. This constructor will be removed after Dune 2.7.")
      : hostGrid_( hostGrid ),
        coordFunction_( std::make_shared<CoordFunction>( this->hostGrid() ) ),
        levelIndexSets_( hostGrid_->maxLevel()+1, nullptr, allocator ),
        storageAllocator_( allocator )
    {}
 
 
    ~GeometryGrid ()
    {
      for( unsigned int i = 0; i < levelIndexSets_.size(); ++i )
      {
        if( levelIndexSets_[ i ] )
          delete( levelIndexSets_[ i ] );
      }
    }
 
    int maxLevel () const
    {
      return hostGrid().maxLevel();
    }
 
    int size ( int level, int codim ) const
    {
      return levelGridView( level ).size( codim );
    }
 
    int size ( int codim ) const
    {
      return leafGridView().size( codim );
    }
 
    int size ( int level, GeometryType type ) const
    {
      return levelGridView( level ).size( type );
    }
 
    int size ( GeometryType type ) const
    {
      return leafGridView().size( type );
    }
 
    size_t numBoundarySegments () const
    {
      return hostGrid().numBoundarySegments( );
    }
    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_.reset( 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();
    }
 
    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 >::Entity
    entity ( const EntitySeed &seed ) const
    {
      typedef typename Traits::template Codim< EntitySeed::codimension >::EntityImpl EntityImpl;
      return EntityImpl( *this, seed );
    }
 
    LevelGridView levelGridView ( int level ) const
    {
      typedef typename LevelGridView::GridViewImp ViewImp;
      return LevelGridView( ViewImp( *this, hostGrid().levelGridView( level ) ) );
    }
 
    LeafGridView leafGridView () const
    {
      typedef typename LeafGridView::GridViewImp ViewImp;
      return LeafGridView( ViewImp( *this, hostGrid().leafGridView() ) );
    }
 
    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;
 
    const CoordFunction &coordFunction () const { return *coordFunction_; }
 
    CoordFunction &coordFunction () { return *coordFunction_; }
 
  protected:
    template< int codim >
    static const typename HostGrid::template Codim< codim >::Entity &
    getHostEntity( const typename Codim< codim >::Entity &entity )
    {
      return entity.impl().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:
    std::shared_ptr<HostGrid> const hostGrid_;
    std::shared_ptr<CoordFunction> coordFunction_;
    mutable std::vector< LevelIndexSet *, typename std::allocator_traits<Allocator>::template rebind_alloc< LevelIndexSet * > > levelIndexSets_;
    mutable LeafIndexSet leafIndexSet_;
    mutable GlobalIdSet globalIdSet_;
    mutable LocalIdSet localIdSet_;
    mutable typename std::allocator_traits<Allocator>::template rebind_alloc< char > 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 >::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