Merge branch 'gint-omp' of https://github.com/dzzz2001/abacus-develop into gint-omp

Author: dzzz2001

docs/advanced/input_files/input-main.md

@@ -153,6 +153,7 @@
     - [out\_mat\_t](#out_mat_t)
     - [out\_mat\_dh](#out_mat_dh)
     - [out\_mat\_xc](#out_mat_xc)
+    - [out\_mat\_xc2](#out_mat_xc2)
     - [out\_eband\_terms](#out_eband_terms)
     - [out\_hr\_npz/out\_dm\_npz](#out_hr_npzout_dm_npz)
     - [dm\_to\_rho](#dm_to_rho)
@@ -1799,6 +1800,13 @@ These variables are used to control the output of properties.
 The band (KS orbital) energy for each (k-point, spin, band) will be printed in the file `OUT.${suffix}/vxc_out.dat`. If EXX is calculated, the local and EXX part of band energy will also be printed in `OUT.${suffix}/vxc_local_out.dat`and `OUT.${suffix}/vxc_exx_out.dat`, respectively. All the `vxc*_out.dat` files contains 3 integers (nk, nspin, nband) followed by nk\*nspin\*nband lines of energy Hartree and eV.
 - **Default**: False
 
+### out_mat_xc2
+
+- **Type**: Boolean
+- **Availability**: Numerical atomic orbital (NAO) basis
+- **Description**: Whether to print the exchange-correlation matrices in **numerical orbital representation** (unit: Ry): $\braket{\phi_i|V_\text{xc}^\text{(semi-)local}+V_\text{exx}+V_\text{DFTU}|\phi_j}(\mathbf{R})$ in CSR format (the same format as [out_mat_hs2](../elec_properties/hs_matrix.md#out_mat_hs2)) in the directory `OUT.${suffix}`. (Note that currently DeePKS term is not included. ) The files are named `Vxc_R_spin$s`.
+- **Default**: False
+
 ### out_eband_terms
 
 - **Type**: Boolean

source/Makefile.Objects

@@ -208,7 +208,7 @@ OBJS_DEEPKS=LCAO_deepks.o\
         deepks_orbpre.o\
         deepks_vdelta.o\
         deepks_vdpre.o\
-        deepks_hmat.o\
+        deepks_vdrpre.o\
         deepks_pdm.o\
         deepks_phialpha.o\
         LCAO_deepks_io.o\
@@ -266,6 +266,7 @@ OBJS_ESOLVER_LCAO=esolver_ks_lcao.o\
       lcao_after_scf.o\
       esolver_gets.o\
       lcao_others.o\
+      esolver_dm2rho.o\
 
 OBJS_GINT=gint.o\
       gint_gamma_env.o\

source/module_base/formatter.h

@@ -191,17 +191,22 @@ class FmtTable
      * 
      * @param titles titles, its size should be the same as the number of columns
      * @param nrows number of rows
-     * @param aligns Alignments instance, can be constructed with initializer_list<char> like {'r', 'c'}, for right and center alignment for values and titles
+     * @param fmts format strings for each column, its size should be the same as the number of columns
+     * @param indent indent for each column, default is 0
+     * @param aligns Alignments instance, for alignment of values and titles, e.g. {Align::LEFT, Align::RIGHT} for left alignment of values and right alignment of titles
      * @param frames Frames instance, can be constructed with initializer_list<char> like {'-', '-', '-', ' ', ' '}, for up, middle, down, left and right frames
      * @param delimiters Delimiters instance, can be constructed with initializer_list<char> like {'-', ' '}, for horizontal and vertical delimiters
      */
     FmtTable(const std::vector<std::string>& titles, 
-             const size_t& nrows, 
+             const size_t nrows, 
              const std::vector<std::string>& fmts,
+             const size_t indent = 0,
              const Alignments& aligns = {},
              const Frames& frames = {},
-             const Delimiters& delimiters = {}): titles_(titles), data_(nrows, titles.size()), fmts_(fmts), aligns_(aligns), frames_(frames), delimiters_(delimiters)
-    { assert(titles.size() == fmts.size()); };
+             const Delimiters& delimiters = {}): 
+             titles_(titles), data_(nrows, titles.size()), // data
+             fmts_(fmts), indent_(indent), aligns_(aligns), frames_(frames), delimiters_(delimiters) // styles
+    { assert(titles.size() == fmts.size()||titles.size() == 0); };
     ~FmtTable() {};
     /**
      * @brief import data from std::vector
@@ -269,22 +274,24 @@ class FmtTable
      */
     std::string concat_title(const std::vector<std::string>& titles) const
     {
-        std::string dst;
+        std::string dst = "";
         // first sum width of all titles
         size_t width = std::accumulate(titles.begin(), titles.end(), 0, [](const size_t& acc, const std::string& s) { return acc + s.size(); });
         // add width of delimiters
         width += titles.size() - 1;
         // add width of left and right frames
         width += 2;
-        dst += std::string(width, frames_.up_) + "\n" + std::string(1, frames_.l_);
+        dst += std::string(indent_, ' ') + std::string(width, frames_.up_) + "\n"; // first line: the upper frame
+        dst += std::string(indent_, ' ') + std::string(1, frames_.l_); // second line: the left frame + titles + right frame
         for(size_t i = 0; i < titles.size(); i++)
         {
             dst += titles[i];
             if (i != titles.size() - 1) {
                 dst += delimiters_.v_;
             }
         }
-        dst += std::string(1, frames_.r_) + "\n" + std::string(width, frames_.mid_) + "\n";
+        dst += std::string(1, frames_.r_) + "\n";
+        dst += std::string(indent_, ' ') + std::string(width, frames_.mid_) + "\n"; // third line: the middle frame
         return dst;
     }
     /**
@@ -303,10 +310,10 @@ class FmtTable
         width += row.size() - 1;
         // for the left and right frame
         width += 2;
-        if (pos == 't') {
-            dst += std::string(width, frames_.up_) + "\n";
+        if (pos == 't') { // 't' for top
+            dst += std::string(indent_, ' ') + std::string(width, frames_.up_) + "\n";
         }
-        dst += std::string(1, frames_.l_);
+        dst += std::string(indent_, ' ') + std::string(1, frames_.l_);
         for(size_t i = 0; i < row.size(); i++)
         {
             dst += row[i];
@@ -315,8 +322,8 @@ class FmtTable
             }
         }
         dst += std::string(1, frames_.r_) + "\n";
-        if (pos == 'b') {
-            dst += std::string(width, frames_.dw_) + "\n";
+        if (pos == 'b') { // 'b' for bottom
+            dst += std::string(indent_, ' ') + std::string(width, frames_.dw_) + "\n"; // the last line
         }
         return dst;
     }
@@ -397,6 +404,7 @@ class FmtTable
     std::vector<std::string> titles_;
     NDArray<std::string> data_; // data
     std::vector<std::string> fmts_; // format strings for each column
+    size_t indent_ = 0; // indent for each column
 };
 
 #endif

source/module_base/test/formatter_test.cpp

@@ -217,6 +217,28 @@ TEST(FormatterTest, FmtTableDefaultArgs)
     EXPECT_EQ(result, ref);
 }
 
+TEST(FormatterTest, FmtTableHeadless)
+{
+    const std::vector<std::string> titles = {"", "", ""};
+    const std::vector<std::string> fmts = {"%s", "%d", "%f"};
+    FmtTable table(titles, 5, fmts);
+    const std::vector<std::string> col1 = {"row1", "row2", "row3", "row4", "row5"};
+    const std::vector<int> col2 = {1, 2, 3, 4, 5};
+    const std::vector<float> col3 = {1.1, 2.2, 3.3, 4.4, 5.5};
+    table << col1 << col2 << col3;
+    const std::string result = table.str();
+    std::cout << result << std::endl;
+    std::string ref = "";
+    ref += "-----------------\n";
+    ref += " row1 1 1.100000 \n";
+    ref += " row2 2 2.200000 \n";
+    ref += " row3 3 3.300000 \n";
+    ref += " row4 4 4.400000 \n";
+    ref += " row5 5 5.500000 \n";
+    ref += "-----------------\n";
+    EXPECT_EQ(result, ref);
+}
+
 TEST(FormatterTest, FmtTableCustomArgsAlign)
 {
     // shared data
@@ -226,7 +248,7 @@ TEST(FormatterTest, FmtTableCustomArgsAlign)
     std::vector<int> col2 = {1, 2, 3, 4, 5};
     std::vector<float> col3 = {1.1, 2.2, 3.3, 4.4, 5.5};
     // align: l and l
-    FmtTable table(titles, 5, fmts, {FmtTable::Align::LEFT, FmtTable::Align::LEFT});
+    FmtTable table(titles, 5, fmts, 0, {FmtTable::Align::LEFT, FmtTable::Align::LEFT});
     table << col1 << col2 << col3;
     std::string result = table.str();
     std::cout << result << std::endl;
@@ -243,7 +265,7 @@ TEST(FormatterTest, FmtTableCustomArgsAlign)
     EXPECT_EQ(result, ref);
 
     // align: r and r
-    FmtTable table2(titles, 5, fmts, {FmtTable::Align::RIGHT, FmtTable::Align::RIGHT});
+    FmtTable table2(titles, 5, fmts, 0, {FmtTable::Align::RIGHT, FmtTable::Align::RIGHT});
     table2 << col1 << col2 << col3;
     result = table2.str();
     std::cout << result << std::endl;
@@ -260,7 +282,7 @@ TEST(FormatterTest, FmtTableCustomArgsAlign)
     EXPECT_EQ(result, ref);
 
     // align: l and r
-    FmtTable table3(titles, 5, fmts, {FmtTable::Align::RIGHT, FmtTable::Align::LEFT});
+    FmtTable table3(titles, 5, fmts, 0, {FmtTable::Align::RIGHT, FmtTable::Align::LEFT});
     table3 << col1 << col2 << col3;
     result = table3.str();
     std::cout << result << std::endl;
@@ -277,7 +299,7 @@ TEST(FormatterTest, FmtTableCustomArgsAlign)
     EXPECT_EQ(result, ref);
 
     // align: r and l
-    FmtTable table4(titles, 5, fmts, {FmtTable::Align::LEFT, FmtTable::Align::RIGHT});
+    FmtTable table4(titles, 5, fmts, 0, {FmtTable::Align::LEFT, FmtTable::Align::RIGHT});
     table4 << col1 << col2 << col3;
     result = table4.str();
     std::cout << result << std::endl;
@@ -303,7 +325,12 @@ TEST(FormatterTest, FmtTableCustomArgsAlignFrame)
     std::vector<int> col2 = {1, 2, 3, 4, 5};
     std::vector<float> col3 = {1.1, 2.2, 3.3, 4.4, 5.5};
 
-    FmtTable table1(titles, 5, fmts, {FmtTable::Align::LEFT, FmtTable::Align::LEFT}, {'+', '?', '*', '.', '^'});
+    FmtTable table1(titles, 
+                    5, 
+                    fmts, 
+                    0, 
+                    {FmtTable::Align::LEFT, FmtTable::Align::LEFT}, 
+                    {'+', '?', '*', '.', '^'});
     table1 << col1 << col2 << col3;
     std::string result = table1.str();
     std::cout << result << std::endl;
@@ -328,7 +355,10 @@ TEST(FormatterTest, FmtTableCustomArgsAlignFrameDelim)
     std::vector<std::string> col1 = {"row1", "row2", "row3", "row4", "row5"};
     std::vector<int> col2 = {1, 2, 3, 4, 5};
     std::vector<float> col3 = {1.1, 2.2, 3.3, 4.4, 5.5};
-    FmtTable table1(titles, 5, fmts, 
+    FmtTable table1(titles, 
+                    5, 
+                    fmts, 
+                    0,
                     {FmtTable::Align::LEFT, FmtTable::Align::LEFT}, 
                     {'=', '/', '&', '#', '%'},
                     {'"', ']'});
@@ -348,6 +378,30 @@ TEST(FormatterTest, FmtTableCustomArgsAlignFrameDelim)
     EXPECT_EQ(result, ref);
 }
 
+TEST(FormatterTest, FmtTableCustomIndent)
+{
+    const std::vector<std::string> titles = {"title1", "t i t l e 2", "t-i-t-l-e-3"};
+    const std::vector<std::string> fmts = {"%s", "%d", "%f"};
+    FmtTable table(titles, 5, fmts, 4);
+    const std::vector<std::string> col1 = {"row1", "row2", "row3", "row4", "row5"};
+    const std::vector<int> col2 = {1, 2, 3, 4, 5};
+    const std::vector<float> col3 = {1.1, 2.2, 3.3, 4.4, 5.5};
+    table << col1 << col2 << col3;
+    const std::string result = table.str();
+    std::cout << result << std::endl;
+    std::string ref = "";
+    ref += "    --------------------------------\n";
+    ref += "     title1 t i t l e 2 t-i-t-l-e-3 \n";
+    ref += "    --------------------------------\n";
+    ref += "       row1           1    1.100000 \n";
+    ref += "       row2           2    2.200000 \n";
+    ref += "       row3           3    3.300000 \n";
+    ref += "       row4           4    4.400000 \n";
+    ref += "       row5           5    5.500000 \n";
+    ref += "    --------------------------------\n";
+    EXPECT_EQ(result, ref);
+}
+
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();

source/module_base/timer.cpp

@@ -300,7 +300,11 @@ void timer::print_all(std::ofstream &ofs)
 
 	std::vector<std::string> titles = {"CLASS_NAME", "NAME", "TIME/s", "CALLS", "AVG/s", "PER/%"};
 	std::vector<std::string> formats = {"%-10s", "%-10s", "%6.2f", "%8d", "%6.2f", "%6.2f"};
-	FmtTable time_statistics(titles, pers.size(), formats, {FmtTable::Align::LEFT, FmtTable::Align::CENTER});
+	FmtTable time_statistics(/*titles=*/titles, 
+							 /*nrows=*/pers.size(), 
+							 /*formats=*/formats, 
+							 /*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();
 	std::cout<<table<<std::endl;

source/module_elecstate/elecstate_lcao.cpp

@@ -23,32 +23,6 @@ void ElecStateLCAO<std::complex<double>>::psiToRho(const psi::Psi<std::complex<d
     ModuleBase::TITLE("ElecStateLCAO", "psiToRho");
     ModuleBase::timer::tick("ElecStateLCAO", "psiToRho");
 
-    // // the calculations of dm, and dm -> rho are, technically, two separate
-    // // functionalities, as we cannot rule out the possibility that we may have a
-    // // dm from other sources, such as read from file. However, since we are not
-    // // separating them now, I opt to add a flag to control how dm is obtained as
-    // // of now
-    // if (!PARAM.inp.dm_to_rho)
-    // {
-    //     ModuleBase::GlobalFunc::NOTE("Calculate the density matrix.");
-
-    //     // this part for calculating DMK in 2d-block format, not used for charge
-    //     // now
-    //     //    psi::Psi<std::complex<double>> dm_k_2d();
-
-    //     if (PARAM.inp.ks_solver == "genelpa" || PARAM.inp.ks_solver == "elpa" || PARAM.inp.ks_solver ==
-    //     "scalapack_gvx" || PARAM.inp.ks_solver == "lapack"
-    //         || PARAM.inp.ks_solver == "cusolver" || PARAM.inp.ks_solver == "cusolvermp"
-    //         || PARAM.inp.ks_solver == "cg_in_lcao") // Peize Lin test 2019-05-15
-    //     {
-    //         elecstate::cal_dm_psi(this->DM->get_paraV_pointer(),
-    //                               this->wg,
-    //                               psi,
-    //                               *(this->DM));
-    //         this->DM->cal_DMR();
-    //     }
-    // }
-
     for (int is = 0; is < PARAM.inp.nspin; is++)
     {
         ModuleBase::GlobalFunc::ZEROS(this->charge->rho[is],

source/module_elecstate/elecstate_print.cpp

@@ -430,10 +430,11 @@ void print_etot(const Magnetism& magnet,
     std::transform(energies_Ry.begin(), energies_Ry.end(), energies_eV.begin(), [](double ener) {
         return ener * ModuleBase::Ry_to_eV;
     });
-    FmtTable table({"Energy", "Rydberg", "eV"},
-                   titles.size(),
-                   {"%-14s", "%20.10f", "%20.10f"},
-                   {FmtTable::Align::LEFT, FmtTable::Align::CENTER});
+    FmtTable table(/*titles=*/{"Energy", "Rydberg", "eV"},
+                   /*nrows=*/titles.size(),
+                   /*formats=*/{"%-14s", "%20.10f", "%20.10f"}, 
+                   /*indents=*/0,
+                   /*align=*/{/*value*/FmtTable::Align::LEFT, /*title*/FmtTable::Align::CENTER});
     table << titles << energies_Ry << energies_eV;
     GlobalV::ofs_running << table.str() << std::endl;
     if (PARAM.inp.out_level == "ie" || PARAM.inp.out_level == "m") // xiaohui add 'm' option, 2015-09-16

source/module_esolver/CMakeLists.txt

@@ -20,6 +20,7 @@ if(ENABLE_LCAO)
       lcao_after_scf.cpp
       esolver_gets.cpp
       lcao_others.cpp
+      esolver_dm2rho.cpp
   )
 endif()
 

source/module_esolver/esolver.cpp

@@ -5,6 +5,7 @@
 #include "module_base/module_device/device.h"
 #include "module_parameter/parameter.h"
 #ifdef __LCAO
+#include "esolver_dm2rho.h"
 #include "esolver_gets.h"
 #include "esolver_ks_lcao.h"
 #include "esolver_ks_lcao_tddft.h"
@@ -204,11 +205,25 @@ ESolver* init_esolver(const Input_para& inp, UnitCell& ucell)
         }
         else if (PARAM.inp.nspin < 4)
         {
-            return new ESolver_KS_LCAO<std::complex<double>, double>();
+            if (PARAM.inp.dm_to_rho)
+            {
+                return new ESolver_DM2rho<std::complex<double>, double>();
+            }
+            else
+            {
+                return new ESolver_KS_LCAO<std::complex<double>, double>();
+            }
         }
         else
         {
-            return new ESolver_KS_LCAO<std::complex<double>, std::complex<double>>();
+            if (PARAM.inp.dm_to_rho)
+            {
+                return new ESolver_DM2rho<std::complex<double>, std::complex<double>>();
+            }
+            else
+            {
+                return new ESolver_KS_LCAO<std::complex<double>, std::complex<double>>();
+            }
         }
     }
     else if (esolver_type == "ksdft_lcao_tddft")