Fix: Refactor Psi constructor to separate declaration and implementation for better readability and maintainability

Author: sunliang98

source/source_psi/psi.cpp

@@ -171,6 +171,53 @@ Psi<T, Device>::Psi(const Psi& psi_in)
     this->psi_current = this->psi + psi_in.get_psi_bias();
 }
 
+// Constructor 2-2
+template <typename T, typename Device>
+template <typename T_in, typename Device_in>
+Psi<T, Device>::Psi(const Psi<T_in, Device_in>& psi_in)
+{
+
+    this->ngk = psi_in.get_ngk_pointer();
+    this->nk = psi_in.get_nk();
+    this->nbands = psi_in.get_nbands();
+    this->nbasis = psi_in.get_nbasis();
+    this->current_k = psi_in.get_current_k();
+    this->current_b = psi_in.get_current_b();
+    this->k_first = psi_in.get_k_first();
+    // this function will copy psi_in.psi to this->psi no matter the device types of each other.
+
+    this->resize(psi_in.get_nk(), psi_in.get_nbands(), psi_in.get_nbasis());
+
+    // Specifically, if the Device_in type is CPU and the Device type is GPU.
+    // Which means we need to initialize a GPU psi from a given CPU psi.
+    // We first malloc a memory in CPU, then cast the memory from T_in to T in CPU.
+    // Finally, synchronize the memory from CPU to GPU.
+    // This could help to reduce the peak memory usage of device.
+    if (std::is_same<Device, base_device::DEVICE_GPU>::value && std::is_same<Device_in, base_device::DEVICE_CPU>::value)
+    {
+        auto* arr = (T*)malloc(sizeof(T) * psi_in.size());
+        // cast the memory from T_in to T in CPU
+        base_device::memory::cast_memory_op<T, T_in, Device_in, Device_in>()(arr,
+                                                                            psi_in.get_pointer()
+                                                                                - psi_in.get_psi_bias(),
+                                                                            psi_in.size());
+        // synchronize the memory from CPU to GPU
+        base_device::memory::synchronize_memory_op<T, Device, Device_in>()(this->psi,
+                                                                        arr,
+                                                                        psi_in.size());
+        free(arr);
+    }
+    else
+    {
+        base_device::memory::cast_memory_op<T, T_in, Device, Device_in>()(this->psi,
+                                                                        psi_in.get_pointer() - psi_in.get_psi_bias(),
+                                                                        psi_in.size());
+    }
+    this->psi_bias = psi_in.get_psi_bias();
+    this->current_nbasis = psi_in.get_current_nbas();
+    this->psi_current = this->psi + psi_in.get_psi_bias();
+}
+
 template <typename T, typename Device>
 void Psi<T, Device>::set_all_psi(const T* another_pointer, const std::size_t size_in)
 {
@@ -497,6 +544,8 @@ template Psi<double, base_device::DEVICE_CPU>::Psi(const Psi<double, base_device
 template Psi<double, base_device::DEVICE_GPU>::Psi(const Psi<double, base_device::DEVICE_CPU>&);
 template Psi<std::complex<double>, base_device::DEVICE_CPU>::Psi(
     const Psi<std::complex<double>, base_device::DEVICE_GPU>&);
+template Psi<std::complex<double>, base_device::DEVICE_CPU>::Psi(
+    const Psi<std::complex<float>, base_device::DEVICE_GPU>&);
 template Psi<std::complex<double>, base_device::DEVICE_GPU>::Psi(
     const Psi<std::complex<double>, base_device::DEVICE_CPU>&);
 template Psi<std::complex<float>, base_device::DEVICE_GPU>::Psi(

source/source_psi/psi.h

@@ -48,49 +48,7 @@ class Psi
     // Constructor 2-2: initialize a new psi from the given psi_in with a different class template
     // in this case, psi_in may have a different device type.
     template <typename T_in, typename Device_in = Device>
-    Psi(const Psi<T_in, Device_in>& psi_in)
-    {
-
-        this->ngk = psi_in.get_ngk_pointer();
-        this->nk = psi_in.get_nk();
-        this->nbands = psi_in.get_nbands();
-        this->nbasis = psi_in.get_nbasis();
-        this->current_k = psi_in.get_current_k();
-        this->current_b = psi_in.get_current_b();
-        this->k_first = psi_in.get_k_first();
-        // this function will copy psi_in.psi to this->psi no matter the device types of each other.
-
-        this->resize(psi_in.get_nk(), psi_in.get_nbands(), psi_in.get_nbasis());
-
-        // Specifically, if the Device_in type is CPU and the Device type is GPU.
-        // Which means we need to initialize a GPU psi from a given CPU psi.
-        // We first malloc a memory in CPU, then cast the memory from T_in to T in CPU.
-        // Finally, synchronize the memory from CPU to GPU.
-        // This could help to reduce the peak memory usage of device.
-        if (std::is_same<Device, base_device::DEVICE_GPU>::value && std::is_same<Device_in, base_device::DEVICE_CPU>::value)
-        {
-            auto* arr = (T*)malloc(sizeof(T) * psi_in.size());
-            // cast the memory from T_in to T in CPU
-            base_device::memory::cast_memory_op<T, T_in, Device_in, Device_in>()(arr,
-                                                                                psi_in.get_pointer()
-                                                                                    - psi_in.get_psi_bias(),
-                                                                                psi_in.size());
-            // synchronize the memory from CPU to GPU
-            base_device::memory::synchronize_memory_op<T, Device, Device_in>()(this->psi,
-                                                                            arr,
-                                                                            psi_in.size());
-            free(arr);
-        }
-        else
-        {
-            base_device::memory::cast_memory_op<T, T_in, Device, Device_in>()(this->psi,
-                                                                            psi_in.get_pointer() - psi_in.get_psi_bias(),
-                                                                            psi_in.size());
-        }
-        this->psi_bias = psi_in.get_psi_bias();
-        this->current_nbasis = psi_in.get_current_nbas();
-        this->psi_current = this->psi + psi_in.get_psi_bias();
-    }
+    Psi(const Psi<T_in, Device_in>& psi_in);
 
     // Constructor 3-1: 2D Psi version
     // used in hsolver-pw function pointer and somewhere.