boundaryprojection.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_BOUNDARYPROJECTION_HH
#define DUNE_BOUNDARYPROJECTION_HH
 
//- system includes
#include <cmath>
 
//- Dune includes
#include <dune/common/fvector.hh>
#include <dune/common/shared_ptr.hh>
 
#include <dune/geometry/multilineargeometry.hh>
 
#include <dune/grid/common/boundarysegment.hh>
 
namespace Dune
{
 
  template <int dimworld>
  struct DuneBoundaryProjection
  {
    typedef FieldVector< double, dimworld> CoordinateType;
    virtual ~DuneBoundaryProjection() {}
 
    virtual CoordinateType operator() (const CoordinateType& global) const = 0;
  };
 
  template < int dimworld >
  class BoundaryProjectionWrapper
    : public DuneBoundaryProjection< dimworld >
  {
  protected:
    typedef DuneBoundaryProjection< dimworld > BaseType;
    const BaseType& proj_;
  public:
    typedef typename BaseType :: CoordinateType CoordinateType;
 
    // constructor taking other projection
    BoundaryProjectionWrapper( const BaseType& proje )
      : proj_( proje )
    {}
 
    ~BoundaryProjectionWrapper () {}
 
    CoordinateType operator() (const CoordinateType& global) const
    {
      return proj_( global );
    }
  };
 
  // BoundarySegmentWrapper
  // ----------------------
 
  template< int dim, int dimworld >
  class BoundarySegmentWrapper
    : public DuneBoundaryProjection< dimworld >
  {
    typedef DuneBoundaryProjection< dimworld > Base;
 
    typedef MultiLinearGeometry<typename Base::CoordinateType::value_type,dim-1,dimworld> FaceMapping;
 
  public:
    typedef typename Base::CoordinateType CoordinateType;
    typedef Dune::BoundarySegment< dim, dimworld > BoundarySegment;
 
    BoundarySegmentWrapper ( const GeometryType &type,
                             const std::vector< CoordinateType > &vertices,
                             const shared_ptr< BoundarySegment > &boundarySegment )
      : faceMapping_( FaceMapping( type, vertices ) ),
        boundarySegment_( boundarySegment )
    {}
 
    CoordinateType operator() ( const CoordinateType &global ) const
    {
      return boundarySegment() ( faceMapping_.local( global ) );
    }
 
    const BoundarySegment &boundarySegment () const
    {
      return *boundarySegment_;
    }
 
  private:
    FaceMapping faceMapping_;
    const shared_ptr< BoundarySegment > boundarySegment_;
  };
 
 
 
  //
  // Example of boundary projection projection to a circle
  //
  template <int dimworld>
  struct CircleBoundaryProjection : public DuneBoundaryProjection< dimworld >
  {
    typedef FieldVector< double, dimworld> CoordinateType;
 
    CircleBoundaryProjection(const double radius = std::sqrt( (double)dimworld ))
      : radius_( radius ) {}
 
    virtual ~CircleBoundaryProjection() {}
 
    virtual CoordinateType operator() (const CoordinateType& global) const
    {
      CoordinateType prj( global );
      // get adjustment factor
      const double factor = radius_  / global.two_norm();
      // adjust
      prj *= factor;
      return prj;
    }
 
  protected:
    const double radius_;
  };
 
} // end namespace
 
#endif // #ifndef DUNE_BOUNDARYPROJECTION_HH