cluster/operator02.hh

Go to the documentation of this file.

/* Cluster approximation of the stiffness matrix 02
 */

#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