hp2D/formula.hh

Go to the documentation of this file.

#ifndef formulahp2D_hh
#define formulahp2D_hh

#include "toolbox/sequence.hh"
#include "toolbox/set.hh"
#include "toolbox/hashMap.hh"
#include "formula/elementFormula.hh"
#include "space/element.hh"
#include "space/function.hh"

// debugging
#include "basics/debug.hh"

#define FormulaFromWeightConstr_D 0
#define FormulaFromWeightAppl_D 0

namespace concepts {

  template<typename F>
  class Array;

  template<typename F>
  class Vector;

  class Attribute;
  class Edge;
  class Edge2d;

} // namespace concepts

namespace hp2D {

  // forward declarations
  class TraceSpace;

  template<typename F>
  class BaseQuad;

  template<typename F>
  class Quad;

  template<typename F>
  class BaseEdge;

  using concepts::Real;
  using concepts::Real2d;

  // *********************************************************** H1Extension **

  template<class F>
  class H1Extension : public concepts::ElementFormula<F> {
  public:
    H1Extension(const concepts::ElementFormula<F>& frm);
    H1Extension(const concepts::ElementFormula<F>& frm,
                const concepts::Set<concepts::Attribute> attributes);

    virtual ~H1Extension();

    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 Real2d& p, const Real t = 0.0) const;
    virtual F operator() (const concepts::ElementWithCell<Real>& elm,
                          const concepts::Real3d& p, const Real t = 0.0) const;

    virtual H1Extension<F>* clone() const {
      return new H1Extension<F>(*frm_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    std::auto_ptr<const concepts::ElementFormula<F> > frm_;
    const concepts::Set<concepts::Attribute> attributes_;
    mutable const concepts::ElementWithCell<Real>* elm_;
    mutable concepts::Array<concepts::ElementWithCell<Real>*> elmEdges_;
    mutable concepts::Sequence<concepts::Edge2d*> cellEdges_;
    mutable concepts::HashMap<const concepts::Edge*> edges_;
    mutable concepts::HashMap<F> vtxValues_;

    bool compute_(const hp2D::Quad<Real>* quad, const Real2d& p, const Real t,
                  F& val) const;

    void clear_() const;
  };

  // ********************************************** ElementFormulaInterpGrad **

  template<typename F, uint dim = 2>
  class ElementFormulaInterpGrad {};

  // ******************************************** ElementFormulaInterpGrad<2> **

  template<typename F>
  class ElementFormulaInterpGrad<F,2> : 
    public concepts::ElementFormula<concepts::Point<F,2> > {
  public:
    ElementFormulaInterpGrad(const concepts::ElementFormula<F>& f);

    virtual concepts::Point<F,2> operator() 
      (const concepts::ElementWithCell<Real>& elm,
       const Real p, const Real t = 0.0) const { return concepts::Point<F,2>(0.0); }
    virtual concepts::Point<F,2> operator()
      (const concepts::ElementWithCell<Real>& elm,
       const concepts::Real2d& p, const Real t = 0.0) const;
    virtual concepts::Point<F,2> operator()
      (const concepts::ElementWithCell<Real>& elm,
       const concepts::Real3d& p, const Real t = 0.0) const  { return concepts::Point<F,2>(0.0); }

    virtual ElementFormulaInterpGrad<F,2>* clone() const {
      return new ElementFormulaInterpGrad<F,2>(*f_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    std::auto_ptr<const concepts::ElementFormula<F> > f_;
    mutable const concepts::ElementWithCell<Real>* quad_;
    mutable concepts::Array<Real> x_[2];
    mutable bool samePoints_;
    mutable concepts::Array<F> values_;
    mutable bool zeroElement_;
  };

  // ********************************************* ElementFormulaInterpGradN **

  template<typename F, uint dim = 2>
  class ElementFormulaInterpGradN {};

  template<typename F>
  class ElementFormulaInterpGradN<F,2> : 
    public concepts::ElementFormula<concepts::Point<F,2> > {
  public:
    ElementFormulaInterpGradN(const concepts::ElementFormula<F>& f);

    virtual concepts::Point<F,2> operator() 
      (const concepts::ElementWithCell<Real>& elm,
       const Real p, const Real t = 0.0) const { return concepts::Point<F,2>(0.0); }
    virtual concepts::Point<F,2> operator()
      (const concepts::ElementWithCell<Real>& elm,
       const concepts::Real2d& p, const Real t = 0.0) const;
    virtual concepts::Point<F,2> operator()
      (const concepts::ElementWithCell<Real>& elm,
       const concepts::Real3d& p, const Real t = 0.0) const  { return concepts::Point<F,2>(0.0); }

    virtual ElementFormulaInterpGradN<F,2>* clone() const {
      return new ElementFormulaInterpGradN<F,2>(*f_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    std::auto_ptr<const concepts::ElementFormula<F> > f_;
    mutable const concepts::ElementWithCell<Real>* quad_;
    mutable concepts::Array<F> coeff_;
    mutable bool zeroElement_;
  };

  // ************************************************ ElementFormulaEdgeMean **

  template<typename F>
  class ElementFormulaEdgeMean : public concepts::ElementFormula<F> {
  public:
    ElementFormulaEdgeMean(const hp2D::TraceSpace& spc,
                           const concepts::Vector<F>& v,
                           const concepts::ElementFunction<F>& f);

    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 (*this)(elm, p[0], t);
    }
    virtual F operator() (const concepts::ElementWithCell<Real>& elm,
                          const concepts::Real3d& p,
                          const Real t = 0.0) const  { 
      return (*this)(elm, p[0], t);
    }

    virtual ElementFormulaEdgeMean<F>* clone() const {
      return new ElementFormulaEdgeMean<F>(spc_, v_, *f_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const hp2D::TraceSpace& spc_;
    const concepts::Vector<F>& v_;
    std::auto_ptr<const concepts::ElementFunction<F> > f_;
  };

  // **************************************** ElementFormulaSignNormalVector **

  class ElementFormulaSignNormalVector : public concepts::ElementFormula<Real> {
  public:
    virtual Real operator() (const concepts::ElementWithCell<Real>& elm,
                          const Real p, const Real t = 0.0) const;
    virtual Real operator() (const concepts::ElementWithCell<Real>& elm,
                          const concepts::Real2d& p,
                          const Real t = 0.0) const { 
      return (*this)(elm, p[0], t);
    }
    virtual Real operator() (const concepts::ElementWithCell<Real>& elm,
                          const concepts::Real3d& p,
                          const Real t = 0.0) const  { 
      return (*this)(elm, p[0], t);
    }

    virtual ElementFormulaSignNormalVector* clone() const {
      return new ElementFormulaSignNormalVector();
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };


} // namespace hp2D

#endif // formulahp2D_hh