geometrywrapper.hh

// -*- tab-width: 4; indent-tabs-mode: nil -*-
#ifndef DUNE_PDELAB_COMMON_GEOMETRYWRAPPER_HH
#define DUNE_PDELAB_COMMON_GEOMETRYWRAPPER_HH
 
#include <dune/common/fvector.hh>
 
namespace Dune {
  namespace PDELab {
 
 
    template<typename E>
    class ElementGeometry
    {
    public:
      typedef typename E::Geometry Geometry;
      typedef E Entity;
 
      ElementGeometry (const E& e_)
        : e(e_)
      {}
 
      Geometry geometry () const
      {
        return e.geometry();
      }
 
      const Entity& entity () const
      {
        return e;
      }
 
      const Entity& hostEntity () const
      {
        return e;
      }
 
    private:
      const E& e;
    };
 
 
 
    template<typename I>
    class IntersectionGeometry
    {
    private:
      const I& i;
      const unsigned int index;
    public:
      typedef typename I::Geometry Geometry;
      typedef typename I::LocalGeometry LocalGeometry;
      typedef typename I::Entity Entity;
      typedef typename Geometry::ctype ctype;
 
      enum { mydimension=I::mydimension };
 
      enum { coorddimension=Geometry::coorddimension };
 
      IntersectionGeometry (const I& i_, unsigned int index_)
        : i(i_), index(index_)
      {}
 
      int insideDomainIndex() const
      {
        return 0;
      }
 
      int outsideDomainIndex() const
      {
        const bool is_boundary = i.boundary();
        return 0 - int(is_boundary);
      }
 
      bool boundary () const
      {
        return i.boundary();
      }
 
      bool neighbor () const
      {
        return i.neighbor();
      }
 
      LocalGeometry geometryInInside () const
      {
        return i.geometryInInside();
      }
 
      LocalGeometry geometryInOutside () const
      {
        return i.geometryInOutside();
      }
 
      Geometry geometry () const
      {
        return i.geometry();
      }
 
      int indexInInside () const
      {
        return i.indexInInside ();
      }
 
      int indexInOutside () const
      {
        return i.indexInOutside ();
      }
 
      Dune::FieldVector<ctype, coorddimension> outerNormal (const Dune::FieldVector<ctype, mydimension>& local) const
      {
        return i.outerNormal(local);
      }
 
      Dune::FieldVector<ctype, coorddimension> integrationOuterNormal (const Dune::FieldVector<ctype, mydimension>& local) const
      {
        return i.integrationOuterNormal(local);
      }
 
      Dune::FieldVector<ctype, coorddimension> unitOuterNormal (const Dune::FieldVector<ctype, mydimension>& local) const
      {
        return i.unitOuterNormal(local);
      }
 
      Dune::FieldVector<ctype, coorddimension> centerUnitOuterNormal () const
      {
        return i.centerUnitOuterNormal();
      }
 
      Entity inside() const
      {
        return i.inside();
      }
 
      Entity insideHostEntity() const
      {
        DUNE_THROW(Dune::Exception,"This should never be called.");
        return i.inside();
      }
 
      Entity outside() const
      {
        return i.outside();
      }
 
      const I& intersection () const
      {
        return i;
      }
 
      unsigned int intersectionIndex() const
      {
        return index;
      }
    };
 
  }
}
 
#endif // DUNE_PDELAB_COMMON_GEOMETRYWRAPPER_HH