memberadaptor.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
 
#ifndef DUNE_PDELAB_FUNCTION_MEMBERADAPTOR_HH
#define DUNE_PDELAB_FUNCTION_MEMBERADAPTOR_HH
 
#include <cstddef>
 
#include <dune/common/fvector.hh>
 
#include <dune/pdelab/common/function.hh>
 
namespace Dune {
  namespace PDELab {
 
 
    template<class Member, class Class,
             class GV, class RF, std::size_t dimR = 1>
    class MemberFunctionToGridFunctionAdaptor :
      public GridFunctionBase<
        GridFunctionTraits< GV, RF, dimR, FieldVector<RF, dimR> >,
        MemberFunctionToGridFunctionAdaptor<Member, Class, GV, RF, dimR>
      >
    {
    public:
      typedef GridFunctionTraits< GV, RF, dimR, FieldVector<RF, dimR> > Traits;
 
    private:
      typedef GridFunctionBase<
        Traits,
        MemberFunctionToGridFunctionAdaptor<Member, Class, GV, RF, dimR>
        > Base;
 
      const Class &obj;
      Member member;
      GV gv;
 
    public:
 
      MemberFunctionToGridFunctionAdaptor(const Class &obj_, Member member_,
                                          const GV& gv_) :
        obj(obj_), member(member_), gv(gv_)
      { }
 
      void evaluate(const typename Traits::ElementType &e,
                    const typename Traits::DomainType &x,
                    typename Traits::RangeType &y) const
      {
        (obj.*member)(e, x, y);
      }
 
      const GV& getGridView() const { return gv; }
    };
 
 
    template<class RF, std::size_t dimRange,
             class GV, class Class, class Member>
    MemberFunctionToGridFunctionAdaptor<Member, Class, GV, RF, dimRange>
    makeMemberFunctionToGridFunctionAdaptor(const Class &obj, Member member,
                                            const GV &gv)
    {
      return MemberFunctionToGridFunctionAdaptor
        <Member, Class, GV, RF, dimRange>(obj, member, gv);
    }
 
 
    template<class Member, class Class,
             class GV, class RF, std::size_t dimR = 1>
    class TwoArgsMemberFunctionToGridFunctionAdaptor :
      public GridFunctionBase<
        GridFunctionTraits< GV, RF, dimR, FieldVector<RF, dimR> >,
        TwoArgsMemberFunctionToGridFunctionAdaptor<Member, Class, GV, RF, dimR>
      >
    {
    public:
      typedef GridFunctionTraits< GV, RF, dimR, FieldVector<RF, dimR> > Traits;
 
    private:
      typedef GridFunctionBase<
        Traits,
        TwoArgsMemberFunctionToGridFunctionAdaptor<Member, Class, GV, RF, dimR>
        > Base;
 
      const Class &obj;
      Member member;
      GV gv;
 
    public:
 
      TwoArgsMemberFunctionToGridFunctionAdaptor(const Class &obj_,
                                                 Member member_,
                                                 const GV& gv_) :
        obj(obj_), member(member_), gv(gv_)
      { }
 
      void evaluate(const typename Traits::ElementType &e,
                    const typename Traits::DomainType &x,
                    typename Traits::RangeType &y) const
      {
        y = (obj.*member)(e, x);
      }
 
      const GV& getGridView() const { return gv; }
    };
 
 
    template<class RF, std::size_t dimRange,
             class GV, class Class, class Member>
    TwoArgsMemberFunctionToGridFunctionAdaptor<Member, Class, GV, RF,
                                               dimRange>
    makeTwoArgsMemberFunctionToGridFunctionAdaptor(const Class &obj,
                                                     Member member,
                                                     const GV &gv)
    {
      return TwoArgsMemberFunctionToGridFunctionAdaptor
        <Member, Class, GV, RF, dimRange>(obj, member, gv);
    }
 
 
    template<class Member, class Class,
             class GV, class RF, std::size_t dimR = 1>
    class TwoArgsMemberFunctionToBoundaryGridFunctionAdaptor :
      public BoundaryGridFunctionBase<
        BoundaryGridFunctionTraits< GV, RF, dimR, FieldVector<RF, dimR> >,
        TwoArgsMemberFunctionToBoundaryGridFunctionAdaptor<Member, Class, GV,
                                                           RF, dimR>
      >
    {
    public:
      typedef BoundaryGridFunctionTraits< GV, RF, dimR, FieldVector<RF, dimR> >
        Traits;
 
    private:
      typedef BoundaryGridFunctionBase<
        Traits,
        TwoArgsMemberFunctionToBoundaryGridFunctionAdaptor<Member, Class, GV,
                                                           RF, dimR>
        > Base;
 
      const Class &obj;
      Member member;
      GV gv;
 
    public:
 
      TwoArgsMemberFunctionToBoundaryGridFunctionAdaptor(const Class &obj_,
                                                         Member member_,
                                                         const GV& gv_) :
        obj(obj_), member(member_), gv(gv_)
      { }
 
      template<typename Intersection>
      void evaluate(const Intersection &is,
                    const typename Traits::DomainType &x,
                    typename Traits::RangeType &y) const
      {
        y = (obj.*member)(is, x);
      }
 
      const GV& getGridView() const { return gv; }
    };
 
 
    template<class RF, std::size_t dimRange,
             class GV, class Class, class Member>
    TwoArgsMemberFunctionToBoundaryGridFunctionAdaptor<Member, Class, GV, RF,
                                                       dimRange>
    make2ArgsMemberFunctionToBoundaryGridFunctionAdaptor(const Class &obj,
                                                         Member member,
                                                         const GV &gv)
    {
      return TwoArgsMemberFunctionToBoundaryGridFunctionAdaptor
        <Member, Class, GV, RF, dimRange>(obj, member, gv);
    }
 
  } // namspace PDELab
} // namspace Dune
 
#endif // DUNE_PDELAB_FUNCTION_MEMBERADAPTOR_HH