hp1D/formula.hh

Go to the documentation of this file.

/* helper classes for bilinear forms and linear forms in hp1d
 */

#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 Element<Real>& elm,
                        const concepts::ElementFormulaContainer<F> frm);
    void compute(const Element<Real>& elm,
                 const concepts::ElementFormulaContainer<F> frm);
  };

  template<class F>
  ArrayElementFormula<F>::ArrayElementFormula() : concepts::Array<F>() {}

  template<class F>
  ArrayElementFormula<F>::ArrayElementFormula
  (const Element<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 Element<Real>& elm);

    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);

    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);
    concepts::Array<F> intermediateValue_;
    const concepts::ElementFormulaContainer<F> frm_;
  };

} // namespace hp1D

#endif //formulahp1d_hh