diff --git a/python/pyabacus/src/hsolver/CMakeLists.txt b/python/pyabacus/src/hsolver/CMakeLists.txt
index 7c9f216870..1246b791ec 100644
--- a/python/pyabacus/src/hsolver/CMakeLists.txt
+++ b/python/pyabacus/src/hsolver/CMakeLists.txt
@@ -9,7 +9,7 @@ list(APPEND _diago
     ${HSOLVER_PATH}/diago_pxxxgvx.cpp
 
 
-    ${HSOLVER_PATH}/kernels/dngvd_op.cpp
+    ${HSOLVER_PATH}/kernels/hegvd_op.cpp
     ${HSOLVER_PATH}/kernels/bpcg_kernel_op.cpp
     # dependency
     ${BASE_PATH}/kernels/math_kernel_op.cpp
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index b619f27dc8..a4eaf0b197 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -35,7 +35,7 @@ list(APPEND device_srcs
   source_pw/module_pwdft/kernels/meta_op.cpp
   source_pw/module_stodft/kernels/hpsi_norm_op.cpp
   source_basis/module_pw/kernels/pw_op.cpp
-  source_hsolver/kernels/dngvd_op.cpp
+  source_hsolver/kernels/hegvd_op.cpp
   source_hsolver/kernels/bpcg_kernel_op.cpp
   source_estate/kernels/elecstate_op.cpp
 
@@ -70,7 +70,7 @@ if(USE_CUDA)
     source_pw/module_stodft/kernels/cuda/hpsi_norm_op.cu
     source_pw/module_pwdft/kernels/cuda/onsite_op.cu
     source_basis/module_pw/kernels/cuda/pw_op.cu
-    source_hsolver/kernels/cuda/dngvd_op.cu
+    source_hsolver/kernels/cuda/hegvd_op.cu
     source_hsolver/kernels/cuda/bpcg_kernel_op.cu
     source_estate/kernels/cuda/elecstate_op.cu
 
@@ -101,7 +101,7 @@ if(USE_ROCM)
     source_pw/module_pwdft/kernels/rocm/onsite_op.hip.cu
     source_pw/module_stodft/kernels/rocm/hpsi_norm_op.hip.cu
     source_basis/module_pw/kernels/rocm/pw_op.hip.cu
-    source_hsolver/kernels/rocm/dngvd_op.hip.cu
+    source_hsolver/kernels/rocm/hegvd_op.hip.cu
     source_hsolver/kernels/rocm/bpcg_kernel_op.hip.cu
     source_estate/kernels/rocm/elecstate_op.hip.cu
 
diff --git a/source/Makefile.Objects b/source/Makefile.Objects
index 8d4d9933a1..4ab7dfc651 100644
--- a/source/Makefile.Objects
+++ b/source/Makefile.Objects
@@ -395,7 +395,7 @@ OBJS_HSOLVER=diago_cg.o\
     hsolver_lcaopw.o\
     hsolver_pw_sdft.o\
     diago_iter_assist.o\
-    dngvd_op.o\
+    hegvd_op.o\
     bpcg_kernel_op.o\
     diag_const_nums.o\
     diag_hs_para.o\
diff --git a/source/source_base/module_container/ATen/kernels/cuda/lapack.cu b/source/source_base/module_container/ATen/kernels/cuda/lapack.cu
index 54176dae51..fcdaa7e70a 100644
--- a/source/source_base/module_container/ATen/kernels/cuda/lapack.cu
+++ b/source/source_base/module_container/ATen/kernels/cuda/lapack.cu
@@ -88,7 +88,7 @@ struct lapack_potrf<T, DEVICE_GPU> {
 };
 
 template <typename T>
-struct lapack_dnevd<T, DEVICE_GPU> {
+struct lapack_heevd<T, DEVICE_GPU> {
     using Real = typename GetTypeReal<T>::type;
     void operator()(
         const char& jobz,
@@ -97,12 +97,12 @@ struct lapack_dnevd<T, DEVICE_GPU> {
         const int& dim,
         Real* eigen_val)
     {
-        cuSolverConnector::dnevd(cusolver_handle, jobz, uplo, dim, Mat, dim, eigen_val);
+        cuSolverConnector::heevd(cusolver_handle, jobz, uplo, dim, Mat, dim, eigen_val);
     }
 };
 
 template <typename T>
-struct lapack_dngvd<T, DEVICE_GPU> {
+struct lapack_hegvd<T, DEVICE_GPU> {
     using Real = typename GetTypeReal<T>::type;
     void operator()(
         const int& itype,
@@ -113,7 +113,7 @@ struct lapack_dngvd<T, DEVICE_GPU> {
         const int& dim,
         Real* eigen_val)
     {
-        cuSolverConnector::dngvd(cusolver_handle, itype, jobz, uplo, dim, Mat_A, dim, Mat_B, dim, eigen_val);
+        cuSolverConnector::hegvd(cusolver_handle, itype, jobz, uplo, dim, Mat_A, dim, Mat_B, dim, eigen_val);
     }
 };
 
@@ -175,15 +175,15 @@ template struct lapack_potrf<double, DEVICE_GPU>;
 template struct lapack_potrf<std::complex<float>,  DEVICE_GPU>;
 template struct lapack_potrf<std::complex<double>, DEVICE_GPU>;
 
-template struct lapack_dnevd<float,  DEVICE_GPU>;
-template struct lapack_dnevd<double, DEVICE_GPU>;
-template struct lapack_dnevd<std::complex<float>,  DEVICE_GPU>;
-template struct lapack_dnevd<std::complex<double>, DEVICE_GPU>;
+template struct lapack_heevd<float,  DEVICE_GPU>;
+template struct lapack_heevd<double, DEVICE_GPU>;
+template struct lapack_heevd<std::complex<float>,  DEVICE_GPU>;
+template struct lapack_heevd<std::complex<double>, DEVICE_GPU>;
 
-template struct lapack_dngvd<float,  DEVICE_GPU>;
-template struct lapack_dngvd<double, DEVICE_GPU>;
-template struct lapack_dngvd<std::complex<float>,  DEVICE_GPU>;
-template struct lapack_dngvd<std::complex<double>, DEVICE_GPU>;
+template struct lapack_hegvd<float,  DEVICE_GPU>;
+template struct lapack_hegvd<double, DEVICE_GPU>;
+template struct lapack_hegvd<std::complex<float>,  DEVICE_GPU>;
+template struct lapack_hegvd<std::complex<double>, DEVICE_GPU>;
 
 template struct lapack_getrf<float,  DEVICE_GPU>;
 template struct lapack_getrf<double, DEVICE_GPU>;
diff --git a/source/source_base/module_container/ATen/kernels/lapack.cpp b/source/source_base/module_container/ATen/kernels/lapack.cpp
index 2369306309..21cbc46f96 100644
--- a/source/source_base/module_container/ATen/kernels/lapack.cpp
+++ b/source/source_base/module_container/ATen/kernels/lapack.cpp
@@ -63,7 +63,7 @@ struct lapack_potrf<T, DEVICE_CPU> {
 };
 
 template <typename T>
-struct lapack_dnevd<T, DEVICE_CPU> {
+struct lapack_heevd<T, DEVICE_CPU> {
     using Real = typename GetTypeReal<T>::type;
     void operator()(
         const char& jobz,
@@ -85,15 +85,15 @@ struct lapack_dnevd<T, DEVICE_CPU> {
         Tensor iwork(DataTypeToEnum<int>::value, DeviceType::CpuDevice, {liwork});
         iwork.zero();
 
-        lapackConnector::dnevd(jobz, uplo, dim, Mat, dim, eigen_val,  work.data<T>(), lwork, rwork.data<Real>(), lrwork, iwork.data<int>(), liwork, info);
+        lapackConnector::heevd(jobz, uplo, dim, Mat, dim, eigen_val,  work.data<T>(), lwork, rwork.data<Real>(), lrwork, iwork.data<int>(), liwork, info);
         if (info != 0) {
-            throw std::runtime_error("dnevd failed with info = " + std::to_string(info));
+            throw std::runtime_error("heevd failed with info = " + std::to_string(info));
         }
     }
 };
 
 template <typename T>
-struct lapack_dngvd<T, DEVICE_CPU> {
+struct lapack_hegvd<T, DEVICE_CPU> {
     using Real = typename GetTypeReal<T>::type;
     void operator()(
         const int& itype,
@@ -117,9 +117,9 @@ struct lapack_dngvd<T, DEVICE_CPU> {
         Tensor iwork(DataType::DT_INT, DeviceType::CpuDevice, {liwork});
         iwork.zero();
 
-        lapackConnector::dngvd(itype, jobz, uplo, dim, Mat_A, dim, Mat_B, dim, eigen_val, work.data<T>(), lwork, rwork.data<Real>(), lrwork, iwork.data<int>(), liwork, info);
+        lapackConnector::hegvd(itype, jobz, uplo, dim, Mat_A, dim, Mat_B, dim, eigen_val, work.data<T>(), lwork, rwork.data<Real>(), lrwork, iwork.data<int>(), liwork, info);
         if (info != 0) {
-            throw std::runtime_error("dngvd failed with info = " + std::to_string(info));
+            throw std::runtime_error("hegvd failed with info = " + std::to_string(info));
         }
     }
 };
@@ -194,15 +194,15 @@ template struct lapack_trtri<double, DEVICE_CPU>;
 template struct lapack_trtri<std::complex<float>,  DEVICE_CPU>;
 template struct lapack_trtri<std::complex<double>, DEVICE_CPU>;
 
-template struct lapack_dnevd<float,  DEVICE_CPU>;
-template struct lapack_dnevd<double, DEVICE_CPU>;
-template struct lapack_dnevd<std::complex<float>,  DEVICE_CPU>;
-template struct lapack_dnevd<std::complex<double>, DEVICE_CPU>;
+template struct lapack_heevd<float,  DEVICE_CPU>;
+template struct lapack_heevd<double, DEVICE_CPU>;
+template struct lapack_heevd<std::complex<float>,  DEVICE_CPU>;
+template struct lapack_heevd<std::complex<double>, DEVICE_CPU>;
 
-template struct lapack_dngvd<float,  DEVICE_CPU>;
-template struct lapack_dngvd<double, DEVICE_CPU>;
-template struct lapack_dngvd<std::complex<float>,  DEVICE_CPU>;
-template struct lapack_dngvd<std::complex<double>, DEVICE_CPU>;
+template struct lapack_hegvd<float,  DEVICE_CPU>;
+template struct lapack_hegvd<double, DEVICE_CPU>;
+template struct lapack_hegvd<std::complex<float>,  DEVICE_CPU>;
+template struct lapack_hegvd<std::complex<double>, DEVICE_CPU>;
 
 template struct lapack_getrf<float,  DEVICE_CPU>;
 template struct lapack_getrf<double, DEVICE_CPU>;
diff --git a/source/source_base/module_container/ATen/kernels/lapack.h b/source/source_base/module_container/ATen/kernels/lapack.h
index cf164dec10..dd3243ac60 100644
--- a/source/source_base/module_container/ATen/kernels/lapack.h
+++ b/source/source_base/module_container/ATen/kernels/lapack.h
@@ -41,7 +41,7 @@ struct lapack_potrf {
 
 
 template <typename T, typename Device>
-struct lapack_dnevd {
+struct lapack_heevd {
     using Real = typename GetTypeReal<T>::type;
     void operator()(
         const char& jobz,
@@ -53,7 +53,7 @@ struct lapack_dnevd {
 
 
 template <typename T, typename Device>
-struct lapack_dngvd {
+struct lapack_hegvd {
     using Real = typename GetTypeReal<T>::type;
     void operator()(
         const int& itype,
diff --git a/source/source_base/module_container/ATen/kernels/rocm/lapack.hip.cu b/source/source_base/module_container/ATen/kernels/rocm/lapack.hip.cu
index cc0a77cb4c..64040cb79c 100644
--- a/source/source_base/module_container/ATen/kernels/rocm/lapack.hip.cu
+++ b/source/source_base/module_container/ATen/kernels/rocm/lapack.hip.cu
@@ -94,7 +94,7 @@ struct lapack_potrf<T, DEVICE_GPU> {
 };
 
 template <typename T>
-struct lapack_dnevd<T, DEVICE_GPU> {
+struct lapack_heevd<T, DEVICE_GPU> {
     using Real = typename GetTypeReal<T>::type;
     void operator()(
         const char& jobz,
@@ -103,19 +103,19 @@ struct lapack_dnevd<T, DEVICE_GPU> {
         const int& dim,
         Real* eigen_val)
     {
-        // hipSolverConnector::dnevd(hipsolver_handle, jobz, uplo, dim, Mat, dim, eigen_val);
+        // hipSolverConnector::heevd(hipsolver_handle, jobz, uplo, dim, Mat, dim, eigen_val);
         std::vector<T> H_Mat(dim * dim, static_cast<T>(0.0));
         std::vector<Real> H_eigen_val(dim, static_cast<Real>(0.0));
         hipMemcpy(H_Mat.data(), Mat, sizeof(T) * H_Mat.size(), hipMemcpyDeviceToHost);
         hipMemcpy(H_eigen_val.data(), eigen_val, sizeof(Real) * H_eigen_val.size(), hipMemcpyDeviceToHost);
-        lapack_dnevd<T, DEVICE_CPU>()(jobz, uplo, H_Mat.data(), dim, H_eigen_val.data());
+        lapack_heevd<T, DEVICE_CPU>()(jobz, uplo, H_Mat.data(), dim, H_eigen_val.data());
         hipMemcpy(Mat, H_Mat.data(), sizeof(T) * H_Mat.size(), hipMemcpyHostToDevice);
         hipMemcpy(eigen_val, H_eigen_val.data(), sizeof(Real) * H_eigen_val.size(), hipMemcpyHostToDevice);
     }
 };
 
 template <typename T>
-struct lapack_dngvd<T, DEVICE_GPU> {
+struct lapack_hegvd<T, DEVICE_GPU> {
     using Real = typename GetTypeReal<T>::type;
     void operator()(
         const int& itype,
@@ -126,7 +126,7 @@ struct lapack_dngvd<T, DEVICE_GPU> {
         const int& dim,
         Real* eigen_val)
     {
-        hipSolverConnector::dngvd(hipsolver_handle, itype, jobz, uplo, dim, Mat_A, dim, Mat_B, dim, eigen_val);
+        hipSolverConnector::hegvd(hipsolver_handle, itype, jobz, uplo, dim, Mat_A, dim, Mat_B, dim, eigen_val);
     }
 };
 
@@ -145,15 +145,15 @@ template struct lapack_potrf<double, DEVICE_GPU>;
 template struct lapack_potrf<std::complex<float>,  DEVICE_GPU>;
 template struct lapack_potrf<std::complex<double>, DEVICE_GPU>;
 
-template struct lapack_dnevd<float,  DEVICE_GPU>;
-template struct lapack_dnevd<double, DEVICE_GPU>;
-template struct lapack_dnevd<std::complex<float>,  DEVICE_GPU>;
-template struct lapack_dnevd<std::complex<double>, DEVICE_GPU>;
+template struct lapack_heevd<float,  DEVICE_GPU>;
+template struct lapack_heevd<double, DEVICE_GPU>;
+template struct lapack_heevd<std::complex<float>,  DEVICE_GPU>;
+template struct lapack_heevd<std::complex<double>, DEVICE_GPU>;
 
-template struct lapack_dngvd<float,  DEVICE_GPU>;
-template struct lapack_dngvd<double, DEVICE_GPU>;
-template struct lapack_dngvd<std::complex<float>,  DEVICE_GPU>;
-template struct lapack_dngvd<std::complex<double>, DEVICE_GPU>;
+template struct lapack_hegvd<float,  DEVICE_GPU>;
+template struct lapack_hegvd<double, DEVICE_GPU>;
+template struct lapack_hegvd<std::complex<float>,  DEVICE_GPU>;
+template struct lapack_hegvd<std::complex<double>, DEVICE_GPU>;
 
 } // namespace kernels
 } // namespace container
\ No newline at end of file
diff --git a/source/source_base/module_container/ATen/kernels/test/lapack_test.cpp b/source/source_base/module_container/ATen/kernels/test/lapack_test.cpp
index f9998c018c..9675e979c5 100644
--- a/source/source_base/module_container/ATen/kernels/test/lapack_test.cpp
+++ b/source/source_base/module_container/ATen/kernels/test/lapack_test.cpp
@@ -92,14 +92,14 @@ TYPED_TEST(LapackTest, Potrf) {
     EXPECT_EQ(A, C);
 }
 
-TYPED_TEST(LapackTest, dnevd) {
+TYPED_TEST(LapackTest, heevd) {
     using Type = typename std::tuple_element<0, decltype(TypeParam())>::type;
     using Real = typename GetTypeReal<Type>::type;
     using Device = typename std::tuple_element<1, decltype(TypeParam())>::type;
     
     blas_gemm<Type, Device> gemmCalculator;
     blas_axpy<Type, Device> axpyCalculator;
-    lapack_dnevd<Type, Device> dnevdCalculator;
+    lapack_heevd<Type, Device> heevdCalculator;
 
     const int dim = 3;
     Tensor A = std::move(Tensor({static_cast<Type>(4.0), static_cast<Type>(1.0), static_cast<Type>(1.0),
@@ -121,7 +121,7 @@ TYPED_TEST(LapackTest, dnevd) {
     const Type beta  = static_cast<Type>(0.0);
     // Note all blas and lapack operators within container are column major!
     // For this reason, we should employ 'L' instead of 'U' in the subsequent line.
-    dnevdCalculator('V', 'U', B.data<Type>(), dim, E.data<Real>());
+    heevdCalculator('V', 'U', B.data<Type>(), dim, E.data<Real>());
     
     E = E.to_device<DEVICE_CPU>();
     const Tensor Alpha = std::move(Tensor({
@@ -139,14 +139,14 @@ TYPED_TEST(LapackTest, dnevd) {
 }
 
 
-TYPED_TEST(LapackTest, dngvd) {
+TYPED_TEST(LapackTest, hegvd) {
     using Type = typename std::tuple_element<0, decltype(TypeParam())>::type;
     using Real = typename GetTypeReal<Type>::type;
     using Device = typename std::tuple_element<1, decltype(TypeParam())>::type;
     
     blas_gemm<Type, Device> gemmCalculator;
     blas_axpy<Type, Device> axpyCalculator;
-    lapack_dngvd<Type, Device> dngvdCalculator;
+    lapack_hegvd<Type, Device> hegvdCalculator;
 
     const int dim = 3;
     Tensor A = std::move(Tensor({static_cast<Type>(4.0), static_cast<Type>(1.0), static_cast<Type>(1.0),
@@ -172,7 +172,7 @@ TYPED_TEST(LapackTest, dngvd) {
     const Type beta  = static_cast<Type>(0.0);
     // Note al<l blas and lapack operators within container are column major!
     // For this reason, we should employ 'L' instead of 'U' in the subsequent line.
-    dngvdCalculator(1, 'V', 'U', B.data<Type>(), I.data<Type>(), dim, E.data<Real>());
+    hegvdCalculator(1, 'V', 'U', B.data<Type>(), I.data<Type>(), dim, E.data<Real>());
 
     E = E.to_device<DEVICE_CPU>();
     const Tensor Alpha = std::move(Tensor({
diff --git a/source/source_base/module_container/base/third_party/cusolver.h b/source/source_base/module_container/base/third_party/cusolver.h
index 111b321e26..d65aa5a204 100644
--- a/source/source_base/module_container/base/third_party/cusolver.h
+++ b/source/source_base/module_container/base/third_party/cusolver.h
@@ -142,7 +142,7 @@ void potrf (cusolverDnHandle_t& cusolver_handle, const char& uplo, const int& n,
 
 
 static inline
-void dnevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& uplo, const int& n, float* A, const int& lda, float * W)
+void heevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& uplo, const int& n, float* A, const int& lda, float * W)
 {
     // prepare some values for cusolverDnSsyevd_bufferSize
     int lwork  = 0; 
@@ -162,13 +162,13 @@ void dnevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& u
 
     cudaErrcheck(cudaMemcpy(&h_info, d_info, sizeof(int), cudaMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     cudaErrcheck(cudaFree(d_info));
     cudaErrcheck(cudaFree(d_work));
 }
 static inline
-void dnevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& uplo, const int& n, double* A, const int& lda, double * W)
+void heevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& uplo, const int& n, double* A, const int& lda, double * W)
 {
     // prepare some values for cusolverDnDsyevd_bufferSize
     int lwork  = 0; 
@@ -188,13 +188,13 @@ void dnevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& u
 
     cudaErrcheck(cudaMemcpy(&h_info, d_info, sizeof(int), cudaMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     cudaErrcheck(cudaFree(d_info));
     cudaErrcheck(cudaFree(d_work));
 }
 static inline
-void dnevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& uplo, const int& n, std::complex<float>* A, const int& lda, float * W)
+void heevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& uplo, const int& n, std::complex<float>* A, const int& lda, float * W)
 {
     // prepare some values for cusolverDnCheevd_bufferSize
     int lwork  = 0; 
@@ -214,13 +214,13 @@ void dnevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& u
 
     cudaErrcheck(cudaMemcpy(&h_info, d_info, sizeof(int), cudaMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     cudaErrcheck(cudaFree(d_info));
     cudaErrcheck(cudaFree(d_work));
 }
 static inline
-void dnevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& uplo, const int& n, std::complex<double>* A, const int& lda, double* W)
+void heevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& uplo, const int& n, std::complex<double>* A, const int& lda, double* W)
 {
     // prepare some values for cusolverDnZheevd_bufferSize
     int lwork  = 0; 
@@ -240,14 +240,14 @@ void dnevd (cusolverDnHandle_t& cusolver_handle, const char& jobz, const char& u
 
     cudaErrcheck(cudaMemcpy(&h_info, d_info, sizeof(int), cudaMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     cudaErrcheck(cudaFree(d_info));
     cudaErrcheck(cudaFree(d_work));
 }
 
 static inline
-void dngvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, float* A, const int& lda, float* B, const int& ldb, float * W)
+void hegvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, float* A, const int& lda, float* B, const int& ldb, float * W)
 {
     // prepare some values for cusolverDnSsygvd_bufferSize
     int lwork  = 0; 
@@ -267,13 +267,13 @@ void dngvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& j
 
     cudaErrcheck(cudaMemcpy(&h_info, d_info, sizeof(int), cudaMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     cudaErrcheck(cudaFree(d_info));
     cudaErrcheck(cudaFree(d_work));
 }
 static inline
-void dngvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, double* A, const int& lda, double* B, const int& ldb, double * W)
+void hegvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, double* A, const int& lda, double* B, const int& ldb, double * W)
 {
     // prepare some values for cusolverDnDsygvd_bufferSize
     int lwork  = 0; 
@@ -293,13 +293,13 @@ void dngvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& j
 
     cudaErrcheck(cudaMemcpy(&h_info, d_info, sizeof(int), cudaMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     cudaErrcheck(cudaFree(d_info));
     cudaErrcheck(cudaFree(d_work));
 }
 static inline
-void dngvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, std::complex<float>* A, const int& lda, std::complex<float>* B, const int& ldb, float* W)
+void hegvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, std::complex<float>* A, const int& lda, std::complex<float>* B, const int& ldb, float* W)
 {
     // prepare some values for cusolverDnChegvd_bufferSize
     int lwork  = 0; 
@@ -319,13 +319,13 @@ void dngvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& j
 
     cudaErrcheck(cudaMemcpy(&h_info, d_info, sizeof(int), cudaMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     cudaErrcheck(cudaFree(d_info));
     cudaErrcheck(cudaFree(d_work));
 }
 static inline
-void dngvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, std::complex<double>* A, const int& lda, std::complex<double>* B, const int& ldb, double* W)
+void hegvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, std::complex<double>* A, const int& lda, std::complex<double>* B, const int& ldb, double* W)
 {
     // prepare some values for cusolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -345,7 +345,7 @@ void dngvd (cusolverDnHandle_t& cusolver_handle, const int& itype, const char& j
 
     cudaErrcheck(cudaMemcpy(&h_info, d_info, sizeof(int), cudaMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     cudaErrcheck(cudaFree(d_info));
     cudaErrcheck(cudaFree(d_work));
diff --git a/source/source_base/module_container/base/third_party/hipsolver.h b/source/source_base/module_container/base/third_party/hipsolver.h
index a0826d3a09..58db644cb7 100644
--- a/source/source_base/module_container/base/third_party/hipsolver.h
+++ b/source/source_base/module_container/base/third_party/hipsolver.h
@@ -131,7 +131,7 @@ void potrf (hipsolverHandle_t& hipsolver_handle, const char& uplo, const int& n,
 
 
 static inline
-void dnevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& uplo, const int& n, float* A, const int& lda, float * W)
+void heevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& uplo, const int& n, float* A, const int& lda, float * W)
 {
     // prepare some values for hipsolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -151,13 +151,13 @@ void dnevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& u
 
     hipErrcheck(hipMemcpy(&h_info, d_info, sizeof(int), hipMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     hipErrcheck(hipFree(d_info));
     hipErrcheck(hipFree(d_work));
 }
 static inline
-void dnevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& uplo, const int& n, double* A, const int& lda, double * W)
+void heevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& uplo, const int& n, double* A, const int& lda, double * W)
 {
     // prepare some values for hipsolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -177,13 +177,13 @@ void dnevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& u
 
     hipErrcheck(hipMemcpy(&h_info, d_info, sizeof(int), hipMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     hipErrcheck(hipFree(d_info));
     hipErrcheck(hipFree(d_work));
 }
 static inline
-void dnevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& uplo, const int& n, std::complex<float>* A, const int& lda, float * W)
+void heevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& uplo, const int& n, std::complex<float>* A, const int& lda, float * W)
 {
     // prepare some values for hipsolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -203,13 +203,13 @@ void dnevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& u
 
     hipErrcheck(hipMemcpy(&h_info, d_info, sizeof(int), hipMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     hipErrcheck(hipFree(d_info));
     hipErrcheck(hipFree(d_work));
 }
 static inline
-void dnevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& uplo, const int& n, std::complex<double>* A, const int& lda, double* W)
+void heevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& uplo, const int& n, std::complex<double>* A, const int& lda, double* W)
 {
     // prepare some values for hipsolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -229,14 +229,14 @@ void dnevd (hipsolverHandle_t& hipsolver_handle, const char& jobz, const char& u
 
     hipErrcheck(hipMemcpy(&h_info, d_info, sizeof(int), hipMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     hipErrcheck(hipFree(d_info));
     hipErrcheck(hipFree(d_work));
 }
 
 static inline
-void dngvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, float* A, const int& lda, float* B, const int& ldb, float * W)
+void hegvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, float* A, const int& lda, float* B, const int& ldb, float * W)
 {
     // prepare some values for hipsolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -256,13 +256,13 @@ void dngvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& j
 
     hipErrcheck(hipMemcpy(&h_info, d_info, sizeof(int), hipMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     hipErrcheck(hipFree(d_info));
     hipErrcheck(hipFree(d_work));
 }
 static inline
-void dngvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, double* A, const int& lda, double* B, const int& ldb, double * W)
+void hegvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, double* A, const int& lda, double* B, const int& ldb, double * W)
 {
     // prepare some values for hipsolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -282,13 +282,13 @@ void dngvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& j
 
     hipErrcheck(hipMemcpy(&h_info, d_info, sizeof(int), hipMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     hipErrcheck(hipFree(d_info));
     hipErrcheck(hipFree(d_work));
 }
 static inline
-void dngvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, std::complex<float>* A, const int& lda, std::complex<float>* B, const int& ldb, float* W)
+void hegvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, std::complex<float>* A, const int& lda, std::complex<float>* B, const int& ldb, float* W)
 {
     // prepare some values for hipsolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -308,13 +308,13 @@ void dngvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& j
 
     hipErrcheck(hipMemcpy(&h_info, d_info, sizeof(int), hipMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     hipErrcheck(hipFree(d_info));
     hipErrcheck(hipFree(d_work));
 }
 static inline
-void dngvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, std::complex<double>* A, const int& lda, std::complex<double>* B, const int& ldb, double* W)
+void hegvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& jobz, const char& uplo, const int& n, std::complex<double>* A, const int& lda, std::complex<double>* B, const int& ldb, double* W)
 {
     // prepare some values for hipsolverDnZhegvd_bufferSize
     int lwork  = 0; 
@@ -334,7 +334,7 @@ void dngvd (hipsolverHandle_t& hipsolver_handle, const int& itype, const char& j
 
     hipErrcheck(hipMemcpy(&h_info, d_info, sizeof(int), hipMemcpyDeviceToHost));
     if (h_info != 0) {
-        throw std::runtime_error("dnevd: failed to invert matrix");
+        throw std::runtime_error("heevd: failed to invert matrix");
     }
     hipErrcheck(hipFree(d_info));
     hipErrcheck(hipFree(d_work));
diff --git a/source/source_base/module_container/base/third_party/lapack.h b/source/source_base/module_container/base/third_party/lapack.h
index 7452dc1835..c3a8af2027 100644
--- a/source/source_base/module_container/base/third_party/lapack.h
+++ b/source/source_base/module_container/base/third_party/lapack.h
@@ -136,7 +136,7 @@ int ilaenv( int ispec, const char *name,const char *opts,const int n1,const int
 }
 // wrap function of fortran lapack routine zhegvd. (pointer version)
 static inline
-void dngvd(const int itype, const char jobz, const char uplo, const int n,
+void hegvd(const int itype, const char jobz, const char uplo, const int n,
             float* a, const int lda,
             const float* b, const int ldb, float* w,
             float* work, int lwork, float* rwork, int lrwork,
@@ -150,7 +150,7 @@ void dngvd(const int itype, const char jobz, const char uplo, const int n,
 }
 // wrap function of fortran lapack routine zhegvd.
 static inline
-void dngvd(const int itype, const char jobz, const char uplo, const int n,
+void hegvd(const int itype, const char jobz, const char uplo, const int n,
             double* a, const int lda,
             const double* b, const int ldb, double* w,
             double* work, int lwork, double* rwork, int lrwork,
@@ -163,7 +163,7 @@ void dngvd(const int itype, const char jobz, const char uplo, const int n,
             iwork, &liwork, &info);
 }
 static inline
-void dngvd(const int itype, const char jobz, const char uplo, const int n,
+void hegvd(const int itype, const char jobz, const char uplo, const int n,
             std::complex<float>* a, const int lda,
             const std::complex<float>* b, const int ldb, float* w,
             std::complex<float>* work, int lwork, float* rwork, int lrwork,
@@ -177,7 +177,7 @@ void dngvd(const int itype, const char jobz, const char uplo, const int n,
 }
 // wrap function of fortran lapack routine zhegvd.
 static inline
-void dngvd(const int itype, const char jobz, const char uplo, const int n,
+void hegvd(const int itype, const char jobz, const char uplo, const int n,
             std::complex<double>* a, const int lda,
             const std::complex<double>* b, const int ldb, double* w,
             std::complex<double>* work, int lwork, double* rwork, int lrwork,
@@ -192,7 +192,7 @@ void dngvd(const int itype, const char jobz, const char uplo, const int n,
 
 // wrap function of fortran lapack routine zheevx.
 static inline
-void dnevx( const int itype, const char jobz, const char range, const char uplo, const int n,
+void heevx( const int itype, const char jobz, const char range, const char uplo, const int n,
              float* a, const int lda,
              const float vl, const float vu, const int il, const int iu, const float abstol,
              const int m, float* w, float* z, const int ldz,
@@ -205,7 +205,7 @@ void dnevx( const int itype, const char jobz, const char range, const char uplo,
 }
 // wrap function of fortran lapack routine zheevx.
 static inline
-void dnevx( const int itype, const char jobz, const char range, const char uplo, const int n,
+void heevx( const int itype, const char jobz, const char range, const char uplo, const int n,
              double* a, const int lda,
              const double vl, const double vu, const int il, const int iu, const double abstol,
              const int m, double* w, double* z, const int ldz,
@@ -217,7 +217,7 @@ void dnevx( const int itype, const char jobz, const char range, const char uplo,
             work, &lwork, rwork, iwork, ifail, &info);
 }
 static inline
-void dnevx( const int itype, const char jobz, const char range, const char uplo, const int n,
+void heevx( const int itype, const char jobz, const char range, const char uplo, const int n,
              std::complex<float>* a, const int lda,
              const float vl, const float vu, const int il, const int iu, const float abstol,
              const int m, float* w, std::complex<float>* z, const int ldz,
@@ -230,7 +230,7 @@ void dnevx( const int itype, const char jobz, const char range, const char uplo,
 }
 // wrap function of fortran lapack routine zheevx.
 static inline
-void dnevx( const int itype, const char jobz, const char range, const char uplo, const int n,
+void heevx( const int itype, const char jobz, const char range, const char uplo, const int n,
              std::complex<double>* a, const int lda,
              const double vl, const double vu, const int il, const int iu, const double abstol,
              const int m, double* w, std::complex<double>* z, const int ldz,
@@ -243,7 +243,7 @@ void dnevx( const int itype, const char jobz, const char range, const char uplo,
 }
 
 static inline
-void dnevd(const char jobz, const char uplo, const int n,
+void heevd(const char jobz, const char uplo, const int n,
             float* a, const int lda, float* w,
             float* work, int lwork, float* rwork, int lrwork,
             int* iwork, int liwork, int& info)
@@ -256,7 +256,7 @@ void dnevd(const char jobz, const char uplo, const int n,
 }
 // wrap function of fortran lapack routine zhegvd.
 static inline
-void dnevd(const char jobz, const char uplo, const int n,
+void heevd(const char jobz, const char uplo, const int n,
             double* a, const int lda, double* w,
             double* work, int lwork, double* rwork, int lrwork,
             int* iwork, int liwork, int& info)
@@ -268,7 +268,7 @@ void dnevd(const char jobz, const char uplo, const int n,
              iwork, &liwork, &info);
 }
 static inline
-void dnevd(const char jobz, const char uplo, const int n,
+void heevd(const char jobz, const char uplo, const int n,
             std::complex<float>* a, const int lda, float* w,
             std::complex<float>* work, int lwork, float* rwork, int lrwork,
             int* iwork, int liwork, int& info)
@@ -281,7 +281,7 @@ void dnevd(const char jobz, const char uplo, const int n,
 }
 // wrap function of fortran lapack routine zhegvd.
 static inline
-void dnevd(const char jobz, const char uplo, const int n,
+void heevd(const char jobz, const char uplo, const int n,
             std::complex<double>* a, const int lda, double* w,
             std::complex<double>* work, int lwork, double* rwork, int lrwork,
             int* iwork, int liwork, int& info)
diff --git a/source/source_esolver/esolver_ks_lcaopw.cpp b/source/source_esolver/esolver_ks_lcaopw.cpp
index 4593258269..1b0b7dae67 100644
--- a/source/source_esolver/esolver_ks_lcaopw.cpp
+++ b/source/source_esolver/esolver_ks_lcaopw.cpp
@@ -23,7 +23,7 @@
 #include "source_pw/module_pwdft/hamilt_pw.h"
 #include "source_hsolver/diago_iter_assist.h"
 #include "source_hsolver/hsolver_lcaopw.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "source_base/kernels/math_kernel_op.h"
 #include "source_io/berryphase.h"
 #include "source_io/numerical_basis.h"
diff --git a/source/source_esolver/esolver_ks_pw.cpp b/source/source_esolver/esolver_ks_pw.cpp
index daba4282c5..4bf5fa6a6c 100644
--- a/source/source_esolver/esolver_ks_pw.cpp
+++ b/source/source_esolver/esolver_ks_pw.cpp
@@ -12,7 +12,7 @@
 #include "source_hamilt/module_vdw/vdw.h"
 #include "source_hsolver/diago_iter_assist.h"
 #include "source_hsolver/hsolver_pw.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "source_io/module_parameter/parameter.h"
 #include "source_lcao/module_deltaspin/spin_constrain.h"
 #include "source_pw/module_pwdft/onsite_projector.h"
diff --git a/source/source_esolver/pw_others.cpp b/source/source_esolver/pw_others.cpp
index b04fec255f..09550f075b 100644
--- a/source/source_esolver/pw_others.cpp
+++ b/source/source_esolver/pw_others.cpp
@@ -25,7 +25,7 @@
 #include "source_pw/module_pwdft/hamilt_pw.h"
 #include "source_hsolver/diago_iter_assist.h"
 #include "source_hsolver/hsolver_pw.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "source_base/kernels/math_kernel_op.h"
 #include "source_io/berryphase.h"
 #include "source_io/numerical_basis.h"
diff --git a/source/source_hsolver/CMakeLists.txt b/source/source_hsolver/CMakeLists.txt
index 8fa1d17983..c2aa8c60e4 100644
--- a/source/source_hsolver/CMakeLists.txt
+++ b/source/source_hsolver/CMakeLists.txt
@@ -37,7 +37,7 @@ if(ENABLE_LCAO)
 
   if(USE_CUDA)
       list(APPEND objects
-          ./kernels/dngvd_op.cpp
+          ./kernels/hegvd_op.cpp
           ./kernels/cuda/diag_cusolver.cu
           diago_cusolver.cpp
           diago_cusolver.h
diff --git a/source/source_hsolver/diago_bpcg.cpp b/source/source_hsolver/diago_bpcg.cpp
index 45c9b8b24d..8b9a51b7f8 100644
--- a/source/source_hsolver/diago_bpcg.cpp
+++ b/source/source_hsolver/diago_bpcg.cpp
@@ -209,7 +209,7 @@ void DiagoBPCG<T, Device>::diag_hsub(
     // gemm: hsub_out(n_band x n_band) = hpsi_in^T(n_band x n_basis) * psi_in(n_basis x n_band)
     this->pmmcn.multiply(1.0, hpsi_in.data<T>(), psi_in.data<T>(), 0.0, hsub_out.data<T>());
 
-    ct::kernels::lapack_dnevd<T, ct_Device>()('V', 'U', hsub_out.data<T>(), this->n_band, eigenvalue_out.data<Real>());
+    ct::kernels::lapack_heevd<T, ct_Device>()('V', 'U', hsub_out.data<T>(), this->n_band, eigenvalue_out.data<Real>());
 
     return;
 }
diff --git a/source/source_hsolver/diago_bpcg.h b/source/source_hsolver/diago_bpcg.h
index d9baa9eef3..796ae77666 100644
--- a/source/source_hsolver/diago_bpcg.h
+++ b/source/source_hsolver/diago_bpcg.h
@@ -7,7 +7,7 @@
 #include "source_base/para_gemm.h"
 #include "source_hamilt/hamilt.h"
 #include "source_pw/module_pwdft/structure_factor.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "source_hsolver/para_linear_transform.h"
 
 #include <ATen/core/tensor.h>
diff --git a/source/source_hsolver/diago_cusolver.h b/source/source_hsolver/diago_cusolver.h
index 5f895ea21d..b8cd0fccd2 100644
--- a/source/source_hsolver/diago_cusolver.h
+++ b/source/source_hsolver/diago_cusolver.h
@@ -5,7 +5,6 @@
 #include "source_hamilt/hamilt.h"
 #include "source_basis/module_ao/parallel_orbitals.h"
 #include "source_hsolver/kernels/cuda/diag_cusolver.cuh"
-// #include "source_hsolver/kernels/cuda/dngvd_op.cu"
 
 namespace hsolver
 {
diff --git a/source/source_hsolver/diago_dav_subspace.cpp b/source/source_hsolver/diago_dav_subspace.cpp
index c180155713..384b1e765a 100644
--- a/source/source_hsolver/diago_dav_subspace.cpp
+++ b/source/source_hsolver/diago_dav_subspace.cpp
@@ -4,7 +4,7 @@
 #include "source_base/memory.h"
 #include "source_base/module_device/device.h"
 #include "source_base/timer.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "source_base/kernels/math_kernel_op.h"
 #include "source_hsolver/kernels/bpcg_kernel_op.h" // normalize_op, precondition_op, apply_eigenvalues_op
 #include "source_base/kernels/dsp/dsp_connector.h"
diff --git a/source/source_hsolver/diago_david.cpp b/source/source_hsolver/diago_david.cpp
index 0fec378e14..607041089f 100644
--- a/source/source_hsolver/diago_david.cpp
+++ b/source/source_hsolver/diago_david.cpp
@@ -4,7 +4,7 @@
 #include "source_base/tool_title.h"             // ModuleBase::TITLE
 #include "source_base/module_device/device.h"
 
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "source_base/kernels/math_kernel_op.h"
 
 
diff --git a/source/source_hsolver/diago_iter_assist.cpp b/source/source_hsolver/diago_iter_assist.cpp
index 419b8b2b65..957cd0cbf4 100644
--- a/source/source_hsolver/diago_iter_assist.cpp
+++ b/source/source_hsolver/diago_iter_assist.cpp
@@ -6,7 +6,7 @@
 #include "source_base/module_device/device.h"
 #include "source_base/parallel_reduce.h"
 #include "source_base/timer.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "source_base/kernels/math_kernel_op.h"
 
 namespace hsolver
diff --git a/source/source_hsolver/kernels/cuda/dngvd_op.cu b/source/source_hsolver/kernels/cuda/hegvd_op.cu
similarity index 99%
rename from source/source_hsolver/kernels/cuda/dngvd_op.cu
rename to source/source_hsolver/kernels/cuda/hegvd_op.cu
index 232c769b2c..f4d03a7522 100644
--- a/source/source_hsolver/kernels/cuda/dngvd_op.cu
+++ b/source/source_hsolver/kernels/cuda/hegvd_op.cu
@@ -1,4 +1,4 @@
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "helper_cuda.h"
 
 #include <base/macros/macros.h>
diff --git a/source/source_hsolver/kernels/dngvd_op.cpp b/source/source_hsolver/kernels/hegvd_op.cpp
similarity index 99%
rename from source/source_hsolver/kernels/dngvd_op.cpp
rename to source/source_hsolver/kernels/hegvd_op.cpp
index 0a700a89d9..9c28866a4e 100644
--- a/source/source_hsolver/kernels/dngvd_op.cpp
+++ b/source/source_hsolver/kernels/hegvd_op.cpp
@@ -1,4 +1,4 @@
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 
 #include <algorithm>
 #include <fstream>
diff --git a/source/source_hsolver/kernels/dngvd_op.h b/source/source_hsolver/kernels/hegvd_op.h
similarity index 90%
rename from source/source_hsolver/kernels/dngvd_op.h
rename to source/source_hsolver/kernels/hegvd_op.h
index bfd59ebdf2..c0a92eb534 100644
--- a/source/source_hsolver/kernels/dngvd_op.h
+++ b/source/source_hsolver/kernels/hegvd_op.h
@@ -1,7 +1,15 @@
-// TODO: This is a temperary location for these functions.
-// And will be moved to a global module(module base) later.
+/// This is the module for wrapper of 
+/// DeNse Generalized eigenValue (eXtended)
+/// HErmitian / SYmmetric
+
+// named HEGVD, actually includes HE/SY GV/GVD/GVX
 
-// DeNse Generalized eigenValue eXtended
+#ifndef MODULE_HSOLVER_HEGVD_H
+#define MODULE_HSOLVER_HEGVD_H
+
+// Note:
+// names follow the same style as standard LAPACK APIs:
+// -----------------------------------
 // he stands for Hermitian
 // sy stands for Symmetric
 // gv stands for Generalized eigenValue problem
@@ -10,9 +18,12 @@
 // x stands for compute a subset of the eigenvalues and, optionally,
 // their corresponding eigenvectors
 // d for all, x for selected
+// gv: all, gvd: all/devide-and-conquer, x: selected eigenvalues
+// -----------------------------------
+// search for docs using the op function name as keywords.
 
-#ifndef MODULE_HSOLVER_DNGVD_H
-#define MODULE_HSOLVER_DNGVD_H
+// TODO: This is a temperary location for these functions.
+// And will be moved to a global module(module base) later.
 
 #include "source_base/macros.h"
 #include "source_base/module_external/lapack_wrapper.h"
@@ -126,4 +137,4 @@ void destroyGpuSolverHandle();
 
 } // namespace hsolver
 
-#endif // !MODULE_HSOLVER_DNGVD_H
\ No newline at end of file
+#endif // !MODULE_HSOLVER_HEGVD_H
\ No newline at end of file
diff --git a/source/source_hsolver/kernels/rocm/dngvd_op.hip.cu b/source/source_hsolver/kernels/rocm/hegvd_op.hip.cu
similarity index 98%
rename from source/source_hsolver/kernels/rocm/dngvd_op.hip.cu
rename to source/source_hsolver/kernels/rocm/hegvd_op.hip.cu
index 2b17394b60..121180de85 100644
--- a/source/source_hsolver/kernels/rocm/dngvd_op.hip.cu
+++ b/source/source_hsolver/kernels/rocm/hegvd_op.hip.cu
@@ -1,11 +1,11 @@
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 
 #include <hip/hip_runtime.h>
 #include <base/macros/macros.h>
 
 namespace hsolver {
 
-// NOTE: mimicked from ../cuda/dngvd_op.cu for three hegvd_op
+// NOTE: mimicked from ../cuda/hegvd_op.cu for three hegvd_op
 
 static hipsolverHandle_t hipsolver_H = nullptr;
 // Test on DCU platform. When nstart is greater than 234, code on DCU performs better.
@@ -36,7 +36,7 @@ void hegvd_op<double, base_device::DEVICE_GPU>::operator()(const base_device::DE
                                                            double* _eigenvalue,
                                                            double* _vcc)
 {
-    // copied from ../cuda/dngvd_op.cu, "hegvd_op"
+    // copied from ../cuda/hegvd_op.cu, "hegvd_op"
     assert(nstart == ldh);
 
     if (nstart > N_DCU){
@@ -110,7 +110,7 @@ void hegvd_op<std::complex<float>, base_device::DEVICE_GPU>::operator()(const ba
                                                                         float* _eigenvalue,
                                                                         std::complex<float>* _vcc)
 {
-    // copied from ../cuda/dngvd_op.cu, "hegvd_op"
+    // copied from ../cuda/hegvd_op.cu, "hegvd_op"
     assert(nstart == ldh);
 
     if (nstart > N_DCU){
@@ -183,7 +183,7 @@ void hegvd_op<std::complex<double>, base_device::DEVICE_GPU>::operator()(const b
                                                                          std::complex<double>* _vcc
                                                                         )
 {
-    // copied from ../cuda/dngvd_op.cu, "hegvd_op"
+    // copied from ../cuda/hegvd_op.cu, "hegvd_op"
     // assert(nstart == ldh);
 
     // save a copy of scc in case the diagonalization fails
diff --git a/source/source_hsolver/kernels/test/CMakeLists.txt b/source/source_hsolver/kernels/test/CMakeLists.txt
index 6ae7221685..851c30c731 100644
--- a/source/source_hsolver/kernels/test/CMakeLists.txt
+++ b/source/source_hsolver/kernels/test/CMakeLists.txt
@@ -5,7 +5,7 @@ if(USE_CUDA OR USE_ROCM)
     AddTest(
         TARGET MODULE_HSOLVER_KERNELS_Unittests
         LIBS parameter ${math_libs} base device
-        SOURCES math_dngvd_test.cpp
+        SOURCES math_hegvd_test.cpp
     )
 endif()
 
diff --git a/source/source_hsolver/kernels/test/math_dngvd_test.cpp b/source/source_hsolver/kernels/test/math_hegvd_test.cpp
similarity index 99%
rename from source/source_hsolver/kernels/test/math_dngvd_test.cpp
rename to source/source_hsolver/kernels/test/math_hegvd_test.cpp
index c5582faec2..adf2ab95ee 100644
--- a/source/source_hsolver/kernels/test/math_dngvd_test.cpp
+++ b/source/source_hsolver/kernels/test/math_hegvd_test.cpp
@@ -1,6 +1,6 @@
 #include "source_base/complexmatrix.h"
 #include "source_base/module_device/memory_op.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 #include "source_base/kernels/math_kernel_op.h"
 
 #include <algorithm>
diff --git a/source/source_hsolver/test/CMakeLists.txt b/source/source_hsolver/test/CMakeLists.txt
index 0649ea8c8e..72ad05e0ba 100644
--- a/source/source_hsolver/test/CMakeLists.txt
+++ b/source/source_hsolver/test/CMakeLists.txt
@@ -115,7 +115,7 @@ if (ENABLE_MPI)
     TARGET MODULE_HSOLVER_LCAO_cusolver
     LIBS parameter  ${math_libs}  base psi device 
     SOURCES diago_lcao_cusolver_test.cpp ../diago_cusolver.cpp ../diago_scalapack.cpp 
-    ../kernels/dngvd_op.cpp
+    ../kernels/hegvd_op.cpp
     ../kernels/cuda/diag_cusolver.cu
   )
   endif()
diff --git a/source/source_hsolver/test/test_diago_hs_para.cpp b/source/source_hsolver/test/test_diago_hs_para.cpp
index a751d72d80..a32d329fbd 100644
--- a/source/source_hsolver/test/test_diago_hs_para.cpp
+++ b/source/source_hsolver/test/test_diago_hs_para.cpp
@@ -10,7 +10,7 @@
 #include <fstream>
 
 #include "../diag_hs_para.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 
 template <typename T>
 typename std::enable_if<std::is_same<T, double>::value || std::is_same<T, float>::value>::type
diff --git a/source/source_main/driver_run.cpp b/source/source_main/driver_run.cpp
index 78f4700a8c..eb04ae588a 100644
--- a/source/source_main/driver_run.cpp
+++ b/source/source_main/driver_run.cpp
@@ -10,7 +10,7 @@
 #include "source_base/module_device/device.h"
 #include "source_base/module_device/memory_op.h"
 #include "source_base/kernels/math_kernel_op.h"
-#include "source_hsolver/kernels/dngvd_op.h"
+#include "source_hsolver/kernels/hegvd_op.h"
 
 #include <ATen/kernels/blas.h>
 #include <ATen/kernels/lapack.h>