intersection.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_GRID_INTERSECTION_HH
#define DUNE_GRID_INTERSECTION_HH
 
#include <dune/grid/common/grid.hh>
 
namespace Dune
{
 
  template< class GridImp, class IntersectionImp >
  class Intersection
  {
#if DUNE_GRID_EXPERIMENTAL_GRID_EXTENSIONS
  public:
#else
  protected:
    // give the GridDefaultImplementation class access to the realImp
    friend class GridDefaultImplementation<
        GridImp::dimension, GridImp::dimensionworld,
        typename GridImp::ctype,
        typename GridImp::GridFamily> ;
#endif
    // type of underlying implementation, for internal use only
    typedef IntersectionImp Implementation;
 
    Implementation &impl () { return real; }
    const Implementation &impl () const { return real; }
 
  protected:
    Implementation real;
 
    enum { dim=GridImp::dimension };
    enum { dimworld=GridImp::dimensionworld };
 
  public:
    typedef typename GridImp::template Codim<0>::Entity Entity;
 
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    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;
 
    enum { codimension=1  };
 
    enum { dimension=dim  };
 
    enum { mydimension=dim-1  };
 
    enum { dimensionworld=dimworld  };
 
    typedef typename GridImp::ctype ctype;
 
    bool boundary () const
    {
      return this->real.boundary();
    }
 
#if DUNE_GRID_EXPERIMENTAL_GRID_EXTENSIONS
    int boundaryId () const
    {
      return this->real.boundaryId();
    }
#endif
 
    size_t boundarySegmentIndex () const
    {
      return this->real.boundarySegmentIndex();
    }
 
    bool neighbor () const
    {
      return this->real.neighbor();
    }
 
    EntityPointer inside() const
    {
      return this->real.inside();
    }
 
    EntityPointer 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();
    }
 
    //===========================================================
    //===========================================================
 
    Intersection ( const Implementation &impl )
      : real( impl )
    {}
 
  protected:
    friend class IntersectionIterator<GridImp, IntersectionImp, IntersectionImp>;
 
    /* hide copy constructor */
    Intersection ( const Intersection &i )
      : real( i.real )
    {}
 
    /* hide assignment operator */
    const Intersection &operator= ( const Intersection &i )
    {
      real = i.real;
      return *this;
    }
  };
 
  //**********************************************************************
  template< class GridImp, class IntersectionImp >
  class IntersectionDefaultNormalVectors
  {
    enum { dim=GridImp::dimension };
    enum { 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().intersectionGlobal().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();
      const ReferenceElement<ct, dim-1> & refElement =
        ReferenceElements<ct, dim-1>::general(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_INTERSECTION_HH