space.hh

Go to the documentation of this file.

 
#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"
#include "basics/output.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::" <<concepts::typeOf(*this)<<"(dim=" << dim_ << ", maxLocDim=" << maxLocDim_;
    os << ", nlvl=" << nlvl_ << ", nelm=" << nelm_ << ", d=" << d_ << ')';
    return os;
  }
 
} // namespace aglowav2
 
#endif // aglowav2Space_hh