defaultgridview.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_DEFAULTGRIDVIEW_HH
#define DUNE_GRID_COMMON_DEFAULTGRIDVIEW_HH

#include <dune/common/typetraits.hh>
#include <dune/common/exceptions.hh>

#include <dune/grid/common/capabilities.hh>
#include <dune/grid/common/gridview.hh>

namespace Dune
{

  template< class GridImp >
  class DefaultLevelGridView;

  template< class GridImp >
  class DefaultLeafGridView;


  template< class GridImp >
  struct DefaultLevelGridViewTraits
  {
    typedef DefaultLevelGridView< GridImp > GridViewImp;

    typedef typename std::remove_const<GridImp>::type Grid;

    typedef typename Grid :: Traits :: LevelIndexSet IndexSet;

    typedef typename Grid :: Traits :: LevelIntersection Intersection;

    typedef typename Grid :: Traits :: LevelIntersectionIterator
    IntersectionIterator;

    typedef typename Grid :: Traits :: Communication Communication;

    template< int cd >
    struct Codim
    {
      typedef typename Grid :: Traits
      :: template Codim< cd > :: template Partition< All_Partition > :: LevelIterator
      Iterator;

      typedef typename Grid :: Traits :: template Codim< cd > :: Entity Entity;

      typedef typename Grid :: template Codim< cd > :: Geometry Geometry;
      typedef typename Grid :: template Codim< cd > :: LocalGeometry
      LocalGeometry;

      template< PartitionIteratorType pit >
      struct Partition
      {
        typedef typename Grid :: template Codim< cd >
        :: template Partition< pit > :: LevelIterator
        Iterator;
      };
    };

    constexpr static bool conforming = Capabilities :: isLevelwiseConforming< Grid > :: v;
  };


  template< class GridImp >
  class DefaultLevelGridView
  {
    typedef DefaultLevelGridView< GridImp > ThisType;

  public:
    typedef DefaultLevelGridViewTraits<GridImp> Traits;

    typedef typename Traits::Grid Grid;

    typedef typename Traits :: IndexSet IndexSet;

    typedef typename Traits :: Intersection Intersection;

    typedef typename Traits :: IntersectionIterator IntersectionIterator;

    typedef typename Grid :: Traits :: Communication Communication;

    template< int cd >
    struct Codim : public Traits :: template Codim<cd> {};

    constexpr static bool conforming = Traits :: conforming;

    DefaultLevelGridView ( const Grid &grid, int level )
      : grid_( &grid ),
        level_( level )
    {}

    const Grid &grid () const
    {
      assert( grid_ );
      return *grid_;
    }

    const IndexSet &indexSet () const
    {
      return grid().levelIndexSet( level_ );
    }

    bool isConforming() const { return bool(Traits::conforming); }

    int size ( int codim ) const
    {
      return grid().size( level_, codim );
    }

    int size ( const GeometryType &type ) const
    {
      return grid().size( level_, type );
    }

    template< int cd >
    typename Codim< cd > :: Iterator begin () const
    {
      return grid().template lbegin< cd, All_Partition >( level_ );
    }

    template< int cd, PartitionIteratorType pit >
    typename Codim< cd > :: template Partition< pit > :: Iterator begin () const
    {
      return grid().template lbegin< cd, pit >( level_ );
    }

    template< int cd >
    typename Codim< cd > :: Iterator end () const
    {
      return grid().template lend< cd, All_Partition >( level_ );
    }

    template< int cd, PartitionIteratorType pit >
    typename Codim< cd > :: template Partition< pit > :: Iterator end () const
    {
      return grid().template lend< cd, pit >( level_ );
    }

    IntersectionIterator
    ibegin ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return grid().ilevelbegin(entity);
    }

    IntersectionIterator
    iend ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return grid().ilevelend(entity);
    }

    const Communication &comm () const
    {
      return grid().comm();
    }

    int overlapSize(int codim) const
    {
      return grid().overlapSize(level_, codim);
    }

    int ghostSize(int codim) const
    {
      return grid().ghostSize(level_, codim);
    }

    template< class DataHandleImp, class DataType >
    void communicate ( CommDataHandleIF< DataHandleImp, DataType > &data,
                       InterfaceType iftype,
                       CommunicationDirection dir ) const
    {
      return grid().communicate( data, iftype, dir, level_ );
    }

  private:
    const Grid *grid_;
    int level_;
  };


  template< class GridImp >
  struct DefaultLeafGridViewTraits {
    typedef DefaultLeafGridView< GridImp > GridViewImp;

    typedef typename std::remove_const<GridImp>::type Grid;

    typedef typename Grid :: Traits :: LeafIndexSet IndexSet;

    typedef typename Grid :: Traits :: LeafIntersection Intersection;

    typedef typename Grid :: Traits :: LeafIntersectionIterator
    IntersectionIterator;

    typedef typename Grid :: Traits :: Communication Communication;

    template< int cd >
    struct Codim
    {
      typedef typename Grid :: Traits
      :: template Codim< cd > :: template Partition< All_Partition > :: LeafIterator
      Iterator;

      typedef typename Grid :: Traits :: template Codim< cd > :: Entity Entity;

      typedef typename Grid :: template Codim< cd > :: Geometry Geometry;
      typedef typename Grid :: template Codim< cd > :: LocalGeometry
      LocalGeometry;

      template <PartitionIteratorType pit >
      struct Partition
      {
        typedef typename Grid :: template Codim< cd >
        :: template Partition< pit > :: LeafIterator
        Iterator;
      };
    };

    constexpr static bool conforming = Capabilities :: isLeafwiseConforming< Grid > :: v;
  };


  template< class GridImp >
  class DefaultLeafGridView
  {
    typedef DefaultLeafGridView< GridImp > ThisType;

  public:
    typedef DefaultLeafGridViewTraits<GridImp> Traits;

    typedef typename Traits::Grid Grid;

    typedef typename Traits :: IndexSet IndexSet;

    typedef typename Traits :: Intersection Intersection;

    typedef typename Traits :: IntersectionIterator IntersectionIterator;

    typedef typename Grid :: Traits :: Communication Communication;

    template< int cd >
    struct Codim : public Traits :: template Codim<cd> {};

    constexpr static bool conforming = Traits :: conforming;

  public:
    DefaultLeafGridView ( const Grid &grid )
      : grid_( &grid )
    {}

    const Grid &grid () const
    {
      assert( grid_ );
      return *grid_;
    }

    const IndexSet &indexSet () const
    {
      return grid().leafIndexSet();
    }

    bool isConforming() const { return bool(Traits::conforming); }

    int size ( int codim ) const
    {
      return grid().size( codim );
    }

    int size ( const GeometryType &type ) const
    {
      return grid().size( type );
    }

    template< int cd >
    typename Codim< cd > :: Iterator begin () const
    {
      return grid().template leafbegin< cd, All_Partition >();
    }

    template< int cd, PartitionIteratorType pit >
    typename Codim< cd > :: template Partition< pit > :: Iterator begin () const
    {
      return grid().template leafbegin< cd, pit >();
    }

    template< int cd >
    typename Codim< cd > :: Iterator end () const
    {
      return grid().template leafend< cd, All_Partition >();
    }

    template< int cd, PartitionIteratorType pit >
    typename Codim< cd > :: template Partition< pit > :: Iterator end () const
    {
      return grid().template leafend< cd, pit >();
    }

    IntersectionIterator
    ibegin ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return grid().ileafbegin(entity);
    }

    IntersectionIterator
    iend ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return grid().ileafend(entity);
    }

    const Communication &comm () const
    {
      return grid().comm();
    }

    int overlapSize(int codim) const
    {
      return grid().overlapSize(codim);
    }

    int ghostSize(int codim) const
    {
      return grid().ghostSize(codim);
    }

    template< class DataHandleImp, class DataType >
    void communicate ( CommDataHandleIF< DataHandleImp, DataType > &data,
                       InterfaceType iftype,
                       CommunicationDirection dir ) const
    {
      return grid().communicate( data, iftype, dir );
    }

  private:
    const Grid *grid_;
  };

}

#endif