common/intersection.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_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