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 "geometry/connectorSet.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::unique_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::unique_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::unique_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::unique_ptr<const concepts::ElementFunction<F> > f_;
  };
 
  // ************************************************ ElementFormulaEdgeJump **
 
  template<typename F>
  class ElementFormulaEdgeJump : public concepts::ElementFormula<F> {
  public:
    ElementFormulaEdgeJump(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 ElementFormulaEdgeJump<F>* clone() const {
      return new ElementFormulaEdgeJump<F>(spc_, v_, *f_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const hp2D::TraceSpace& spc_;
    const concepts::Vector<F>& v_;
    std::unique_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