function.hh

Go to the documentation of this file.

 
#ifndef hpFunction3d_hh
#define hpFunction3d_hh
 
#include "../space.hh"
#include "neumannTraceElement3d.hh"
 
#include "toolbox/sequence.hh"
#include "geometry/connectorSet.hh"
 
 
namespace hp3D {
   //forward declaration
  class Hexahedron;
  template<class F>
  class NeumannTraceElement3d;
 
  using concepts::Real;
  using concepts::Real2d;
  using concepts::Real3d;
 
 
  // ***************************************************************** Value **
 
  template<class F, class G = concepts::Real>
  class Value: public concepts::ElementFunction<F, G> {
  public:
 
    virtual ~Value() {}
 
    virtual Value<F, G>* clone() const;
 
    virtual uint n() const {
      return 1;
    }
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff, F& val, const uint *i) const;
    
    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 Real2d& p, const Real t = 0.0) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff, F& val,
                            const Real3d& 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 Real3d& p, const Real t = 0.0) const;
 
  private:
 
    bool compute_(const Hexahedron* elm, const concepts::Array<F>& coeff,
                     F& val, const uint* i) const;
 
    bool compute_(const Hexahedron* elm, const concepts::Array<F>& coeff,
        F& val, const Real3d& p, const Real t) const;
 
    bool compute_(const NeumannTraceElement3d<Real>* elm, const concepts::Array<F>& coeff,
             F& val, const Real2d& p, const Real t) const;
 
  };
 
  // ****************************************************************** Grad **
 
  template<class F, class G = Real>
  class Grad: public concepts::ElementFunction<F, G> {
 
  public:
 
    virtual ~Grad() {
    }
 
 
    virtual Grad<F, G>* clone() const;
 
    virtual uint n() const {
      return 3;
    }
 
    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 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 Real3d& p, const Real t = 0.0) const;
 
  };
 
  // ****************************************************************** Laplacian **
 
  template<class F, class G = Real>
  class Laplacian: public concepts::ElementFunction<F, G> {
 
  public:
 
    virtual ~Laplacian() {
    }
 
 
    virtual Laplacian<F, G>* clone() const override;
 
    virtual uint n() const override{
      return 1;
    }
 
    void operator()(const concepts::Element<G>& elm,
                    const concepts::Array<F>& coeff,
                    F& val, const uint *i) const;
 
    void operator()(const concepts::Element<G>& elm,
                    const concepts::Array<F>& coeff,
                    concepts::Array<F>& val,
                    const uint *i) const override {
      val.resize(1);
      (*this)(elm, coeff, val[0], i);
    }
 
    void operator()(const concepts::Element<G>& elm,
                    const uint* j,
                    concepts::Array<F>& val,
                    const uint* i) const override;
 
    void operator()(const concepts::Element<G>& elm,
                    const concepts::Array<F>& coeff,
                    concepts::Array<F>& val,
                    const concepts::Real p,
                    const concepts::Real t = 0.0) const override;
 
    void operator()(const concepts::Element<G>& elm,
                    const concepts::Array<F>& coeff, concepts::Array<F>& val,
                    const concepts::Real2d& p,
                    const concepts::Real t = 0.0) const override;
 
 
    void operator()(const concepts::Element<G>& elm,
                    const concepts::Array<F>& coeff, F& val,
                    const concepts::Real3d& p,
                    const concepts::Real t = 0.0) const;
 
    void operator()(const concepts::Element<G>& elm,
                    const concepts::Array<F>& coeff, concepts::Array<F>& val,
                    const concepts::Real3d& p,
                    const concepts::Real t = 0.0) const override {
      val.resize(1);
      (*this)(elm, coeff, val[0], p, t);
    }
 
 
  };
 
 
 
}/*namespace hp3d */
 
#endif /* hpFunction3d_hh */