doxy/html/CP__State__Plane_8h_source.html

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 /** \file CP_State_Plane.h

  *

  */

 //////////////////////////////////////////////////////////////////////////////


 #ifndef _PLANE_H_

 #define _PLANE_H_


 //////////////////////////////////////////////////////////////////////////////


 #include "charm++.h"

 #include "debug_flags.h"

 #include "ckmulticast.h"

 #include "structure_factor/StructFactorCache.h"

 #include "structure_factor/StructureFactor.h"

 //#include "ckPairCalculator.h"

 void getSplitDecomp(int *,int *,int *,int , int ,int );


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class ProductMsg : public CkMcastBaseMsg, public CMessage_ProductMsg {

  public:

     int datalen, hops;

     int subplane;

     double *data;

     int idx;

 };

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class CompAtmForcMsg: public CkMcastBaseMsg, public CMessage_CompAtmForcMsg {

  public:

    int nZmat;

    int iterNL;

    double *zmat;

    void init(int _nzmat, double *_zmat, int _iterNL)

      {

        nZmat = _nzmat;

        iterNL = _iterNL;

        CmiMemcpy(zmat, _zmat, sizeof(double)* nZmat);

      }

    friend class CMessage_CompAtmForcMsg;

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class GHartDummyMsg: public CMessage_GHartDummyMsg {

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class RSDummyResume: public CMessage_RSDummyResume {

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class TMsg: public CMessage_TMsg {

 public:

     int datalen;

     complex *data;

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class RhoGSFFTMsg: public CMessage_RhoGSFFTMsg {

 public:

     int size;

     int offset;

     int offsetGx;

     int iopt;

         int num;

     complex *data;

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class RhoGHartMsg: public CMessage_RhoGHartMsg {

 public:

     int size;

         int senderIndex;

         int offset;

     int offsetGx;

         int iter;

         int iopt;

         int num;

     complex *data;

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class RhoRHartMsg: public CMessage_RhoRHartMsg {

 public:

     int size;

         int senderIndex;

         int iopt;

         int iter;

     complex *data;

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class RhoRSFFTMsg: public CMessage_RhoRSFFTMsg {

 public:

     int size;

     int senderIndex;

     int iopt;

     complex *data;

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class RhoHartRSFFTMsg: public CMessage_RhoHartRSFFTMsg {

 public:

     int size;

     int index;

     int senderBigIndex;

     int senderStrtLine;

     int iopt;

     complex *data;

 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class RPPPFFTMsg: public CMessage_RPPPFFTMsg {

 public:

     int size;

     int senderIndex;

     int numPlanes;

     complex *data;

 };

 //////////////////////////////////////////////////////////////////////////////


 /** @addtogroup RealSpaceState

  *  @{

  *

  * \brief Chare Array 2D chare array nplanex X nstates.  Handles

  * electronic structure in real space. The points of plane-wave

  * pseudo-potential are cut along the x-dimension for finer

  * parallelization.

 */

 class CP_State_RealSpacePlane : public CBase_CP_State_RealSpacePlane {

  public:

     CP_State_RealSpacePlane_SDAG_CODE

     CP_State_RealSpacePlane(int, int,int,int,int,int,int, UberCollection);

     CP_State_RealSpacePlane(CkMigrateMessage *m) {};

     ~CP_State_RealSpacePlane() { if(cookie!=NULL) delete [] cookie; };

     void unpackFFT(RSFFTMsg *);

     void doFFT();

   void doVksFFT();

     void unpackProduct(ProductMsg *);

     void doProductThenFFT();

   void sendFPsiToGSP();

     void setNumPlanesToExpect(int num);

     void printData();

     void init(ProductMsg *);

     void doReduction();

     void ResumeFromSync();

     void pup(PUP::er &);

  private:

     const UberCollection thisInstance;

     int forwardTimeKeep;

     int backwardTimeKeep;

   int iplane_ind;

   int ibead_ind,kpoint_ind, itemper_ind;

   int iteration;

   int rhoRsubplanes;

   int ngrida;

   int ngridb;

   int ngridc;

     int count;

     int rsize;

     int csize;

   int countProduct;

     int numCookies;

   int istate;

     UberCollection RhoReductionDest;

     RealStateSlab rs;

     CkSectionInfo *cookie;

     CProxy_CP_State_GSpacePlane gproxy;

 };

 //////////////////////////////////////////////////////////////////////////////

 /*@}*/


 /** @addtogroup Density

     @{

 */

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class CP_Rho_RealSpacePlane : public CBase_CP_Rho_RealSpacePlane {

  public:

         int listSubFlag;

         int cp_grad_corr_on;

     int ees_eext_on;

         int nplane_rho_x;

         int ngridcEext;

     int ngrida;

         int ngridb;

         int ngridc;

         int iplane_ind;

         int myNgridb;      // I don't have all ngridb lines of x now

         int myNplane_rho;  // I don't have all nplane_rho_x lines of y now

         int nptsExpndA;

         int nptsExpndB;

         int nptsA;

         int nptsB;

         int myBoff;

         int myAoff;

         int countDebug;

         int countFFTRyToGy;

         int rhoRsubplanes;

         int myTime;

     bool doneRhoReal;

     bool doneRHart;

     int recvCountFromGRho;

     int recvCountFromGHartExt;

     CP_Rho_RealSpacePlane(CkMigrateMessage *m){}

     CP_Rho_RealSpacePlane(int, bool,int,int,int, UberCollection);

     void init();

        ~CP_Rho_RealSpacePlane();

     void pup(PUP::er &);

     void acceptDensity(CkReductionMsg *);

     void handleDensityReduction();

         void launchEextRNlG();

     void energyComputation();

     void fftRhoRtoRhoG();

         void launchNLRealFFT();

         void sendPartlyFFTRyToGy(int iopt);

         void acceptRhoGradVksRyToGy(RhoGSFFTMsg *msg);

         void fftRhoRyToGy(int iopt);

         void sendPartlyFFTtoRhoG(int );

         void acceptGradRhoVks(RhoRSFFTMsg *);

         void sendPartlyFFTGxToRx(int );

         void acceptRhoGradVksGxToRx(RhoGSFFTMsg *msg);

         void GradCorr();

         void whiteByrdFFT();

         void acceptWhiteByrd(RhoRSFFTMsg *msg);

         void addWhiteByrdVks();

         void acceptHartVks(RhoHartRSFFTMsg *);

         void addHartEextVks();

     void RHartReport();

         void doMulticastCheck();

     void doMulticast();

         void exitForDebugging();

     void isAtSync(int iter){AtSync();};

     void ResumeFromSync();

     void sendPartlyFFTtoRhoGall();

         void acceptGradRhoVksAll(RhoRSFFTMsg *msg);


  private:

     const UberCollection thisInstance;

     int rhoKeeperId;

         int rhoGHelpers;

         int countGradVks[5]; // number of collections that have arrived

         int countIntRtoG[5]; // our internal transpose friends.

         int countIntGtoR[5]; // our internal transpose friends.

         int countWhiteByrd;  // number of collections that have arrived

     int countRHart;

     int countRHartValue;

         int doneGradRhoVks; // count 1,2,3 = x,y,z all done

     bool doneWhiteByrd;

     bool doneHartVks;

     double FFTscale;

     double volumeFactor;

     double probScale;

     RhoRealSlab rho_rs;

         //Comlib multicast proxies

     CProxySection_CP_State_RealSpacePlane *realSpaceSectionProxyA;

         CProxySection_CP_State_RealSpacePlane *realSpaceSectionCProxyA;

     CProxy_CP_Rho_GSpacePlane rhoGProxy_com;

     CProxy_CP_Rho_GSpacePlane rhoGProxyIGX_com;

     CProxy_CP_Rho_GSpacePlane rhoGProxyIGY_com;

     CProxy_CP_Rho_GSpacePlane rhoGProxyIGZ_com;

     int redCount;

     CkReductionMsg *RedMsg;

 };

 //////////////////////////////////////////////////////////////////////////////

 /*@}*/


 /** @addtogroup Density

     @{

 */


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class CP_Rho_GSpacePlane:  public CBase_CP_Rho_GSpacePlane {

  public:

     CP_Rho_GSpacePlane(CkMigrateMessage *m) {}

     CP_Rho_GSpacePlane(int, int, int, bool, UberCollection);

     ~CP_Rho_GSpacePlane();

     void run();

     void init();

     void acceptRhoData(RhoGSFFTMsg *msg);

     void doRhoFFT(); // refine the name

     void ResumeFromSync();

         void divRhoVksGspace();

         void RhoGSendRhoR(int );

         void acceptWhiteByrd(RhoGSFFTMsg *);

         void acceptWhiteByrd();

     void pup(PUP::er &p);

     void isAtSync(int iter){AtSync();};

         int cp_grad_corr_on;

         int ees_eext_on;

         int ngridcEext;

         int rhoRsubplanes;

         int countDebug;

         void exitForDebugging();

         void acceptWhiteByrdAll(RhoGSFFTMsg *msg);

         void RhoGSendRhoRall();

     void launchNlG();

  private:

     const UberCollection thisInstance;

     CProxySection_GSpaceDriver nlsectproxy;

     int myTime;

     int recvCountFromRRho;

         int nPacked;

         int count_stuff;

     int count;

         int countWhiteByrd[4];

         int doneWhiteByrd;

         int rhoGHelpers;

         int iplane_ind;

         int *numSplit;

         int *istrtSplit;

         int *iendSplit;

     RhoGSlab rho_gs;

         CProxy_CP_Rho_RealSpacePlane rhoRealProxy0_com;

         CProxy_CP_Rho_RealSpacePlane rhoRealProxy1_com;

         CProxy_CP_Rho_RealSpacePlane rhoRealProxy2_com;

         CProxy_CP_Rho_RealSpacePlane rhoRealProxy3_com;

         CProxy_CP_Rho_RealSpacePlane rhoRealProxyByrd_com;

 };

 //////////////////////////////////////////////////////////////////////////////

 /*@}*/


 /** @addtogroup Density

     @{

 */

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class CP_Rho_RHartExt:  public CBase_CP_Rho_RHartExt {

  public:

     const UberCollection thisInstance;

         int listSubFlag;

         int nplane_rho_x;

         int rhoRsubplanes;

         int registrationFlag;

         int launchFlag;

         int ngrida;

         int ngridb;

         int ngridc;

         int iplane_ind;

         int ees_eext_on;

         int natmTyp;

         int countFFT[2];

         int countIntRtoG;

         int countIntGtoR[2];

         int iteration;

         int iterAtmTyp;

         int csize;

         int nAtmTypRecv;

         int csizeInt;

         int myNgridb;

         int myBoff;

         int nptsB;

         int nptsExpndB;

         int myNplane_rho;

         int myAoff;

         int nptsA;

         int nptsExpndA;

         int countDebug;

     int recvCountFromGHartExt;

     int nchareHartAtmT;

     int natmTypTot;

     int atmTypoff;


         complex *atmSFC;

         double  *atmSFR;

         complex *atmForcC;

         double  *atmForcR;


         complex *atmEwdSFC;

         double  *atmEwdSFR;

         complex *atmEwdForcC;

         double  *atmEwdForcR;


         complex *atmSFCint;

         double  *atmSFRint;

         complex *atmForcCint;

         double  *atmForcRint;


         complex *atmEwdSFCint;

         double  *atmEwdSFRint;

         complex *atmEwdForcCint;

         double  *atmEwdForcRint;


         CProxy_CP_Rho_GHartExt rhoGHartProxy_com;

     CP_Rho_RHartExt(CkMigrateMessage *m) {}

     CP_Rho_RHartExt(int , int , int , int , int, UberCollection );

     ~CP_Rho_RHartExt();

     void init();

     void pup(PUP::er &p);

         void startEextIter();

     void computeAtmSF();

         void registrationDone(CkReductionMsg *msg);

         void fftAtmSfRtoG();

         void sendAtmSfRyToGy();

         void recvAtmSfRyToGy(RhoGHartMsg *msg);

     void sendAtmSfRhoGHart();

         void recvAtmForcFromRhoGHart(RhoRHartMsg *msg);

     void fftAtmForcGtoR(int flagEwd);

         void sendAtmForcGxToRx(int iopt);

         void recvAtmForcGxToRx(RhoGHartMsg *msg);

     void computeAtmForc(int);

         void exitForDebugging();

 };

 //////////////////////////////////////////////////////////////////////////////

 /*@}*/


 /** @addtogroup Density

     @{

 */

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class CP_Rho_GHartExt:  public CBase_CP_Rho_GHartExt {

  public:

     CP_Rho_GHartExt(CkMigrateMessage *m) {}

     CP_Rho_GHartExt(int , int , int , int ,int, UberCollection );

     void init();

     ~CP_Rho_GHartExt();

     void pup(PUP::er &);

     void acceptData(RhoGHartMsg *msg);

     void HartExtVksG();

     void FFTVks();

     void sendVks();

     void acceptVks(int size, complex * inVks);

     void acceptAtmSFTot(int size, complex * inAtm);

         void recvAtmSFFromRhoRHart(RhoGHartMsg *msg);

         void FFTEesBck();

         void getHartEextEes();

         void FFTEesFwd(int );

         void sendAtmSF(int );

     void isAtSync(int iter){AtSync();};

         int rhoRsubplanes;

         int ngridaEext;

         int ngridbEext;

         int ngridcEext;

         int ees_eext_on;

         int natmTyp;

         int iterAtmTyp;

         int nsendAtmTyp;

         int numFullEext;

         int registrationFlag;

         int launchFlag;

         int CountDebug;

         int iperd;

         complex *atmSF;

         complex *atmSFtot;

         double ehart_ret;

         double eext_ret;

         double ewd_ret;

         void registrationDone(CkReductionMsg *msg);

         void exitForDebugging();

  private:

     const UberCollection thisInstance;

     complex *atmSFtotRecv;

     complex *VksRecv;

     int countAtmSFtot;

     int countVksTot;

     int nchareHartAtmT;

     int natmTypTot;

     int atmTypoff;

     int recvCountFromRHartExt;

     RhoGSlab rho_gs;

         int atmSFHere;

         int densityHere;

         int countEextFFT;

     int iopt;

         int iteration;

         int ind_x;       // This chares index=thisIndex.x.

         int ind_xdiv;    // This chare is a subcollection of rhog(ind_xdiv).

         int ind_xrem;    // The subcollection index  0<= ind_rem < rhoGHelpers.

         int rhoGHelpers; // The number of subcolletions of each rhog(ind_xdiv).

         int istrt_lines;  // start of my subdivion of lines in rhog()

         int iend_lines;   // end of my subdivion of lines in rhog()

         int numLines;    // Number of lines in my subdivision

         CProxy_CP_Rho_RealSpacePlane rhoRealProxy_com;

         CProxy_CP_Rho_RHartExt       rhoRHartProxy_com0;

         CProxy_CP_Rho_RHartExt       rhoRHartProxy_com1;

     int **index_pack_tran;

 };

 //////////////////////////////////////////////////////////////////////////////

 /*@}*/


 /** @addtogroup Particle

     @{

 */


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 class CP_State_RealParticlePlane: public CBase_CP_State_RealParticlePlane {

  public:

   // Variables

   const UberCollection thisInstance;

    int ees_nonlocal;

    int nChareR;           // Real Space chares=# C-planes

    int nChareG;           // G Space chares

    int Rstates_per_pe;    // Real Space topomap variable

    int myPlane;           // Real space plane number

    int ibead_ind,kpoint_ind, itemper_ind;


    int rhoRTime;

    int numIterNl;         // # of non-local iterations per time step

    int countZ;

    int countEnl;

    int count;             // fft communication counter

    int iterNL;            // Nl iteration counter

    int itime;             // time step counter;

    int recvBlock;


    int ngridA;            // FFT grid size along a

    int ngridB;            // FFT grid size along b

    int ngridC;            // FFT grid size along c

    int planeSize;         // expanded plane size for FFTing

    int planeSizeT;        // true plane size

    int csize;             // complex variable size for FFT

    int zmatSizeMax;       // zmatrix size for projector

    int reductionPlaneNum; // Reduction Plane number

    int itimeRed;


    int registrationFlag;


    bool launchFFT;

    bool fftDataDone;

    bool planeRedSectionComplete;

    bool enlSectionComplete;


    double cp_enl;         // Non-local energy

    double cp_enlTot;      // Reduced Non-local energy

    double *projPsiR;      // real/final form of projector (after gx,gy FFTs)

    complex *projPsiC;     // complex/intermediate form of projector (before gx,gy FFTs)

    double *zmat;          // Non-local matrix for doublePack

    double *zmatScr;       // Non-local matrix for doublePack

    complex *zmatC;        // Non-local matrix complex for not doublePack

    complex *zmatScrC;     // Non-local matrix complex for not doublePack


   //-----------

   // Proxies


    CProxySection_CP_State_RealParticlePlane rPlaneSectProxy; // Section Red proxy zmat

    CProxySection_CP_State_RealParticlePlane rPlaneENLProxy;  // Section Red proxy cp_enl

    CkSectionInfo rPlaneRedCookie;   // Section Red cookie for zmat

    CkSectionInfo rEnlCookie;        // Section Red cookie for cp_enl

    CProxy_CP_State_ParticlePlane gPP_proxy;

 #ifdef _CP_GS_DEBUG_COMPARE_VKS_

   complex *savedprojpsiC;

   complex *savedProjpsiCScr;

   double *savedProjpsiRScr;

   double *savedzmat;

   double **savedmn;

   double **saveddmn_x;

   double **saveddmn_y;

   double **saveddmn_z;

   int **savedigrid;


 #endif

   //-----------

   // Functions

    CP_State_RealParticlePlane(CkMigrateMessage *m) {}

    CP_State_RealParticlePlane(int , int , int ,int , int ,int ,int,int, UberCollection);

    void init();

   ~CP_State_RealParticlePlane();

    void planeRedSectDone(CkReductionMsg *m);

    void enlSectDone(CkReductionMsg *m);

    void initComplete();

    void launchFFTControl(int );

    void pup(PUP::er &);

    void printEnlR(CkReductionMsg *m);

    void printEnlRSimp(double,int,int);

    void recvFromEesGPP(NLFFTMsg *);

    void FFTNLEesFwdR();

    void computeZmatEes();

    void recvZMatEes(CkReductionMsg *);

    void computeAtmForcEes(CompAtmForcMsg *msg);

    void FFTNLEesBckR();

    void sendToEesGPP();

    void setPlaneRedCookie(EnlCookieMsg *);

    void setEnlCookie(EnlCookieMsg *);

    int calcReductionPlaneNum(int );

    void registrationDone();

    void recvZMatEesSimp(int , double *,int,int,int);

 };

 //////////////////////////////////////////////////////////////////////////////

 /*@}*/


 /** @addtogroup LargeSparse

     @{

 */


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 /**

  * The Large Sparse RhoG is where we interface with NAMD in QMMM for

  * the large grid

 */

 class CP_LargeSP_RhoGSpacePlane: public CBase_CP_LargeSP_RhoGSpacePlane {

  public:

   const UberCollection thisInstance;

   // Functions

    CP_LargeSP_RhoGSpacePlane(CkMigrateMessage *m) {}

    CP_LargeSP_RhoGSpacePlane(UberCollection);

    void init();

   ~CP_LargeSP_RhoGSpacePlane();

    void pup(PUP::er &);

    void acceptMDSg();

    void acceptLSPRhoR();


 };

 //////////////////////////////////////////////////////////////////////////////

 /*@}*/


 /** @addtogroup LargeSparse

     @{

 */


 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 /**

  * The Large Sparse RhoR is where we interpolate dense RhoR onto the large

  * grid for QMMM

 */

 class CP_LargeSP_RhoRealSpacePlane: public CBase_CP_LargeSP_RhoRealSpacePlane {

  public:

   const UberCollection thisInstance;

   // constructor Functions

    CP_LargeSP_RhoRealSpacePlane(CkMigrateMessage *m) {}

    CP_LargeSP_RhoRealSpacePlane(UberCollection);

    // entry methods

    void init();

    void acceptLSPRhoG();

    void acceptRhoR();


    // sequential stuff

   ~CP_LargeSP_RhoRealSpacePlane();

    void pup(PUP::er &);


 };

 //////////////////////////////////////////////////////////////////////////////


 //////////////////////////////////////////////////////////////////////////////


 /*@}*/


 //////////////////////////////////////////////////////////////////////////////

 #endif // #ifndef _PLANE_H_

 //////////////////////////////////////////////////////////////////////////////


CP_Rho_GHartExt::acceptAtmSFTot
void acceptAtmSFTot(int size, complex *inAtm)
Collect the SF from all the atm type chares on chare 0 //////////////////////////////////////////////...
Definition: CP_Rho_GHartExt.C:1110

CP_State_RealParticlePlane::recvZMatEes
void recvZMatEes(CkReductionMsg *)
Reduction client of zmat : Here everyone must have the same iteration ///////////////////////////////...
Definition: CP_State_RealParticlePlane.C:789

CP_Rho_RealSpacePlane::acceptRhoGradVksGxToRx
void acceptRhoGradVksGxToRx(RhoGSFFTMsg *msg)
Double Transpose Bck Recv : A(gx,y,z) on the way to A(x,y,z) Recv (gx,z) parallel -> (y...
Definition: CP_Rho_RealSpacePlane.C:1671

CP_Rho_GHartExt::getHartEextEes
void getHartEextEes()
compute HartreeEextEes
Definition: CP_Rho_GHartExt.C:814

CP_Rho_RealSpacePlane::acceptDensity
void acceptDensity(CkReductionMsg *)
Data comes from StateRspacePlane once an algorithm step.
Definition: CP_Rho_RealSpacePlane.C:374

CP_Rho_RealSpacePlane::sendPartlyFFTtoRhoG
void sendPartlyFFTtoRhoG(int)
The Tranpose to G-space : A(gx,gy,z) on the way to A(gx,gy,gz) Change parallel by gx...
Definition: CP_Rho_RealSpacePlane.C:1003

RhoRHartMsg
Definition: CP_State_Plane.h:116

CP_State_RealParticlePlane::planeRedSectDone
void planeRedSectDone(CkReductionMsg *m)
All cookies initialized for zmat plane reduction ////////////////////////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:342

UberCollection
holds the UberIndex and the offset for proxies
Definition: Uber.h:68

CMessage_RPPPFFTMsg

CP_Rho_RHartExt::startEextIter
void startEextIter()
Invoke by Rspace-density : Density has arrived in r-space and will soon arrive in g-space...
Definition: CP_Rho_RHartExt.C:287

CP_Rho_GSpacePlane
Definition: CP_State_Plane.h:321

RhoHartRSFFTMsg
Definition: CP_State_Plane.h:143

CP_State_RealParticlePlane::printEnlR
void printEnlR(CkReductionMsg *m)
Energy reduction client for ees method! /////////////////////////////////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:60

CompAtmForcMsg
Definition: CP_State_Plane.h:39

CP_Rho_GSpacePlane::acceptWhiteByrd
void acceptWhiteByrd()
Definition: CP_Rho_GSpacePlane.C:1091

CP_State_RealParticlePlane::calcReductionPlaneNum
int calcReductionPlaneNum(int)
spread the reduction plane numbers around to minimize map collisions
Definition: CP_State_RealParticlePlane.C:1301

CP_Rho_RHartExt::sendAtmSfRyToGy
void sendAtmSfRyToGy()
Double Transpose Fwd Send : A(gx,y,z) on the way to A(gx,gy,z) Send so that (y,z) parallelism is swit...
Definition: CP_Rho_RHartExt.C:492

CP_Rho_GSpacePlane::RhoGSendRhoRall
void RhoGSendRhoRall()
Definition: CP_Rho_GSpacePlane.C:781

CP_Rho_RealSpacePlane::addHartEextVks
void addHartEextVks()
Add the VksHartEext to VksTot : Set the done flag.
Definition: CP_Rho_RealSpacePlane.C:2251

CP_LargeSP_RhoRealSpacePlane::init
void init()
post constructor initialization
Definition: CP_LargeSP_RhoRealSpacePlane.C:106

CP_State_RealParticlePlane::computeAtmForcEes
void computeAtmForcEes(CompAtmForcMsg *msg)
Use Zmat and ProjPsi to get atmForces, Energy and psiforces /////////////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:850

RSDummyResume
Definition: CP_State_Plane.h:66

RPPPFFTMsg
Definition: CP_State_Plane.h:158

CP_Rho_RHartExt::exitForDebugging
void exitForDebugging()
Glenn's Rhart exit.
Definition: CP_Rho_RHartExt.C:1228

CP_Rho_GSpacePlane::divRhoVksGspace
void divRhoVksGspace()
invoke fft subroutine : doFwFFT() unpack do an FFT 1D along z rho(gx,gy,gz) parallelized in full z-li...
Definition: CP_Rho_GSpacePlane.C:591

CBase_CP_LargeSP_RhoRealSpacePlane

CP_State_RealParticlePlane::init
void init()
Post construction initialization.
Definition: CP_State_RealParticlePlane.C:194

CP_Rho_RealSpacePlane::addWhiteByrdVks
void addWhiteByrdVks()
Add the VksWhiteByrd to VksTot : Set the done flag.
Definition: CP_Rho_RealSpacePlane.C:2107

CP_Rho_GHartExt::registrationDone
void registrationDone(CkReductionMsg *msg)
= Make sure everyone is registered on the 1st time step
Definition: CP_Rho_GHartExt.C:641

CP_LargeSP_RhoRealSpacePlane::acceptLSPRhoG
void acceptLSPRhoG()
Data comes from LSP_RhoG once an algorithm step.
Definition: CP_LargeSP_RhoRealSpacePlane.C:169

CBase_CP_Rho_GSpacePlane

CP_State_RealParticlePlane::FFTNLEesBckR
void FFTNLEesBckR()
Do the FFT of projPsi(x,y,z) to get projPsi(gx,gy,z) ////////////////////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:1131

TMsg
Definition: CP_State_Plane.h:75

CP_Rho_RealSpacePlane::exitForDebugging
void exitForDebugging()
Glenn's RhoReal exit.
Definition: CP_Rho_RealSpacePlane.C:2422

CP_State_RealParticlePlane::sendToEesGPP
void sendToEesGPP()
Send the PsiForce NL FFT back to GparticlePlane.
Definition: CP_State_RealParticlePlane.C:1226

CP_State_RealParticlePlane::initComplete
void initComplete()
Initialization and registration done for this chare /////////////////////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:355

CP_LargeSP_RhoRealSpacePlane
The Large Sparse RhoR is where we interpolate dense RhoR onto the large grid for QMMM.
Definition: CP_State_Plane.h:672

CP_Rho_RHartExt::computeAtmForc
void computeAtmForc(int)
Get forces on atoms from Ewald or electrons /////////////////////////////////////////////////////////...
Definition: CP_Rho_RHartExt.C:1107

CP_Rho_GHartExt
Definition: CP_State_Plane.h:462

CP_Rho_RealSpacePlane::whiteByrdFFT
void whiteByrdFFT()
The white-bird term : First fwfft redefined delrho(r) to delrho(g) then send to RhoGspacePlane.
Definition: CP_Rho_RealSpacePlane.C:1886

CP_State_RealParticlePlane::printEnlRSimp
void printEnlRSimp(double, int, int)
Energy reduction client for ees method! /////////////////////////////////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:80

CP_State_RealParticlePlane::~CP_State_RealParticlePlane
~CP_State_RealParticlePlane()
The destructor : never called directly but I guess migration needs it ///////////////////////////////...
Definition: CP_State_RealParticlePlane.C:376

CP_Rho_RealSpacePlane::doMulticastCheck
void doMulticastCheck()
If all the parts of exc-eext-hart are done, invoke blast of vks to states.
Definition: CP_Rho_RealSpacePlane.C:2296

CBase_CP_LargeSP_RhoGSpacePlane

RSFFTMsg
Definition: CP_State_GSpacePlane.h:64

CBase_CP_Rho_GHartExt

CBase_CP_State_RealSpacePlane

EnlCookieMsg
Definition: CP_State_ParticlePlane.h:23

CP_Rho_RealSpacePlane::acceptWhiteByrd
void acceptWhiteByrd(RhoRSFFTMsg *msg)
The white bird vks correction is returned from RhoG : VksW(gx,gy,z) This routine recvs the transpose ...
Definition: CP_Rho_RealSpacePlane.C:1989

CP_Rho_GHartExt::recvAtmSFFromRhoRHart
void recvAtmSFFromRhoRHart(RhoGHartMsg *msg)
Recv Atm SF from RhoRhart : Euler Exponential spline based method ///////////////////////////////////...
Definition: CP_Rho_GHartExt.C:664

CP_Rho_GHartExt::FFTEesFwd
void FFTEesFwd(int)
Statr FFting to R-space atmSF(gx,gy,gz) -> atmSF(gx,gy,z) ///////////////////////////////////////////...
Definition: CP_Rho_GHartExt.C:950

CP_State_RealSpacePlane::init
void init(ProductMsg *)
Setting up the multicast trees for Gengbin's library.
Definition: CP_State_RealSpacePlane.C:729

CMessage_RSDummyResume

CBase_CP_State_RealParticlePlane

CP_State_RealParticlePlane::setPlaneRedCookie
void setPlaneRedCookie(EnlCookieMsg *)
Recv a dummy message, 1 integer, and set the cookie monster /////////////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:1323

CP_Rho_RealSpacePlane::launchEextRNlG
void launchEextRNlG()
The density is here : Launch ees NL and ees Ext routines.
Definition: CP_Rho_RealSpacePlane.C:492

CP_Rho_RealSpacePlane::fftRhoRyToGy
void fftRhoRyToGy(int iopt)
Double Transpose Fwd FFT : A(gx,y,z) -> A(gx,gy,z)
Definition: CP_Rho_RealSpacePlane.C:923

CBase_CP_Rho_RHartExt

CMessage_RhoRHartMsg

CP_Rho_RealSpacePlane::GradCorr
void GradCorr()
The gradient of the density is now completed.
Definition: CP_Rho_RealSpacePlane.C:1788

CP_State_RealParticlePlane::FFTNLEesFwdR
void FFTNLEesFwdR()
Complete the Forward FFT of psi-projector sent from g-space chares //////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:523

CP_Rho_RHartExt::fftAtmSfRtoG
void fftAtmSfRtoG()
FFT of SF(x,y,z,iatmTyp) -> SF(gx,gy,z,iatmTyp)
Definition: CP_Rho_RHartExt.C:417

RhoGSlab
Definition: fftCacheSlab.h:258

NLFFTMsg
Definition: CP_State_ParticlePlane.h:32

CP_Rho_GHartExt::acceptVks
void acceptVks(int size, complex *inVks)
Collect the VKS from all the atm type chares on chare 1 /////////////////////////////////////////////...
Definition: CP_Rho_GHartExt.C:1173

CBase_CP_Rho_RealSpacePlane

CP_State_RealParticlePlane::recvFromEesGPP
void recvFromEesGPP(NLFFTMsg *)
Recv FFT data/psi-projector from CP_StateParticlePlane kicking things off for this Chare...
Definition: CP_State_RealParticlePlane.C:406

CP_LargeSP_RhoGSpacePlane
The Large Sparse RhoG is where we interface with NAMD in QMMM for the large grid. ...
Definition: CP_State_Plane.h:645

CMessage_RhoRSFFTMsg

CP_Rho_RealSpacePlane
Definition: CP_State_Plane.h:224

CP_Rho_RHartExt::init
void init()
Definition: CP_Rho_RHartExt.C:143

CP_Rho_GSpacePlane::acceptWhiteByrdAll
void acceptWhiteByrdAll(RhoGSFFTMsg *msg)
RhoReal sends rho(gx,gy,z) here such that it is now decomposed with lines of constant gx...
Definition: CP_Rho_GSpacePlane.C:977

CP_Rho_RealSpacePlane::doMulticast
void doMulticast()
Send vks back to the states /////////////////////////////////////////////////////////////////////////...
Definition: CP_Rho_RealSpacePlane.C:2312

CP_State_RealParticlePlane::enlSectDone
void enlSectDone(CkReductionMsg *m)
All cookies initialized for enl section, only reduction root receives this //////////////////////////...
Definition: CP_State_RealParticlePlane.C:329

CP_LargeSP_RhoRealSpacePlane::pup
void pup(PUP::er &)
Pup my variables for migration.
Definition: CP_LargeSP_RhoRealSpacePlane.C:130

RhoRealSlab
Definition: fftCacheSlab.h:195

CMessage_RhoGSFFTMsg

CMessage_RhoHartRSFFTMsg

CP_Rho_RealSpacePlane::acceptHartVks
void acceptHartVks(RhoHartRSFFTMsg *)
Accept hartExt transpose data : receive VksHartEext(gx,gy,z) gx,z is parallel.
Definition: CP_Rho_RealSpacePlane.C:2144

RealStateSlab
Definition: fftCacheSlab.h:166

CP_State_RealSpacePlane::doReduction
void doReduction()
No one else can use tmpdataR until I perform doReduction because I will not be rolled out until I fin...
Definition: CP_State_RealSpacePlane.C:417

CP_Rho_RealSpacePlane::acceptGradRhoVks
void acceptGradRhoVks(RhoRSFFTMsg *)
Accept transpose data from RhoG : receive grad_rho(gy,gx,z)
Definition: CP_Rho_RealSpacePlane.C:1233

CP_Rho_RealSpacePlane::launchNLRealFFT
void launchNLRealFFT()
Launch ees-nonlocal real here.
Definition: CP_Rho_RealSpacePlane.C:703

CP_Rho_GHartExt::sendAtmSF
void sendAtmSF(int)
Send the SF data to back to Rhart to get atm forces /////////////////////////////////////////////////...
Definition: CP_Rho_GHartExt.C:983

CP_Rho_RHartExt::sendAtmSfRhoGHart
void sendAtmSfRhoGHart()
Send SF(gx,gy,z,iatmTYP) to g-space whence the FFT will be completed.
Definition: CP_Rho_RHartExt.C:654

CP_Rho_GHartExt::FFTVks
void FFTVks()
Partly fft vks(gx,gy,gz) -> vks(gx,gy,z)
Definition: CP_Rho_GHartExt.C:493

CP_Rho_GHartExt::acceptData
void acceptData(RhoGHartMsg *msg)
The density arrives from RhoGspace ONCE a time step /////////////////////////////////////////////////...
Definition: CP_Rho_GHartExt.C:364

CP_Rho_RHartExt::computeAtmSF
void computeAtmSF()
Start the real space part of the EES interpolation for atmSF(iatmTyp) ///////////////////////////////...
Definition: CP_Rho_RHartExt.C:363

CP_LargeSP_RhoGSpacePlane::acceptLSPRhoR
void acceptLSPRhoR()
Data comes from LargeSP_RhoReal once an algorithm step.
Definition: CP_LargeSP_RhoGSpacePlane.C:146

CP_Rho_RealSpacePlane::handleDensityReduction
void handleDensityReduction()
Handle the memory cleanup and setting of flags when density has all arrived.
Definition: CP_Rho_RealSpacePlane.C:417

CP_Rho_RealSpacePlane::init
void init()
post constructor initialization
Definition: CP_Rho_RealSpacePlane.C:215

CMessage_RhoGHartMsg

CP_Rho_RealSpacePlane::sendPartlyFFTGxToRx
void sendPartlyFFTGxToRx(int)
Double Transpose Bck Send : A(gx,y,z) on the way to A(x,y,z) Send so (gx,z) parallel -> (y...
Definition: CP_Rho_RealSpacePlane.C:1555

CP_State_RealParticlePlane
Definition: CP_State_Plane.h:539

CMessage_CompAtmForcMsg

CP_Rho_RHartExt
Definition: CP_State_Plane.h:377

CP_State_RealParticlePlane::recvZMatEesSimp
void recvZMatEesSimp(int, double *, int, int, int)
A chare can be behind by 1 iteration only.
Definition: CP_State_RealParticlePlane.C:708

CP_Rho_RealSpacePlane::energyComputation
void energyComputation()
Compute one part of the EXC energy using PINY CP_exc_calc.
Definition: CP_Rho_RealSpacePlane.C:573

CP_Rho_GHartExt::~CP_Rho_GHartExt
~CP_Rho_GHartExt()
Destructor /////////////////////////////////////////////////////////////////////////// //////////////...
Definition: CP_Rho_GHartExt.C:290

CP_Rho_GHartExt::init
void init()
Post constructor initialization /////////////////////////////////////////////////////////////////////...
Definition: CP_Rho_GHartExt.C:234

CP_Rho_RealSpacePlane::acceptRhoGradVksRyToGy
void acceptRhoGradVksRyToGy(RhoGSFFTMsg *msg)
Double Transpose Fwd Recv : A(gx,y,z) on the way to A(gx,gy,z) Recv so that (y,z) parallel switched t...
Definition: CP_Rho_RealSpacePlane.C:872

CP_State_RealSpacePlane::doFFT
void doFFT()
After receiving from G-space, FFT to real space /////////////////////////////////////////////////////...
Definition: CP_State_RealSpacePlane.C:264

getSplitDecomp
void getSplitDecomp(int *, int *, int *, int, int, int)
Initialization Function /////////////////////////////////////////////////////////////////////////// /...
Definition: util.C:2250

CP_Rho_RHartExt::fftAtmForcGtoR
void fftAtmForcGtoR(int flagEwd)
Complete the FFT : sf(gx,gy,z) ->sf(x,y,z) //////////////////////////////////////////////////////////...
Definition: CP_Rho_RHartExt.C:878

CkMcastBaseMsg

CP_Rho_GSpacePlane::launchNlG
void launchNlG()
The density is here : Launch ees NL.
Definition: CP_Rho_GSpacePlane.C:558

CP_State_RealParticlePlane::launchFFTControl
void launchFFTControl(int)
Control launch of FFT based on Rho having more of its act together //////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:1113

CP_State_RealParticlePlane::registrationDone
void registrationDone()
= Make sure everyone is registered on the 1st time step
Definition: CP_State_RealParticlePlane.C:1384

RhoGHartMsg
Definition: CP_State_Plane.h:100

CP_Rho_GSpacePlane::acceptRhoData
void acceptRhoData(RhoGSFFTMsg *msg)
RhoReal sends rho(gx,gy,z) here such that it is now decomposed with lines of constant gx...
Definition: CP_Rho_GSpacePlane.C:345

CP_Rho_RealSpacePlane::fftRhoRtoRhoG
void fftRhoRtoRhoG()
1) Perform FFT of density: Single Transpose method rho(x,y,z) —> rho(gx,gy,z) Double Transpose method...
Definition: CP_Rho_RealSpacePlane.C:626

CP_State_RealSpacePlane
Definition: CP_State_Plane.h:175

CP_Rho_GHartExt::sendVks
void sendVks()
Send vks_hart_ext back to rho_real where fft(gx,gy) will be performed ///////////////////////////////...
Definition: CP_Rho_GHartExt.C:535

CP_Rho_RHartExt::recvAtmForcGxToRx
void recvAtmForcGxToRx(RhoGHartMsg *msg)
Definition: CP_Rho_RHartExt.C:1021

RhoGSFFTMsg
Definition: CP_State_Plane.h:86

ProductMsg
Definition: CP_State_Plane.h:28

CP_Rho_RealSpacePlane::acceptGradRhoVksAll
void acceptGradRhoVksAll(RhoRSFFTMsg *msg)
Accept transpose data from RhoG : receive grad_rho(gy,gx,z)
Definition: CP_Rho_RealSpacePlane.C:1389

CP_Rho_RealSpacePlane::sendPartlyFFTRyToGy
void sendPartlyFFTRyToGy(int iopt)
Double Transpose Fwd Send : A(gx,y,z) on the way to A(gx,gy,z) Send so that (y,z) parallelism is swit...
Definition: CP_Rho_RealSpacePlane.C:752

CP_Rho_GHartExt::FFTEesBck
void FFTEesBck()
Finish FFting to G-space :: 2D) atmSF(gx,gy,z) -> atmSF(gx,gy,gz)
Definition: CP_Rho_GHartExt.C:775

CP_State_RealSpacePlane::sendFPsiToGSP
void sendFPsiToGSP()
Definition: CP_State_RealSpacePlane.C:639

CP_LargeSP_RhoRealSpacePlane::acceptRhoR
void acceptRhoR()
Data comes from Rho_Real once an algorithm step.
Definition: CP_LargeSP_RhoRealSpacePlane.C:146

CP_Rho_GSpacePlane::RhoGSendRhoR
void RhoGSendRhoR(int)
Definition: CP_Rho_GSpacePlane.C:647

debug_flags.h
Useful debugging flags.

complex
Definition: convert_State2KPTState.C:7

CP_Rho_RHartExt::registrationDone
void registrationDone(CkReductionMsg *msg)
= Make sure everyone is registered on the 1st time step
Definition: CP_Rho_RHartExt.C:333

CP_LargeSP_RhoGSpacePlane::acceptMDSg
void acceptMDSg()
Data comes from MD once an algorithm step.
Definition: CP_LargeSP_RhoGSpacePlane.C:169

CP_LargeSP_RhoGSpacePlane::pup
void pup(PUP::er &)
Pup my variables for migration.
Definition: CP_LargeSP_RhoGSpacePlane.C:130

CP_Rho_RealSpacePlane::sendPartlyFFTtoRhoGall
void sendPartlyFFTtoRhoGall()
Definition: CP_Rho_RealSpacePlane.C:1143

CP_Rho_GHartExt::HartExtVksG
void HartExtVksG()
Compute hartree eext and vks using the N^2 method ///////////////////////////////////////////////////...
Definition: CP_Rho_GHartExt.C:419

CP_State_RealSpacePlane::doVksFFT
void doVksFFT()
Definition: CP_State_RealSpacePlane.C:583

CMessage_TMsg

GHartDummyMsg
Definition: CP_State_Plane.h:58

RhoRSFFTMsg
Definition: CP_State_Plane.h:131

CP_Rho_GSpacePlane::doRhoFFT
void doRhoFFT()
Complete the FFT to give use Rho(gx,gy,gz) //////////////////////////////////////////////////////////...
Definition: CP_Rho_GSpacePlane.C:445

CP_State_RealParticlePlane::setEnlCookie
void setEnlCookie(EnlCookieMsg *)
Recv a dummy message, 1 integer, and set the cookie monster /////////////////////////////////////////...
Definition: CP_State_RealParticlePlane.C:1355

CP_State_RealParticlePlane::computeZmatEes
void computeZmatEes()
Compute the Zmat elements of this iteration : Spawn the section reduction ///////////////////////////...
Definition: CP_State_RealParticlePlane.C:631

CP_Rho_RHartExt::recvAtmSfRyToGy
void recvAtmSfRyToGy(RhoGHartMsg *msg)
Double Transpose Fwd Recv : A(gx,y,z) on the way to A(gx,gy,z) Recv so that (y,z) parallel switched t...
Definition: CP_Rho_RHartExt.C:577

CP_State_RealSpacePlane::unpackProduct
void unpackProduct(ProductMsg *)
In this method, we receive vks from the density.
Definition: CP_State_RealSpacePlane.C:496

CP_State_RealSpacePlane::unpackFFT
void unpackFFT(RSFFTMsg *)
Definition: CP_State_RealSpacePlane.C:170

CP_Rho_RHartExt::recvAtmForcFromRhoGHart
void recvAtmForcFromRhoGHart(RhoRHartMsg *msg)
Hartree sends back atom forces from e-atm interation Depending on the flag, it is Ewald or e-atm inte...
Definition: CP_Rho_RHartExt.C:753

CP_Rho_GHartExt::exitForDebugging
void exitForDebugging()
Glenn's special exit.
Definition: CP_Rho_GHartExt.C:1205

CP_Rho_GSpacePlane::init
void init()
post constructor initialization /////////////////////////////////////////////////////////////////////...
Definition: CP_Rho_GSpacePlane.C:191

CP_Rho_RealSpacePlane::RHartReport
void RHartReport()
Under ees-eext Rhart chare reports its completion : Set the done flag.
Definition: CP_Rho_RealSpacePlane.C:2278

CMessage_GHartDummyMsg

CP_State_RealSpacePlane::CP_State_RealSpacePlane
CP_State_RealSpacePlane_SDAG_CODE CP_State_RealSpacePlane(int, int, int, int, int, int, int, UberCollection)
Definition: CP_State_RealSpacePlane.C:85

CP_Rho_GSpacePlane::exitForDebugging
void exitForDebugging()
Glenn's RhoReal exit.
Definition: CP_Rho_GSpacePlane.C:1161

CP_Rho_RHartExt::sendAtmForcGxToRx
void sendAtmForcGxToRx(int iopt)
Definition: CP_Rho_RHartExt.C:930

CMessage_ProductMsg

CP_LargeSP_RhoGSpacePlane::init
void init()
post constructor initialization
Definition: CP_LargeSP_RhoGSpacePlane.C:106

CP_Rho_RealSpacePlane::pup
void pup(PUP::er &)
Pup my variables for migration.
Definition: CP_Rho_RealSpacePlane.C:298