operator02.hh

Go to the documentation of this file.

 
#ifndef clusterOperator02_hh
#define clusterOperator02_hh
 
#include "basics/exceptions.hh"
#include "operator/bilinearForm.hh"
#include "operator/compositions.hh"
#include "operator/sparseMatrix.hh"
#include "cluster/f.hh"
 
namespace cluster {
 
  // ************************************************************ Operator02 **
 
  template<class NodeX, class NodeY>
  class Operator02 : public concepts::Operator<typename TreeTraits<NodeX>::F> {
    typedef TreeTraits<NodeX>   TraitsX;
    typedef TreeTraits<NodeY>   TraitsY;
    typedef typename TraitsX::F FX;
    typedef typename TraitsY::F FY;
 
    concepts::BilinearForm<FX>& bf_;
    ClstF<NodeX,NodeY>& F_;
    ClstX<NodeX>& X_;
    ClstY<NodeY>& Y_;
    concepts::SparseMatrix<FX> N_;
 
    concepts::ElementMatrix<FX> A_;
    concepts::ElementMatrix<FX> B_;
 
    void constructor_(const NodeX* X, const NodeY* Y);
    void constructor_(const concepts::Element<FX>* elmX, const NodeY* Y);
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  public:
    Operator02(concepts::BilinearForm<FX>& bf, ClstF<NodeX, NodeY>& F,
         ClstX<NodeX>& X, ClstY<NodeY>& Y);
 
    void operator()(const concepts::Function<FY>& fncY,
        concepts::Function<FX>& fncX);
    void operator()(const concepts::Vector<FY>& fncY,
        concepts::Vector<FX>& fncX);
    inline float memory() const;
    inline const concepts::Space<FX>& spaceX() const {return X_.space();}
    inline const concepts::Space<FY>& spaceY() const {return Y_.space();}
  };
 
  template<class NodeX, class NodeY>
  inline float Operator02<NodeX, NodeY>::memory() const {
    return sizeof(Operator02<NodeX, NodeY>) + N_.memory()
      - sizeof(concepts::SparseMatrix<FX>);
  }
 
} // namespace cluster
 
#endif // clusterOperator02_hh