Update DOS output formats (pw basis).

source/module_base/test/timer_test.cpp

@@ -59,19 +59,22 @@ TEST_F(TimerTest, Tick)
 	EXPECT_GT(ModuleBase::timer::timer_pool["wavefunc"]["evc"].cpu_second,0.0001);
 }
 
+
 TEST_F(TimerTest, Start)
 {
 	ModuleBase::timer::start();
 	// start() called tick() once
 	EXPECT_FALSE(ModuleBase::timer::timer_pool[""]["total"].start_flag);
 }
 
+
 TEST_F(TimerTest, write_to_json)
 {
 	ModuleBase::timer::tick("wavefunc","evc");
 	std::this_thread::sleep_for(std::chrono::microseconds(T_Elapse)); // 0.1 ms
 	ModuleBase::timer::tick("wavefunc","evc");
 	ModuleBase::timer::write_to_json("tmp.json");
+
 	// check if tmp.json exists
 	ifs.open("tmp.json");
 	EXPECT_TRUE(ifs.good());
@@ -89,9 +92,6 @@ TEST_F(TimerTest, write_to_json)
 		content += tmp;
 	}
 
-	// check if the content is correct
-	// shuold be like this:
-	// {"total": 0, "sub":[{"class_name": "wavefunc","sub":[{"name":"evc","cpu_second": 0.000318,"calls":2,"cpu_second_per_call":0.000159,"cpu_second_per_total": null}]}]}
 	EXPECT_THAT(content,testing::HasSubstr("\"total\":"));
 	EXPECT_THAT(content,testing::HasSubstr("\"sub\":[{\"class_name\":\"wavefunc\",\"sub\":[{\"name\":\"evc\",\"cpu_second\":"));
 	EXPECT_THAT(content,testing::HasSubstr("\"calls\":2,\"cpu_second_per_call\":"));
@@ -106,25 +106,29 @@ TEST_F(TimerTest, PrintAll)
 	ModuleBase::timer::tick("wavefunc","evc");
 	std::this_thread::sleep_for(std::chrono::microseconds(T_Elapse)); // 0.1 ms
 	ModuleBase::timer::tick("wavefunc","evc");
+
 	// call print_all
 	ofs.open("tmp");
 	testing::internal::CaptureStdout();
 	ModuleBase::timer::print_all(ofs);
 	output = testing::internal::GetCapturedStdout();
 	ofs.close();
+
 	// checout output on screen
-	std::cout << "Get captured stdout: \n" << std::endl;
-	std::cout << output << std::endl;
+	// std::cout << "Get captured stdout: \n" << std::endl;
+	// std::cout << output << std::endl;
 	EXPECT_THAT(output,testing::HasSubstr("TIME STATISTICS"));
 	EXPECT_THAT(output,testing::HasSubstr("CLASS_NAME"));
 	EXPECT_THAT(output,testing::HasSubstr("NAME"));
 	EXPECT_THAT(output,testing::HasSubstr("TIME/s"));
 	EXPECT_THAT(output,testing::HasSubstr("CALLS"));
 	EXPECT_THAT(output,testing::HasSubstr("AVG/s"));
 	EXPECT_THAT(output,testing::HasSubstr("PER/%"));
+
 	// check output in file
 	ifs.open("tmp");
-	std::cout << "Capture contents line by line from output file: \n" << std::endl;
+	// std::cout << "Capture contents line by line from output file: \n" << std::endl;
+	getline(ifs,output);
 	getline(ifs,output);
 	EXPECT_THAT(output,testing::HasSubstr("TIME STATISTICS"));
 	getline(ifs,output);
@@ -139,36 +143,41 @@ TEST_F(TimerTest, PrintAll)
 	remove("time.json");
 }
 
+
 TEST_F(TimerTest, PrintUntilNow)
 {
 	long double time = ModuleBase::timer::print_until_now();
 	EXPECT_TRUE(time>0.0);
 }
 
+
 TEST_F(TimerTest, Finish)
 {
 	ModuleBase::timer::tick("wavefunc","evc");
 	std::this_thread::sleep_for(std::chrono::microseconds(T_Elapse)); // 0.1 ms
 	ModuleBase::timer::tick("wavefunc","evc");
+
 	// call print_all
 	ofs.open("tmp");
 	testing::internal::CaptureStdout();
 	ModuleBase::timer::finish(ofs);
 	output = testing::internal::GetCapturedStdout();
 	ofs.close();
 	// checout output on screen
-	std::cout << "Get captured stdout: \n" << std::endl;
-	std::cout << output << std::endl;
+	//std::cout << "Get captured stdout: \n" << std::endl;
+	//std::cout << output << std::endl;
 	EXPECT_THAT(output,testing::HasSubstr("TIME STATISTICS"));
 	EXPECT_THAT(output,testing::HasSubstr("CLASS_NAME"));
 	EXPECT_THAT(output,testing::HasSubstr("NAME"));
 	EXPECT_THAT(output,testing::HasSubstr("TIME/s"));
 	EXPECT_THAT(output,testing::HasSubstr("CALLS"));
 	EXPECT_THAT(output,testing::HasSubstr("AVG/s"));
 	EXPECT_THAT(output,testing::HasSubstr("PER/%"));
+
 	// check output in file
 	ifs.open("tmp");
-	std::cout << "Capture contents line by line from output file: \n" << std::endl;
+	//std::cout << "Capture contents line by line from output file: \n" << std::endl;
+	getline(ifs,output);
 	getline(ifs,output);
 	EXPECT_THAT(output,testing::HasSubstr("TIME STATISTICS"));
 	getline(ifs,output);
@@ -182,7 +191,6 @@ TEST_F(TimerTest, Finish)
 	ifs.close();
 }
 
-// use __MPI to activate parallel environment
 #ifdef __MPI
 int main(int argc, char **argv)
 {

source/module_base/test/tool_quit_test.cpp

@@ -93,7 +93,7 @@ TEST_F(ToolQuitTest,warningquit)
 	ifs.open("running.log");
 	getline(ifs,output);
 	// test output in running.log file
-	EXPECT_THAT(output,testing::HasSubstr("!!!!!!!"));
+	EXPECT_THAT(output,testing::HasSubstr("-------"));
 	ifs.close();
 }
 
@@ -116,7 +116,7 @@ TEST_F(ToolQuitTest,warningquit_with_ret)
 	ifs.open("running.log");
 	getline(ifs,output);
 	// test output in running.log file
-	EXPECT_THAT(output,testing::HasSubstr("!!!!!!!"));
+	EXPECT_THAT(output,testing::HasSubstr("-------"));
 	ifs.close();
 }
 // use __MPI to activate parallel environment

source/module_base/timer.cpp

@@ -306,7 +306,7 @@ void timer::print_all(std::ofstream &ofs)
 							 /*indent=*/0, 
 							 /*align=*/{/*value*/FmtTable::Align::LEFT, /*title*/FmtTable::Align::CENTER});
 	time_statistics << class_names << names << times << calls << avgs << pers;
-	const std::string table = "TIME STATISTICS\n" + time_statistics.str();
+	const std::string table = "\nTIME STATISTICS\n" + time_statistics.str();
 	std::cout<<table<<std::endl;
 	ofs<<table<<std::endl;
 	write_to_json("time.json");

source/module_base/tool_quit.cpp

@@ -68,34 +68,34 @@ void WARNING_QUIT(const std::string &file,const std::string &description,int ret
 {
 #ifdef __NORMAL
 
-	std::cout << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
-	std::cout << "                         NOTICE                           " << std::endl;
-	std::cout << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
+	std::cout << " ---------------------------------------------------------" << std::endl;
+	std::cout << "                         !NOTICE!                         " << std::endl;
+	std::cout << " ---------------------------------------------------------" << std::endl;
 
 #else
 		std::cout << " " << std::endl;
-		std::cout << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
-		std::cout << "                         NOTICE                           " << std::endl;
-		std::cout << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
+		std::cout << " ---------------------------------------------------------" << std::endl;
+		std::cout << "                         !NOTICE!                         " << std::endl;
+		std::cout << " ---------------------------------------------------------" << std::endl;
 		std::cout << " " << std::endl;
 		std::cout << " " << description << std::endl;
 		std::cout << " CHECK IN FILE : " << PARAM.globalv.global_out_dir << "warning.log" << std::endl;
 		std::cout << " " << std::endl;
-		std::cout << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
-		std::cout << "                         NOTICE                           " << std::endl;
-		std::cout << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
+		std::cout << " ---------------------------------------------------------" << std::endl;
+		std::cout << "                         !NOTICE!                         " << std::endl;
+		std::cout << " ---------------------------------------------------------" << std::endl;
 
 
-	GlobalV::ofs_running << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
-	GlobalV::ofs_running << "                         NOTICE                           " << std::endl;
-	GlobalV::ofs_running << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
+	GlobalV::ofs_running << " ---------------------------------------------------------" << std::endl;
+	GlobalV::ofs_running << "                         !NOTICE!                         " << std::endl;
+	GlobalV::ofs_running << " ---------------------------------------------------------" << std::endl;
 	GlobalV::ofs_running << std::endl;
 	GlobalV::ofs_running << " " << description << std::endl;
 	GlobalV::ofs_running << " CHECK IN FILE : " << PARAM.globalv.global_out_dir << "warning.log" << std::endl;
 	GlobalV::ofs_running << std::endl;
-	GlobalV::ofs_running << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
+	GlobalV::ofs_running << " ---------------------------------------------------------" << std::endl;
 	GlobalV::ofs_running << "                         NOTICE                           " << std::endl;
-	GlobalV::ofs_running << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
+	GlobalV::ofs_running << " ---------------------------------------------------------" << std::endl;
 
 	WARNING(file,description);
     GlobalV::ofs_running<<" Check in file : "<<PARAM.globalv.global_out_dir<<"warning.log"<<std::endl;
@@ -128,10 +128,10 @@ void CHECK_WARNING_QUIT(const bool error_in, const std::string &file,const std::
 		}
 
 		//print error information
-		std::cout << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
+		std::cout << " ---------------------------------------------------------" << std::endl;
 		std::cout << " ERROR! " << description << std::endl;
 		std::cout << " CHECK IN FILE : " << PARAM.globalv.global_out_dir << "warning.log" << std::endl;
-		std::cout << " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
+		std::cout << " ---------------------------------------------------------" << std::endl;
 		GlobalV::ofs_running << " ERROR! CHECK IN FILE : " << PARAM.globalv.global_out_dir << "warning.log" << std::endl;
 		GlobalV::ofs_warning << std::endl;
 		GlobalV::ofs_warning << " ERROR! " << file << ", core " << GlobalV::MY_RANK+1 << ": " << description << std::endl;

source/module_cell/unitcell.cpp

@@ -301,9 +301,6 @@ void UnitCell::setup_cell(const std::string& fn, std::ofstream& log)
     assert(lat0 > 0.0);
     this->omega = latvec.Det() * this->lat0 * this->lat0 * this->lat0;
 
-    std::cout << "latvec.det=" << latvec.Det() << std::endl;
-    std::cout << "lat0=" << lat0 << std::endl;
-
 
     if (this->omega < 0)
     {

source/module_elecstate/fp_energy.h

@@ -1,11 +1,12 @@
+#ifndef FP_ENERGY_H
+#define FP_ENERGY_H
+
 #include <vector>
 
 /**
  * @file fp_energy.h
  * @brief This file contains all energies about first-principle calculations
  */
-#ifndef FP_ENERGY_H
-#define FP_ENERGY_H
 namespace elecstate
 {
 /**
@@ -63,11 +64,11 @@ struct efermi
     double ef = 0.0;         ///< Fermi energy
     double ef_up = 0.0;      ///< spin up Fermi energy
     double ef_dw = 0.0;      ///< spin down Fermi energy
-    bool two_efermi = false; ///<
+    bool two_efermi = false; 
     void set_efval(const int& is, const double& ef_in);
     double get_efval(const int& is) const;
     std::vector<double> get_all_ef() const;
 };
 
 } // namespace elecstate
-#endif
+#endif

source/module_elecstate/module_charge/charge_init.cpp

@@ -73,7 +73,7 @@ void Charge::init_rho(elecstate::efermi& eferm_iout,
                 {
                     if (is == 1)    // failed at the second spin
                     {
-                        std::cout << "Incomplete electron density file!" << std::endl;
+                        std::cout << " Incomplete electron density file." << std::endl;
                         read_error = true;
                         break;
                     }
@@ -105,15 +105,15 @@ void Charge::init_rho(elecstate::efermi& eferm_iout,
         if (read_error)
         {
             const std::string warn_msg
-                = " WARNING: \"init_chg\" is enabled but ABACUS failed to read charge density from file.\n"
-                  " Please check if there is SPINX_CHG.cube (X=1,...) or {suffix}-CHARGE-DENSITY.restart in the "
+                = " WARNING: \"init_chg\" is enabled but ABACUS failed to read\n charge density from file.\n"
+                  " Please check if there is SPINX_CHG.cube (X=1,...) or\n {suffix}-CHARGE-DENSITY.restart in the "
                   "directory.\n";
-            std::cout << std::endl << warn_msg;
+            std::cout << warn_msg;
             if (PARAM.inp.init_chg == "file")
             {
                 ModuleBase::WARNING_QUIT("Charge::init_rho",
-                                         "Failed to read in charge density from file.\nIf you want to use atomic "
-                                         "charge initialization, \nplease set init_chg to atomic in INPUT.");
+                                         "Failed to read in charge density from file.\n For initializing atomic "
+                                         "charge in calculations,\n please set init_chg to atomic in INPUT.");
             }
         }
 

source/module_esolver/esolver_ks.cpp

@@ -733,7 +733,7 @@ void ESolver_KS<T, Device>::after_all_runners(UnitCell& ucell)
     // 1) write information
     if (PARAM.inp.out_dos != 0 || PARAM.inp.out_band[0] != 0 || PARAM.inp.out_proj_band != 0)
     {
-        GlobalV::ofs_running << "\n\n\n\n";
+        GlobalV::ofs_running << "\n\n";
         GlobalV::ofs_running << " >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
                                 ">>>>>>>>>>>>>>>>>>>>>>>>>"
                              << std::endl;
@@ -761,17 +761,17 @@ void ESolver_KS<T, Device>::after_all_runners(UnitCell& ucell)
         GlobalV::ofs_running << " <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
                                 "<<<<<<<<<<<<<<<<<<<<<<<<<"
                              << std::endl;
-        GlobalV::ofs_running << "\n\n\n\n";
+        GlobalV::ofs_running << "\n\n";
     }
 
     // 2) write information
     ModuleIO::write_istate_info(this->pelec->ekb, this->pelec->wg, this->kv);
 
-    const int nspin0 = (PARAM.inp.nspin == 2) ? 2 : 1;
 
     // 3) print out band information
     if (PARAM.inp.out_band[0])
     {
+        const int nspin0 = (PARAM.inp.nspin == 2) ? 2 : 1;
         for (int is = 0; is < nspin0; is++)
         {
             std::stringstream ss2;

source/module_esolver/esolver_ks_pw.cpp

@@ -827,29 +827,18 @@ void ESolver_KS_PW<T, Device>::after_all_runners(UnitCell& ucell)
 {
     ESolver_KS<T, Device>::after_all_runners(ucell);
 
-    const int nspin0 = (PARAM.inp.nspin == 2) ? 2 : 1;
-
-    //! 3) Compute density of states (DOS)
+    //! 1) Compute density of states (DOS)
     if (PARAM.inp.out_dos)
     {
         ModuleIO::write_dos_pw(this->pelec->ekb,
                                this->pelec->wg,
                                this->kv,
+                               PARAM.inp.nbands,
+                               this->pelec->eferm,
                                PARAM.inp.dos_edelta_ev,
                                PARAM.inp.dos_scale,
-                               PARAM.inp.dos_sigma);
-
-        if (nspin0 == 1)
-        {
-            GlobalV::ofs_running << " Fermi energy is " << this->pelec->eferm.ef << " Rydberg" << std::endl;
-        }
-        else if (nspin0 == 2)
-        {
-            GlobalV::ofs_running << " Fermi energy (spin = 1) is " << this->pelec->eferm.ef_up << " Rydberg"
-                                 << std::endl;
-            GlobalV::ofs_running << " Fermi energy (spin = 2) is " << this->pelec->eferm.ef_dw << " Rydberg"
-                                 << std::endl;
-        }
+                               PARAM.inp.dos_sigma,
+                               GlobalV::ofs_running);
     }
 
     // out ldos
@@ -862,7 +851,7 @@ void ESolver_KS_PW<T, Device>::after_all_runners(UnitCell& ucell)
             ucell);
     }
 
-    //! 5) Calculate the spillage value, used to generate numerical atomic orbitals
+    //! 3) Calculate the spillage value, used to generate numerical atomic orbitals
     if (PARAM.inp.basis_type == "pw" && winput::out_spillage)
     {
         // ! Print out overlap matrices
@@ -882,13 +871,13 @@ void ESolver_KS_PW<T, Device>::after_all_runners(UnitCell& ucell)
         }
     }
 
-    //! 6) Print out electronic wave functions in real space
+    //! 4) Print out electronic wave functions in real space
     if (PARAM.inp.out_wfc_r == 1) // Peize Lin add 2021.11.21
     {
         ModuleIO::write_psi_r_1(ucell, this->psi[0], this->pw_wfc, "wfc_realspace", true, this->kv);
     }
 
-    //! 7) Use Kubo-Greenwood method to compute conductivities
+    //! 5) Use Kubo-Greenwood method to compute conductivities
     if (PARAM.inp.cal_cond)
     {
         EleCond<Real, Device> elec_cond(&ucell, &this->kv, this->pelec, this->pw_wfc, this->kspw_psi, &this->ppcell);
@@ -902,7 +891,7 @@ void ESolver_KS_PW<T, Device>::after_all_runners(UnitCell& ucell)
     }
 
 #ifdef __MLKEDF
-    // generate training data for ML-KEDF
+    //! 6) generate training data for ML-KEDF
     if (PARAM.inp.of_ml_gene_data == 1)
     {
         this->pelec->pot->update_from_charge(&this->chr, &ucell);