aglowav2/space.hh

Go to the documentation of this file.

/* Spaces for the wavelets.
 */

#ifndef aglowav2Space_hh
#define aglowav2Space_hh

#ifdef __GUNG__
#pragma interface
#endif

#include "toolbox/scannerConnectors.hh"
#include "space/space.hh"
#include "bem/element.hh"
#include "cluster/tree.hh"
#include "aglowav2/element.hh"

namespace aglowav2 {

  // ********************************************************* Haar3dDFSScan **

  template<class F = concepts::Real>
  class Haar3dDFSScan : public concepts::Scan<concepts::Element<F> > {
  public:
    virtual Haar3dXXX<F>& operator++(int) = 0;
  };

  // ********************************************************* Haar3dBFSScan **

  template<class F = concepts::Real>
  class Haar3dBFSScan : public concepts::Scan<concepts::Element<F> > {
  public:
    virtual Haar3dXXX<F>& operator++(int) = 0;
    virtual void skip(uint lvl) = 0;
  };

  // **************************************************************** Haar3d **

  template<class F = concepts::Real>
  class Haar3d : public concepts::Space<F> {
  public:
    virtual ~Haar3d() {}

    virtual uint nlvl() const = 0;
    virtual uint maxLocDim() const = 0;
    virtual Haar3dDFSScan<F>* dfsscan() const = 0;
    virtual Haar3dBFSScan<F>* bfsscan() const = 0;
  };

  // ******************************************************** Haar3d0DFSScan **

  template<class F = concepts::Real>
  class Haar3d0DFSScan : public Haar3dDFSScan<F> {
  public:
    Haar3d0DFSScan(Haar3d000<F>* elm, uint ht);
    Haar3d0DFSScan(const Haar3d0DFSScan<F>& sc);
    inline ~Haar3d0DFSScan() {delete[] stk_;}

    Haar3d000<F>& operator++(int);
    inline Haar3d0DFSScan<F>* clone() const {
      return new Haar3d0DFSScan<F>(*this);
    }
    inline bool eos() const {return sptr_[0] ? 0 : 1;}

  private:
    uint ht_;
    Haar3d000<F>** stk_;
    Haar3d000<F>** sptr_;
  };

  // ******************************************************** Haar3d0BFSScan **

  template<class F = concepts::Real>
  class Haar3d0BFSScan : public Haar3dBFSScan<F> {
  public:
    Haar3d0BFSScan(Haar3d000<F>* elm, uint ht);
    Haar3d0BFSScan(const Haar3d0BFSScan<F>& sc);
    inline ~Haar3d0BFSScan() {delete[] stk_;}

    Haar3d000<F>& operator++(int);
    inline Haar3d0BFSScan<F>* clone() const {
      return new Haar3d0BFSScan<F>(*this);
    }
    inline bool eos() const {return sptr_[0] ? 0 : 1;}
    void skip(uint lvl);

  private:
    uint ht_;
    Haar3d000<F>** stk_;
    Haar3d000<F>** sptr_;
  };

  // *************************************************************** Haar3d0 **

  template<class F = concepts::Real>
  class Haar3d0 : public Haar3d<F> {
  public:
    Haar3d0(cluster::Tree<cluster::Cluster<F> >& tree, uint d = 0);
    virtual ~Haar3d0() {destructor_(elm_);}

    inline uint dim() const {return dim_;}
    inline uint nelm() const {return nelm_;}
    inline uint nlvl() const {return nlvl_;}
    inline uint d() const {return d_;}
    inline uint maxLocDim() const {return maxLocDim_;}
    inline uint sumLocDim() const {return sLocDim_;}
    inline concepts::Real size() const {return sz_;}
    inline const concepts::Space<F>& space() const {return spc_;}

    inline Haar3d0DFSScan<F>* dfsscan() const;
    inline Haar3d0BFSScan<F>* bfsscan() const;
    inline Haar3d0BFSScan<F>* scan() const;

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

  private:
    void constructor_(const cluster::Cluster<F>* clst, uint lvl,
          Haar3d000<F>** Chld, Haar3d000<F>** Curchld,
          uint* nChld, const bem::Constant3d002<F>** Elm,
          uint* nElm, concepts::Real* At, uint* nAt);
             
    void destructor_(Haar3d000<F>* elm);

    void keyset_(Haar3d000<F>* elm, uint lvl, uint gamma);

    void moments_(const bem::Constant3d002<F>& elm, concepts::Real* mnts);
    uint dim_;
    uint nelm_;
    uint nlvl_;
    uint d_;
    uint maxLocDim_;
    uint sLocDim_;
    concepts::Real sz_;
    Haar3d000<F>* elm_;
    const concepts::Space<F>& spc_;

    uint *j_, *idx_;

    concepts::Real *v0x_, *v0y_, *v0z_, *x_, *y_, *z_;

    uint* bc_;

    const bem::Constant3d002<F>** locelm_;

    concepts::Real *S_, *Ut_, *At_, *work_;

    static const uint MAXLOCDIM_;
    static const concepts::Real EPS_;
  };

  template<class F>
  inline Haar3d0DFSScan<F>* Haar3d0<F>::dfsscan() const {
    return new Haar3d0DFSScan<F>(elm_, nlvl_);
  }

  template<class F>
  inline Haar3d0BFSScan<F>* Haar3d0<F>::bfsscan() const {
    return new Haar3d0BFSScan<F>(elm_, nlvl_);
  }

  template<class F>
  inline Haar3d0BFSScan<F>* Haar3d0<F>::scan() const {
    return new Haar3d0BFSScan<F>(elm_, nlvl_);
  }

  template<class F>
  std::ostream& Haar3d0<F>::info(std::ostream& os) const {
    os << "aglowav2::Haar3d0(dim=" << dim_ << ", maxLocDim=" << maxLocDim_;
    os << ", nlvl=" << nlvl_ << ", nelm=" << nelm_ << ", d=" << d_ << ')';
    return os;
  }

} // namespace aglowav2

#endif // aglowav2Space_hh