gridfamily.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_CURVED_SURFACE_GRID_GRIDFAMILY_HH
#define DUNE_CURVED_SURFACE_GRID_GRIDFAMILY_HH

#include <dune/grid/common/grid.hh>
#include <dune/curvedgeometry/curvedgeometry.hh>
#include <dune/curvedsurfacegrid/capabilities.hh>
#include <dune/curvedsurfacegrid/entity.hh>
#include <dune/curvedsurfacegrid/entityseed.hh>
//#include <dune/curvedsurfacegrid/geometry.hh>
#include <dune/curvedsurfacegrid/gridview.hh>
#include <dune/curvedsurfacegrid/intersection.hh>
#include <dune/curvedsurfacegrid/intersectioniterator.hh>
#include <dune/curvedsurfacegrid/iterator.hh>
#include <dune/curvedsurfacegrid/idset.hh>
#include <dune/curvedsurfacegrid/indexsets.hh>

namespace Dune
{

  /** \brief namespace containing the implementations of CurvedSurfaceGrid
   *  \ingroup CurvedGeo
   */
  namespace CGeo
  {
    // GridFamily
    // ----------

    template< class HG, class CF, int order, class Allocator >
    struct GridFamily
    {
      struct Traits
      {
        using Grid = CurvedSurfaceGrid<HG, CF, order, Allocator>;
        using HostGrid = HG;
        using CoordFunction = CF;

        using ctype = typename HostGrid::ctype;

        static const int dimension = HostGrid::dimension;
        static const int dimensionworld = CoordFunction::dimRange;

        using LeafIntersection = Dune::Intersection<const Grid, CGeo::Intersection<const Grid, typename HostGrid::LeafIntersection> >;
        using LevelIntersection = Dune::Intersection<const Grid, CGeo::Intersection<const Grid, typename HostGrid::LevelIntersection> >;

        using LeafIntersectionIterator
          = Dune::IntersectionIterator<const Grid, CGeo::IntersectionIterator<const Grid, typename HostGrid::LeafIntersectionIterator>, CGeo::Intersection<const Grid, typename HostGrid::LeafIntersection> >;
        using LevelIntersectionIterator
          = Dune::IntersectionIterator<const Grid, CGeo::IntersectionIterator<const Grid, typename HostGrid::LevelIntersectionIterator >, CGeo::Intersection<const Grid, typename HostGrid::LevelIntersection> >;

        using HierarchicIterator = Dune::EntityIterator<0, const Grid, CGeo::HierarchicIterator<const Grid> >;

        template< int codim >
        struct Codim
        {
          template < int mydim, int cdim, class GridImpl >
          using GeometryImplTemplate = Dune::LagrangeCurvedGeometry<ctype,mydim,cdim,order>;

          // geometry types
          using GeometryImpl = GeometryImplTemplate<dimension-codim, dimensionworld, const Grid>;
          using Geometry = Dune::Geometry<dimension-codim, dimensionworld, const Grid, GeometryImplTemplate>;
          using LocalGeometry = typename HostGrid::template Codim<codim>::LocalGeometry;

          // entity types
          using EntityImpl = CGeo::Entity<codim, dimension, const Grid>;
          using Entity = Dune::Entity<codim, dimension, const Grid, CGeo::Entity>;

          using EntitySeed = Dune::EntitySeed<const Grid, CGeo::EntitySeed<codim, const Grid> >;

          template< PartitionIteratorType pitype >
          struct Partition
          {
            using LeafIteratorImp = CGeo::Iterator<typename HostGrid::LeafGridView, codim, pitype, const Grid>;
            using LeafIterator = Dune::EntityIterator<codim, const Grid, LeafIteratorImp>;

            using LevelIteratorImp = CGeo::Iterator<typename HostGrid::LevelGridView, codim, pitype, const Grid>;
            using LevelIterator = Dune::EntityIterator<codim, const Grid, LevelIteratorImp>;
          };

          using LeafIterator = typename Partition< All_Partition >::LeafIterator;
          using LevelIterator = typename Partition< All_Partition >::LevelIterator;
        };

        // index-sets
        using LeafIndexSet = CGeo::IndexSet<const Grid, typename HostGrid::Traits::LeafIndexSet>;
        using LevelIndexSet = CGeo::IndexSet<const Grid, typename HostGrid::Traits::LevelIndexSet>;

        // id-sets
        using GlobalIdSet = CGeo::IdSet<const Grid, typename HostGrid::Traits::GlobalIdSet>;
        using LocalIdSet = CGeo::IdSet<const Grid, typename HostGrid::Traits::LocalIdSet>;

        using CollectiveCommunication = typename HostGrid::Traits::CollectiveCommunication;

        // grid views
        using LeafGridView = Dune::GridView< CGeo::GridViewTraits< typename HostGrid::LeafGridView, CF, order, Allocator > >;
        using LevelGridView = Dune::GridView< CGeo::GridViewTraits< typename HostGrid::LevelGridView, CF, order, Allocator > >;
      };
    };

  } // namespace CGeo
} // namespace Dune

#endif // DUNE_CURVED_SURFACE_GRID_GRIDFAMILY_HH