Fix uncommitted changes from previously

Makefile

 SRC_EXT = cc
 
 # Compiler choice
-CXX = g++-11.2
+CXX = g++
 CXXFLAGS = -fopenmp
 LDFLAGS = -O3 -w -fopenmp
 # Compilation command
 ###########################################
 # Parallel version
 
-.PHONE: parallel
+.PHONY: parallel
 parallel : $(EXECUTABLES_PAR)
 
 $(EXECUTABLES_PAR): $(BIN_DIR)/%: $(SRC_DIR)/EXECS/%.$(SRC_EXT) $(LIB_DIR)/lib$(VERSION).a

include/ABACUS_Scan.h

   // Functions in src/UTILS/Data_File_Name.cc:
   void Data_File_Name (std::stringstream& name, char whichDSF, DP c_int, DP L, int N,
 		       int iKmin, int iKmax, DP kBT, DP L2, std::string defaultname);
+  std::string Data_Filename (char whichDSF, DP c_int, DP L, int N,
+			     int iKmin, int iKmax, DP kBT, DP L2, std::string defaultname);
   void Data_File_Name (std::stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT,
 		       LiebLin_Bethe_State& State, LiebLin_Bethe_State& RefScanState, std::string defaultname);
+  std::string Data_Filename (char whichDSF, int iKmin, int iKmax, DP kBT,
+			     LiebLin_Bethe_State& State, LiebLin_Bethe_State& RefScanState, std::string defaultname);
   void Data_File_Name (std::stringstream& name, char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
 		       DP kBT, int N2, std::string defaultname);
+  std::string Data_Filename (char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
+			     DP kBT, int N2, std::string defaultname);
   void Data_File_Name (std::stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT,
 		       Heis_Bethe_State& State, Heis_Bethe_State& RefScanState, std::string defaultname);
+  std::string Data_Filename (char whichDSF, int iKmin, int iKmax, DP kBT,
+			     Heis_Bethe_State& State, Heis_Bethe_State& RefScanState, std::string defaultname);
   void ODSLF_Data_File_Name (std::stringstream& name, char whichDSF, DP Delta, int N, int M,
 			     int iKmin, int iKmax, DP kBT, int N2, std::string defaultname);
   void Data_File_Name (std::stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT,
     Scan_Info();  // constructor, puts everything to zero
     Scan_Info (DP sr, DP Nf, long long int Ni, long long int Nd, long long int Ndc, long long int Ndc0, double t);
 
-    void Save (const char* outfile_Cstr);
-    void Load (const char* infile_Cstr);
+    // void Save (const char* outfile_Cstr);
+    // void Load (const char* infile_Cstr);
+    void Save (std::string outfile_str);
+    void Load (std::string infile_str);
 
     inline Scan_Info& operator = (const Scan_Info& ref_info)
     {
     inline void Raise_Scanning_Flags (DP threshold); // checks whether base/type should be scanned based on simpler base/type combinations
 
     inline void Order_in_SRC ();
-    inline void Save_Info (const char* sumfile_Cstr);
-    inline void Load_Info (const char* sumfile_Cstr);
+    // inline void Save_Info (const char* sumfile_Cstr);
+    // inline void Load_Info (const char* sumfile_Cstr);
+    inline void Save_Info (std::string sumfile_str);
+    inline void Load_Info (std::string sumfile_str);
   };
 
   // Do the explicit class specializations:
     }
 
   template<class Tstate>
-    inline void Scan_State_List<Tstate>::Save_Info (const char* sumfile_Cstr)
+  inline void Scan_State_List<Tstate>::Save_Info (std::string sumfile_str)
     {
       std::ofstream outfile;
 
-      outfile.open(sumfile_Cstr);
+      outfile.open(sumfile_str);
       if (outfile.fail()) ABACUSerror("Could not open outfile... ");
 
       outfile.setf(std::ios::fixed);
     }
 
   template<class Tstate>
-    inline void Scan_State_List<Tstate>::Load_Info (const char* sumfile_Cstr)
+  inline void Scan_State_List<Tstate>::Load_Info (std::string sumfile_str)
     {
       std::ifstream infile;
-      infile.open(sumfile_Cstr);
+      infile.open(sumfile_str);
       if(infile.fail()) {
-	std::cout << std::endl << sumfile_Cstr << std::endl;
+	std::cout << std::endl << sumfile_str << std::endl;
 	ABACUSerror("Could not open input file in Scan_State_List::Load_Info.");
       }
 

include/ABACUS_Utils.h

 
   // Inexplicably missing string functions in standard library:
 
+  inline std::string DP_to_string (DP value) {
+    std::stringstream s;
+    s << std::setprecision(16) << value;
+    return s.str();
+  }
+
   inline std::string replace(const std::string& str,
 			     const std::string& from,
 			     const std::string& to) {

scripts/Histograms.py

 for datafilename in args.filenames:
 	data = numpy.loadtxt(datafilename, delimiter="\t", usecols=[0,1,2,3])
 	x = [line[0] for line in data]
-	y = [line[3] for line in data]
+	y = [line[2] for line in data]
 	fig.add_trace(go.Bar(x=x, y=y))
 fig.show()

src/SCAN/General_Scan.cc

     int Max_Secs_used = int(0.9 * Max_Secs); // we don't start any new ithread loop beyond this point
     int Max_Secs_alert = int(0.95 * Max_Secs); // we break any ongoing ithread loop beyond this point
 
+    /* TO_STR
     stringstream filenameprefix;
     Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, kBT,
 		    AveragingState, SeedScanState, defaultScanStatename);
 	filenameprefix << "_" << rank[r] << "_" << nr_processors[r];
 
     string prefix = filenameprefix.str();
+    */
+    string prefix = Data_Filename(whichDSF, iKmin, iKmax, kBT,
+				  AveragingState, SeedScanState, defaultScanStatename);
+    if (in_parallel)
+      for (int r = 0; r < paralevel; ++r)
+	prefix += "_" + to_string(rank[r]) + "_" + to_string(nr_processors[r]);
 
+    /* TO_STR
     stringstream filenameprefix_prevparalevel;
     // without the rank and nr_processors of the highest paralevel
 
 		       filenameprefix << "_" << rank[r] << "_" << nr_processors[r];
 
     string prefix_prevparalevel = filenameprefix_prevparalevel.str();
+    */
+    // without the rank and nr_processors of the highest paralevel
+    string prefix_prevparalevel = Data_Filename(whichDSF, iKmin, iKmax, kBT,
+						AveragingState, SeedScanState, defaultScanStatename);
+    if (in_parallel)
+      for (int r = 0; r < paralevel - 1; ++r)
+	prefix_prevparalevel += "_" + to_string(rank[r]) + "_" + to_string(nr_processors[r]);
 
+    /* TO_STR
     stringstream RAW_stringstream;    string RAW_string;
     stringstream INADM_stringstream;    string INADM_string;
     stringstream CONV0_stringstream;    string CONV0_string;
     SUM_string = SUM_stringstream.str();    const char* SUM_Cstr = SUM_string.c_str();
 
     THRDIR_string = THRDIR_stringstream.str();
+    */
+    string RAW_str = prefix + ".raw";
+    string INADM_str = prefix + ".inadm";
+    string CONV0_str = prefix + ".conv0";
+    string STAT_str = prefix + ".stat";
+    string LOG_str = prefix + ".log";
+    string THR_str = prefix + ".thr";
+    string THRDIR_str = prefix + "_thrdir";
+    string SRC_str = prefix + ".src";
+    string SUM_str = prefix + ".sum";
+
 
     fstream RAW_outfile;
-    if (!refine || in_parallel) RAW_outfile.open(RAW_Cstr, fstream::out | fstream::trunc);
-    else RAW_outfile.open(RAW_Cstr, fstream::out | fstream::app);
+    if (!refine || in_parallel) RAW_outfile.open(RAW_str, fstream::out | fstream::trunc);
+    else RAW_outfile.open(RAW_str, fstream::out | fstream::app);
     if (RAW_outfile.fail()) {
-      cout << RAW_Cstr << endl;
+      cout << RAW_str << endl;
       ABACUSerror("Could not open RAW_outfile... ");
     }
     RAW_outfile.precision(16);
 
     fstream INADM_outfile;
-    if (!refine || in_parallel) INADM_outfile.open(INADM_Cstr, fstream::out | fstream::trunc);
-    else INADM_outfile.open(INADM_Cstr, fstream::out | fstream::app);
+    if (!refine || in_parallel) INADM_outfile.open(INADM_str, fstream::out | fstream::trunc);
+    else INADM_outfile.open(INADM_str, fstream::out | fstream::app);
     if (INADM_outfile.fail()) ABACUSerror("Could not open INADM_outfile... ");
     INADM_outfile.precision(16);
 
     fstream CONV0_outfile;
-    if (!refine || in_parallel) CONV0_outfile.open(CONV0_Cstr, fstream::out | fstream::trunc);
-    else CONV0_outfile.open(CONV0_Cstr, fstream::out | fstream::app);
+    if (!refine || in_parallel) CONV0_outfile.open(CONV0_str, fstream::out | fstream::trunc);
+    else CONV0_outfile.open(CONV0_str, fstream::out | fstream::app);
     if (CONV0_outfile.fail()) ABACUSerror("Could not open CONV0_outfile... ");
     CONV0_outfile.precision(16);
 
     fstream STAT_outfile;
-    if (!refine || in_parallel) STAT_outfile.open(STAT_Cstr, fstream::out | fstream::trunc);
-    else STAT_outfile.open(STAT_Cstr, fstream::out | fstream::app);
+    if (!refine || in_parallel) STAT_outfile.open(STAT_str, fstream::out | fstream::trunc);
+    else STAT_outfile.open(STAT_str, fstream::out | fstream::app);
     if (STAT_outfile.fail()) ABACUSerror("Could not open STAT_outfile... ");
     STAT_outfile.precision(8);
 
     ofstream LOG_outfile;
     if (!in_parallel) {
-      if (!refine) LOG_outfile.open(LOG_Cstr, fstream::out | fstream::trunc);
-      else LOG_outfile.open(LOG_Cstr, fstream::out | fstream::app);
+      if (!refine) LOG_outfile.open(LOG_str, fstream::out | fstream::trunc);
+      else LOG_outfile.open(LOG_str, fstream::out | fstream::app);
       if (LOG_outfile.fail()) ABACUSerror("Could not open LOG_outfile... ");
       LOG_outfile.precision(16);
     }
     else { // in_parallel
-      LOG_outfile.open(LOG_Cstr, fstream::out | fstream::trunc);
+      LOG_outfile.open(LOG_str, fstream::out | fstream::trunc);
       if (LOG_outfile.fail()) ABACUSerror("Could not open LOG_outfile... ");
       LOG_outfile.precision(16);
     }
 
     Scan_Info scan_info;
 
-    if (!refine) mkdir(THRDIR_string.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
-    Scan_Thread_Data paused_thread_data (THRDIR_string, refine);
+    if (!refine) mkdir(THRDIR_str.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
+    Scan_Thread_Data paused_thread_data (THRDIR_str, refine);
 
     if (refine) {
       paused_thread_data.Load();
-      if (!in_parallel) scan_info.Load(SRC_Cstr);
+      if (!in_parallel) scan_info.Load(SRC_str);
     }
 
     Scan_Info scan_info_before = scan_info;  // for LOG file
     Scan_State_List<Tstate> ScanStateList (whichDSF, SeedScanState);
     ScanStateList.Populate_List(whichDSF, SeedScanState);
 
-    if (refine && !in_parallel) ScanStateList.Load_Info (SUM_Cstr);
+    if (refine && !in_parallel) ScanStateList.Load_Info (SUM_str);
     else if (in_parallel && rank.sum() == 0) {}; // do nothing, keep info in the higher .sum file!
 
     DP Chem_Pot = Chemical_Potential (AveragingState);
     CONV0_outfile.close();
     STAT_outfile.close();
 
-    scan_info.Save(SRC_Cstr);
+    scan_info.Save(SRC_str);
 
     Scan_Info scan_info_refine = scan_info;
     scan_info_refine -= scan_info_before;
 
     ScanStateList.Order_in_SRC ();
 
-    ScanStateList.Save_Info (SUM_Cstr);
+    ScanStateList.Save_Info (SUM_str);
 
 
     // Evaluate f-sumrule:
     // Construct the finite-size saddle-point state:
     // if we refine, read the quantum numbers of the saddle point state (and seed sps) from the sps file:
 
+    /* TO_STR
     stringstream SPS_stringstream;  string SPS_string;
     Data_File_Name (SPS_stringstream, whichDSF, c_int, L, N, iKmin, iKmax, kBT, 0.0, "");
     SPS_stringstream << ".sps";
     SPS_string = SPS_stringstream.str();    const char* SPS_Cstr = SPS_string.c_str();
+    */
+    string SPS_str = Data_Filename (whichDSF, c_int, L, N, iKmin, iKmax, kBT, 0.0, "") + ".sps";
 
     fstream spsfile;
-    if (refine) spsfile.open(SPS_Cstr, fstream::in);
-    else spsfile.open(SPS_Cstr, fstream::out | fstream::trunc);
+    if (refine) spsfile.open(SPS_str, fstream::in);
+    else spsfile.open(SPS_str, fstream::out | fstream::trunc);
     if (spsfile.fail()) {
-      cout << SPS_Cstr << endl; ABACUSerror("Could not open spsfile.");
+      cout << SPS_str << endl; ABACUSerror("Could not open spsfile.");
     }
 
     LiebLin_Bethe_State spstate;

src/SCAN/Scan_Info.cc

   Scan_Info::Scan_Info (DP sr, DP Nf, long long int Ni, long long int Nd, long long int Ndc, long long int Ndc0, double t) :
     sumrule_obtained(sr), Nfull(Nf), Ninadm(Ni), Ndata(Nd), Ndata_conv(Ndc), Ndata_conv0(Ndc0), TT(t) {}
 
-  void Scan_Info::Save (const char* outfile_Cstr)
+  //void Scan_Info::Save (const char* outfile_Cstr)
+  void Scan_Info::Save (string outfile_str)
   {
     ofstream outfile;
 
-    outfile.open(outfile_Cstr);
+    outfile.open(outfile_str);
     if (outfile.fail()) ABACUSerror("Could not open outfile... ");
 
     outfile.precision(16);
     return;
   }
 
-  void Scan_Info::Load (const char* infile_Cstr)
+  //void Scan_Info::Load (const char* infile_Cstr)
+  void Scan_Info::Load (string infile_str)
   {
     ifstream infile;
-    infile.open(infile_Cstr);
+    infile.open(infile_str);
     if(infile.fail()) {
-      cout << endl << infile_Cstr << endl;
+      cout << endl << infile_str << endl;
       ABACUSerror("Could not open input file in Scan_Info::Load.");
     }
 

src/UTILS/Data_File_Name.cc

     return;
   }
 
+  string Data_Filename (char whichDSF, DP c_int, DP L, int N, int iKmin, int iKmax,
+			DP kBT, DP L2, string defaultScanStatename)
+  {
+    string name = "LiebLin_";
+    if (whichDSF == 'Z') name += "Z";
+    else if (whichDSF == 'd') name += "rho-rho";
+    else if (whichDSF == 'g') name += "psi-psidag";
+    else if (whichDSF == 'o') name += "psidag-psi";
+    else if (whichDSF == 'q') name += "GeomQuench";
+    else if (whichDSF == '1') name += "Type_I_Exp_Data";
+    else if (whichDSF == 'B') name += "BECg2";
+    else if (whichDSF == 'C') name += "BECoverlap";
+    else ABACUSerror("Option not implemented in Data_File_Name");
+
+    name += "_c_" + DP_to_string(c_int) + "_L_" + DP_to_string(L) + "_N_" + to_string(N);
+    if (defaultScanStatename == "") name += "_" + to_string(N) + "_0_"; // simulates label of ground state
+    else name += "_" + defaultScanStatename;
+    if (iKmin == iKmax) name += "_iK_" + to_string(iKmin);
+    else name += "_iKmin_" + to_string(iKmin) + "_iKmax_" + to_string(iKmax);
+    if (kBT > 0.0) name += "_kBT_" + DP_to_string(kBT);
+    if (whichDSF == 'q') name += "_L2_" + DP_to_string(L2);
+
+    return(name);
+  }
+
+
   void Data_File_Name (stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT,
 		       LiebLin_Bethe_State& State, LiebLin_Bethe_State& RefScanState, string defaultScanStatename)
   {
     return;
   }
 
+  string Data_Filename (char whichDSF, int iKmin, int iKmax, DP kBT,
+			LiebLin_Bethe_State& State, LiebLin_Bethe_State& RefScanState,
+			string defaultScanStatename)
+  {
+    string name = "LiebLin_";
+    if (whichDSF == 'Z') name += "Z";
+    else if (whichDSF == 'd') name += "rho-rho";
+    else if (whichDSF == 'g') name += "psi-psidag";
+    else if (whichDSF == 'o') name += "psidag-psi";
+    else if (whichDSF == 'q') name += "GeomQuench";
+    else if (whichDSF == '1') name += "Type_I_Exp_Data";
+    else if (whichDSF == 'B') name += "BECg2";
+    else if (whichDSF == 'C') name += "BECoverlap";
+    else ABACUSerror("Option not implemented in Data_File_Name");
+
+    name += "_c_" + DP_to_string(State.c_int) + "_L_" + DP_to_string(State.L) + "_N_" + to_string(State.N);
+    if (defaultScanStatename == "") name += "_" + State.label;
+    else name += "_" + defaultScanStatename;
+    if (iKmin == iKmax) name += "_iK_" + to_string(iKmin);
+    else name += "_iKmin_" + to_string(iKmin) + "_iKmax_" + to_string(iKmax);
+    if (kBT > 0.0) name += "_kBT_" + DP_to_string(kBT);
+    if (whichDSF == 'q') name += "_L2_" + DP_to_string(RefScanState.L);
+
+    return(name);
+  }
+
 
   // Heisenberg:
 
     return;
   }
 
+  string Data_Filename (char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
+			DP kBT, int N2, string defaultScanStatename)
+  {
+    string name = "HEIS_";
+    if (whichDSF == 'Z') name += "Z";
+    else if (whichDSF == 'm') name += "Smp";
+    else if (whichDSF == 'z') name += "Szz";
+    else if (whichDSF == 'p') name += "Spm";
+    else if (whichDSF == 'a') name += "SzSz";
+    else if (whichDSF == 'b') name += "SzSm";
+    else if (whichDSF == 'c') name += "SmSm";
+    else if (whichDSF == 'q') name += "GeomQuench";
+    else {
+      cout << "Option tried (1): " << whichDSF << endl;
+      ABACUSerror("Option not implemented in Data_File_Name");
+    }
+
+    name += "_D_" + to_string(Delta) + "_N_" + to_string(N) + "_M_";
+    for (int i = 0; i < int(log10(DP(N/2))) - int(log10(DP(M))); ++i) name += "0";
+    name += to_string(M);
+    if (defaultScanStatename == "") name += "_" + to_string(M) + "_0_"; // simulates label of ground state
+    else name += "_" + defaultScanStatename;
+
+    if (kBT > 0.0) name += "_kBT_" + to_string(kBT);
+    if (whichDSF == 'q') name += "_N2_" + to_string(N2);
+
+    return(name);
+  }
+
   void Data_File_Name (stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT,
 		       Heis_Bethe_State& State, Heis_Bethe_State& RefScanState, string defaultScanStatename)
   {
     return;
   }
 
+  string Data_Filename (char whichDSF, int iKmin, int iKmax, DP kBT,
+			Heis_Bethe_State& State, Heis_Bethe_State& RefScanState, string defaultScanStatename)
+  {
+    string name = "HEIS_";
+    if (whichDSF == 'Z') name += "Z";
+    else if (whichDSF == 'm') name += "Smp";
+    else if (whichDSF == 'z') name += "Szz";
+    else if (whichDSF == 'p') name += "Spm";
+    else if (whichDSF == 'a') name += "SzSz";
+    else if (whichDSF == 'b') name += "SzSm";
+    else if (whichDSF == 'c') name += "SmSm";
+    else if (whichDSF == 'q') name += "GeomQuench";
+    else {
+      cout << "Option tried (2): " << whichDSF << endl;
+      ABACUSerror("Option not implemented in Data_File_Name");
+    }
+
+    name += "_D_" + to_string(State.chain.Delta) + "_N_" + to_string(State.chain.Nsites) + "_M_";
+    for (int i = 0; i < int(log10(DP(State.chain.Nsites/2))) - int(log10(DP(State.base.Mdown))); ++i) name += "0";
+    name += to_string(State.base.Mdown);
+    if (defaultScanStatename == "") name += "_" + State.label;
+    else name += "_" + defaultScanStatename;
+    if (kBT > 0.0) name += "_kBT_" + to_string(kBT);
+    if (whichDSF == 'q') name += "_N2_" + to_string(RefScanState.chain.Nsites);
+
+    return(name);
+  }
+
 
   // One-D spinless fermions: IN DEVELOPMENT
   /*

src/UTILS/State_Label.cc

 
   // M0[|type1:M1|type2:M2...]_nexc0[|nexc1|nexc2...]_type0Ix2old@type0Ix2new[:...][|type1Ix2old@type1Ix2new...]
 
-  // A label is always relative to another label reference state, in practise
+  // A label is always relative to another label reference state, in practice
   // the seed state used in the scanning for correlations (or otherwise by default: the ground state).
 
   // The first part of the label (before the first _ ) labels the particle content (the "base").