intersection.hh

// 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_GRID_COMMON_INTERSECTION_HH
#define DUNE_GRID_COMMON_INTERSECTION_HH
 
#include <dune/grid/common/grid.hh>
 
namespace Dune
{
 
  template< class GridImp, class IntersectionImp >
  class Intersection
  {
  public:
    typedef IntersectionImp Implementation;
 
    Implementation &impl () { return real; }
 
    const Implementation &impl () const { return real; }
 
  protected:
    Implementation real;
 
  public:
    typedef typename GridImp::template Codim<0>::Entity Entity;
 
    typedef typename GridImp::template Codim<1>::Geometry Geometry;
 
    typedef typename Geometry::LocalCoordinate LocalCoordinate;
 
    typedef typename Geometry::GlobalCoordinate GlobalCoordinate;
 
    typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
 
    constexpr static int mydimension = GridImp::dimension - 1;
 
    constexpr static int dimensionworld = GridImp::dimensionworld;
 
    typedef typename GridImp::ctype ctype;
 
    bool boundary () const
    {
      return this->real.boundary();
    }
 
    size_t boundarySegmentIndex () const
    {
      return this->real.boundarySegmentIndex();
    }
 
    bool neighbor () const
    {
      return this->real.neighbor();
    }
 
    Entity inside() const
    {
      return this->real.inside();
    }
 
    Entity outside() const
    {
      return this->real.outside();
    }
 
    bool conforming () const
    {
      return this->real.conforming();
    }
 
    LocalGeometry geometryInInside () const
    {
      return this->real.geometryInInside();
    }
 
    LocalGeometry geometryInOutside () const
    {
      return this->real.geometryInOutside();
    }
 
    Geometry geometry () const
    {
      return this->real.geometry();
    }
 
    GeometryType type () const
    {
      return this->real.type();
    }
 
    int indexInInside () const
    {
      return this->real.indexInInside();
    }
 
    int indexInOutside () const
    {
      return this->real.indexInOutside();
    }
 
    GlobalCoordinate outerNormal (const LocalCoordinate& local) const
    {
      return this->real.outerNormal(local);
    }
 
    GlobalCoordinate integrationOuterNormal (const LocalCoordinate& local) const
    {
      return this->real.integrationOuterNormal(local);
    }
 
    GlobalCoordinate unitOuterNormal (const LocalCoordinate& local) const
    {
      return this->real.unitOuterNormal(local);
    }
 
    GlobalCoordinate centerUnitOuterNormal () const
    {
      return this->real.centerUnitOuterNormal();
    }
 
    bool operator==(const Intersection& other) const
    {
      return real.equals(other.real);
    }
 
    bool operator!=(const Intersection& other) const
    {
      return !real.equals(other.real);
    }
 
    Intersection()
    {}
 
    Intersection(const Intersection& other)
      : real(other.real)
    {}
 
    Intersection(Intersection&& other)
      : real(std::move(other.real))
    {}
 
    Intersection& operator=(const Intersection& other)
    {
      real = other.real;
      return *this;
    }
 
    Intersection& operator=(Intersection&& other)
    {
      real = std::move(other.real);
      return *this;
    }
 
    //===========================================================
    //===========================================================
 
    Intersection ( const Implementation &impl )
      : real( impl )
    {}
 
    Intersection ( Implementation&& impl )
      : real( std::move(impl) )
    {}
 
 
  protected:
    friend class IntersectionIterator<GridImp, IntersectionImp, IntersectionImp>;
 
  };
 
  //**********************************************************************
  template< class GridImp, class IntersectionImp >
  class IntersectionDefaultNormalVectors
  {
    constexpr static int dim = GridImp::dimension;
    constexpr static int dimworld = GridImp::dimensionworld;
    typedef typename GridImp::ctype ct;
  public:
 
    FieldVector<ct, dimworld> integrationOuterNormal (const FieldVector<ct, dim-1>& local) const
    {
      FieldVector<ct, dimworld> n = asImp().unitOuterNormal(local);
      n *= asImp().geometry().integrationElement(local);
      return n;
    }
 
    FieldVector<ct, dimworld> unitOuterNormal (const FieldVector<ct, dim-1>& local) const
    {
      FieldVector<ct, dimworld> n = asImp().outerNormal(local);
      n /= n.two_norm();
      return n;
    }
 
    FieldVector<ct, dimworld> centerUnitOuterNormal () const
    {
      // For now, we do this...
      GeometryType type = asImp().geometry().type();
      auto refElement = referenceElement<ct, dim-1>(type);
      return asImp().unitOuterNormal(refElement.position(0,0));
      // But later, if we change the meaning of center(),
      // we may have to change to this...
      // return asImp().unitOuterNormal(asImp().local(asImp().center()));
    }
 
  private:
    // CRTP (curiously recurring template pattern)
    IntersectionImp &asImp () { return static_cast< IntersectionImp & >( *this ); }
    const IntersectionImp &asImp () const { return static_cast< const IntersectionImp & >( *this ); }
  };
 
} // namespace Dune
 
#endif // DUNE_GRID_COMMON_INTERSECTION_HH