add check and update code format in exx (#6244) (#6255)

linpeize · PeizeLin · web-flow · commit 9d78d905569b · 2025-06-01T10:51:43.000+08:00
* fix bug and update code format in exx

* Fix bug in Exx_LRI_Interface. Change &amp;&amp; to ||

* update exx in ESolver_KS_LCAO and FORCE_STRESS

* update runtime check in Exx_LRI_Interface

* move exx_lri_double from ESolver_KS_LCAO to Exx_LRI_Interface

---------


Conflicts:
	source/module_ri/Exx_LRI_interface.hpp

Co-authored-by: linpz &lt;linpz@mail.ustc.edu.cn&gt;
diff --git a/source/module_esolver/esolver_ks_lcao.cpp b/source/module_esolver/esolver_ks_lcao.cpp
@@ -83,13 +83,11 @@ ESolver_KS_LCAO<TK, TR>::ESolver_KS_LCAO()
     //  because some members like two_level_step are used outside if(cal_exx)
     if (GlobalC::exx_info.info_ri.real_number)
     {
-        this->exx_lri_double = std::make_shared<Exx_LRI<double>>(GlobalC::exx_info.info_ri);
-        this->exd = std::make_shared<Exx_LRI_Interface<TK, double>>(exx_lri_double);
+        this->exd = std::make_shared<Exx_LRI_Interface<TK, double>>(GlobalC::exx_info.info_ri);
     }
     else
     {
-        this->exx_lri_complex = std::make_shared<Exx_LRI<std::complex<double>>>(GlobalC::exx_info.info_ri);
-        this->exc = std::make_shared<Exx_LRI_Interface<TK, std::complex<double>>>(exx_lri_complex);
+        this->exc = std::make_shared<Exx_LRI_Interface<TK, std::complex<double>>>(GlobalC::exx_info.info_ri);
     }
 #endif
 }
@@ -198,12 +196,12 @@ void ESolver_KS_LCAO<TK, TR>::before_all_runners(UnitCell& ucell, const Input_pa
             // initialize 2-center radial tables for EXX-LRI
             if (GlobalC::exx_info.info_ri.real_number)
             {
-                this->exx_lri_double->init(MPI_COMM_WORLD, ucell, this->kv, orb_);
+                this->exd->init(MPI_COMM_WORLD, ucell, this->kv, orb_);
                 this->exd->exx_before_all_runners(this->kv, ucell, this->pv);
             }
             else
             {
-                this->exx_lri_complex->init(MPI_COMM_WORLD, ucell, this->kv, orb_);
+                this->exc->init(MPI_COMM_WORLD, ucell, this->kv, orb_);
                 this->exc->exx_before_all_runners(this->kv, ucell, this->pv);
             }
         }
@@ -351,8 +349,8 @@ void ESolver_KS_LCAO<TK, TR>::cal_force(UnitCell& ucell, ModuleBase::matrix& for
                        this->ld,
 #endif
 #ifdef __EXX
-                       *this->exx_lri_double,
-                       *this->exx_lri_complex,
+                       *this->exd,
+                       *this->exc,
 #endif
                        &ucell.symm);
 
@@ -461,8 +459,8 @@ void ESolver_KS_LCAO<TK, TR>::after_all_runners(UnitCell& ucell)
                                     this->gd
 #ifdef __EXX
                                     ,
-                                    this->exx_lri_double ? &this->exx_lri_double->Hexxs : nullptr,
-                                    this->exx_lri_complex ? &this->exx_lri_complex->Hexxs : nullptr
+                                    this->exd ? &this->exd->get_Hexxs() : nullptr,
+                                    this->exc ? &this->exc->get_Hexxs() : nullptr
 #endif
         );
     }
@@ -484,8 +482,8 @@ void ESolver_KS_LCAO<TK, TR>::after_all_runners(UnitCell& ucell)
                                       this->gd
 #ifdef __EXX
                                       ,
-                                      this->exx_lri_double ? &this->exx_lri_double->Hexxs : nullptr,
-                                      this->exx_lri_complex ? &this->exx_lri_complex->Hexxs : nullptr
+                                      this->exd ? &this->exd->get_Hexxs() : nullptr,
+                                      this->exc ? &this->exc->get_Hexxs() : nullptr
 #endif
         );
     }
@@ -514,8 +512,8 @@ void ESolver_KS_LCAO<TK, TR>::after_all_runners(UnitCell& ucell)
                                             this->two_center_bundle_
 #ifdef __EXX
                                             ,
-                                            this->exx_lri_double ? &this->exx_lri_double->Hexxs : nullptr,
-                                            this->exx_lri_complex ? &this->exx_lri_complex->Hexxs : nullptr
+                                            this->exd ? &this->exd->get_Hexxs() : nullptr,
+                                            this->exc ? &this->exc->get_Hexxs() : nullptr
 #endif
         );
     }
diff --git a/source/module_esolver/esolver_ks_lcao.h b/source/module_esolver/esolver_ks_lcao.h
@@ -116,8 +116,6 @@ class ESolver_KS_LCAO : public ESolver_KS<TK>
 #ifdef __EXX
     std::shared_ptr<Exx_LRI_Interface<TK, double>> exd = nullptr;
     std::shared_ptr<Exx_LRI_Interface<TK, std::complex<double>>> exc = nullptr;
-    std::shared_ptr<Exx_LRI<double>> exx_lri_double = nullptr;
-    std::shared_ptr<Exx_LRI<std::complex<double>>> exx_lri_complex = nullptr;
 #endif
 
     friend class LR::ESolver_LR<double, double>;
diff --git a/source/module_esolver/lcao_before_scf.cpp b/source/module_esolver/lcao_before_scf.cpp
@@ -159,8 +159,8 @@ void ESolver_KS_LCAO<TK, TR>::before_scf(UnitCell& ucell, const int istep)
             ,
             istep,
             GlobalC::exx_info.info_ri.real_number ? &this->exd->two_level_step : &this->exc->two_level_step,
-            GlobalC::exx_info.info_ri.real_number ? &exx_lri_double->Hexxs : nullptr,
-            GlobalC::exx_info.info_ri.real_number ? nullptr : &exx_lri_complex->Hexxs
+            GlobalC::exx_info.info_ri.real_number ? &this->exd->get_Hexxs() : nullptr,
+            GlobalC::exx_info.info_ri.real_number ? nullptr : &this->exc->get_Hexxs()
 #endif
         );
     }
diff --git a/source/module_esolver/lcao_others.cpp b/source/module_esolver/lcao_others.cpp
@@ -217,8 +217,8 @@ void ESolver_KS_LCAO<TK, TR>::others(UnitCell& ucell, const int istep)
             ,
             istep,
             GlobalC::exx_info.info_ri.real_number ? &this->exd->two_level_step : &this->exc->two_level_step,
-            GlobalC::exx_info.info_ri.real_number ? &exx_lri_double->Hexxs : nullptr,
-            GlobalC::exx_info.info_ri.real_number ? nullptr : &exx_lri_complex->Hexxs
+            GlobalC::exx_info.info_ri.real_number ? &this->exd->get_Hexxs() : nullptr,
+            GlobalC::exx_info.info_ri.real_number ? nullptr : &this->exc->get_Hexxs()
 #endif
         );
     }
diff --git a/source/module_hamilt_lcao/hamilt_lcaodft/FORCE_STRESS.cpp b/source/module_hamilt_lcao/hamilt_lcaodft/FORCE_STRESS.cpp
@@ -55,8 +55,8 @@ void Force_Stress_LCAO<T>::getForceStress(UnitCell& ucell,
                                           LCAO_Deepks<T>& ld,
 #endif
 #ifdef __EXX
-                                          Exx_LRI<double>& exx_lri_double,
-                                          Exx_LRI<std::complex<double>>& exx_lri_complex,
+                                          Exx_LRI_Interface<T, double>& exd,
+                                          Exx_LRI_Interface<T, std::complex<double>>& exc,
 #endif
                                           ModuleSymmetry::Symmetry* symm)
 {
@@ -377,26 +377,26 @@ void Force_Stress_LCAO<T>::getForceStress(UnitCell& ucell,
         {
             if (GlobalC::exx_info.info_ri.real_number)
             {
-                exx_lri_double.cal_exx_force(ucell.nat);
-                force_exx = GlobalC::exx_info.info_global.hybrid_alpha * exx_lri_double.force_exx;
+                exd.cal_exx_force(ucell.nat);
+                force_exx = GlobalC::exx_info.info_global.hybrid_alpha * exd.get_force();
             }
             else
             {
-                exx_lri_complex.cal_exx_force(ucell.nat);
-                force_exx = GlobalC::exx_info.info_global.hybrid_alpha * exx_lri_complex.force_exx;
+                exc.cal_exx_force(ucell.nat);
+                force_exx = GlobalC::exx_info.info_global.hybrid_alpha * exc.get_force();
             }
         }
         if (isstress)
         {
             if (GlobalC::exx_info.info_ri.real_number)
             {
-                exx_lri_double.cal_exx_stress(ucell.omega, ucell.lat0);
-                stress_exx = GlobalC::exx_info.info_global.hybrid_alpha * exx_lri_double.stress_exx;
+                exd.cal_exx_stress(ucell.omega, ucell.lat0);
+                stress_exx = GlobalC::exx_info.info_global.hybrid_alpha * exd.get_stress();
             }
             else
             {
-                exx_lri_complex.cal_exx_stress(ucell.omega, ucell.lat0);
-                stress_exx = GlobalC::exx_info.info_global.hybrid_alpha * exx_lri_complex.stress_exx;
+                exc.cal_exx_stress(ucell.omega, ucell.lat0);
+                stress_exx = GlobalC::exx_info.info_global.hybrid_alpha * exc.get_stress();
             }
         }
     }
diff --git a/source/module_hamilt_lcao/hamilt_lcaodft/FORCE_STRESS.h b/source/module_hamilt_lcao/hamilt_lcaodft/FORCE_STRESS.h
@@ -11,7 +11,7 @@
 #include "module_io/input_conv.h"
 #include "module_psi/psi.h"
 #ifdef __EXX
-#include "module_ri/Exx_LRI.h"
+#include "module_ri/Exx_LRI_interface.h"
 #endif
 #include "force_stress_arrays.h"
 #include "module_hamilt_lcao/module_gint/gint_gamma.h"
@@ -53,8 +53,8 @@ class Force_Stress_LCAO
                         LCAO_Deepks<T>& ld,
 #endif
 #ifdef __EXX
-                        Exx_LRI<double>& exx_lri_double,
-                        Exx_LRI<std::complex<double>>& exx_lri_complex,
+                        Exx_LRI_Interface<T, double>& exd,
+                        Exx_LRI_Interface<T, std::complex<double>>& exc,
 #endif
                         ModuleSymmetry::Symmetry* symm);
 
diff --git a/source/module_lr/esolver_lrtd_lcao.cpp b/source/module_lr/esolver_lrtd_lcao.cpp
@@ -272,10 +272,10 @@ LR::ESolver_LR<T, TR>::ESolver_LR(ModuleESolver::ESolver_KS_LCAO<T, TR>&& ks_sol
     {
         // if the same kernel is calculated in the esolver_ks, move it
         std::string dft_functional = LR_Util::tolower(input.dft_functional);
-        if (ks_sol.exx_lri_double && std::is_same<T, double>::value && xc_kernel == dft_functional) {
-            this->move_exx_lri(ks_sol.exx_lri_double);
-        } else if (ks_sol.exx_lri_complex && std::is_same<T, std::complex<double>>::value && xc_kernel == dft_functional) {
-            this->move_exx_lri(ks_sol.exx_lri_complex);
+        if (ks_sol.exd && std::is_same<T, double>::value && xc_kernel == dft_functional) {
+            this->move_exx_lri(ks_sol.exd->exx_ptr);
+        } else if (ks_sol.exc && std::is_same<T, std::complex<double>>::value && xc_kernel == dft_functional) {
+            this->move_exx_lri(ks_sol.exc->exx_ptr);
         } else    // construct C, V from scratch
         {
             // set ccp_type according to the xc_kernel
diff --git a/source/module_ri/Exx_LRI.h b/source/module_ri/Exx_LRI.h
@@ -21,21 +21,21 @@
 #include "module_exx_symmetry/symmetry_rotation.h"
 
 	class Parallel_Orbitals;
-	
+
 	template<typename T, typename Tdata>
 	class RPA_LRI;
 
 	template<typename T, typename Tdata>
 	class Exx_LRI_Interface;
 
-    namespace LR
-    {
-        template<typename T, typename TR>
-        class ESolver_LR;
+	namespace LR
+	{
+		template<typename T, typename TR>
+		class ESolver_LR;
 
-        template<typename T>
-        class OperatorLREXX;
-    }
+		template<typename T>
+		class OperatorLREXX;
+	}
 
 template<typename Tdata>
 class Exx_LRI
@@ -49,37 +49,39 @@ class Exx_LRI
 	using TatomR = std::array<double,Ndim>;		// tmp
 
 public:
-    Exx_LRI(const Exx_Info::Exx_Info_RI& info_in) :info(info_in) {}
-    Exx_LRI operator=(const Exx_LRI&) = delete;
-    Exx_LRI operator=(Exx_LRI&&);
-
-    void reset_Cs(const std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>& Cs_in) { this->exx_lri.set_Cs(Cs_in, this->info.C_threshold); }
-    void reset_Vs(const std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>& Vs_in) { this->exx_lri.set_Vs(Vs_in, this->info.V_threshold); }
-
-	void init(const MPI_Comm &mpi_comm_in, 
-			  const UnitCell &ucell,
-			  const K_Vectors &kv_in, 
-			  const LCAO_Orbitals& orb);
-	void cal_exx_force(const int& nat);
-    void cal_exx_stress(const double& omega, const double& lat0);
+	Exx_LRI(const Exx_Info::Exx_Info_RI& info_in) :info(info_in) {}
+	Exx_LRI operator=(const Exx_LRI&) = delete;
+	Exx_LRI operator=(Exx_LRI&&);
+
+	void init(
+		const MPI_Comm &mpi_comm_in,
+		const UnitCell &ucell,
+		const K_Vectors &kv_in,
+		const LCAO_Orbitals& orb);
 	void cal_exx_ions(const UnitCell& ucell, const bool write_cv = false);
-    void cal_exx_elec(const std::vector<std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>>& Ds,
+	void cal_exx_elec(
+		const std::vector<std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>>& Ds,
 		const UnitCell& ucell,
-        const Parallel_Orbitals& pv,
-        const ModuleSymmetry::Symmetry_rotation* p_symrot = nullptr);
-    std::vector<std::vector<int>> get_abfs_nchis() const;
+		const Parallel_Orbitals& pv,
+		const ModuleSymmetry::Symmetry_rotation* p_symrot = nullptr);
+	void cal_exx_force(const int& nat);
+	void cal_exx_stress(const double& omega, const double& lat0);
+
+	void reset_Cs(const std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>& Cs_in) { this->exx_lri.set_Cs(Cs_in, this->info.C_threshold); }
+	void reset_Vs(const std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>& Vs_in) { this->exx_lri.set_Vs(Vs_in, this->info.V_threshold); }
+	//std::vector<std::vector<int>> get_abfs_nchis() const;
 
 	std::vector< std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>> Hexxs;
-    double Eexx;
+	double Eexx;
 	ModuleBase::matrix force_exx;
 	ModuleBase::matrix stress_exx;
-    
+
 
 private:
 	const Exx_Info::Exx_Info_RI &info;
 	MPI_Comm mpi_comm;
 	const K_Vectors *p_kv = nullptr;
-    std::vector<double> orb_cutoff_;
+	std::vector<double> orb_cutoff_;
 
 	std::vector<std::vector<std::vector<Numerical_Orbital_Lm>>> lcaos;
 	std::vector<std::vector<std::vector<Numerical_Orbital_Lm>>> abfs;
@@ -89,16 +91,16 @@ class Exx_LRI
 	RI::Exx<TA,Tcell,Ndim,Tdata> exx_lri;
 
 	void post_process_Hexx( std::map<TA, std::map<TAC, RI::Tensor<Tdata>>> &Hexxs_io ) const;
-    double post_process_Eexx(const double& Eexx_in) const;
+	double post_process_Eexx(const double& Eexx_in) const;
 
 	friend class RPA_LRI<double, Tdata>;
 	friend class RPA_LRI<std::complex<double>, Tdata>;
 	friend class Exx_LRI_Interface<double, Tdata>;
 	friend class Exx_LRI_Interface<std::complex<double>, Tdata>;
-    friend class LR::ESolver_LR<double, double>;
-    friend class LR::ESolver_LR<std::complex<double>, double>;
-    friend class LR::OperatorLREXX<double>;
-    friend class LR::OperatorLREXX<std::complex<double>>;
+	friend class LR::ESolver_LR<double, double>;
+	friend class LR::ESolver_LR<std::complex<double>, double>;
+	friend class LR::OperatorLREXX<double>;
+	friend class LR::OperatorLREXX<std::complex<double>>;
 };
 
 #include "Exx_LRI.hpp"
diff --git a/source/module_ri/Exx_LRI.hpp b/source/module_ri/Exx_LRI.hpp
@@ -26,9 +26,9 @@
 #include <string>
 
 template<typename Tdata>
-void Exx_LRI<Tdata>::init(const MPI_Comm &mpi_comm_in, 
+void Exx_LRI<Tdata>::init(const MPI_Comm &mpi_comm_in,
 						  const UnitCell &ucell,
-						  const K_Vectors &kv_in, 
+						  const K_Vectors &kv_in,
 						  const LCAO_Orbitals& orb)
 {
 	ModuleBase::TITLE("Exx_LRI","init");
@@ -130,7 +130,7 @@ void Exx_LRI<Tdata>::cal_exx_ions(const UnitCell& ucell,
 	this->exx_lri.set_parallel(this->mpi_comm, atoms_pos, latvec, period);
 
 	// std::max(3) for gamma_only, list_A2 should contain cell {-1,0,1}. In the future distribute will be neighbour.
-	const std::array<Tcell,Ndim> period_Vs = LRI_CV_Tools::cal_latvec_range<Tcell>(1+this->info.ccp_rmesh_times, ucell, orb_cutoff_);	
+	const std::array<Tcell,Ndim> period_Vs = LRI_CV_Tools::cal_latvec_range<Tcell>(1+this->info.ccp_rmesh_times, ucell, orb_cutoff_);
 	const std::pair<std::vector<TA>, std::vector<std::vector<std::pair<TA,std::array<Tcell,Ndim>>>>>
 		list_As_Vs = RI::Distribute_Equally::distribute_atoms_periods(this->mpi_comm, atoms, period_Vs, 2, false);
 
@@ -237,7 +237,7 @@ void Exx_LRI<Tdata>::cal_exx_elec(const std::vector<std::map<TA, std::map<TAC, R
 	}
 	this->Eexx = post_process_Eexx(this->Eexx);
 	this->exx_lri.set_symmetry(false, {});
-	ModuleBase::timer::tick("Exx_LRI", "cal_exx_elec");	
+	ModuleBase::timer::tick("Exx_LRI", "cal_exx_elec");
 }
 
 template<typename Tdata>
@@ -283,11 +283,6 @@ void Exx_LRI<Tdata>::cal_exx_force(const int& nat)
 	ModuleBase::TITLE("Exx_LRI","cal_exx_force");
 	ModuleBase::timer::tick("Exx_LRI", "cal_exx_force");
 
-    if (!this->exx_lri.flag_finish.D)
-    {
-        ModuleBase::WARNING_QUIT("Force_Stress_LCAO", "Cannot calculate EXX force when the first PBE loop is not converged.");
-    }
-
 	this->force_exx.create(nat, Ndim);
 	for(int is=0; is<PARAM.inp.nspin; ++is)
 	{
@@ -328,6 +323,7 @@ void Exx_LRI<Tdata>::cal_exx_stress(const double& omega, const double& lat0)
 	ModuleBase::timer::tick("Exx_LRI", "cal_exx_stress");
 }
 
+/*
 template<typename Tdata>
 std::vector<std::vector<int>> Exx_LRI<Tdata>::get_abfs_nchis() const
 {
@@ -341,5 +337,6 @@ std::vector<std::vector<int>> Exx_LRI<Tdata>::get_abfs_nchis() const
 	}
 	return abfs_nchis;
 }
+*/
 
 #endif
diff --git a/source/module_ri/Exx_LRI_interface.h b/source/module_ri/Exx_LRI_interface.h
diff --git a/source/module_ri/Exx_LRI_interface.hpp b/source/module_ri/Exx_LRI_interface.hpp
diff --git a/source/module_ri/Mix_Matrix.cpp b/source/module_ri/Mix_Matrix.cpp

Original file line number	Diff line number	Diff line change
`@@ -83,13 +83,11 @@ ESolver_KS_LCAO<TK, TR>::ESolver_KS_LCAO()`
`83`	`83`	`// because some members like two_level_step are used outside if(cal_exx)`
`84`	`84`	`if (GlobalC::exx_info.info_ri.real_number)`
`85`	`85`	`{`
`86`		`- this->exx_lri_double = std::make_shared<Exx_LRI<double>>(GlobalC::exx_info.info_ri);`
`87`		`- this->exd = std::make_shared<Exx_LRI_Interface<TK, double>>(exx_lri_double);`
	`86`	`+ this->exd = std::make_shared<Exx_LRI_Interface<TK, double>>(GlobalC::exx_info.info_ri);`
`88`	`87`	`}`
`89`	`88`	`else`
`90`	`89`	`{`
`91`		`- this->exx_lri_complex = std::make_shared<Exx_LRI<std::complex<double>>>(GlobalC::exx_info.info_ri);`
`92`		`- this->exc = std::make_shared<Exx_LRI_Interface<TK, std::complex<double>>>(exx_lri_complex);`
	`90`	`+ this->exc = std::make_shared<Exx_LRI_Interface<TK, std::complex<double>>>(GlobalC::exx_info.info_ri);`
`93`	`91`	`}`
`94`	`92`	`#endif`
`95`	`93`	`}`
`@@ -198,12 +196,12 @@ void ESolver_KS_LCAO<TK, TR>::before_all_runners(UnitCell& ucell, const Input_pa`
`198`	`196`	`// initialize 2-center radial tables for EXX-LRI`
`199`	`197`	`if (GlobalC::exx_info.info_ri.real_number)`
`200`	`198`	`{`
`201`		`- this->exx_lri_double->init(MPI_COMM_WORLD, ucell, this->kv, orb_);`
	`199`	`+ this->exd->init(MPI_COMM_WORLD, ucell, this->kv, orb_);`
`202`	`200`	`this->exd->exx_before_all_runners(this->kv, ucell, this->pv);`
`203`	`201`	`}`
`204`	`202`	`else`
`205`	`203`	`{`
`206`		`- this->exx_lri_complex->init(MPI_COMM_WORLD, ucell, this->kv, orb_);`
	`204`	`+ this->exc->init(MPI_COMM_WORLD, ucell, this->kv, orb_);`
`207`	`205`	`this->exc->exx_before_all_runners(this->kv, ucell, this->pv);`
`208`	`206`	`}`
`209`	`207`	`}`
`@@ -351,8 +349,8 @@ void ESolver_KS_LCAO<TK, TR>::cal_force(UnitCell& ucell, ModuleBase::matrix& for`
`351`	`349`	`this->ld,`
`352`	`350`	`#endif`
`353`	`351`	`#ifdef __EXX`
`354`		`- *this->exx_lri_double,`
`355`		`- *this->exx_lri_complex,`
	`352`	`+ *this->exd,`
	`353`	`+ *this->exc,`
`356`	`354`	`#endif`
`357`	`355`	`&ucell.symm);`
`358`	`356`
`@@ -461,8 +459,8 @@ void ESolver_KS_LCAO<TK, TR>::after_all_runners(UnitCell& ucell)`
`461`	`459`	`this->gd`
`462`	`460`	`#ifdef __EXX`
`463`	`461`	`,`
`464`		`- this->exx_lri_double ? &this->exx_lri_double->Hexxs : nullptr,`
`465`		`- this->exx_lri_complex ? &this->exx_lri_complex->Hexxs : nullptr`
	`462`	`+ this->exd ? &this->exd->get_Hexxs() : nullptr,`
	`463`	`+ this->exc ? &this->exc->get_Hexxs() : nullptr`
`466`	`464`	`#endif`
`467`	`465`	`);`
`468`	`466`	`}`
`@@ -484,8 +482,8 @@ void ESolver_KS_LCAO<TK, TR>::after_all_runners(UnitCell& ucell)`
`484`	`482`	`this->gd`
`485`	`483`	`#ifdef __EXX`
`486`	`484`	`,`
`487`		`- this->exx_lri_double ? &this->exx_lri_double->Hexxs : nullptr,`
`488`		`- this->exx_lri_complex ? &this->exx_lri_complex->Hexxs : nullptr`
	`485`	`+ this->exd ? &this->exd->get_Hexxs() : nullptr,`
	`486`	`+ this->exc ? &this->exc->get_Hexxs() : nullptr`
`489`	`487`	`#endif`
`490`	`488`	`);`
`491`	`489`	`}`
`@@ -514,8 +512,8 @@ void ESolver_KS_LCAO<TK, TR>::after_all_runners(UnitCell& ucell)`
`514`	`512`	`this->two_center_bundle_`
`515`	`513`	`#ifdef __EXX`
`516`	`514`	`,`
`517`		`- this->exx_lri_double ? &this->exx_lri_double->Hexxs : nullptr,`
`518`		`- this->exx_lri_complex ? &this->exx_lri_complex->Hexxs : nullptr`
	`515`	`+ this->exd ? &this->exd->get_Hexxs() : nullptr,`
	`516`	`+ this->exc ? &this->exc->get_Hexxs() : nullptr`
`519`	`517`	`#endif`
`520`	`518`	`);`
`521`	`519`	`}`
Original file line number	Diff line number	Diff line change
`@@ -159,8 +159,8 @@ void ESolver_KS_LCAO<TK, TR>::before_scf(UnitCell& ucell, const int istep)`
`159`	`159`	`,`
`160`	`160`	`istep,`
`161`	`161`	`GlobalC::exx_info.info_ri.real_number ? &this->exd->two_level_step : &this->exc->two_level_step,`
`162`		`- GlobalC::exx_info.info_ri.real_number ? &exx_lri_double->Hexxs : nullptr,`
`163`		`- GlobalC::exx_info.info_ri.real_number ? nullptr : &exx_lri_complex->Hexxs`
	`162`	`+ GlobalC::exx_info.info_ri.real_number ? &this->exd->get_Hexxs() : nullptr,`
	`163`	`+ GlobalC::exx_info.info_ri.real_number ? nullptr : &this->exc->get_Hexxs()`
`164`	`164`	`#endif`
`165`	`165`	`);`
`166`	`166`	`}`
Original file line number	Diff line number	Diff line change
`@@ -217,8 +217,8 @@ void ESolver_KS_LCAO<TK, TR>::others(UnitCell& ucell, const int istep)`
`217`	`217`	`,`
`218`	`218`	`istep,`
`219`	`219`	`GlobalC::exx_info.info_ri.real_number ? &this->exd->two_level_step : &this->exc->two_level_step,`
`220`		`- GlobalC::exx_info.info_ri.real_number ? &exx_lri_double->Hexxs : nullptr,`
`221`		`- GlobalC::exx_info.info_ri.real_number ? nullptr : &exx_lri_complex->Hexxs`
	`220`	`+ GlobalC::exx_info.info_ri.real_number ? &this->exd->get_Hexxs() : nullptr,`
	`221`	`+ GlobalC::exx_info.info_ri.real_number ? nullptr : &this->exc->get_Hexxs()`
`222`	`222`	`#endif`
`223`	`223`	`);`
`224`	`224`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,8 +55,8 @@ void Force_Stress_LCAO<T>::getForceStress(UnitCell& ucell,`
`55`	`55`	`LCAO_Deepks<T>& ld,`
`56`	`56`	`#endif`
`57`	`57`	`#ifdef __EXX`
`58`		`- Exx_LRI<double>& exx_lri_double,`
`59`		`- Exx_LRI<std::complex<double>>& exx_lri_complex,`
	`58`	`+ Exx_LRI_Interface<T, double>& exd,`
	`59`	`+ Exx_LRI_Interface<T, std::complex<double>>& exc,`
`60`	`60`	`#endif`
`61`	`61`	`ModuleSymmetry::Symmetry* symm)`
`62`	`62`	`{`
`@@ -377,26 +377,26 @@ void Force_Stress_LCAO<T>::getForceStress(UnitCell& ucell,`
`377`	`377`	`{`
`378`	`378`	`if (GlobalC::exx_info.info_ri.real_number)`
`379`	`379`	`{`
`380`		`- exx_lri_double.cal_exx_force(ucell.nat);`
`381`		`- force_exx = GlobalC::exx_info.info_global.hybrid_alpha * exx_lri_double.force_exx;`
	`380`	`+ exd.cal_exx_force(ucell.nat);`
	`381`	`+ force_exx = GlobalC::exx_info.info_global.hybrid_alpha * exd.get_force();`
`382`	`382`	`}`
`383`	`383`	`else`
`384`	`384`	`{`
`385`		`- exx_lri_complex.cal_exx_force(ucell.nat);`
`386`		`- force_exx = GlobalC::exx_info.info_global.hybrid_alpha * exx_lri_complex.force_exx;`
	`385`	`+ exc.cal_exx_force(ucell.nat);`
	`386`	`+ force_exx = GlobalC::exx_info.info_global.hybrid_alpha * exc.get_force();`
`387`	`387`	`}`
`388`	`388`	`}`
`389`	`389`	`if (isstress)`
`390`	`390`	`{`
`391`	`391`	`if (GlobalC::exx_info.info_ri.real_number)`
`392`	`392`	`{`
`393`		`- exx_lri_double.cal_exx_stress(ucell.omega, ucell.lat0);`
`394`		`- stress_exx = GlobalC::exx_info.info_global.hybrid_alpha * exx_lri_double.stress_exx;`
	`393`	`+ exd.cal_exx_stress(ucell.omega, ucell.lat0);`
	`394`	`+ stress_exx = GlobalC::exx_info.info_global.hybrid_alpha * exd.get_stress();`
`395`	`395`	`}`
`396`	`396`	`else`
`397`	`397`	`{`
`398`		`- exx_lri_complex.cal_exx_stress(ucell.omega, ucell.lat0);`
`399`		`- stress_exx = GlobalC::exx_info.info_global.hybrid_alpha * exx_lri_complex.stress_exx;`
	`398`	`+ exc.cal_exx_stress(ucell.omega, ucell.lat0);`
	`399`	`+ stress_exx = GlobalC::exx_info.info_global.hybrid_alpha * exc.get_stress();`
`400`	`400`	`}`
`401`	`401`	`}`
`402`	`402`	`}`