geometry.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_GEOMETRY_HH
#define DUNE_GRID_GEOMETRY_HH
 
#include <cassert>
 
#include <dune/common/fmatrix.hh>
#include <dune/common/typetraits.hh>
 
#include <dune/geometry/referenceelements.hh>
 
namespace Dune
{
 
  // External Forward Declarations
  // -----------------------------
 
  template< int dim, int dimworld, class ct, class GridFamily >
  class GridDefaultImplementation;
 
 
 
  namespace FacadeOptions
  {
 
 
    template< int mydim, int cdim, class GridImp, template< int, int, class > class GeometryImp >
    struct StoreGeometryReference
    {
      static const bool v = true;
    };
 
  }
 
 
 
  //*****************************************************************************
  //
  // Geometry
  // forwards the interface to the implementation
  //
  //*****************************************************************************
 
  template< int mydim, int cdim, class GridImp, template< int, int, class > class GeometryImp >
  class Geometry
  {
  #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 GeometryImp< mydim, cdim, GridImp > Implementation;
 
    const Implementation &impl () const { return realGeometry; }
 
  public:
    enum { dimension=GridImp::dimension  };
    enum { mydimension=mydim  };
    enum { coorddimension=cdim  };
 
    enum { dimensionworld=GridImp::dimensionworld  };
    typedef typename GridImp::ctype ctype;
 
    typedef FieldVector<ctype, mydim> LocalCoordinate;
 
    typedef FieldVector< ctype, cdim > GlobalCoordinate;
 
    typedef typename Implementation::JacobianInverseTransposed JacobianInverseTransposed;
 
    typedef JacobianInverseTransposed Jacobian DUNE_DEPRECATED_MSG ( "type Geometry::Jacobian is deprecated, use Geometry::JacobianInverseTransposed instead." );
 
    typedef typename Implementation::JacobianTransposed JacobianTransposed;
 
    GeometryType type () const { return impl().type(); }
 
    bool affine() const { return impl().affine(); }
 
    int corners () const { return impl().corners(); }
 
    GlobalCoordinate corner ( int i ) const
    {
      return impl().corner( i );
    }
 
    GlobalCoordinate global (const LocalCoordinate& local) const
    {
      return impl().global( local );
    }
 
    LocalCoordinate local (const GlobalCoordinate& global) const
    {
      return impl().local( global );
    }
 
    ctype integrationElement (const LocalCoordinate& local) const
    {
      return impl().integrationElement( local );
    }
 
    ctype volume () const
    {
      return impl().volume();
    }
 
    GlobalCoordinate center () const
    {
      return impl().center();
    }
 
    const JacobianTransposed &
    jacobianTransposed ( const LocalCoordinate& local ) const
    {
      return impl().jacobianTransposed( local );
    }
 
    const JacobianInverseTransposed &
    jacobianInverseTransposed ( const LocalCoordinate &local ) const
    {
      return impl().jacobianInverseTransposed(local);
    }
 
    explicit Geometry ( const Implementation &impl )
      : realGeometry( impl )
    {
      deprecationWarning ( integral_constant< bool, storeReference >() );
    }
 
  private:
    const Geometry &operator= ( const Geometry &rhs );
 
    void DUNE_DEPRECATED_MSG( "This Dune::Geometry is still a reference to its implementation." )
    deprecationWarning ( integral_constant< bool, true > ) {}
 
    void
    deprecationWarning ( integral_constant< bool, false > ) {}
 
  protected:
    static const bool storeReference = FacadeOptions::StoreGeometryReference< mydim, cdim, GridImp, GeometryImp >::v;
 
    typename conditional< storeReference, const Implementation &, Implementation >::type realGeometry;
  };
 
 
 
  //************************************************************************
  // GEOMETRY Default Implementations
  //*************************************************************************
  //
  // --GeometryDefault
  //
  template<int mydim, int cdim, class GridImp, template<int,int,class> class GeometryImp>
  class GeometryDefaultImplementation
  {
  public:
    static const int mydimension = mydim;
    static const int coorddimension = cdim;
 
    // save typing
    typedef typename GridImp::ctype ctype;
 
    typedef FieldVector< ctype, mydim > LocalCoordinate;
    typedef FieldVector< ctype, cdim > GlobalCoordinate;
 
    typedef FieldMatrix< ctype, cdim, mydim > JacobianInverseTransposed;
 
    typedef FieldMatrix< ctype, mydim, cdim > JacobianTransposed;
 
    ctype volume () const
    {
      GeometryType type = asImp().type();
 
      // get corresponding reference element
      const ReferenceElement< ctype , mydim > & refElement =
        ReferenceElements< ctype, mydim >::general(type);
 
      LocalCoordinate localBaryCenter ( 0 );
      // calculate local bary center
      const int corners = refElement.size(0,0,mydim);
      for(int i=0; i<corners; ++i) localBaryCenter += refElement.position(i,mydim);
      localBaryCenter *= (ctype) (1.0/corners);
 
      // volume is volume of reference element times integrationElement
      return refElement.volume() * asImp().integrationElement(localBaryCenter);
    }
 
    GlobalCoordinate center () const
    {
      GeometryType type = asImp().type();
 
      // get corresponding reference element
      const ReferenceElement< ctype , mydim > & refElement =
        ReferenceElements< ctype, mydim >::general(type);
 
      // center is (for now) the centroid of the reference element mapped to
      // this geometry.
      return asImp().global(refElement.position(0,0));
    }
 
  private:
    GeometryImp<mydim,cdim,GridImp>& asImp () {return static_cast<GeometryImp<mydim,cdim,GridImp>&>(*this);}
    const GeometryImp<mydim,cdim,GridImp>& asImp () const {return static_cast<const GeometryImp<mydim,cdim,GridImp>&>(*this);}
  }; // end GeometryDefault
 
  template<int cdim, class GridImp, template<int,int,class> class GeometryImp>
  class GeometryDefaultImplementation<0,cdim,GridImp,GeometryImp>
  {
    // my dimension
    enum { mydim = 0 };
 
  public:
    static const int mydimension = mydim;
    static const int coorddimension = cdim;
 
    // save typing
    typedef typename GridImp::ctype ctype;
 
    typedef FieldVector< ctype, mydim > LocalCoordinate;
    typedef FieldVector< ctype, cdim > GlobalCoordinate;
 
    typedef FieldMatrix< ctype, cdim, mydim > JacobianInverseTransposed;
 
    typedef FieldMatrix< ctype, mydim, cdim > JacobianTransposed;
 
    FieldVector<ctype, cdim> global (const FieldVector<ctype, mydim>& local) const
    {
      return asImp().corner(0);
    }
 
    FieldVector<ctype, mydim> local (const FieldVector<ctype, cdim>& ) const
    {
      return FieldVector<ctype, mydim>();
    }
 
    bool checkInside (const FieldVector<ctype, mydim>& ) const
    {
      return true;
    }
 
    ctype volume () const
    {
      return 1.0;
    }
 
    FieldVector<ctype, cdim> center () const
    {
      return asImp().corner(0);
    }
 
  private:
    // Barton-Nackman trick
    GeometryImp<mydim,cdim,GridImp>& asImp () {return static_cast<GeometryImp<mydim,cdim,GridImp>&>(*this);}
    const GeometryImp<mydim,cdim,GridImp>& asImp () const {return static_cast<const GeometryImp<mydim,cdim,GridImp>&>(*this);}
  }; // end GeometryDefault
 
} // namespace Dune
 
#endif // DUNE_GRID_GEOMETRY_HH