vectorElementFormula.hh

Go to the documentation of this file.

 
#ifndef vectorelementformula_hh
#define vectorelementformula_hh
 
#include <vector>
#include "toolbox/sharedPointer.hh"
#include "elementFormula.hh"
#include "elementFormulaContainer.hh"
 
namespace concepts {
 
 
  // *********************************************** VectorElementFormulaBase **
 
  template<typename F, int dim, typename G = typename Realtype<F>::type>
  class VectorElementFormulaBase : public ElementFormula< Point<F, dim>, G >
  {
  public:
    VectorElementFormulaBase<F,dim,G>() : formulas_() 
    {
      for(int i=0; i < dim; ++i)
        formulas_.push_back(ElementFormulaContainer<F,G>());
    }
 
    VectorElementFormulaBase<F,dim,G>
    (const std::vector<ElementFormulaContainer<F,G> >& formulas) 
     : formulas_(formulas)
    { 
      conceptsAssert(formulas_.size() == dim, concepts::Assertion());
    }
 
    Point<F, dim> operator() (const ElementWithCell<G>& elm, const Real p,
                              const Real t = 0.0) const
    {
      Point<F, dim> ret;
      for (int i=0; i < dim; ++i) 
        ret[i] = !formulas_[i].empty() ? formulas_[i](elm, p, t) : F(0);
      return ret;
    }
 
    Point<F, dim> operator() (const ElementWithCell<G>& elm, const Real2d& p,
                              const Real t = 0.0) const
    {
      Point<F, dim> ret;
      for (int i=0; i < dim; ++i)
        ret[i] = !formulas_[i].empty() ? formulas_[i](elm, p, t) : F(0);
 
      return ret;
    }
 
    Point<F, dim> operator() (const ElementWithCell<G>& elm, const Real3d& p,
                              const Real t = 0.0) const
    {
      Point<F, dim> ret;
      for (int i=0; i < dim; ++i)
        ret[i] = !formulas_[i].empty() ? formulas_[i](elm, p, t) : F(0);
 
      return ret;
    }
 
    virtual VectorElementFormulaBase<F,dim,G>* clone() const
    {
      return new VectorElementFormulaBase<F, dim, G>(*this);
    }
 
#if 0
    VectorElementFormulaBase<F,dim,G>( const VectorElementFormulaBase<F,dim,G>& other) 
      : formulas_(other.formulas_)
    { }
#endif
 
    virtual ~VectorElementFormulaBase() { }
 
    const std::vector<ElementFormulaContainer<F, G> >& getFormulas() 
    {
      return formulas_;
    }
 
    ElementFormulaContainer<F, G>& operator[](int i)
    {
      conceptsAssert(i < dim, concepts::Assertion());
 
      return formulas_[i];
    }
 
  protected:
    std::vector<ElementFormulaContainer<F, G> > formulas_;
 
    virtual std::ostream& info(std::ostream& os) const {
      os << concepts::typeOf(*this) << "([";
      for (int i=0; i < dim; ++i) {
        if (!formulas_[i].empty())
          os << formulas_[i].frm();
        else
          os << "0";
        if (i < dim - 1)
          os << ", ";
      }
      return os << "])";
    }
  };
 
  // ************************************************ VectorElementFormula *****
 
  template<typename F, int dim, typename G = typename Realtype<F>::type>
  class VectorElementFormula : public VectorElementFormulaBase<F,dim,G> {};
 
 
  // ************************************************ VectorElementFormula<2> **
 
  template<typename F, typename G>  
  class VectorElementFormula<F,2,G> : public VectorElementFormulaBase<F,2,G>
  {
  public:
    VectorElementFormula<F,2,G>() : VectorElementFormulaBase<F,2,G>() {}
 
    VectorElementFormula<F,2,G>
    (const std::vector<ElementFormulaContainer<F,G> >& formulas) 
      : VectorElementFormulaBase<F,2,G>(formulas) {}
 
    VectorElementFormula<F,2,G>(const ElementFormulaContainer<F,G>& frm1,
                                const ElementFormulaContainer<F,G>& frm2) 
      : VectorElementFormulaBase<F,2,G>() {
      (*this)[0] = frm1;
      (*this)[1] = frm2;
    }
  };
 
 
  // ************************************************ VectorElementFormula<3> **
 
  template<typename F, typename G>  
  class VectorElementFormula<F,3,G> : public VectorElementFormulaBase<F,3,G>
  {
  public:
    VectorElementFormula<F,3,G>() : VectorElementFormulaBase<F,2,G>() {}
 
    VectorElementFormula<F,3,G>
    (const std::vector<ElementFormulaContainer<F,G> >& formulas) 
      : VectorElementFormulaBase<F,3,G>(formulas) {}
 
    VectorElementFormula<F,3,G>(const ElementFormulaContainer<F,G> frm1,
                                const ElementFormulaContainer<F,G> frm2, 
                                const ElementFormulaContainer<F,G> frm3) 
      : VectorElementFormulaBase<F,3,G>() {
      (*this)[0] = frm1;
      (*this)[1] = frm2;
      (*this)[2] = frm3;
    }
  };
 
 
} // namespace concepts
 
 
#endif // vectorelementformula_hh