lambdaFormula.hh

 
#ifndef CONCEPTS_LAMBDAFORMULA
#define CONCEPTS_LAMBDAFORMULA
 
#if __cplusplus >= 201103L
 
#include "formula/formula.hh"
#include "elementFormula.hh"
#include "space/element.hh"
#include <type_traits>
 
#if defined(__clang__)
#include <functional>
#endif
 
#if defined(__GNUC__)
#if __GNUC__ >= 7
#include <functional>
#endif
#endif
 
 
namespace concepts {
  
  namespace detail {
 
    template<int CoordDim>
    using CoordinateT = typename concepts::Coordinate<CoordDim>::type ;
 
    template<int CoordDim>
    using CoordinateParamT = typename concepts::CoordinateParam<CoordDim>::type ;
 
    template<int Dim> struct CoordinateTag {};                                              
    template<int ParamDim, int Dim>
    typename std::enable_if<Dim!=1,Point<Real,Dim>>::type elemMap_ (const concepts::ElementWithCell<concepts::Real> &elm, 
                              CoordinateParamT<ParamDim> p,
                              CoordinateTag<ParamDim>, 
                              CoordinateTag<Dim>) {
      return elm.cell().elemMap(p);         
    }                                
 
    CoordinateT<1> elemMap_ (const concepts::ElementWithCell<concepts::Real> &elm, 
                             CoordinateParamT<1> p,
                             CoordinateTag<1>, 
                             CoordinateTag<1>);                               
    CoordinateT<1> elemMap_ (const concepts::ElementWithCell<concepts::Real> &elm, 
                             CoordinateParamT<2> p,
                             CoordinateTag<2>, 
                             CoordinateTag<1>);                               
    CoordinateT<1> elemMap_ (const concepts::ElementWithCell<concepts::Real> &elm, 
                             CoordinateParamT<3> p,
                             CoordinateTag<3>, 
                             CoordinateTag<1>);                               
  }
  
  // **************************************** BaseLambdaElementFormula ***
 
  template<class Derived, class F>
  class BaseLambdaElementFormula : public concepts::ElementFormula<F> {
  public:
    F operator() (const concepts::ElementWithCell<concepts::Real> &elm, detail::CoordinateParamT<1> p, const Real t=0.) const {
      return static_cast<const Derived*>(this)->template impl_<1>(elm,p,t);
    }
    F operator() (const concepts::ElementWithCell<concepts::Real> &elm, detail::CoordinateParamT<2> p, const Real t=0.) const {
      return static_cast<const Derived*>(this)->template impl_<2>(elm,p,t);
    }
    F operator() (const concepts::ElementWithCell<concepts::Real> &elm, detail::CoordinateParamT<3> p, const Real t=0.) const {
      return static_cast<const Derived*>(this)->template impl_<3>(elm,p,t);
    }
  };
 
  // *********************************************** BaseLambdaFormula ***
 
  template<class Derived, class F>
  class BaseLambdaFormula : public concepts::Formula<F> {
  public:
    F operator() (detail::CoordinateParamT<1> p, const Real t=0.) const {
      return static_cast<const Derived*>(this)->template impl_<1>(p,t);
    }
    F operator() (detail::CoordinateParamT<2> p, const Real t=0.) const {
      return static_cast<const Derived*>(this)->template impl_<2>(p,t);
    }
    F operator() (detail::CoordinateParamT<3> p, const Real t=0.) const {
      return static_cast<const Derived*>(this)->template impl_<3>(p,t);
    }
  };
  
  // *************************************************** LambdaFormula ***
 
  template<int Dim, class F = concepts::Real>
  class LambdaFormula : 
    public BaseLambdaFormula<LambdaFormula<Dim,F>,F> {
  public:
    using FieldT = F;
    using FuncT = std::function<F(detail::CoordinateParamT<Dim>)>;
    
    template<class FuncParamT>
    LambdaFormula(const FuncParamT& func) : func_(func) {}
    
    LambdaFormula* clone() const { 
      return new LambdaFormula(*this); 
    }
      
  private:
    FuncT func_;
    
    template<int ParamDim>
    F impl_ (detail::CoordinateParamT<ParamDim> p, const Real t) const
    {
      return func_(p);
    }
    friend class BaseLambdaFormula<LambdaFormula<Dim,F>,F>;
  };
  
  // ******************************************** LambdaElementFormula ***
 
  template<int Dim, class F = concepts::Real>
  class LambdaElementFormula :
    public BaseLambdaElementFormula<LambdaElementFormula<Dim,F>,F> {
  public:
    using FieldT = F;
    using FuncT = std::function<F(
                    const concepts::ElementWithCell<concepts::Real>&,
                    detail::CoordinateParamT<Dim>)>;
    
    template<class FuncParamT>
    LambdaElementFormula(const FuncParamT& func) : func_(func) {}
    
    LambdaElementFormula* clone() const { 
      return new LambdaElementFormula(*this); 
    }
      
  private:
    FuncT func_;
    
    template<int ParamDim>
    F impl_ (const concepts::ElementWithCell<concepts::Real> &elm, 
             detail::CoordinateParamT<ParamDim> p,
             const concepts::Real t) const {
      return /*Dim == ParamDim ? */   
        func_(elm,p) /*:
        throw concepts::Assertion()*/;
    }
    
    friend class BaseLambdaElementFormula<LambdaElementFormula<Dim,F>,F>;
  };
}
 
#endif // __cplusplus >= 201103L
 
#endif // CONCEPTS_LAMBDAFORMULA