fix UTs

maki49 · maki49 · commit 4cc41f53231f · 2024-11-15T05:00:10.000+08:00
diff --git a/source/module_hsolver/diago_dav_subspace.cpp b/source/module_hsolver/diago_dav_subspace.cpp
@@ -21,7 +21,7 @@ Diago_DavSubspace<T, Device>::Diago_DavSubspace(PreFunc&& precondition_in,
                                                 const int& diag_nmax_in,
                                                 const bool& need_subspace_in,
                                                 const diag_comm_info& diag_comm_in)
-    : precondition(std::forward<PreFunc>(precondition_in)), n_band(nband_in), dim(nbasis_in), nbase_x(nband_in* david_ndim_in),
+    : precondition(precondition_in), n_band(nband_in), dim(nbasis_in), nbase_x(nband_in* david_ndim_in),
     diag_thr(diag_thr_in), iter_nmax(diag_nmax_in), is_subspace(need_subspace_in), diag_comm(diag_comm_in)
 {
     this->device = base_device::get_device_type<Device>(this->ctx);
diff --git a/source/module_hsolver/diago_david.cpp b/source/module_hsolver/diago_david.cpp
@@ -39,7 +39,7 @@ DiagoDavid<T, Device>::DiagoDavid(PreFunc&& precondition_in,
                                   const bool use_paw_in,
                                   const diag_comm_info& diag_comm_in)
     : nband(nband_in), dim(dim_in), nbase_x(david_ndim_in* nband_in), david_ndim(david_ndim_in), use_paw(use_paw_in), diag_comm(diag_comm_in),
-    precondition(std::forward<PreFunc>(precondition_in))
+    precondition(precondition_in)
 {
     this->device = base_device::get_device_type<Device>(this->ctx);
 
diff --git a/source/module_hsolver/precondition_funcs.h b/source/module_hsolver/precondition_funcs.h
@@ -4,6 +4,9 @@
 #include "module_base/module_device/types.h"
 #include "module_base/module_device/memory_op.h"
 #include "module_hsolver/kernels/math_kernel_op.h"
+
+/// @brief Preconditioner Function Library
+/// Users can add other types of operation than the following ones at one's need.
 namespace hsolver
 {
     template <typename T>
@@ -19,10 +22,6 @@ namespace hsolver
     /// @brief Transform vectors
     namespace fvec
     {
-        /// @brief To be called in the iterative eigensolver.
-        /// Users can add other types of operation than the following ones at one's need.
-        /// fixed parameters: object vector, eigenvalue, leading dimension, number of vectors
-
         ///---------------------------------------------------------------------------------------------
         /// type 1: directly divide each vector by the precondition vector
         ///---------------------------------------------------------------------------------------------
@@ -36,7 +35,7 @@ namespace hsolver
                 vector_div_vector_op<T, Device>()({}, dim, ptr_m, ptr_m, pre);
             }
         }
-        /// calling intereface in the eigensolver
+        /// Intereface to be called in the eigensolver
         template <typename T>
         using Div = std::function<void(T*, const size_t&, const size_t&)>;
         // Kernel function full of dependence
@@ -73,17 +72,18 @@ namespace hsolver
                 }
             }
         }
-        /// calling intereface in the eigensolver
+        /// Intereface to be called in the eigensolver
         template <typename T>
         using DivTransMinusEig = std::function<void(T*, const Real<T>*, const size_t&, const size_t&)>;
-        // Kernel function full of dependence
+        /// Kernel function full of dependence
         template <typename T, typename Device = base_device::DEVICE_CPU>
         using DivTransMinusEigKernel = std::function<decltype(div_trans_prevec_minus_eigen<T, Device>)>;
     }
 
     /// @brief A operator-like class of precondition function
     ///     to encapsulate the pre-allocation of memory on different devices before starting the iterative eigensolver.
-    ///     One can pass the operatr() function of this class, or other custom lambdas/functions to eigensolvers.
+    ///     One can use `.get()` interface to get the function to be called by the eigensovler,
+    ///     or pass a custom lambdas/function to replace the one returned by `.get()`.
     template <typename T, typename Device = base_device::DEVICE_CPU, typename Kernel_t = fvec::DivKernel<T, Device>>
     struct PreOP
     {
diff --git a/source/module_hsolver/test/CMakeLists.txt b/source/module_hsolver/test/CMakeLists.txt
@@ -75,11 +75,11 @@ if (ENABLE_MPI)
     SOURCES test_hsolver_pw.cpp ../hsolver_pw.cpp ../hsolver_lcaopw.cpp ../diago_bpcg.cpp ../diago_dav_subspace.cpp ../diag_const_nums.cpp ../diago_iter_assist.cpp
   )
 
-  # AddTest(
-  #   TARGET HSolver_sdft
-  #   LIBS parameter  ${math_libs} psi device base container
-  #   SOURCES test_hsolver_sdft.cpp ../hsolver_pw_sdft.cpp ../hsolver_pw.cpp ../diago_bpcg.cpp ../diago_dav_subspace.cpp ../diag_const_nums.cpp ../diago_iter_assist.cpp
-  # )
+  AddTest(
+    TARGET HSolver_sdft
+    LIBS parameter  ${math_libs} psi device base container
+    SOURCES test_hsolver_sdft.cpp ../hsolver_pw_sdft.cpp ../hsolver_pw.cpp ../diago_bpcg.cpp ../diago_dav_subspace.cpp ../diag_const_nums.cpp ../diago_iter_assist.cpp
+  )
 
   if(ENABLE_LCAO)
     if(USE_ELPA)
diff --git a/source/module_hsolver/test/diago_david_float_test.cpp b/source/module_hsolver/test/diago_david_float_test.cpp
@@ -92,8 +92,9 @@ class DiagoDavPrepare
 
 		const int dim = phi.get_current_nbas() ;
 		const int nband = phi.get_nbands();
-		const int ld_psi =phi.get_nbasis();
-		hsolver::DiagoDavid<std::complex<float>> dav(precondition, nband, dim, order, false, comm_info);
+        const int ld_psi = phi.get_nbasis();
+        const hsolver::PreOP<std::complex<float>> pre_op(precondition, dim);
+        hsolver::DiagoDavid<std::complex<float>> dav(pre_op.get(), nband, dim, order, false, comm_info);
 
 		hsolver::DiagoIterAssist<std::complex<float>>::PW_DIAG_NMAX = maxiter;
 		hsolver::DiagoIterAssist<std::complex<float>>::PW_DIAG_THR = eps;
diff --git a/source/module_hsolver/test/diago_david_real_test.cpp b/source/module_hsolver/test/diago_david_real_test.cpp
@@ -92,7 +92,8 @@ class DiagoDavPrepare
 		const int dim = phi.get_current_nbas();
         const int nband = phi.get_nbands();
         const int ld_psi = phi.get_nbasis();
-        hsolver::DiagoDavid<double> dav(precondition, nband, dim, order, false, comm_info);
+        const hsolver::PreOP<double> pre_op(precondition, dim);
+        hsolver::DiagoDavid<double> dav(pre_op.get(), nband, dim, order, false, comm_info);
 
         hsolver::DiagoIterAssist<double>::PW_DIAG_NMAX = maxiter;
         hsolver::DiagoIterAssist<double>::PW_DIAG_THR = eps;
diff --git a/source/module_hsolver/test/diago_david_test.cpp b/source/module_hsolver/test/diago_david_test.cpp
@@ -91,8 +91,10 @@ class DiagoDavPrepare
 
 		const int dim = phi.get_current_nbas();
 		const int nband = phi.get_nbands();
-		const int ld_psi = phi.get_nbasis();
-		hsolver::DiagoDavid<std::complex<double>> dav(precondition, nband, dim, order, false, comm_info);
+        const int ld_psi = phi.get_nbasis();
+        const auto pre_func = [&precondition](std::complex<double>* ptr, const int& ld, const int& nvec)->void
+            {  hsolver::fvec::div_prevec(ptr, ld, nvec, precondition); };
+        hsolver::DiagoDavid<std::complex<double>> dav(pre_func, nband, dim, order, false, comm_info);
 
 		hsolver::DiagoIterAssist<std::complex<double>>::PW_DIAG_NMAX = maxiter;
 		hsolver::DiagoIterAssist<std::complex<double>>::PW_DIAG_THR = eps;
diff --git a/source/module_hsolver/test/hsolver_pw_sup.h b/source/module_hsolver/test/hsolver_pw_sup.h
@@ -1,4 +1,5 @@
 #include "module_basis/module_pw/pw_basis_k.h"
+#include "module_hsolver/precondition_funcs.h"
 
 namespace ModulePW {
 
@@ -121,15 +122,15 @@ template class DiagoCG<std::complex<float>, base_device::DEVICE_CPU>;
 template class DiagoCG<std::complex<double>, base_device::DEVICE_CPU>;
 
 template <typename T, typename Device>
-DiagoDavid<T, Device>::DiagoDavid(const Real* precondition_in,
+DiagoDavid<T, Device>::DiagoDavid(PreFunc&& precondition_in,
                                   const int nband_in,
                                   const int dim_in,
                                   const int david_ndim_in,
                                   const bool use_paw_in,
                                   const diag_comm_info& diag_comm_in)
-    : nband(nband_in), dim(dim_in), nbase_x(david_ndim_in * nband_in), david_ndim(david_ndim_in), use_paw(use_paw_in), diag_comm(diag_comm_in) {
+    : nband(nband_in), dim(dim_in), nbase_x(david_ndim_in* nband_in), david_ndim(david_ndim_in), use_paw(use_paw_in), diag_comm(diag_comm_in),
+    precondition(std::forward<PreFunc>(precondition_in)) {
     this->device = base_device::get_device_type<Device>(this->ctx);
-    this->precondition = precondition_in;
 
     test_david = 2;
     // 1: check which function is called and which step is executed

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ Diago_DavSubspace<T, Device>::Diago_DavSubspace(PreFunc&& precondition_in,`
`21`	`21`	`const int& diag_nmax_in,`
`22`	`22`	`const bool& need_subspace_in,`
`23`	`23`	`const diag_comm_info& diag_comm_in)`
`24`		`- : precondition(std::forward<PreFunc>(precondition_in)), n_band(nband_in), dim(nbasis_in), nbase_x(nband_in* david_ndim_in),`
	`24`	`+ : precondition(precondition_in), n_band(nband_in), dim(nbasis_in), nbase_x(nband_in* david_ndim_in),`
`25`	`25`	`diag_thr(diag_thr_in), iter_nmax(diag_nmax_in), is_subspace(need_subspace_in), diag_comm(diag_comm_in)`
`26`	`26`	`{`
`27`	`27`	`this->device = base_device::get_device_type<Device>(this->ctx);`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ DiagoDavid<T, Device>::DiagoDavid(PreFunc&& precondition_in,`
`39`	`39`	`const bool use_paw_in,`
`40`	`40`	`const diag_comm_info& diag_comm_in)`
`41`	`41`	`: nband(nband_in), dim(dim_in), nbase_x(david_ndim_in* nband_in), david_ndim(david_ndim_in), use_paw(use_paw_in), diag_comm(diag_comm_in),`
`42`		`- precondition(std::forward<PreFunc>(precondition_in))`
	`42`	`+ precondition(precondition_in)`
`43`	`43`	`{`
`44`	`44`	`this->device = base_device::get_device_type<Device>(this->ctx);`
`45`	`45`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,9 @@`
`4`	`4`	`#include "module_base/module_device/types.h"`
`5`	`5`	`#include "module_base/module_device/memory_op.h"`
`6`	`6`	`#include "module_hsolver/kernels/math_kernel_op.h"`
	`7`	`+`
	`8`	`+/// @brief Preconditioner Function Library`
	`9`	`+/// Users can add other types of operation than the following ones at one's need.`
`7`	`10`	`namespace hsolver`
`8`	`11`	`{`
`9`	`12`	`template <typename T>`
`@@ -19,10 +22,6 @@ namespace hsolver`
`19`	`22`	`/// @brief Transform vectors`
`20`	`23`	`namespace fvec`
`21`	`24`	`{`
`22`		`- /// @brief To be called in the iterative eigensolver.`
`23`		`- /// Users can add other types of operation than the following ones at one's need.`
`24`		`- /// fixed parameters: object vector, eigenvalue, leading dimension, number of vectors`
`25`		`-`
`26`	`25`	`///---------------------------------------------------------------------------------------------`
`27`	`26`	`/// type 1: directly divide each vector by the precondition vector`
`28`	`27`	`///---------------------------------------------------------------------------------------------`
`@@ -36,7 +35,7 @@ namespace hsolver`
`36`	`35`	`vector_div_vector_op<T, Device>()({}, dim, ptr_m, ptr_m, pre);`
`37`	`36`	`}`
`38`	`37`	`}`
`39`		`- /// calling intereface in the eigensolver`
	`38`	`+ /// Intereface to be called in the eigensolver`
`40`	`39`	`template <typename T>`
`41`	`40`	`using Div = std::function<void(T*, const size_t&, const size_t&)>;`
`42`	`41`	`// Kernel function full of dependence`
`@@ -73,17 +72,18 @@ namespace hsolver`
`73`	`72`	`}`
`74`	`73`	`}`
`75`	`74`	`}`
`76`		`- /// calling intereface in the eigensolver`
	`75`	`+ /// Intereface to be called in the eigensolver`
`77`	`76`	`template <typename T>`
`78`	`77`	`using DivTransMinusEig = std::function<void(T, const Real<T>, const size_t&, const size_t&)>;`
`79`		`- // Kernel function full of dependence`
	`78`	`+ /// Kernel function full of dependence`
`80`	`79`	`template <typename T, typename Device = base_device::DEVICE_CPU>`
`81`	`80`	`using DivTransMinusEigKernel = std::function<decltype(div_trans_prevec_minus_eigen<T, Device>)>;`
`82`	`81`	`}`
`83`	`82`
`84`	`83`	`/// @brief A operator-like class of precondition function`
`85`	`84`	`/// to encapsulate the pre-allocation of memory on different devices before starting the iterative eigensolver.`
`86`		`- /// One can pass the operatr() function of this class, or other custom lambdas/functions to eigensolvers.`
	`85`	+ /// One can use `.get()` interface to get the function to be called by the eigensovler,
	`86`	+ /// or pass a custom lambdas/function to replace the one returned by `.get()`.
`87`	`87`	`template <typename T, typename Device = base_device::DEVICE_CPU, typename Kernel_t = fvec::DivKernel<T, Device>>`
`88`	`88`	`struct PreOP`
`89`	`89`	`{`