function.hh

Go to the documentation of this file.

 
#ifndef hpFunction1d_hh
#define hpFunction1d_hh
 
#include "basics/typedefs.hh"
#include "toolbox/array.hh"
#include "space/function.hh"
#include "element.hh"
#ifdef HAS_XERUS
#include "rysElement.hh"
#endif
 
namespace hp1D {
 
  using concepts::Real;
 
  // ***************************************************************** Value **
 
  template<typename F = Real,
           typename G = typename concepts::Realtype<F>::type>
  class Value : public concepts::ElementFunction<F, G> {
  public:
    virtual uint n() const { return 1; }
 
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const uint *i) const;
    virtual void operator() (const concepts::Element<G>& elm, const uint* j,
                             concepts::Array<F>& val, const uint* i) const;
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const Real p, 
                             const Real t = 0.0) const;
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const concepts::Real2d& p,
                             const Real t = 0.0) const;
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const concepts::Real3d& p,
                             const Real t = 0.0) const;
 
    virtual Value<F,G>* clone() const { 
      return new Value();
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    bool compute_(const hp1D::Element<G>* elm,
                  const concepts::Array<F>& coeff,
                  F& val, const uint i) const;
    bool compute_(const hp1D::Element<G>* elm, const uint j,
                  F& val, const uint i) const;
    bool compute_(const hp1D::Element<G>* elm,
                  const concepts::Array<F>& coeff,
                  F& val, const Real p, const Real t = 0.0) const;
    bool compute_(const hp1D::LegendreElement<G>* elm,
                  const concepts::Array<F>& coeff,
                  F& val, const Real p, const Real t = 0.0) const;
#ifdef HAS_XERUS
    bool compute_(const hp1D::RysElement<G>* elm,
                  const concepts::Array<F>& coeff,
                  F& val, const Real p, const Real t = 0.0) const;
#endif // HAS_XERUS
  };
 
  // ****************************************************************** Grad **
 
  template<typename F = Real,
           typename G = typename concepts::Realtype<F>::type>
  class Grad : public concepts::ElementFunction<F, G> {
  public:
    virtual uint n() const { return 1; }
 
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const uint *i) const;
    virtual void operator() (const concepts::Element<G>& elm, const uint* j,
                             concepts::Array<F>& val, const uint* i) const;
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const Real p, 
                             const Real t = 0.0) const;
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const concepts::Real2d& p,
                             const Real t = 0.0) const;
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const concepts::Real3d& p,
                             const Real t = 0.0) const;
 
    virtual Grad<F,G>* clone() const { 
      return new Grad();
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    bool compute_(const hp1D::Element<G>* elm,
                  const concepts::Array<F>& coeff,
                  F& val, const uint i) const;
    bool compute_(const hp1D::Element<G>* elm, const uint j,
                  F& val, const uint i) const;
    bool compute_(const hp1D::Element<G>* elm,
                  const concepts::Array<F>& coeff,
                  F& val, const Real p, const Real t = 0.0) const;
  };
 
} // namespace hp1D
 
#endif // hpFunction1d_hh