frmE_component.hh

Go to the documentation of this file.

 
#ifndef FRME_COMPONENT_HH
#define FRME_COMPONENT_HH
 
#include "elementFormula.hh"
#include "elementFormulaContainer.hh"
 
namespace concepts {
  
  // ********************************************************* FrmE_Component **
  
  template<class F, class G = typename Realtype<F>::type, 
           class H = typename Datatype<F>::type>
  class FrmE_Component : public ElementFormula<H,G> {
    
  public:
    FrmE_Component(const ElementFormulaContainer<F,G> &frm, const uint comp)
      : frm_(frm), comp_(comp)
    {
    }
    
    virtual ~FrmE_Component() {}
    
    virtual H operator ()(const ElementWithCell<G> &elm, 
                          const Real p, const Real t = 0.0) const
    {
      F value = frm_(elm, p, t);
      return value[comp_];
    }
    
    virtual H operator ()(const ElementWithCell<G> &elm, 
                          const Real2d &p, const Real t = 0.0) const
    {
      F value = frm_(elm, p, t);
      return value[comp_];
    }
    
    virtual H operator ()(const ElementWithCell<G> &elm, 
                          const Real3d &p, const Real t = 0.0) const
    {
      F value = frm_(elm, p, t);
      return value[comp_];
    }
    
    virtual FrmE_Component<F,G,H>* clone() const {
      return new FrmE_Component<F, G, H>(frm_, comp_);
    }
    
  protected:
    virtual std::ostream& info(std::ostream &os) const {
      return os << concepts::typeOf(*this) <<"(component " << comp_
                << " of " << frm_ << ")";
    }
    
  private:
    ElementFormulaContainer<F,G> frm_;
    uint comp_;
  };
 
  // ************************************************** FrmE_Component_Matrix **
  
  template<class F, class G = typename Realtype<F>::type, 
           class H = typename Datatype<F>::type>
  class FrmE_Component_Matrix : public ElementFormula<H,G> {
    
  public:
    FrmE_Component_Matrix(const ElementFormulaContainer<F,G> &frm, 
                          const uint compRow, const uint compCol)
      : frm_(frm), compRow_(compRow), compCol_(compCol)
    {
    }
    
    virtual ~FrmE_Component_Matrix() {}
    
    virtual H operator ()(const ElementWithCell<G> &elm, 
                          const Real p, const Real t = 0.0) const
    {
      F value = frm_(elm, p, t);
      return value(compRow_, compCol_);
    }
    
    virtual H operator ()(const ElementWithCell<G> &elm, 
                          const Real2d &p, const Real t = 0.0) const
    {
      F value = frm_(elm, p, t);
      return value(compRow_, compCol_);
    }
    
    virtual H operator ()(const ElementWithCell<G> &elm, 
                          const Real3d &p, const Real t = 0.0) const
    {
      F value = frm_(elm, p, t);
      return value(compRow_, compCol_);
    }
    
    virtual FrmE_Component_Matrix<F,G,H>* clone() const {
      return new FrmE_Component_Matrix<F, G, H>(frm_, compRow_, compCol_);
    }
    
  protected:
    virtual std::ostream& info(std::ostream &os) const {
      return os << concepts::typeOf(*this) << "(component (" << compRow_
      << ", " << compCol_ << ") of " << frm_ << ")";
    }
  private:
    ElementFormulaContainer<F,G> frm_;
    
    uint compRow_, compCol_;
  };
 
} // namespace concepts
 
#endif // FRME_COMPONENT_HH