frmE_matrix.hh

Go to the documentation of this file.

 
#ifndef frme_matrix_hh
#define frme_matrix_hh
 
#include "elementFormula.hh"
#include "elementFormulaContainer.hh"
 
namespace concepts {
 
  // *************************************************** FrmE_PointToMapping **
 
  template<int dim, class F, class G = typename Realtype<F>::type>
  class FrmE_PointToMapping : public ElementFormula<Mapping<F,dim>,G> {
  public:
    FrmE_PointToMapping
    (const ElementFormulaContainer<Point<F,dim*dim>,G>& frm,
     bool transpose = false)
      : frm_(frm)
    {}
 
    virtual ~FrmE_PointToMapping() {}
    
    virtual Mapping<F,dim> operator ()(const ElementWithCell<G> &elm, 
                                       const Real p, const Real t = 0.0) const
    {
      return compute_(elm, p, t);
    }
    
    virtual Mapping<F,dim> operator ()(const ElementWithCell<G> &elm, 
                                       const Real2d &p, const Real t = 0.0) const
    {
      return compute_(elm, p, t);
    }
    
    virtual Mapping<F,dim> operator ()(const ElementWithCell<G> &elm, 
                                       const Real3d &p, const Real t = 0.0) const
    {
      return compute_(elm, p, t);
    }
    
    virtual FrmE_PointToMapping<dim,F,G>* clone() const {
      return new FrmE_PointToMapping<dim, F, G>(frm_);
    }
    
  protected:
    virtual std::ostream& info(std::ostream &os) const {
      return os << concepts::typeOf(*this) << "(" << frm_ << ")";
    }
  private:
    ElementFormulaContainer<Point<F,dim*dim>,G> frm_;
    bool transpose_;
 
    template<class H>
    Mapping<F,dim> compute_(const ElementWithCell<G> &elm, 
                            const H& p, const Real t = 0.0) const
    {
      Point<F, dim*dim> point = frm_(elm, p, t);
      DEBUGL(0, "point = " << point);
      Mapping<F, dim> m;
      if (transpose_) {
        for(uint i = 0; i < dim; ++i)
          for(uint j = 0; j < dim; ++j)
            m(i,j) = point[i+j*dim];
      } else {
        for(uint i = 0; i < dim; ++i)
          for(uint j = 0; j < dim; ++j)
            m(i,j) = point[j+i*dim];
      }
      DEBUGL(0, "m = " << m);
      return m;
    }
  };
 
  // *************************************************** FrmE_PointsToMapping **
 
  template<int dim, class F, class G = typename Realtype<F>::type>
  class FrmE_PointsToMapping : public ElementFormula<Mapping<F,dim>,G> {
  };
 
  template<class F, class G>
  class FrmE_PointsToMapping<2, F, G> : public ElementFormula<Mapping<F,2>,G> {
  public:
    FrmE_PointsToMapping(const ElementFormulaContainer<Point<F,2>,G> frm1,
                         const ElementFormulaContainer<Point<F,2>,G> frm2,
                         bool transpose = false) :
      frm1_(frm1), frm2_(frm2), transpose_(transpose) {}
 
    virtual ~FrmE_PointsToMapping() {}
    
    virtual Mapping<F,2> operator ()(const ElementWithCell<G> &elm, 
                                       const Real p, const Real t = 0.0) const
    {
      const Mapping<F,2> m(frm1_(elm, p, t), frm2_(elm, p, t));
      return transpose_ ? m.transpose() : m;
    }
    
    virtual Mapping<F,2> operator ()(const ElementWithCell<G> &elm, 
                                       const Real2d &p, const Real t = 0.0) const
    {
      const Mapping<F,2> m(frm1_(elm, p, t), frm2_(elm, p, t));
      return transpose_ ? m.transpose() : m;
    }
    
    virtual Mapping<F,2> operator ()(const ElementWithCell<G> &elm, 
                                       const Real3d &p, const Real t = 0.0) const
    {
      const Mapping<F,2> m(frm1_(elm, p, t), frm2_(elm, p, t));
      return transpose_ ? m.transpose() : m;
    }
    
    virtual FrmE_PointsToMapping<2,F,G>* clone() const {
      return new FrmE_PointsToMapping<2, F, G>(frm1_, frm2_, transpose_);
    }
 
  protected:
    virtual std::ostream& info(std::ostream &os) const {
      return os << concepts::typeOf(*this) << "(" << frm1_ << ", " << frm2_
                << ", transpose = " << transpose_ << ")";
    }
  private:
    ElementFormulaContainer<Point<F,2>,G> frm1_, frm2_;
    bool transpose_;
  };  
 
  // ************************************************************* FrmE_Trace **
 
  template<int dim, class F, class G = typename Realtype<F>::type>
  class FrmE_Trace : public ElementFormula<F,G> {
  public:
    FrmE_Trace(const ElementFormulaContainer<Mapping<F,dim>,G> frm) :
      frm_(frm) {}
 
    virtual ~FrmE_Trace() {}
    
    virtual F operator ()(const ElementWithCell<G> &elm, 
                          const Real p, const Real t = 0.0) const
    {
      return frm_(elm, p, t).trace();
    }
    
    virtual F operator ()(const ElementWithCell<G> &elm, 
                          const Real2d &p, const Real t = 0.0) const
    {
      return frm_(elm, p, t).trace();
    }
    
    virtual F operator ()(const ElementWithCell<G> &elm, 
                          const Real3d &p, const Real t = 0.0) const
    {
      return frm_(elm, p, t).trace();
    }
    
    virtual FrmE_Trace<dim,F,G>* clone() const {
      return new FrmE_Trace<dim, F, G>(frm_);
    }
 
  protected:
    virtual std::ostream& info(std::ostream &os) const {
      return os << concepts::typeOf(*this) << "(" << frm_ << ")";
    }
  private:
    ElementFormulaContainer<Mapping<F,dim>,G> frm_;
  };  
 
} // namespace concepts
 
#endif // frme_matrix_hh