Merge branch 'develop' of https://github.com/sunliang98/abacus-develop into zero_atom

Author: sunliang98

docs/quick_start/easy_install.md

@@ -1,6 +1,17 @@
 # Easy Installation
 
-This guide helps you install ABACUS with basic features. **For DeePKS, DeePMD and Libxc support, or building with `make`, please refer to [the advanced installation guide](../advanced/install.md)** after going through this page. We recommend building ABACUS with `cmake` to avoid dependency issues. We recommend compiling ABACUS(and possibly its requirements) from the source code using the latest compiler for the best performace. You can also deploy ABACUS **without building** by [Docker](#container-deployment) or [conda](#install-by-conda). Please note that ABACUS only supports Linux; for Windows users, please consider using [WSL](https://learn.microsoft.com/en-us/windows/wsl/) or docker.
+This guide helps you install ABACUS with basic features. **For DeePKS, DeePMD and Libxc support, or building with `make`, please refer to [the advanced installation guide](../advanced/install.md)** after going through this page. We recommend building ABACUS with `cmake` to avoid dependency issues. We recommend compiling ABACUS(and possibly its requirements) from the source code using the latest compiler for the best performace. You can try [toolchain](#install-requirements-by-toolchain) to install ABACUS and dependencies in a source-code compilation way with convience. You can also deploy ABACUS **without building** by [Docker](#container-deployment) or [conda](#install-by-conda). Please note that ABACUS only supports Linux; for Windows users, please consider using [WSL](https://learn.microsoft.com/en-us/windows/wsl/) or docker.
+
+## Get ABACUS source code
+
+ABACUS source code can be obtained via one of the following choices:
+
+- Clone the whole repo with git: `git clone https://github.com/deepmodeling/abacus-develop.git`
+- Clone the minimum required part of repo: `git clone https://github.com/deepmodeling/abacus-develop.git --depth=1`
+- Download the latest source code without git: `wget https://github.com/deepmodeling/abacus-develop/archive/refs/heads/develop.zip`
+- Get the source code of a stable version [here](https://github.com/deepmodeling/abacus-develop/releases)
+- If you have connection issues accessing GitHub, please try out our official [Gitee repo](https://gitee.com/deepmodeling/abacus-develop/): e.g. `git clone https://gitee.com/deepmodeling/abacus-develop.git`. This Gitee repo is updated synchronously with GitHub.
+
 
 ## Prerequisites
 
@@ -43,32 +54,22 @@ Please refer to our [guide](https://github.com/deepmodeling/abacus-develop/wiki/
 
 We offer a set of [toolchain](https://github.com/deepmodeling/abacus-develop/tree/develop/toolchain)
 scripts to compile and install all the requirements
-automatically and suitable for machine characteristic in an online or offline way.
-The toolchain can be downloaded with ABACUS repo, which is easily used and can
-have a convenient installation under HPC environment in both `GNU` or `Intel-oneAPI` toolchain.
-Sometimes, ABACUS by toolchain installation may have highly efficient performance.
-A Tutorial for using this toolchain can be accessed in [bohrium-notebook](https://nb.bohrium.dp.tech/detail/5215742477)
-
-> Notice: the toolchain is under development, please let me know if you encounter any problem in using this toolchain.
+automatically and suitable for machine characteristic in an online or offline way. 
+The toolchain can be downloaded with ABACUS repo, and users can easily compile the requirements by running *toolchain_[gnu,intel].sh* and ABACUS itself by running *build_abacus_[gnu,intel].sh* script in the toolchain directory in both `GNU` and `Intel-oneAPI` toolchain.
+Sometimes, ABACUS by toolchain installation may have better efficient performance due to the suitable compiled dependencies.
 
+Users should read the README in toolchain directory for most of the information before use, and a tutorial for using this toolchain can be accessed in [bohrium-notebook](https://nb.bohrium.dp.tech/detail/5215742477) as reference.
 
-## Get ABACUS source code
-
-Of course a copy of ABACUS source code is required, which can be obtained via one of the following choices:
+> Notice: the toolchain is under development, please let we know if you encounter any problem in using this toolchain by raising issue or contacting us.
 
-- Clone the whole repo with git: `git clone https://github.com/deepmodeling/abacus-develop.git`
-- Clone the minimum required part of repo: `git clone https://github.com/deepmodeling/abacus-develop.git --depth=1`
-- Download the latest source code without git: `wget https://github.com/deepmodeling/abacus-develop/archive/refs/heads/develop.zip`
-- Get the source code of a stable version [here](https://github.com/deepmodeling/abacus-develop/releases)
-- If you have connection issues accessing GitHub, please try out our official [Gitee repo](https://gitee.com/deepmodeling/abacus-develop/): e.g. `git clone https://gitee.com/deepmodeling/abacus-develop.git`
 
-### Update to latest release
+## Update to latest release by git
 
 Please check the [release page](https://github.com/deepmodeling/abacus-develop/releases) for the release note of a new version.
 
 It is OK to download the new source code from beginning following the previous step.
 
-To update your cloned git repo in-place:
+You can update your cloned git repo (from Github or Gitee) in-place with the following commands:
 
 ```bash
 git remote -v
@@ -78,7 +79,7 @@ git remote -v
 
 # Replace "origin" with "upstream" or the remote name corresponding to deepmodeling/abacus-develop if necessary
 git fetch origin
-git checkout v3.2.0 # Replace the tag with the latest version
+git checkout v3.8.4 # Replace the tag with the latest version
 git describe --tags # Verify if the tag has been successfully checked out
 ```
 
@@ -158,6 +159,12 @@ If ABACUS is installed into a custom directory using `CMAKE_INSTALL_PREFIX`, ple
 export PATH=/my-install-dir/:$PATH
 ```
 
+If ABACUS is installed by toolchain, there will be an environment script in the toolchain directory named as *abacus_env.sh*. You can source it to set the environment variables.
+
+```bash
+source /path/to/abacus/toolchain/abacus_env.sh
+```
+
 Please set OpenMP threads by setting environment variable:
 
 ```bash

python/pyabacus/src/hsolver/py_diago_cg.hpp

@@ -114,13 +114,13 @@ class PyDiagoCG
         );
     }
 
-    void diag(
-        std::function<py::array_t<std::complex<double>>(py::array_t<std::complex<double>>)> mm_op,
-        int diag_ndim,
-        double tol,
-        bool need_subspace,
-        bool scf_type,
-        int nproc_in_pool = 1
+    void diag(std::function<py::array_t<std::complex<double>>(py::array_t<std::complex<double>>)> mm_op,
+              int diag_ndim,
+              double tol,
+              const std::vector<double>& diag_ethr,
+              bool need_subspace,
+              bool scf_type,
+              int nproc_in_pool = 1
     ) {
         const std::string basis_type = "pw";
         const std::string calculation = scf_type ? "scf" : "nscf";
@@ -171,7 +171,7 @@ class PyDiagoCG
             nproc_in_pool
         );
 
-        cg->diag(hpsi_func, spsi_func, *psi, *eig, *prec);
+        cg->diag(hpsi_func, spsi_func, *psi, *eig, diag_ethr, *prec);
     }
 
 private:

python/pyabacus/src/hsolver/py_hsolver.cpp

@@ -158,7 +158,9 @@ void bind_hsolver(py::module& m)
             for invoking this class is a function defined in _hsolver.py, 
             which uses this class to perform the calculations.
         )pbdoc")
-        .def("diag", &py_hsolver::PyDiagoCG::diag, R"pbdoc(
+        .def("diag",
+             &py_hsolver::PyDiagoCG::diag,
+             R"pbdoc(
             Diagonalize the linear operator using the Conjugate Gradient Method.
 
             Parameters
@@ -179,6 +181,7 @@ void bind_hsolver(py::module& m)
         "mm_op"_a,
         "max_iter"_a,
         "tol"_a,
+        "diag_ethr"_a,  
         "need_subspace"_a,
         "scf_type"_a,
         "nproc_in_pool"_a)

python/pyabacus/src/pyabacus/hsolver/_hsolver.py

@@ -195,6 +195,7 @@ def cg(
     precondition: NDArray[np.float64],
     tol: float = 1e-2,
     max_iter: int = 1000,
+    diag_ethr: Union[List[float], None] = None,
     need_subspace: bool = False,
     scf_type: bool = False,
     nproc_in_pool: int = 1
@@ -244,6 +245,9 @@ def cg(
         if init_v.ndim == 2:
             init_v = init_v.T
         init_v = init_v.flatten().astype(np.complex128, order='C')
+
+    if diag_ethr is None:
+        diag_ethr = [tol] * num_eigs
 
     _diago_obj_cg = diago_cg(dim, num_eigs)
     _diago_obj_cg.set_psi(init_v)
@@ -255,6 +259,7 @@ def cg(
         mvv_op,
         max_iter, 
         tol,
+        diag_ethr,
         need_subspace,
         scf_type,
         nproc_in_pool

source/module_esolver/esolver_ks_lcao.cpp

@@ -1224,7 +1224,7 @@ void ESolver_KS_LCAO<TK, TR>::after_scf(UnitCell& ucell, const int istep)
                                              PARAM.inp.out_wannier_wvfn_formatted,
                                              PARAM.inp.nnkpfile,
                                              PARAM.inp.wannier_spin);
-
+            myWannier.set_tpiba_omega(ucell.tpiba, ucell.omega);
             myWannier.calculate(ucell,
                                 this->pelec->ekb, 
                                 this->pw_wfc, 

source/module_hsolver/diago_cg.cpp

@@ -54,7 +54,10 @@ DiagoCG<T, Device>::~DiagoCG()
 }
 
 template <typename T, typename Device>
-void DiagoCG<T, Device>::diag_mock(const ct::Tensor& prec_in, ct::Tensor& psi, ct::Tensor& eigen)
+void DiagoCG<T, Device>::diag_mock(const ct::Tensor& prec_in,
+                                   ct::Tensor& psi,
+                                   ct::Tensor& eigen,
+                                   const std::vector<double>& ethr_band)
 {
     ModuleBase::TITLE("DiagoCG", "diag_once");
     ModuleBase::timer::tick("DiagoCG", "diag_once");
@@ -153,6 +156,7 @@ void DiagoCG<T, Device>::diag_mock(const ct::Tensor& prec_in, ct::Tensor& psi, c
             converged = this->update_psi(pphi,
                                          cg,
                                          scg, // const Tensor&
+                                         ethr_band[m],
                                          cg_norm,
                                          theta,
                                          eigen_pack[m], // Real&
@@ -392,6 +396,7 @@ template <typename T, typename Device>
 bool DiagoCG<T, Device>::update_psi(const ct::Tensor& pphi,
                                     const ct::Tensor& cg,
                                     const ct::Tensor& scg,
+                                    const double& ethreshold,
                                     Real& cg_norm,
                                     Real& theta,
                                     Real& eigen,
@@ -441,7 +446,7 @@ bool DiagoCG<T, Device>::update_psi(const ct::Tensor& pphi,
                                                            cg.data<T>(),
                                                            sint_norm);
 
-    if (std::abs(eigen - e0) < pw_diag_thr_)
+    if (std::abs(eigen - e0) < ethreshold)
     {
         // ModuleBase::timer::tick("DiagoCG","update");
         return true;
@@ -582,6 +587,7 @@ void DiagoCG<T, Device>::diag(const Func& hpsi_func,
                               const Func& spsi_func,
                               ct::Tensor& psi,
                               ct::Tensor& eigen,
+                              const std::vector<double>& ethr_band,
                               const ct::Tensor& prec)
 {
     /// record the times of trying iterative diagonalization
@@ -603,7 +609,7 @@ void DiagoCG<T, Device>::diag(const Func& hpsi_func,
 
         ++ntry;
         avg_iter_ += 1.0;
-        this->diag_mock(prec, psi_temp, eigen);
+        this->diag_mock(prec, psi_temp, eigen, ethr_band);
     } while (this->test_exit_cond(ntry, this->notconv_));
 
     if (this->notconv_ > std::max(5, this->n_band_ / 4))

source/module_hsolver/diago_cg.h

@@ -40,7 +40,12 @@ class DiagoCG final
     // virtual void init(){};
     // refactor hpsi_info
     // this is the diag() function for CG method
-    void diag(const Func& hpsi_func, const Func& spsi_func, ct::Tensor& psi, ct::Tensor& eigen, const ct::Tensor& prec = {});
+    void diag(const Func& hpsi_func,
+              const Func& spsi_func,
+              ct::Tensor& psi,
+              ct::Tensor& eigen,
+              const std::vector<double>& ethr_band,
+              const ct::Tensor& prec = {});
 
   private:
     Device * ctx_ = {};
@@ -103,6 +108,7 @@ class DiagoCG final
         const ct::Tensor& pphi,
         const ct::Tensor& cg,
         const ct::Tensor& scg,
+        const double& ethreshold,
         Real &cg_norm, 
         Real &theta, 
         Real &eigen,
@@ -113,7 +119,10 @@ class DiagoCG final
     void schmit_orth(const int& m, const ct::Tensor& psi, const ct::Tensor& sphi, ct::Tensor& phi_m);
 
     // used in diag() for template replace Hamilt with Hamilt_PW
-    void diag_mock(const ct::Tensor& prec, ct::Tensor& psi, ct::Tensor& eigen);
+    void diag_mock(const ct::Tensor& prec,
+                   ct::Tensor& psi,
+                   ct::Tensor& eigen,
+                   const std::vector<double>& ethr_band);
 
     bool test_exit_cond(const int& ntry, const int& notconv) const;
 

source/module_hsolver/hsolver_pw.cpp

@@ -279,7 +279,7 @@ void HSolverPW<T, Device>::solve(hamilt::Hamilt<T, Device>* pHamilt,
     // prepare for the precondition of diagonalization
     std::vector<Real> precondition(psi.get_nbasis(), 0.0);
     std::vector<Real> eigenvalues(this->wfc_basis->nks * psi.get_nbands(), 0.0);
-    ethr_band.resize(psi.get_nbands(), DiagoIterAssist<T, Device>::PW_DIAG_THR);
+    ethr_band.resize(psi.get_nbands(), this->diag_thr);
 
     /// Loop over k points for solve Hamiltonian to charge density
     for (int ik = 0; ik < this->wfc_basis->nks; ++ik)
@@ -467,7 +467,7 @@ void HSolverPW<T, Device>::hamiltSolvePsiK(hamilt::Hamilt<T, Device>* hm,
                                .to_device<ct_Device>()
                                .slice({0}, {psi.get_current_nbas()});
 
-        cg.diag(hpsi_func, spsi_func, psi_tensor, eigen_tensor, prec_tensor);
+        cg.diag(hpsi_func, spsi_func, psi_tensor, eigen_tensor, this->ethr_band, prec_tensor);
         // TODO: Double check tensormap's potential problem
         ct::TensorMap(psi.get_pointer(), psi_tensor, {psi.get_nbands(), psi.get_nbasis()}).sync(psi_tensor);
     }

source/module_hsolver/hsolver_pw.h

@@ -84,12 +84,12 @@ class HSolverPW
     int rank_in_pool = 0;
     int nproc_in_pool = 1;
 
+    std::vector<double> ethr_band;
+
   private:
     /// @brief calculate the threshold for iterative-diagonalization for each band
     void cal_ethr_band(const double& wk, const double* wg, const double& ethr, std::vector<double>& ethrs);
 
-    std::vector<double> ethr_band;
-
 #ifdef USE_PAW
     void paw_func_in_kloop(const int ik,
                            const double tpiba);

source/module_hsolver/hsolver_pw_sdft.cpp

@@ -29,33 +29,11 @@ void HSolverPW_SDFT<T, Device>::solve(const UnitCell& ucell,
     const int nbands = psi.get_nbands();
     const int nks = psi.get_nk();
 
-    //---------------------------------------------------------------------------------------------------------------
-    //---------------------------------for psi init guess!!!!--------------------------------------------------------
-    //---------------------------------------------------------------------------------------------------------------
-    // if (!PARAM.inp.psi_initializer && !this->initialed_psi && this->basis_type == "pw")
-    // {
-    //     for (int ik = 0; ik < nks; ++ik)
-    //     {
-    //         /// update H(k) for each k point
-    //         pHamilt->updateHk(ik);
-
-    //         if (nbands > 0 && GlobalV::MY_STOGROUP == 0)
-    //         {
-    //             /// update psi pointer for each k point
-    //             psi.fix_k(ik);
-
-    //             /// for psi init guess!!!!
-    //             hamilt::diago_PAO_in_pw_k2(this->ctx, ik, psi, this->wfc_basis, this->pwf, pHamilt);
-    //         }
-    //     }
-    // }
-    //---------------------------------------------------------------------------------------------------------------
-    //---------------------------------------------------------------------------------------------------------------
-    //---------------------------------------------------------------------------------------------------------------
-
     // prepare for the precondition of diagonalization
     std::vector<double> precondition(psi.get_nbasis(), 0.0);
 
+    this->ethr_band.resize(psi.get_nbands(), this->diag_thr);
+
     // report if the specified diagonalization method is not supported
     const std::initializer_list<std::string> _methods = {"cg", "dav", "dav_subspace", "bpcg"};
     if (std::find(std::begin(_methods), std::end(_methods), this->method) == std::end(_methods))