change ucell in module_psi/wavefunc.cpp

A-006 · A-006 · commit 7f0807da53e9 · 2024-12-04T10:50:34.000+08:00
diff --git a/source/module_esolver/esolver_ks_pw.cpp b/source/module_esolver/esolver_ks_pw.cpp
@@ -373,6 +373,7 @@ void ESolver_KS_PW<T, Device>::before_scf(UnitCell& ucell, const int istep)
                                         this->kspw_psi,
                                         this->p_hamilt,
                                         this->ppcell,
+                                        ucell,
                                         GlobalV::ofs_running,
                                         this->already_initpsi);
 
diff --git a/source/module_psi/psi_init.cpp b/source/module_psi/psi_init.cpp
@@ -152,6 +152,7 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,
                                         psi::Psi<T, Device>* kspw_psi,
                                         hamilt::Hamilt<T, Device>* p_hamilt,
                                         const pseudopot_cell_vnl& nlpp,
+                                        const UnitCell& ucell,
                                         std::ofstream& ofs_running,
                                         const bool is_already_initpsi)
 {
@@ -278,6 +279,8 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,
                                                    &this->wf_old,
                                                    nlpp.tab_at,
                                                    nlpp.lmaxkb,
+                                                   ucell.natomwfc,
+                                                   ucell.lmax_ppwf,
                                                    p_hamilt);
                     }
                 }
@@ -294,6 +297,8 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,
                                                &this->wf_old,
                                                nlpp.tab_at,
                                                nlpp.lmaxkb,
+                                               ucell.natomwfc,
+                                               ucell.lmax_ppwf,
                                                p_hamilt);
                 }
             }
diff --git a/source/module_psi/psi_init.h b/source/module_psi/psi_init.h
@@ -54,6 +54,7 @@ class PSIInit
                         psi::Psi<T, Device>* kspw_psi,
                         hamilt::Hamilt<T, Device>* p_hamilt,
                         const pseudopot_cell_vnl& nlpp,
+                        const UnitCell& ucell,
                         std::ofstream& ofs_running,
                         const bool is_already_initpsi);
 
diff --git a/source/module_psi/wavefunc.cpp b/source/module_psi/wavefunc.cpp
@@ -140,15 +140,15 @@ void wavefunc::wfcinit(psi::Psi<std::complex<double>>* psi_in, ModulePW::PW_Basi
     return;
 }
 
-int wavefunc::get_starting_nw() const
+int wavefunc::get_starting_nw(const int natomwfc) const
 {
     if (PARAM.inp.init_wfc == "file")
     {
         return PARAM.inp.nbands;
     }
     else if (PARAM.inp.init_wfc.substr(0, 6) == "atomic")
     {
-        if (GlobalC::ucell.natomwfc >= PARAM.inp.nbands)
+        if (natomwfc >= PARAM.inp.nbands)
         {
             if (PARAM.inp.test_wf)
             {
@@ -160,11 +160,11 @@ int wavefunc::get_starting_nw() const
             if (PARAM.inp.test_wf)
             {
                 GlobalV::ofs_running << " Start wave functions are atomic + "
-                                     << PARAM.inp.nbands - GlobalC::ucell.natomwfc << " random wave functions."
+                                     << PARAM.inp.nbands - natomwfc << " random wave functions."
                                      << std::endl;
             }
         }
-        return std::max(GlobalC::ucell.natomwfc, PARAM.inp.nbands);
+        return std::max(natomwfc, PARAM.inp.nbands);
     }
     else if (PARAM.inp.init_wfc == "random")
     {
@@ -194,6 +194,8 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,
                         wavefunc* p_wf,
                         const ModuleBase::realArray& tab_at,
                         const int& lmaxkb,
+                        const int natomwfc,
+                        const int lmax_ppwf,
                         hamilt::Hamilt<std::complex<float>, base_device::DEVICE_CPU>* phm_in)
 {
     // TODO float func
@@ -207,6 +209,8 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,
                         wavefunc* p_wf,
                         const ModuleBase::realArray& tab_at,
                         const int& lmaxkb,
+                        const int natomwfc,
+                        const int lmax_ppwf,
                         hamilt::Hamilt<std::complex<double>, base_device::DEVICE_CPU>* phm_in)
 {
     ModuleBase::TITLE("wavefunc", "diago_PAO_in_pw_k2");
@@ -252,7 +256,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,
         }
     }
     else if (PARAM.inp.init_wfc == "random"
-             || (PARAM.inp.init_wfc.substr(0, 6) == "atomic" && GlobalC::ucell.natomwfc == 0))
+             || (PARAM.inp.init_wfc.substr(0, 6) == "atomic" && natomwfc == 0))
     {
         p_wf->random(wvf.get_pointer(), 0, nbands, ik, wfc_basis);
 
@@ -273,7 +277,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,
     }
     else if (PARAM.inp.init_wfc.substr(0, 6) == "atomic")
     {
-        const int starting_nw = p_wf->get_starting_nw();
+        const int starting_nw = p_wf->get_starting_nw(natomwfc);
         if (starting_nw == 0)
         {
             return;
@@ -289,7 +293,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,
 
         p_wf->atomic_wfc(ik,
                          current_nbasis,
-                         GlobalC::ucell.lmax_ppwf,
+                         lmax_ppwf,
                          lmaxkb,
                          wfc_basis,
                          wfcatom,
@@ -298,7 +302,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,
                          PARAM.globalv.dq);
 
         if (PARAM.inp.init_wfc == "atomic+random"
-            && starting_nw == GlobalC::ucell.natomwfc) // added by qianrui 2021-5-16
+            && starting_nw == natomwfc) // added by qianrui 2021-5-16
         {
             p_wf->atomicrandom(wfcatom, 0, starting_nw, ik, wfc_basis);
         }
@@ -307,7 +311,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,
         // If not enough atomic wfc are available, complete
         // with random wfcs
         //====================================================
-        p_wf->random(wfcatom.c, GlobalC::ucell.natomwfc, nbands, ik, wfc_basis);
+        p_wf->random(wfcatom.c, natomwfc, nbands, ik, wfc_basis);
 
         // (7) Diago with cg method.
         // if(GlobalV::DIAGO_TYPE == "cg") xiaohui modify 2013-09-02
@@ -351,6 +355,8 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_GPU* ctx,
                         wavefunc* p_wf,
                         const ModuleBase::realArray& tab_at,
                         const int& lmaxkb,
+                        const int  natomwfc,
+                        const int  lmax_ppwf,
                         hamilt::Hamilt<std::complex<float>, base_device::DEVICE_GPU>* phm_in)
 {
     // TODO float
@@ -364,6 +370,8 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_GPU* ctx,
                         wavefunc* p_wf,
                         const ModuleBase::realArray& tab_at,
                         const int& lmaxkb,
+                        const int natomwfc,
+                        const int lmax_ppwf,
                         hamilt::Hamilt<std::complex<double>, base_device::DEVICE_GPU>* phm_in)
 {
     ModuleBase::TITLE("wavefunc", "diago_PAO_in_pw_k2");
@@ -393,15 +401,15 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_GPU* ctx,
     {
         p_wf->atomic_wfc(ik,
                          current_nbasis,
-                         GlobalC::ucell.lmax_ppwf,
+                         lmax_ppwf,
                          lmaxkb,
                          wfc_basis,
                          wfcatom,
                          tab_at,
                          PARAM.globalv.nqx,
                          PARAM.globalv.dq);
         if (PARAM.inp.init_wfc == "atomic+random"
-            && starting_nw == GlobalC::ucell.natomwfc) // added by qianrui 2021-5-16
+            && starting_nw == natomwfc) // added by qianrui 2021-5-16
         {
             p_wf->atomicrandom(wfcatom, 0, starting_nw, ik, wfc_basis);
         }
@@ -410,7 +418,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_GPU* ctx,
         // If not enough atomic wfc are available, complete
         // with random wfcs
         //====================================================
-        p_wf->random(wfcatom.c, GlobalC::ucell.natomwfc, nbands, ik, wfc_basis);
+        p_wf->random(wfcatom.c, natomwfc, nbands, ik, wfc_basis);
     }
     else if (PARAM.inp.init_wfc == "random")
     {
diff --git a/source/module_psi/wavefunc.h b/source/module_psi/wavefunc.h
@@ -21,7 +21,7 @@ class wavefunc : public WF_atomic
 
     void wfcinit(psi::Psi<std::complex<double>>* psi_in, ModulePW::PW_Basis_K* wfc_basis);
 
-    int get_starting_nw(void) const;
+    int get_starting_nw(const int natomwfc) const;
 
     void init_after_vc(const int nks); // LiuXh 20180515
 };
@@ -57,6 +57,8 @@ void diago_PAO_in_pw_k2(const Device* ctx,
                         wavefunc* p_wf,
                         const ModuleBase::realArray& tab_at,
                         const int& lmaxkb,
+                        const int natomwfc,
+                        const int lmax_ppwf,
                         hamilt::Hamilt<std::complex<FPTYPE>, Device>* phm_in = nullptr);
 } // namespace hamilt
 

Original file line number	Diff line number	Diff line change
`@@ -152,6 +152,7 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,`
`152`	`152`	`psi::Psi<T, Device>* kspw_psi,`
`153`	`153`	`hamilt::Hamilt<T, Device>* p_hamilt,`
`154`	`154`	`const pseudopot_cell_vnl& nlpp,`
	`155`	`+ const UnitCell& ucell,`
`155`	`156`	`std::ofstream& ofs_running,`
`156`	`157`	`const bool is_already_initpsi)`
`157`	`158`	`{`
`@@ -278,6 +279,8 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,`
`278`	`279`	`&this->wf_old,`
`279`	`280`	`nlpp.tab_at,`
`280`	`281`	`nlpp.lmaxkb,`
	`282`	`+ ucell.natomwfc,`
	`283`	`+ ucell.lmax_ppwf,`
`281`	`284`	`p_hamilt);`
`282`	`285`	`}`
`283`	`286`	`}`
`@@ -294,6 +297,8 @@ void PSIInit<T, Device>::initialize_psi(Psi<std::complex<double>>* psi,`
`294`	`297`	`&this->wf_old,`
`295`	`298`	`nlpp.tab_at,`
`296`	`299`	`nlpp.lmaxkb,`
	`300`	`+ ucell.natomwfc,`
	`301`	`+ ucell.lmax_ppwf,`
`297`	`302`	`p_hamilt);`
`298`	`303`	`}`
`299`	`304`	`}`
Original file line number	Diff line number	Diff line change
`@@ -140,15 +140,15 @@ void wavefunc::wfcinit(psi::Psi<std::complex<double>>* psi_in, ModulePW::PW_Basi`
`140`	`140`	`return;`
`141`	`141`	`}`
`142`	`142`
`143`		`-int wavefunc::get_starting_nw() const`
	`143`	`+int wavefunc::get_starting_nw(const int natomwfc) const`
`144`	`144`	`{`
`145`	`145`	`if (PARAM.inp.init_wfc == "file")`
`146`	`146`	`{`
`147`	`147`	`return PARAM.inp.nbands;`
`148`	`148`	`}`
`149`	`149`	`else if (PARAM.inp.init_wfc.substr(0, 6) == "atomic")`
`150`	`150`	`{`
`151`		`- if (GlobalC::ucell.natomwfc >= PARAM.inp.nbands)`
	`151`	`+ if (natomwfc >= PARAM.inp.nbands)`
`152`	`152`	`{`
`153`	`153`	`if (PARAM.inp.test_wf)`
`154`	`154`	`{`
`@@ -160,11 +160,11 @@ int wavefunc::get_starting_nw() const`
`160`	`160`	`if (PARAM.inp.test_wf)`
`161`	`161`	`{`
`162`	`162`	`GlobalV::ofs_running << " Start wave functions are atomic + "`
`163`		`- << PARAM.inp.nbands - GlobalC::ucell.natomwfc << " random wave functions."`
	`163`	`+ << PARAM.inp.nbands - natomwfc << " random wave functions."`
`164`	`164`	`<< std::endl;`
`165`	`165`	`}`
`166`	`166`	`}`
`167`		`- return std::max(GlobalC::ucell.natomwfc, PARAM.inp.nbands);`
	`167`	`+ return std::max(natomwfc, PARAM.inp.nbands);`
`168`	`168`	`}`
`169`	`169`	`else if (PARAM.inp.init_wfc == "random")`
`170`	`170`	`{`
`@@ -194,6 +194,8 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,`
`194`	`194`	`wavefunc* p_wf,`
`195`	`195`	`const ModuleBase::realArray& tab_at,`
`196`	`196`	`const int& lmaxkb,`
	`197`	`+ const int natomwfc,`
	`198`	`+ const int lmax_ppwf,`
`197`	`199`	`hamilt::Hamilt<std::complex<float>, base_device::DEVICE_CPU>* phm_in)`
`198`	`200`	`{`
`199`	`201`	`// TODO float func`
`@@ -207,6 +209,8 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,`
`207`	`209`	`wavefunc* p_wf,`
`208`	`210`	`const ModuleBase::realArray& tab_at,`
`209`	`211`	`const int& lmaxkb,`
	`212`	`+ const int natomwfc,`
	`213`	`+ const int lmax_ppwf,`
`210`	`214`	`hamilt::Hamilt<std::complex<double>, base_device::DEVICE_CPU>* phm_in)`
`211`	`215`	`{`
`212`	`216`	`ModuleBase::TITLE("wavefunc", "diago_PAO_in_pw_k2");`
`@@ -252,7 +256,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,`
`252`	`256`	`}`
`253`	`257`	`}`
`254`	`258`	`else if (PARAM.inp.init_wfc == "random"`
`255`		`- \|\| (PARAM.inp.init_wfc.substr(0, 6) == "atomic" && GlobalC::ucell.natomwfc == 0))`
	`259`	`+ \|\| (PARAM.inp.init_wfc.substr(0, 6) == "atomic" && natomwfc == 0))`
`256`	`260`	`{`
`257`	`261`	`p_wf->random(wvf.get_pointer(), 0, nbands, ik, wfc_basis);`
`258`	`262`
`@@ -273,7 +277,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,`
`273`	`277`	`}`
`274`	`278`	`else if (PARAM.inp.init_wfc.substr(0, 6) == "atomic")`
`275`	`279`	`{`
`276`		`- const int starting_nw = p_wf->get_starting_nw();`
	`280`	`+ const int starting_nw = p_wf->get_starting_nw(natomwfc);`
`277`	`281`	`if (starting_nw == 0)`
`278`	`282`	`{`
`279`	`283`	`return;`
`@@ -289,7 +293,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,`
`289`	`293`
`290`	`294`	`p_wf->atomic_wfc(ik,`
`291`	`295`	`current_nbasis,`
`292`		`- GlobalC::ucell.lmax_ppwf,`
	`296`	`+ lmax_ppwf,`
`293`	`297`	`lmaxkb,`
`294`	`298`	`wfc_basis,`
`295`	`299`	`wfcatom,`
`@@ -298,7 +302,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,`
`298`	`302`	`PARAM.globalv.dq);`
`299`	`303`
`300`	`304`	`if (PARAM.inp.init_wfc == "atomic+random"`
`301`		`- && starting_nw == GlobalC::ucell.natomwfc) // added by qianrui 2021-5-16`
	`305`	`+ && starting_nw == natomwfc) // added by qianrui 2021-5-16`
`302`	`306`	`{`
`303`	`307`	`p_wf->atomicrandom(wfcatom, 0, starting_nw, ik, wfc_basis);`
`304`	`308`	`}`
`@@ -307,7 +311,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_CPU* ctx,`
`307`	`311`	`// If not enough atomic wfc are available, complete`
`308`	`312`	`// with random wfcs`
`309`	`313`	`//====================================================`
`310`		`- p_wf->random(wfcatom.c, GlobalC::ucell.natomwfc, nbands, ik, wfc_basis);`
	`314`	`+ p_wf->random(wfcatom.c, natomwfc, nbands, ik, wfc_basis);`
`311`	`315`
`312`	`316`	`// (7) Diago with cg method.`
`313`	`317`	`// if(GlobalV::DIAGO_TYPE == "cg") xiaohui modify 2013-09-02`
`@@ -351,6 +355,8 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_GPU* ctx,`
`351`	`355`	`wavefunc* p_wf,`
`352`	`356`	`const ModuleBase::realArray& tab_at,`
`353`	`357`	`const int& lmaxkb,`
	`358`	`+ const int natomwfc,`
	`359`	`+ const int lmax_ppwf,`
`354`	`360`	`hamilt::Hamilt<std::complex<float>, base_device::DEVICE_GPU>* phm_in)`
`355`	`361`	`{`
`356`	`362`	`// TODO float`
`@@ -364,6 +370,8 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_GPU* ctx,`
`364`	`370`	`wavefunc* p_wf,`
`365`	`371`	`const ModuleBase::realArray& tab_at,`
`366`	`372`	`const int& lmaxkb,`
	`373`	`+ const int natomwfc,`
	`374`	`+ const int lmax_ppwf,`
`367`	`375`	`hamilt::Hamilt<std::complex<double>, base_device::DEVICE_GPU>* phm_in)`
`368`	`376`	`{`
`369`	`377`	`ModuleBase::TITLE("wavefunc", "diago_PAO_in_pw_k2");`
`@@ -393,15 +401,15 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_GPU* ctx,`
`393`	`401`	`{`
`394`	`402`	`p_wf->atomic_wfc(ik,`
`395`	`403`	`current_nbasis,`
`396`		`- GlobalC::ucell.lmax_ppwf,`
	`404`	`+ lmax_ppwf,`
`397`	`405`	`lmaxkb,`
`398`	`406`	`wfc_basis,`
`399`	`407`	`wfcatom,`
`400`	`408`	`tab_at,`
`401`	`409`	`PARAM.globalv.nqx,`
`402`	`410`	`PARAM.globalv.dq);`
`403`	`411`	`if (PARAM.inp.init_wfc == "atomic+random"`
`404`		`- && starting_nw == GlobalC::ucell.natomwfc) // added by qianrui 2021-5-16`
	`412`	`+ && starting_nw == natomwfc) // added by qianrui 2021-5-16`
`405`	`413`	`{`
`406`	`414`	`p_wf->atomicrandom(wfcatom, 0, starting_nw, ik, wfc_basis);`
`407`	`415`	`}`
`@@ -410,7 +418,7 @@ void diago_PAO_in_pw_k2(const base_device::DEVICE_GPU* ctx,`
`410`	`418`	`// If not enough atomic wfc are available, complete`
`411`	`419`	`// with random wfcs`
`412`	`420`	`//====================================================`
`413`		`- p_wf->random(wfcatom.c, GlobalC::ucell.natomwfc, nbands, ik, wfc_basis);`
	`421`	`+ p_wf->random(wfcatom.c, natomwfc, nbands, ik, wfc_basis);`
`414`	`422`	`}`
`415`	`423`	`else if (PARAM.inp.init_wfc == "random")`
`416`	`424`	`{`