change ucell in dftu_occup

A-006 · A-006 · commit 05d089c7e099 · 2024-12-01T10:00:35.000+08:00
diff --git a/source/module_esolver/esolver_ks_lcao.cpp b/source/module_esolver/esolver_ks_lcao.cpp
@@ -881,7 +881,7 @@ void ESolver_KS_LCAO<TK, TR>::iter_finish(UnitCell& ucell, const int istep, int&
             {
                 const std::vector<std::vector<TK>>& tmp_dm
                     = dynamic_cast<elecstate::ElecStateLCAO<TK>*>(this->pelec)->get_DM()->get_DMK_vector();
-                ModuleDFTU::dftu_cal_occup_m(iter, tmp_dm, this->kv, this->p_chgmix->get_mixing_beta(), this->p_hamilt);
+                ModuleDFTU::dftu_cal_occup_m(iter, ucell,tmp_dm, this->kv, this->p_chgmix->get_mixing_beta(), this->p_hamilt);
             }
             GlobalC::dftu.cal_energy_correction(ucell,istep);
         }
diff --git a/source/module_hamilt_lcao/module_dftu/dftu.cpp b/source/module_hamilt_lcao/module_dftu/dftu.cpp
@@ -185,7 +185,7 @@ void DFTU::init(UnitCell& cell, // unitcell class
 #endif
 
         initialed_locale = true;
-        this->copy_locale();
+        this->copy_locale(cell);
     }
     else
     {
@@ -201,7 +201,7 @@ void DFTU::init(UnitCell& cell, // unitcell class
         }
         else
         {
-            this->zero_locale();
+            this->zero_locale(cell);
         }
     }
 
@@ -423,22 +423,24 @@ const hamilt::HContainer<double>* DFTU::get_dmr(int ispin) const
 //! dftu occupation matrix for gamma only using dm(double)
 template <>
 void dftu_cal_occup_m(const int iter,
+                      const UnitCell& ucell,
                       const std::vector<std::vector<double>>& dm,
                       const K_Vectors& kv,
                       const double& mixing_beta,
                       hamilt::Hamilt<double>* p_ham)
 {
-    GlobalC::dftu.cal_occup_m_gamma(iter, dm, mixing_beta, p_ham);
+    GlobalC::dftu.cal_occup_m_gamma(iter, ucell ,dm, mixing_beta, p_ham);
 }
 
 //! dftu occupation matrix for multiple k-points using dm(complex)
 template <>
 void dftu_cal_occup_m(const int iter,
+                      const UnitCell& ucell,
                       const std::vector<std::vector<std::complex<double>>>& dm,
                       const K_Vectors& kv,
                       const double& mixing_beta,
                       hamilt::Hamilt<std::complex<double>>* p_ham)
 {
-    GlobalC::dftu.cal_occup_m_k(iter, dm, kv, mixing_beta, p_ham);
+    GlobalC::dftu.cal_occup_m_k(iter,ucell, dm, kv, mixing_beta, p_ham);
 }
 } // namespace ModuleDFTU
diff --git a/source/module_hamilt_lcao/module_dftu/dftu.h b/source/module_hamilt_lcao/module_dftu/dftu.h
@@ -89,16 +89,25 @@ class DFTU
     //=============================================================
   public:
     // calculate the local occupation number matrix
-    void cal_occup_m_k(const int iter, const std::vector<std::vector<std::complex<double>>>& dm_k, const K_Vectors& kv, const double& mixing_beta, hamilt::Hamilt<std::complex<double>>* p_ham);
-    void cal_occup_m_gamma(const int iter, const std::vector<std::vector<double>>& dm_gamma, const double& mixing_beta, hamilt::Hamilt<double>* p_ham);
+    void cal_occup_m_k(const int iter, 
+                       const UnitCell& ucell,
+                       const std::vector<std::vector<std::complex<double>>>& dm_k, 
+                       const K_Vectors& kv, 
+                       const double& mixing_beta, 
+                       hamilt::Hamilt<std::complex<double>>* p_ham);
+    void cal_occup_m_gamma(const int iter, 
+                           const UnitCell& ucell,
+                           const std::vector<std::vector<double>>& dm_gamma, 
+                           const double& mixing_beta, 
+                           hamilt::Hamilt<double>* p_ham);
 
     // dftu can be calculated only after locale has been initialed
     bool initialed_locale = false;
 
   private:
-    void copy_locale();
-    void zero_locale();
-    void mix_locale(const double& mixing_beta);
+    void copy_locale(const UnitCell& ucell);
+    void zero_locale(const UnitCell& ucell);
+    void mix_locale(const UnitCell& ucell,const double& mixing_beta);
 
 public:
     // local occupancy matrix of the correlated subspace
@@ -270,6 +279,7 @@ class DFTU
 
 template <typename T>
 void dftu_cal_occup_m(const int iter,
+                      const UnitCell& ucell,
                       const std::vector<std::vector<T>>& dm,
                       const K_Vectors& kv,
                       const double& mixing_beta,
diff --git a/source/module_hamilt_lcao/module_dftu/dftu_occup.cpp b/source/module_hamilt_lcao/module_dftu/dftu_occup.cpp
@@ -29,23 +29,23 @@ extern "C"
 
 namespace ModuleDFTU
 {
-void DFTU::copy_locale()
+void DFTU::copy_locale(const UnitCell& ucell)
 {
     ModuleBase::TITLE("DFTU", "copy_locale");
     ModuleBase::timer::tick("DFTU", "copy_locale");
 
-    for (int T = 0; T < GlobalC::ucell.ntype; T++)
+    for (int T = 0; T < ucell.ntype; T++)
     {
         if (orbital_corr[T] == -1)
             continue;
 
-        for (int I = 0; I < GlobalC::ucell.atoms[T].na; I++)
+        for (int I = 0; I < ucell.atoms[T].na; I++)
         {
-            const int iat = GlobalC::ucell.itia2iat(T, I);
+            const int iat = ucell.itia2iat(T, I);
 
-            for (int l = 0; l < GlobalC::ucell.atoms[T].nwl + 1; l++)
+            for (int l = 0; l < ucell.atoms[T].nwl + 1; l++)
             {
-                const int N = GlobalC::ucell.atoms[T].l_nchi[l];
+                const int N = ucell.atoms[T].l_nchi[l];
 
                 for (int n = 0; n < N; n++)
                 {
@@ -65,22 +65,22 @@ void DFTU::copy_locale()
     ModuleBase::timer::tick("DFTU", "copy_locale");
 }
 
-void DFTU::zero_locale()
+void DFTU::zero_locale(const UnitCell& ucell)
 {
     ModuleBase::TITLE("DFTU", "zero_locale");
     ModuleBase::timer::tick("DFTU", "zero_locale");
 
-    for (int T = 0; T < GlobalC::ucell.ntype; T++)
+    for (int T = 0; T < ucell.ntype; T++)
     {
         if (orbital_corr[T] == -1) continue;
 
-        for (int I = 0; I < GlobalC::ucell.atoms[T].na; I++)
+        for (int I = 0; I < ucell.atoms[T].na; I++)
         {
-            const int iat = GlobalC::ucell.itia2iat(T, I);
+            const int iat = ucell.itia2iat(T, I);
 
-            for (int l = 0; l < GlobalC::ucell.atoms[T].nwl + 1; l++)
+            for (int l = 0; l < ucell.atoms[T].nwl + 1; l++)
             {
-                const int N = GlobalC::ucell.atoms[T].l_nchi[l];
+                const int N = ucell.atoms[T].l_nchi[l];
 
                 for (int n = 0; n < N; n++)
                 {
@@ -100,25 +100,26 @@ void DFTU::zero_locale()
     ModuleBase::timer::tick("DFTU", "zero_locale");
 }
 
-void DFTU::mix_locale(const double& mixing_beta)
+void DFTU::mix_locale(const UnitCell& ucell,
+                      const double& mixing_beta)
 {
     ModuleBase::TITLE("DFTU", "mix_locale");
     ModuleBase::timer::tick("DFTU", "mix_locale");
 
     double beta = mixing_beta;
 
-    for (int T = 0; T < GlobalC::ucell.ntype; T++)
+    for (int T = 0; T < ucell.ntype; T++)
     {
         if (orbital_corr[T] == -1)
             continue;
 
-        for (int I = 0; I < GlobalC::ucell.atoms[T].na; I++)
+        for (int I = 0; I < ucell.atoms[T].na; I++)
         {
-            const int iat = GlobalC::ucell.itia2iat(T, I);
+            const int iat = ucell.itia2iat(T, I);
 
-            for (int l = 0; l < GlobalC::ucell.atoms[T].nwl + 1; l++)
+            for (int l = 0; l < ucell.atoms[T].nwl + 1; l++)
             {
-                const int N = GlobalC::ucell.atoms[T].l_nchi[l];
+                const int N = ucell.atoms[T].l_nchi[l];
 
                 for (int n = 0; n < N; n++)
                 {
@@ -139,16 +140,17 @@ void DFTU::mix_locale(const double& mixing_beta)
 }
 
 void DFTU::cal_occup_m_k(const int iter, 
-                        const std::vector<std::vector<std::complex<double>>>& dm_k,
-                        const K_Vectors& kv,
-                        const double& mixing_beta,
-                        hamilt::Hamilt<std::complex<double>>* p_ham)
+                         const UnitCell& ucell,
+                         const std::vector<std::vector<std::complex<double>>>& dm_k,
+                         const K_Vectors& kv,
+                         const double& mixing_beta,
+                         hamilt::Hamilt<std::complex<double>>* p_ham)
 {
     ModuleBase::TITLE("DFTU", "cal_occup_m_k");
     ModuleBase::timer::tick("DFTU", "cal_occup_m_k");
 
-    this->copy_locale();
-    this->zero_locale();
+    this->copy_locale(ucell);
+    this->zero_locale(ucell);
 
     //=================Part 1======================
     // call SCALAPACK routine to calculate the product of the S and density matrix
@@ -196,24 +198,24 @@ void DFTU::cal_occup_m_k(const int iter,
 #endif
 
         const int spin = kv.isk[ik];
-        for (int it = 0; it < GlobalC::ucell.ntype; it++)
+        for (int it = 0; it < ucell.ntype; it++)
         {
-            const int NL = GlobalC::ucell.atoms[it].nwl + 1;
+            const int NL = ucell.atoms[it].nwl + 1;
             const int LC = orbital_corr[it];
 
             if (LC == -1)
                 continue;
 
-            for (int ia = 0; ia < GlobalC::ucell.atoms[it].na; ia++)
+            for (int ia = 0; ia < ucell.atoms[it].na; ia++)
             {
-                const int iat = GlobalC::ucell.itia2iat(it, ia);
+                const int iat = ucell.itia2iat(it, ia);
 
                 for (int l = 0; l < NL; l++)
                 {
                     if (l != orbital_corr[it])
                         continue;
 
-                    const int N = GlobalC::ucell.atoms[it].l_nchi[l];
+                    const int N = ucell.atoms[it].l_nchi[l];
 
                     for (int n = 0; n < N; n++)
                     {
@@ -260,24 +262,24 @@ void DFTU::cal_occup_m_k(const int iter,
         } // end it
     } // ik
 
-    for (int it = 0; it < GlobalC::ucell.ntype; it++)
+    for (int it = 0; it < ucell.ntype; it++)
     {
-        const int NL = GlobalC::ucell.atoms[it].nwl + 1;
+        const int NL = ucell.atoms[it].nwl + 1;
         const int LC = orbital_corr[it];
 
         if (LC == -1)
             continue;
 
-        for (int ia = 0; ia < GlobalC::ucell.atoms[it].na; ia++)
+        for (int ia = 0; ia < ucell.atoms[it].na; ia++)
         {
-            const int iat = GlobalC::ucell.itia2iat(it, ia);
+            const int iat = ucell.itia2iat(it, ia);
 
             for (int l = 0; l < NL; l++)
             {
                 if (l != orbital_corr[it])
                     continue;
 
-                const int N = GlobalC::ucell.atoms[it].l_nchi[l];
+                const int N = ucell.atoms[it].l_nchi[l];
 
                 for (int n = 0; n < N; n++)
                 {
@@ -346,20 +348,24 @@ void DFTU::cal_occup_m_k(const int iter,
 
     if(mixing_dftu && initialed_locale)
     {
-        this->mix_locale(mixing_beta);
+        this->mix_locale(ucell,mixing_beta);
     }
 
     this->initialed_locale = true;
     ModuleBase::timer::tick("DFTU", "cal_occup_m_k");
     return;
 }
 
-void DFTU::cal_occup_m_gamma(const int iter, const std::vector<std::vector<double>> &dm_gamma, const double& mixing_beta, hamilt::Hamilt<double>* p_ham)
+void DFTU::cal_occup_m_gamma(const int iter,
+                             const UnitCell &ucell,
+                             const std::vector<std::vector<double>> &dm_gamma, 
+                             const double& mixing_beta, 
+                             hamilt::Hamilt<double>* p_ham)
 {
     ModuleBase::TITLE("DFTU", "cal_occup_m_gamma");
     ModuleBase::timer::tick("DFTU", "cal_occup_m_gamma");
-    this->copy_locale();
-    this->zero_locale();
+    this->copy_locale(ucell);
+    this->zero_locale(ucell);
 
     //=================Part 1======================
     // call PBLAS routine to calculate the product of the S and density matrix
@@ -396,21 +402,21 @@ void DFTU::cal_occup_m_gamma(const int iter, const std::vector<std::vector<doubl
                 this->paraV->desc);
 #endif
 
-        for (int it = 0; it < GlobalC::ucell.ntype; it++)
+        for (int it = 0; it < ucell.ntype; it++)
         {
-            const int NL = GlobalC::ucell.atoms[it].nwl + 1;
+            const int NL = ucell.atoms[it].nwl + 1;
             if (orbital_corr[it] == -1)
                 continue;
-            for (int ia = 0; ia < GlobalC::ucell.atoms[it].na; ia++)
+            for (int ia = 0; ia < ucell.atoms[it].na; ia++)
             {
-                const int iat = GlobalC::ucell.itia2iat(it, ia);
+                const int iat = ucell.itia2iat(it, ia);
 
                 for (int l = 0; l < NL; l++)
                 {
                     if (l != orbital_corr[it])
                         continue;
 
-                    const int N = GlobalC::ucell.atoms[it].l_nchi[l];
+                    const int N = ucell.atoms[it].l_nchi[l];
 
                     for (int n = 0; n < N; n++)
                     {
@@ -494,7 +500,7 @@ void DFTU::cal_occup_m_gamma(const int iter, const std::vector<std::vector<doubl
 
     if(mixing_dftu && initialed_locale)
     {
-        this->mix_locale(mixing_beta);
+        this->mix_locale(ucell,mixing_beta);
     }
 
     this->initialed_locale = true;

Original file line number	Diff line number	Diff line change
`@@ -881,7 +881,7 @@ void ESolver_KS_LCAO<TK, TR>::iter_finish(UnitCell& ucell, const int istep, int&`
`881`	`881`	`{`
`882`	`882`	`const std::vector<std::vector<TK>>& tmp_dm`
`883`	`883`	`= dynamic_cast<elecstate::ElecStateLCAO<TK>*>(this->pelec)->get_DM()->get_DMK_vector();`
`884`		`- ModuleDFTU::dftu_cal_occup_m(iter, tmp_dm, this->kv, this->p_chgmix->get_mixing_beta(), this->p_hamilt);`
	`884`	`+ ModuleDFTU::dftu_cal_occup_m(iter, ucell,tmp_dm, this->kv, this->p_chgmix->get_mixing_beta(), this->p_hamilt);`
`885`	`885`	`}`
`886`	`886`	`GlobalC::dftu.cal_energy_correction(ucell,istep);`
`887`	`887`	`}`
Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ void DFTU::init(UnitCell& cell, // unitcell class`
`185`	`185`	`#endif`
`186`	`186`
`187`	`187`	`initialed_locale = true;`
`188`		`- this->copy_locale();`
	`188`	`+ this->copy_locale(cell);`
`189`	`189`	`}`
`190`	`190`	`else`
`191`	`191`	`{`
`@@ -201,7 +201,7 @@ void DFTU::init(UnitCell& cell, // unitcell class`
`201`	`201`	`}`
`202`	`202`	`else`
`203`	`203`	`{`
`204`		`- this->zero_locale();`
	`204`	`+ this->zero_locale(cell);`
`205`	`205`	`}`
`206`	`206`	`}`
`207`	`207`
`@@ -423,22 +423,24 @@ const hamilt::HContainer<double>* DFTU::get_dmr(int ispin) const`
`423`	`423`	`//! dftu occupation matrix for gamma only using dm(double)`
`424`	`424`	`template <>`
`425`	`425`	`void dftu_cal_occup_m(const int iter,`
	`426`	`+ const UnitCell& ucell,`
`426`	`427`	`const std::vector<std::vector<double>>& dm,`
`427`	`428`	`const K_Vectors& kv,`
`428`	`429`	`const double& mixing_beta,`
`429`	`430`	`hamilt::Hamilt<double>* p_ham)`
`430`	`431`	`{`
`431`		`- GlobalC::dftu.cal_occup_m_gamma(iter, dm, mixing_beta, p_ham);`
	`432`	`+ GlobalC::dftu.cal_occup_m_gamma(iter, ucell ,dm, mixing_beta, p_ham);`
`432`	`433`	`}`
`433`	`434`
`434`	`435`	`//! dftu occupation matrix for multiple k-points using dm(complex)`
`435`	`436`	`template <>`
`436`	`437`	`void dftu_cal_occup_m(const int iter,`
	`438`	`+ const UnitCell& ucell,`
`437`	`439`	`const std::vector<std::vector<std::complex<double>>>& dm,`
`438`	`440`	`const K_Vectors& kv,`
`439`	`441`	`const double& mixing_beta,`
`440`	`442`	`hamilt::Hamilt<std::complex<double>>* p_ham)`
`441`	`443`	`{`
`442`		`- GlobalC::dftu.cal_occup_m_k(iter, dm, kv, mixing_beta, p_ham);`
	`444`	`+ GlobalC::dftu.cal_occup_m_k(iter,ucell, dm, kv, mixing_beta, p_ham);`
`443`	`445`	`}`
`444`	`446`	`} // namespace ModuleDFTU`
Original file line number	Diff line number	Diff line change
`@@ -29,23 +29,23 @@ extern "C"`
`29`	`29`
`30`	`30`	`namespace ModuleDFTU`
`31`	`31`	`{`
`32`		`-void DFTU::copy_locale()`
	`32`	`+void DFTU::copy_locale(const UnitCell& ucell)`
`33`	`33`	`{`
`34`	`34`	`ModuleBase::TITLE("DFTU", "copy_locale");`
`35`	`35`	`ModuleBase::timer::tick("DFTU", "copy_locale");`
`36`	`36`
`37`		`- for (int T = 0; T < GlobalC::ucell.ntype; T++)`
	`37`	`+ for (int T = 0; T < ucell.ntype; T++)`
`38`	`38`	`{`
`39`	`39`	`if (orbital_corr[T] == -1)`
`40`	`40`	`continue;`
`41`	`41`
`42`		`- for (int I = 0; I < GlobalC::ucell.atoms[T].na; I++)`
	`42`	`+ for (int I = 0; I < ucell.atoms[T].na; I++)`
`43`	`43`	`{`
`44`		`- const int iat = GlobalC::ucell.itia2iat(T, I);`
	`44`	`+ const int iat = ucell.itia2iat(T, I);`
`45`	`45`
`46`		`- for (int l = 0; l < GlobalC::ucell.atoms[T].nwl + 1; l++)`
	`46`	`+ for (int l = 0; l < ucell.atoms[T].nwl + 1; l++)`
`47`	`47`	`{`
`48`		`- const int N = GlobalC::ucell.atoms[T].l_nchi[l];`
	`48`	`+ const int N = ucell.atoms[T].l_nchi[l];`
`49`	`49`
`50`	`50`	`for (int n = 0; n < N; n++)`
`51`	`51`	`{`
`@@ -65,22 +65,22 @@ void DFTU::copy_locale()`
`65`	`65`	`ModuleBase::timer::tick("DFTU", "copy_locale");`
`66`	`66`	`}`
`67`	`67`
`68`		`-void DFTU::zero_locale()`
	`68`	`+void DFTU::zero_locale(const UnitCell& ucell)`
`69`	`69`	`{`
`70`	`70`	`ModuleBase::TITLE("DFTU", "zero_locale");`
`71`	`71`	`ModuleBase::timer::tick("DFTU", "zero_locale");`
`72`	`72`
`73`		`- for (int T = 0; T < GlobalC::ucell.ntype; T++)`
	`73`	`+ for (int T = 0; T < ucell.ntype; T++)`
`74`	`74`	`{`
`75`	`75`	`if (orbital_corr[T] == -1) continue;`
`76`	`76`
`77`		`- for (int I = 0; I < GlobalC::ucell.atoms[T].na; I++)`
	`77`	`+ for (int I = 0; I < ucell.atoms[T].na; I++)`
`78`	`78`	`{`
`79`		`- const int iat = GlobalC::ucell.itia2iat(T, I);`
	`79`	`+ const int iat = ucell.itia2iat(T, I);`
`80`	`80`
`81`		`- for (int l = 0; l < GlobalC::ucell.atoms[T].nwl + 1; l++)`
	`81`	`+ for (int l = 0; l < ucell.atoms[T].nwl + 1; l++)`
`82`	`82`	`{`
`83`		`- const int N = GlobalC::ucell.atoms[T].l_nchi[l];`
	`83`	`+ const int N = ucell.atoms[T].l_nchi[l];`
`84`	`84`
`85`	`85`	`for (int n = 0; n < N; n++)`
`86`	`86`	`{`
`@@ -100,25 +100,26 @@ void DFTU::zero_locale()`
`100`	`100`	`ModuleBase::timer::tick("DFTU", "zero_locale");`
`101`	`101`	`}`
`102`	`102`
`103`		`-void DFTU::mix_locale(const double& mixing_beta)`
	`103`	`+void DFTU::mix_locale(const UnitCell& ucell,`
	`104`	`+ const double& mixing_beta)`
`104`	`105`	`{`
`105`	`106`	`ModuleBase::TITLE("DFTU", "mix_locale");`
`106`	`107`	`ModuleBase::timer::tick("DFTU", "mix_locale");`
`107`	`108`
`108`	`109`	`double beta = mixing_beta;`
`109`	`110`
`110`		`- for (int T = 0; T < GlobalC::ucell.ntype; T++)`
	`111`	`+ for (int T = 0; T < ucell.ntype; T++)`
`111`	`112`	`{`
`112`	`113`	`if (orbital_corr[T] == -1)`
`113`	`114`	`continue;`
`114`	`115`
`115`		`- for (int I = 0; I < GlobalC::ucell.atoms[T].na; I++)`
	`116`	`+ for (int I = 0; I < ucell.atoms[T].na; I++)`
`116`	`117`	`{`
`117`		`- const int iat = GlobalC::ucell.itia2iat(T, I);`
	`118`	`+ const int iat = ucell.itia2iat(T, I);`
`118`	`119`
`119`		`- for (int l = 0; l < GlobalC::ucell.atoms[T].nwl + 1; l++)`
	`120`	`+ for (int l = 0; l < ucell.atoms[T].nwl + 1; l++)`
`120`	`121`	`{`
`121`		`- const int N = GlobalC::ucell.atoms[T].l_nchi[l];`
	`122`	`+ const int N = ucell.atoms[T].l_nchi[l];`
`122`	`123`
`123`	`124`	`for (int n = 0; n < N; n++)`
`124`	`125`	`{`
`@@ -139,16 +140,17 @@ void DFTU::mix_locale(const double& mixing_beta)`
`139`	`140`	`}`
`140`	`141`
`141`	`142`	`void DFTU::cal_occup_m_k(const int iter,`
`142`		`- const std::vector<std::vector<std::complex<double>>>& dm_k,`
`143`		`- const K_Vectors& kv,`
`144`		`- const double& mixing_beta,`
`145`		`- hamilt::Hamilt<std::complex<double>>* p_ham)`
	`143`	`+ const UnitCell& ucell,`
	`144`	`+ const std::vector<std::vector<std::complex<double>>>& dm_k,`
	`145`	`+ const K_Vectors& kv,`
	`146`	`+ const double& mixing_beta,`
	`147`	`+ hamilt::Hamilt<std::complex<double>>* p_ham)`
`146`	`148`	`{`
`147`	`149`	`ModuleBase::TITLE("DFTU", "cal_occup_m_k");`
`148`	`150`	`ModuleBase::timer::tick("DFTU", "cal_occup_m_k");`
`149`	`151`
`150`		`- this->copy_locale();`
`151`		`- this->zero_locale();`
	`152`	`+ this->copy_locale(ucell);`
	`153`	`+ this->zero_locale(ucell);`
`152`	`154`
`153`	`155`	`//=================Part 1======================`
`154`	`156`	`// call SCALAPACK routine to calculate the product of the S and density matrix`
`@@ -196,24 +198,24 @@ void DFTU::cal_occup_m_k(const int iter,`
`196`	`198`	`#endif`
`197`	`199`
`198`	`200`	`const int spin = kv.isk[ik];`
`199`		`- for (int it = 0; it < GlobalC::ucell.ntype; it++)`
	`201`	`+ for (int it = 0; it < ucell.ntype; it++)`
`200`	`202`	`{`
`201`		`- const int NL = GlobalC::ucell.atoms[it].nwl + 1;`
	`203`	`+ const int NL = ucell.atoms[it].nwl + 1;`
`202`	`204`	`const int LC = orbital_corr[it];`
`203`	`205`
`204`	`206`	`if (LC == -1)`
`205`	`207`	`continue;`
`206`	`208`
`207`		`- for (int ia = 0; ia < GlobalC::ucell.atoms[it].na; ia++)`
	`209`	`+ for (int ia = 0; ia < ucell.atoms[it].na; ia++)`
`208`	`210`	`{`
`209`		`- const int iat = GlobalC::ucell.itia2iat(it, ia);`
	`211`	`+ const int iat = ucell.itia2iat(it, ia);`
`210`	`212`
`211`	`213`	`for (int l = 0; l < NL; l++)`
`212`	`214`	`{`
`213`	`215`	`if (l != orbital_corr[it])`
`214`	`216`	`continue;`
`215`	`217`
`216`		`- const int N = GlobalC::ucell.atoms[it].l_nchi[l];`
	`218`	`+ const int N = ucell.atoms[it].l_nchi[l];`
`217`	`219`
`218`	`220`	`for (int n = 0; n < N; n++)`
`219`	`221`	`{`
`@@ -260,24 +262,24 @@ void DFTU::cal_occup_m_k(const int iter,`
`260`	`262`	`} // end it`
`261`	`263`	`} // ik`
`262`	`264`
`263`		`- for (int it = 0; it < GlobalC::ucell.ntype; it++)`
	`265`	`+ for (int it = 0; it < ucell.ntype; it++)`
`264`	`266`	`{`
`265`		`- const int NL = GlobalC::ucell.atoms[it].nwl + 1;`
	`267`	`+ const int NL = ucell.atoms[it].nwl + 1;`
`266`	`268`	`const int LC = orbital_corr[it];`
`267`	`269`
`268`	`270`	`if (LC == -1)`
`269`	`271`	`continue;`
`270`	`272`
`271`		`- for (int ia = 0; ia < GlobalC::ucell.atoms[it].na; ia++)`
	`273`	`+ for (int ia = 0; ia < ucell.atoms[it].na; ia++)`
`272`	`274`	`{`
`273`		`- const int iat = GlobalC::ucell.itia2iat(it, ia);`
	`275`	`+ const int iat = ucell.itia2iat(it, ia);`
`274`	`276`
`275`	`277`	`for (int l = 0; l < NL; l++)`
`276`	`278`	`{`
`277`	`279`	`if (l != orbital_corr[it])`
`278`	`280`	`continue;`
`279`	`281`
`280`		`- const int N = GlobalC::ucell.atoms[it].l_nchi[l];`
	`282`	`+ const int N = ucell.atoms[it].l_nchi[l];`
`281`	`283`
`282`	`284`	`for (int n = 0; n < N; n++)`
`283`	`285`	`{`
`@@ -346,20 +348,24 @@ void DFTU::cal_occup_m_k(const int iter,`
`346`	`348`
`347`	`349`	`if(mixing_dftu && initialed_locale)`
`348`	`350`	`{`
`349`		`- this->mix_locale(mixing_beta);`
	`351`	`+ this->mix_locale(ucell,mixing_beta);`
`350`	`352`	`}`
`351`	`353`
`352`	`354`	`this->initialed_locale = true;`
`353`	`355`	`ModuleBase::timer::tick("DFTU", "cal_occup_m_k");`
`354`	`356`	`return;`
`355`	`357`	`}`
`356`	`358`
`357`		`-void DFTU::cal_occup_m_gamma(const int iter, const std::vector<std::vector<double>> &dm_gamma, const double& mixing_beta, hamilt::Hamilt<double>* p_ham)`
	`359`	`+void DFTU::cal_occup_m_gamma(const int iter,`
	`360`	`+ const UnitCell &ucell,`
	`361`	`+ const std::vector<std::vector<double>> &dm_gamma,`
	`362`	`+ const double& mixing_beta,`
	`363`	`+ hamilt::Hamilt<double>* p_ham)`
`358`	`364`	`{`
`359`	`365`	`ModuleBase::TITLE("DFTU", "cal_occup_m_gamma");`
`360`	`366`	`ModuleBase::timer::tick("DFTU", "cal_occup_m_gamma");`
`361`		`- this->copy_locale();`
`362`		`- this->zero_locale();`
	`367`	`+ this->copy_locale(ucell);`
	`368`	`+ this->zero_locale(ucell);`
`363`	`369`
`364`	`370`	`//=================Part 1======================`
`365`	`371`	`// call PBLAS routine to calculate the product of the S and density matrix`
`@@ -396,21 +402,21 @@ void DFTU::cal_occup_m_gamma(const int iter, const std::vector<std::vector<doubl`
`396`	`402`	`this->paraV->desc);`
`397`	`403`	`#endif`
`398`	`404`
`399`		`- for (int it = 0; it < GlobalC::ucell.ntype; it++)`
	`405`	`+ for (int it = 0; it < ucell.ntype; it++)`
`400`	`406`	`{`
`401`		`- const int NL = GlobalC::ucell.atoms[it].nwl + 1;`
	`407`	`+ const int NL = ucell.atoms[it].nwl + 1;`
`402`	`408`	`if (orbital_corr[it] == -1)`
`403`	`409`	`continue;`
`404`		`- for (int ia = 0; ia < GlobalC::ucell.atoms[it].na; ia++)`
	`410`	`+ for (int ia = 0; ia < ucell.atoms[it].na; ia++)`
`405`	`411`	`{`
`406`		`- const int iat = GlobalC::ucell.itia2iat(it, ia);`
	`412`	`+ const int iat = ucell.itia2iat(it, ia);`
`407`	`413`
`408`	`414`	`for (int l = 0; l < NL; l++)`
`409`	`415`	`{`
`410`	`416`	`if (l != orbital_corr[it])`
`411`	`417`	`continue;`
`412`	`418`
`413`		`- const int N = GlobalC::ucell.atoms[it].l_nchi[l];`
	`419`	`+ const int N = ucell.atoms[it].l_nchi[l];`
`414`	`420`
`415`	`421`	`for (int n = 0; n < N; n++)`
`416`	`422`	`{`
`@@ -494,7 +500,7 @@ void DFTU::cal_occup_m_gamma(const int iter, const std::vector<std::vector<doubl`
`494`	`500`
`495`	`501`	`if(mixing_dftu && initialed_locale)`
`496`	`502`	`{`
`497`		`- this->mix_locale(mixing_beta);`
	`503`	`+ this->mix_locale(ucell,mixing_beta);`
`498`	`504`	`}`
`499`	`505`
`500`	`506`	`this->initialed_locale = true;`