cluster/f04.hh

Go to the documentation of this file.

/* Far field matrix F04
 */

#ifndef clusterF04_hh
#define clusterF04_hh

#include "toolbox/scannerConnectors.hh"
#include "toolbox/hashMap.hh"
#include "cluster/expansion.hh"
#include "cluster/f.hh"

namespace cluster {

  // ******************************************************************* F04 **

  template<class NodeX, class NodeY>
  class F04 : public ClstF<NodeX, NodeY> {
  public:
    typedef typename ClstF<NodeX, NodeY>::TraitsX  TraitsX;
    typedef typename ClstF<NodeX, NodeY>::TraitsY  TraitsY;
    typedef typename ClstF<NodeX, NodeY>::FX       FX;
    typedef typename ClstF<NodeX, NodeY>::FY       FY;
    typedef typename ClstF<NodeX, NodeY>::NfldNodes NfldNodes;
    typedef typename ClstF<NodeX, NodeY>::NfldScan NfldScan;
  private:
    class Ffld {
      Ffld* lnk_;
      const NodeX* clstX_;
      const NodeY* clstY_;
      uint m_;
      FColExp* val_;

    public:
      inline Ffld(const NodeX* clstX, const NodeY* clstY,
      Ffld* lnk = 0)
  : lnk_(lnk), clstX_(clstX), clstY_(clstY), m_(0), val_(0) {}
      inline ~Ffld() {delete val_;}

      inline Ffld* link() const {return lnk_;}
      inline uint sigma() const {return TraitsX::index(clstX_);}
      inline uint tau() const {return TraitsY::index(clstY_);}
      inline concepts::Real3d z() const {
  return TraitsY::center(clstY_) - TraitsX::center(clstX_);
      }
      inline uint m(uint m) {if (m) m_ = m;  return m_;}
      inline uint m() const {return m_;}
      inline FColExp* val(uint blksz, const ExpansionF<FX>& exp) {
  if (blksz) {delete val_; val_ = exp.getCol(blksz);}  return val_;
      }
      inline FColExp* val() const {return val_;}
      inline concepts::Real intensity(concepts::Real s) const {
  concepts::Real I = TraitsX::nleaf(clstX_);
  if (I < TraitsY::nleaf(clstY_))  I = TraitsY::nleaf(clstY_);
  //concepts::Real I =
  //  (concepts::Real)TraitsX::nleaf(clstX_) * TraitsY::nleaf(clstY_);
  return I * pow(z().l2(), -s);
      }
    };

    const Tree<NodeX>& treeX_;
    const Tree<NodeY>& treeY_;

    const ExpansionF<FX>& exp_;

    uint m_;
    concepts::Real eta_;
    concepts::Real s_;
    uint minsz_;

    Ffld* ffld_;
    uint nffld_;
    uint nffldval_;
    concepts::Joiner<NfldNodes, 1>* nfld_;
    uint nnfld_;

    void constructor_(const NodeX* clstX, const NodeY* clstY,
          concepts::Real* Imax);
    template<class Trts, class Nd>
    uint info_(uint idx, const Nd* clst,
         __gnu_cxx::hash_map<uint, uint>& nlf) const;

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

  public:
    F04(const Tree<NodeX>& treeX, const Tree<NodeY>& treeY,
  const ExpansionF<FX>& exp, concepts::Real eta,
  concepts::Real s, uint minsz);
    ~F04();

    void operator()(const ClstY<NodeY>& vecY, ClstX<NodeX>& vecX) const;

    inline NfldScan* scan() const {
      return new concepts::ListScan<NfldNodes>(*nfld_);
    }
    inline float memory() const;
    std::ostream& info(std::ostream& os, uint idxX, uint idxY) const;
  };

  template<class NodeX, class NodeY>
  inline float F04<NodeX, NodeY>::memory() const {
    return sizeof(F04<NodeX, NodeY>)
      + (float)nffld_ * sizeof(typename F04<NodeX, NodeY>::Ffld)
      + (float)nnfld_ * sizeof(concepts::Joiner<NfldNodes, 1>)
      + nffldval_ *
      (ffld_->val() ? ffld_->val()->memory(1)
       : ffld_->val(1, exp_)->memory(1));
  }

} // namespace cluster

#endif // clusterF04_hh