formula.hh

Go to the documentation of this file.

 
#ifndef formulahp1d_hh
#define formulahp1d_hh
 
#include "basics/operations.hh"
#include "formula/formula.hh"
#include "geometry/formula.hh"
#include "geometry/arrays.hh"
#include "function/vector.hh"
#include "element.hh"
 
namespace hp1D {
 
  // *********************************************** ElementFormulaInterpGrad **
 
  template<typename F>
  class ElementFormulaInterpGrad: public concepts::ElementFormula<F> {
  public:
    ElementFormulaInterpGrad(const concepts::ElementFormulaContainer<F> frm);
 
    virtual F operator()(const concepts::ElementWithCell<Real>& elm,
        const Real p, const Real t = 0.0) const;
    virtual F operator()(const concepts::ElementWithCell<Real>& elm,
        const concepts::Real2d& p, const Real t = 0.0) const {
      return 0.0;
    }
    virtual F operator()(const concepts::ElementWithCell<Real>& elm,
        const concepts::Real3d& p, const Real t = 0.0) const {
      return 0.0;
    }
 
    virtual ElementFormulaInterpGrad<F>* clone() const {
      return new ElementFormulaInterpGrad<F>(frm_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const concepts::ElementFormulaContainer<F> frm_;
    mutable concepts::Array<Real> x_;
    mutable const concepts::ElementWithCell<Real>* edge_;
    mutable concepts::Array<F> values_;
  };
 
  // *************************************************** ArrayElementFormula **
 
 
  template<class F = Real>
  class ArrayElementFormula: public concepts::Array<F> {
  public:
    ArrayElementFormula();
    ArrayElementFormula(const BaseElement<Real>& elm,
        const concepts::ElementFormulaContainer<F> frm);
    void compute(const BaseElement<Real>& elm,
        const concepts::ElementFormulaContainer<F> frm);
  };
 
  template<class F>
  ArrayElementFormula<F>::ArrayElementFormula() :
      concepts::Array<F>() {
  }
 
  template<class F>
  ArrayElementFormula<F>::ArrayElementFormula(const BaseElement<Real>& elm,
      const concepts::ElementFormulaContainer<F> frm) :
      concepts::Array<F>(0) {
    compute(elm, frm);
  }
 
  // ****************************************************** LinearFormHelper **
 
  template<uint i, class F = Real>
  class LinearFormHelper {
  };
 
  // *************************************************** LinearFormHelper<0> **
 
  template<class F>
  class LinearFormHelper<0, F> {
  public:
    LinearFormHelper(const concepts::ElementFormulaContainer<F> frm);
    virtual ~LinearFormHelper();
 
  protected:
    void computeIntermediate_(const BaseElement<Real>& elm) const;
 
    mutable concepts::Array<F> intermediateValue_;
 
    const concepts::ElementFormulaContainer<F> frm_;
  };
 
  // *************************************************** LinearFormHelper<1> **
 
  template<class F>
  class LinearFormHelper<1, F> {
  public:
    LinearFormHelper(const concepts::ElementFormulaContainer<F> frm);
    virtual ~LinearFormHelper();
 
  protected:
    void computeIntermediate_(const Element<Real>& elm) const;
 
    mutable concepts::Array<F> intermediateValue_;
 
    const concepts::ElementFormulaContainer<F> frm_;
  };
 
  // **************************************************** BilinearFormHelper **
 
  template<uint i, uint j, class F = Real>
  class BilinearFormHelper {
  };
 
  // *********************************************** BilinearFormHelper<0,0> **
 
  template<class F>
  class BilinearFormHelper<0, 0, F> : public LinearFormHelper<0, F> {
  public:
    BilinearFormHelper(const concepts::ElementFormulaContainer<F> frm) :
        LinearFormHelper<0, F>(frm) {
    }
 
    const concepts::ElementFormula<F>* formula() const {
      return &this->frm_.frm();
    }
  };
 
  // *********************************************** BilinearFormHelper<1,1> **
 
  template<class F>
  class BilinearFormHelper<1, 1, F> {
  public:
    BilinearFormHelper(const concepts::ElementFormulaContainer<F> frm =
        concepts::ElementFormulaContainer<F>());
    virtual ~BilinearFormHelper();
  protected:
    void computeIntermediate_(const Element<Real>& elm) const;
    mutable concepts::Array<F> intermediateValue_;
    const concepts::ElementFormulaContainer<F> frm_;
  };
 
   template<class F>
   class BilinearFormHelper<2, 2, F> {
   public:
     BilinearFormHelper(const concepts::ElementFormulaContainer<F> frm =
         concepts::ElementFormulaContainer<F>());
     virtual ~BilinearFormHelper();
 
   protected:
 
     mutable concepts::Array<F> intermediateValueHess_;
 
     mutable concepts::Array<F> intermediateValueJac_;
 
     mutable concepts::Array<F> intermediateValueFrm_;
 
     void computeIntermediate_(const Element<Real>& elm) const;
 
     const concepts::ElementFormulaContainer<F> frm_;
 
   };
 
   /*********************************** BilinearFormVtxHelper **************************/
   template<class F = Real>
   class BilinearFormVtxHelper {
   public:
     BilinearFormVtxHelper(const concepts::ElementFormulaContainer<F> frm) :
         frm_(frm) {
     }
 
     const concepts::ElementFormula<F>* formula() const {
       return &this->frm_.frm();
     }
 
     const concepts::Array<Real> getInvJacobeanDet(
         const hp1D::Element<Real>& elm) const;
 
     const concepts::Array<Real> getInvJacobeanDetSq (
         const hp1D::Element<Real>& elm) const;
 
     const concepts::Array<Real> getTangentialSecondDerivative(
         const hp1D::Element<Real>& elm) const;
 
     const concepts::Array<F> getFrmVal(const hp1D::Element<Real>& elm) const;
 
   protected:
 
     const concepts::ElementFormulaContainer<F> frm_;
   };
 
 
} // namespace hp1D
 
#endif //formulahp1d_hh