formula.hh

Go to the documentation of this file.

 
#ifndef spcFormula_hh
#define spcFormula_hh
 
#include "basics/vectorsMatrices.hh"
#include "toolbox/sharedPointer.hh"
#include "formula/boundary.hh"
#include "formula/formula.hh"
#include "formula/vectorElementFormula.hh"
#include "geometry/boundaryConditions.hh"
#include "space/element.hh"
 
namespace concepts {
 
  // forward declaration
  template<typename F, typename G>
  class ElementFormula;             // defined in formula/elementFormula.hh
 
 
 
  // **************************************************** ElementFormulaLiCo **
 
  /* Linear combination of two element formulas of type \c F and \c G.
 
     @param F type of the 1st element formula and the return value
     @param G type of the 2nd element formula
     @param H type of the factors in the linear combination
     @param J type of the element, mostly Real
 
     @author Kersten Schmidt, 2004
   */
 
  template<class F = Real, class G = F, class H = F,
           class J = typename Realtype<F>::type>
  class ElementFormulaLiCo : public ElementFormula<F,J> {
  public:
    ElementFormulaLiCo(const ElementFormula<F,J>& frm1,
                       const ElementFormula<G,J>& frm2,
                       H a = 1.0, H b = 1.0) :
      frm1_(frm1.clone()), frm2_(frm2.clone()), a_(a), b_(b) {}
    ElementFormulaLiCo(const ElementFormulaLiCo<F,G,H,J>& frm) :
      frm1_(frm.frm1_->clone()), frm2_(frm.frm2_->clone()), 
      a_(frm.a_), b_(frm.b_) {}
    virtual ~ElementFormulaLiCo() {
      frm1_.reset(0); frm2_.reset(0);
    }
    virtual F operator() (const ElementWithCell<J>& elm, const Real p,
        const Real t = 0.0) const { 
      return combine_(elm,p,t);
    }
    virtual F operator() (const ElementWithCell<J>& elm, const Real2d& p,
        const Real t = 0.0) const  { 
      return combine_(elm,p,t);
    }
    virtual F operator() (const ElementWithCell<J>& elm, const Real3d& p,
        const Real t = 0.0) const  { 
      return combine_(elm,p,t);
    }
    virtual ElementFormulaLiCo<F,G,H,J>* clone() const {
      return new ElementFormulaLiCo<F,G,H,J>(*frm1_, *frm2_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    std::unique_ptr<const ElementFormula<F,J> > frm1_;
    std::unique_ptr<const ElementFormula<G,J> > frm2_;
    const H a_, b_;
    template<typename P>
    F combine_(const ElementWithCell<J>& elm, const P& p,
         const Real t = 0.0) const;
  };
 
  template<typename F, typename G, typename H, typename J>
  template<typename P>
  F ElementFormulaLiCo<F,G,H,J>::combine_(const ElementWithCell<J>& elm, 
            const P& p, const Real t) const {
    F val1 = (*frm1_)(elm, p, t);
    G val2 = (*frm2_)(elm, p, t);
    return val1 * (F)a_ + val2 * (F)b_;
  }
 
  template<typename F, typename G, typename H, typename J>
  std::ostream& ElementFormulaLiCo<F,G,H,J>::info(std::ostream& os) const {
    return os << concepts::typeOf(*this)<<"(" << a_ << " * " << *frm1_ << "+ "
        << b_ << " * " << *frm2_ << ")";
  }
 
//   template<class F, class G>
//   ElementFormulaLiCo<F,G,Real> 
//   operator+(const ElementFormula<F>& frm1,
//             const ElementFormula<G>& frm2) 
//   {
//     return ElementFormulaLiCo<F,G,Real>(frm1, frm2, 1.0,  1.0);
//   }
 
//   template<class F, class G>
//   ElementFormulaLiCo<F,G,Real> 
//   operator-(const ElementFormula<F>& frm1,
//             const ElementFormula<G>& frm2) 
//   {
//     return ElementFormulaLiCo<F,G,Real>(frm1, frm2, 1.0, -1.0);
//   }
 
  // ************************************************* ElementFormulaCompose **
 
  /* Composition of two element formulas of type \c H to one of type \c F.
 
     \c F has to have a constructor of two \c H, like Real2d.
 
     @param F type of the return value, e.g. Real2d
     @param G type of the element, mostly Real
     @param H type of one element formula, e.g. Real
 
     @author Kersten Schmidt, 2004
   */
 
  template<typename F, typename G, typename H>
  class ElementFormulaCompose : public ElementFormula<F,G> {
  public:
    ElementFormulaCompose(const ElementFormula<H,G>& frm1,
                          const ElementFormula<H,G>& frm2) :
      frm1_(frm1.clone()), frm2_(frm2.clone()) {}
    ElementFormulaCompose(const ElementFormulaCompose<F,G,H>& frm) :
      frm1_(frm.frm1_->clone()), frm2_(frm.frm2_->clone()) {}
    virtual ~ElementFormulaCompose() {
      frm1_.reset(0); frm2_.reset(0);
    }
    virtual F operator() (const ElementWithCell<G>& elm, const Real p,
                          const Real t = 0.0) const { 
      return compose_(elm,p,t);
    }
    virtual F operator() (const ElementWithCell<G>& elm, const Real2d& p,
                          const Real t = 0.0) const  { 
      return compose_(elm,p,t);
    }
    virtual F operator() (const ElementWithCell<G>& elm, const Real3d& p,
                          const Real t = 0.0) const  { 
      return compose_(elm,p,t);
    }
    virtual ElementFormulaCompose<F,G,H>* clone() const {
      return new ElementFormulaCompose<F,G,H>(*frm1_, *frm2_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    std::unique_ptr<const ElementFormula<H,G> > frm1_, frm2_;
 
    template<typename P>
    F compose_(const ElementWithCell<G>& elm, const P& p, const Real t = 0.0) const;
  };
 
  template<typename F, typename G, typename H>
  template<typename P>
  F ElementFormulaCompose<F,G,H>::compose_(const ElementWithCell<G>& elm, 
             const P& p, const Real t) const {
    return F((*frm1_)(elm,p,t),(*frm2_)(elm,p,t));
  }
 
  template<typename F, typename G, typename H>
  std::ostream& ElementFormulaCompose<F,G,H>::info(std::ostream& os) const {
    return os << concepts::typeOf(*this)<<"(" << *frm1_ << ", " <<  *frm2_ << ")";
  }
 
  // ************************************************ ElementBoundaryFormula **
 
  class ElementFormulaBoundary : public ElementFormula<Real> {
  public:
    ElementFormulaBoundary
    (const BoundaryConditions bc,
     const Boundary::boundaryTypes bType = Boundary::DIRICHLET);
    virtual Real operator() (const ElementWithCell<Real>& elm, const Real p,
                             const Real t = 0.0) const;
    virtual Real operator() (const ElementWithCell<Real>& elm, const Real2d& p,
                             const Real t = 0.0) const;
    virtual Real operator() (const ElementWithCell<Real>& elm, const Real3d& p,
                             const Real t = 0.0) const;
    virtual ElementFormulaBoundary* clone() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const BoundaryConditions bc_;
    const Boundary::boundaryTypes bType_;
  };
  
 
  // ************************************************ ElementFormulaRotate2D **
 
  template<class F>
  class ElementFormulaRotate2D : public ElementFormula<Point<F,2> > {
  public:
    ElementFormulaRotate2D
    (const ElementFormulaContainer<Point<F,2> > frm)
      : frm_(frm) {}
    virtual Point<F,2> operator()(const ElementWithCell<Real>& elm,
                                  const Real p, const Real t = 0.0) const;
    virtual Point<F,2> operator()(const ElementWithCell<Real>& elm,
                                  const Real2d& p, const Real t = 0.0) const;
    virtual Point<F,2> operator()(const ElementWithCell<Real>& elm,
                                  const Real3d& p, const Real t = 0.0) const;
    virtual ElementFormulaRotate2D<F>* clone() const {
      return new ElementFormulaRotate2D<F>(this->frm_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const ElementFormulaContainer<Point<F,2> > frm_;
  };
 
 
  // ***************************************** FrmE_ScalarProductNormalEdge2d **
 
  template< class F = Real>
  class FrmE_ScalarProductNormalEdge2d : public ElementFormula< F > 
  {
  public:
    FrmE_ScalarProductNormalEdge2d
    (RCP<const ElementFormula< Point<F, 2> > > vf) 
      : vf_(vf)
    { }
 
    virtual FrmE_ScalarProductNormalEdge2d* clone() const {
      return new FrmE_ScalarProductNormalEdge2d(*this);
    }
 
    inline RCP<const ElementFormula< Point<F, 2> > > frm() const
    {
      return vf_;
    }
 
    inline RCP<const ElementFormula< Point<F, 2> > >& frm() 
    {
      return vf_;
    }
 
    virtual F operator() (const ElementWithCell<Real>& elm,
                          const Real p, const Real t = 0.0) const;
    virtual F operator() (const ElementWithCell<Real>& elm, 
                          const Real2d& p, const Real t = 0.0) const 
    {
      // In the same manner as for Real3d, albeit not that needed.
      return (*this)(elm, p[0], t);
    }
 
    virtual F operator() (const ElementWithCell<Real>& elm,
                          const Real3d& p, const Real t = 0.0) const {
      // This is necessary for general integration routine
      // (see space/integral.hh)
      return (*this)(elm, p[0], t);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  public:
    RCP<const ElementFormula< Point<F, 2> > > vf_;
  };
 
 
} // namespace concepts
 
#endif // spcFormula_hh