Refactor: remove wf from esolver (#5567)

haozhihan · web-flow · commit ed2fecf6933b · 2024-11-22T21:24:16.000+08:00
* repalce wf.npwx

* change the file name `wfinit`

* remove wf from esolver

* fix build bug
diff --git a/source/Makefile.Objects b/source/Makefile.Objects
@@ -666,7 +666,7 @@ OBJS_SRCPW=H_Ewald_pw.o\
     symmetry_rhog.o\
     wavefunc.o\
     wf_atomic.o\
-    wfinit.o\
+    psiinit.o\
     elecond.o\
     sto_tool.o\
     sto_elecond.o\
diff --git a/source/module_esolver/esolver_ks.h b/source/module_esolver/esolver_ks.h
@@ -65,10 +65,6 @@ class ESolver_KS : public ESolver_FP
     //! Charge mixing method, only used in KDSFT, not in OFDFT
     Charge_Mixing* p_chgmix = nullptr;
 
-    //! wave functions, this one may be deleted in near future
-    //! mohan note 2024-11-14
-    wavefunc wf;
-
     //! Electronic wavefunctions
     psi::Psi<T>* psi = nullptr;
 
diff --git a/source/module_esolver/esolver_ks_pw.cpp b/source/module_esolver/esolver_ks_pw.cpp
@@ -185,7 +185,6 @@ void ESolver_KS_PW<T, Device>::before_all_runners(const Input_para& inp, UnitCel
                                                   PARAM.inp.ks_solver,
                                                   PARAM.inp.basis_type,
                                                   PARAM.inp.psi_initializer,
-                                                  &this->wf,
                                                   this->pw_wfc);
     this->p_wf_init->prepare_init(&(this->sf),
                                   &ucell,
diff --git a/source/module_esolver/esolver_ks_pw.h b/source/module_esolver/esolver_ks_pw.h
@@ -2,7 +2,7 @@
 #define ESOLVER_KS_PW_H
 #include "./esolver_ks.h"
 #include "module_hamilt_pw/hamilt_pwdft/operator_pw/velocity_pw.h"
-#include "module_hamilt_pw/hamilt_pwdft/wfinit.h"
+#include "module_hamilt_pw/hamilt_pwdft/psiinit.h"
 
 #include <memory>
 #include <module_base/macros.h>
diff --git a/source/module_esolver/esolver_sdft_pw.cpp b/source/module_esolver/esolver_sdft_pw.cpp
@@ -78,13 +78,13 @@ void ESolver_SDFT_PW<T, Device>::before_all_runners(const Input_para& inp, UnitC
     // 4) allocate spaces for \sqrt(f(H))|chi> and |\tilde{chi}>
     size_t size = stowf.chi0->size();
     this->stowf.shchi
-        = new psi::Psi<T, Device>(this->kv.get_nks(), this->stowf.nchip_max, this->wf.npwx, this->kv.ngk.data());
+        = new psi::Psi<T, Device>(this->kv.get_nks(), this->stowf.nchip_max, this->pw_wfc->npwk_max, this->kv.ngk.data());
     ModuleBase::Memory::record("SDFT::shchi", size * sizeof(T));
 
     if (PARAM.inp.nbands > 0)
     {
         this->stowf.chiortho
-            = new psi::Psi<T, Device>(this->kv.get_nks(), this->stowf.nchip_max, this->wf.npwx, this->kv.ngk.data());
+            = new psi::Psi<T, Device>(this->kv.get_nks(), this->stowf.nchip_max, this->pw_wfc->npwk_max, this->kv.ngk.data());
         ModuleBase::Memory::record("SDFT::chiortho", size * sizeof(T));
     }
 
diff --git a/source/module_hamilt_pw/hamilt_pwdft/CMakeLists.txt b/source/module_hamilt_pw/hamilt_pwdft/CMakeLists.txt
@@ -28,7 +28,7 @@ list(APPEND objects
     VNL_grad_pw.cpp
     wavefunc.cpp
     wf_atomic.cpp
-    wfinit.cpp
+    psiinit.cpp
     structure_factor.cpp
     structure_factor_k.cpp
     soc.cpp
diff --git a/source/module_hamilt_pw/hamilt_pwdft/psiinit.cpp b/source/module_hamilt_pw/hamilt_pwdft/psiinit.cpp
@@ -1,4 +1,4 @@
-#include "wfinit.h"
+#include "psiinit.h"
 
 #include "module_base/macros.h"
 #include "module_base/timer.h"
@@ -18,14 +18,12 @@ PSIInit<T, Device>::PSIInit(const std::string& init_wfc_in,
                             const std::string& ks_solver_in,
                             const std::string& basis_type_in,
                             const bool& use_psiinitializer_in,
-                            wavefunc* p_wf_in,
                             ModulePW::PW_Basis_K* pw_wfc_in)
 {
     this->init_wfc = init_wfc_in;
     this->ks_solver = ks_solver_in;
     this->basis_type = basis_type_in;
     this->use_psiinitializer = use_psiinitializer_in;
-    this->p_wf = p_wf_in;
     this->pw_wfc = pw_wfc_in;
 }
 
@@ -122,16 +120,16 @@ void PSIInit<T, Device>::allocate_psi(Psi<std::complex<double>>*& psi,
         // old method explicitly requires variables such as total number of kpoints, number
         // of bands, number of G-vectors, and so on. Comparatively in new method, these
         // variables are imported in function called initialize.
-        psi = this->p_wf->allocate(nkstot, nks, ngk, npwx);
+        psi = this->wf_old.allocate(nkstot, nks, ngk, npwx);
 
         // however, init_at_1 does not actually initialize the psi, instead, it is a
         // function to calculate a interpolate table saving overlap intergral or say
         // Spherical Bessel Transform of atomic orbitals.
-        this->p_wf->init_at_1(p_sf);
+        this->wf_old.init_at_1(p_sf);
         // similarly, wfcinit not really initialize any wavefunction, instead, it initialize
         // the mapping from ixy, the 1d flattened index of point on fft grid (x, y) plane,
         // to the index of "stick", composed of grid points.
-        this->p_wf->wfcinit(psi, pw_wfc);
+        this->wf_old.wfcinit(psi, pw_wfc);
     }
 }
 
@@ -143,8 +141,8 @@ void PSIInit<T, Device>::make_table(const int nks, Structure_Factor* p_sf)
     }    // do not need to do anything because the interpolate table is unchanged
     else // old initialization method, used in EXX calculation
     {
-        this->p_wf->init_after_vc(nks); // reallocate wanf2, the planewave expansion of lcao
-        this->p_wf->init_at_1(p_sf);    // re-calculate tab_at, the overlap matrix between atomic pswfc and jlq
+        this->wf_old.init_after_vc(nks); // reallocate wanf2, the planewave expansion of lcao
+        this->wf_old.init_at_1(p_sf);    // re-calculate tab_at, the overlap matrix between atomic pswfc and jlq
     }
 }
 
@@ -271,7 +269,7 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,
                         kspw_psi->fix_k(ik);
 
                         /// for psi init guess!!!!
-                        hamilt::diago_PAO_in_pw_k2(this->ctx, ik, *(kspw_psi), this->pw_wfc, this->p_wf, p_hamilt);
+                        hamilt::diago_PAO_in_pw_k2(this->ctx, ik, *(kspw_psi), this->pw_wfc, &this->wf_old, p_hamilt);
                     }
                 }
                 else
@@ -280,7 +278,7 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,
                     kspw_psi->fix_k(ik);
 
                     /// for psi init guess!!!!
-                    hamilt::diago_PAO_in_pw_k2(this->ctx, ik, *(kspw_psi), this->pw_wfc, this->p_wf, p_hamilt);
+                    hamilt::diago_PAO_in_pw_k2(this->ctx, ik, *(kspw_psi), this->pw_wfc, &this->wf_old, p_hamilt);
                 }
             }
         }
diff --git a/source/module_hamilt_pw/hamilt_pwdft/psiinit.h b/source/module_hamilt_pw/hamilt_pwdft/psiinit.h
@@ -16,7 +16,6 @@ class PSIInit
             const std::string& ks_solver_in,
             const std::string& basis_type_in,
             const bool& use_psiinitializer_in,
-            wavefunc* p_wf_in,
             ModulePW::PW_Basis_K* pw_wfc_in);
     ~PSIInit(){};
 
@@ -47,7 +46,7 @@ class PSIInit
      *
      * @param psi store the wavefunction
      * @param p_hamilt Hamiltonian operator
-     * @param ofs_running output stream for running information 
+     * @param ofs_running output stream for running information
      * @param is_already_initpsi whether psi has been initialized
      */
     void initialize_psi(Psi<std::complex<double>>* psi,
@@ -73,17 +72,22 @@ class PSIInit
     // while the std::make_unique() is not supported till C++14,
     // so use the new and std::unique_ptr to manage the memory, but this makes new-delete not symmetric
     std::unique_ptr<psi_initializer<T, Device>> psi_init;
-    // temporary
-    // wavefunc pointer
-    wavefunc* p_wf = nullptr;
+
+    //! temporary: wave functions, this one may be deleted in future
+    wavefunc wf_old;
+
     // whether to use psi_initializer
     bool use_psiinitializer = false;
+
     // wavefunction initialization type
     std::string init_wfc = "none";
+
     // Kohn-Sham solver type
     std::string ks_solver = "none";
+
     // basis type
     std::string basis_type = "none";
+
     // pw basis
     ModulePW::PW_Basis_K* pw_wfc = nullptr;
 
diff --git a/source/module_ri/exx_lip.hpp b/source/module_ri/exx_lip.hpp
@@ -21,7 +21,7 @@
 #include "module_elecstate/elecstate.h"
 #include "module_basis/module_pw/pw_basis_k.h"
 #include "module_cell/module_symmetry/symmetry.h"
-#include "module_hamilt_pw/hamilt_pwdft/wfinit.h"
+#include "module_hamilt_pw/hamilt_pwdft/psiinit.h"
 #include "module_hamilt_pw/hamilt_pwdft/structure_factor.h"
 #include "module_base/tool_title.h"
 #include "module_base/timer.h"

Original file line number	Diff line number	Diff line change
`@@ -78,13 +78,13 @@ void ESolver_SDFT_PW<T, Device>::before_all_runners(const Input_para& inp, UnitC`
`78`	`78`	`// 4) allocate spaces for \sqrt(f(H))\|chi> and \|\tilde{chi}>`
`79`	`79`	`size_t size = stowf.chi0->size();`
`80`	`80`	`this->stowf.shchi`
`81`		`- = new psi::Psi<T, Device>(this->kv.get_nks(), this->stowf.nchip_max, this->wf.npwx, this->kv.ngk.data());`
	`81`	`+ = new psi::Psi<T, Device>(this->kv.get_nks(), this->stowf.nchip_max, this->pw_wfc->npwk_max, this->kv.ngk.data());`
`82`	`82`	`ModuleBase::Memory::record("SDFT::shchi", size * sizeof(T));`
`83`	`83`
`84`	`84`	`if (PARAM.inp.nbands > 0)`
`85`	`85`	`{`
`86`	`86`	`this->stowf.chiortho`
`87`		`- = new psi::Psi<T, Device>(this->kv.get_nks(), this->stowf.nchip_max, this->wf.npwx, this->kv.ngk.data());`
	`87`	`+ = new psi::Psi<T, Device>(this->kv.get_nks(), this->stowf.nchip_max, this->pw_wfc->npwk_max, this->kv.ngk.data());`
`88`	`88`	`ModuleBase::Memory::record("SDFT::chiortho", size * sizeof(T));`
`89`	`89`	`}`
`90`	`90`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#include "wfinit.h"`
	`1`	`+#include "psiinit.h"`
`2`	`2`
`3`	`3`	`#include "module_base/macros.h"`
`4`	`4`	`#include "module_base/timer.h"`
`@@ -18,14 +18,12 @@ PSIInit<T, Device>::PSIInit(const std::string& init_wfc_in,`
`18`	`18`	`const std::string& ks_solver_in,`
`19`	`19`	`const std::string& basis_type_in,`
`20`	`20`	`const bool& use_psiinitializer_in,`
`21`		`- wavefunc* p_wf_in,`
`22`	`21`	`ModulePW::PW_Basis_K* pw_wfc_in)`
`23`	`22`	`{`
`24`	`23`	`this->init_wfc = init_wfc_in;`
`25`	`24`	`this->ks_solver = ks_solver_in;`
`26`	`25`	`this->basis_type = basis_type_in;`
`27`	`26`	`this->use_psiinitializer = use_psiinitializer_in;`
`28`		`- this->p_wf = p_wf_in;`
`29`	`27`	`this->pw_wfc = pw_wfc_in;`
`30`	`28`	`}`
`31`	`29`
`@@ -122,16 +120,16 @@ void PSIInit<T, Device>::allocate_psi(Psi<std::complex<double>>*& psi,`
`122`	`120`	`// old method explicitly requires variables such as total number of kpoints, number`
`123`	`121`	`// of bands, number of G-vectors, and so on. Comparatively in new method, these`
`124`	`122`	`// variables are imported in function called initialize.`
`125`		`- psi = this->p_wf->allocate(nkstot, nks, ngk, npwx);`
	`123`	`+ psi = this->wf_old.allocate(nkstot, nks, ngk, npwx);`
`126`	`124`
`127`	`125`	`// however, init_at_1 does not actually initialize the psi, instead, it is a`
`128`	`126`	`// function to calculate a interpolate table saving overlap intergral or say`
`129`	`127`	`// Spherical Bessel Transform of atomic orbitals.`
`130`		`- this->p_wf->init_at_1(p_sf);`
	`128`	`+ this->wf_old.init_at_1(p_sf);`
`131`	`129`	`// similarly, wfcinit not really initialize any wavefunction, instead, it initialize`
`132`	`130`	`// the mapping from ixy, the 1d flattened index of point on fft grid (x, y) plane,`
`133`	`131`	`// to the index of "stick", composed of grid points.`
`134`		`- this->p_wf->wfcinit(psi, pw_wfc);`
	`132`	`+ this->wf_old.wfcinit(psi, pw_wfc);`
`135`	`133`	`}`
`136`	`134`	`}`
`137`	`135`
`@@ -143,8 +141,8 @@ void PSIInit<T, Device>::make_table(const int nks, Structure_Factor* p_sf)`
`143`	`141`	`} // do not need to do anything because the interpolate table is unchanged`
`144`	`142`	`else // old initialization method, used in EXX calculation`
`145`	`143`	`{`
`146`		`- this->p_wf->init_after_vc(nks); // reallocate wanf2, the planewave expansion of lcao`
`147`		`- this->p_wf->init_at_1(p_sf); // re-calculate tab_at, the overlap matrix between atomic pswfc and jlq`
	`144`	`+ this->wf_old.init_after_vc(nks); // reallocate wanf2, the planewave expansion of lcao`
	`145`	`+ this->wf_old.init_at_1(p_sf); // re-calculate tab_at, the overlap matrix between atomic pswfc and jlq`
`148`	`146`	`}`
`149`	`147`	`}`
`150`	`148`
`@@ -271,7 +269,7 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,`
`271`	`269`	`kspw_psi->fix_k(ik);`
`272`	`270`
`273`	`271`	`/// for psi init guess!!!!`
`274`		`- hamilt::diago_PAO_in_pw_k2(this->ctx, ik, *(kspw_psi), this->pw_wfc, this->p_wf, p_hamilt);`
	`272`	`+ hamilt::diago_PAO_in_pw_k2(this->ctx, ik, *(kspw_psi), this->pw_wfc, &this->wf_old, p_hamilt);`
`275`	`273`	`}`
`276`	`274`	`}`
`277`	`275`	`else`
`@@ -280,7 +278,7 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,`
`280`	`278`	`kspw_psi->fix_k(ik);`
`281`	`279`
`282`	`280`	`/// for psi init guess!!!!`
`283`		`- hamilt::diago_PAO_in_pw_k2(this->ctx, ik, *(kspw_psi), this->pw_wfc, this->p_wf, p_hamilt);`
	`281`	`+ hamilt::diago_PAO_in_pw_k2(this->ctx, ik, *(kspw_psi), this->pw_wfc, &this->wf_old, p_hamilt);`
`284`	`282`	`}`
`285`	`283`	`}`
`286`	`284`	`}`