change ucell in dftu_io

A-006 · A-006 · commit 674d89e728b7 · 2024-12-01T10:21:40.000+08:00
diff --git a/source/module_esolver/esolver_ks_lcao.cpp b/source/module_esolver/esolver_ks_lcao.cpp
@@ -885,7 +885,7 @@ void ESolver_KS_LCAO<TK, TR>::iter_finish(UnitCell& ucell, const int istep, int&
             }
             GlobalC::dftu.cal_energy_correction(ucell,istep);
         }
-        GlobalC::dftu.output();
+        GlobalC::dftu.output(ucell);
     }
 
     // (7) for deepks, calculate delta_e
diff --git a/source/module_hamilt_lcao/module_dftu/dftu.cpp b/source/module_hamilt_lcao/module_dftu/dftu.cpp
@@ -179,9 +179,9 @@ void DFTU::init(UnitCell& cell, // unitcell class
     {
         std::stringstream sst;
         sst << "initial_onsite.dm";
-        this->read_occup_m(sst.str());
+        this->read_occup_m(cell,sst.str());
 #ifdef __MPI
-        this->local_occup_bcast();
+        this->local_occup_bcast(cell);
 #endif
 
         initialed_locale = true;
@@ -193,9 +193,9 @@ void DFTU::init(UnitCell& cell, // unitcell class
         {
             std::stringstream sst;
             sst << PARAM.globalv.global_out_dir << "onsite.dm";
-            this->read_occup_m(sst.str());
+            this->read_occup_m(cell,sst.str());
 #ifdef __MPI
-            this->local_occup_bcast();
+            this->local_occup_bcast(cell);
 #endif
             initialed_locale = true;
         }
diff --git a/source/module_hamilt_lcao/module_dftu/dftu.h b/source/module_hamilt_lcao/module_dftu/dftu.h
@@ -230,12 +230,15 @@ class DFTU
     // For reading/writing/broadcasting/copying relevant data structures
     //=============================================================
   public:
-    void output();
+    void output(const UnitCell& ucell);
 
   private:
-    void write_occup_m(std::ofstream& ofs, bool diag=false);
-    void read_occup_m(const std::string& fn);
-    void local_occup_bcast();
+    void write_occup_m(const UnitCell& ucell,
+                       std::ofstream& ofs, 
+                       bool diag=false);
+    void read_occup_m(const UnitCell& ucell,
+                      const std::string& fn);
+    void local_occup_bcast(const UnitCell& ucell);
 
     //=============================================================
     // In dftu_yukawa.cpp
diff --git a/source/module_hamilt_lcao/module_dftu/dftu_io.cpp b/source/module_hamilt_lcao/module_dftu/dftu_io.cpp
@@ -6,19 +6,19 @@
 namespace ModuleDFTU
 {
 
-void DFTU::output()
+void DFTU::output(const UnitCell &ucell)
 {
     ModuleBase::TITLE("DFTU", "output");
 
     GlobalV::ofs_running << "//=========================L(S)DA+U===========================//" << std::endl;
 
-    for (int T = 0; T < GlobalC::ucell.ntype; T++)
+    for (int T = 0; T < ucell.ntype; T++)
     {
-        const int NL = GlobalC::ucell.atoms[T].nwl + 1;
+        const int NL = ucell.atoms[T].nwl + 1;
 
         for (int L = 0; L < NL; L++)
         {
-            const int N = GlobalC::ucell.atoms[T].l_nchi[L];
+            const int N = ucell.atoms[T].l_nchi[L];
 
             if (L >= orbital_corr[T] && orbital_corr[T] != -1)
             {
@@ -50,7 +50,7 @@ void DFTU::output()
     }
 
     GlobalV::ofs_running << "Local occupation matrices" << std::endl;
-    this->write_occup_m(GlobalV::ofs_running, true);
+    this->write_occup_m(ucell,GlobalV::ofs_running, true);
     GlobalV::ofs_running << "//=======================================================//" << std::endl;
     
     //Write onsite.dm
@@ -64,7 +64,7 @@ void DFTU::output()
       std::cout << "DFTU::write_occup_m. Can't create file onsite.dm!" << std::endl;
       exit(0);
     } 
-    this->write_occup_m(ofdftu);
+    this->write_occup_m(ucell,ofdftu);
     ofdftu.close();
 
     return;
@@ -73,24 +73,26 @@ void DFTU::output()
 // define the function calculate the eigenvalues of a matrix
 std::vector<double> CalculateEigenvalues(std::vector<std::vector<double>>& A, int n);
 
-void DFTU::write_occup_m(std::ofstream &ofs, bool diag)
+void DFTU::write_occup_m(const UnitCell& ucell,
+                         std::ofstream &ofs, 
+                         bool diag)
 {
     ModuleBase::TITLE("DFTU", "write_occup_m");
 
     if(GlobalV::MY_RANK != 0) { return;
 }
 
-    for (int T = 0; T < GlobalC::ucell.ntype; T++)
+    for (int T = 0; T < ucell.ntype; T++)
     {
         if (orbital_corr[T] == -1) {
             continue;
 }
-        const int NL = GlobalC::ucell.atoms[T].nwl + 1;
+        const int NL = ucell.atoms[T].nwl + 1;
         const int LC = orbital_corr[T];
 
-        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);
             ofs << "atoms"
                 << "  " << iat << std::endl;
 
@@ -100,7 +102,7 @@ void DFTU::write_occup_m(std::ofstream &ofs, bool diag)
                     continue;
 }
 
-                const int N = GlobalC::ucell.atoms[T].l_nchi[l];
+                const int N = ucell.atoms[T].l_nchi[l];
                 ofs << "L"
                     << "  " << l << std::endl;
 
@@ -220,7 +222,8 @@ void DFTU::write_occup_m(std::ofstream &ofs, bool diag)
     return;
 }
 
-void DFTU::read_occup_m(const std::string &fn)
+void DFTU::read_occup_m(const UnitCell& ucell,
+                        const std::string &fn)
 {
     ModuleBase::TITLE("DFTU", "read_occup_m");
 
@@ -270,8 +273,8 @@ void DFTU::read_occup_m(const std::string &fn)
             ifdftu >> iat;
             ifdftu.ignore(150, '\n');
 
-            T = GlobalC::ucell.iat2it[iat];
-            const int NL = GlobalC::ucell.atoms[T].nwl + 1;
+            T = ucell.iat2it[iat];
+            const int NL = ucell.atoms[T].nwl + 1;
             const int LC = orbital_corr[T];
 
             for (int l = 0; l < NL; l++)
@@ -287,7 +290,7 @@ void DFTU::read_occup_m(const std::string &fn)
                     ifdftu >> L;
                     ifdftu.ignore(150, '\n');
 
-                    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++)
                     {
                         // if(!Yukawa && n!=0) continue;
@@ -384,28 +387,28 @@ void DFTU::read_occup_m(const std::string &fn)
     return;
 }
 
-void DFTU::local_occup_bcast()
+void DFTU::local_occup_bcast(const UnitCell& ucell)
 {
     ModuleBase::TITLE("DFTU", "local_occup_bcast");
 
-    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);
             const int L = orbital_corr[T];
 
-            for (int l = 0; l <= GlobalC::ucell.atoms[T].nwl; l++)
+            for (int l = 0; l <= ucell.atoms[T].nwl; l++)
             {
                 if (l != orbital_corr[T]) {
                     continue;
 }
 
-                for (int n = 0; n < GlobalC::ucell.atoms[T].l_nchi[l]; n++)
+                for (int n = 0; n < ucell.atoms[T].l_nchi[l]; n++)
                 {
                     // if(!Yukawa && n!=0) continue;
                     if (n != 0) {

Original file line number	Diff line number	Diff line change
`@@ -885,7 +885,7 @@ void ESolver_KS_LCAO<TK, TR>::iter_finish(UnitCell& ucell, const int istep, int&`
`885`	`885`	`}`
`886`	`886`	`GlobalC::dftu.cal_energy_correction(ucell,istep);`
`887`	`887`	`}`
`888`		`- GlobalC::dftu.output();`
	`888`	`+ GlobalC::dftu.output(ucell);`
`889`	`889`	`}`
`890`	`890`
`891`	`891`	`// (7) for deepks, calculate delta_e`
Original file line number	Diff line number	Diff line change
`@@ -6,19 +6,19 @@`
`6`	`6`	`namespace ModuleDFTU`
`7`	`7`	`{`
`8`	`8`
`9`		`-void DFTU::output()`
	`9`	`+void DFTU::output(const UnitCell &ucell)`
`10`	`10`	`{`
`11`	`11`	`ModuleBase::TITLE("DFTU", "output");`
`12`	`12`
`13`	`13`	`GlobalV::ofs_running << "//=========================L(S)DA+U===========================//" << std::endl;`
`14`	`14`
`15`		`- for (int T = 0; T < GlobalC::ucell.ntype; T++)`
	`15`	`+ for (int T = 0; T < ucell.ntype; T++)`
`16`	`16`	`{`
`17`		`- const int NL = GlobalC::ucell.atoms[T].nwl + 1;`
	`17`	`+ const int NL = ucell.atoms[T].nwl + 1;`
`18`	`18`
`19`	`19`	`for (int L = 0; L < NL; L++)`
`20`	`20`	`{`
`21`		`- const int N = GlobalC::ucell.atoms[T].l_nchi[L];`
	`21`	`+ const int N = ucell.atoms[T].l_nchi[L];`
`22`	`22`
`23`	`23`	`if (L >= orbital_corr[T] && orbital_corr[T] != -1)`
`24`	`24`	`{`
`@@ -50,7 +50,7 @@ void DFTU::output()`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`GlobalV::ofs_running << "Local occupation matrices" << std::endl;`
`53`		`- this->write_occup_m(GlobalV::ofs_running, true);`
	`53`	`+ this->write_occup_m(ucell,GlobalV::ofs_running, true);`
`54`	`54`	`GlobalV::ofs_running << "//=======================================================//" << std::endl;`
`55`	`55`
`56`	`56`	`//Write onsite.dm`
`@@ -64,7 +64,7 @@ void DFTU::output()`
`64`	`64`	`std::cout << "DFTU::write_occup_m. Can't create file onsite.dm!" << std::endl;`
`65`	`65`	`exit(0);`
`66`	`66`	`}`
`67`		`- this->write_occup_m(ofdftu);`
	`67`	`+ this->write_occup_m(ucell,ofdftu);`
`68`	`68`	`ofdftu.close();`
`69`	`69`
`70`	`70`	`return;`
`@@ -73,24 +73,26 @@ void DFTU::output()`
`73`	`73`	`// define the function calculate the eigenvalues of a matrix`
`74`	`74`	`std::vector<double> CalculateEigenvalues(std::vector<std::vector<double>>& A, int n);`
`75`	`75`
`76`		`-void DFTU::write_occup_m(std::ofstream &ofs, bool diag)`
	`76`	`+void DFTU::write_occup_m(const UnitCell& ucell,`
	`77`	`+ std::ofstream &ofs,`
	`78`	`+ bool diag)`
`77`	`79`	`{`
`78`	`80`	`ModuleBase::TITLE("DFTU", "write_occup_m");`
`79`	`81`
`80`	`82`	`if(GlobalV::MY_RANK != 0) { return;`
`81`	`83`	`}`
`82`	`84`
`83`		`- for (int T = 0; T < GlobalC::ucell.ntype; T++)`
	`85`	`+ for (int T = 0; T < ucell.ntype; T++)`
`84`	`86`	`{`
`85`	`87`	`if (orbital_corr[T] == -1) {`
`86`	`88`	`continue;`
`87`	`89`	`}`
`88`		`- const int NL = GlobalC::ucell.atoms[T].nwl + 1;`
	`90`	`+ const int NL = ucell.atoms[T].nwl + 1;`
`89`	`91`	`const int LC = orbital_corr[T];`
`90`	`92`
`91`		`- for (int I = 0; I < GlobalC::ucell.atoms[T].na; I++)`
	`93`	`+ for (int I = 0; I < ucell.atoms[T].na; I++)`
`92`	`94`	`{`
`93`		`- const int iat = GlobalC::ucell.itia2iat(T, I);`
	`95`	`+ const int iat = ucell.itia2iat(T, I);`
`94`	`96`	`ofs << "atoms"`
`95`	`97`	`<< " " << iat << std::endl;`
`96`	`98`
`@@ -100,7 +102,7 @@ void DFTU::write_occup_m(std::ofstream &ofs, bool diag)`
`100`	`102`	`continue;`
`101`	`103`	`}`
`102`	`104`
`103`		`- const int N = GlobalC::ucell.atoms[T].l_nchi[l];`
	`105`	`+ const int N = ucell.atoms[T].l_nchi[l];`
`104`	`106`	`ofs << "L"`
`105`	`107`	`<< " " << l << std::endl;`
`106`	`108`
`@@ -220,7 +222,8 @@ void DFTU::write_occup_m(std::ofstream &ofs, bool diag)`
`220`	`222`	`return;`
`221`	`223`	`}`
`222`	`224`
`223`		`-void DFTU::read_occup_m(const std::string &fn)`
	`225`	`+void DFTU::read_occup_m(const UnitCell& ucell,`
	`226`	`+ const std::string &fn)`
`224`	`227`	`{`
`225`	`228`	`ModuleBase::TITLE("DFTU", "read_occup_m");`
`226`	`229`
`@@ -270,8 +273,8 @@ void DFTU::read_occup_m(const std::string &fn)`
`270`	`273`	`ifdftu >> iat;`
`271`	`274`	`ifdftu.ignore(150, '\n');`
`272`	`275`
`273`		`- T = GlobalC::ucell.iat2it[iat];`
`274`		`- const int NL = GlobalC::ucell.atoms[T].nwl + 1;`
	`276`	`+ T = ucell.iat2it[iat];`
	`277`	`+ const int NL = ucell.atoms[T].nwl + 1;`
`275`	`278`	`const int LC = orbital_corr[T];`
`276`	`279`
`277`	`280`	`for (int l = 0; l < NL; l++)`
`@@ -287,7 +290,7 @@ void DFTU::read_occup_m(const std::string &fn)`
`287`	`290`	`ifdftu >> L;`
`288`	`291`	`ifdftu.ignore(150, '\n');`
`289`	`292`
`290`		`- const int N = GlobalC::ucell.atoms[T].l_nchi[L];`
	`293`	`+ const int N = ucell.atoms[T].l_nchi[L];`
`291`	`294`	`for (int n = 0; n < N; n++)`
`292`	`295`	`{`
`293`	`296`	`// if(!Yukawa && n!=0) continue;`
`@@ -384,28 +387,28 @@ void DFTU::read_occup_m(const std::string &fn)`
`384`	`387`	`return;`
`385`	`388`	`}`
`386`	`389`
`387`		`-void DFTU::local_occup_bcast()`
	`390`	`+void DFTU::local_occup_bcast(const UnitCell& ucell)`
`388`	`391`	`{`
`389`	`392`	`ModuleBase::TITLE("DFTU", "local_occup_bcast");`
`390`	`393`
`391`		`- for (int T = 0; T < GlobalC::ucell.ntype; T++)`
	`394`	`+ for (int T = 0; T < ucell.ntype; T++)`
`392`	`395`	`{`
`393`	`396`	`if (orbital_corr[T] == -1) {`
`394`	`397`	`continue;`
`395`	`398`	`}`
`396`	`399`
`397`		`- for (int I = 0; I < GlobalC::ucell.atoms[T].na; I++)`
	`400`	`+ for (int I = 0; I < ucell.atoms[T].na; I++)`
`398`	`401`	`{`
`399`		`- const int iat = GlobalC::ucell.itia2iat(T, I);`
	`402`	`+ const int iat = ucell.itia2iat(T, I);`
`400`	`403`	`const int L = orbital_corr[T];`
`401`	`404`
`402`		`- for (int l = 0; l <= GlobalC::ucell.atoms[T].nwl; l++)`
	`405`	`+ for (int l = 0; l <= ucell.atoms[T].nwl; l++)`
`403`	`406`	`{`
`404`	`407`	`if (l != orbital_corr[T]) {`
`405`	`408`	`continue;`
`406`	`409`	`}`
`407`	`410`
`408`		`- for (int n = 0; n < GlobalC::ucell.atoms[T].l_nchi[l]; n++)`
	`411`	`+ for (int n = 0; n < ucell.atoms[T].l_nchi[l]; n++)`
`409`	`412`	`{`
`410`	`413`	`// if(!Yukawa && n!=0) continue;`
`411`	`414`	`if (n != 0) {`