function.hh

Go to the documentation of this file.

 
#ifndef VECTORIAL_FUNCTION_HH
#define VECTORIAL_FUNCTION_HH
 
#include <memory>
#include "space/function.hh"
#include "vectorial/vectorial.hh"
 
namespace vectorial {
 
  using concepts::Real;
  using concepts::Real2d;
  using concepts::Real3d;
 
 
  // ******************************************************* ElementFunction **
 
  template<class F, class G = typename concepts::Realtype<F>::type>
  class ElementFunction : public concepts::ElementFunction<F,G>,
                          public Vectorial<const concepts::ElementFunction<F,G> > {
  public:
    ElementFunction(const uint vdim, uint arrayWidth = 0) 
      : Vectorial<const concepts::ElementFunction<F,G> >(vdim, arrayWidth) {}
 
    virtual ~ElementFunction();
    virtual uint n() const;
    virtual void operator() (const concepts::Element<G>& elm, 
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const uint *i) const;
    virtual void operator() (const concepts::Element<G>& elm, const uint* j,
                             concepts::Array<F>& val, const uint* i) const;
 
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const Real p, 
                             const Real t = 0.0) const;
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const concepts::Real2d& p,
                             const Real t = 0.0) const;
    virtual void operator() (const concepts::Element<G>& elm,
                             const concepts::Array<F>& coeff,
                             concepts::Array<F>& val, const concepts::Real3d& p,
                             const Real t = 0.0) const;
 
    virtual ElementFunction<F,G>* clone() const;
 
    virtual void put(const concepts::ElementFunction<F,G>& vdata,
                     const uint a = 0, const uint b = 0);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
 
  // ********************************************** ElementFunctionComponent **
 
  template<class F, class G = Real>
  class ElementFunctionComponent : public concepts::ElementFunction<F,G>
  {
  public:
    ElementFunctionComponent(uint vdim, const concepts::ElementFunction<F,G> &fun,
                             const uint component);
 
    virtual ~ElementFunctionComponent() {}
 
    virtual ElementFunctionComponent<F,G>* clone() const
    {
      return new ElementFunctionComponent(fun_->clone(), n_);
    }
 
    virtual uint n() const {
      return n_;
    }
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const uint *i) const;
 
    virtual void operator()(const concepts::Element<G>& elm, const uint* j,
                            concepts::Array<F>& val, const uint* i) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real p, const Real t = 0.0) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real2d& p, const Real t = 0.0) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real3d& p, const Real t = 0.0) const;
 
  protected:
    virtual std::ostream& info(std::ostream &os) const
    {
      return os << fun_;
    }
  private:
    uint n_;
    std::unique_ptr<ElementFunction<F,G> > fun_;
 
    ElementFunctionComponent(ElementFunction<F,G>* fun, uint n) 
      : n_(n), fun_(fun)
    {}
  };
 
  // ************************************************** ElementFunctionAllComponents **
 
  template<class F, class G = Real>
  class ElementFunctionAllComponents : public concepts::ElementFunction<F,G>
  {
  public:
    ElementFunctionAllComponents(uint vdim, const concepts::ElementFunction<F,G> &fun);
 
    virtual ~ElementFunctionAllComponents() {}
 
    virtual ElementFunctionAllComponents<F,G>* clone() const
    {
      return new ElementFunctionAllComponents(fun_->clone(), n_);
    }
 
    virtual uint n() const {
      return n_;
    }
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const uint *i) const;
 
    virtual void operator()(const concepts::Element<G>& elm, const uint* j,
                            concepts::Array<F>& val, const uint* i) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real p, const Real t = 0.0) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real2d& p, const Real t = 0.0) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real3d& p, const Real t = 0.0) const;
 
  protected:
    virtual std::ostream& info(std::ostream &os) const
    {
      return os << fun_;
    }
  private:
    uint n_;
    std::unique_ptr<ElementFunction<F,G> > fun_;
 
    ElementFunctionAllComponents(ElementFunction<F,G>* fun, uint n) 
      : n_(n), fun_(fun)
    {}
  };
 
  // ****************************************************** SymmetrizeTensor **
 
  template<uint dim, class F, class G = Real>
  class SymmetrizeTensor : public concepts::ElementFunction<F,G>
  {
  public:
    SymmetrizeTensor(const concepts::ElementFunction<F,G> &fun);
 
    virtual ~SymmetrizeTensor(){}
 
    virtual SymmetrizeTensor<dim,F,G>* clone() const
    {
      return new SymmetrizeTensor( *fun_ );
    }
 
    virtual uint n() const {
      return dim*dim;
    }
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const uint *i) const;
 
    virtual void operator()(const concepts::Element<G>& elm, const uint* j,
                            concepts::Array<F>& val, const uint* i) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real p, const Real t = 0.0) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real2d& p, const Real t = 0.0) const;
 
    virtual void operator()(const concepts::Element<G>& elm,
                            const concepts::Array<F>& coeff,
                            concepts::Array<F>& val,
                            const Real3d& p, const Real t = 0.0) const;
 
  protected:
    virtual std::ostream& info(std::ostream &os) const
    {
      return os << concepts::typeOf(*this)<<"(" << *fun_ << ")";
    }
 
  private:
    std::unique_ptr<const concepts::ElementFunction<F,G> > fun_;
 
  };
 
 
} // namespace vectorial
 
 
#endif // VECTORIAL_FUNCTION_HH