Refactor: Remove obsolete cg_in_lcao code

Author: AsTonyshment

source/source_base/global_function.h

@@ -1,9 +1,9 @@
 #ifndef GLOBAL_FUNCTION_H
 #define GLOBAL_FUNCTION_H
 
-#include "module_external/blas_connector.h"
 #include "glob_fn_each2.h" // Peize Lin add 2016-09-07
 #include "global_variable.h"
+#include "module_external/blas_connector.h"
 #include "tool_check.h" // mohan add 2021-05-08
 #include "tool_quit.h"  // mohan add 2021-05-07
 #include "tool_title.h" // mohan add 2021-05-05
@@ -146,37 +146,34 @@ static void READ_VALUE(std::ifstream& ifs, T& v)
 }
 
 //-------------------------------------------------------------
-//! The `SCAN_BEGIN` function efficiently searches 
-//! text files for specified keywords 
+//! The `SCAN_BEGIN` function efficiently searches
+//! text files for specified keywords
 //-------------------------------------------------------------
-bool SCAN_BEGIN(std::ifstream& ifs, 
-                const std::string& TargetName, 
-                const bool restart = true, 
-                const bool ifwarn = true);
+bool SCAN_BEGIN(std::ifstream& ifs, const std::string& TargetName, const bool restart = true, const bool ifwarn = true);
 
 //-------------------------------------------------------------
-// The `SCAN_LINE_BEGIN` function efficiently searches 
+// The `SCAN_LINE_BEGIN` function efficiently searches
 // text files for specified keywords while ignoring comment
-// lines and whitespace. It skips any line starting with '#' 
+// lines and whitespace. It skips any line starting with '#'
 //-------------------------------------------------------------
-bool SCAN_LINE_BEGIN(std::ifstream& ifs, 
-                const std::string& TargetName, 
-                const bool restart = true, 
-                const bool ifwarn = true);
+bool SCAN_LINE_BEGIN(std::ifstream& ifs, const std::string& TargetName, const bool restart = true, const bool ifwarn = true);
 
 void SCAN_END(std::ifstream& ifs, const std::string& TargetName, const bool ifwarn = true);
 
 template <class T>
 static inline void DCOPY(const T& a, T& b, const int& dim)
 {
-    for (int i = 0; i < dim; ++i) {
+    for (int i = 0; i < dim; ++i)
+    {
         b[i] = a[i];
     }
 }
 
 template <typename T>
-inline void DCOPY(const T* a, T* b, const int& dim) {
-    for (int i = 0; i < dim; ++i) {
+inline void DCOPY(const T* a, T* b, const int& dim)
+{
+    for (int i = 0; i < dim; ++i)
+    {
         b[i] = a[i];
     }
 }
@@ -236,7 +233,7 @@ static inline const T* VECTOR_TO_PTR(const std::valarray<T>& v)
 // Peize Lin add 2016-07-18
 //==========================================================
 template <typename T>
-std::string TO_STRING(const T& t, const int n=20)		// n=20 since LDBL_EPSILON is 1E-16 or 1E-19
+std::string TO_STRING(const T& t, const int n = 20) // n=20 since LDBL_EPSILON is 1E-16 or 1E-19
 {
     std::stringstream newstr;
     newstr << std::setprecision(n) << t;
@@ -255,7 +252,8 @@ template <typename T_map, typename T_key1>
 inline void* MAP_EXIST(T_map& ms, const T_key1& key1)
 {
     auto ms1 = ms.find(key1);
-    if (ms1 == ms.end()) {
+    if (ms1 == ms.end())
+    {
         return nullptr;
     }
     return static_cast<void*>(&ms1->second);
@@ -265,7 +263,8 @@ template <typename T_map, typename T_key1, typename... T_key_tail>
 inline void* MAP_EXIST(T_map& ms, const T_key1& key1, const T_key_tail&... key_tail)
 {
     auto ms1 = ms.find(key1);
-    if (ms1 == ms.end()) {
+    if (ms1 == ms.end())
+    {
         return nullptr;
     }
     return MAP_EXIST(ms1->second, key_tail...);
@@ -275,7 +274,8 @@ template <typename T_map, typename T_key1>
 inline const void* MAP_EXIST(const T_map& ms, const T_key1& key1)
 {
     auto ms1 = ms.find(key1);
-    if (ms1 == ms.end()) {
+    if (ms1 == ms.end())
+    {
         return nullptr;
     }
     return static_cast<const void*>(&ms1->second);
@@ -285,7 +285,8 @@ template <typename T_map, typename T_key1, typename... T_key_tail>
 inline const void* MAP_EXIST(const T_map& ms, const T_key1& key1, const T_key_tail&... key_tail)
 {
     auto ms1 = ms.find(key1);
-    if (ms1 == ms.end()) {
+    if (ms1 == ms.end())
+    {
         return nullptr;
     }
     return MAP_EXIST(ms1->second, key_tail...);
@@ -323,7 +324,8 @@ static inline void DELETE_MUL_PTR(T_element* v)
 template <typename T_element, typename T_N_first, typename... T_N_tail>
 static inline void DELETE_MUL_PTR(T_element* v, const T_N_first N_first, const T_N_tail... N_tail)
 {
-    for (T_N_first i = 0; i < N_first; ++i) {
+    for (T_N_first i = 0; i < N_first; ++i)
+    {
         DELETE_MUL_PTR(v[i], N_tail...);
     }
     delete[] v;
@@ -353,7 +355,8 @@ static inline void FREE_MUL_PTR(T_element* v)
 template <typename T_element, typename T_N_first, typename... T_N_tail>
 static inline void FREE_MUL_PTR(T_element* v, const T_N_first N_first, const T_N_tail... N_tail)
 {
-    for (T_N_first i = 0; i < N_first; ++i) {
+    for (T_N_first i = 0; i < N_first; ++i)
+    {
         FREE_MUL_PTR(v[i], N_tail...);
     }
     free(v);
@@ -371,7 +374,7 @@ T ddot_real(const int& dim, const std::complex<T>* psi_L, const std::complex<T>*
 static inline bool IS_COLUMN_MAJOR_KS_SOLVER(std::string ks_solver)
 {
     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";
+           || ks_solver == "cusolvermp" || ks_solver == "pexsi" || ks_solver == "lapack";
 }
 
 } // namespace GlobalFunc

source/source_estate/elecstate_print.cpp

@@ -1,13 +1,13 @@
 #include "elecstate.h"
+#include "occupy.h"
 #include "source_base/formatter.h"
 #include "source_base/global_variable.h"
 #include "source_base/parallel_common.h"
-#include "source_estate/module_pot/h_hartree_pw.h"
 #include "source_estate/module_pot/efield.h"
 #include "source_estate/module_pot/gatefield.h"
+#include "source_estate/module_pot/h_hartree_pw.h"
 #include "source_hamilt/module_xc/xc_functional.h"
 #include "source_io/module_parameter/parameter.h"
-#include "occupy.h"
 namespace elecstate
 {
 /**
@@ -49,7 +49,6 @@ void print_scf_iterinfo(const std::string& ks_solver,
 {
     std::map<std::string, std::string> iter_header_dict
         = {{"cg", "CG"},
-           {"cg_in_lcao", "CG"},
            {"lapack", "LA"},
            {"genelpa", "GE"},
            {"elpa", "EL"},
@@ -127,10 +126,7 @@ void print_scf_iterinfo(const std::string& ks_solver,
         values = {double(istep), mag[0], mag[1], mag[2], mag[3], etot, ediff, drho[0]};
         break;
     default:
-        titles = {"ITER",
-                  FmtCore::center("ETOT/eV", wener),
-                  FmtCore::center("EDIFF/eV", wener),
-                  FmtCore::center("DRHO", wrho)};
+        titles = {"ITER", FmtCore::center("ETOT/eV", wener), FmtCore::center("EDIFF/eV", wener), FmtCore::center("DRHO", wrho)};
         values = {double(istep), etot, ediff, drho[0]};
         break;
     }
@@ -163,7 +159,6 @@ void print_scf_iterinfo(const std::string& ks_solver,
     std::cout << buf << std::flush;
 }
 
-
 /// @brief print total free energy and other energies
 /// @param ucell: unit cell
 /// @param converged: if converged
@@ -204,10 +199,10 @@ void print_etot(const Magnetism& magnet,
     std::vector<double> energies_Ry;
     std::vector<double> energies_eV;
 
-	if( (iter % PARAM.inp.out_freq_elec == 0) || converged || iter == PARAM.inp.scf_nmax )
-	{
+    if ((iter % PARAM.inp.out_freq_elec == 0) || converged || iter == PARAM.inp.scf_nmax)
+    {
         int n_order = std::max(0, Occupy::gaussian_type);
-      
+
         //! Kohn-Sham functional energy
         titles.push_back("E_KohnSham");
         energies_Ry.push_back(elec.f_en.etot);
@@ -271,11 +266,11 @@ void print_etot(const Magnetism& magnet,
         }
 
         // mohan add 20251108
-		if (PARAM.inp.dft_plus_u)
-		{
+        if (PARAM.inp.dft_plus_u)
+        {
             titles.push_back("E_plusU");
             energies_Ry.push_back(elec.f_en.edftu);
-		}
+        }
 
         //! hybrid functional energy
         titles.push_back("E_exx");
@@ -296,7 +291,7 @@ void print_etot(const Magnetism& magnet,
             titles.push_back("E_efield");
             energies_Ry.push_back(elecstate::Efield::etotefield);
         }
- 
+
         //! gate energy
         if (PARAM.inp.gate_flag)
         {
@@ -354,23 +349,19 @@ void print_etot(const Magnetism& magnet,
         energies_Ry.push_back(elec.bandgap_dw);
     }
     energies_eV.resize(energies_Ry.size());
-    std::transform(energies_Ry.begin(), energies_Ry.end(), energies_eV.begin(), [](double ener) {
-        return ener * ModuleBase::Ry_to_eV;
-    });
+    std::transform(energies_Ry.begin(), energies_Ry.end(), energies_eV.begin(), [](double ener) { return ener * ModuleBase::Ry_to_eV; });
 
     // for each SCF step, we print out energy
     FmtTable table(/*titles=*/{"Energy", "Rydberg", "eV"},
                    /*nrows=*/titles.size(),
-                   /*formats=*/{"%-14s", "%20.10f", "%20.10f"}, 
+                   /*formats=*/{"%-14s", "%20.10f", "%20.10f"},
                    /*indents=*/1,
-                   /*align=*/{/*value*/FmtTable::Align::LEFT, /*title*/FmtTable::Align::CENTER});
+                   /*align=*/{/*value*/ FmtTable::Align::LEFT, /*title*/ FmtTable::Align::CENTER});
     // print out the titles
     table << titles << energies_Ry << energies_eV;
 
     GlobalV::ofs_running << table.str() << std::endl;
 
-
-    
     if (PARAM.inp.out_level == "ie" || PARAM.inp.out_level == "m")
     {
         std::vector<double> mag;
@@ -380,10 +371,7 @@ void print_etot(const Magnetism& magnet,
             mag = {magnet.tot_mag, magnet.abs_mag};
             break;
         case 4:
-            mag = {magnet.tot_mag_nc[0],
-                   magnet.tot_mag_nc[1],
-                   magnet.tot_mag_nc[2],
-                   magnet.abs_mag};
+            mag = {magnet.tot_mag_nc[0], magnet.tot_mag_nc[1], magnet.tot_mag_nc[2], magnet.abs_mag};
             break;
         default:
             mag = {};
@@ -396,9 +384,7 @@ void print_etot(const Magnetism& magnet,
         }
         // Pure SDFT (nbands=0) uses Chebyshev trace (CT) since no H diagonalization is performed.
         // Mixed SDFT (nbands>0) still diagonalizes KS orbitals, so use the actual ks_solver label.
-        const std::string iter_label = (PARAM.inp.esolver_type == "sdft" && PARAM.inp.nbands == 0)
-                                           ? "sdft"
-                                           : PARAM.inp.ks_solver;
+        const std::string iter_label = (PARAM.inp.esolver_type == "sdft" && PARAM.inp.nbands == 0) ? "sdft" : PARAM.inp.ks_solver;
         elecstate::print_scf_iterinfo(iter_label,
                                       iter,
                                       4,
@@ -422,8 +408,7 @@ void print_etot(const Magnetism& magnet,
 void print_format(const std::string& name, const double& value)
 {
     GlobalV::ofs_running << std::setiosflags(std::ios::showpos);
-    GlobalV::ofs_running << " " << std::setw(16) << name << std::setw(30) << value << std::setw(30)
-                         << value * ModuleBase::Ry_to_eV << std::endl;
+    GlobalV::ofs_running << " " << std::setw(16) << name << std::setw(30) << value << std::setw(30) << value * ModuleBase::Ry_to_eV << std::endl;
     GlobalV::ofs_running << std::resetiosflags(std::ios::showpos);
     return;
 }