hostgridaccess.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_HOSTGRIDACCESS_HH
#define DUNE_GRID_HOSTGRIDACCESS_HH

#include <string>

#include <dune/grid/geometrygrid/intersection.hh>

namespace Dune
{

  // External Forward Declarations
  // -----------------------------

  template< class HostGrid, class CoordFunction, class Allocator >
  class GeometryGrid;

  template< class >
  class IdentityGrid;


  // HostGridAccess
  // --------------

  template< class Grid >
  struct HostGridAccess;



  template< class HG, class CoordFunction, class Allocator >
  struct HostGridAccess< GeometryGrid< HG, CoordFunction, Allocator > >
  {
    typedef GeometryGrid< HG, CoordFunction, Allocator > Grid;

    typedef typename Grid::HostGrid HostGrid;

    template< int codim >
    struct Codim
    {
      typedef typename Grid::template Codim< codim >::Entity Entity;

      typedef typename HostGrid::template Codim< codim >::Entity HostEntity;
    };

    typedef typename Grid::Traits::LeafIntersection LeafIntersection;
    typedef typename Grid::Traits::LevelIntersection LevelIntersection;

    typedef typename HostGrid::Traits::LeafIntersection HostLeafIntersection;
    typedef typename HostGrid::Traits::LevelIntersection HostLevelIntersection;

    static const HostGrid &hostGrid ( const Grid &grid )
    {
      return grid.hostGrid();
    }

    template< class Entity >
    static const typename Codim< Entity::codimension >::HostEntity &
    hostEntity ( const Entity &entity )
    {
      return hostEntity< Entity::codimension >( entity );
    }

    template< int codim >
    static const typename Codim< codim >::HostEntity &
    hostEntity ( const typename Codim< codim >::Entity &entity )
    {
      return entity.impl().hostEntity();
    }

    template< class HostIntersection >
    static const HostIntersection &
    hostIntersection ( const Intersection< const Grid, GeoGrid::Intersection< const Grid, HostIntersection > > &intersection )
    {
      return intersection.impl().hostIntersection();
    }
  };


  template< class HG >
  struct HostGridAccess< IdentityGrid< HG > >
  {
    typedef IdentityGrid< HG > Grid;

    typedef HG HostGrid;

    template< int codim >
    struct Codim
    {
      typedef typename Grid::template Codim< codim >::Entity Entity;

      typedef typename HostGrid::template Codim< codim >::Entity HostEntity;
    };

    typedef typename Grid::Traits::LeafIntersection LeafIntersection;
    typedef typename Grid::Traits::LevelIntersection LevelIntersection;

    typedef typename HostGrid::Traits::LeafIntersection HostLeafIntersection;
    typedef typename HostGrid::Traits::LevelIntersection HostLevelIntersection;

    static const HostGrid &hostGrid ( const Grid &grid )
    {
      return grid.getHostGrid();
    }

    template< class Entity >
    static const typename Codim< Entity::codimension >::HostEntity &
    hostEntity ( const Entity &entity )
    {
      return hostEntity< Entity::codimension >( entity );
    }

    template< int codim >
    static const typename Codim< codim >::HostEntity &
    hostEntity ( const typename Codim< codim >::Entity &entity )
    {
      return *entity.impl().hostEntity_;
    }

    static const HostLeafIntersection &
    hostIntersection ( const LeafIntersection &intersection )
    {
      return *intersection.impl().hostIterator_;
    }

    static const HostLevelIntersection &
    hostIntersection ( const LevelIntersection &intersection )
    {
      return *intersection.impl().hostIterator_;
    }
  };

} // namespace Dune

#endif // #ifndef DUNE_GRID_HOSTGRIDACCESS_HH