Remove scc calculation deprecated code of traditional Davidson algorithm.

Author: Cstandardlib

source/source_hsolver/diago_david.cpp

@@ -76,10 +76,6 @@ DiagoDavid<T, Device>::DiagoDavid(const Real* precondition_in,
     resmem_complex_op()(this->hcc, nbase_x * nbase_x, "DAV::hcc");
     setmem_complex_op()(this->hcc, 0, nbase_x * nbase_x);
 
-    // scc(nbase_x, nbase_x); // Overlap on the reduced basis
-    // resmem_complex_op()(this->ctx, this->scc, nbase_x * nbase_x, "DAV::scc");
-    // setmem_complex_op()(this->ctx, this->scc, 0, nbase_x * nbase_x);
-
     // vcc(nbase_x, nbase_x); // Eigenvectors of hcc
     resmem_complex_op()(this->vcc, nbase_x * nbase_x, "DAV::vcc");
     setmem_complex_op()(this->vcc, 0, nbase_x * nbase_x);
@@ -106,7 +102,6 @@ DiagoDavid<T, Device>::~DiagoDavid()
     delmem_complex_op()(this->hpsi);
     delmem_complex_op()(this->spsi);
     delmem_complex_op()(this->hcc);
-    // delmem_complex_op()(this->ctx, this->scc);
     delmem_complex_op()(this->vcc);
     delmem_complex_op()(this->lagrange_matrix);
     base_device::memory::delete_memory_op<Real, base_device::DEVICE_CPU>()(this->eigenvalue);
@@ -562,28 +557,12 @@ void DiagoDavid<T, Device>::cal_elem(const int& dim,
                                      this->zero,
                                      hcc + nbase, // notconv * (nbase + notconv)
                                      nbase_x);
-    // scc[nbase] = basis[nbase]' * spsi
-    // gemm_op<T, Device>()(this->ctx,
-    //                           'C',
-    //                           'N',
-    //                           notconv,
-    //                           nbase + notconv,
-    //                           dim,
-    //                           this->one,
-    //                           basis + dim*nbase, // dim * notconv
-    //                           dim,
-    //                           spsi,               // dim * (nbase + notconv)
-    //                           dim,
-    //                           this->zero,
-    //                           scc + nbase,        // notconv * (nbase + notconv)
-    //                           nbase_x);
 
 
 #ifdef __MPI
     if (diag_comm.nproc > 1)
     {
         ModuleBase::matrixTranspose_op<T, Device>()(nbase_x, nbase_x, hcc, hcc);
-        // matrixTranspose_op<T, Device>()(this->ctx, nbase_x, nbase_x, scc, scc);
 
         auto* swap = new T[notconv * nbase_x];
         syncmem_complex_op()(swap, hcc + nbase * nbase_x, notconv * nbase_x);
@@ -599,21 +578,13 @@ void DiagoDavid<T, Device>::cal_elem(const int& dim,
             else {
                 MPI_Reduce(swap, hcc + nbase * nbase_x, notconv * nbase_x, MPI_DOUBLE_COMPLEX, MPI_SUM, 0, diag_comm.comm);
             }
-            // syncmem_complex_op()(this->ctx, this->ctx, swap, scc + nbase * nbase_x, notconv * nbase_x);
-            if (base_device::get_current_precision(swap) == "single") {
-                // MPI_Reduce(swap, scc + nbase * nbase_x, notconv * nbase_x, MPI_COMPLEX, MPI_SUM, 0, diag_comm.comm);
-            }
-            else {
-                // MPI_Reduce(swap, scc + nbase * nbase_x, notconv * nbase_x, MPI_DOUBLE_COMPLEX, MPI_SUM, 0, diag_comm.comm);
-            }
+
         }
         delete[] swap;
 
         // Parallel_Reduce::reduce_complex_double_pool( hcc + nbase * nbase_x, notconv * nbase_x );
-        // Parallel_Reduce::reduce_complex_double_pool( scc + nbase * nbase_x, notconv * nbase_x );
 
         ModuleBase::matrixTranspose_op<T, Device>()(nbase_x, nbase_x, hcc, hcc);
-        // matrixTranspose_op<T, Device>()(this->ctx, nbase_x, nbase_x, scc, scc);
     }
 #endif
 
@@ -763,42 +734,31 @@ void DiagoDavid<T, Device>::refresh(const int& dim,
 
     setmem_complex_op()(hcc, 0, nbase_x * nbase_x);
 
-    // setmem_complex_op()(this->ctx, scc, 0, nbase_x * nbase_x);
-
     if (this->device == base_device::GpuDevice)
     {
 #if defined(__CUDA) || defined(__ROCM)
         T* hcc_cpu = nullptr;
-        // T* scc_cpu = nullptr;
         T* vcc_cpu = nullptr;
         base_device::memory::resize_memory_op<T, base_device::DEVICE_CPU>()(hcc_cpu,
                                                                             nbase_x * nbase_x,
                                                                             "DAV::hcc");
-        // base_device::memory::resize_memory_op<T, base_device::DEVICE_CPU>()(this->cpu_ctx,
-        //                                                                     scc_cpu,
-        //                                                                     nbase_x * nbase_x,
-        //                                                                     "DAV::scc");
         base_device::memory::resize_memory_op<T, base_device::DEVICE_CPU>()(vcc_cpu,
                                                                             nbase_x * nbase_x,
                                                                             "DAV::vcc");
 
         syncmem_d2h_op()(hcc_cpu, hcc, nbase_x * nbase_x);
-        // syncmem_d2h_op()(this->cpu_ctx, this->ctx, scc_cpu, scc, nbase_x * nbase_x);
         syncmem_d2h_op()(vcc_cpu, vcc, nbase_x * nbase_x);
 
         for (int i = 0; i < nbase; i++)
         {
             hcc_cpu[i * nbase_x + i] = eigenvalue_in[i];
-            // scc_cpu[i * nbase_x + i] = this->one[0];
             vcc_cpu[i * nbase_x + i] = this->one[0];
         }
 
         syncmem_h2d_op()(hcc, hcc_cpu, nbase_x * nbase_x);
-        // syncmem_h2d_op()(this->ctx, this->cpu_ctx, scc, scc_cpu, nbase_x * nbase_x);
         syncmem_h2d_op()(vcc, vcc_cpu, nbase_x * nbase_x);
 
         base_device::memory::delete_memory_op<T, base_device::DEVICE_CPU>()(hcc_cpu);
-        // base_device::memory::delete_memory_op<T, base_device::DEVICE_CPU>()(this->cpu_ctx, scc_cpu);
         base_device::memory::delete_memory_op<T, base_device::DEVICE_CPU>()(vcc_cpu);
 #endif
     }
@@ -808,7 +768,6 @@ void DiagoDavid<T, Device>::refresh(const int& dim,
         {
             hcc[i * nbase_x + i] = eigenvalue_in[i];
             // sc(i, i) = this->one;
-            // scc[i * nbase_x + i] = this->one[0];
             // vc(i, i) = this->one;
             vcc[i * nbase_x + i] = this->one[0];
         }