identitygridintersections.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 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_IDENTITYGRID_INTERSECTIONS_HH
#define DUNE_IDENTITYGRID_INTERSECTIONS_HH
 
#include "identitygridleafiterator.hh"
#include <dune/grid/identitygrid/identitygridentity.hh>
 
namespace Dune {
 
 
  // External forward declarations
  template< class Grid >
  struct HostGridAccess;
 
 
  template<class GridImp>
  class IdentityGridLeafIntersection
  {
 
    friend class IdentityGridLeafIntersectionIterator<GridImp>;
 
    friend struct HostGridAccess< typename std::remove_const< GridImp >::type >;
 
    constexpr static int dim = GridImp::dimension;
 
    constexpr static int dimworld = GridImp::dimensionworld;
 
    // The type used to store coordinates
    typedef typename GridImp::ctype ctype;
 
    typedef typename GridImp::HostGridType::LeafGridView::Intersection HostLeafIntersection;
 
  public:
 
    typedef typename GridImp::template Codim<1>::Geometry Geometry;
    typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
    typedef typename GridImp::template Codim<0>::Entity Entity;
    typedef FieldVector<ctype, dimworld> NormalVector;
 
    IdentityGridLeafIntersection()
    {}
 
    IdentityGridLeafIntersection(const GridImp* identityGrid,
                                 const HostLeafIntersection& hostIntersection)
      : identityGrid_(identityGrid)
      , hostIntersection_(hostIntersection)
    {}
 
    IdentityGridLeafIntersection(const GridImp* identityGrid,
                                 HostLeafIntersection&& hostIntersection)
      : identityGrid_(identityGrid)
      , hostIntersection_(std::move(hostIntersection))
    {}
 
    bool equals(const IdentityGridLeafIntersection& other) const
    {
      return hostIntersection_ == other.hostIntersection_;
    }
 
    Entity inside() const {
      return IdentityGridEntity<0,dim,GridImp>(identityGrid_,hostIntersection_.inside());
    }
 
 
    Entity outside() const {
      return IdentityGridEntity<0,dim,GridImp>(identityGrid_,hostIntersection_.outside());
    }
 
 
    bool boundary () const {
      return hostIntersection_.boundary();
    }
 
    NormalVector centerUnitOuterNormal () const {
      return hostIntersection_.centerUnitOuterNormal();
    }
 
    bool neighbor () const {
      return hostIntersection_.neighbor();
    }
 
    size_t boundarySegmentIndex() const {
      return hostIntersection_.boundarySegmentIndex();
    }
 
    bool conforming () const {
      return hostIntersection_.conforming();
    }
 
    GeometryType type () const {
      return hostIntersection_.type();
    }
 
 
    LocalGeometry geometryInInside () const
    {
      return LocalGeometry( hostIntersection_.geometryInInside() );
    }
 
    LocalGeometry geometryInOutside () const
    {
      return LocalGeometry( hostIntersection_.geometryInOutside() );
    }
 
    Geometry geometry () const
    {
      return Geometry( hostIntersection_.geometry() );
    }
 
 
    int indexInInside () const {
      return hostIntersection_.indexInInside();
    }
 
 
    int indexInOutside () const {
      return hostIntersection_.indexInOutside();
    }
 
 
    FieldVector<ctype, GridImp::dimensionworld> outerNormal (const FieldVector<ctype, GridImp::dimension-1>& local) const {
      return hostIntersection_.outerNormal(local);
    }
 
    FieldVector<ctype, GridImp::dimensionworld> integrationOuterNormal (const FieldVector<ctype, GridImp::dimension-1>& local) const {
      return hostIntersection_.integrationOuterNormal(local);
    }
 
    FieldVector<ctype, GridImp::dimensionworld> unitOuterNormal (const FieldVector<ctype, GridImp::dimension-1>& local) const {
      return hostIntersection_.unitOuterNormal(local);
    }
 
 
  private:
    //**********************************************************
    //  private methods
    //**********************************************************
 
    const GridImp* identityGrid_;
 
    HostLeafIntersection hostIntersection_;
  };
 
 
 
 
  template<class GridImp>
  class IdentityGridLevelIntersection
  {
 
    friend class IdentityGridLevelIntersectionIterator<GridImp>;
 
    friend struct HostGridAccess< typename std::remove_const< GridImp >::type >;
 
    constexpr static int dim = GridImp::dimension;
 
    constexpr static int dimworld = GridImp::dimensionworld;
 
    // The type used to store coordinates
    typedef typename GridImp::ctype ctype;
 
    typedef typename GridImp::HostGridType::LevelGridView::Intersection HostLevelIntersection;
 
  public:
 
    typedef typename GridImp::template Codim<1>::Geometry Geometry;
    typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
    typedef typename GridImp::template Codim<0>::Entity Entity;
    typedef FieldVector<ctype, dimworld> NormalVector;
 
    IdentityGridLevelIntersection()
    {}
 
    IdentityGridLevelIntersection(const GridImp* identityGrid,
                                  const HostLevelIntersection& hostIntersection)
      : identityGrid_(identityGrid)
      , hostIntersection_(hostIntersection)
    {}
 
    IdentityGridLevelIntersection(const GridImp* identityGrid,
                                  HostLevelIntersection&& hostIntersection)
      : identityGrid_(identityGrid)
      , hostIntersection_(std::move(hostIntersection))
    {}
 
    bool equals(const IdentityGridLevelIntersection& other) const
    {
      return hostIntersection_ == other.hostIntersection_;
    }
 
    Entity inside() const {
      return IdentityGridEntity<0,dim,GridImp>(identityGrid_,hostIntersection_.inside());
    }
 
 
    Entity outside() const {
      return IdentityGridEntity<0,dim,GridImp>(identityGrid_,hostIntersection_.outside());
    }
 
 
    bool boundary () const {
      return hostIntersection_.boundary();
    }
 
    NormalVector centerUnitOuterNormal () const {
      return hostIntersection_.centerUnitOuterNormal();
    }
 
    bool neighbor () const {
      return hostIntersection_.neighbor();
    }
 
    size_t boundarySegmentIndex() const {
      return hostIntersection_.boundarySegmentIndex();
    }
 
    bool conforming () const {
      return hostIntersection_.conforming();
    }
 
    GeometryType type () const {
      return hostIntersection_.type();
    }
 
 
    LocalGeometry geometryInInside () const
    {
      return LocalGeometry( hostIntersection_.geometryInInside() );
    }
 
    LocalGeometry geometryInOutside () const
    {
      return LocalGeometry( hostIntersection_.geometryInOutside() );
    }
 
    Geometry geometry () const
    {
      return Geometry( hostIntersection_.geometry() );
    }
 
 
    int indexInInside () const {
      return hostIntersection_.indexInInside();
    }
 
 
    int indexInOutside () const {
      return hostIntersection_.indexInOutside();
    }
 
 
    FieldVector<ctype, dimworld> outerNormal (const FieldVector<ctype, dim-1>& local) const {
      return hostIntersection_.outerNormal(local);
    }
 
    FieldVector<ctype, dimworld> integrationOuterNormal (const FieldVector<ctype, dim-1>& local) const {
      return hostIntersection_.integrationOuterNormal(local);
    }
 
    FieldVector<ctype, dimworld> unitOuterNormal (const FieldVector<ctype, dim-1>& local) const {
      return hostIntersection_.unitOuterNormal(local);
    }
 
  private:
 
    const GridImp* identityGrid_;
 
    HostLevelIntersection hostIntersection_;
 
  };
 
 
}  // namespace Dune
 
#endif