remove Psi<T, Device>::Psi(T* psi_pointer, const Psi& psi_in, const int nk_in, int nband_in)

Author: haozhihan

source/module_hamilt_general/operator.cpp

@@ -61,7 +61,12 @@ typename Operator<T, Device>::hpsi_info Operator<T, Device>::hPsi(hpsi_info& inp
         // ModuleBase::GlobalFunc::COPYARRAY(this->hpsi->get_pointer(), hpsi_pointer, this->hpsi->size());
         syncmem_op()(this->ctx, this->ctx, hpsi_pointer, this->hpsi->get_pointer(), this->hpsi->size());
         delete this->hpsi;
-        this->hpsi = new psi::Psi<T, Device>(hpsi_pointer, *psi_input, 1, nbands / psi_input->npol);
+        this->hpsi = new psi::Psi<T, Device>(hpsi_pointer, 
+                                             1, 
+                                             nbands / psi_input->npol,
+                                             psi_input->get_nbasis(),
+                                             psi_input->get_nbasis(),
+                                             true);
     }
 
     auto call_act = [&, this](const Operator* op, const bool& is_first_node) -> void {
@@ -177,7 +182,13 @@ T* Operator<T, Device>::get_hpsi(const hpsi_info& info) const
     else
     {
         this->in_place = false;
-        this->hpsi = new psi::Psi<T, Device>(hpsi_pointer, std::get<0>(info)[0], 1, nbands_range);
+        // this->hpsi = new psi::Psi<T, Device>(hpsi_pointer, std::get<0>(info)[0], 1, nbands_range);
+        this->hpsi = new psi::Psi<T, Device>(hpsi_pointer, 
+                                             1, 
+                                             nbands_range, 
+                                             std::get<0>(info)->get_nbasis(), 
+                                             std::get<0>(info)->get_nbasis(), 
+                                             true);
     }
 
     hpsi_pointer = this->hpsi->get_pointer();

source/module_lr/utils/lr_util.hpp

@@ -99,7 +99,11 @@ namespace LR_Util
     template<typename T>
     psi::Psi<T> get_psi_spin(const psi::Psi<T>& psi_in, const int& is, const int& nk)
     {
-        return psi::Psi<T>(&psi_in(is * nk, 0, 0), psi_in, nk, psi_in.get_nbands());
+        return psi::Psi<T>(&psi_in(is * nk, 0, 0), 
+                           nk, 
+                           psi_in.get_nbands(),
+                           psi_in.get_nbasis(),
+                           true);
     }
 
     /// psi(nk=1, nbands=nb, nk * nbasis) -> psi(nb, nk, nbasis) without memory copy

source/module_psi/psi.cpp

@@ -93,7 +93,7 @@ Psi<T, Device>::Psi(T* psi_pointer,
 {
 
     // Currently this function only supports nk_in == 1 when called within diagH_subspace_init.
-    // assert(nk_in == 1); // NOTE because lr/utils/lr_uril.hpp func
+    // assert(nk_in == 1); // NOTE because lr/utils/lr_uril.hpp func & get_psi_spin func
 
     this->k_first = k_first_in;
     this->npol = PARAM.globalv.npol;
@@ -193,24 +193,24 @@ Psi<T, Device>::Psi(const Psi& psi_in, const int nk_in, const int nband_in)
     }
 }
 
-template <typename T, typename Device>
-Psi<T, Device>::Psi(T* psi_pointer, const Psi& psi_in, const int nk_in, int nband_in)
-{
-    this->k_first = psi_in.get_k_first();
-    assert(nk_in <= psi_in.get_nk());
-    if (nband_in == 0)
-    {
-        nband_in = psi_in.get_nbands();
-    }
-    this->ngk = psi_in.ngk;
-    this->npol = psi_in.npol;
-    this->nk = nk_in;
-    this->nbands = nband_in;
-    this->nbasis = psi_in.nbasis;
-    this->psi_current = psi_pointer;
-    this->allocate_inside = false;
-    this->psi = psi_pointer;
-}
+// template <typename T, typename Device>
+// Psi<T, Device>::Psi(T* psi_pointer, const Psi& psi_in, const int nk_in, int nband_in)
+// {
+//     this->k_first = psi_in.get_k_first();
+//     assert(nk_in <= psi_in.get_nk());
+//     if (nband_in == 0)
+//     {
+//         nband_in = psi_in.get_nbands();
+//     }
+//     this->ngk = psi_in.ngk;
+//     this->npol = psi_in.npol;
+//     this->nk = nk_in;
+//     this->nbands = nband_in;
+//     this->nbasis = psi_in.nbasis;
+//     this->psi_current = psi_pointer;
+//     this->allocate_inside = false;
+//     this->psi = psi_pointer;
+// }
 
 template <typename T, typename Device>
 Psi<T, Device>::Psi(const Psi& psi_in)

source/module_psi/psi.h

@@ -47,9 +47,9 @@ class Psi
     // Constructor 4: copy a new Psi which have several k-points and several bands from inputted psi_in
     Psi(const Psi& psi_in, const int nk_in, const int nband_in);
 
-    // Constructor 5: a wrapper of a data pointer, used for Operator::hPsi()
-    // in this case, fix_k can not be used
-    Psi(T* psi_pointer, const Psi& psi_in, const int nk_in, int nband_in = 0);
+    // // Constructor 5: a wrapper of a data pointer, used for Operator::hPsi()
+    // // in this case, fix_k can not be used
+    // Psi(T* psi_pointer, const Psi& psi_in, const int nk_in, int nband_in);
 
     // Constructor 6: initialize a new psi from the given psi_in
     Psi(const Psi& psi_in);

source/module_psi/test/psi_test.cpp

@@ -14,9 +14,6 @@ class TestPsi : public ::testing::Test
     const psi::Psi<double>* psi_object32 = new psi::Psi<double>(ink, inbands, inbasis, &ngk[0]);
     const psi::Psi<std::complex<float>>* psi_object33 = new psi::Psi<std::complex<float>>(ink, inbands, inbasis, &ngk[0]);
     const psi::Psi<float>* psi_object34 = new psi::Psi<float>(ink, inbands, inbasis, &ngk[0]);
-
-    // psi::Psi<std::complex<double>>* psi_object4 = new psi::Psi<std::complex<double>>(*psi_object31, ink, 0);
-    psi::Psi<std::complex<double>>* psi_object5 = new psi::Psi<std::complex<double>>(psi_object31->get_pointer(), *psi_object31, ink, 0);
 };
 
 TEST_F(TestPsi, get_val)