functionwrappers.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_PDELAB_COMMON_FUNCTIONWRAPPERS_HH
#define DUNE_PDELAB_COMMON_FUNCTIONWRAPPERS_HH
 
#include <vector>
#include <tuple>
 
#include <dune/typetree/nodetags.hh>
 
#include "function.hh"
 
namespace Dune {
  namespace PDELab {
 
 
    //
    //  PointwiseGridFunctionAdapter
    //
 
 
    template<typename Engine, typename F0, typename... Functions>
    class PointwiseGridFunctionAdapter :
      public GridFunctionBase<
      typename F0::Traits,
      PointwiseGridFunctionAdapter<Engine, F0, Functions...> >
    {
    public:
      typedef typename F0::Traits Traits;
 
    private:
      const Engine& engine;
      std::tuple<const F0*, const Functions*...> storage;
 
 
      template<unsigned int I, unsigned int N>
      void evaluate(
        const typename Traits::ElementType& e,
        const typename Traits::DomainType& x,
        std::vector<typename Traits::RangeType>& y,
        std::integral_constant<unsigned int, I>,
        std::integral_constant<unsigned int, N>,
        std::integral_constant<bool, true>) const {
        std::get<I>(storage)->evaluate(e, x, y[I]);
        evaluate(e,x,y,
          std::integral_constant<unsigned int, I+1>(),
          std::integral_constant<unsigned int, N>(),
          std::integral_constant<bool, (I+1<N)>()
          );
      }
 
      template<unsigned int I>
      void evaluate(
        const typename Traits::ElementType& e,
        const typename Traits::DomainType& x,
        std::vector<typename Traits::RangeType>& y,
        std::integral_constant<unsigned int, I>,
        std::integral_constant<unsigned int, I>,
        std::integral_constant<bool, false>) const
      {}
 
    public:
 
      template<typename... F>
      PointwiseGridFunctionAdapter(const Engine& engine_, const F&... functions)
        : engine(engine_), storage(&functions...)
      {}
 
          inline void evaluate (const typename Traits::ElementType& e,
                                                        const typename Traits::DomainType& x,
                                                        typename Traits::RangeType& y) const
          {
        static const unsigned int N = sizeof...(Functions)+1;
        std::vector<typename Traits::RangeType> in(N);
        evaluate(e, x, in,
          std::integral_constant<unsigned int, 0>(),
          std::integral_constant<unsigned int, N>(),
          std::integral_constant<bool, true>()
          );
        engine.evaluate(y, in);
          }
 
          inline const typename Traits::GridViewType& getGridView () const
          {
        return std::get<0>(storage)->getGridView();
          }
 
    };
 
    template<typename Engine, typename... Functions>
    PointwiseGridFunctionAdapter<Engine, Functions...>
    makePointwiseGridFunctionAdapter(const Engine& engine, const Functions&... f)
    {
      return PointwiseGridFunctionAdapter
        <Engine,Functions...>
        (engine,f...);
    }
 
    //
    //  AdapterEngines
    //
 
    class PointwiseAdapterEngine
    {
    public:
 
 
      template<typename Domain, typename Range>
      void evaluate(Range& out,
                    const std::vector<Domain>& in) const;
    };
 
 
    template<typename S>
    class PointwiseScaleAdapterEngine
    {
      S scale;
 
    public:
 
 
      PointwiseScaleAdapterEngine(const S scale_)
        : scale(scale_)
      {}
 
      template<typename Domain, typename Range>
      void evaluate(Range& out,
                    const std::vector<Domain>& in) const {
        assert(in.size() == 1);
        out = in[0];
        out *= scale;
      }
    };
 
    template<typename S>
    PointwiseScaleAdapterEngine<S>
    makePointwiseScaleAdapterEngine(const S scale) {
      return PointwiseScaleAdapterEngine<S>(scale);
    }
 
 
    class PointwiseSumAdapterEngine
    {
    public:
 
      template<typename Domain, typename Range>
      void evaluate(Range& out,
                    const std::vector<Domain>& in) const {
        out = 0;
        for(unsigned i = 0; i < in.size(); ++i)
          out += in[i];
      }
    };
 
 
  } // namespace PDELab
} // namespace Dune
 
#endif // DUNE_PDELAB_COMMON_FUNCTIONWRAPPERS_HH