Rename assume_orthogonal to assume_S_orthogonal

Author: Cstandardlib

source/source_hsolver/diago_cg.cpp

@@ -592,18 +592,22 @@ void DiagoCG<T, Device>::diag(const Func& hpsi_func,
     ct::Tensor psi_temp = psi.slice({0, 0}, {int(psi.shape().dim_size(0)), int(prec.shape().dim_size(0))});
     do
     {
-        if (ntry > 0) // not the first try, then psi is orthogonalized
+        // subspace diagonalization to get a better starting guess
+        // for cg diagonalization, restart from current psi approximation
+        // Note: if not the first try, then psi is already S-orthogonalized by CG iterations!
+        // Otherwise, if the first try, then psi is not assumed to be S-orthogonalized
+        if (ntry > 0)
         {
             ct::TensorMap psi_map = ct::TensorMap(psi.data(), psi_temp);
-            const bool assume_orthogonal = true;
-            this->subspace_func_(psi_temp, psi_map, assume_orthogonal);
+            const bool assume_S_orthogonal = true;
+            this->subspace_func_(psi_temp, psi_map, assume_S_orthogonal);
             psi_temp.sync(psi_map);
         }
         else if (need_subspace_)
         {
             ct::TensorMap psi_map = ct::TensorMap(psi.data(), psi_temp);
-            const bool assume_orthogonal = false;
-            this->subspace_func_(psi_temp, psi_map, assume_orthogonal);
+            const bool assume_S_orthogonal = false;
+            this->subspace_func_(psi_temp, psi_map, assume_S_orthogonal);
             psi_temp.sync(psi_map);
         }
 

source/source_hsolver/diago_iter_assist.cpp

@@ -24,7 +24,7 @@ void DiagoIterAssist<T, Device>::diagH_subspace(const hamilt::Hamilt<T, Device>*
                                                 Real* en,                           // [out] eigenvalues
                                                 int n_band, // [in] number of bands to be calculated, also number of rows
                                                            // of evc, if set to 0, n_band = nstart, default 0
-                                                const bool is_orthogonal // [in] if true, psi is already orthogonalized
+                                                const bool is_S_orthogonal // [in] if true, psi is already orthogonalized
 )
 {
     ModuleBase::TITLE("DiagoIterAssist", "diag_subspace");
@@ -47,7 +47,7 @@ void DiagoIterAssist<T, Device>::diagH_subspace(const hamilt::Hamilt<T, Device>*
     setmem_complex_op()(hcc, 0, nstart * nstart);
 
     // scc is overlap matrix, only needed when psi is not orthogonal
-    if(!is_orthogonal){
+    if(!is_S_orthogonal){
         resmem_complex_op()(scc, nstart * nstart, "DiagSub::scc");
         setmem_complex_op()(scc, 0, nstart * nstart);
     }
@@ -96,7 +96,7 @@ void DiagoIterAssist<T, Device>::diagH_subspace(const hamilt::Hamilt<T, Device>*
                                          hcc,
                                          nstart);
 
-        if(!is_orthogonal){
+        if(!is_S_orthogonal){
             // Only calculate S_sub if not orthogonal
             T *spsi = temp;
             // do sPsi for all bands
@@ -121,13 +121,13 @@ void DiagoIterAssist<T, Device>::diagH_subspace(const hamilt::Hamilt<T, Device>*
     if (GlobalV::NPROC_IN_POOL > 1)
     {
         Parallel_Reduce::reduce_pool(hcc, nstart * nstart);
-        if(!is_orthogonal){
+        if(!is_S_orthogonal){
             Parallel_Reduce::reduce_pool(scc, nstart * nstart);
         }
     }
 
     // after generation of H and (optionally) S matrix, diag them
-    if (is_orthogonal) {
+    if (is_S_orthogonal) {
         // Solve standard eigenproblem: H_sub * y = lambda * y
         DiagoIterAssist::diagH_LAPACK_standard(nstart, n_band, hcc, nstart, en, vcc);
     } else {
@@ -160,7 +160,7 @@ void DiagoIterAssist<T, Device>::diagH_subspace(const hamilt::Hamilt<T, Device>*
         delmem_complex_op()(temp);
     }
     delmem_complex_op()(hcc);
-    if(!is_orthogonal){
+    if(!is_S_orthogonal){
         delmem_complex_op()(scc);
     }
     delmem_complex_op()(vcc);

source/source_hsolver/diago_iter_assist.h

@@ -42,14 +42,14 @@ class DiagoIterAssist
      * @param evc     Output container for computed eigenvectors.
      * @param en      Output array for computed eigenvalues.
      * @param n_band  Number of bands (eigenvalues/eigenvectors) to compute. Default is 0 (all).
-     * @param is_orthogonal If true, assumes the input wavefunction is already orthogonalized.
+     * @param is_S_orthogonal If true, assumes the input wavefunction is already orthogonalized.
      */
     static void diagH_subspace(const hamilt::Hamilt<T, Device>* const pHamilt,
                                const psi::Psi<T, Device>& psi,
                                psi::Psi<T, Device>& evc,
                                Real *en,
                                int n_band = 0,
-                               const bool is_orthogonal = false);
+                               const bool is_S_orthogonal = false);
 
     /// @brief use LAPACK to diagonalize the Hamiltonian matrix
     /// @param pHamilt interface to hamiltonian

source/source_hsolver/hsolver_pw.cpp

@@ -249,7 +249,7 @@ void HSolverPW<T, Device>::hamiltSolvePsiK(hamilt::Hamilt<T, Device>* hm,
         // wrap the subspace_func into a lambda function
         // if assume_orthogonal is true, then solve standard eigenproblem
         // otherwise, solve generalized eigenproblem
-        auto subspace_func = [hm, cur_nbasis](const ct::Tensor& psi_in, ct::Tensor& psi_out, const bool assume_orthogonal) {
+        auto subspace_func = [hm, cur_nbasis](const ct::Tensor& psi_in, ct::Tensor& psi_out, const bool assume_S_orthogonal) {
             // psi_in should be a 2D tensor:
             // psi_in.shape() = [nbands, nbasis]
             const auto ndim = psi_in.shape().ndim();
@@ -269,7 +269,7 @@ void HSolverPW<T, Device>::hamiltSolvePsiK(hamilt::Hamilt<T, Device>* hm,
                                     ct::DeviceType::CpuDevice,
                                     ct::TensorShape({psi_in.shape().dim_size(0)}));
 
-            DiagoIterAssist<T, Device>::diagH_subspace(hm, psi_in_wrapper, psi_out_wrapper, eigen.data<Real>(), assume_orthogonal);
+            DiagoIterAssist<T, Device>::diagH_subspace(hm, psi_in_wrapper, psi_out_wrapper, eigen.data<Real>(), assume_S_orthogonal);
         };
         DiagoCG<T, Device> cg(this->basis_type,
                               this->calculation_type,