operator.hh

Go to the documentation of this file.

 
#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