move kpar into read_input_item

Author: Qianruipku

source/module_base/global_variable.cpp

@@ -18,7 +18,6 @@ namespace GlobalV
 
 int NPROC = 1; ///< global number of process
 int KPAR = 1;  ///< global number of pools
-int KPAR_LCAO = 1; ///< global number of pools for LCAO diagonalization only
 int MY_RANK = 0; ///< global index of process
 int MY_POOL = 0; ///< global index of pool (count in pool)
 int MY_STOGROUP = 0;

source/module_base/global_variable.h

@@ -28,7 +28,6 @@ namespace GlobalV
 // NAME : DCOLOR( color of each group)
 // NAME : GRANK( index of grid world)
 // NAME : GSIZE( number of processors in each grid world)
-// NAME : KPAR_LCAO ( global number of pools for LCAO diagonalization only)
 //========================================================================
 extern int NPROC;
 extern int KPAR;
@@ -44,7 +43,6 @@ extern int DSIZE;
 extern int DCOLOR;
 extern int GRANK;
 extern int GSIZE;
-extern int KPAR_LCAO;
 
 //==========================================================
 // NAME : ofs_running( contain information during runnnig)

source/module_esolver/esolver_ks_lcao.cpp

@@ -241,16 +241,16 @@ void ESolver_KS_LCAO<TK, TR>::before_all_runners(UnitCell& ucell, const Input_pa
     }
 
     // 12) if kpar is not divisible by nks, print a warning
-    if (GlobalV::KPAR_LCAO > 1)
+    if (PARAM.globalv.kpar_lcao > 1)
     {
-        if (this->kv.get_nks() % GlobalV::KPAR_LCAO != 0)
+        if (this->kv.get_nks() % PARAM.globalv.kpar_lcao != 0)
         {
             ModuleBase::WARNING("ESolver_KS_LCAO::before_all_runners", "nks is not divisible by kpar.");
             std::cout << "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
                          "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
                          "%%%%%%%%%%%%%%%%%%%%%%%%%%"
                       << std::endl;
-            std::cout << " Warning: nks (" << this->kv.get_nks() << ") is not divisible by kpar (" << GlobalV::KPAR_LCAO
+            std::cout << " Warning: nks (" << this->kv.get_nks() << ") is not divisible by kpar (" << PARAM.globalv.kpar_lcao
                       << ")." << std::endl;
             std::cout << " This may lead to poor load balance. It is strongly suggested to" << std::endl;
             std::cout << " set nks to be divisible by kpar, but if this is really what" << std::endl;

source/module_hsolver/hsolver_lcao.cpp

@@ -47,14 +47,14 @@ void HSolverLCAO<T, Device>::solve(hamilt::Hamilt<T>* pHamilt,
 
     if (this->method != "pexsi")
     {
-        if (GlobalV::KPAR_LCAO > 1
+        if (PARAM.globalv.kpar_lcao > 1
             && (this->method == "genelpa" || this->method == "elpa" || this->method == "scalapack_gvx"))
         {
 #ifdef __MPI
-            this->parakSolve(pHamilt, psi, pes, GlobalV::KPAR_LCAO);
+            this->parakSolve(pHamilt, psi, pes, PARAM.globalv.kpar_lcao);
 #endif
         }
-        else if (GlobalV::KPAR_LCAO == 1)
+        else if (PARAM.globalv.kpar_lcao == 1)
         {
             /// Loop over k points for solve Hamiltonian to eigenpairs(eigenvalues and eigenvectors).
             for (int ik = 0; ik < psi.get_nk(); ++ik)

source/module_io/input_conv.cpp

@@ -171,37 +171,9 @@ void Input_Conv::Convert()
     ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "orbital_dir", PARAM.inp.orbital_dir);
     // GlobalV::global_pseudo_type = PARAM.inp.pseudo_type;
 
-    if (PARAM.inp.calculation == "relax" || PARAM.inp.calculation == "cell-relax")
-    {
-    }
-
 
-    if (PARAM.inp.device  == "gpu" && PARAM.inp.basis_type == "pw")
-    {
-        GlobalV::KPAR = base_device::information::get_device_kpar(PARAM.inp.kpar, PARAM.inp.bndpar);
-    }
-#ifdef __LCAO
-    else if (PARAM.inp.basis_type == "lcao") {
-        /// GlobalV::KPAR_LCAO is used in LCAO diagonalization only
-        GlobalV::KPAR_LCAO = PARAM.inp.kpar;
-        /// all other parts of the code use GlobalV::KPAR = 1
-        GlobalV::KPAR = 1;
-    }
-#endif
-    else
-    {
-        GlobalV::KPAR = PARAM.inp.kpar;
-    }
-    if (PARAM.inp.device  == "cpu" and PARAM.inp.precision == "single")
-    {
-// cpu single precision is not supported while float_fftw lib is not available
-#ifndef __ENABLE_FLOAT_FFTW
-        ModuleBase::WARNING_QUIT(
-            "Input_Conv",
-            "Single precision with cpu is not supported while float_fftw lib is not available; \
-            \n Please recompile with cmake flag \"-DENABLE_FLOAT_FFTW=ON\".\n");
-#endif // __ENABLE_FLOAT_FFTW
-    }
+    GlobalV::KPAR = PARAM.inp.kpar;
+    
 
 
 #ifdef __LCAO

source/module_io/read_input_item_system.cpp

@@ -233,6 +233,19 @@ void ReadInput::item_system()
         item.annotation = "devide all processors into kpar groups and k points "
                           "will be distributed among";
         read_sync_int(input.kpar);
+        item.reset_value = [](const Input_Item& item, Parameter& para) {
+            if (para.inp.device  == "gpu" && para.inp.basis_type == "pw")
+            {
+                para.input.kpar = base_device::information::get_device_kpar(para.inp.kpar, para.inp.bndpar);
+            }
+#ifdef __LCAO
+            else if (para.inp.basis_type == "lcao")
+            {
+                para.sys.kpar_lcao = para.inp.kpar;
+                para.input.kpar = 1;
+            }
+#endif
+        };
         item.check_value = [](const Input_Item& item, const Parameter& para) {
             if (para.input.basis_type == "lcao" && para.input.kpar > 1)
             {
@@ -796,6 +809,17 @@ void ReadInput::item_system()
                 const std::string warningstr = nofound_str(avail_list, "precision");
                 ModuleBase::WARNING_QUIT("ReadInput", warningstr);
             }
+
+            // cpu single precision is not supported while float_fftw lib is not available
+            if (para.inp.device == "cpu" && para.inp.precision == "single")
+            {
+#ifndef __ENABLE_FLOAT_FFTW
+                ModuleBase::WARNING_QUIT(
+                    "ReadInput",
+                    "Single precision with cpu is not supported while float_fftw lib is not available; \
+            \n Please recompile with cmake flag \"-DENABLE_FLOAT_FFTW=ON\".\n");
+#endif
+            }
         };
         this->add_item(item);
     }

source/module_io/read_set_globalv.cpp

@@ -127,5 +127,6 @@ void ReadInput::set_globalv_bcast()
     add_double_bcast(sys.dq);
     add_int_bcast(sys.nqx);
     add_int_bcast(sys.nqxq);
+    add_int_bcast(sys.kpar_lcao);
 }
 } // namespace ModuleIO

source/module_parameter/system_parameter.h

@@ -53,5 +53,6 @@ struct System_para
     bool double_grid = false;               ///< true if "ndx,ndy,ndz" is larger than "nx,ny,nz"
     double uramping = -10.0 / 13.6;         /// U-Ramping method (Ry)
     std::vector<double> hubbard_u = {};     ///< Hubbard Coulomb interaction parameter U (Ry)
+    int kpar_lcao = 1;                      ///< global number of pools for LCAO diagonalization only
 };
 #endif