tree.hh

Go to the documentation of this file.

 
#ifndef aglowavTree_hh
#define aglowavTree_hh
 
#ifdef __GUNG__
  #pragma interface
#endif
 
#include "basics/exceptions.hh"
#include "space/space.hh"
#include "bem/element.hh"
#include "cluster/tree.hh"
 
namespace aglowav {
 
  // **************************************************** One2ManyTreeTraits **
 
  template<class o2mNode>
  class One2ManyTreeTraits {
  public:
    static o2mNode* child(const o2mNode* nd, uint j) {return nd->child(j);}
  };
 
  // ********************************************************** One2ManyTree **
  
  template<class o2mNode>
  class One2ManyTree;
  
  template<class o2mNode>
  inline std::ostream& operator<<(std::ostream& os,
          const One2ManyTree<o2mNode>& t) {
    return t.info(os);
  }  
 
  template<class o2mNode>
  class One2ManyTree {
    friend std::ostream& operator<< <>(std::ostream& os,
               const One2ManyTree<o2mNode>& t);
 
  public:
    typedef One2ManyTreeTraits<o2mNode> Traits;
    typedef o2mNode Node;
 
    virtual ~One2ManyTree() {}
 
    virtual const o2mNode* root() const = 0;
    virtual uint nleaf() const = 0;
 
    virtual std::ostream& info(std::ostream& os) const;
    void sketch(std::ostream& os, const o2mNode* rt = 0, uint l = 0) const;
  };
 
  // ********************************************************** BiTreeTraits **
 
  template<class Node>
  class BiTreeTraits : public One2ManyTreeTraits<Node> {
  public:
    static Node* lft(const Node* nd) {return nd->lft();}
    static Node*& lft(Node* nd) {return nd->lft();}
    static Node* rght(const Node* nd) {return nd->rght();}
  };
 
  // **************************************************************** BiTree **
 
  template<class biNode>
  class BiTree : public One2ManyTree<biNode> {
  public:
    typedef BiTreeTraits<biNode> Traits;
 
   virtual const biNode* root() const = 0;
  };
 
  // ****************************************************** ClstBiTreeTraits **
 
  template<class BiClNode>
  class ClstBiTreeTraits : public BiTreeTraits<BiClNode>,
                           public cluster::TreeTraits<BiClNode> {
  public:
    typedef typename cluster::TreeTraits<BiClNode>::F F;
 
    static BiClNode* newNode(const concepts::Element<F>& elm,
                             const cluster::BBall<F>& ball, BiClNode* lft) {
      return new BiClNode(elm, ball, lft);
    }
    static BiClNode* newNode(uint idx, BiClNode& lft, BiClNode& rght,
                             const concepts::Real3d& c,
           concepts::Real r, uint nlf = 0) {
      return new BiClNode(idx, lft, rght, c, r, nlf);
    }
  };
 
  // ************************************************************ BiClNode00 **
  
  template<class F>
  class BiClNode00;
  
  template<class F>
  inline std::ostream& operator<<(std::ostream& os, const BiClNode00<F>& nd) {
    os << "aglowav::BiClNode00(idx = " << nd.index()
       << ", nleaf = " << nd.nleaf();
    return os << ", r = " << nd.radius() << ", c = " << nd.center() << ')';
  }  
 
  template<class F>
  class BiClNode00 {
    friend std::ostream& operator<< <> (std::ostream& os,
          const BiClNode00<F>& nd);
 
  public:
    typedef F CF;
 
    BiClNode00(const concepts::Element<F>& elm, const cluster::BBall<F>& ball,
               BiClNode00<F>* lft);
    BiClNode00(uint idx, BiClNode00<F>& lft, BiClNode00<F>& rght,
               const concepts::Real3d& c, concepts::Real r, uint nleaf = 0);
 
    BiClNode00<F>* child(uint j) const;
    BiClNode00<F>* lft() const {return lft_;}
    BiClNode00<F>*& lft() {return lft_;}
    BiClNode00<F>* rght() const {return (nlf_) ? ne_.rght : (BiClNode00<F>*)0;}
    const bem::Constant3d001<F>* element() const;
    const concepts::Real3d& center() const {return c_;}
    uint nleaf() const {return nlf_;}
    concepts::Real radius() const {return r_;}
    uint index() const {return idx_;}
 
  private:
    union NE {
      BiClNode00<F>*               rght;
      const bem::Constant3d001<F>* elm;
    };
 
    BiClNode00<F>* lft_;
    NE ne_;
    uint idx_;
    uint nlf_;
    concepts::Real3d c_;
    concepts::Real r_;
  };
 
  template<class F>
  inline BiClNode00<F>* BiClNode00<F>::child(uint j) const {
    return (!j) ? lft_ : (nlf_ && j == 1) ? ne_.rght : (BiClNode00<F>*)0;
  }
 
  template<class F>
  inline const bem::Constant3d001<F>* BiClNode00<F>::element() const {
    return (nlf_) ? (const bem::Constant3d001<F>*)0 : ne_.elm;
  }
 
} // namespace aglowav
 
#endif // aglowavTree_hh