fmm3d_mpi.hpp

Go to the documentation of this file.

/* Kernel Independent Fast Multipole Method
   Copyright (C) 2004 Lexing Ying, New York University

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with this program; see the file COPYING.  If not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#ifndef _FMM3D_HPP_
#define _FMM3D_HPP_

#include "knlmat3d_mpi.hpp"
#include "let3d_mpi.hpp"
#include "matmgnt3d_mpi.hpp"

class FMM3d_MPI: public KnlMat3d_MPI
{
public:
  typedef pair<int,int> intpair;
  enum {          UE=0, UC=1, DE=2, DC=3,  };

  //------------------------------------
public:

  class NodeExt {
  public:
         NodeExt(): _vLstInNum(0), _vLstInCnt(0), _vLstOthNum(0), _vLstOthCnt(0) {;}
         int _vLstInNum;
         int _vLstInCnt;
         DblNumVec _effVal;
         int _vLstOthNum;
         int _vLstOthCnt;
         DblNumVec _effDen;
};
  class Node {
  protected:
         NodeExt* _ptr;
  public:
         Node(): _ptr(NULL) {;}
         ~Node() {
                if(_ptr!=NULL)            delete _ptr;
         }
         NodeExt* ptr() {               if(_ptr==NULL)  _ptr = new NodeExt();           return _ptr;     }
         int& vLstInNum() { return ptr()->_vLstInNum; }
         int& vLstInCnt() { return ptr()->_vLstInCnt; }
         DblNumVec& effVal() { return ptr()->_effVal; }
         int& vLstOthNum() { return ptr()->_vLstOthNum; }
         int& vLstOthCnt() { return ptr()->_vLstOthCnt; }
         DblNumVec& effDen() { return ptr()->_effDen; }
  };
  
  //------------------------------------
protected:
  Point3 _ctr;
  int    _rootLevel; 
  int _np;  
  //COMPONENTS, local member and data  vector<int> _stphds, _evlhds;
  Let3d_MPI* _let;
  MatMgnt3d_MPI* _matmgnt;

  vector<Node> _nodeVec;

  Vec _glbSrcExaPos;
  Vec _glbSrcExaNor;
  Vec _glbSrcExaDen;
  Vec _glbSrcUpwEquDen;

  Vec _ctbSrcExaPos;
  Vec _ctbSrcExaNor;
  Vec _ctbSrcExaDen;
  Vec _ctbSrcUpwEquDen;
  Vec _ctbSrcUpwChkVal;
  VecScatter _ctb2GlbSrcExaPos;
  VecScatter _ctb2GlbSrcExaDen;
  VecScatter _ctb2GlbSrcUpwEquDen;

  Vec _evaTrgExaPos;
  Vec _evaTrgExaVal;
  Vec _evaTrgDwnEquDen;
  Vec _evaTrgDwnChkVal;

  Vec _usrSrcExaPos;
  Vec _usrSrcExaNor;
  Vec _usrSrcExaDen;
  Vec _usrSrcUpwEquDen;
  VecScatter _usr2GlbSrcExaPos;
  VecScatter _usr2GlbSrcExaDen;
  VecScatter _usr2GlbSrcUpwEquDen;
  
  //IMPORTANT
  Kernel3d_MPI _knl_mm;
  
public:
  FMM3d_MPI(const string& p);
  ~FMM3d_MPI();
  //MEMBER ACCESS
  Point3& ctr() { return _ctr; }
  int& rootLevel() { return _rootLevel; }
  int& np() { return _np; }
  //SETUP and USE
  int setup();
  int evaluate(Vec srcDen, Vec trgVal);
  int check(Vec srcDen, Vec trgVal, int numchk, double& rerr);  //int report();
  //OTHER ACCESS
  Let3d_MPI* let() { return _let; }
  MatMgnt3d_MPI* matmgnt() { return _matmgnt; }

  Node& node(int gNodeIdx) { return _nodeVec[gNodeIdx]; }
  
protected:
  int datSze(int tp) { return _matmgnt->plnDatSze(tp); }
  //multiplication
  int SrcEqu2TrgChk_dgemv(const DblNumMat& srcPos, const DblNumMat& srcNor, const DblNumMat& trgPos, const DblNumVec& srcDen, DblNumVec& trgVal);
  int SrcEqu2UpwChk_dgemv(const DblNumMat& srcPos, const DblNumMat& srcNor, Point3 trgctr, double trgrad, const DblNumVec& srcDen, DblNumVec& trgVal);
  int SrcEqu2DwnChk_dgemv(const DblNumMat& srcPos, const DblNumMat& srcNor, Point3 trgctr, double trgrad, const DblNumVec& srcDen, DblNumVec& trgVal);
  int DwnEqu2TrgChk_dgemv(Point3 srcctr, double srcrad, const DblNumMat& trgPos, const DblNumVec& srcDen, DblNumVec& trgVal);
  int UpwEqu2TrgChk_dgemv(Point3 srcctr, double srcrad, const DblNumMat& trgPos, const DblNumVec& srcDen, DblNumVec& trgVal);
  //contributor data
  DblNumMat ctbSrcExaPos(int gNodeIdx);
  DblNumMat ctbSrcExaNor(int gNodeIdx);
  DblNumVec ctbSrcExaDen(int gNodeIdx);
  DblNumVec ctbSrcUpwEquDen(int gNodeIdx);
  DblNumVec ctbSrcUpwChkVal(int gNodeIdx);
  
  //user data
  DblNumMat usrSrcExaPos(int gNodeIdx);
  DblNumMat usrSrcExaNor(int gNodeIdx);
  DblNumVec usrSrcExaDen(int gNodeIdx);
  DblNumVec usrSrcUpwEquDen(int gNodeIdx);
  
  //evaluator data
  DblNumMat evaTrgExaPos(int gNodeIdx);
  DblNumVec evaTrgExaVal(int gNodeIdx);
  DblNumVec evaTrgDwnEquDen(int gNodeIdx);
  DblNumVec evaTrgDwnChkVal(int gNodeIdx);
  
};
#endif

---