Refactor:Use PARAM instead of ks_solver,nb2d,search_radius (#5138)

* delete nb2d

* delete ks_solver in cpp file

* delete ks_solver in test file

* change function in ks_solver

* Modify search_radius

* fix compile bug

* [pre-commit.ci lite] apply automatic fixes

* modify parameter search_radius

* modify the init number

source/module_base/global_function.h

@@ -355,10 +355,10 @@ T ddot_real(const int& dim, const std::complex<T>* psi_L, const std::complex<T>*
 // NAME : IS_COLUMN_MAJOR_KS_SOLVER
 // check ks_solver requires column major or not
 //==========================================================
-static inline bool IS_COLUMN_MAJOR_KS_SOLVER()
+static inline bool IS_COLUMN_MAJOR_KS_SOLVER(std::string ks_solver)
 {
-    return GlobalV::KS_SOLVER == "genelpa" || GlobalV::KS_SOLVER == "elpa" || GlobalV::KS_SOLVER == "scalapack_gvx" || GlobalV::KS_SOLVER == "cusolver"
-           || GlobalV::KS_SOLVER == "cusolvermp" || GlobalV::KS_SOLVER == "cg_in_lcao" || GlobalV::KS_SOLVER == "pexsi" || GlobalV::KS_SOLVER == "lapack";
+    return ks_solver == "genelpa" || ks_solver == "elpa" || ks_solver == "scalapack_gvx" || ks_solver == "cusolver"
+           || ks_solver == "cusolvermp" || ks_solver == "cg_in_lcao" || ks_solver == "pexsi" || ks_solver == "lapack";
 }
 
 } // namespace GlobalFunc

source/module_base/test/global_function_test.cpp

@@ -13,7 +13,7 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include <time.h>
+#include <ctime>
 
 /************************************************
  *  unit test of functions in global_function
@@ -57,7 +57,7 @@
  *   - print out warning info in running.log file
  * - COPYARRAY
  *   - copy complex or double arrays
- * - IS_COLUMN_MAJOR_KS_SOLVER()
+ * - IS_COLUMN_MAJOR_KS_SOLVER(PARAM.input.ks_solver)
  *   - judge whether the KS_SOLVER is column major
  * - VECTOR_TO_PTR
  *   - get a copy of the ptr of a vector
@@ -300,7 +300,8 @@ TEST_F(GlobalFunctionTest, OutV2)
     {
 	tmp_para += "a";
 	length = tmp_para.size()+1;
-	if (length == 32) EXPECT_THAT(str, testing::HasSubstr(tmp_para));
+	if (length == 32) { EXPECT_THAT(str, testing::HasSubstr(tmp_para));
+}
     }
     ifs.close();
 }
@@ -430,8 +431,8 @@ TEST_F(GlobalFunctionTest, MakeDir)
 TEST_F(GlobalFunctionTest, OutTime)
 {
     std::string name = "scf";
-    start = time(NULL);
-    end = time(NULL) + 200;
+    start = time(nullptr);
+    end = time(nullptr) + 200;
     ModuleBase::GlobalFunc::OUT_TIME(name, start, end);
     GlobalV::ofs_warning.close();
     ifs.open("warning.log");
@@ -654,8 +655,8 @@ TEST_F(GlobalFunctionTest, COPYARRAY)
 
 TEST_F(GlobalFunctionTest,IsColumnMajor)
 {
-	GlobalV::KS_SOLVER = "genelpa";
-	EXPECT_TRUE(ModuleBase::GlobalFunc::IS_COLUMN_MAJOR_KS_SOLVER());
+	PARAM.input.ks_solver = "genelpa";
+	EXPECT_TRUE(ModuleBase::GlobalFunc::IS_COLUMN_MAJOR_KS_SOLVER(PARAM.input.ks_solver));
 }
 
 TEST_F(GlobalFunctionTest,Vector2Ptr)

source/module_elecstate/elecstate_getters.cpp

@@ -55,7 +55,7 @@ double get_ucell_tot_magnetization_nc_z()
 
 std::string get_ks_solver_type()
 {
-    return GlobalV::KS_SOLVER;
+    return PARAM.inp.ks_solver;
 }
 
 } // namespace elecstate

source/module_elecstate/elecstate_lcao.cpp

@@ -38,9 +38,9 @@ void ElecStateLCAO<std::complex<double>>::psiToRho(const psi::Psi<std::complex<d
         // now
         //    psi::Psi<std::complex<double>> dm_k_2d();
 
-        if (GlobalV::KS_SOLVER == "genelpa" || GlobalV::KS_SOLVER == "elpa" || GlobalV::KS_SOLVER == "scalapack_gvx" || GlobalV::KS_SOLVER == "lapack"
-            || GlobalV::KS_SOLVER == "cusolver" || GlobalV::KS_SOLVER == "cusolvermp"
-            || GlobalV::KS_SOLVER == "cg_in_lcao") // Peize Lin test 2019-05-15
+        if (PARAM.inp.ks_solver == "genelpa" || PARAM.inp.ks_solver == "elpa" || PARAM.inp.ks_solver == "scalapack_gvx" || PARAM.inp.ks_solver == "lapack"
+            || PARAM.inp.ks_solver == "cusolver" || PARAM.inp.ks_solver == "cusolvermp"
+            || PARAM.inp.ks_solver == "cg_in_lcao") // Peize Lin test 2019-05-15
         {
             elecstate::cal_dm_psi(this->DM->get_paraV_pointer(),
                                   this->wg,
@@ -91,8 +91,8 @@ void ElecStateLCAO<double>::psiToRho(const psi::Psi<double>& psi)
     this->calculate_weights();
     this->calEBand();
 
-    if (GlobalV::KS_SOLVER == "genelpa" || GlobalV::KS_SOLVER == "elpa" || GlobalV::KS_SOLVER == "scalapack_gvx" || GlobalV::KS_SOLVER == "lapack"
-        || GlobalV::KS_SOLVER == "cusolver" || GlobalV::KS_SOLVER == "cusolvermp" || GlobalV::KS_SOLVER == "cg_in_lcao")
+    if (PARAM.inp.ks_solver == "genelpa" || PARAM.inp.ks_solver == "elpa" || PARAM.inp.ks_solver == "scalapack_gvx" || PARAM.inp.ks_solver == "lapack"
+        || PARAM.inp.ks_solver == "cusolver" || PARAM.inp.ks_solver == "cusolvermp" || PARAM.inp.ks_solver == "cg_in_lcao")
     {
         ModuleBase::timer::tick("ElecStateLCAO", "cal_dm_2d");
 

source/module_elecstate/elecstate_lcao_tddft.cpp

@@ -23,8 +23,8 @@ void ElecStateLCAO_TDDFT::psiToRho_td(const psi::Psi<std::complex<double>>& psi)
     // this part for calculating DMK in 2d-block format, not used for charge now
     //    psi::Psi<std::complex<double>> dm_k_2d();
 
-    if (GlobalV::KS_SOLVER == "genelpa" || GlobalV::KS_SOLVER == "scalapack_gvx"
-        || GlobalV::KS_SOLVER == "lapack") // Peize Lin test 2019-05-15
+    if (PARAM.inp.ks_solver == "genelpa" || PARAM.inp.ks_solver == "scalapack_gvx"
+        || PARAM.inp.ks_solver == "lapack") // Peize Lin test 2019-05-15
     {
         elecstate::cal_dm_psi(this->DM->get_paraV_pointer(), this->wg, psi, *(this->DM));
         this->DM->cal_DMR();

source/module_elecstate/module_dm/cal_dm_psi.cpp

@@ -1,5 +1,6 @@
 #include "cal_dm_psi.h"
 
+#include "module_parameter/parameter.h"
 #include "module_base/blas_connector.h"
 #include "module_base/scalapack_connector.h"
 #include "module_base/timer.h"
@@ -123,7 +124,7 @@ void cal_dm_psi(const Parallel_Orbitals* ParaV,
         // C++: dm(iw1,iw2) = wfc(ib,iw1).T * wg_wfc(ib,iw2)
 #ifdef __MPI
 
-        if (GlobalV::KS_SOLVER == "cg_in_lcao")
+        if (PARAM.inp.ks_solver == "cg_in_lcao")
         {
             psiMulPsi(wg_wfc, wfc, dmk_pointer);
         } else 

source/module_esolver/esolver_ks_lcao.cpp

@@ -705,8 +705,8 @@ void ESolver_KS_LCAO<TK, TR>::hamilt2density(int istep, int iter, double ethr)
         this->pelec->f_en.eband = 0.0;
         this->pelec->f_en.demet = 0.0;
 
-        hsolver::HSolverLCAO<TK> hsolver_lcao_obj(&(this->pv), GlobalV::KS_SOLVER);
-        hsolver_lcao_obj.solve(this->p_hamilt, this->psi[0], this->pelec, GlobalV::KS_SOLVER, false);
+        hsolver::HSolverLCAO<TK> hsolver_lcao_obj(&(this->pv), PARAM.inp.ks_solver);
+        hsolver_lcao_obj.solve(this->p_hamilt, this->psi[0], this->pelec, PARAM.inp.ks_solver, false);
 
 
         if (PARAM.inp.out_bandgap)

source/module_esolver/esolver_ks_lcao_tddft.cpp

@@ -168,8 +168,8 @@ void ESolver_KS_LCAO_TDDFT::hamilt2density(const int istep, const int iter, cons
         this->pelec->f_en.demet = 0.0;
         if (this->psi != nullptr)
         {
-            hsolver::HSolverLCAO<std::complex<double>> hsolver_lcao_obj(&this->pv, GlobalV::KS_SOLVER);
-            hsolver_lcao_obj.solve(this->p_hamilt, this->psi[0], this->pelec_td, GlobalV::KS_SOLVER, false);
+            hsolver::HSolverLCAO<std::complex<double>> hsolver_lcao_obj(&this->pv, PARAM.inp.ks_solver);
+            hsolver_lcao_obj.solve(this->p_hamilt, this->psi[0], this->pelec_td, PARAM.inp.ks_solver, false);
         }
     }
     // else

source/module_esolver/esolver_ks_pw.cpp

@@ -141,7 +141,7 @@ void ESolver_KS_PW<T, Device>::before_all_runners(const Input_para& inp, UnitCel
 
     //! 7) prepare some parameters for electronic wave functions initilization
     this->p_wf_init = new psi::WFInit<T, Device>(PARAM.inp.init_wfc,
-                                                 GlobalV::KS_SOLVER,
+                                                 PARAM.inp.ks_solver,
                                                  PARAM.inp.basis_type,
                                                  PARAM.inp.psi_initializer,
                                                  &this->wf,

source/module_esolver/esolver_lj.cpp

@@ -38,7 +38,7 @@ namespace ModuleESolver
             GlobalV::ofs_running,
             grid_neigh,
             ucell,
-            GlobalV::SEARCH_RADIUS,
+            search_radius,
             PARAM.inp.test_atom_input);
 
         double distance=0.0;
@@ -95,7 +95,7 @@ namespace ModuleESolver
             PARAM.inp.search_pbc,
             grid_neigh,
             ucell, 
-            GlobalV::SEARCH_RADIUS,
+            search_radius,
             PARAM.inp.test_atom_input);
 #endif
     }
@@ -200,7 +200,7 @@ namespace ModuleESolver
         }
 
         // set the search radius
-        GlobalV::SEARCH_RADIUS = rcut_max + 0.01;
+        search_radius = rcut_max + 0.01;
     }
 
     void ESolver_LJ::set_c6_c12(const int rule, const std::vector<double> epsilon, const std::vector<double> sigma)

source/module_esolver/esolver_lj.h

@@ -42,6 +42,7 @@ namespace ModuleESolver
         void cal_en_shift(const bool is_shift);
 
         //--------------temporary----------------------------
+        double search_radius=-1.0;
         ModuleBase::matrix lj_rcut;
         ModuleBase::matrix lj_c12;
         ModuleBase::matrix lj_c6;

source/module_esolver/esolver_sdft_pw.cpp

@@ -78,7 +78,7 @@ void ESolver_SDFT_PW::before_all_runners(const Input_para& inp, UnitCell& ucell)
 
     // 6) prepare some parameters for electronic wave functions initilization
     this->p_wf_init = new psi::WFInit<std::complex<double>>(PARAM.inp.init_wfc,
-                                                            GlobalV::KS_SOLVER,
+                                                            PARAM.inp.ks_solver,
                                                             PARAM.inp.basis_type,
                                                             PARAM.inp.psi_initializer,
                                                             &this->wf,

source/module_esolver/lcao_before_scf.cpp

@@ -62,12 +62,12 @@ void ESolver_KS_LCAO<TK, TR>::beforesolver(const int istep)
         {
             nsk = PARAM.inp.nspin;
             ncol = this->pv.ncol_bands;
-            if (GlobalV::KS_SOLVER == "genelpa"
-                || GlobalV::KS_SOLVER == "elpa"
-                || GlobalV::KS_SOLVER == "lapack"
-                || GlobalV::KS_SOLVER == "pexsi"
-                || GlobalV::KS_SOLVER == "cusolver"
-                || GlobalV::KS_SOLVER == "cusolvermp") {
+            if (PARAM.inp.ks_solver == "genelpa"
+                || PARAM.inp.ks_solver == "elpa"
+                || PARAM.inp.ks_solver == "lapack"
+                || PARAM.inp.ks_solver == "pexsi"
+                || PARAM.inp.ks_solver == "cusolver"
+                || PARAM.inp.ks_solver == "cusolvermp") {
                 ncol = this->pv.ncol;
             }
         }
@@ -156,7 +156,7 @@ void ESolver_KS_LCAO<TK, TR>::beforesolver(const int istep)
                    &(this->pv),
                    PARAM.inp.nspin,
                    this->kv,
-                   GlobalV::KS_SOLVER,
+                   PARAM.inp.ks_solver,
                    this->p_hamilt,
                    this->psi,
                    this->pelec);

source/module_esolver/lcao_gets.cpp

@@ -44,7 +44,8 @@ void ESolver_KS_LCAO<std::complex<double>, double>::get_S(void)
 {
     ModuleBase::TITLE("ESolver_KS_LCAO", "get_S");
     // (1) Find adjacent atoms for each atom.
-    GlobalV::SEARCH_RADIUS = atom_arrange::set_sr_NL(GlobalV::ofs_running,
+    double search_radius = -1.0;
+    search_radius = atom_arrange::set_sr_NL(GlobalV::ofs_running,
                                                      PARAM.inp.out_level,
                                                      orb_.get_rcutmax_Phi(),
                                                      GlobalC::ucell.infoNL.get_rcutmax_Beta(),
@@ -54,7 +55,7 @@ void ESolver_KS_LCAO<std::complex<double>, double>::get_S(void)
                          GlobalV::ofs_running,
                          GlobalC::GridD,
                          GlobalC::ucell,
-                         GlobalV::SEARCH_RADIUS,
+                         search_radius,
                          PARAM.inp.test_atom_input);
 
     this->RA.for_2d(this->pv, PARAM.globalv.gamma_only_local, orb_.cutoffs());
@@ -85,7 +86,8 @@ void ESolver_KS_LCAO<std::complex<double>, std::complex<double>>::get_S(void)
 {
     ModuleBase::TITLE("ESolver_KS_LCAO", "get_S");
     // (1) Find adjacent atoms for each atom.
-    GlobalV::SEARCH_RADIUS = atom_arrange::set_sr_NL(GlobalV::ofs_running,
+    double search_radius = -1.0;
+    search_radius = atom_arrange::set_sr_NL(GlobalV::ofs_running,
                                                      PARAM.inp.out_level,
                                                      orb_.get_rcutmax_Phi(),
                                                      GlobalC::ucell.infoNL.get_rcutmax_Beta(),
@@ -95,7 +97,7 @@ void ESolver_KS_LCAO<std::complex<double>, std::complex<double>>::get_S(void)
                          GlobalV::ofs_running,
                          GlobalC::GridD,
                          GlobalC::ucell,
-                         GlobalV::SEARCH_RADIUS,
+                         search_radius,
                          PARAM.inp.test_atom_input);
 
     this->RA.for_2d(this->pv, PARAM.globalv.gamma_only_local, orb_.cutoffs());

source/module_esolver/lcao_nscf.cpp

@@ -52,8 +52,8 @@ void ESolver_KS_LCAO<TK, TR>::nscf() {
     // then when the istep is a variable of scf or nscf,
     // istep becomes istep-1, this should be fixed in future
     int istep = 0;
-    hsolver::HSolverLCAO<TK> hsolver_lcao_obj(&(this->pv), GlobalV::KS_SOLVER);
-    hsolver_lcao_obj.solve(this->p_hamilt, this->psi[0], this->pelec, GlobalV::KS_SOLVER, true);
+    hsolver::HSolverLCAO<TK> hsolver_lcao_obj(&(this->pv), PARAM.inp.ks_solver);
+    hsolver_lcao_obj.solve(this->p_hamilt, this->psi[0], this->pelec, PARAM.inp.ks_solver, true);
 
     time_t time_finish = std::time(nullptr);
     ModuleBase::GlobalFunc::OUT_TIME("cal_bands", time_start, time_finish);

source/module_esolver/lcao_others.cpp

@@ -70,17 +70,12 @@ void ESolver_KS_LCAO<TK, TR>::others(const int istep)
     {
         // test_search_neighbor();
         std::cout << FmtCore::format("\n * * * * * *\n << Start %s.\n", "testing neighbour");
-        if (GlobalV::SEARCH_RADIUS < 0)
-        {
-            std::cout << " SEARCH_RADIUS : " << GlobalV::SEARCH_RADIUS << std::endl;
-            std::cout << " please make sure search_radius > 0" << std::endl;
-        }
-
+        double search_radius = PARAM.inp.search_radius;
         atom_arrange::search(PARAM.inp.search_pbc,
                              GlobalV::ofs_running,
                              GlobalC::GridD,
                              GlobalC::ucell,
-                             GlobalV::SEARCH_RADIUS,
+                             search_radius,
                              PARAM.inp.test_atom_input,
                              true);
         std::cout << FmtCore::format(" >> Finish %s.\n * * * * * *\n", "testing neighbour");

source/module_esolver/set_matrix_grid.cpp

@@ -27,7 +27,8 @@ void ESolver_KS_LCAO<TK, TR>::set_matrix_grid(Record_adj& ra)
     ModuleBase::timer::tick("ESolver_KS_LCAO", "set_matrix_grid");
 
     // (1) Find adjacent atoms for each atom.
-    GlobalV::SEARCH_RADIUS = atom_arrange::set_sr_NL(GlobalV::ofs_running,
+    double search_radius = -1.0;
+    search_radius = atom_arrange::set_sr_NL(GlobalV::ofs_running,
                                                      PARAM.inp.out_level,
                                                      orb_.get_rcutmax_Phi(),
                                                      GlobalC::ucell.infoNL.get_rcutmax_Beta(),
@@ -37,7 +38,7 @@ void ESolver_KS_LCAO<TK, TR>::set_matrix_grid(Record_adj& ra)
                          GlobalV::ofs_running,
                          GlobalC::GridD,
                          GlobalC::ucell,
-                         GlobalV::SEARCH_RADIUS,
+                         search_radius,
                          PARAM.inp.test_atom_input);
 
     // ModuleBase::GlobalFunc::DONE(GlobalV::ofs_running,"SEARCH ADJACENT

source/module_hamilt_lcao/hamilt_lcaodft/LCAO_init_basis.cpp

@@ -24,21 +24,21 @@ void init_basis_lcao(Parallel_Orbitals& pv,
     ModuleBase::TITLE("ESolver_KS_LCAO", "init_basis_lcao");
 
     const int nlocal = GlobalV::NLOCAL;
-
+    int nb2d = PARAM.inp.nb2d;
     // autoset NB2D first
-    if (GlobalV::NB2D == 0)
+    if (nb2d == 0)
     {
         if (nlocal > 0)
         {
-            GlobalV::NB2D = (PARAM.inp.nspin == 4) ? 2 : 1;
+            nb2d = (PARAM.inp.nspin == 4) ? 2 : 1;
         }
         if (nlocal > 500)
         {
-            GlobalV::NB2D = 32;
+            nb2d = 32;
         }
         if (nlocal > 1000)
         {
-            GlobalV::NB2D = 64;
+            nb2d = 64;
         }
     }
 
@@ -75,7 +75,7 @@ void init_basis_lcao(Parallel_Orbitals& pv,
     // storage form of H and S matrices on each processor
     // is determined in 'divide_HS_2d' subroutine
 
-    int try_nb = pv.init(nlocal, nlocal, GlobalV::NB2D, DIAG_WORLD);
+    int try_nb = pv.init(nlocal, nlocal, nb2d, DIAG_WORLD);
     try_nb += pv.set_nloc_wfc_Eij(GlobalV::NBANDS, GlobalV::ofs_running, GlobalV::ofs_warning);
     if (try_nb != 0)
     {

source/module_hamilt_lcao/hamilt_lcaodft/LCAO_set_mat2d.cpp

@@ -1,5 +1,6 @@
 #include "module_hamilt_lcao/hamilt_lcaodft/LCAO_domain.h"
 
+#include "module_parameter/parameter.h"
 namespace LCAO_domain
 {
 
@@ -22,7 +23,7 @@ void set_mat2d(
     const int ic = pv.global2local_col(global_ic);
 
     const long index =
-        ModuleBase::GlobalFunc::IS_COLUMN_MAJOR_KS_SOLVER()
+        ModuleBase::GlobalFunc::IS_COLUMN_MAJOR_KS_SOLVER(PARAM.inp.ks_solver)
         ? ic * static_cast<long>(pv.nrow) + ir
         : ir * static_cast<long>(pv.ncol) + ic;
 

source/module_hamilt_lcao/hamilt_lcaodft/fedm_gamma.cpp

@@ -47,7 +47,7 @@ void Force_LCAO<double>::cal_fedm(
     elecstate::DensityMatrix<double, double> edm(&pv, nspin);
 
 #ifdef __PEXSI
-    if (GlobalV::KS_SOLVER == "pexsi")
+    if (PARAM.inp.ks_solver == "pexsi")
     {
         auto pes = dynamic_cast<const elecstate::ElecStateLCAO<double>*>(pelec);
         for (int ik = 0; ik < nspin; ik++)

source/module_hamilt_lcao/hamilt_lcaodft/operator_lcao/deepks_lcao.cpp

@@ -518,7 +518,7 @@ void hamilt::DeePKS<hamilt::OperatorLCAO<TK, TR>>::contributeHk(int ik)
     // set SK to zero and then calculate SK for each k vector
     ModuleBase::GlobalFunc::ZEROS(h_delta_k, this->hsk->get_size());
 
-    if (ModuleBase::GlobalFunc::IS_COLUMN_MAJOR_KS_SOLVER())
+    if (ModuleBase::GlobalFunc::IS_COLUMN_MAJOR_KS_SOLVER(PARAM.inp.ks_solver))
     {
         const int nrow = this->hsk->get_pv()->get_row_size();
         hamilt::folding_HR(*this->H_V_delta, h_delta_k, this->kvec_d[ik], nrow, 1);

source/module_hamilt_lcao/hamilt_lcaodft/operator_lcao/operator_lcao.cpp

@@ -229,7 +229,7 @@ template <typename TK, typename TR>
 void OperatorLCAO<TK, TR>::contributeHk(int ik) {
     ModuleBase::TITLE("OperatorLCAO", "contributeHk");
     ModuleBase::timer::tick("OperatorLCAO", "contributeHk");
-    if(ModuleBase::GlobalFunc::IS_COLUMN_MAJOR_KS_SOLVER())
+    if(ModuleBase::GlobalFunc::IS_COLUMN_MAJOR_KS_SOLVER(PARAM.inp.ks_solver))
     {
         const int nrow = this->hsk->get_pv()->get_row_size();
         hamilt::folding_HR(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], nrow, 1);