aglowav2/operator.hh

Go to the documentation of this file.

/* Operators for the agglomerated wavelets.
 */

#ifndef aglowav2Operator_hh
#define aglowav2Operator_hh

#ifdef __GUNG__
#pragma interface
#endif

#include "operator/compositions.hh"
#include "aglowav2/space.hh"
#include "aglowav2/bform.hh"

namespace aglowav2 {

  // ***************************************************************** Delta **

  template<class F = concepts::Real>
  class Delta {
  public:
    virtual bool operator()(const Haar3dXXX<F>& elmX,
          const Haar3dXXX<F>& elmY) const = 0;
    virtual bool operator()(const Haar3d000<F>& elmX,
          const Haar3d000<F>& elmY) const;
  };

  template<class F>
  bool Delta<F>::operator()(const Haar3d000<F>& elmX,
          const Haar3d000<F>& elmY) const {
    const Haar3dXXX<F>& elmXA(elmX);
    const Haar3dXXX<F>& elmYA(elmY);
    return (*this)(elmXA, elmYA);
  }

  // ************************************************************* DeltaFull **

  template<class F = concepts::Real>
  class DeltaFull : public Delta<F> {
  public:
    bool operator()(const Haar3dXXX<F>& elmX,
        const Haar3dXXX<F>& elmY) const;
    bool operator()(const Haar3d000<F>& elmX,
        const Haar3d000<F>& elmY) const;
  };

  // *************************************************************** Delta00 **

  template<class F = concepts::Real>
  class Delta00 : public Delta<F> {
  public:
    Delta00(concepts::Real a, concepts::Real alpha, const Haar3d0<F>& spc);

    bool operator()(const Haar3dXXX<F>& elmX,
        const Haar3dXXX<F>& elmY) const;
    bool operator()(const Haar3d000<F>& elmX,
        const Haar3d000<F>& elmY) const;

  private:
    concepts::Real a_;
    concepts::Real alpha_;

    concepts::Real Sz_;
    concepts::Real h_;
  };

  // ************************************************************ Operator00 **

  template<class F = concepts::Real>
  class Operator00 : public concepts::Operator<F> {
  public:
    Operator00(AglowavBF00<F>& bf, const Haar3d0<F>& spc,
               const Delta<F>& delta);
    ~Operator00();

    void operator()(const concepts::Function<F>& fncY,
        concepts::Function<F>& fncX);
    void operator()(const concepts::Vector<F>& fncY,
        concepts::Vector<F>& fncX);

    const concepts::Space<F>& spaceX() const {return spc_;}
    const concepts::Space<F>& spaceY() const {return spc_;}

    const F* diag() const {return diag_;}
    uint memory() const {return mem_;}
    /* Returns the maximal memory used for the construction of the matrix
       (incl. bilinear form)
    */
    uint maxMemory() const {return maxmem_;}

    void pattern(std::ostream& os, uint nr) const;
    void patternL(std::ostream& os, uint nr) const;
    void uncompress(std::ostream& os, uint nr) const;
    void uncompressL(std::ostream& os, uint nr) const;

  protected:
    std::ostream& info(std::ostream& os) const;

  private:
    struct Pattern {
      uint index;
      uint length;

      Pattern() : index(0), length(0) {}
    };

    struct Matrix {
      F*       valuation;
      Pattern* pattern;

      Matrix() : valuation(0) {}
    };

    void lstore_(concepts::ElementMatrix<F>& A, uint idx, F* val,
     Pattern** pat);
    void ustore_(concepts::ElementMatrix<F>& A, uint idx, F** val,
     Pattern* pat);
    void dstore_(concepts::ElementMatrix<F>& A, uint idx, F** val,
     Pattern** pat);
    void compress_(uint dim, uint idx, F valbuf[], uint nval,
       Pattern patbuf[], uint npat);

    const Haar3d0<F>& spc_;
    uint n_;
    Matrix* mtx_;

    uint mem_;
    uint maxmem_;
    uint nentry_;

    F* diag_;
  };

} // namespace aglowav2

#endif // aglowav2Operator_hh