cluster/operator01.hh

Go to the documentation of this file.

/* Cluster approximation of the stiffness matrix 01
 */

#ifndef clusterOperator01_hh
#define clusterOperator01_hh

#include "basics/exceptions.hh"
#include "toolbox/dynArray.hh"
#include "operator/bilinearForm.hh"
#include "operator/compositions.hh"
#include "cluster/f.hh"

namespace cluster {

  // ***************************************************** CacheSizeExceeded **

  class CacheSizeExceeded : public concepts::ExceptionBase {};

  // ************************************************************ Operator01 **

  template<class NodeX, class NodeY>
  class Operator01 : public concepts::Operator<typename TreeTraits<NodeX>::F> {
  public:
    typedef TreeTraits<NodeX>   TraitsX;
    typedef TreeTraits<NodeY>   TraitsY;
    typedef typename TraitsX::F FX;
    typedef typename TraitsY::F FY;
    class NfldMatrix {
      NfldMatrix* lnk_;
      uint  dX_;
      uint* idxX_;
      uint  dY_;
      uint* idxY_;
      FX* val_;
    public:
      NfldMatrix(concepts::BilinearForm<FX>& bf, NfldMatrix* lnk,
     concepts::DynArray<uint>& idxX, uint nidxX,
     concepts::DynArray<const concepts::Element<FX>*>& elmX,
     uint nelmX, concepts::DynArray<uint>& idxY, uint nidxY,
     concepts::DynArray<const concepts::Element<FY>*>& elmY,
     uint nelmY);
      inline ~NfldMatrix() {delete[] val_; delete[] idxY_; delete[] idxX_;}

      void operator()(const concepts::Vector<FY>& fncY,
          concepts::Vector<FX>& fncX);
      inline NfldMatrix* link() const {return lnk_;}
      inline float memory() const;
    };
    Operator01(concepts::BilinearForm<FX>& bf, ClstF<NodeX,NodeY>& F,
               ClstX<NodeX>& X, ClstY<NodeY>& Y);
    virtual ~Operator01();

    void operator()(const concepts::Function<FY>& fncY,
        concepts::Function<FX>& fncX);
    void operator()(const concepts::Vector<FY>& fncY,
        concepts::Vector<FX>& fncX);
    float memory() const;
    inline const concepts::Space<FX>& spaceX() const {return X_.space();}
    inline const concepts::Space<FY>& spaceY() const {return Y_.space();}
  protected:
    std::ostream& info(std::ostream& os) const;
  private:
    concepts::BilinearForm<FX>& bf_;
    ClstF<NodeX, NodeY>& F_;
    ClstX<NodeX>& X_;
    ClstY<NodeY>& Y_;
    NfldMatrix* N_;
    uint nnfldval_;

    template<class Trts, class Nd>
    void constructor_(const Nd* clst, concepts::DynArray<uint>& idx,
          uint* nidx, concepts::DynArray<const concepts::Element
          <typename Trts::F>*>& elm, uint* nelm);
  };

  template<class NodeX, class NodeY>
  inline float Operator01<NodeX,NodeY>::NfldMatrix::memory() const {
    return sizeof(NfldMatrix)
      + (float)dX_ * sizeof(idxX_[0])
      + (float)dY_ * sizeof(idxY_[0])
      + (float)(dX_ * dY_) * sizeof(val_[0]);
  }

} // namespace cluster

#endif // clusterOperator01_hh