Fix: correct append mode for out_wfc_lcao output (backport deepmodeling#5914)

The out_app_flag semantics were broken in write_wfc_nao: the text path
always opened with truncation and the binary path always with 'a'. With
out_app_flag=1 (append all MD steps to one WFC_NAO file) every step
overwrote the previous text file, so only the last step survived; with
out_app_flag=0 (per-step _ION files) re-running in the same directory
appended new blocks to stale binary files.

- Thread an explicit append_flag (istep > 0 && out_app_flag) through
  wfc_nao_write2file/wfc_nao_write2file_complex.
- Open text output with std::ofstream::app when appending and truncate
  otherwise; open Binstream with 'a'/'w' accordingly.
- The LTS setprecision(25) text format is kept unchanged.

Verified with a 2-step LCAO MD (out_wfc_lcao=1/2): text+append produces
one WFC_NAO_K1.txt containing both steps (28544 = 2 x 14272 bytes);
binary+append produces WFC_NAO_K1.dat = 2 x 3524; binary without append
produces one-block ION1/ION3 .dat files. Before the fix the text file
kept only the last step and binary re-runs accumulated duplicate blocks.
The 220_NO_KP_MD_wfc_out integrate case passes (Compare_wfc_lcao_pass 0).

Author: dyzheng

source/module_io/write_wfc_nao.cpp

@@ -46,156 +46,186 @@ std::string wfc_nao_gen_fname(const int out_type,
     return fn_out;
 }
 
-void wfc_nao_write2file(const std::string &name, const double* ctot, const int nlocal, const int ik, const ModuleBase::matrix& ekb, const ModuleBase::matrix& wg, bool writeBinary)
+void wfc_nao_write2file(const std::string& name,
+                        const double* ctot,
+                        const int nlocal,
+                        const int ik,
+                        const ModuleBase::matrix& ekb,
+                        const ModuleBase::matrix& wg,
+                        const bool& writeBinary,
+                        const bool& append_flag)
 {
     ModuleBase::TITLE("ModuleIO", "write_wfc_nao");
     ModuleBase::timer::tick("ModuleIO", "write_wfc_nao");
 
-    //if (GlobalV::DRANK == 0)
+    int nbands = ekb.nc;
+
+    if (writeBinary)
     {
-        int nbands = ekb.nc;
-        
-        if (writeBinary)
+        Binstream ofs;
+        if (append_flag)
         {
-            Binstream ofs(name, "a");
-            if (!ofs)
-            {
-                ModuleBase::WARNING("ModuleIO::write_wfc_nao", "Can't write local orbital wave functions.");
-            }
+            ofs.open(name, "a");
+        }
+        else
+        {
+            ofs.open(name, "w");
+        }
+        if (!ofs)
+        {
+            ModuleBase::WARNING("ModuleIO::write_wfc_nao", "Can't write local orbital wave functions.");
+        }
 
-            ofs << nbands;
-            ofs << nlocal;
+        ofs << nbands;
+        ofs << nlocal;
 
-            for (int i = 0; i < nbands; i++)
-            {
-                ofs << i+1;
-                ofs << ekb(ik, i);
-                ofs << wg(ik, i);
+        for (int i = 0; i < nbands; i++)
+        {
+            ofs << i + 1;
+            ofs << ekb(ik, i);
+            ofs << wg(ik, i);
 
-                for (int j = 0; j < nlocal; j++)
-                {
-                    ofs << ctot[i*nlocal + j];
-                }
+            for (int j = 0; j < nlocal; j++)
+            {
+                ofs << ctot[i * nlocal + j];
             }
-            ofs.close();
+        }
+        ofs.close();
+    }
+    else
+    {
+        std::ofstream ofs;
+        if (append_flag)
+        {
+            ofs.open(name.c_str(), std::ofstream::app);
         }
         else
         {
-            std::ofstream ofs;
-            // if (PARAM.inp.out_app_flag)
-            // {
-            //     ofs.open(name.c_str(), std::ofstream::app);
-            // }
-            // else
-            {   // the default value of `out_app_flag`is true, but usually there's no use to save each step's LCAO wave function.
-                ofs.open(name.c_str());
-            }
-            if (!ofs)
-            {
-                ModuleBase::WARNING("ModuleIO::write_wfc_nao", "Can't write local orbital wave functions.");
-            }
-            ofs << nbands << " (number of bands)" << std::endl;
-            ofs << nlocal << " (number of orbitals)";
-            ofs << std::setprecision(8);
-            ofs << std::scientific;
+            ofs.open(name.c_str());
+        }
+        if (!ofs)
+        {
+            ModuleBase::WARNING("ModuleIO::write_wfc_nao", "Can't write local orbital wave functions.");
+        }
+        ofs << nbands << " (number of bands)" << std::endl;
+        ofs << nlocal << " (number of orbitals)";
+        ofs << std::setprecision(8);
+        ofs << std::scientific;
 
-            for (int i=0; i<nbands; i++)
+        for (int i = 0; i < nbands; i++)
+        {
+            // +1 to mean more clearly.
+            // band index start from 1.
+            ofs << "\n" << i + 1 << " (band)";
+            ofs << "\n" << ekb(ik, i) << " (Ry)";
+            ofs << "\n" << wg(ik, i) << " (Occupations)";
+            for (int j = 0; j < nlocal; j++)
             {
-                // +1 to mean more clearly.
-                // band index start from 1.
-                ofs << "\n" << i+1 << " (band)";
-		    	ofs << "\n" << ekb(ik, i) << " (Ry)";
-		    	ofs << "\n" << wg(ik,i) << " (Occupations)";
-                for (int j=0; j<nlocal; j++)
+                if (j % 5 == 0)
                 {
-                    if (j % 5 == 0) ofs << "\n";
-                    ofs << ctot[i*nlocal + j] << " ";
+                    ofs << "\n";
                 }
+                ofs << ctot[i * nlocal + j] << " ";
             }
-            ofs << std::endl;
-            ofs.close();
         }
+        ofs << std::endl;
+        ofs.close();
     }
 
     ModuleBase::timer::tick("ModuleIO", "write_wfc_nao");
     return;
 }
 
-void wfc_nao_write2file_complex(const std::string &name, const std::complex<double>* ctot, const int nlocal,const int &ik, const ModuleBase::Vector3<double> &kvec_c, const ModuleBase::matrix& ekb, const ModuleBase::matrix& wg, bool writeBinary)
+void wfc_nao_write2file_complex(const std::string& name,
+                                const std::complex<double>* ctot,
+                                const int nlocal,
+                                const int& ik,
+                                const ModuleBase::Vector3<double>& kvec_c,
+                                const ModuleBase::matrix& ekb,
+                                const ModuleBase::matrix& wg,
+                                const bool& writeBinary,
+                                const bool& append_flag)
 {
     ModuleBase::TITLE("ModuleIO","write_wfc_nao_complex");
     ModuleBase::timer::tick("ModuleIO","write_wfc_nao_complex");
 
-    
-    //if (GlobalV::DRANK==0)
+    int nbands = ekb.nc;
+
+    if (writeBinary)
     {
-        int nbands = ekb.nc;
+        Binstream ofs;
+        if (append_flag)
+        {
+            ofs.open(name, "a");
+        }
+        else
+        {
+            ofs.open(name, "w");
+        }
+        if (!ofs)
+        {
+            ModuleBase::WARNING("ModuleIO::write_wfc_nao", "Can't write local orbital wave functions.");
+        }
+        ofs << ik + 1;
+        ofs << kvec_c.x;
+        ofs << kvec_c.y;
+        ofs << kvec_c.z;
+        ofs << nbands;
+        ofs << nlocal;
 
-        if (writeBinary)
+        for (int i = 0; i < nbands; i++)
         {
-            Binstream ofs(name, "a");
-            if (!ofs)
-            {
-                ModuleBase::WARNING("ModuleIO::write_wfc_nao", "Can't write local orbital wave functions.");
-            }
-            ofs << ik+1;
-            ofs << kvec_c.x;
-            ofs << kvec_c.y;
-            ofs << kvec_c.z;
-            ofs << nbands;
-            ofs << nlocal;
+            ofs << i + 1;
+            ofs << ekb(ik, i);
+            ofs << wg(ik, i);
 
-            for (int i = 0; i < nbands; i++)
+            for (int j = 0; j < nlocal; j++)
             {
-                ofs << i+1;
-                ofs << ekb(ik, i);
-                ofs << wg(ik, i);
-
-                for (int j = 0; j < nlocal; j++)
-                {
-                    ofs << ctot[i*nlocal + j].real() << ctot[i*nlocal + j].imag();
-                }
+                ofs << ctot[i * nlocal + j].real() << ctot[i * nlocal + j].imag();
             }
-            ofs.close();
+        }
+        ofs.close();
+    }
+    else
+    {
+        std::ofstream ofs;
+        if (append_flag)
+        {
+            ofs.open(name.c_str(), std::ofstream::app);
         }
         else
         {
-            std::ofstream ofs;
-            // if (PARAM.inp.out_app_flag)
-            // {
-            //     ofs.open(name.c_str(), std::ofstream::app);
-            // }
-            // else
-            {   // the default value of `out_app_flag`is true, but usually there's no use to save each step's LCAO wave function.
-                ofs.open(name.c_str());
-            }
-            if (!ofs)
-            {
-                ModuleBase::WARNING("ModuleIO::write_wfc_nao","Can't write local orbital wave functions.");
-            }
-            ofs << std::setprecision(25);
-		    ofs << ik+1 << " (index of k points)" << std::endl;
-		    ofs << kvec_c.x << " " << kvec_c.y << " " << kvec_c.z << std::endl;
-            ofs << nbands << " (number of bands)" << std::endl;
-            ofs << nlocal << " (number of orbitals)";
-            ofs << std::scientific;
+            ofs.open(name.c_str());
+        }
+        if (!ofs)
+        {
+            ModuleBase::WARNING("ModuleIO::write_wfc_nao", "Can't write local orbital wave functions.");
+        }
+        ofs << std::setprecision(25);
+        ofs << ik + 1 << " (index of k points)" << std::endl;
+        ofs << kvec_c.x << " " << kvec_c.y << " " << kvec_c.z << std::endl;
+        ofs << nbands << " (number of bands)" << std::endl;
+        ofs << nlocal << " (number of orbitals)";
+        ofs << std::scientific;
 
-            for (int i=0; i<nbands; i++)
+        for (int i = 0; i < nbands; i++)
+        {
+            // +1 to mean more clearly.
+            // band index start from 1.
+            ofs << "\n" << i + 1 << " (band)";
+            ofs << "\n" << ekb(ik, i) << " (Ry)";
+            ofs << "\n" << wg(ik, i) << " (Occupations)";
+            for (int j = 0; j < nlocal; j++)
             {
-                // +1 to mean more clearly.
-                // band index start from 1.
-                ofs << "\n" << i+1 << " (band)";
-		    	ofs << "\n" << ekb(ik, i) << " (Ry)";
-		    	ofs << "\n" << wg(ik,i) << " (Occupations)";
-                for (int j=0; j<nlocal; j++)
+                if (j % 5 == 0)
                 {
-                    if (j % 5 == 0) ofs << "\n";
-                    ofs << ctot[i*nlocal + j].real() << " " << ctot[i*nlocal + j].imag() << " ";
+                    ofs << "\n";
                 }
+                ofs << ctot[i * nlocal + j].real() << " " << ctot[i * nlocal + j].imag() << " ";
             }
-            ofs << std::endl;
-            ofs.close();
         }
+        ofs << std::endl;
+        ofs.close();
     }
 
     ModuleBase::timer::tick("ModuleIO","write_wfc_nao_complex");
@@ -267,20 +297,29 @@ void write_wfc_nao(const int out_type,
         if (myid == 0)
         {
             std::string fn = PARAM.globalv.global_out_dir + wfc_nao_gen_fname(out_type, gamma_only, PARAM.inp.out_app_flag, ik, istep);
+            bool append_flag = (istep > 0 && PARAM.inp.out_app_flag);
             if (std::is_same<double, T>::value)
             {
-                wfc_nao_write2file(fn, reinterpret_cast<double*>(ctot.data()), nlocal, ik, ekb, wg, writeBinary);
+                wfc_nao_write2file(fn,
+                                   reinterpret_cast<double*>(ctot.data()),
+                                   nlocal,
+                                   ik,
+                                   ekb,
+                                   wg,
+                                   writeBinary,
+                                   append_flag);
             }
             else
             {
                 wfc_nao_write2file_complex(fn,
-                                      reinterpret_cast<std::complex<double>*>(ctot.data()),
-                                      nlocal,
-                                      ik,
-                                      kvec_c[ik],
-                                      ekb,
-                                      wg,
-                                      writeBinary);
+                                           reinterpret_cast<std::complex<double>*>(ctot.data()),
+                                           nlocal,
+                                           ik,
+                                           kvec_c[ik],
+                                           ekb,
+                                           wg,
+                                           writeBinary,
+                                           append_flag);
             }
         }
     }

source/module_io/write_wfc_nao.h

@@ -48,7 +48,22 @@ void write_wfc_nao(const int out_type,
                     const Parallel_Orbitals& pv,
                     const int istep=-1) ;
 
-void wfc_nao_write2file(const std::string &name, const double* ctot, const int nlocal, const int ik, const ModuleBase::matrix& ekb, const ModuleBase::matrix& wg, bool writeBinary);
-void wfc_nao_write2file_complex(const std::string &name, const std::complex<double>* ctot, const int nlocal,const int &ik, const ModuleBase::Vector3<double> &kvec_c, const ModuleBase::matrix& ekb, const ModuleBase::matrix& wg, bool writeBinary=false);
+void wfc_nao_write2file(const std::string& name,
+                        const double* ctot,
+                        const int nlocal,
+                        const int ik,
+                        const ModuleBase::matrix& ekb,
+                        const ModuleBase::matrix& wg,
+                        const bool& writeBinary,
+                        const bool& append_flag = false);
+void wfc_nao_write2file_complex(const std::string& name,
+                                const std::complex<double>* ctot,
+                                const int nlocal,
+                                const int& ik,
+                                const ModuleBase::Vector3<double>& kvec_c,
+                                const ModuleBase::matrix& ekb,
+                                const ModuleBase::matrix& wg,
+                                const bool& writeBinary = false,
+                                const bool& append_flag = false);
 }// namespace ModuleIO
-#endif
+#endif