Finish first clean of src files

src/SCAN/General_Scan_Parallel.cc

@@ -52,7 +52,8 @@ namespace ABACUS {
 
     Vect<Scan_Thread_Data> thr_data_par(nr_processors_at_newlevel);
     for (int rank = 0; rank < nr_processors_at_newlevel; ++rank)
-      thr_data_par[rank] = Scan_Thread_Data (THRDIRS_stringstream[rank].str(), false); // put refine == false here to avoid loading any deprecated data
+      thr_data_par[rank] = Scan_Thread_Data (THRDIRS_stringstream[rank].str(), false);
+    // put refine == false here to avoid loading any deprecated data
 
     // Transfer all the existing threads into the new ones:
     int rankindex = 0;
@@ -83,59 +84,12 @@ namespace ABACUS {
     return;
   }
 
-  /*
-  void Create_Empty_Files (string prefix, char whichDSF, int nr_processors_at_newlevel)
-  {
-    // This function creates, for convenience, a set of 'empty' files, so a full set of files is available at all paralevels.
-    for (int rank = 0; rank < nr_processors_at_newlevel; ++rank) {
-      stringstream RAW_stringstream;    string RAW_string;
-      stringstream INADM_stringstream;    string INADM_string;
-      stringstream CONV0_stringstream;    string CONV0_string;
-      stringstream LOG_stringstream;    string LOG_string;
-      //stringstream THR_stringstream;    string THR_string;
-      stringstream SRC_stringstream;    string SRC_string;
-      stringstream FSR_stringstream;    string FSR_string;
-      stringstream SUM_stringstream;    string SUM_string;
-
-      RAW_stringstream << prefix << "_" << rank << "_" << nr_processors_at_newlevel << ".raw";
-      INADM_stringstream << prefix << "_" << rank << "_" << nr_processors_at_newlevel << ".inadm";
-      CONV0_stringstream << prefix << "_" << rank << "_" << nr_processors_at_newlevel << ".conv0";
-      LOG_stringstream << prefix << "_" << rank << "_" << nr_processors_at_newlevel << ".log";
-      //THR_stringstream << prefix << "_" << rank << "_" << nr_processors_at_newlevel << ".thr";
-      SRC_stringstream << prefix << "_" << rank << "_" << nr_processors_at_newlevel << ".src";
-      FSR_stringstream << prefix << "_" << rank << "_" << nr_processors_at_newlevel << ".fsr";
-      SUM_stringstream << prefix << "_" << rank << "_" << nr_processors_at_newlevel << ".sum";
-
-      RAW_string = RAW_stringstream.str();    const char* RAW_Cstr = RAW_string.c_str();
-      INADM_string = INADM_stringstream.str();    const char* INADM_Cstr = INADM_string.c_str();
-      CONV0_string = CONV0_stringstream.str();    const char* CONV0_Cstr = CONV0_string.c_str();
-      LOG_string = LOG_stringstream.str();    const char* LOG_Cstr = LOG_string.c_str();
-      //THR_string = THR_stringstream.str();    const char* THR_Cstr = THR_string.c_str();
-      SRC_string = SRC_stringstream.str();    const char* SRC_Cstr = SRC_string.c_str();
-      FSR_string = FSR_stringstream.str();    const char* FSR_Cstr = FSR_string.c_str();
-      SUM_string = SUM_stringstream.str();    const char* SUM_Cstr = SUM_string.c_str();
-
-      // We open and close these files (except for SUM, which we fill with a zero-valued scan_info
-      fstream RAW_file; RAW_file.open(RAW_Cstr); RAW_file.close();
-      fstream INADM_file; INADM_file.open(INADM_Cstr); INADM_file.close();
-      fstream CONV0_file; CONV0_file.open(CONV0_Cstr); CONV0_file.close();
-      fstream LOG_file; LOG_file.open(LOG_Cstr); LOG_file.close();
-      Scan_Info emptyinfo; emptyinfo.Save(SRC_Cstr);
-      fstream FSR_file; FSR_file.open(FSR_Cstr); FSR_file.close();
-      fstream SUM_file; SUM_file.open(SUM_Cstr); SUM_file.close();
-
-    }
-  }
-  */
 
   void Merge_raw_Files (string prefix, char whichDSF, int nr_processors_at_newlevel)
   {
 
     // Open the original raw file:
     stringstream RAW_stringstream;    string RAW_string;
-    //RAW_stringstream << prefix;
-    //if (whichDSF == 'Z') RAW_stringstream << ".dat";
-    //else RAW_stringstream << ".raw";
     RAW_stringstream << prefix << ".raw";
     RAW_string = RAW_stringstream.str();    const char* RAW_Cstr = RAW_string.c_str();
 
@@ -153,23 +107,18 @@ namespace ABACUS {
       ifstream RAW_infile;
       RAW_infile.open(RAW_in_Cstr);
       if (RAW_infile.fail()) {
-	//cout << RAW_in_Cstr << endl;
-	//ABACUSerror ("Could not open file.");
 	continue; // if file isn't there, just continue...
       }
 
       DP omega;
       int iK;
       DP FF;
-      //int conv;
       DP dev;
       string label;
       int nr, nl;
       while (RAW_infile.peek() != EOF) {
-	//RAW_infile >> omega >> iK >> FF >> conv >> label;
 	RAW_infile >> omega >> iK >> FF >> dev >> label;
 	if (whichDSF == '1') RAW_infile >> nr >> nl;
-	//RAW_outfile << endl << omega << "\t" << iK << "\t" << FF << "\t" << conv << "\t" << label;
 	RAW_outfile << endl << omega << "\t" << iK << "\t" << FF << "\t" << dev << "\t" << label;
 	if (whichDSF == '1') RAW_outfile << "\t" << nr << "\t" << nl;
       }
@@ -244,7 +193,6 @@ namespace ABACUS {
     SUM_string = SUM_stringstream.str();    const char* SUM_Cstr = SUM_string.c_str();
 
     // Load the original info:
-    //ScanStateList.Load_Info (SUM_Cstr);  // Not needed anymore: rank 0 has loaded the original info
     if (file_exists(SUM_Cstr)) ScanStateList.Load_Info (SUM_Cstr);  // Needed again!
 
     // Load all other info:
@@ -470,12 +418,9 @@ namespace ABACUS {
   //****************************************************************************//
   // Model-specific functions:
 
-  //void Prepare_Parallel_Scan_LiebLin (char whichDSF, DP c_int, DP L, int N, int iK_UL, bool fixed_iK, int iKneeded,
   void Prepare_Parallel_Scan_LiebLin (char whichDSF, DP c_int, DP L, int N, int iKmin, int iKmax, DP kBT,
-				   string defaultScanStatename,
-				   //int Max_Secs, bool refine, int rank,
-				   int paralevel, Vect<int> rank_lower_paralevels, Vect<int> nr_processors_lower_paralevels,
-				   int nr_processors_at_newlevel)
+				      string defaultScanStatename, int paralevel, Vect<int> rank_lower_paralevels,
+				      Vect<int> nr_processors_lower_paralevels, int nr_processors_at_newlevel)
   {
     // From an existing scan, this function splits the threads into
     // nr_processors_at_newlevel separate files, from which the parallel process
@@ -485,35 +430,21 @@ namespace ABACUS {
 
     // Define file name
     stringstream filenameprefix;
-    //Data_File_Name (filenameprefix, whichDSF, fixed_iK, iKneeded, GroundState, GroundState);
     Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, kBT, GroundState, GroundState, defaultScanStatename);
     for (int i = 0; i < paralevel - 1; ++i) filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
     string prefix = filenameprefix.str();
 
     Split_thr_Files (prefix, whichDSF, nr_processors_at_newlevel);
 
-    //Create_Empty_Files (prefix, whichDSF, nr_processors_at_newlevel);
-
     return;
   }
 
-  //void Wrapup_Parallel_Scan_LiebLin (char whichDSF, DP c_int, DP L, int N, int iK_UL, bool fixed_iK, int iKneeded,
   void Wrapup_Parallel_Scan_LiebLin (char whichDSF, DP c_int, DP L, int N, int iKmin, int iKmax, DP kBT,
-				  string defaultScanStatename,
-				  //int Max_Secs, bool refine, int rank,
-				  int paralevel, Vect<int> rank_lower_paralevels, Vect<int> nr_processors_lower_paralevels,
-				  int nr_processors_at_newlevel)
+				     string defaultScanStatename, int paralevel, Vect<int> rank_lower_paralevels,
+				     Vect<int> nr_processors_lower_paralevels, int nr_processors_at_newlevel)
   {
-    //DP epsilon = log(L)/L;
-
-    //LiebLin_Bethe_State GroundState (c_int, L, N);
-    //LiebLin_Bethe_State spstate = Canonical_Saddle_Point_State (c_int, L, N, kBT, epsilon);
-    //LiebLin_Bethe_State spstate = Canonical_Saddle_Point_State (c_int, L, N, kBT);
-
     // Read the saddle-point state from the sps file:
     stringstream SPS_stringstream;  string SPS_string;
-    //SPS_stringstream << "Tgt0_";
-    //Data_File_Name (SPS_stringstream, whichDSF, iKmin, iKmax, kBT, spstate, SeedScanState, "");
     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();
@@ -546,14 +477,13 @@ namespace ABACUS {
     if (whichDSF == 'g') Nscan = N + 1;
 
     LiebLin_Bethe_State SeedScanState = spstate;
-    //if (whichDSF == 'o' || whichDSF == 'g') SeedScanState = Canonical_Saddle_Point_State (c_int, L, Nscan, kBT, epsilon);
     if (whichDSF == 'o' || whichDSF == 'g') SeedScanState = Canonical_Saddle_Point_State (c_int, L, Nscan, kBT);
 
     // Define file name
     stringstream filenameprefix;
-    //Data_File_Name (filenameprefix, whichDSF, fixed_iK, iKneeded, GroundState, GroundState);
     Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, kBT, spstate, SeedScanState, defaultScanStatename);
-    for (int i = 0; i < paralevel - 1; ++i) filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
+    for (int i = 0; i < paralevel - 1; ++i)
+      filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
     string prefix = filenameprefix.str();
 
 
@@ -570,19 +500,7 @@ namespace ABACUS {
     Merge_inadm_conv0_src_stat_log_Files (prefix, whichDSF, nr_processors_at_newlevel);
     // This also puts some digested info in log file.
 
-    // Evaluate f-sumrule:
-    /*
-    stringstream RAW_stringstream;    string RAW_string;
-    RAW_stringstream << prefix << ".raw";
-    RAW_string = RAW_stringstream.str();    const char* RAW_Cstr = RAW_string.c_str();
-
-    stringstream FSR_stringstream;    string FSR_string;
-    FSR_stringstream << prefix << ".fsr";
-    FSR_string = FSR_stringstream.str();    const char* FSR_Cstr = FSR_string.c_str();
-    */
     DP Chem_Pot = Chemical_Potential (spstate);
-    //if (!fixed_iK) if (whichDSF != 'q') Evaluate_F_Sumrule (whichDSF, GroundState, Chem_Pot, RAW_Cstr, FSR_Cstr);
-    //if (iKmin != iKmax) if (whichDSF != 'q') Evaluate_F_Sumrule (whichDSF, GroundState, Chem_Pot, iKmin, iKmax, RAW_Cstr, FSR_Cstr);
     if (iKmin != iKmax) if (whichDSF != 'q') Evaluate_F_Sumrule (prefix, whichDSF, spstate, Chem_Pot, iKmin, iKmax);
 
     // ... and we're done.
@@ -595,7 +513,6 @@ namespace ABACUS {
   // Heisenberg:
 
   void Prepare_Parallel_Scan_Heis (char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
-				   //int Max_Secs, bool refine, int rank,
 				   int paralevel, Vect<int> rank_lower_paralevels, Vect<int> nr_processors_lower_paralevels,
 				   int nr_processors_at_newlevel)
   {
@@ -611,8 +528,6 @@ namespace ABACUS {
 
     Heis_Base baseconfig_groundstate(BD1, Nrapidities_groundstate);
 
-    //Ix2_Offsets baseoffsets(baseconfig_groundstate, 0ULL);
-
     // Define file name
     stringstream filenameprefix;
 
@@ -639,7 +554,8 @@ namespace ABACUS {
 
     else ABACUSerror("Delta out of range in Prepare_Parallel_Scan_Heis");
 
-    for (int i = 0; i < paralevel - 1; ++i) filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
+    for (int i = 0; i < paralevel - 1; ++i)
+      filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
     string prefix = filenameprefix.str();
 
     Split_thr_Files (prefix, whichDSF, nr_processors_at_newlevel);
@@ -664,8 +580,6 @@ namespace ABACUS {
 
     Heis_Base baseconfig_groundstate(BD1, Nrapidities_groundstate);
 
-    //Ix2_Offsets baseoffsets(baseconfig_groundstate, 0ULL);
-
     // Define file name
     stringstream filenameprefix;
     string prefix;
@@ -681,7 +595,8 @@ namespace ABACUS {
       else ABACUSerror("Unknown whichDSF in Scan_Heis.");
 
       Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, 0.0, GroundState, SeedScanState, "");
-      for (int i = 0; i < paralevel - 1; ++i) filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
+      for (int i = 0; i < paralevel - 1; ++i)
+	filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
       prefix = filenameprefix.str();
 
       // Merge sum files
@@ -715,7 +630,8 @@ namespace ABACUS {
       else ABACUSerror("Unknown whichDSF in Scan_Heis.");
 
       Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, 0.0, GroundState, SeedScanState, "");
-      for (int i = 0; i < paralevel - 1; ++i) filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
+      for (int i = 0; i < paralevel - 1; ++i)
+	filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
       prefix = filenameprefix.str();
 
       // Merge sum files
@@ -748,7 +664,8 @@ namespace ABACUS {
       else ABACUSerror("Unknown whichDSF in Scan_Heis.");
 
       Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, 0.0, GroundState, SeedScanState, "");
-      for (int i = 0; i < paralevel - 1; ++i) filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
+      for (int i = 0; i < paralevel - 1; ++i)
+	filenameprefix << "_" << rank_lower_paralevels[i] << "_" << nr_processors_lower_paralevels[i];
       prefix = filenameprefix.str();
 
       // Merge sum files
@@ -773,7 +690,7 @@ namespace ABACUS {
     else ABACUSerror("Delta out of range in Prepare_Parallel_Scan_Heis");
 
 
-     // ... and we're done.
+    // ... and we're done.
 
     return;
   }

src/SCAN/Particle_Hole_Excitation_Cost.cc

@@ -24,10 +24,7 @@ namespace ABACUS {
     // Estimates the cost of adding a particle-hole excitation to an intermediate state
     DP ph_cost = 1.0;
 
-    //if (whichDSF == 'd') ph_cost = ABACUS::min(0.1, 1.0/sqrt(AveragingState.c_int));
-    //if (whichDSF == 'd') ph_cost = ABACUS::min(0.1, 1.0/AveragingState.c_int);
     if (whichDSF == 'd') ph_cost = ABACUS::min(0.01, 0.1/AveragingState.c_int);
-    //if (whichDSF == 'd') ph_cost = ABACUS::min(0.001, 0.01/AveragingState.c_int);
     else if (whichDSF == 'o') ph_cost = 0.01;
     else if (whichDSF == 'g') ph_cost = 0.01;
     else if (whichDSF == 'Z') ph_cost = 1.0;

src/SCAN/Scan_Info.cc

@@ -20,13 +20,9 @@ using namespace ABACUS;
 namespace ABACUS {
 
   Scan_Info::Scan_Info() :
-    //sumrule_obtained(0.0), Nfull(0LL), Ninadm(0LL), Ndata(0LL), Ndata_conv(0LL), Ndata_conv0(0LL), CPU_ticks(0LL), CPU_ticks_TOT(0LL)  {}
-    //sumrule_obtained(0.0), Nfull(0.0), Ninadm(0LL), Ndata(0LL), Ndata_conv(0LL), Ndata_conv0(0LL), CPU_ticks(0LL), CPU_ticks_TOT(0LL)  {}
     sumrule_obtained(0.0), Nfull(0.0), Ninadm(0LL), Ndata(0LL), Ndata_conv(0LL), Ndata_conv0(0LL), TT(0.0)  {}
 
-  //Scan_Info::Scan_Info (DP sr, long long int Nf, long long int Ni, long long int Nd, long long int Ndc, long long int Ndc0, long long int t) :
   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), CPU_ticks(t), CPU_ticks_TOT(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)
@@ -36,19 +32,17 @@ namespace ABACUS {
     outfile.open(outfile_Cstr);
     if (outfile.fail()) ABACUSerror("Could not open outfile... ");
 
-    //outfile.setf(ios::fixed);
-    //outfile.setf(ios::showpoint);
     outfile.precision(16);
 
     int TT_hr = int(TT/3600);
     int TT_min = int((TT - 3600.0*TT_hr)/60);
 
-    outfile << setw(25) << setprecision(16) << sumrule_obtained << setw(25) << Nfull << setw(16) << Ninadm << setw(16) << Ndata << setw(16) << Ndata_conv << setw(16) << Ndata_conv0
-      //<< "\t" << CPU_ticks/CLOCKS_PER_SEC << "\t" << CPU_ticks_TOT/CLOCKS_PER_SEC << endl;
-      //<< setw(16) << std::fixed << setprecision(3) << TT << endl;
-	    << "\t" << TT_hr << " h " << TT_min << " m " << std::fixed << setprecision(3) << TT - 3600*TT_hr - 60*TT_min << " s" << endl;
-    //outfile << "sumrule_obtained \t Nfull \t Ninadm \t Ndata \t Ndata_conv \t Ndata_conv0 \t T \t TT.";
-    outfile << setw(25) << "sumrule_obtained" << setw(25) << "Nfull" << setw(16) << "Ninadm" << setw(16) << "Ndata" << setw(16) << "Ndata_conv" << setw(16) << "Ndata_conv0" << setw(16) << "TT." << endl;
+    outfile << setw(25) << setprecision(16) << sumrule_obtained << setw(25) << Nfull
+	    << setw(16) << Ninadm << setw(16) << Ndata << setw(16) << Ndata_conv << setw(16) << Ndata_conv0
+	    << "\t" << TT_hr << " h " << TT_min << " m "
+	    << std::fixed << setprecision(3) << TT - 3600*TT_hr - 60*TT_min << " s" << endl;
+    outfile << setw(25) << "sumrule_obtained" << setw(25) << "Nfull" << setw(16) << "Ninadm"
+	    << setw(16) << "Ndata" << setw(16) << "Ndata_conv" << setw(16) << "Ndata_conv0" << setw(16) << "TT." << endl;
     outfile.close();
 
     return;
@@ -67,13 +61,10 @@ namespace ABACUS {
     DP TT_sec;
     char a;
 
-    //infile >> sumrule_obtained >> Nfull >> Ninadm >> Ndata >> Ndata_conv >> Ndata_conv0 >> CPU_ticks >> CPU_ticks_TOT;
-    //infile >> sumrule_obtained >> Nfull >> Ninadm >> Ndata >> Ndata_conv >> Ndata_conv0 >> TT;
-    infile >> sumrule_obtained >> Nfull >> Ninadm >> Ndata >> Ndata_conv >> Ndata_conv0 >> TT_hr >> a >> TT_min >> a >> TT_sec >> a;
+    infile >> sumrule_obtained >> Nfull >> Ninadm >> Ndata >> Ndata_conv >> Ndata_conv0
+	   >> TT_hr >> a >> TT_min >> a >> TT_sec >> a;
 
     TT = 3600.0 * TT_hr + 60.0* TT_min + TT_sec;
-    //CPU_ticks_TOT *= CLOCKS_PER_SEC; // correct for factor in Save function
-    //CPU_ticks = 0;  // reset CPU ticks.
 
     infile.close();
 
@@ -84,12 +75,12 @@ namespace ABACUS {
   {
     s.ios::unsetf(ios::scientific);
     return s << " sr " << setprecision(14) << info.sumrule_obtained
-	     << "\tNfull " << std::fixed << setprecision(0) << info.Nfull << "\t Ninadm " << info.Ninadm << " Ndata " << info.Ndata
+	     << "\tNfull " << std::fixed << setprecision(0) << info.Nfull
+	     << "\t Ninadm " << info.Ninadm << " Ndata " << info.Ndata
 	     << "\t_conv " << info.Ndata_conv << " _conv0 " << info.Ndata_conv0
-      //<< " t " << info.CPU_ticks/CLOCKS_PER_SEC << "s"
-      //<< " TT " << info.CPU_ticks_TOT/CLOCKS_PER_SEC;
-      //<< "\tTT " << std::fixed << setprecision(3) << info.TT;
-	     << "\tTT " << int(info.TT/3600) << " h " << int((info.TT - 3600.0 * int(info.TT/3600))/60) << " m " << std::fixed << setprecision(3) << info.TT - 3600.0 * int(info.TT/3600) - 60.0 * int((info.TT - 3600.0 * int(info.TT/3600))/60) << " s";
+	     << "\tTT " << int(info.TT/3600) << " h " << int((info.TT - 3600.0 * int(info.TT/3600))/60)
+	     << " m " << std::fixed << setprecision(3)
+	     << info.TT - 3600.0 * int(info.TT/3600) - 60.0 * int((info.TT - 3600.0 * int(info.TT/3600))/60) << " s";
   }
 
 

src/SCAN/Scan_Thread_Data.cc

@@ -57,15 +57,13 @@ namespace ABACUS {
     }
 
     filename = Vect<string> (nlists);
-    //file = Vect<fstream*> (nlists);
-    //file_is_open = Vect<bool> (nlists);
 
     for (int il = 0; il < nlists; ++il) {
       stringstream filename_strstream;
       filename_strstream << thrdir_name << "/" << il << ".thr";
       filename[il] = filename_strstream.str();
-      if (!refine) remove(filename[il].c_str()); // the file is deleted to make sure we don't interfere with a previous (failed) computation
-      //file_is_open[il] = false;
+      if (!refine) remove(filename[il].c_str());
+      // the file is deleted to make sure we don't interfere with a previous (failed) computation
     }
     if (!refine) {
       // remove the nthreads.dat file
@@ -79,11 +77,6 @@ namespace ABACUS {
 
   Scan_Thread_Data::~Scan_Thread_Data()
   {
-    //for (int il = 0; il < nlists; ++il)
-    //if (file_is_open[il]) {
-    //	(*file[il]).close();
-    //	delete file[il];
-    //}
   }
 
   bool Scan_Thread_Data::Increase_Memory_Size (int il, int nr_to_add)
@@ -118,21 +111,11 @@ namespace ABACUS {
 
   void Scan_Thread_Data::Include_Thread (int il, string label_ref, int type_ref)
   {
-    //cout << "Calling Include_Threads..." << endl;
-
-    if (il < 0 || il > nlists - 1) ABACUSerror("il out of range in Scan_Thread_Data::Include_Thread.");
-
-    //cout << "\t\tIncluding thread " << label_ref << "\t" << type_ref << " in list with il = " << il << endl;
+    if (il < 0 || il > nlists - 1)
+      ABACUSerror("il out of range in Scan_Thread_Data::Include_Thread.");
 
     if (il < lowest_il_with_nthreads_neq_0) lowest_il_with_nthreads_neq_0 = il;
 
-    // append to file
-    //if (!file_is_open[il]) {
-    //file[il] = new fstream(filename[il].c_str(), fstream::out);
-    //file_is_open[il] = true;
-    //}
-    //*file[il] << label_ref << "\t" << type_ref << endl;
-
     // Keep in memory for now:
     if (nthreads_in_memory[il] > dim[il] - 10) {
       (*this).Increase_Memory_Size (il, dim[il]);
@@ -158,23 +141,13 @@ namespace ABACUS {
       label[il] = Vect<string> (dim[il]);
       type[il] = Vect<int> (dim[il]);
     }
-
-    //cout << "\t\tDone including thread." << endl;
-    //char a;
-    //cin >> a;
-    //cout << "OK for Include_Threads..." << endl;
-
   }
 
 
   Vect<Scan_Thread> Scan_Thread_Data::Extract_Next_Scan_Threads ()
   {
-    //cout << "Calling Extract_Next_Scan_Threads..." << endl;
-
     // Returns a vector of threads which are next in line for scanning.
 
-    //cout << "Here 1" << endl;
-
     int il_used = lowest_il_with_nthreads_neq_0;
     Vect<Scan_Thread> next_in_line(nthreads_total[il_used]);
 
@@ -206,25 +179,6 @@ namespace ABACUS {
     type[il_used] = Vect<int> (dim[il_used]);
     remove(filename[il_used].c_str());
 
-    /* Moved to Include_Thread
-    // We save the higher-index in-memory threads to files if they are big enough:
-    for (int il = il_used + 1; il < nlists; ++il)
-      //if (nthreads_in_memory[il] > 0) {
-      if (nthreads_in_memory[il] > 1000) {
-	fstream outfile;
-	outfile.open(filename[il].c_str(), fstream::out | fstream::app);
-	for (int it = 0; it < nthreads_in_memory[il]; ++it)
-	  outfile << label[il][it] << "\t" << type[il][it] << endl;
-	outfile.close();
-	nthreads_on_disk[il] += nthreads_in_memory[il];
-
-	// We then reset these memory buffers
-	dim[il] = 100;
-	nthreads_in_memory[il] = 0;
-	label[il] = Vect<string> (dim[il]);
-	type[il] = Vect<int> (dim[il]);
-      }
-    */
     // Find the next non-empty list:
     do {
       lowest_il_with_nthreads_neq_0 += 1;
@@ -234,11 +188,6 @@ namespace ABACUS {
       }
     } while (nthreads_total[lowest_il_with_nthreads_neq_0] == 0);
 
-    //cout << "Set lowest_il_with_nthreads_neq_0 to " << lowest_il_with_nthreads_neq_0 << endl;
-    //cin >> a;
-
-    //cout << "OK for Extract_Next_Scan_Threads." << endl;
-
     return(next_in_line);
   }
 
@@ -258,7 +207,8 @@ namespace ABACUS {
 
   void Scan_Thread_Data::Flush_to_Disk (int il)
   {
-    if (il < 0 || il > nlists - 1) ABACUSerror("il out of range in Scan_Thread_Data::Flush_to_Disk.");
+    if (il < 0 || il > nlists - 1)
+      ABACUSerror("il out of range in Scan_Thread_Data::Flush_to_Disk.");
 
     if (nthreads_in_memory[il] > 0) {
       fstream outfile;
@@ -288,7 +238,8 @@ namespace ABACUS {
     string nthreads_outfile_str = nthreads_outfile_strstream.str();
 
     nthreads_outfile.open(nthreads_outfile_str.c_str());
-    if (nthreads_outfile.fail()) ABACUSerror("Could not open outfile in Scan_Thread_Data::Save... ");
+    if (nthreads_outfile.fail())
+      ABACUSerror("Could not open outfile in Scan_Thread_Data::Save... ");
 
     //cout << "Saving threads: nthreads_tot vector is" << endl;
     for (int il = 0; il < nlists; ++il) {

src/TBA/Root_Density.cc

@@ -19,439 +19,347 @@ using namespace ABACUS;
 
 namespace ABACUS {
 
-/************************************/
-/*
-struct Root_Density {
-
-  int Npts;  // how many points are used to describe each function
-  DP lambdamax;  // what the largest rapidity is
-  Vect_DP lambda;  // rapidity vector
-  Vect_DP dlambda; // differential element
-  Vect_DP value;  // the root density itself
-  Vect_DP prev_value;  // results of previous iteration
-  DP diff;   // relative differences with previous iteration
-  bool value_infty_set;  // boolean, true if asymptotic value set
-  DP value_infty;  // asymptotic value, computed analytically
-
-  Root_Density ();
-  Root_Density (int Npts_ref, DP lambdamax_ref);
-
-  Root_Density& operator= (const Root_Density& RefDensity);
-
-  DP Return_Value (DP lambda_ref);  // evaluates the function for any argument using linear interpolation
-  DP Set_Asymptotics (DP value_infty_ref);  // sets value for lambda >= lambdamax
-
-  Root_Density Compress_and_Match_Densities (DP comp_factor);  // returns a Root_Density with fewer points
-};
-*/
-
-Root_Density::Root_Density ()
-  : Npts(1), lambdamax(0.0), lambda(Vect_DP(0.0, Npts)), dlambda(Vect_DP(0.0, Npts)), value(Vect_DP(0.0, Npts)),
-    prev_value(Vect_DP(0.0, Npts)), diff(1.0e+6), value_infty_set(false), value_infty(0.0)
-{
-}
-
-Root_Density::Root_Density (int Npts_ref, DP lambdamax_ref)
-  : Npts(Npts_ref), lambdamax(lambdamax_ref), lambda(Vect_DP(Npts)), dlambda(Vect_DP(0.0, Npts)), value(Vect_DP(0.0, Npts)),
-    prev_value(Vect_DP(0.0, Npts)), diff(1.0e+6), value_infty_set(false), value_infty(0.0)
-{
-  for (int i = 0; i < value.size(); ++i) {
-    lambda[i] = lambdamax * (-(Npts - 1.0) + 2*i)/Npts;
-    dlambda[i] = 2.0 * lambdamax/Npts;
+
+  Root_Density::Root_Density ()
+    : Npts(1), lambdamax(0.0), lambda(Vect_DP(0.0, Npts)), dlambda(Vect_DP(0.0, Npts)), value(Vect_DP(0.0, Npts)),
+      prev_value(Vect_DP(0.0, Npts)), diff(1.0e+6), value_infty_set(false), value_infty(0.0)
+  {
   }
-}
-
-Root_Density& Root_Density::operator= (const Root_Density& RefDensity)
-{
-  if (this != &RefDensity) {
-    Npts = RefDensity.Npts;
-    lambdamax = RefDensity.lambdamax;
-    lambda = RefDensity.lambda;
-    dlambda = RefDensity.dlambda;
-    value = RefDensity.value;
-    prev_value = RefDensity.prev_value;
-    diff = RefDensity.diff;
-    value_infty_set = RefDensity.value_infty_set;
-    value_infty = RefDensity.value_infty;
 
+  Root_Density::Root_Density (int Npts_ref, DP lambdamax_ref)
+    : Npts(Npts_ref), lambdamax(lambdamax_ref), lambda(Vect_DP(Npts)), dlambda(Vect_DP(0.0, Npts)), value(Vect_DP(0.0, Npts)),
+      prev_value(Vect_DP(0.0, Npts)), diff(1.0e+6), value_infty_set(false), value_infty(0.0)
+  {
+    for (int i = 0; i < value.size(); ++i) {
+      lambda[i] = lambdamax * (-(Npts - 1.0) + 2*i)/Npts;
+      dlambda[i] = 2.0 * lambdamax/Npts;
+    }
   }
-  return(*this);
-}
-
-DP Root_Density::Return_Value (DP lambda_ref)
-{
-  // This function returns a value for epsilon at any real lambda
-  // using simple linear interpolation.
-  // Degree 3 polynomical also programmed in, but commented out:  no improvement.
-
-  DP answer = 0.0;
-  if (fabs(lambda_ref) >= fabs(lambda[0])) {
-    if (value_infty_set) answer = value_infty;
-    else ABACUSerror("Need to set asymptotics of Root_Density !");
+
+  Root_Density& Root_Density::operator= (const Root_Density& RefDensity)
+  {
+    if (this != &RefDensity) {
+      Npts = RefDensity.Npts;
+      lambdamax = RefDensity.lambdamax;
+      lambda = RefDensity.lambda;
+      dlambda = RefDensity.dlambda;
+      value = RefDensity.value;
+      prev_value = RefDensity.prev_value;
+      diff = RefDensity.diff;
+      value_infty_set = RefDensity.value_infty_set;
+      value_infty = RefDensity.value_infty;
+
+    }
+    return(*this);
   }
 
-  else { // try to find the i such that lambda[i] <= lambda_ref < lambda[i+1]
+  DP Root_Density::Return_Value (DP lambda_ref)
+  {
+    // This function returns a value for epsilon at any real lambda
+    // using simple linear interpolation.
+    // Degree 3 polynomical also programmed in, but commented out:  no improvement.
+
+    DP answer = 0.0;
+    if (fabs(lambda_ref) >= fabs(lambda[0])) {
+      if (value_infty_set) answer = value_infty;
+      else ABACUSerror("Need to set asymptotics of Root_Density !");
+    }
 
-    int index = (Npts - 1)/2;
-    int indexstep = (Npts - 1)/4 + 1;
+    else { // try to find the i such that lambda[i] <= lambda_ref < lambda[i+1]
 
-    while (indexstep >= 1) {
+      int index = (Npts - 1)/2;
+      int indexstep = (Npts - 1)/4 + 1;
 
-      if ( // if is "lower": we go up
-	  lambda_ref >= lambda[index + 1]) {
-	index += indexstep;
-      }
+      while (indexstep >= 1) {
 
-      else if ( // if is "higher" or equal:  we go down
-	       lambda[index] > lambda_ref) {
-	index -= indexstep;
-      }
+	if ( // if is "lower": we go up
+	    lambda_ref >= lambda[index + 1]) {
+	  index += indexstep;
+	}
 
-      index = ABACUS::max(0, index);
-      index = ABACUS::min(Npts - 2, index);
+	else if ( // if is "higher" or equal:  we go down
+		 lambda[index] > lambda_ref) {
+	  index -= indexstep;
+	}
 
-      if (indexstep == 1) indexstep--;
-      else indexstep = (indexstep + 1)/2;
+	index = ABACUS::max(0, index);
+	index = ABACUS::min(Npts - 2, index);
 
-    } // while ...
+	if (indexstep == 1) indexstep--;
+	else indexstep = (indexstep + 1)/2;
 
-    if (index < 0 || index >= Npts || lambda[index] > lambda_ref || lambda[index + 1] < lambda_ref) {
-      cout << "Seeking index: " << index << "\t" << lambda[index] << "\t <=? " << lambda_ref << "\t<? " << lambda[index + 1] << endl;
-      ABACUSerror("Calculating index wrong in Root_Density::Evaluate.");
-    }
+      } // while ...
+
+      if (index < 0 || index >= Npts || lambda[index] > lambda_ref || lambda[index + 1] < lambda_ref) {
+	cout << "Seeking index: " << index << "\t" << lambda[index] << "\t <=? " << lambda_ref
+	     << "\t<? " << lambda[index + 1] << endl;
+	ABACUSerror("Calculating index wrong in Root_Density::Evaluate.");
+      }
 
-    //if (index < 1 || index > Npts - 3)
-    answer = ((value[index] * (lambda[index+1] - lambda_ref)
-	       + value[index + 1] * (lambda_ref - lambda[index]))/(lambda[index+1] - lambda[index]));
-    /*
-    else {
-      // Better:  if possible, fit to polynomial going through 4 closest points
-      Vect_DP xa (4);
-      Vect_DP ya (4);
-      DP dy;
-      xa[0] = lambda[index - 1];  xa[1] = lambda[index];  xa[2] = lambda[index + 1];  xa[3] = lambda[index + 2];
-      ya[0] = value[index - 1];  ya[1] = value[index];  ya[2] = value[index + 1];  ya[3] = value[index + 2];
-      polint (xa, ya, lambda_ref, answer, dy);  // sets answer to value at lambda_ref
+      answer = ((value[index] * (lambda[index+1] - lambda_ref)
+		 + value[index + 1] * (lambda_ref - lambda[index]))/(lambda[index+1] - lambda[index]));
     }
-    */
+
+    return(answer);
   }
 
-  return(answer);
-}
+  void Root_Density::Set_Asymptotics (DP value_infty_ref)
+  {
+    value_infty = value_infty_ref;
+    value_infty_set = true;
+  }
 
-void Root_Density::Set_Asymptotics (DP value_infty_ref)
-{
-  value_infty = value_infty_ref;
-  value_infty_set = true;
-}
+  Root_Density Root_Density::Compress_and_Match_Densities (DP comp_factor)
+  {
+    // Returns a 'compressed' version of the density, using 1/comp_factor as many points.
 
-Root_Density Root_Density::Compress_and_Match_Densities (DP comp_factor)
-{
-  // Returns a 'compressed' version of the density, using 1/comp_factor as many points.
+    int Npts_used = int(2.0 * lambdamax/(dlambda[0] * comp_factor));
 
-  // PROBLEM:  this implementation can lead to numerical instabilities.
+    Root_Density compressed_density(Npts_used, lambdamax);
 
-  //Root_Density compressed_density(Npts/comp_factor, lambdamax);
+    compressed_density.Set_Asymptotics (value_infty);
 
-  // Rather:  use this implementation:
-  int Npts_used = int(2.0 * lambdamax/(dlambda[0] * comp_factor));
+    for (int i = 0; i < compressed_density.Npts; ++i)
+      compressed_density.value[i] = (*this).Return_Value (compressed_density.lambda[i]);
 
-  Root_Density compressed_density(Npts_used, lambdamax);
+    return(compressed_density);
+  }
 
-  compressed_density.Set_Asymptotics (value_infty);
+  void Root_Density::Save (const char* outfile_Cstr)
+  {
+    ofstream outfile;
+    outfile.open(outfile_Cstr);
+    outfile.precision(16);
 
-  for (int i = 0; i < compressed_density.Npts; ++i)
-    compressed_density.value[i] = (*this).Return_Value (compressed_density.lambda[i]);
+    for (int i = 0; i < Npts; ++i) {
+      if (i > 0) outfile << endl;
+      outfile << setw(20) << lambda[i] << "\t" << setw(20) << value[i];
+    }
 
-  return(compressed_density);
-}
+    outfile.close();
+  }
 
-void Root_Density::Save (const char* outfile_Cstr)
-{
-  ofstream outfile;
-  outfile.open(outfile_Cstr);
-  outfile.precision(16);
 
-  for (int i = 0; i < Npts; ++i) {
-    if (i > 0) outfile << endl;
-    outfile << setw(20) << lambda[i] << "\t" << setw(20) << value[i];
+  Root_Density_Set::Root_Density_Set () : ntypes(1), epsilon(Vect<Root_Density> (ntypes)), Npts_total(0), diff(1.0e+6)
+  {
   }
 
-  outfile.close();
-}
-
-
-/************************************/
-/*
-struct Root_Density_Set {
-
-  int ntypes;
-  Vect<Root_Density> epsilon;
-  int Npts_total;  // sum of all Npts of epsilon's
-  DP diff;  // sum of diff's of the epsilon's
-
-  Root_Density_Set ();
-  Root_Density_Set (int ntypes_ref, int Npts_ref, DP lambdamax_ref);
-  Root_Density_Set (int ntypes_ref, Vect_INT Npts_ref, Vect_DP lambdamax_ref);
-
-  Root_Density_Set& operator= (const Root_Density_Set& RefSet);
-
-  void Insert_new_function (DP asymptotic_value);
-  void Extend_limits (Vect<bool> need_to_extend_limit);
-  void Insert_new_points (Vect<Vect<bool> > need_new_point_around);
-
-  DP Return_Value (int n_ref, DP lambda_ref);  // returns a value, no matter what.
-
-  Root_Density_Set Return_Compressed_and_Matched_Set (DP comp_factor);
-  void Match_Densities (Root_Density_Set& RefSet);
-
-  void Save (const char* outfile_Cstr);
-};
-*/
-Root_Density_Set::Root_Density_Set () : ntypes(1), epsilon(Vect<Root_Density> (ntypes)), Npts_total(0), diff(1.0e+6)
-{
-}
-
-Root_Density_Set::Root_Density_Set (int ntypes_ref, int Npts_ref, DP lambdamax_ref)
-  : ntypes(ntypes_ref), epsilon(Vect<Root_Density> (ntypes_ref)), Npts_total(ntypes_ref * Npts_ref), diff(1.0e+6)
-{
-  for (int n = 0; n < ntypes; ++n) epsilon[n] = Root_Density(Npts_ref, lambdamax_ref);
-}
-
-Root_Density_Set::Root_Density_Set (int ntypes_ref, Vect_INT Npts_ref, Vect_DP lambdamax_ref)
-  : ntypes(ntypes_ref), epsilon(Vect<Root_Density> (ntypes_ref)), Npts_total(Npts_ref.sum()), diff(1.0e+6)
-{
-  if (Npts_ref.size() != ntypes_ref || lambdamax_ref.size() != ntypes_ref) ABACUSerror("Wrong vector sizes in Root_Density_Set.");
-  for (int n = 0; n < ntypes; ++n) epsilon[n] = Root_Density(Npts_ref[n], lambdamax_ref[n]);
-}
-
-Root_Density_Set& Root_Density_Set::operator= (const Root_Density_Set& RefSet)
-{
-  if (this != &RefSet) {
-    ntypes = RefSet.ntypes;
-    epsilon = RefSet.epsilon;
-    Npts_total = RefSet.Npts_total;
-    diff = RefSet.diff;
+  Root_Density_Set::Root_Density_Set (int ntypes_ref, int Npts_ref, DP lambdamax_ref)
+    : ntypes(ntypes_ref), epsilon(Vect<Root_Density> (ntypes_ref)), Npts_total(ntypes_ref * Npts_ref), diff(1.0e+6)
+  {
+    for (int n = 0; n < ntypes; ++n) epsilon[n] = Root_Density(Npts_ref, lambdamax_ref);
   }
-  return(*this);
-}
 
-void Root_Density_Set::Insert_new_function (DP asymptotic_value)
-{
-  // This function extends a set by adding one epsilon_n function on top
+  Root_Density_Set::Root_Density_Set (int ntypes_ref, Vect_INT Npts_ref, Vect_DP lambdamax_ref)
+    : ntypes(ntypes_ref), epsilon(Vect<Root_Density> (ntypes_ref)), Npts_total(Npts_ref.sum()), diff(1.0e+6)
+  {
+    if (Npts_ref.size() != ntypes_ref || lambdamax_ref.size() != ntypes_ref)
+      ABACUSerror("Wrong vector sizes in Root_Density_Set.");
+    for (int n = 0; n < ntypes; ++n) epsilon[n] = Root_Density(Npts_ref[n], lambdamax_ref[n]);
+  }
 
-  Root_Density_Set Updated_Set (ntypes + 1, 10, 10.0);  // last two parameters are meaningless
-  for (int n = 0; n < ntypes; ++n) Updated_Set.epsilon[n] = epsilon[n];
+  Root_Density_Set& Root_Density_Set::operator= (const Root_Density_Set& RefSet)
+  {
+    if (this != &RefSet) {
+      ntypes = RefSet.ntypes;
+      epsilon = RefSet.epsilon;
+      Npts_total = RefSet.Npts_total;
+      diff = RefSet.diff;
+    }
+    return(*this);
+  }
 
-  //Updated_Set.epsilon[ntypes] = Root_Density (epsilon[ntypes - 1].Npts, epsilon[ntypes - 1].lambdamax);
-  Updated_Set.epsilon[ntypes] = Root_Density (50, epsilon[ntypes - 1].lambdamax);
-  Updated_Set.epsilon[ntypes].Set_Asymptotics (asymptotic_value);
+  void Root_Density_Set::Insert_new_function (DP asymptotic_value)
+  {
+    // This function extends a set by adding one epsilon_n function on top
 
-  for (int i = 0; i < Updated_Set.epsilon[ntypes].Npts; ++i)
-    Updated_Set.epsilon[ntypes].value[i] = Updated_Set.epsilon[ntypes].value_infty;
+    Root_Density_Set Updated_Set (ntypes + 1, 10, 10.0);  // last two parameters are meaningless
+    for (int n = 0; n < ntypes; ++n) Updated_Set.epsilon[n] = epsilon[n];
 
-  ntypes = Updated_Set.ntypes;
-  epsilon = Updated_Set.epsilon;
-  Npts_total+= Updated_Set.epsilon[ntypes - 1].Npts;
-}
+    Updated_Set.epsilon[ntypes] = Root_Density (50, epsilon[ntypes - 1].lambdamax);
+    Updated_Set.epsilon[ntypes].Set_Asymptotics (asymptotic_value);
 
-void Root_Density_Set::Extend_limits (Vect<bool> need_to_extend_limit)
-{
-  // Extend the limits of integration at each level, according to boolean
+    for (int i = 0; i < Updated_Set.epsilon[ntypes].Npts; ++i)
+      Updated_Set.epsilon[ntypes].value[i] = Updated_Set.epsilon[ntypes].value_infty;
 
-  // The function extends the limits by 10% on both sides, putting the
-  // extra values to value_infty.
+    ntypes = Updated_Set.ntypes;
+    epsilon = Updated_Set.epsilon;
+    Npts_total+= Updated_Set.epsilon[ntypes - 1].Npts;
+  }
 
-  if (need_to_extend_limit.size() != epsilon.size()) ABACUSerror("Wrong size need_to_extend_limit boolean in Extend_limits.");
+  void Root_Density_Set::Extend_limits (Vect<bool> need_to_extend_limit)
+  {
+    // Extend the limits of integration at each level, according to boolean
 
-  Vect_INT nr_new_points_needed(0, ntypes);
-  int total_nr_new_points_added = 0;
-  DP dlambda_used = 0.0;
-  for (int n = 0; n < ntypes; ++n) {
-    if (need_to_extend_limit[n]) {
+    // The function extends the limits by 10% on both sides, putting the
+    // extra values to value_infty.
 
-      Root_Density epsilon_n_before_update = epsilon[n];
+    if (need_to_extend_limit.size() != epsilon.size())
+      ABACUSerror("Wrong size need_to_extend_limit boolean in Extend_limits.");
 
-      // Determine the dlambda to be used:
-      dlambda_used = epsilon[n].dlambda[0];
+    Vect_INT nr_new_points_needed(0, ntypes);
+    int total_nr_new_points_added = 0;
+    DP dlambda_used = 0.0;
+    for (int n = 0; n < ntypes; ++n) {
+      if (need_to_extend_limit[n]) {
 
-      // How many new points do we add ?  Say 5\% on each side:
-      nr_new_points_needed[n] = ABACUS::max(1, epsilon[n].Npts/20);
+	Root_Density epsilon_n_before_update = epsilon[n];
 
-      epsilon[n] = Root_Density(epsilon_n_before_update.Npts + 2* nr_new_points_needed[n], epsilon_n_before_update.lambdamax + nr_new_points_needed[n] * dlambda_used);
-      epsilon[n].Set_Asymptotics(epsilon_n_before_update.value_infty);
+	// Determine the dlambda to be used:
+	dlambda_used = epsilon[n].dlambda[0];
 
-      for (int i = 0; i < nr_new_points_needed[n]; ++i) {
-	epsilon[n].lambda[i] = epsilon_n_before_update.lambda[0] - (nr_new_points_needed[n] - i) * dlambda_used;
-	epsilon[n].dlambda[i] = dlambda_used;
-	epsilon[n].value[i] = epsilon_n_before_update.value_infty;
-      }
+	// How many new points do we add ?  Say 5\% on each side:
+	nr_new_points_needed[n] = ABACUS::max(1, epsilon[n].Npts/20);
 
-      for (int i = 0; i < epsilon_n_before_update.Npts; ++i) {
-	epsilon[n].lambda[i + nr_new_points_needed[n] ] = epsilon_n_before_update.lambda[i];
-	epsilon[n].dlambda[i + nr_new_points_needed[n] ] = epsilon_n_before_update.dlambda[i];
-	epsilon[n].value[i + nr_new_points_needed[n] ] = epsilon_n_before_update.value[i];
-      }
-
-      for (int i = 0; i < nr_new_points_needed[n]; ++i) {
-	epsilon[n].lambda[i + epsilon_n_before_update.Npts + nr_new_points_needed[n] ]
-	  = epsilon_n_before_update.lambda[epsilon_n_before_update.Npts - 1] + (i+1.0) * dlambda_used;
-	epsilon[n].dlambda[i + epsilon_n_before_update.Npts + nr_new_points_needed[n] ] = dlambda_used;
-	epsilon[n].value[i + epsilon_n_before_update.Npts + nr_new_points_needed[n] ] = epsilon_n_before_update.value_infty;
-      }
+	epsilon[n] = Root_Density(epsilon_n_before_update.Npts + 2* nr_new_points_needed[n],
+				  epsilon_n_before_update.lambdamax + nr_new_points_needed[n] * dlambda_used);
+	epsilon[n].Set_Asymptotics(epsilon_n_before_update.value_infty);
 
-      total_nr_new_points_added += 2 * nr_new_points_needed[n];
+	for (int i = 0; i < nr_new_points_needed[n]; ++i) {
+	  epsilon[n].lambda[i] = epsilon_n_before_update.lambda[0] - (nr_new_points_needed[n] - i) * dlambda_used;
+	  epsilon[n].dlambda[i] = dlambda_used;
+	  epsilon[n].value[i] = epsilon_n_before_update.value_infty;
+	}
 
-      //cout << "Extending limits at level " << n << " with " << nr_new_points_needed[n] << " points on each side to " << epsilon[n].lambdamax << endl;
+	for (int i = 0; i < epsilon_n_before_update.Npts; ++i) {
+	  epsilon[n].lambda[i + nr_new_points_needed[n] ] = epsilon_n_before_update.lambda[i];
+	  epsilon[n].dlambda[i + nr_new_points_needed[n] ] = epsilon_n_before_update.dlambda[i];
+	  epsilon[n].value[i + nr_new_points_needed[n] ] = epsilon_n_before_update.value[i];
+	}
 
-    } // if (need
-  } // for n
+	for (int i = 0; i < nr_new_points_needed[n]; ++i) {
+	  epsilon[n].lambda[i + epsilon_n_before_update.Npts + nr_new_points_needed[n] ]
+	    = epsilon_n_before_update.lambda[epsilon_n_before_update.Npts - 1] + (i+1.0) * dlambda_used;
+	  epsilon[n].dlambda[i + epsilon_n_before_update.Npts + nr_new_points_needed[n] ] = dlambda_used;
+	  epsilon[n].value[i + epsilon_n_before_update.Npts + nr_new_points_needed[n] ] = epsilon_n_before_update.value_infty;
+	}
 
-  Npts_total += total_nr_new_points_added;
+	total_nr_new_points_added += 2 * nr_new_points_needed[n];
 
-  // Done !
+      } // if (need
+    } // for n
 
-  return;
+    Npts_total += total_nr_new_points_added;
 
-}
+    // Done !
 
-void Root_Density_Set::Insert_new_points (Vect<Vect<bool> > need_new_point_around)
-{
-  // need_new_point_around specifies whether a new point needs to be inserted around existing points.
+    return;
 
-  // Count the number of new points needed per type:
-  Vect_INT nr_new_points_needed(0, ntypes);
-  int total_nr_new_points_needed = 0;
-  for (int n = 0; n < ntypes; ++n) {
-    if (need_new_point_around[n].size() != epsilon[n].Npts) ABACUSerror("Wrong size need_new_point_around boolean in Insert_new_points.");
-    for (int i = 0; i < epsilon[n].Npts; ++i)
-      if (need_new_point_around[n][i]) nr_new_points_needed[n]++;
-    total_nr_new_points_needed += nr_new_points_needed[n];
-  }
-  /*
-  // Simplistic version:  always keep equidistant points
-  for (int n = 0; n < ntypes; ++n) {
-    Root_Density epsilon_n_before_update = epsilon[n];
-    epsilon[n] = Root_Density(epsilon_n_before_update.Npts + nr_new_points_needed[n], epsilon_n_before_update.lambdamax);
-    epsilon[n].Set_Asymptotics(epsilon_n_before_update.value_infty);
-    for (int i = 0; i < epsilon[n].Npts; ++i)
-      epsilon[n].value[i] = epsilon_n_before_update.Return_Value(epsilon[n].lambda[i]);
   }
-  */
-
-  // Working version using non-equispaced points
-  // Now update all data via interpolation:
-  for (int n = 0; n < ntypes; ++n) {
-    Root_Density epsilon_n_before_update = epsilon[n];
-    epsilon[n] = Root_Density(epsilon_n_before_update.Npts + nr_new_points_needed[n], epsilon_n_before_update.lambdamax);
-    epsilon[n].Set_Asymptotics(epsilon_n_before_update.value_infty);
-    //cout << "Check: " << epsilon[n].Npts << " " << epsilon_n_before_update.Npts << endl;
-    int nr_pts_added_n = 0;
-    for (int i = 0; i < epsilon_n_before_update.Npts; ++i) {
-      if (!need_new_point_around[n][i]) {
-	epsilon[n].lambda[i + nr_pts_added_n] = epsilon_n_before_update.lambda[i];
-	epsilon[n].dlambda[i + nr_pts_added_n] = epsilon_n_before_update.dlambda[i];
-	epsilon[n].value[i + nr_pts_added_n] = epsilon_n_before_update.value[i];
+
+  void Root_Density_Set::Insert_new_points (Vect<Vect<bool> > need_new_point_around)
+  {
+    // need_new_point_around specifies whether a new point needs to be inserted around existing points.
+
+    // Count the number of new points needed per type:
+    Vect_INT nr_new_points_needed(0, ntypes);
+    int total_nr_new_points_needed = 0;
+    for (int n = 0; n < ntypes; ++n) {
+      if (need_new_point_around[n].size() != epsilon[n].Npts)
+	ABACUSerror("Wrong size need_new_point_around boolean in Insert_new_points.");
+      for (int i = 0; i < epsilon[n].Npts; ++i)
+	if (need_new_point_around[n][i]) nr_new_points_needed[n]++;
+      total_nr_new_points_needed += nr_new_points_needed[n];
+    }
+
+    // Working version using non-equispaced points
+    // Now update all data via interpolation:
+    for (int n = 0; n < ntypes; ++n) {
+      Root_Density epsilon_n_before_update = epsilon[n];
+      epsilon[n] = Root_Density(epsilon_n_before_update.Npts + nr_new_points_needed[n], epsilon_n_before_update.lambdamax);
+      epsilon[n].Set_Asymptotics(epsilon_n_before_update.value_infty);
+      int nr_pts_added_n = 0;
+      for (int i = 0; i < epsilon_n_before_update.Npts; ++i) {
+	if (!need_new_point_around[n][i]) {
+	  epsilon[n].lambda[i + nr_pts_added_n] = epsilon_n_before_update.lambda[i];
+	  epsilon[n].dlambda[i + nr_pts_added_n] = epsilon_n_before_update.dlambda[i];
+	  epsilon[n].value[i + nr_pts_added_n] = epsilon_n_before_update.value[i];
+	}
+	else if (need_new_point_around[n][i]) {
+	  epsilon[n].lambda[i + nr_pts_added_n] = epsilon_n_before_update.lambda[i] - 0.25 * epsilon_n_before_update.dlambda[i];
+	  epsilon[n].dlambda[i + nr_pts_added_n] = 0.5 * epsilon_n_before_update.dlambda[i];
+	  epsilon[n].value[i + nr_pts_added_n] = epsilon_n_before_update.Return_Value(epsilon[n].lambda[i + nr_pts_added_n]);
+	  nr_pts_added_n++;
+	  epsilon[n].lambda[i + nr_pts_added_n] = epsilon_n_before_update.lambda[i] + 0.25 * epsilon_n_before_update.dlambda[i];
+	  epsilon[n].dlambda[i + nr_pts_added_n] = 0.5 * epsilon_n_before_update.dlambda[i];
+	  epsilon[n].value[i + nr_pts_added_n] = epsilon_n_before_update.Return_Value(epsilon[n].lambda[i + nr_pts_added_n]);
+	}
       }
-      else if (need_new_point_around[n][i]) {
-	epsilon[n].lambda[i + nr_pts_added_n] = epsilon_n_before_update.lambda[i] - 0.25 * epsilon_n_before_update.dlambda[i];
-	epsilon[n].dlambda[i + nr_pts_added_n] = 0.5 * epsilon_n_before_update.dlambda[i];
-	epsilon[n].value[i + nr_pts_added_n] = epsilon_n_before_update.Return_Value(epsilon[n].lambda[i + nr_pts_added_n]);
-	nr_pts_added_n++;
-	epsilon[n].lambda[i + nr_pts_added_n] = epsilon_n_before_update.lambda[i] + 0.25 * epsilon_n_before_update.dlambda[i];
-	epsilon[n].dlambda[i + nr_pts_added_n] = 0.5 * epsilon_n_before_update.dlambda[i];
-	epsilon[n].value[i + nr_pts_added_n] = epsilon_n_before_update.Return_Value(epsilon[n].lambda[i + nr_pts_added_n]);
+      if (nr_pts_added_n != nr_new_points_needed[n]) {
+	cout << nr_pts_added_n << "\t" << nr_new_points_needed[n] << endl;
+	ABACUSerror("Wrong counting of new points in Insert_new_points.");
       }
-    }
-    if (nr_pts_added_n != nr_new_points_needed[n]) {
-      cout << nr_pts_added_n << "\t" << nr_new_points_needed[n] << endl;
-      ABACUSerror("Wrong counting of new points in Insert_new_points.");
-    }
 
-    // Check:
-    //for (int i = 0; i < epsilon[n].Npts - 1; ++i)
-    //if (fabs(epsilon[n].lambda[i] + 0.5 *(epsilon[n].dlambda[i] + epsilon[n].dlambda[i+1]) - epsilon[n].lambda[i+1]) > 1.0e-13)
-	//{
-    // cout << "Error at level " << n << "\ti " << i << "\t" << epsilon[n].lambda[i] << "\t" << epsilon[n].dlambda[i]
-    //       << "\t" << epsilon[n].lambda[i+1] << "\t" << epsilon[n].dlambda[i+1]
-    //       << "\t" << epsilon[n].lambda[i] + 0.5 *(epsilon[n].dlambda[i] + epsilon[n].dlambda[i+1]) - epsilon[n].lambda[i+1] << endl;
-    //  ABACUSerror("...");
-    //}
+    } // for n
 
-  } // for n
+    Npts_total += total_nr_new_points_needed;
 
+    // Done !
 
-  //cout << "need_new_pt_above " << need_new_point_above[0] << endl << endl;
-  //cout << "epsilon[0].lambda = " << epsilon[0].lambda << endl << endl;
-  //cout << "epsilon[0].dlambda = " << epsilon[0].dlambda << endl << endl;
-  //cout << "epsilon[0].value = " << epsilon[0].value << endl << endl;
+    return;
+  }
 
-  Npts_total += total_nr_new_points_needed;
+  DP Root_Density_Set::Return_Value (int n_ref, DP lambda_ref)
+  {
+    // Returns a value, no matter what !
 
-  // Done !
+    if (n_ref < ntypes) return(epsilon[n_ref].Return_Value(lambda_ref));
 
-  return;
-}
+    else // assume asymptotic form of epsilon, proportional to n
+      return(epsilon[ntypes - 1].Return_Value(lambda_ref) * n_ref/(ntypes - 1.0));
 
-DP Root_Density_Set::Return_Value (int n_ref, DP lambda_ref)
-{
-  // Returns a value, no matter what !
+  }
 
-  if (n_ref < ntypes) return(epsilon[n_ref].Return_Value(lambda_ref));
+  Root_Density_Set Root_Density_Set::Return_Compressed_and_Matched_Set (DP comp_factor)
+  {
+    // Returns a set with 1/comp_factor as many points at each level
 
-  else // assume asymptotic form of epsilon, proportional to n
-    return(epsilon[ntypes - 1].Return_Value(lambda_ref) * n_ref/(ntypes - 1.0));
+    if (comp_factor >= 2.0)
+      ABACUSerror("Compression factor too large in Return_Compressed_and_Matched_Set, numerical instability will occur.");
 
-}
+    Vect_INT nrpts_comp (ntypes);
+    Vect_DP lambdamax_comp (ntypes);
+    for (int n = 0; n < ntypes; ++n) {
+      nrpts_comp[n] = int(2.0 * epsilon[n].lambdamax/(epsilon[n].dlambda[0] * comp_factor));
+      lambdamax_comp[n] = epsilon[n].lambdamax;
+    }
 
-Root_Density_Set Root_Density_Set::Return_Compressed_and_Matched_Set (DP comp_factor)
-{  // Returns a set with 1/comp_factor as many points at each level
+    Root_Density_Set Compressed_and_Matched_Set (ntypes, nrpts_comp, lambdamax_comp);
 
-  if (comp_factor >= 2.0)
-    ABACUSerror("Compression factor too large in Return_Compressed_and_Matched_Set, numerical instability will occur.");
+    for (int n = 0; n < ntypes; ++n)
+      Compressed_and_Matched_Set.epsilon[n] = (*this).epsilon[n].Compress_and_Match_Densities (comp_factor);
 
-  Vect_INT nrpts_comp (ntypes);
-  Vect_DP lambdamax_comp (ntypes);
-  for (int n = 0; n < ntypes; ++n) {
-    nrpts_comp[n] = int(2.0 * epsilon[n].lambdamax/(epsilon[n].dlambda[0] * comp_factor));
-    lambdamax_comp[n] = epsilon[n].lambdamax;
+    return(Compressed_and_Matched_Set);
   }
 
-  Root_Density_Set Compressed_and_Matched_Set (ntypes, nrpts_comp, lambdamax_comp);
-
-  for (int n = 0; n < ntypes; ++n)
-    Compressed_and_Matched_Set.epsilon[n] = (*this).epsilon[n].Compress_and_Match_Densities (comp_factor);
-
-  return(Compressed_and_Matched_Set);
-}
+  void Root_Density_Set::Match_Densities (Root_Density_Set& RefSet)
+  {
+    // matched densities to those in RefSet
 
-void Root_Density_Set::Match_Densities (Root_Density_Set& RefSet)
-{ // matched densities to those in RefSet
-
-  for (int n = 0; n < ntypes; ++n)
-    for (int i = 0; i < epsilon[n].Npts; ++i)
-      epsilon[n].value[i] = RefSet.epsilon[n].Return_Value(epsilon[n].lambda[i]);
-}
-
-void Root_Density_Set::Save (const char* outfile_Cstr)
-{
-  ofstream outfile;
-  outfile.open(outfile_Cstr);
-  outfile.precision(16);
+    for (int n = 0; n < ntypes; ++n)
+      for (int i = 0; i < epsilon[n].Npts; ++i)
+	epsilon[n].value[i] = RefSet.epsilon[n].Return_Value(epsilon[n].lambda[i]);
+  }
 
-  // Determine what the maximal nr of pts is:
-  int Npts_n_max = 0;
-  for (int n = 0; n < ntypes; ++n) Npts_n_max = ABACUS::max(Npts_n_max, epsilon[n].Npts);
+  void Root_Density_Set::Save (const char* outfile_Cstr)
+  {
+    ofstream outfile;
+    outfile.open(outfile_Cstr);
+    outfile.precision(16);
+
+    // Determine what the maximal nr of pts is:
+    int Npts_n_max = 0;
+    for (int n = 0; n < ntypes; ++n) Npts_n_max = ABACUS::max(Npts_n_max, epsilon[n].Npts);
+
+    for (int i = 0; i < Npts_n_max; ++i) {
+      if (i > 0) outfile << endl;
+      for (int n = 0; n < ntypes; ++n) (i < epsilon[n].Npts) ?
+					 (outfile << epsilon[n].lambda[i] << "\t" << epsilon[n].value[i] << "\t")
+					 : (outfile << 0 << "\t" << 0 << "\t");
+    }
 
-  for (int i = 0; i < Npts_n_max; ++i) {
-    if (i > 0) outfile << endl;
-    for (int n = 0; n < ntypes; ++n) (i < epsilon[n].Npts) ?
-					       (outfile << epsilon[n].lambda[i] << "\t" << epsilon[n].value[i] << "\t")
-					       : (outfile << 0 << "\t" << 0 << "\t");
+    outfile.close();
   }
 
-  outfile.close();
-}
-
 
 } // namespace ABACUS

src/TBA/TBA_LiebLin.cc

@@ -90,8 +90,6 @@ namespace ABACUS {
       rho_GS = LiebLin_rho_GS (c_int, k_F, lambdamax, Npts, req_prec);
       n_found = Density_GS (rho_GS);
 
-      //cout << "k_F " << k_F << "\tn_found " << n_found << endl;
-
     } while (fabs(dk_F) > req_prec && dk_F > 1.0/Npts
 	     && fabs(n - n_found) > req_prec && fabs(n - n_found) > 1.0/Npts);
 
@@ -189,23 +187,6 @@ namespace ABACUS {
 
 
   // Finite T functions:
-  /*
-  // from ABACUS_TBA.h
-
-  struct LiebLin_TBA_Solution {
-
-    DP c_int;
-    DP mu;
-    DP nbar;
-    DP kBT;
-    Root_Density epsilon;
-    Root_Density depsilon_dmu;
-    Root_Density rho;
-    Root_Density rhoh;
-
-    LiebLin_TBA_Solution (DP c_int_ref, DP mu_ref, DP kBT_ref, int Npts_ref, DP req_diff, int Max_Secs);
-  };
-  */
 
   LiebLin_TBA_Solution::LiebLin_TBA_Solution (DP c_int_ref, DP mu_ref, DP kBT_ref, DP req_diff, int Max_Secs)
     : c_int(c_int_ref), mu(mu_ref), kBT(kBT_ref)
@@ -218,20 +199,10 @@ namespace ABACUS {
     ebar = LiebLin_ebar_TBA (rho);
     sbar = LiebLin_sbar_TBA (rho, rhoh);
   }
-  /*
-  LiebLin_TBA_Solution::LiebLin_TBA_Solution (DP c_int_ref, DP mu_ref, DP kBT_ref, int Npts_ref, DP req_diff, int Max_Secs, const LiebLin_TBA_Solution& prev_sol)
-    : c_int(c_int_ref), mu(mu_ref), kBT(kBT_ref)
-  {
-    epsilon = LiebLin_epsilon_TBA (c_int, mu, kBT, Npts_ref, req_diff, Max_Secs, prev_sol.epsilon);
-    depsilon_dmu = LiebLin_depsilon_dmu_TBA (c_int, mu, kBT, Npts_ref, req_diff, Max_Secs, epsilon, prev_sol.depsilon_dmu);
-    rho = LiebLin_rho_TBA (kBT, epsilon, depsilon_dmu);
-    rhoh = LiebLin_rhoh_TBA (kBT, epsilon, depsilon_dmu);
-    nbar = LiebLin_nbar_TBA (rho);
-  }
-  */
 
 
-  LiebLin_TBA_Solution LiebLin_TBA_Solution_fixed_nbar_ebar (DP c_int, DP nbar_required, DP ebar_required, DP req_diff, int Max_Secs)
+  LiebLin_TBA_Solution LiebLin_TBA_Solution_fixed_nbar_ebar (DP c_int, DP nbar_required, DP ebar_required,
+							     DP req_diff, int Max_Secs)
   {
     // This function finds the TBA solution for a required nbar and ebar (mean energy).
     // We here try to triangulate the temperature; the chemical potential is triangulated
@@ -263,26 +234,7 @@ namespace ABACUS {
       lnkBT += dlnkBT;
       tbasol = LiebLin_TBA_Solution_fixed_nbar(c_int, nbar_required, exp(lnkBT), req_diff, Max_Secs);
       niter++;
-      //cout << setprecision(16) << "kBT: niter " << niter << "\tebar = " << tbasol.ebar << "\trequired = " << ebar_required << "\tlnkBT = " << lnkBT << "\tdlnkBT = " << dlnkBT << endl;
     }
-    // FIRST VERSION
-
-    /* SECOND VERSION
-    DP lnkBT = 1.0;
-    DP dlnkBT = 1.0;
-
-    DP mu = 2.0;
-    DP dmu = 1.0;
-
-    LiebLin_TBA_Solution tbasol = LiebLin_TBA_Solution(c_int, mu, kBT, req_diff, Max_Secs);
-    DP mu_prev = mu;
-    DP nbar_prev = tbasol.nbar;
-    DP lnkBT_prev = lnkBT;
-    DP ebar_prev = LiebLin_ebar_TBA (tbasol.rho);
-
-    DP dmu_prev, dnbardmu;
-    DP dlnkBT_prev, debardlnkBT;
-    */ // SECOND VERSION
 
     return(tbasol);
   }
@@ -292,48 +244,6 @@ namespace ABACUS {
   LiebLin_TBA_Solution LiebLin_TBA_Solution_fixed_nbar (DP c_int, DP nbar_required, DP kBT, DP req_diff, int Max_Secs)
   {
     // Find the required mu. Provide some initial guess.
-    /*
-    DP gamma_required = c_int/nbar_required;
-
-
-    // We define a matrix of mu's (calculated once and for all and filled in here)
-    // from which we can define an accurate first guess for mu, given gamma_required and kBT.
-
-    // The gamma's are by definition (1/16) * 2^{igamma},
-    // and the kBT are (1/16) * 2^{iT}.
-    int ndata = 16;
-    Vect<DP> gamma(ndata);
-    Vect<DP> Tred(ndata); // reduced temperature, kBT/
-    for (int i = 0; i < ndata; ++i) {
-      gamma[i] = 0.0625 * pow(2.0, i);
-      T[i] = 0.0625 * pow(2.0, i);
-    }
-    SQMat<DP> mudata(ndata);
-    // This data was computed separately, for unit filling, using 512 points, to accuracy 10^-4:
-
-    // Figure out which index igamma we should use:
-    // (1/16) * 2^{igamma_low} <~ gamma_required, so
-    int igamma_below = int(log(gamma_required * 16.0)/log(2.0));
-    // Similarly,
-    int iT_below = int(log(kBT * 16.0)/log(2.0));
-
-    igamma_below = ABACUS::max(igamma_below, 0);
-    igamma_below = ABACUS::min(igamma_below, ndata - 1);
-    iT_below = ABACUS::max(iT_below, 0);
-    iT_below = ABACUS::min(iT_below, ndata - 1);
-    // We use indices igamma_below, igamma_below + 1, iT_below, iT_below + 1 to guess mu:
-    // do a four-point extrapolation,
-    DP mu = ((gamma[igamma_below + 1] - gamma_required) * (T[iT_below + 1] - kBT) * mudata[igamma_below][iT_below]
-	     + (gamma_required - gamma[igamma_below]) * (T[iT_below + 1] - kBT) * mudata[igamma_below + 1][iT_below]
-	     + (gamma[igamma_below + 1] - gamma_required) * (kBT - T[iT_below]) * mudata[igamma_below][iT_below + 1]
-	     + (gamma_required - gamma[igamma_below]) * (kBT - T[iT_below]) * mudata[igamma_below + 1][iT_below + 1])
-      /((gamma[igamma_below + 1] - gamma[igamma_below]) * (T[iT_below + 1] - T[iT_below]));
-
-    // Translate to the required filling:
-
-
-    DP dnbardmu = ;
-    */
 
     DP mu = 2.0;
     DP dmu = 1.0;
@@ -360,7 +270,6 @@ namespace ABACUS {
       mu += dmu;
       tbasol = LiebLin_TBA_Solution(c_int, mu, kBT, req_diff, Max_Secs);
       niter++;
-      //cout << setprecision(16) << "\tmu: niter " << niter << "\tnbar = " << tbasol.nbar << "\trequired = " << nbar_required<< "\tmu = " << mu << "\tdmu = " << dmu << endl;
     }
 
     return(tbasol);
@@ -398,7 +307,7 @@ namespace ABACUS {
 
       tni[i] = measure_factor * epsilon.value[i];
       tni_ex[i] = measure_factor * (epsilon.value[i-1] *  (epsilon.lambda[i+1] - epsilon.lambda[i])
-				       + epsilon.value[i+1] * (epsilon.lambda[i] - epsilon.lambda[i-1]))
+				    + epsilon.value[i+1] * (epsilon.lambda[i] - epsilon.lambda[i-1]))
 	/(epsilon.lambda[i+1] - epsilon.lambda[i-1]);
 
       max_delta_tni_dlambda = ABACUS::max(max_delta_tni_dlambda, fabs(tni[i] - tni_ex[i]) * epsilon.dlambda[i]);
@@ -454,7 +363,9 @@ namespace ABACUS {
       int nr_pts_to_add_left = epsilon.Npts/10;
       int nr_pts_to_add_right = epsilon.Npts/10;
       Root_Density epsilon_before_update = epsilon;
-      epsilon = Root_Density(epsilon_before_update.Npts + nr_pts_to_add_left + nr_pts_to_add_right, epsilon_before_update.lambdamax + nr_pts_to_add_left * epsilon_before_update.dlambda[0] + nr_pts_to_add_right * epsilon_before_update.dlambda[epsilon_before_update.Npts - 1]);
+      epsilon = Root_Density(epsilon_before_update.Npts + nr_pts_to_add_left + nr_pts_to_add_right,
+			     epsilon_before_update.lambdamax + nr_pts_to_add_left * epsilon_before_update.dlambda[0]
+			     + nr_pts_to_add_right * epsilon_before_update.dlambda[epsilon_before_update.Npts - 1]);
 
       // Initialize points added on left
       for (int i = 0; i < nr_pts_to_add_left; ++i) {
@@ -470,9 +381,13 @@ namespace ABACUS {
       }
       // Initialize points added on right
       for (int i = 0; i < nr_pts_to_add_right; ++i) {
-	epsilon.lambda[nr_pts_to_add_left + epsilon_before_update.Npts + i] = epsilon_before_update.lambda[epsilon_before_update.Npts - 1] + (i+1) * epsilon_before_update.dlambda[epsilon_before_update.Npts - 1];
-	epsilon.dlambda[nr_pts_to_add_left + epsilon_before_update.Npts + i] = epsilon_before_update.dlambda[epsilon_before_update.Npts - 1];
-	epsilon.value[nr_pts_to_add_left + epsilon_before_update.Npts + i] = epsilon_before_update.value[epsilon_before_update.Npts - 1];
+	epsilon.lambda[nr_pts_to_add_left + epsilon_before_update.Npts + i] =
+	  epsilon_before_update.lambda[epsilon_before_update.Npts - 1]
+	  + (i+1) * epsilon_before_update.dlambda[epsilon_before_update.Npts - 1];
+	epsilon.dlambda[nr_pts_to_add_left + epsilon_before_update.Npts + i] =
+	  epsilon_before_update.dlambda[epsilon_before_update.Npts - 1];
+	epsilon.value[nr_pts_to_add_left + epsilon_before_update.Npts + i] =
+	  epsilon_before_update.value[epsilon_before_update.Npts - 1];
       }
     }
 
@@ -484,14 +399,16 @@ namespace ABACUS {
   {
 
     clock_t StartTime = clock();
-    int Max_CPU_ticks = 98 * (Max_Secs - 0) * CLOCKS_PER_SEC/100;  // give 30 seconds to wrap up, assume we time to 2% accuracy.
+    int Max_CPU_ticks = 98 * (Max_Secs - 0) * CLOCKS_PER_SEC/100;
+    // give 30 seconds to wrap up, assume we time to 2% accuracy.
 
     // Set basic precision needed:
     DP running_prec = 1.0;
 
     DP refine_fraction = 0.5; // value fraction of points to be refined
 
-    DP lambdamax_init = 10.0 * sqrt(ABACUS::max(1.0, kBT + mu));  // such that exp(-(lambdamax^2 - mu - Omega)/T) <~ machine_eps
+    DP lambdamax_init = 10.0 * sqrt(ABACUS::max(1.0, kBT + mu));
+    // such that exp(-(lambdamax^2 - mu - Omega)/T) <~ machine_eps
 
     int Npts = 50;
 
@@ -522,7 +439,6 @@ namespace ABACUS {
       // Refine... returns sum_delta_tni_dlambda, so running prec is estimated as...
       previous_running_prec = running_prec;
       running_prec = Refine_LiebLin_epsilon_TBA (epsilon, c_int, mu, kBT, refine_fraction);
-      //cout << "ncycles = " << ncycles << "\trunning_prec = " << running_prec << endl;
       running_prec = ABACUS::min(running_prec, previous_running_prec);
 
       // Now iterate to convergence for given discretization
@@ -537,11 +453,13 @@ namespace ABACUS {
 	Vect<DP> Tln1plusemineps(epsilon.Npts);
 	for (int i = 0; i < epsilon.Npts; ++i) {
 	  Tln1plusemineps[i] = epsilon.value[i] > 0.0 ?
-	    kBT * (epsilon.value[i] < 24.0 * kBT ? log(1.0 + exp(-epsilon.value[i]/kBT)) : exp(-epsilon.value[i]/kBT) * (1.0 - 0.5 * exp(-epsilon.value[i]/kBT)))
-	    //kBT * log(1.0 + exp(-epsilon.value[i]/kBT))
+	    kBT * (epsilon.value[i] < 24.0 * kBT
+		   ? log(1.0 + exp(-epsilon.value[i]/kBT))
+		   : exp(-epsilon.value[i]/kBT) * (1.0 - 0.5 * exp(-epsilon.value[i]/kBT)))
 	    :
-	    -epsilon.value[i] + kBT * (-epsilon.value[i] < 24.0 * kBT ? log (1.0 + exp(epsilon.value[i]/kBT)) : exp(epsilon.value[i]/kBT) * (1.0 - 0.5 * exp(epsilon.value[i]/kBT)));
-	  //-epsilon.value[i] + kBT * log (1.0 + exp(epsilon.value[i]/kBT));
+	    -epsilon.value[i] + kBT * (-epsilon.value[i] < 24.0 * kBT
+				       ? log (1.0 + exp(epsilon.value[i]/kBT))
+				       : exp(epsilon.value[i]/kBT) * (1.0 - 0.5 * exp(epsilon.value[i]/kBT)));
 	  // Keep previous rapidities:
 	  epsilon.prev_value[i] = epsilon.value[i];
 	}
@@ -551,7 +469,11 @@ namespace ABACUS {
 	for (int i = 0; i < epsilon.Npts; ++i) {
 	  a_2_Tln_conv[i] = 0.0;
 
-	  for (int j = 0; j < epsilon.Npts; ++j) a_2_Tln_conv[i] += oneoverpi * (atan(oneoverc * (epsilon.lambda[i] - epsilon.lambda[j] + 0.5 * epsilon.dlambda[j])) - atan(oneoverc * (epsilon.lambda[i] - epsilon.lambda[j] - 0.5 * epsilon.dlambda[j]))) * Tln1plusemineps[j];
+	  for (int j = 0; j < epsilon.Npts; ++j)
+	    a_2_Tln_conv[i] +=
+	      oneoverpi * (atan(oneoverc * (epsilon.lambda[i] - epsilon.lambda[j] + 0.5 * epsilon.dlambda[j]))
+			   - atan(oneoverc * (epsilon.lambda[i] - epsilon.lambda[j]
+					      - 0.5 * epsilon.dlambda[j]))) * Tln1plusemineps[j];
 
 	} // a_2_Tln_conv is now calculated
 
@@ -563,9 +485,7 @@ namespace ABACUS {
 	  epsilon.value[i] -= a_2_Tln_conv[i];
 
 	  // Include some damping:
-	  //epsilon.value[i] = 0.1 * epsilon.prev_value[i] + 0.9 * epsilon.value[i];
 	  epsilon.value[i] = 0.1 * epsilon.prev_value[i] + 0.9 * epsilon.value[i];
-	  //* (1.0 + (epsilon.value[i] - epsilon.prev_value[i])/fabs(epsilon.value[i] + epsilon.prev_value[i]));
 	}
 
 	niter++;
@@ -582,15 +502,11 @@ namespace ABACUS {
 	StopTime = clock();
 	CPU_ticks += StopTime - StartTime;
 
-	//cout << "epsilon: niter = " << niter << "\tdiff = " << epsilon.diff << endl;
-	//cout << epsilon.lambda[0] << "\t" << epsilon.dlambda[0] << endl;
-	//cout << "a_2_Tln_conv[0] = " << a_2_Tln_conv[0] << "\tTln1plusemineps[0] = " << Tln1plusemineps[0] << endl;
       } while (niter < 5 || niter < niter_max && CPU_ticks < Max_CPU_ticks && epsilon.diff > 0.1*running_prec);
 
       ncycles++;
       niter_tot += niter;
 
-      //cout << "End of a cycle: niter = " << niter << "\tniter_tot = " << niter_tot << "\tepsilon.diff = " << epsilon.diff << "\tNpts = " << epsilon.Npts << "\tlambdamax = " << epsilon.lambda[0] << "\trunning_prec = " << running_prec << "\treq_diff = " << req_diff << endl;
     } // do cycles
     while (ncycles < 5 || running_prec > req_diff && CPU_ticks < Max_CPU_ticks);
 
@@ -603,7 +519,8 @@ namespace ABACUS {
   {
 
     clock_t StartTime = clock();
-    int Max_CPU_ticks = 98 * (Max_Secs - 0) * CLOCKS_PER_SEC/100;  // give 30 seconds to wrap up, assume we time to 2% accuracy.
+    int Max_CPU_ticks = 98 * (Max_Secs - 0) * CLOCKS_PER_SEC/100;
+    // give 30 seconds to wrap up, assume we time to 2% accuracy.
 
     Root_Density depsilon_dmu = epsilon;
 
@@ -644,7 +561,10 @@ namespace ABACUS {
 	a_2_depsover1plusepluseps_conv[i] = 0.0;
 
 	for (int j = 0; j < depsilon_dmu.Npts; ++j)
-	  a_2_depsover1plusepluseps_conv[i] += oneoverpi * (atan(oneoverc * (epsilon.lambda[i] - epsilon.lambda[j] + 0.5 * epsilon.dlambda[j])) - atan(oneoverc * (epsilon.lambda[i] - epsilon.lambda[j] - 0.5 * epsilon.dlambda[j]))) * depsover1plusepluseps[j];
+	  a_2_depsover1plusepluseps_conv[i] +=
+	    oneoverpi * (atan(oneoverc * (epsilon.lambda[i] - epsilon.lambda[j] + 0.5 * epsilon.dlambda[j]))
+			 - atan(oneoverc * (epsilon.lambda[i] - epsilon.lambda[j] - 0.5 * epsilon.dlambda[j])))
+	    * depsover1plusepluseps[j];
       }
 
       // Reconstruct the depsilon_dmu function:
@@ -668,7 +588,6 @@ namespace ABACUS {
       StopTime = clock();
       CPU_ticks += StopTime - StartTime;
 
-      //cout << "depsilon_dmu: niter = " << niter << "\tdiff = " << depsilon_dmu.diff << endl;
     } while (niter < 5 || niter < niter_max && CPU_ticks < Max_CPU_ticks && depsilon_dmu.diff > req_diff);
 
     return(depsilon_dmu);
@@ -717,7 +636,9 @@ namespace ABACUS {
   DP LiebLin_sbar_TBA (const Root_Density& rho, const Root_Density& rhoh)
   {
     DP sbar = 0.0;
-    for (int i = 0; i < rho.Npts; ++i) sbar += ((rho.value[i] + rhoh.value[i]) * log(rho.value[i] + rhoh.value[i]) - rho.value[i] * log(rho.value[i]+1.0e-30) - rhoh.value[i] * log(rhoh.value[i]+1.0e-30)) * rho.dlambda[i];
+    for (int i = 0; i < rho.Npts; ++i)
+      sbar += ((rho.value[i] + rhoh.value[i]) * log(rho.value[i] + rhoh.value[i])
+	       - rho.value[i] * log(rho.value[i]+1.0e-30) - rhoh.value[i] * log(rhoh.value[i]+1.0e-30)) * rho.dlambda[i];
 
     return(sbar);
   }
@@ -743,20 +664,12 @@ namespace ABACUS {
 	  lambda_found[Nfound++] = 0.25 * (rho.lambda[i-1] + 3.0 * rho.lambda[i]);
 	}
 	else {
-	  //lambda_found[Nfound] = rho.lambda[i];
 	  // Better: center the lambda_found between these points:
-	  //lambda_found[Nfound] = rho.lambda[i-1] + (rho.lambda[i] - rho.lambda[i-1]) * ((Nfound + 1.0) - integral_prev)/(integral - integral_prev);
 	  lambda_found[Nfound] = 0.5 * (rho.lambda[i-1] + rho.lambda[i]);
 	  Nfound++;
 	}
       }
-      //cout << "\ti = " << i << "\tintegral = " << integral << "\tNfound = " << Nfound << endl;
     }
-    //cout << "rho: " << rho.Npts << " points" << endl << rho.value << endl;
-    //cout << "sym: " << rho.value[0] << " " << rho.value[rho.value.size() - 1]
-    // << "\t" << rho.value[rho.value.size()/2] << " " << rho.value[rho.value.size()/2 + 1] << endl;
-    //cout << "Found " << Nfound << " particles." << endl;
-    //cout << "lambda_found = " << lambda_found << endl;
 
     Vect<DP> lambda(N);
     // Fill up the found rapidities:
@@ -770,11 +683,9 @@ namespace ABACUS {
     for (int i = 0; i < N; ++i) {
       DP sum = 0.0;
       for (int j = 0; j < N; ++j) sum += 2.0 * atan((lambda[i] - lambda[j])/c_int);
-      //Ix2[i] = 2.0* int((L * lambda[i] + sum)/twoPI) + (N % 2) - 1;
       // For N is even/odd, we want to round off to the nearest odd/even integer.
       Ix2[i] = 2.0 * floor((L* lambda[i] + sum)/twoPI + 0.5 * (N%2 ? 1 : 2)) + (N%2) - 1;
     }
-    //cout << "Found quantum numbers " << endl << Ix2 << endl;
 
     // Check that the quantum numbers are all distinct:
     bool allOK = false;
@@ -784,12 +695,10 @@ namespace ABACUS {
       allOK = true;
       for (int i = 0; i < N-1; ++i) if (Ix2[i] == Ix2[i+1]) allOK = false;
     }
-    //cout << "Found modified quantum numbers " << endl << Ix2 << endl;
 
     LiebLin_Bethe_State rhostate(c_int, L, N);
     rhostate.Ix2 = Ix2;
     rhostate.Compute_All(true);
-    //cout << "rapidities of state found: " << rhostate.lambdaoc << endl;
 
     return(rhostate);
   }

src/TBA/TBA_XXZ.cc

@@ -80,7 +80,8 @@ namespace ABACUS {
       conv = 0.0;
       for (int j = 0; j < rhotot_GS.Npts; ++j)
 	conv += fabs(rhotot_GS.lambda[j]) > B ? 0.0 :
-	  XXZ_a2_kernel (sin2zeta, cos2zeta, rhotot_GS.lambda[i] - rhotot_GS.lambda[j]) * rhotot_GS.prev_value[j] * rhotot_GS.dlambda[j];
+	  XXZ_a2_kernel (sin2zeta, cos2zeta, rhotot_GS.lambda[i] - rhotot_GS.lambda[j])
+	  * rhotot_GS.prev_value[j] * rhotot_GS.dlambda[j];
       rhotot_GS.value[i] = XXZ_a1_kernel(sinzeta, coszeta, rhotot_GS.lambda[i]) - conv;
     }
 
@@ -109,11 +110,9 @@ namespace ABACUS {
     int niter = 0;
     do {
       Iterate_XXZ_rhotot_GS (zeta, B, rhotot_GS);
-      //cout << rhotot_GS.diff << endl;
       niter ++;
     } while (rhotot_GS.diff > req_prec);
 
-    //cout << "rhotot: niter = " << niter << endl;
     return(rhotot_GS);
   }
 
@@ -147,7 +146,6 @@ namespace ABACUS {
 	  XXZ_a2_kernel (sin2zeta, cos2zeta, eps_GS.lambda[i] - eps_GS.lambda[j])
 	  * eps_GS.prev_value[j] * eps_GS.dlambda[j];
       eps_GS.value[i] = Hz - PI * sinzeta * XXZ_a1_kernel(sinzeta, coszeta, eps_GS.lambda[i]) - conv;
-      //cout << i << "\t" << eps_GS.lambda[i] << "\t" << eps_GS.value[i] << "\t" << conv << endl;
     }
 
     // Calculate the sum of differences:
@@ -175,12 +173,9 @@ namespace ABACUS {
     int niter = 0;
     do {
       Iterate_XXZ_eps_GS (zeta, Hz, eps_GS);
-      //cout << eps_GS.diff << endl;
       niter++;
-      //cout << niter << "\t" << eps_GS.diff << endl;
     } while (eps_GS.diff > req_prec);
 
-  //cout << "eps: niter = " << niter << endl;
     return(eps_GS);
   }
 
@@ -232,11 +227,9 @@ namespace ABACUS {
     int niter = 0;
     do {
       Iterate_XXZ_depsdlambda_GS (zeta, B, depsdlambda_GS);
-      //cout << depsdlambda_GS.diff << endl;
       niter++;
     } while (depsdlambda_GS.diff > req_prec);
 
-    //cout << "depsdlambda: niter = " << niter << endl;
     return(depsdlambda_GS);
   }
 
@@ -289,12 +282,9 @@ namespace ABACUS {
     int niter = 0;
     do {
       Iterate_XXZ_b2BB_lambda_B (zeta, B, b2BB_lambda_B);
-      //cout << eps_GS.diff << endl;
       niter++;
     } while (b2BB_lambda_B.diff > req_prec);
 
-    //if (lambda_p + lambda_h + 2.0*B > 0.0) cout << "Nonzero backflow possible." << endl;
-    //cout << "Kbackflow: niter = " << niter << endl;
     return(b2BB_lambda_B);
   }
 
@@ -347,12 +337,9 @@ namespace ABACUS {
     int niter = 0;
     do {
       Iterate_XXZ_b2BB_lambda_lambdap (zeta, B, lambdap, b2BB_lambda_lambdap);
-      //cout << eps_GS.diff << endl;
       niter++;
     } while (b2BB_lambda_lambdap.diff > req_prec);
 
-    //if (lambda_p + lambda_h + 2.0*B > 0.0) cout << "Nonzero backflow possible." << endl;
-    //cout << "Kbackflow: niter = " << niter << endl;
     return(b2BB_lambda_lambdap);
   }
 
@@ -368,14 +355,12 @@ namespace ABACUS {
     DP sin2zeta = sin(2.0*zeta);
     DP cos2zeta = cos(2.0*zeta);
     for (int i = 0; i < Kbackflow_GS.Npts; ++i) {
-      //if (Kbackflow_GS.lambda[i] < -B || Kbackflow_GS.lambda[i] > lambda_p + lambda_h + B) Kbackflow_GS.value[i] = 0.0;
       if (false && fabs(Kbackflow_GS.lambda[i]) > B) Kbackflow_GS.value[i] = 0.0;
       else {
 	// First, calculate the convolution
 	conv = 0.0;
 	for (int j = 0; j < Kbackflow_GS.Npts; ++j)
 	  conv += fabs(Kbackflow_GS.lambda[j]) > B ? 0.0 :
-	    //(Kbackflow_GS.lambda[i] < -B || Kbackflow_GS.lambda[i] > lambda_p + lambda_h + B) ? 0.0 :
 	    XXZ_a2_kernel (sin2zeta, cos2zeta, Kbackflow_GS.lambda[i] - Kbackflow_GS.lambda[j])
 	    * Kbackflow_GS.prev_value[j] * Kbackflow_GS.dlambda[j];
 	Kbackflow_GS.value[i] = -XXZ_a2_kernel(sin2zeta, cos2zeta, Kbackflow_GS.lambda[i] - lambda_p)
@@ -407,12 +392,9 @@ namespace ABACUS {
     int niter = 0;
     do {
       Iterate_XXZ_Kbackflow_GS (zeta, B, lambda_p, lambda_h, Kbackflow_GS);
-      //cout << eps_GS.diff << endl;
       niter++;
     } while (Kbackflow_GS.diff > req_prec);
 
-    //if (lambda_p + lambda_h + 2.0*B > 0.0) cout << "Nonzero backflow possible." << endl;
-    //cout << "Kbackflow: niter = " << niter << endl;
     return(Kbackflow_GS);
   }
 
@@ -465,12 +447,9 @@ namespace ABACUS {
     int niter = 0;
     do {
       Iterate_XXZ_Fbackflow_GS (zeta, B, lambda_p, lambda_h, Fbackflow_GS);
-      //cout << eps_GS.diff << endl;
       niter++;
     } while (Fbackflow_GS.diff > req_prec);
 
-    //if (lambda_p + lambda_h + 2.0*B > 0.0) cout << "Nonzero backflow possible." << endl;
-    //cout << "Fbackflow: niter = " << niter << endl;
     return(Fbackflow_GS);
   }
 
@@ -519,199 +498,10 @@ namespace ABACUS {
 
     do {
       Iterate_XXZ_Z_GS (zeta, B, Z_GS);
-      //cout << depsdlambda_GS.diff << endl;
     } while (Z_GS.diff > req_prec);
 
     return(Z_GS);
   }
 
-  /*
-  void XXZ_Compare_Lattice_and_Continuum_Backflows_base_1010 (DP Delta, int N, int M, long long int id)
-  {
-    // Define the chain:  J, Delta, h, Nsites
-    Heis_Chain chain(1.0, Delta, 0.0, N);
-
-    // Define the base:  chain, Mdown
-    Heis_Base gbase(chain, M);
-
-    // Define the ground state
-    XXZ_Bethe_State gstate(chain, gbase);
-
-    // Compute everything about the ground state
-    gstate.Compute_All(true);
-
-    // Define the number of rapidities for an excited state
-    Vect_INT Nrapidities(0, chain.Nstrings);
-    Nrapidities[0] = M;
-
-    Vect_INT Nexcitations(0, 2* chain.Nstrings + 2);
-    Nexcitations[0] = 0;
-    Nexcitations[1] = 1;
-    Nexcitations[2] = 0;
-    Nexcitations[3] = 1;
-
-    // Define a base configuration for this set of rapidity numbers
-    Heis_Base ebase (chain, Nrapidities);
-
-    // Define the excited state
-    XXZ_Bethe_State estate(chain, ebase);
-
-    // Define an offset from a base and a number of holes
-    Ix2_Offsets offsets(ebase, Nexcitations);
-
-    // Set the offset to the desired id
-    offsets.Set_to_id (id);
-
-    // Set the offset data into the quantum numbers
-    estate.Set_Ix2_Offsets(offsets);
-
-    // Compute everything about this eigenstate
-    estate.Compute_All(true);
-
-    DP k_ext_N = estate.K - gstate.K;
-    DP omega_N = estate.E - gstate.E;
-    DP lambdap = estate.lambda[0][0];
-    DP lambdah = 0.0;
-    for (int alpha = 1; alpha < estate.base[0] - 1; ++alpha)
-      if (estate.Ix2[0][alpha + 1] > estate.Ix2[0][alpha] + 2) {
-	lambdah = 0.5 * (estate.lambda[0][alpha] + estate.lambda[0][alpha + 1]);
-      }
-
-
-    // Now solve the thermodynamic equations:
-    DP req_prec = 1.0e-12;
-    DP Hz_N = H_vs_M (Delta, N, M);
-    cout << "Hz_N = " << Hz_N << endl;
-    DP lambdamax = 4.0 * fabs(gstate.lambda[0][0]);
-    int Npts = 2000;
-    Root_Density eps_GS = XXZ_eps_GS (Delta, Hz_N, lambdamax, Npts, req_prec);
-
-    // We can read off the value of B from the obtained eps_GS function:
-    DP B_eps = 0.0;
-    int iB_eps = Npts/2;
-    for (int i = Npts/2; i < Npts - 1; ++i)
-      if (eps_GS.value[i] * eps_GS.value[i+1] < 0.0) {
-	B_eps = 0.5 * (eps_GS.lambda[i] + eps_GS.lambda[i+1]);
-	iB_eps = i;
-      }
-    if (B_eps == 0.0) {
-      cout << "Delta = " << Delta << "\tN = " << N << "\tM = " << M << "\tHz_N = " << Hz_N << "\tid = " << id << endl;
-      ABACUSerror("B not found.");
-    }
-    if (B_eps > 0.5 * lambdamax) {
-      cout << "Delta = " << Delta << "\tN = " << N << "\tM = " << M << "\tHz_N = " << Hz_N << "\tid = " << id << endl;
-      ABACUSerror("Use a higher value of lambdamax.");
-    }
-    //DP lambdamax = lambdamax_eps;
-    //DP lambdamax = 2.0 * fabs(gstate.lambda[0][0]); // window of definition of Kbackflow is covered
-    // Start by finding the appropriate B:
-    DP B = DP(M)/N; // initial guess;
-    DP B_old = B;
-    DP dB = 0.5 * B; // variation we allow;
-    DP m_TBA = 0.0;
-    //Vect<Root_Density> rhotot_GS_iter(10);// = XXZ_rhotot_GS (Delta, B, lambdamax, Npts, req_prec);
-    Root_Density rhotot_GS = XXZ_rhotot_GS (Delta, B, lambdamax, Npts, req_prec);
-    int iter = 0;
-    do {
-      B_old = B;
-      rhotot_GS = XXZ_rhotot_GS (Delta, B, lambdamax, Npts, req_prec);
-      m_TBA = 0.0;
-      for (int i1 = 0; i1 < rhotot_GS.Npts; ++i1) if (fabs(rhotot_GS.lambda[i1]) < B) m_TBA += rhotot_GS.value[i1] * rhotot_GS.dlambda[i1];
-      if (m_TBA < DP(M)/N) B += dB;
-      else B -= dB;
-      cout << "B_old = " << B_old << "\tB = " << B << "\tdB = " << dB << "\tm = " << m_TBA << "\tM/N = " << DP(M)/N << endl;
-      dB *= 1.0/1.9;
-    } while (dB > 0.001 && iter < 9);
-
-    cout << "Check of consistency:  B_eps = " << B_eps << "\tB = " << B << "\tm_TBA = " << m_TBA << "\tM/N = " << DP(M)/N << endl;
-
-    //Root_Density rhotot_GS = XXZ_rhotot_GS (Delta, B, lambdamax, Npts, req_prec);
-    Root_Density b2BB_lambda_B = XXZ_b2BB_lambda_B (Delta, B, lambdamax, Npts, req_prec);
-    Root_Density Kbackflow_GS = XXZ_Kbackflow_GS (Delta, B, lambdamax, lambdap, lambdah, Npts, req_prec);
-    Root_Density Fbackflow_GS = XXZ_Fbackflow_GS (Delta, B, lambdamax, lambdap, lambdah, Npts, req_prec);
-
-    // Calculate the momentum and energy of the TBA state:
-    // Momentum:
-    DP conv = 0.0;
-    DP zeta = acos(Delta);
-    for (int l = 0; l < rhotot_GS.Npts; ++l) {
-      conv += fabs(rhotot_GS.lambda[l]) > B ? 0.0 :
-	(XXZ_phi2_kernel(zeta, lambdap - rhotot_GS.lambda[l])
-	 - XXZ_phi2_kernel(zeta, lambdah - rhotot_GS.lambda[l]))
-	* rhotot_GS.value[l] * rhotot_GS.dlambda[l];
-    }
-    DP k_ext_TBA = -XXZ_phi1_kernel (zeta, lambdap) + XXZ_phi1_kernel (zeta, lambdah) + conv;
-    // Energy:
-    conv = 0.0;
-    DP sinzeta = sin(zeta);
-    DP coszeta = cos(zeta);
-    for (int l = 0; l < Kbackflow_GS.Npts; ++l)
-      conv += fabs(Kbackflow_GS.lambda[l]) > B ? 0.0 :
-	(Hz_N - PI * sinzeta * XXZ_a1_kernel(sinzeta, coszeta, Kbackflow_GS.lambda[l]))
-	* Kbackflow_GS.value[l] * Kbackflow_GS.dlambda[l];
-    DP omega_TBA = -PI * sin(zeta) * (XXZ_a1_kernel(sinzeta, coszeta, lambdap)
-				      - XXZ_a1_kernel(sinzeta, coszeta, lambdah)) + conv;
-
-    cout << "k_ext_N = " << k_ext_N << "\tk_ext_TBA = " << k_ext_TBA << "\tomega_N = " << omega_N << "\tomega_TBA = " << omega_TBA << endl;
-
-    // Get back to the finite lattice case:
-    // Define densities as 1/N \sum_j delta (lambda - lambda_j);  use Gaussian smoothing of functions.
-    DP gwidth = 2.0 * B * log(DP(N))/M; // mean rapidity spacing times some factor, for smoothing of Gaussians
-    DP gwidthsq = gwidth * gwidth;
-    Vect_DP rhoGS_N (0.0, Npts);
-    Vect_DP rhoexc_N (0.0, Npts);
-    Vect_DP Kflow_N (0.0, Npts);
-    for (int iout = 0; iout < Npts; ++iout) {
-      DP lambdaout = rhotot_GS.lambda[iout];
-      // We compute the densities at each point...
-      for (int alpha = 0; alpha < M; ++alpha)
-	rhoGS_N[iout] += exp(-(gstate.lambda[0][alpha] - lambdaout) * (gstate.lambda[0][alpha] - lambdaout)/gwidthsq);
-      rhoGS_N[iout] /= N * sqrt(PI) * gwidth;
-      for (int alpha = 1; alpha < estate.base[0]; ++alpha)
-	rhoexc_N[iout] += exp(-(estate.lambda[0][alpha] - lambdaout) * (estate.lambda[0][alpha] - lambdaout)/gwidthsq);
-      rhoexc_N[iout] /= N * sqrt(PI) * gwidth;
-
-      Kflow_N[iout] = N * (rhoexc_N[iout] - rhoGS_N[iout] + (1.0/N) * exp(-(lambdah - lambdaout) * (lambdah - lambdaout)/gwidthsq)/(sqrt(PI) * gwidth));
-    } // for iout
-
-    cout << "Here 1" << endl;
-    // Now produce a file with the density flow:
-    stringstream flo_stringstream;
-    flo_stringstream << "Flow_D_" << Delta << "_N_" << N << "_M_" << M << "_base_id_" << estate.base_id << "_type_id_" << estate.type_id
-		     << "_id_" << estate.id << ".flo";
-    string flo_string = flo_stringstream.str();
-    const char* flo_Cstr = flo_string.c_str();
-
-    ofstream outfile_flo;
-    outfile_flo.open(flo_Cstr);
-    outfile_flo.precision(16);
-
-    for (int iout = 0; iout < Npts; ++iout)
-      outfile_flo << rhotot_GS.lambda[iout] << "\t" << rhotot_GS.value[iout] << "\t" << rhoGS_N[iout] << "\t"
-		  << rhoexc_N[iout] << "\t" << Kbackflow_GS.value[iout] << "\t"
-		  << (fabs(Kbackflow_GS.lambda[iout]) > B ? 0.0 : Kbackflow_GS.value[iout]) - b2BB_lambda_B.value[iout] * Fbackflow_GS.value[iB_eps]
-	+ b2BB_lambda_B.value[b2BB_lambda_B.Npts - 1 - iout] * Fbackflow_GS.value[Fbackflow_GS.Npts - 1 - iB_eps] << "\t" << Kflow_N[iout] << endl;
-
-    outfile_flo.close();
-
-    // ... and a file with the remainder of the data:
-    stringstream dat_stringstream;
-    dat_stringstream << "Flow_D_" << Delta << "_N_" << N << "_M_" << M << "_base_id_" << estate.base_id << "_type_id_" << estate.type_id
-		     << "_id_" << estate.id << ".dat";
-    string dat_string = dat_stringstream.str();
-    const char* dat_Cstr = dat_string.c_str();
-
-    ofstream outfile_dat;
-    outfile_dat.open(dat_Cstr);
-    outfile_dat.precision(16);
-
-    outfile_dat << "lambdap\tlambdah\tk_ext_N\tk_ext_TBA\tomega_N\tomega_TBA"
-		<< lambdap << "\t" << lambdah << "\t" << k_ext_N << "\t" << k_ext_TBA << "\t" << omega_N << "\t" << omega_TBA << endl;
-
-    outfile_dat.close();
-
-    return;
-  }
-  */
 
 }  // namespace ABACUS

src/UTILS/Data_File_Name.cc

@@ -28,7 +28,8 @@ namespace ABACUS {
 
   // Lieb-Liniger:
 
-  void Data_File_Name (stringstream& name, char whichDSF, DP c_int, DP L, int N, int iKmin, int iKmax, DP kBT, DP L2, string defaultScanStatename)
+  void Data_File_Name (stringstream& name, char whichDSF, DP c_int, DP L, int N, int iKmin, int iKmax,
+		       DP kBT, DP L2, string defaultScanStatename)
   {
     name << "LiebLin_";
     if (whichDSF == 'Z') name << "Z";
@@ -42,7 +43,6 @@ namespace ABACUS {
     else ABACUSerror("Option not implemented in Data_File_Name");
 
     name << "_c_" << c_int << "_L_" << L << "_N_" << N;
-    //if (fixed_iK) name << "_iK_" << iKneeded;
     if (defaultScanStatename == "") name << "_" << N << "_0_"; // simulates label of ground state
     else name << "_" << defaultScanStatename;
     if (iKmin == iKmax) name << "_iK_" << iKmin;
@@ -53,8 +53,8 @@ namespace ABACUS {
     return;
   }
 
-  //void Data_File_Name (stringstream& name, char whichDSF, bool fixed_iK, int iKneeded, LiebLin_Bethe_State& State, LiebLin_Bethe_State& RefScanState)
-  void Data_File_Name (stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT, LiebLin_Bethe_State& State, LiebLin_Bethe_State& RefScanState, string defaultScanStatename)
+  void Data_File_Name (stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT,
+		       LiebLin_Bethe_State& State, LiebLin_Bethe_State& RefScanState, string defaultScanStatename)
   {
     name << "LiebLin_";
     if (whichDSF == 'Z') name << "Z";
@@ -68,7 +68,6 @@ namespace ABACUS {
     else ABACUSerror("Option not implemented in Data_File_Name");
 
     name << "_c_" << State.c_int << "_L_" << State.L << "_N_" << State.N;
-    //if (fixed_iK) name << "_iK_" << iKneeded;
     if (defaultScanStatename == "") name << "_" << State.label;
     else name << "_" << defaultScanStatename;
     if (iKmin == iKmax) name << "_iK_" << iKmin;  else name << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
@@ -81,8 +80,8 @@ namespace ABACUS {
 
   // Heisenberg:
 
-  //void Data_File_Name (stringstream& name, char whichDSF, DP Delta, int N, int M, bool fixed_iK, int iKneeded, int N2)
-  void Data_File_Name (stringstream& name, char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax, DP kBT, int N2, string defaultScanStatename)
+  void Data_File_Name (stringstream& name, char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
+		       DP kBT, int N2, string defaultScanStatename)
   {
     name << "HEIS_";
     if (whichDSF == 'Z') name << "Z";
@@ -104,21 +103,14 @@ namespace ABACUS {
     if (defaultScanStatename == "") name << "_" << M << "_0_"; // simulates label of ground state
     else name << "_" << defaultScanStatename;
 
-    //if (fixed_iK) {
-    //  name << "_iK_";
-    //  for (int i = 0; i < int(log10(DP(N/2))) - int(log10(DP(iKneeded))); ++i) name << "0";
-    //  name << iKneeded;
-    //}
-    // From ABACUS++G_8 onwards: for Heisenberg, always scan over all momentum integers
-    //if (iKmin == iKmax) name << "_iK_" << iKmin;  else name << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     if (kBT > 0.0) name << "_kBT_" << kBT;
     if (whichDSF == 'q') name << "_N2_" << N2;
 
     return;
   }
 
-  //void Data_File_Name (stringstream& name, char whichDSF, bool fixed_iK, int iKneeded, Heis_Bethe_State& State, Heis_Bethe_State& RefScanState)
-  void Data_File_Name (stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT, Heis_Bethe_State& State, Heis_Bethe_State& RefScanState, string defaultScanStatename)
+  void Data_File_Name (stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT,
+		       Heis_Bethe_State& State, Heis_Bethe_State& RefScanState, string defaultScanStatename)
   {
     name << "HEIS_";
     if (whichDSF == 'Z') name << "Z";
@@ -139,15 +131,6 @@ namespace ABACUS {
     name << State.base.Mdown;
     if (defaultScanStatename == "") name << "_" << State.label;
     else name << "_" << defaultScanStatename;
-    /*
-    if (fixed_iK) {
-      name << "_iK_";
-      for (int i = 0; i < int(log10(DP(State.chain.Nsites/2))) - int(log10(DP(iKneeded))); ++i) name << "0";
-      name << iKneeded;
-    }
-    */
-    // From ABACUS++G_8 onwards: for Heisenberg, always scan over all momentum integers
-    //if (iKmin == iKmax) name << "_iK_" << iKmin;  else name << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     if (kBT > 0.0) name << "_kBT_" << kBT;
     if (whichDSF == 'q') name << "_N2_" << RefScanState.chain.Nsites;
 
@@ -155,10 +138,11 @@ namespace ABACUS {
   }
 
 
-  // One-D spinless fermions:
+  // One-D spinless fermions: IN DEVELOPMENT
   /*
-  void ODSLF_Data_File_Name (stringstream& name, char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax, DP kBT, int N2, string defaultScanStatename)
-  {
+    void ODSLF_Data_File_Name (stringstream& name, char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
+    DP kBT, int N2, string defaultScanStatename)
+    {
     name << "ODSLF_";
     if (whichDSF == 'Z') name << "Z";
     else if (whichDSF == 'm') name << "cdag_c";
@@ -176,11 +160,11 @@ namespace ABACUS {
     if (whichDSF == 'q') name << "_N2_" << N2;
 
     return;
-  }
+    }
 
-  //void Data_File_Name (stringstream& name, char whichDSF, bool fixed_iK, int iKneeded, Heis_Bethe_State& State, Heis_Bethe_State& RefScanState)
-  void Data_File_Name (stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT, ODSLF_Bethe_State& State, ODSLF_Bethe_State& RefScanState, string defaultScanStatename)
-  {
+    void Data_File_Name (stringstream& name, char whichDSF, int iKmin, int iKmax, DP kBT,
+    ODSLF_Bethe_State& State, ODSLF_Bethe_State& RefScanState, string defaultScanStatename)
+    {
     name << "ODSLF_";
     if (whichDSF == 'Z') name << "Z";
     else if (whichDSF == 'm') name << "cdag_c";
@@ -195,16 +179,16 @@ namespace ABACUS {
     for (int i = 0; i < int(log10(DP(State.chain.Nsites/2))) - int(log10(DP(State.base.Mdown))); ++i) name << "0";
     name << State.base.Mdown;
     if (fixed_iK) {
-      name << "_iK_";
-      for (int i = 0; i < int(log10(DP(State.chain.Nsites/2))) - int(log10(DP(iKneeded))); ++i) name << "0";
-      name << iKneeded;
+    name << "_iK_";
+    for (int i = 0; i < int(log10(DP(State.chain.Nsites/2))) - int(log10(DP(iKneeded))); ++i) name << "0";
+    name << iKneeded;
     }
     if (iKmin == iKmax) name << "_iK_" << iKmin;  else name << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     if (kBT > 0.0) name << "_kBT_" << kBT;
     if (whichDSF == 'q') name << "_N2_" << RefScanState.chain.Nsites;
 
     return;
-  }
-*/
+    }
+  */
 
 } // namespace ABACUS

src/UTILS/Smoothen_RAW_into_SF.cc

@@ -49,7 +49,6 @@ namespace ABACUS {
     DP omega;
     int iK;
     DP FF;
-    //int conv;
     DP dev;
     string label;
 
@@ -69,16 +68,13 @@ namespace ABACUS {
     DP SFfactor = 1.0;
 
     while (RAW_infile.peek() != EOF) {
-      //RAW_infile >> omega >> iK >> FF >> conv >> label;
       RAW_infile >> omega >> iK >> FF >> dev >> label;
       if (iK >= iKmin && iK <= iKmax  && fabs(omega) > 1.0e-8) { // remove connected part of DSF
-	//SSF[iK - iKmin] += FF * FF;
 	for (int deltaiK = -DiK; deltaiK <= DiK; ++deltaiK)
 	  if (iK + deltaiK >= iKmin && iK + deltaiK <= iKmax)
 	    SSF[iK + deltaiK - iKmin] += Kweight[abs(deltaiK)] * FF * FF;
 	for (int iomega = 0; iomega < Nom; ++iomega)
 	  if (big_gwidth_used > (d_omega = fabs(omegaout[iomega] - omega))) {
-	    //DSF[iomega][iK - iKmin] += FF * FF * exp(-d_omega*d_omega * oneovertwowidthsq);
 	    SFfactor = FF * FF * exp(-d_omega*d_omega * oneovertwowidthsq);
 	    ASF[iomega] += SFfactor;
 	    if (fabs(omega) > 1.0e-12) // exclude the delta function contribution coming from diagonal term, if present
@@ -107,7 +103,6 @@ namespace ABACUS {
 
     stringstream DSF_stringstream;    string DSF_string;
     DSF_stringstream << prefix;
-    //if (iKmax != iKmin) DSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     if (DiK > 0) DSF_stringstream << "_DiK_" << DiK;
     DSF_stringstream << "_ommin_"<< ommin << "_ommax_" << ommax << "_Nom_" << Nom << "_w_" << gwidth << ".dsf";
     DSF_string = DSF_stringstream.str();    const char* DSF_Cstr = DSF_string.c_str();
@@ -125,7 +120,6 @@ namespace ABACUS {
 
     stringstream SSF_stringstream;    string SSF_string;
     SSF_stringstream << prefix;
-    //if (iKmin != iKmax) SSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     if (DiK > 0) SSF_stringstream << "_DiK_" << DiK;
     SSF_stringstream << ".ssf";
     SSF_string = SSF_stringstream.str();    const char* SSF_Cstr = SSF_string.c_str();
@@ -143,7 +137,6 @@ namespace ABACUS {
 
     stringstream ASF_stringstream;    string ASF_string;
     ASF_stringstream << prefix;
-    //if (iKmax != iKmin) DSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     ASF_stringstream << "_ommin_"<< ommin << "_ommax_" << ommax << "_Nom_" << Nom << "_w_" << gwidth << ".asf";
     ASF_string = ASF_stringstream.str();    const char* ASF_Cstr = ASF_string.c_str();
 
@@ -192,7 +185,6 @@ namespace ABACUS {
     DP omega;
     int iK;
     DP FF;
-    //int conv;
     DP dev;
     string label;
 
@@ -214,10 +206,6 @@ namespace ABACUS {
     for (int ns = 0; ns < weight.size(); ++ns) {
 
       // Open the original raw file:
-      //stringstream RAW_stringstream;    string RAW_string;
-      //RAW_stringstream << prefix << ".raw";
-      //RAW_string = RAW_stringstream.str();
-      //const char* RAW_Cstr = RAW_string.c_str();
       const char* RAW_Cstr = rawfilename[ns].c_str();
 
       ifstream RAW_infile;
@@ -228,13 +216,11 @@ namespace ABACUS {
       }
 
       while (RAW_infile.peek() != EOF) {
-	//RAW_infile >> omega >> iK >> FF >> conv >> label;
 	RAW_infile >> omega >> iK >> FF >> dev >> label;
 	if (iK >= iKmin && iK <= iKmax && fabs(omega) > 1.0e-8) { // remove connected part of DSF)
 	  SSF[iK - iKmin] += weight[ns] * FF * FF;
 	  for (int iomega = 0; iomega < Nom; ++iomega)
 	    if (big_gwidth_used > (d_omega = fabs(omegaout[iomega] - omega))) {
-	      //DSF[iomega][iK - iKmin] += FF * FF * exp(-d_omega*d_omega * oneovertwowidthsq);
 	      SFfactor = weight[ns] * FF * FF * exp(-d_omega*d_omega * oneovertwowidthsq);
 	      ASF[iomega] += SFfactor;
 	      if (fabs(omega) > 1.0e-12) // exclude the delta function contribution coming from diagonal term, if present
@@ -264,7 +250,6 @@ namespace ABACUS {
 
     stringstream DSF_stringstream;    string DSF_string;
     DSF_stringstream << prefix;
-    //if (iKmax != iKmin) DSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     DSF_stringstream << "_ns_" << weight.size();
     if (DiK > 0) DSF_stringstream << "_DiK_" << DiK;
     DSF_stringstream << "_ommin_"<< ommin << "_ommax_" << ommax << "_Nom_" << Nom << "_w_" << gwidth << ".dsf";
@@ -283,7 +268,6 @@ namespace ABACUS {
 
     stringstream SSF_stringstream;    string SSF_string;
     SSF_stringstream << prefix;
-    //if (iKmin != iKmax) SSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     SSF_stringstream << "_ns_" << weight.size();
     SSF_stringstream << ".ssf";
     SSF_string = SSF_stringstream.str();    const char* SSF_Cstr = SSF_string.c_str();
@@ -301,7 +285,6 @@ namespace ABACUS {
 
     stringstream ASF_stringstream;    string ASF_string;
     ASF_stringstream << prefix;
-    //if (iKmax != iKmin) DSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     ASF_stringstream << "_ns_" << weight.size();
     ASF_stringstream << "_ommin_"<< ommin << "_ommax_" << ommax << "_Nom_" << Nom << "_w_" << gwidth << ".asf";
     ASF_string = ASF_stringstream.str();    const char* ASF_Cstr = ASF_string.c_str();
@@ -317,7 +300,6 @@ namespace ABACUS {
     ASF_outfile.close();
 
 
-
     // Check sums:
     DP sumdsf = 0.0;
     DP sumssf = 0.0;
@@ -361,7 +343,6 @@ namespace ABACUS {
     DP omega;
     int iK;
     DP FF;
-    //int conv;
     DP dev;
     string label;
 
@@ -373,7 +354,6 @@ namespace ABACUS {
     DP oneovertwowidthsq = 1.0/(2.0 * gwidth * gwidth);
 
     while (RAW_infile.peek() != EOF) {
-      //RAW_infile >> omega >> iK >> FF >> conv >> label;
       RAW_infile >> omega >> iK >> FF >> dev >> label;
       if (iK >= iKmin && iK <= iKmax && fabs(omega) > 1.0e-8) { // remove connected part of DSF)
 	for (int iomega = 0; iomega < Nom; ++iomega)
@@ -390,7 +370,6 @@ namespace ABACUS {
       ASF[iomega] *= normalization_used;
 
     // Output to .asf file
-
     stringstream ASF_stringstream;    string ASF_string;
     ASF_stringstream << prefix;
     //if (iKmax != iKmin) DSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;

src/UTILS/Smoothen_RAW_into_SF_LiebLin_Scaled.cc

@@ -21,7 +21,7 @@ using namespace ABACUS;
 namespace ABACUS {
 
   DP Smoothen_RAW_into_SF_LiebLin_Scaled (string prefix, DP L, int N, int iKmin, int iKmax, int DiK,
-				       DP ommin, DP ommax, int Nom, DP width, DP normalization)
+					  DP ommin, DP ommax, int Nom, DP width, DP normalization)
   {
     // DiK is the (half-)window in iK which is averaged over. A single iK means DiK == 0.
 
@@ -51,7 +51,6 @@ namespace ABACUS {
     DP omega;
     int iK;
     DP FF;
-    //int conv;
     DP dev;
     string label;
 
@@ -76,9 +75,10 @@ namespace ABACUS {
     // For iK > N, there are N states.
 
     for (iK = iKmin; iK <= iKmax; ++iK)
-      //gwidth[iK - iKmin] = width * 2.0 * ABACUS::min( pow(twoPI * ABACUS::max(abs(iK),1)/L, 2.0), pow(twoPI * N/L, 2.0))/ABACUS::min(N, ABACUS::max(abs(iK), 1));
-    // Make sure the width does not become lower than the omegaout raster:
-      gwidth[iK - iKmin] = ABACUS::max(2.0 * (ommax - ommin)/Nom, width * 2.0 * ABACUS::min( pow(twoPI * ABACUS::max(abs(iK),1)/L, 2.0), pow(twoPI * N/L, 2.0))/ABACUS::min(N, ABACUS::max(abs(iK), 1)));
+      // Make sure the width does not become lower than the omegaout raster:
+      gwidth[iK - iKmin] = ABACUS::max(2.0 * (ommax - ommin)/Nom, width * 2.0
+				       * ABACUS::min( pow(twoPI * ABACUS::max(abs(iK),1)/L, 2.0),
+						      pow(twoPI * N/L, 2.0))/ABACUS::min(N, ABACUS::max(abs(iK), 1)));
 
 
     Vect_DP big_gwidth_used (iKmax - iKmin + 1);
@@ -95,14 +95,12 @@ namespace ABACUS {
 
     DP FFsq = 0.0;
     while (RAW_infile.peek() != EOF) {
-      //RAW_infile >> omega >> iK >> FF >> conv >> label;
       RAW_infile >> omega >> iK >> FF >> dev >> label;
       if (iK >= iKmin && iK <= iKmax && fabs(omega) > 1.0e-8) { // remove connected part of DSF
 	FFsq = FF * FF;
 	SSF[iK - iKmin] += FFsq;
 	for (int iomega = 0; iomega < Nom; ++iomega)
 	  if (big_gwidth_used[iK - iKmin] > (d_omega = fabs(omegaout[iomega] - omega)))
-	    //DSF[iomega][iK - iKmin] += FF * FF * normalization_used[iK - iKmin] * exp(-d_omega*d_omega * oneovertwowidthsq[iK - iKmin]);
 	    for (int deltaiK = -DiK; deltaiK <= DiK; ++deltaiK)
 	      if (iK + deltaiK >= iKmin && iK + deltaiK <= iKmax)
 		DSFS[iomega][iK + deltaiK - iKmin] += Kweight[abs(deltaiK)] * FFsq * normalization_used[iK + deltaiK - iKmin]
@@ -112,19 +110,13 @@ namespace ABACUS {
     RAW_infile.close();
 
     // Reset proper normalization:
-    //DP normalization_used = normalization * 1.0/(sqrt(twoPI) * gwidth); // Gaussian factor
     for (int iK = 0; iK < iKmax - iKmin + 1; ++iK) {
       SSF[iK] *= normalization/twoPI;
-    //FSR[iK] *= normalization_used;
-    //for (int iomega = 0; iomega < Nom; ++iomega)
-    //DSF[iomega][iK] *= normalization_used;
     }
 
     // Output to .dsfs and .ssf files
-
     stringstream DSFS_stringstream;    string DSFS_string;
     DSFS_stringstream << prefix;
-    //if (iKmax != iKmin) DSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     if (DiK > 0) DSFS_stringstream << "_DiK_" << DiK;
     DSFS_stringstream << "_ommin_"<< ommin << "_ommax_" << ommax << "_Nom_" << Nom << "_w_" << width << ".dsfs";
     DSFS_string = DSFS_stringstream.str();    const char* DSFS_Cstr = DSFS_string.c_str();
@@ -143,7 +135,6 @@ namespace ABACUS {
 
     stringstream SSF_stringstream;    string SSF_string;
     SSF_stringstream << prefix;
-    //if (iKmin != iKmax) SSF_stringstream << "_iKmin_" << iKmin << "_iKmax_" << iKmax;
     SSF_stringstream << ".ssf";
     SSF_string = SSF_stringstream.str();    const char* SSF_Cstr = SSF_string.c_str();
 
@@ -159,13 +150,10 @@ namespace ABACUS {
 
     // Check sums:
     DP sumdsf = 0.0;
-    //DP sumssf = 0.0;
     for (int iK = 0; iK < iKmax - iKmin + 1; ++iK) {
-      //sumssf += FSR[iK];
       for (int iomega = 0; iomega < Nom; ++iomega)
 	sumdsf += DSFS[iomega][iK];
     }
-    //sumssf /= (iKmax - iKmin + 1);
     sumdsf /= (iKmax - iKmin + 1) * Nom;
 
     return(sumdsf);

src/UTILS/Sort_RAW_File.cc

@@ -26,106 +26,99 @@ namespace ABACUS {
 
 
   void Sort_RAW_File (const char ff_file[], char optionchar, char whichDSF)
-    {
-      // Sorts FF in decreasing order for 'f' option, or energies in increasing order for option 'e', and writes .dat_srt file
+  {
+    // Sorts FF in decreasing order for 'f' option, or energies in increasing order for option 'e', and writes .dat_srt file
+
+    if (!(optionchar == 'e' || optionchar == 'f')) ABACUSerror("Wrong option in Sort_FF");
+
+    // Check size of threads file:
+    struct stat statbuf;
 
-      if (!(optionchar == 'e' || optionchar == 'f')) ABACUSerror("Wrong option in Sort_FF");
+    stat (ff_file, &statbuf);
+    int filesize = statbuf.st_size;
 
-      // Check size of threads file:
-      struct stat statbuf;
+    // Determine the number of entries approximately
+    int entry_size = 2* sizeof(float) + 2*sizeof(int);
 
-      stat (ff_file, &statbuf);
-      int filesize = statbuf.st_size;
+    //const int MAXDATA = 50000000;
+    const int MAXDATA = filesize/entry_size + 10;
 
-      // Determine the number of entries approximately
-      int entry_size = 2* sizeof(float) + 2*sizeof(int);
+    DP* omega = new DP[MAXDATA];
+    int* iK = new int[MAXDATA];
+    DP* ff = new DP[MAXDATA];
+    DP* ff_im = new DP[MAXDATA];
+    DP* dev = new DP[MAXDATA];
+    string* label = new string[MAXDATA];
 
-      //const int MAXDATA = 50000000;
-      const int MAXDATA = filesize/entry_size + 10;
+    ifstream infile;
+    infile.open(ff_file);
 
-      DP* omega = new DP[MAXDATA];
-      int* iK = new int[MAXDATA];
-      DP* ff = new DP[MAXDATA];
-      DP* ff_im = new DP[MAXDATA];
-      //int* conv = new int[MAXDATA];
-      DP* dev = new DP[MAXDATA];
-      string* label = new string[MAXDATA];
+    if (infile.fail()) ABACUSerror("The input file was not opened successfully in Sort_RAW_File. ");
 
-      ifstream infile;
-      infile.open(ff_file);
+    stringstream outfilename;
+    string outfilename_string;
+    outfilename << ff_file << "_srt_" << optionchar;
+    outfilename_string = outfilename.str();
+    const char* outfilename_c_str = outfilename_string.c_str();
 
-      if (infile.fail()) ABACUSerror("The input file was not opened successfully in Sort_RAW_File. ");
+    ofstream outfile;
+    outfile.open(outfilename_c_str);
+    outfile.precision(16);
 
-      stringstream outfilename;
-      string outfilename_string;
-      outfilename << ff_file << "_srt_" << optionchar;
-      outfilename_string = outfilename.str();
-      const char* outfilename_c_str = outfilename_string.c_str();
+    int Ndata = 0;
+    while (((infile.peek()) != EOF) && (Ndata < MAXDATA)) {
+
+      infile >> omega[Ndata];
+      infile >> iK[Ndata];
+      if (whichDSF != 'Z') infile >> ff[Ndata];
+      if (whichDSF == 'q') infile >> ff_im[Ndata];  // imaginary part of overlap, quench case
+      infile >> dev[Ndata];
+      infile >> label[Ndata];
+
+      Ndata++;
+    }
+    infile.close();
 
-      ofstream outfile;
-      outfile.open(outfilename_c_str);
-      outfile.precision(16);
+    int* index = new int[Ndata];
+    DP* ffsq = new DP[Ndata];
 
-      int Ndata = 0;
-      while (((infile.peek()) != EOF) && (Ndata < MAXDATA)) {
+    for (int i = 0; i < Ndata; ++i) index[i] = i;
+    for (int i = 0; i < Ndata; ++i) ffsq[i] = ff[i] * ff[i];
 
-      	infile >> omega[Ndata];
-	infile >> iK[Ndata];
-	if (whichDSF != 'Z') infile >> ff[Ndata];
-	if (whichDSF == 'q') infile >> ff_im[Ndata];  // imaginary part of overlap, quench case
-	//infile >> conv[Ndata];
-	infile >> dev[Ndata];
-	infile >> label[Ndata];
+    if (optionchar == 'f') QuickSort(ffsq, index, 0, Ndata - 1);
+    else if (optionchar == 'e') QuickSort(omega, index, 0, Ndata - 1);
 
-	Ndata++;
+    for (int i = 0; i < Ndata; i++) {
+
+      if (i > 0) outfile << endl;
+      if (optionchar == 'f') {
+
+	outfile << omega[index[Ndata - 1 - i] ] << "\t" << iK[index[Ndata - 1 - i] ];
+	if (whichDSF != 'Z') outfile << "\t" << ff[index[Ndata - 1 - i] ];
+	if (whichDSF == 'q') outfile << "\t" << ff_im[index[Ndata - 1 - i] ];
+	outfile << "\t" << dev[index[Ndata - 1 - i] ] << "\t" << label[index[Ndata - 1 - i] ];
       }
-      infile.close();
-
-      int* index = new int[Ndata];
-      DP* ffsq = new DP[Ndata];
-
-      for (int i = 0; i < Ndata; ++i) index[i] = i;
-      for (int i = 0; i < Ndata; ++i) ffsq[i] = ff[i] * ff[i];
-
-      if (optionchar == 'f') QuickSort(ffsq, index, 0, Ndata - 1);
-      else if (optionchar == 'e') QuickSort(omega, index, 0, Ndata - 1);
-
-      for (int i = 0; i < Ndata; i++) {
-
-	if (i > 0) outfile << endl;
-	if (optionchar == 'f') {
-
-	  outfile << omega[index[Ndata - 1 - i] ] << "\t" << iK[index[Ndata - 1 - i] ];
-	  if (whichDSF != 'Z') outfile << "\t" << ff[index[Ndata - 1 - i] ];
-	  if (whichDSF == 'q') outfile << "\t" << ff_im[index[Ndata - 1 - i] ];
-	  outfile << "\t" //<< conv[index[Ndata - 1 - i] ] << "\t"
-		  << dev[index[Ndata - 1 - i] ] << "\t"
-		  << label[index[Ndata - 1 - i] ];
-	}
-	else if (optionchar == 'e') {
-	  outfile << omega[i] << "\t" << iK[index[i] ];
-	  if (whichDSF != 'Z') outfile << "\t" << ff[index[i] ];
-	  if (whichDSF == 'q') outfile << "\t" << ff_im[index[i] ];
-	  outfile << "\t" //<< conv[index[i] ] << "\t"
-		  << dev[index[i] ] << "\t"
-		  << label[index[i] ];
-	}
+      else if (optionchar == 'e') {
+	outfile << omega[i] << "\t" << iK[index[i] ];
+	if (whichDSF != 'Z') outfile << "\t" << ff[index[i] ];
+	if (whichDSF == 'q') outfile << "\t" << ff_im[index[i] ];
+	outfile << "\t" << dev[index[i] ] << "\t" << label[index[i] ];
       }
+    }
 
-      outfile.close();
+    outfile.close();
 
-      delete[] omega;
-      delete[] iK;
-      delete[] ff;
-      delete[] ff_im;
-      //delete[] conv;
-      delete[] dev;
-      delete[] label;
+    delete[] omega;
+    delete[] iK;
+    delete[] ff;
+    delete[] ff_im;
+    delete[] dev;
+    delete[] label;
 
-      delete[] index;
-      delete[] ffsq;
+    delete[] index;
+    delete[] ffsq;
 
-      return;
-    }
+    return;
+  }
 
 } // namespace ABACUS

src/UTILS/State_Label.cc

@@ -50,9 +50,7 @@ namespace ABACUS {
   {
     string::size_type i1 = label.find(LABELSEP);
 
-    //cout << "Extracting Base_Label from label " << label << endl;
     string baselabel = label.substr(0, i1);
-    //cout << "Extracted Base_Label " << baselabel << endl;
 
     return(baselabel);
   }
@@ -76,7 +74,6 @@ namespace ABACUS {
     int remainder = int_to_convert;
     stringstream result_strstrm;
     do {
-      //cout << "remainder = " << remainder << "\tnext index = " << remainder - ABACUScodingsize * (remainder/ABACUScodingsize) << endl;
       result_strstrm << ABACUScoding[remainder - ABACUScodingsize * (remainder/ABACUScodingsize)];
       remainder /= ABACUScodingsize;
     } while (remainder > 0);
@@ -120,22 +117,13 @@ namespace ABACUS {
     string nexclabel = label.substr(i1+1, i2-i1-1);
     string Ix2exclabel = label.substr(i2+1);
 
-    //cout << "label: " << label << endl;
-    //cout << "baselabel: " << baselabel << endl;
-    //cout << "nexclabel: " << nexclabel << endl;
-    //cout << "Ix2exclabel: " << Ix2exclabel << endl;
-
     // Read off the base label: count the number of TYPESEP in baselabel
     int nbar = 0;
     for (unsigned int i = 0; i < baselabel.length(); ++i) if (baselabel[i] == TYPESEP) nbar++;
 
-    //cout << "nbar = " << nbar << endl;
-
     // There are now nbar + 1 base label data:
     int ntypes = nbar + 1;
 
-    //cout << "ntypes = " << ntypes << endl;
-
     Vect<int> type(ntypes); // integer type labels of the types present
     type[0] = 0; // always the case by convention
     Vect<int> M(ntypes); // how many particles of each type
@@ -183,8 +171,6 @@ namespace ABACUS {
 
     } // else if ntypes > 1
 
-    //cout << "ntypes = " << ntypes << "\tM = " << M << endl;
-
     // baselabel is now completely read
 
     // Define some dud nex, Ix2old, Ix2exc:
@@ -213,22 +199,14 @@ namespace ABACUS {
     string nexclabel = label.substr(i1+1, i2-i1-1);
     string Ix2exclabel = label.substr(i2+1);
 
-    //cout << "label: " << label << endl;
-    //cout << "baselabel: " << baselabel << endl;
-    //cout << "nexclabel: " << nexclabel << endl;
-    //cout << "Ix2exclabel: " << Ix2exclabel << endl;
 
     // Read off the base label: count the number of TYPESEP in baselabel
     int nbar = 0;
     for (unsigned int i = 0; i < baselabel.length(); ++i) if (baselabel[i] == TYPESEP) nbar++;
 
-    //cout << "nbar = " << nbar << endl;
-
     // There are now nbar + 1 base label data:
     int ntypes = nbar + 1;
 
-    //cout << "ntypes = " << ntypes << endl;
-
     Vect<int> type(ntypes); // integer type labels of the types present
     type[0] = 0; // always the case by convention
     Vect<int> M(ntypes); // how many particles of each type
@@ -317,10 +295,6 @@ namespace ABACUS {
 
     // nexc is now completely read
 
-    //cout << "typefound: " << type << endl;
-    //cout << "Mfound: " << M << endl;
-    //cout << "nexcfound: " << nexc << endl;
-
 
     // Now read off the (compressed) jexc and Ix2exc vectors of vectors:
     Vect<Vect<int> > Ix2old(ntypes); // which Ix2 will be excited
@@ -340,22 +314,17 @@ namespace ABACUS {
       }
       for (int iexc = 0; iexc < nexc[itype]; ++iexc) {
 	//string::size_type i1 = Ix2exclabelremaining.find(INEXCSEP);
-	string::size_type i2 = (iexc < nexc[itype] - 1 ? Ix2exclabelremaining.find(EXCSEP) : Ix2exclabelremaining.find(TYPESEP)); // careful here!
-	//cout << "\t" << itype << "\t" << iexc << "\t" << Ix2exclabelremaining << "\t" << i1 << "\t" << i2 << endl;
-	//string Ix2oldread = Ix2exclabelremaining.substr(0,i1);
-	//string Ix2excread = Ix2exclabelremaining.substr(i1+1,i2-i1-1);
+	string::size_type i2 = (iexc < nexc[itype] - 1 ? Ix2exclabelremaining.find(EXCSEP)
+				: Ix2exclabelremaining.find(TYPESEP)); // careful here!
 	string Ix2excIDread = Ix2exclabelremaining.substr(0,i2);
 	int Ix2excID = Convert_STR_to_POSINT(Ix2excIDread);
-	Ix2old[itype][iexc] = OriginIx2[type[itype] ][Ix2excID - M[itype] * (Ix2excID/M[itype])]; // index is remainder w/r to nr of strings of this type
+	Ix2old[itype][iexc] = OriginIx2[type[itype] ][Ix2excID - M[itype] * (Ix2excID/M[itype])];
+	// index is remainder w/r to nr of strings of this type
 	// Convention: if remainder is even, moving left. If odd, moving right.
 	// 0 means move one unit left, 1 means move one unit right, etc.
-	//Ix2exc[itype][iexc] = Ix2old[itype][iexc] + (Ix2excID/M[itype] % 2 ? 2 : -2) * (Ix2excID/(2 * M[itype]) + 0);
-	Ix2exc[itype][iexc] = Ix2old[itype][iexc] + (Ix2excID/M[itype] % 2 ? 2 : -2) * (Ix2excID/(2 * M[itype]) + 1); // ABACUS++T_8 onwards
+	Ix2exc[itype][iexc] = Ix2old[itype][iexc] + (Ix2excID/M[itype] % 2 ? 2 : -2)
+	  * (Ix2excID/(2 * M[itype]) + 1); // ABACUS++T_8 onwards
 
-	//istringstream Ix2oldreadbuffer (Ix2oldread);
-	//Ix2oldreadbuffer >> Ix2old[itype][iexc];
-	//istringstream Ix2excreadbuffer (Ix2excread);
-	//Ix2excreadbuffer >> Ix2exc[itype][iexc];
 	// Remove everything up to index i2 in Ix2exclabelremaining
 	Ix2exclabelremaining = Ix2exclabelremaining.substr(i2+1);
       }
@@ -363,47 +332,27 @@ namespace ABACUS {
 
     // Now read off the Ix2old, Ix2exc of the last type: this is always done
     for (int iexc = 0; iexc < nexc[ntypes - 1] - 1; ++iexc) {
-      //string::size_type i1 = Ix2exclabelremaining.find(INEXCSEP);
       string::size_type i2 = Ix2exclabelremaining.find(EXCSEP);
-      //string Ix2oldread = Ix2exclabelremaining.substr(0,i1);
-      //string Ix2excread = Ix2exclabelremaining.substr(i1+1,i2-i1-1);
       string Ix2excIDread = Ix2exclabelremaining.substr(0,i2);
       int Ix2excID = Convert_STR_to_POSINT(Ix2excIDread);
-      Ix2old[ntypes - 1][iexc] = OriginIx2[type[ntypes - 1] ][Ix2excID - M[ntypes - 1] * (Ix2excID/M[ntypes - 1])]; // index is remainder w/r to nr of strings of this type
+      Ix2old[ntypes - 1][iexc] = OriginIx2[type[ntypes - 1] ][Ix2excID - M[ntypes - 1] * (Ix2excID/M[ntypes - 1])];
+      // index is remainder w/r to nr of strings of this type
       // Convention: if remainder is even, moving left. If odd, moving right.
-      //Ix2exc[ntypes - 1][iexc] = Ix2old[ntypes - 1][iexc] + (Ix2excID/M[ntypes - 1] % 2 ? 2 : -2) * (Ix2excID/(2 * M[ntypes - 1]) + 0);
-      Ix2exc[ntypes - 1][iexc] = Ix2old[ntypes - 1][iexc] + (Ix2excID/M[ntypes - 1] % 2 ? 2 : -2) * (Ix2excID/(2 * M[ntypes - 1]) + 1); // ABACUS++T_8 onwards
+      Ix2exc[ntypes - 1][iexc] = Ix2old[ntypes - 1][iexc] + (Ix2excID/M[ntypes - 1] % 2 ? 2 : -2)
+	* (Ix2excID/(2 * M[ntypes - 1]) + 1); // ABACUS++T_8 onwards
 
-      //istringstream Ix2oldreadbuffer (Ix2oldread);
-      //Ix2oldreadbuffer >> Ix2old[ntypes - 1][iexc];
-      //istringstream Ix2excreadbuffer (Ix2excread);
-      //Ix2excreadbuffer >> Ix2exc[ntypes - 1][iexc];
       // Remove everything up to index i2 in Ix2exclabelremaining
       Ix2exclabelremaining = Ix2exclabelremaining.substr(i2+1);
     }
 
     // Now read off the last pair:
     int Ix2excID = Convert_STR_to_POSINT(Ix2exclabelremaining);
-    Ix2old[ntypes - 1][ABACUS::max(nexc[ntypes - 1] - 1,0)] = OriginIx2[type[ntypes - 1] ][Ix2excID - M[ntypes - 1] * (Ix2excID/M[ntypes - 1])]; // index is remainder w/r to nr of strings of this type
+    Ix2old[ntypes - 1][ABACUS::max(nexc[ntypes - 1] - 1,0)] =
+      OriginIx2[type[ntypes - 1] ][Ix2excID - M[ntypes - 1] * (Ix2excID/M[ntypes - 1])];
+    // index is remainder w/r to nr of strings of this type
     // Convention: if remainder is even, moving left. If odd, moving right.
-    //Ix2exc[ntypes - 1][ABACUS::max(nexc[ntypes - 1] - 1,0)] = Ix2old[ntypes - 1][nexc[ntypes - 1] - 1] + (Ix2excID/M[ntypes - 1] % 2 ? 2 : -2) * (Ix2excID/(2 * M[ntypes - 1]) + 0);
-    Ix2exc[ntypes - 1][ABACUS::max(nexc[ntypes - 1] - 1,0)] = Ix2old[ntypes - 1][nexc[ntypes - 1] - 1] + (Ix2excID/M[ntypes - 1] % 2 ? 2 : -2) * (Ix2excID/(2 * M[ntypes - 1]) + 1); // ABACUS++T_8 onwards
-
-    //string::size_type ilast = Ix2exclabelremaining.find(INEXCSEP);
-    //string Ix2oldread = Ix2exclabelremaining.substr(0,ilast);
-    //string Ix2excread = Ix2exclabelremaining.substr(ilast+1);
-    //istringstream Ix2oldreadbuffer (Ix2oldread);
-    //Ix2oldreadbuffer >> Ix2old[ntypes - 1][nexc[ntypes - 1] - 1];
-    //istringstream Ix2excreadbuffer (Ix2excread);
-    //Ix2excreadbuffer >> Ix2exc[ntypes - 1][nexc[ntypes - 1] - 1];
-
-    //cout << "nexc = " << endl;
-    //cout << nexc << endl;
-    //cout << "Ix2old and Ix2exc: " << endl;
-    //for (int itype = 0; itype < ntypes; ++itype) {
-    //cout << "Ix2old["<< itype << "]: " << Ix2old[itype] << endl;
-    //cout << "Ix2exc["<< itype << "]: " << Ix2exc[itype] << endl;
-    //}
+    Ix2exc[ntypes - 1][ABACUS::max(nexc[ntypes - 1] - 1,0)] = Ix2old[ntypes - 1][nexc[ntypes - 1] - 1]
+      + (Ix2excID/M[ntypes - 1] % 2 ? 2 : -2) * (Ix2excID/(2 * M[ntypes - 1]) + 1); // ABACUS++T_8 onwards
 
     State_Label_Data labeldata (type, M, nexc, Ix2old, Ix2exc);
 
@@ -421,43 +370,28 @@ namespace ABACUS {
   {
     // This function produces a compressed label.
 
-    //cout << "Label A" << endl;
-
-    //cout << "\t" << data.M.size() << endl;
-    //cout << "\t" << data.M[0] << endl;
-
     string label;
 
     // Write the base:
     // First, particles of type 0:
-    //cout << "Label A2" << endl;
     stringstream M0out;
-    //cout << "Label A3" << endl;
-    //cout << "\t" << data.M[0] << endl;
     M0out << data.M[0];
-    //cout << "Label A4" << endl;
     label += M0out.str();
-    //cout << "Label A5" << endl;
 
     for (int itype = 1; itype < data.M.size(); ++itype) {
-      //cout << "\ta" << itype << "\t" << data.M.size() << endl;
       if (data.M[itype] > 0) {
 	label += TYPESEP;
 	stringstream typeout;
 	typeout << data.type[itype];
 	label += typeout.str();
 	label += EXCSEP;
-	//cout << "\tc" << endl;
 	stringstream Mout;
 	Mout << data.M[itype];
 	label += Mout.str();
-	//cout << "\td" << endl;
       }
     }
     label += LABELSEP;
 
-    //cout << "Label B" << endl;
-
     // Now the nexc:
     stringstream nexc0out;
     nexc0out << data.nexc[0];
@@ -470,8 +404,6 @@ namespace ABACUS {
     }
     label += LABELSEP;
 
-    //cout << "Label C" << endl;
-
     // Now the displacements:
     // The conventions are as follows.
     // For each excitation, an integer number ID is given according to the following rules:
@@ -489,15 +421,15 @@ namespace ABACUS {
 	int holeindex = -1;
 	do {
 	  holeindex++;
-	} while (OriginIx2[data.type[itype] ][holeindex] != data.Ix2old[itype][iexc] && holeindex < OriginIx2[data.type[itype] ].size() - 1);
-	if (holeindex == OriginIx2[data.type[itype] ].size()) ABACUSerror("Going out of bounds in Compress_Label.");
+	} while (OriginIx2[data.type[itype] ][holeindex] != data.Ix2old[itype][iexc]
+		 && holeindex < OriginIx2[data.type[itype] ].size() - 1);
+	if (holeindex == OriginIx2[data.type[itype] ].size())
+	  ABACUSerror("Going out of bounds in Compress_Label.");
 	excID = excID * data.M[itype] + holeindex;
 	label += Convert_POSINT_to_STR(excID);
       } // for iexc
     } // for itype
 
-    //cout << "Label D" << endl;
-
     return(label);
   }
 
@@ -512,13 +444,17 @@ namespace ABACUS {
   {
     // This function does not assume any ordering of the Ix2.
 
-    if (ScanIx2.size() != OriginIx2.size()) ABACUSerror("ScanIx2.size() != OriginIx2.size() in Find_Label.");
-    for (int i = 0; i < ScanIx2.size(); ++i) if (ScanIx2[i].size() != OriginIx2[i].size()) ABACUSerror("ScanIx2[i].size() != OriginIx2[i].size() in Find_Label.");
+    if (ScanIx2.size() != OriginIx2.size())
+      ABACUSerror("ScanIx2.size() != OriginIx2.size() in Find_Label.");
+    for (int i = 0; i < ScanIx2.size(); ++i)
+      if (ScanIx2[i].size() != OriginIx2[i].size())
+	ABACUSerror("ScanIx2[i].size() != OriginIx2[i].size() in Find_Label.");
 
     // Set the state ulabel:
     // Count the number of types present:
     int ntypespresent = 0;
-    for (int is = 0; is < ScanIx2.size(); ++is) if (is == 0 || ScanIx2[is].size() > 0) ntypespresent++; // type 0 is by default always present
+    for (int is = 0; is < ScanIx2.size(); ++is)
+      if (is == 0 || ScanIx2[is].size() > 0) ntypespresent++; // type 0 is by default always present
 
     Vect<int> type_ref(ntypespresent);
     Vect<int> M_ref(ntypespresent);
@@ -541,10 +477,15 @@ namespace ABACUS {
     for (int it = 0; it < ntypespresent; ++it) Ix2exc_ref[it] = Vect<int>(ABACUS::max(nexc_ref[it],1));
     for (int it = 0; it < ntypespresent; ++it) {
       int nexccheck = 0;
-      for (int i = 0; i < M_ref[it]; ++i) if (!OriginIx2[type_ref[it] ].includes(ScanIx2[type_ref[it] ][i])) Ix2exc_ref[it][nexccheck++] = ScanIx2[type_ref[it] ][i];
-      if (nexccheck != nexc_ref[it]) ABACUSerror("Counting excitations wrong (1) in Return_State_Label");
+      for (int i = 0; i < M_ref[it]; ++i)
+	if (!OriginIx2[type_ref[it] ].includes(ScanIx2[type_ref[it] ][i]))
+	  Ix2exc_ref[it][nexccheck++] = ScanIx2[type_ref[it] ][i];
+      if (nexccheck != nexc_ref[it])
+	ABACUSerror("Counting excitations wrong (1) in Return_State_Label");
       nexccheck = 0;
-      for (int i = 0; i < M_ref[it]; ++i) if (!ScanIx2[type_ref[it] ].includes(OriginIx2[type_ref[it] ][i])) Ix2old_ref[it][nexccheck++] = OriginIx2[type_ref[it] ][i];
+      for (int i = 0; i < M_ref[it]; ++i)
+	if (!ScanIx2[type_ref[it] ].includes(OriginIx2[type_ref[it] ][i]))
+	  Ix2old_ref[it][nexccheck++] = OriginIx2[type_ref[it] ][i];
       if (nexccheck != nexc_ref[it]) {
 	cout << OriginIx2 << endl;
 	cout << ScanIx2 << endl;
@@ -572,19 +513,16 @@ namespace ABACUS {
   }
 
 
-  //bool Set_to_Label (string label_ref, Vect<Vect<int> >& Ix2, const Vect<Vect<int> >& OriginIx2)
+
   Vect<Vect<int> > Return_Ix2_from_Label (string label_ref, const Vect<Vect<int> >& OriginIx2)
   {
     // ASSUMPTIONS:
     // OriginIx2 is ordered.
 
-    //Ix2 = OriginIx2; // this will fail if the sizes are incompatible
     Vect<Vect<int> > Ix2 = OriginIx2; // this will fail if the sizes are incompatible
 
     State_Label_Data labeldata = Read_State_Label (label_ref, OriginIx2);
 
-    //cout << "Read label OK" << endl;
-
     // Now set the excitations:
     for (int it = 0; it < labeldata.type.size(); ++it)
       for (int iexc = 0; iexc < labeldata.nexc[it]; ++iexc)
@@ -596,12 +534,9 @@ namespace ABACUS {
     // Now reorder the Ix2 to follow convention:
     for (int il = 0; il < Ix2.size(); ++il) Ix2[il].QuickSort();
 
-    //cout << "Ix2 found = " << Ix2 << endl;
-
     return(Ix2);
-    //return(true);
   }
-  // Specialization to Lieb-Liniger:
+
   Vect<int> Return_Ix2_from_Label (string label_ref, const Vect<int>& OriginIx2)
   {
     Vect<Vect<int> > OriginIx2here(1);
@@ -611,47 +546,4 @@ namespace ABACUS {
   }
 
 
-  /* DEPRECATED ++G_5
-  // Conversion from one to the other:
-  string Compress_Ulabel (string ulabel_ref, const Vect<Vect<int> >& OriginIx2)
-  {
-    // From a normal label, return a compressed one.
-    State_Label_Data data = Read_State_Ulabel (ulabel_ref);
-
-    return(Return_State_Label(data, OriginIx2));
-  }
-
-  string Compress_Ulabel (string ulabel_ref, const Vect<int>& OriginIx2)
-  // if there is only one type
-  {
-    // From a normal label, return a compressed one.
-    Vect<Vect<int> > OriginIx2here(1);
-    OriginIx2here[0] = OriginIx2;
-
-    State_Label_Data data = Read_State_Ulabel (ulabel_ref);
-
-    return(Return_State_Label(data, OriginIx2here));
-  }
-
-  string Uncompress_Label (string label_ref, const Vect<Vect<int> >& OriginIx2)
-  {
-    // From a compressed label, return a normal one.
-    State_Label_Data data = Read_State_Label (label_ref, OriginIx2);
-
-    return(Return_State_Ulabel(data));
-  }
-
-  string Uncompress_Label (string label_ref, const Vect<int>& OriginIx2)
-  // if there is only one type
-  {
-    // From a compressed label, return a normal one.
-    Vect<Vect<int> > OriginIx2here(1);
-    OriginIx2here[0] = OriginIx2;
-
-    State_Label_Data data = Read_State_Label (label_ref, OriginIx2here);
-
-    return(Return_State_Ulabel(data));
-  }
-  */
-
 } // namespace ABACUS

src/XXX_VOA/SF_4p_client.cc

@@ -41,9 +41,6 @@ namespace ABACUS {
     MPI_Comm_rank (comm, &rank);
 
     MPI_Recv (client_request, client_request_size, MPI_DOUBLE, server, MPI_ANY_TAG, comm, &status);
-    //cout << "Client of rank " << rank << ":  received request ";
-    //for (int i = 0; i < client_request_size; ++i) cout << client_request[i] << " ";
-    //cout << "with tag " << status.MPI_TAG << endl;
 
 
     while (status.MPI_TAG) {
@@ -59,112 +56,12 @@ namespace ABACUS {
       client_result[7] = SF_4p_opt (client_request[2], client_request[3], client_request[4],
 				    int(client_request[5]), int(client_request[6]), Itable);
       MPI_Send (client_result, client_result_size, MPI_DOUBLE, server, status.MPI_TAG, comm);
-      //cout << "Client of rank " << rank << " sending complete" << endl;
 
       // Wait for subsequent request from server
       MPI_Recv (client_request, client_request_size, MPI_DOUBLE, server, MPI_ANY_TAG, comm, &status);
-      //cout << "Client of rank " << rank << ":  received request ";
-      //for (int i = 0; i < client_request_size; ++i) cout << client_request[i] << " ";
-      //cout << "with tag " << status.MPI_TAG << endl;
-
-    }
-
-    return;
-  }
-  /*
-  void SF_4p_kwKW_alpha_client (MPI_Comm comm, DP req_prec, int max_rec, I_table Itable)
-  {
-    int server = 0;
-    int rank;
-
-    MPI_Status status;
-
-    int client_request_size = 2;
-    DP client_request[client_request_size]; // this is k, alpha
-    int client_result_size = 3;
-    DP client_result[client_result_size]; // this is k, alpha, SF_4p_kwKW_alpha
-
-    MPI_Comm_rank (comm, &rank);
-
-    MPI_Recv (client_request, client_request_size, MPI_DOUBLE, server, MPI_ANY_TAG, comm, &status);
-    //cout << "Client of rank " << rank << ":  received request ";
-    //for (int i = 0; i < client_request_size; ++i) cout << client_request[i] << " ";
-    //cout << "with tag " << status.MPI_TAG << endl;
-
-    Vect_DP args_to_SF_4p_kwKW_alpha(4);
-    args_to_SF_4p_kwKW_alpha[2] = req_prec;
-    args_to_SF_4p_kwKW_alpha[3] = DP(max_rec);
-
-    while (status.MPI_TAG) {
-
-      args_to_SF_4p_kwKW_alpha[0] = client_request[0];
-      args_to_SF_4p_kwKW_alpha[1] = client_request[1];
-
-      // Result:  SF_4p (k, omega)
-      client_result[0] = client_request[0];
-      client_result[1] = client_request[1];
-      client_result[2] = SF_4p_kwKW_alpha (args_to_SF_4p_kwKW_alpha, Itable);
-
-      MPI_Send (client_result, client_result_size, MPI_DOUBLE, server, status.MPI_TAG, comm);
-      //cout << "Client of rank " << rank << " sending complete" << endl;
-
-      // Wait for subsequent request from server
-      MPI_Recv (client_request, client_request_size, MPI_DOUBLE, server, MPI_ANY_TAG, comm, &status);
-      //cout << "Client of rank " << rank << ":  received request ";
-      //for (int i = 0; i < client_request_size; ++i) cout << client_request[i] << " ";
-      //cout << "with tag " << status.MPI_TAG << endl;
-
     }
 
     return;
   }
 
-  void SF_4p_kwKW_alpha_opt_client (MPI_Comm comm, DP req_prec, int Npts_K, int Npts_W, I_table Itable)
-  {
-    int server = 0;
-    int rank;
-
-    MPI_Status status;
-
-    int client_request_size = 2;
-    DP client_request[client_request_size]; // this is k, alpha
-    int client_result_size = 3;
-    DP client_result[client_result_size]; // this is k, alpha, SF_4p_kwKW_alpha_opt
-
-    MPI_Comm_rank (comm, &rank);
-
-    MPI_Recv (client_request, client_request_size, MPI_DOUBLE, server, MPI_ANY_TAG, comm, &status);
-    //cout << "Client of rank " << rank << ":  received request ";
-    //for (int i = 0; i < client_request_size; ++i) cout << client_request[i] << " ";
-    //cout << "with tag " << status.MPI_TAG << endl;
-
-    Vect_DP args_to_SF_4p_kwKW_alpha_opt(5);
-    args_to_SF_4p_kwKW_alpha_opt[2] = req_prec;
-    args_to_SF_4p_kwKW_alpha_opt[3] = DP(Npts_K);
-    args_to_SF_4p_kwKW_alpha_opt[4] = DP(Npts_W);
-
-    while (status.MPI_TAG) {
-
-      args_to_SF_4p_kwKW_alpha_opt[0] = client_request[0];
-      args_to_SF_4p_kwKW_alpha_opt[1] = client_request[1];
-
-      // Result:  SF_4p (k, omega)
-      client_result[0] = client_request[0];
-      client_result[1] = client_request[1];
-      client_result[2] = SF_4p_kwKW_alpha_opt (args_to_SF_4p_kwKW_alpha_opt, Itable);
-
-      MPI_Send (client_result, client_result_size, MPI_DOUBLE, server, status.MPI_TAG, comm);
-      //cout << "Client of rank " << rank << " sending complete" << endl;
-
-      // Wait for subsequent request from server
-      MPI_Recv (client_request, client_request_size, MPI_DOUBLE, server, MPI_ANY_TAG, comm, &status);
-      //cout << "Client of rank " << rank << ":  received request ";
-      //for (int i = 0; i < client_request_size; ++i) cout << client_request[i] << " ";
-      //cout << "with tag " << status.MPI_TAG << endl;
-
-    }
-
-    return;
-  }
-  */
 } // namespace ABACUS

src/XXX_VOA/SF_4p_server.cc

@@ -57,7 +57,6 @@ namespace ABACUS {
 	for (int ik = 0; ik < dim_k; ++ik) {
 	  SF_outfile >> SF_4p[dim_k * iomega + ik];
 	  if (SF_4p[dim_k * iomega + ik] == 0.0) total_nr_req++;
-	  //cout << ik << "\t" << iomega << "\t" << SF_4p[dim_k * iomega + ik] << "\t" << (SF_4p[dim_k * iomega + ik] == 0.0) << "\t" << total_nr_req << endl;
 
 	  // We only load the LHS of the BZ, so we load N/2 empty values...
 	}
@@ -87,11 +86,6 @@ namespace ABACUS {
       cout << total_nr_req << "\t" << index << endl;
       ABACUSerror("Not counting total_nr_req correctly in SF_4p_opt_server");
     }
-    //ofstream SFsrc_outfile;
-    //SFsrc_outfile.open(SFsrc_Cstr);
-
-    //DP omegamin_used = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
-    //DP omegamax_used = 0.5 * wmax_4p (k);
 
     int nr_machines;
     MPI_Comm_size (comm, &nr_machines);
@@ -129,22 +123,16 @@ namespace ABACUS {
       client_request[6] = DP(Npts_W);
 
       MPI_Send(client_request, client_request_size, MPI_DOUBLE, i, scanning, comm);
-      //cout << "Server:  sent request ";
-      //for (int ii = 0; ii < client_request_size; ++ii) cout << client_request[ii] << " ";
-      //cout << "with tag " << scanning << " to client " << i << endl;
       nr_sent_out++;
-      //cout << "nr_sent_out = " << nr_sent_out << endl;
     }
 
     DP Actual_Time_MPI = MPI_Wtime();
 
-    //while (nr_returned < total_nr_req) {
     while (nr_returned < nr_sent_out) {
 
-      //cout << "Server:  waiting for answers... " << endl;
       MPI_Recv (client_result, client_result_size, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, comm, &status);
       nr_returned++;
-      //cout << "Server:  received answer from client " << status.MPI_SOURCE << endl;
+
       // unbuffer result
       SF_4p[dim_k * int(client_result[1]) + int(client_result[0])] = client_result[7];
 
@@ -158,15 +146,10 @@ namespace ABACUS {
 	client_request[3] = (needed_iomega[nr_sent_out] + 0.5) * omegamax/Nomega;
 	MPI_Send (client_request, client_request_size, MPI_DOUBLE, status.MPI_SOURCE, scanning, comm);
 	nr_sent_out++;
-	//cout << "nr_sent_out = " << nr_sent_out << endl;
       }
 
     } // while (nr_returned < total_nr_req)
 
-    cout << endl << "Computed " << nr_returned << " points ouf of " << total_nr_req << " required. " << endl;
-
-    cout << endl << "Server saving file..." << endl;
-
     // Output all data:  double up to full [0, 2pi] interval in k with symmetry
     SF_outfile.seekp(0);
     for (int iomega = 0; iomega < Nomega; ++iomega) {
@@ -187,384 +170,5 @@ namespace ABACUS {
     return;
   }
 
-  /****************************************************
-
-  // TO COMPLETE FOR 5.5 (commented out in 5.7)
-
-  *********************************************************/
-  /*
-  void SF_4p_opt_server (MPI_Comm comm, DP k_needed, DP omegamax, int Nomega, DP req_prec, int Npts_K, int Npts_W, I_table Itable,
-			 int Max_Secs, bool refine)
-  {
-    double Start_Time_MPI = MPI_Wtime();
-
-    Heis_Write_w_File (Nomega, omegamax);
-
-    stringstream SF_stringstream;
-    string SF_string;
-    SF_stringstream << "SF_4p_k_" << k_needed << "_No_" << Nomega << "_omax_" << omegamax
-		    << "_prec_" << req_prec << "_Npts_K_" << Npts_K << "_Npts_W_" << Npts_W << ".dat";
-    SF_string = SF_stringstream.str();
-    const char* SF_Cstr = SF_string.c_str();
-
-    fstream SF_outfile;
-    if (!refine) SF_outfile.open(SF_Cstr, fstream::out | fstream::trunc);
-    else SF_outfile.open(SF_Cstr, fstream::in | fstream::out);
-    if (SF_outfile.fail()) ABACUSerror("Could not open SF_outfile... ");
-
-    SF_outfile.precision(12);
-
-    int dim_k = 1;
-
-    DP* SF_4p = new DP[dim_k * Nomega];
-
-    // Initialize to zero to be sure:
-    for (int i = 0; i < Nomega * dim_k; ++i) SF_4p[i] = 0.0;
-
-    // If refining, load SF from existing file
-
-    int total_nr_req = 0;
-    DP buff;
-    if (refine) {
-      for (int iomega = 0; iomega < Nomega; ++iomega) {
-	for (int ik = 0; ik < dim_k; ++ik) {
-	  SF_outfile >> SF_4p[dim_k * iomega + ik];
-	  if (SF_4p[dim_k * iomega + ik] == 0.0) total_nr_req++;
-	  //cout << ik << "\t" << iomega << "\t" << SF_4p[dim_k * iomega + ik] << "\t" << (SF_4p[dim_k * iomega + ik] == 0.0) << "\t" << total_nr_req << endl;
-
-	  // We only load the LHS of the BZ, so we load N/2 empty values...
-	}
-	for (int ibuff = 0; ibuff < N/2; ++ibuff) SF_outfile >> buff;
-      }
-    }
-    else if (!refine) total_nr_req = dim_k * Nomega;
-
-    // List iomega and ik which need to be computed:
-
-    int* needed_ik = new int[total_nr_req];
-    int* needed_iomega = new int[total_nr_req];
-
-    int index = 0;
-    for (int iomega = 0; iomega < Nomega; ++iomega)
-      for (int ik = 0; ik < dim_k; ++ik) {
-	if (SF_4p[dim_k * iomega + ik] == 0) {
-	  needed_ik[index] = ik;
-	  needed_iomega[index] = iomega;
-	  index++;
-	}
-      }
-
-    cout << total_nr_req << " points required." << endl;
-
-    if (index != total_nr_req) {
-      cout << total_nr_req << "\t" << index << endl;
-      ABACUSerror("Not counting total_nr_req correctly in SF_4p_opt_server");
-    }
-    //ofstream SFsrc_outfile;
-    //SFsrc_outfile.open(SFsrc_Cstr);
-
-    //DP omegamin_used = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
-    //DP omegamax_used = 0.5 * wmax_4p (k);
-
-    int nr_machines;
-    MPI_Comm_size (comm, &nr_machines);
-    int nr_clients = nr_machines - 1;  // one for the server
-
-    int client_request_size = 7;
-    DP client_request[client_request_size];
-    // this is:
-    // ik
-    // iomega
-    // k
-    // omega
-    // req_prec
-    // Npts_K
-    // Npts_W
-    int client_result_size = 8;
-    DP client_result[client_result_size]; // same, plus SF_4p
-
-    MPI_Status status;
-
-    int scanning = 1;
-
-    int nr_sent_out = 0;
-    int nr_returned = 0;
-
-    for (int i = 1; i <= nr_clients && i <= total_nr_req; ++i) {
-
-      // Send request to client i, in the form of the req_id_array vector
-      client_request[0] = DP(needed_ik[nr_sent_out]);
-      client_request[1] = DP(needed_iomega[nr_sent_out]);
-      client_request[2] = k_needed;//(twoPI * needed_ik[nr_sent_out])/N;
-      client_request[3] = (needed_iomega[nr_sent_out] + 0.5) * omegamax/Nomega;
-      client_request[4] = req_prec;
-      client_request[5] = DP(Npts_K);
-      client_request[6] = DP(Npts_W);
-
-      MPI_Send(client_request, client_request_size, MPI_DOUBLE, i, scanning, comm);
-      //cout << "Server:  sent request ";
-      //for (int ii = 0; ii < client_request_size; ++ii) cout << client_request[ii] << " ";
-      //cout << "with tag " << scanning << " to client " << i << endl;
-      nr_sent_out++;
-      //cout << "nr_sent_out = " << nr_sent_out << endl;
-    }
-
-    DP Actual_Time_MPI = MPI_Wtime();
-
-    //while (nr_returned < total_nr_req) {
-    while (nr_returned < nr_sent_out) {
-
-      //cout << "Server:  waiting for answers... " << endl;
-      MPI_Recv (client_result, client_result_size, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, comm, &status);
-      nr_returned++;
-      //cout << "Server:  received answer from client " << status.MPI_SOURCE << endl;
-      // unbuffer result
-      SF_4p[int(client_result[1])] = client_result[7];
-
-      Actual_Time_MPI = MPI_Wtime();
-
-      // Send out new request if needed and time available
-      if (nr_sent_out < total_nr_req && Actual_Time_MPI - Start_Time_MPI < Max_Secs) {
-	client_request[0] = needed_ik[nr_sent_out];
-	client_request[1] = needed_iomega[nr_sent_out];
-	client_request[2] = k_needed;//(twoPI * needed_ik[nr_sent_out])/N;
-	client_request[3] = (needed_iomega[nr_sent_out] + 0.5) * omegamax/Nomega;
-	MPI_Send (client_request, client_request_size, MPI_DOUBLE, status.MPI_SOURCE, scanning, comm);
-	nr_sent_out++;
-	//cout << "nr_sent_out = " << nr_sent_out << endl;
-      }
-
-    } // while (nr_returned < total_nr_req)
-
-    cout << endl << "Computed " << nr_returned << " points ouf of " << total_nr_req << " required. " << endl;
-
-    cout << endl << "Server saving file..." << endl;
-
-    // Output all data:
-    SF_outfile.seekp(0);
-    for (int iomega = 0; iomega < Nomega; ++iomega) {
-      SF_outfile << omega[iomega] << "\t" << SF_4p[iomega] << endl;
-    }
-
-    SF_outfile.close();
-
-    cout << endl << "Done !" << endl;
-
-    // Send term signal to clients
-    int scanning_completed = 0;
-    for (int i = 1; i <= nr_clients; ++i)
-      MPI_Send (client_request, client_request_size, MPI_DOUBLE, i, scanning_completed, comm);
-
-    return;
-  }
-  */
-  /*
-  // Function producing a fixed k scan, with data file
-  void SF_4p_rec_par (MPI_Comm comm, DP k, DP req_prec, int max_rec_w, int max_rec, I_table Itable)
-  {
-    int Npts_w = int(pow(3.0, max_rec_w + 2));
-
-    stringstream SFraw_stringstream;
-    string SFraw_string;
-    SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w << "_max_rec_" << max_rec << ".raw";
-    SFraw_string = SFraw_stringstream.str();
-    const char* SFraw_Cstr = SFraw_string.c_str();
-
-    stringstream SF_stringstream;
-    string SF_string;
-    SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w << "_max_rec_" << max_rec << ".dat";
-    SF_string = SF_stringstream.str();
-    const char* SF_Cstr = SF_string.c_str();
-
-    stringstream SFsrc_stringstream;
-    string SFsrc_string;
-    SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w << "_max_rec_" << max_rec << ".src";
-    SFsrc_string = SFsrc_stringstream.str();
-    const char* SFsrc_Cstr = SFsrc_string.c_str();
-
-    ofstream SFraw_outfile;
-    SFraw_outfile.open(SFraw_Cstr);
-    //ofstream SFsrc_outfile;
-    //SFsrc_outfile.open(SFsrc_Cstr);
-
-    //DP omegamin_used = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
-    //DP omegamax_used = 0.5 * wmax_4p (k);
-
-    int nr_machines;
-    MPI_Comm_size (comm, &nr_machines);
-    int nr_clients = nr_machines - 1;  // one for the server
-
-    int client_request_size = 2;
-    DP client_request[client_request_size]; // this is k, alpha
-    int client_result_size = 3;
-    DP client_result[client_result_size]; // this is k, alpha, SF_4p_kwKW_alpha
-
-    MPI_Status status;
-
-    int scanning = 1;
-
-    int total_nr_req = Npts_w;
-    int nr_sent_out = 0;
-    int nr_returned = 0;
-
-    Vect_DP alpha_req(Npts_w);
-    for (int iw = 0; iw < Npts_w; ++iw) alpha_req[iw] = 0.5 * PI * (iw + 0.5)/Npts_w;
-
-    //cout << "alpha_req = " << alpha_req << endl;
-
-    for (int i = 1; i <= nr_clients && i <= total_nr_req; ++i) {
-
-      // Send request to client i, in the form of the req_id_array vector
-      client_request[0] = k;
-      client_request[1] = alpha_req[nr_sent_out];
-
-      MPI_Send(client_request, client_request_size, MPI_DOUBLE, i, scanning, comm);
-      //cout << "Server:  sent request ";
-      //for (int ii = 0; ii < client_request_size; ++ii) cout << client_request[ii] << " ";
-      //cout << "with tag " << scanning << " to client " << i << endl;
-      nr_sent_out++;
-      //cout << "nr_sent_out = " << nr_sent_out << endl;
-    }
-
-    while (nr_returned < total_nr_req) {
-
-      //cout << "Server:  waiting for answers... " << endl;
-      MPI_Recv (client_result, client_result_size, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, comm, &status);
-      nr_returned++;
-      //cout << "Server:  received answer from client " << status.MPI_SOURCE << endl;
-
-      // unbuffer result
-      SFraw_outfile << client_result[1] << "\t" << client_result[2] << endl;
-
-      // Send out new request if needed
-      if (nr_sent_out < total_nr_req) {
-	client_request[1] = alpha_req[nr_sent_out];
-	MPI_Send (client_request, client_request_size, MPI_DOUBLE, status.MPI_SOURCE, scanning, comm);
-	nr_sent_out++;
-	//cout << "nr_sent_out = " << nr_sent_out << endl;
-      }
-
-    } // while (nr_returned < total_nr_req)
-
-    // Send term signal to clients
-    int scanning_completed = 0;
-    for (int i = 1; i <= nr_clients; ++i)
-      MPI_Send (client_request, client_request_size, MPI_DOUBLE, i, scanning_completed, comm);
-
-    SFraw_outfile.close();
-
-    //SFsrc_outfile << answer << endl;
-    //SFsrc_outfile.close();
-
-    // Translate raw data into SF_4p (k,omega) data
-
-    //Translate_raw_4p_data (k, max_rec_w, SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
-    Translate_raw_4p_data (k, int(pow(3.0, max_rec_w + 2)), SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
-
-    return;
-  }
-
-  void SF_4p_opt_par (MPI_Comm comm, DP k, DP req_prec, int Npts_w, int Npts_K, int Npts_W, I_table Itable)
-  {
-    stringstream SFraw_stringstream;
-    string SFraw_string;
-    SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".raw";
-    SFraw_string = SFraw_stringstream.str();
-    const char* SFraw_Cstr = SFraw_string.c_str();
-
-    stringstream SF_stringstream;
-    string SF_string;
-    SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".dat";
-    SF_string = SF_stringstream.str();
-    const char* SF_Cstr = SF_string.c_str();
-
-    stringstream SFsrc_stringstream;
-    string SFsrc_string;
-    SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".src";
-    SFsrc_string = SFsrc_stringstream.str();
-    const char* SFsrc_Cstr = SFsrc_string.c_str();
-
-    ofstream SFraw_outfile;
-    SFraw_outfile.open(SFraw_Cstr);
-    //ofstream SFsrc_outfile;
-    //SFsrc_outfile.open(SFsrc_Cstr);
-
-    //DP omegamin_used = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
-    //DP omegamax_used = 0.5 * wmax_4p (k);
-
-    int nr_machines;
-    MPI_Comm_size (comm, &nr_machines);
-    int nr_clients = nr_machines - 1;  // one for the server
-
-    int client_request_size = 2;
-    DP client_request[client_request_size]; // this is k, alpha
-    int client_result_size = 3;
-    DP client_result[client_result_size]; // this is k, alpha, SF_4p_kwKW_alpha_opt
-
-    MPI_Status status;
-
-    int scanning = 1;
-
-    int total_nr_req = Npts_w;
-    int nr_sent_out = 0;
-    int nr_returned = 0;
-
-    Vect_DP alpha_req(Npts_w);
-    for (int iw = 0; iw < Npts_w; ++iw) alpha_req[iw] = 0.5 * PI * (iw + 0.5)/Npts_w;
-
-    //cout << "alpha_req = " << alpha_req << endl;
-
-    for (int i = 1; i <= nr_clients && i <= total_nr_req; ++i) {
-
-      // Send request to client i, in the form of the req_id_array vector
-      client_request[0] = k;
-      client_request[1] = alpha_req[nr_sent_out];
-
-      MPI_Send(client_request, client_request_size, MPI_DOUBLE, i, scanning, comm);
-      //cout << "Server:  sent request ";
-      //for (int ii = 0; ii < client_request_size; ++ii) cout << client_request[ii] << " ";
-      //cout << "with tag " << scanning << " to client " << i << endl;
-      nr_sent_out++;
-      //cout << "nr_sent_out = " << nr_sent_out << endl;
-    }
-
-    while (nr_returned < total_nr_req) {
-
-      //cout << "Server:  waiting for answers... " << endl;
-      MPI_Recv (client_result, client_result_size, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, comm, &status);
-      nr_returned++;
-      //cout << "Server:  received answer from client " << status.MPI_SOURCE << endl;
-
-      // unbuffer result
-      SFraw_outfile << client_result[1] << "\t" << client_result[2] << endl;
-
-      // Send out new request if needed
-      if (nr_sent_out < total_nr_req) {
-	client_request[1] = alpha_req[nr_sent_out];
-	MPI_Send (client_request, client_request_size, MPI_DOUBLE, status.MPI_SOURCE, scanning, comm);
-	nr_sent_out++;
-	//cout << "nr_sent_out = " << nr_sent_out << endl;
-      }
-
-    } // while (nr_returned < total_nr_req)
-
-    // Send term signal to clients
-    int scanning_completed = 0;
-    for (int i = 1; i <= nr_clients; ++i)
-      MPI_Send (client_request, client_request_size, MPI_DOUBLE, i, scanning_completed, comm);
-
-    SFraw_outfile.close();
-
-    //SFsrc_outfile << answer << endl;
-    //SFsrc_outfile.close();
-
-    // Translate raw data into SF_4p (k,omega) data
-
-    //Translate_raw_4p_data (k, max_rec_w, SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
-    Translate_raw_4p_data (k, Npts_w, SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
-
-    return;
-  }
-  */
 
 } // namespace ABACUS

src/XXX_VOA/XXX_VOA.cc

@@ -26,7 +26,7 @@ namespace ABACUS {
 
     DP rho_used = fabs(rho);
 
-    if (rho_used > 10000.0) return(-PI * rho_used - 2.0 * Euler_Mascheroni);  // CHECK THIS
+    if (rho_used > 10000.0) return(-PI * rho_used - 2.0 * Euler_Mascheroni);
 
     Vect_DP args(2);
     args[0] = 0.0;
@@ -37,12 +37,6 @@ namespace ABACUS {
       - 2.0 * Integrate_rec (Integrand_12, args, 0, t1, tinf, req_prec, 12)
       - Integrate_rec (Integrand_2, args, 0, 0.0, tinf, req_prec, 12);
 
-    /*
-    DP answer = -2.0 * Euler_Mascheroni - 2.0 * log(4.0 * rho_used * t1)
-      + 2.0 * (Integrate_optimal (Integrand_11, args, 0, 0.0, t1, req_prec, 1.0e-30, 10000)).integ_est
-      - 2.0 * (Integrate_optimal (Integrand_12, args, 0, t1, tinf, req_prec, 1.0e-30, 10000)).integ_est
-      - (Integrate_optimal (Integrand_2, args, 0, 0.0, tinf, req_prec, 1.0e-30, 10000)).integ_est;
-    */
     return(answer);
   }
 
@@ -53,14 +47,17 @@ namespace ABACUS {
   {
     // Careful !  This is S(k, omega) = S (k, w) |dw/domega| = 2 S(k, w)
 
-    DP w = 2.0 * omega;  // Rescale energies by factor 2 because of definitions of H_XXX (omega:  S.S;  w: 0.5 * sigma.sigma = 2 S.S)
+    DP w = 2.0 * omega;
+    // Rescale energies by factor 2 because of definitions of H_XXX (omega:  S.S;  w: 0.5 * sigma.sigma = 2 S.S)
 
     DP wu = twoPI * sin(0.5 * k);
     DP wl = PI * fabs(sin(k));
 
     // Factor of 2:  return S(k, omega), not S(k, w)
-    // 0.25 factor:  1/4 * 2 * 1/2, where 1/4 comes from Bougourzi, 2 is the Jacobian |dw/domega| and 1/2 is S^{zz} = 1/2 * S^{+-}
-    return(w < wu && w > wl ? 2.0 * 0.5 * exp(-Itable.Return_val (acosh(sqrt((wu * wu - wl * wl)/(w * w - wl * wl)))/PI))/sqrt(wu * wu - w * w) : 0.0);
+    // 0.25 factor:  1/4 * 2 * 1/2, where 1/4 comes from Bougourzi, 2 is the Jacobian |dw/domega|
+    // and 1/2 is S^{zz} = 1/2 * S^{+-}
+    return(w < wu && w > wl ? 2.0 * 0.5
+	   * exp(-Itable.Return_val (acosh(sqrt((wu * wu - wl * wl)/(w * w - wl * wl)))/PI))/sqrt(wu * wu - w * w) : 0.0);
 
   }
 
@@ -75,7 +72,8 @@ namespace ABACUS {
 
     // 0.5 factor:  1 from Bougourzi, and 1/2 is S^{zz} = 1/2 * S^{+-}
     return(args[1] < wu && args[1] > wl ?
-	   0.5 * exp(-Itable.Return_val (acosh(sqrt((wu * wu - wl * wl)/(args[1] * args[1] - wl * wl)))/PI))/sqrt(wu * wu - args[1] * args[1]) : 0.0);
+	   0.5 * exp(-Itable.Return_val (acosh(sqrt((wu * wu - wl * wl)/(args[1] * args[1] - wl * wl)))
+					 /PI))/sqrt(wu * wu - args[1] * args[1]) : 0.0);
   }
 
   DP SF_2p_alt (Vect_DP args, I_table Itable)
@@ -87,8 +85,7 @@ namespace ABACUS {
     DP wu = twoPI * sin(0.5 * args[0]);
     DP wl = PI * fabs(sin(args[0]));
 
-    //DP w = wu * cos(args[1]);
-    //DP factor = 1.0;
+
     DP w = wl * cosh(args[1]);
 
     if (w >= wu || w <= wl) return(0.0);
@@ -109,8 +106,6 @@ namespace ABACUS {
     DP wu = twoPI * sin(0.5 * args[0]);
     DP wl = PI * fabs(sin(args[0]));
 
-    //DP w = wu * cos(args[1]);
-    //DP factor = 1.0;
     DP w = wl * cosh(args[1]);
     DP factor = sqrt((w * w - wl * wl)/(wu * wu - w * w));
 
@@ -153,7 +148,6 @@ namespace ABACUS {
     args_to_SF_2p[1] = 0.0; // this will be w
     args_to_SF_2p[2] = ABACUS::max(1.0e-14, 0.01 * req_prec);
 
-    //return(Integrate_rec_using_table (SF_2p_alt, args_to_SF_2p, 1, Itable, 0.0, acos(wl/wu), req_prec, max_rec)/twoPI);
     return(Integrate_rec_using_table (SF_2p_alt, args_to_SF_2p, 1, Itable, 0.0, acosh(wu/wl), req_prec, max_rec)/twoPI);
   }
 
@@ -168,7 +162,8 @@ namespace ABACUS {
     args_to_SF_2p_intw[2] = DP(max_rec);
 
     // Factor 2:  int[0, 2PI] = 2 int[0, PI]
-    return(4.0 * 2.0 * Integrate_rec_using_table (SF_2p_intw, args_to_SF_2p_intw, 0, Itable, 0.0, PI, req_prec, max_rec)/twoPI);
+    return(4.0 * 2.0 * Integrate_rec_using_table (SF_2p_intw, args_to_SF_2p_intw, 0, Itable,
+						  0.0, PI, req_prec, max_rec)/twoPI);
     // 4 : because full integral gives 1/4, return value here is sr fraction obtained.
   }
 
@@ -183,7 +178,8 @@ namespace ABACUS {
     args_to_SF_2p_intw[2] = DP(max_rec);
 
     // Factor 2:  int[0, 2PI] = 2 int[0, PI]
-    return(4.0 * 2.0 * Integrate_rec_using_table (SF_2p_intw_alt, args_to_SF_2p_intw, 0, Itable, 0.0, PI, req_prec, max_rec)/twoPI);
+    return(4.0 * 2.0 * Integrate_rec_using_table (SF_2p_intw_alt, args_to_SF_2p_intw, 0, Itable,
+						  0.0, PI, req_prec, max_rec)/twoPI);
     // 4 : because full integral gives 1/4, return value here is sr fraction obtained.
   }
 
@@ -210,7 +206,8 @@ namespace ABACUS {
     args_to_SF_2p[1] = 0.0; // this will be w
     args_to_SF_2p[2] = ABACUS::max(1.0e-14, 0.01 * req_prec);
 
-    return((Integrate_rec_using_table (SF_2p_w, args_to_SF_2p, 1, Itable, wl, wu, req_prec, max_rec)/twoPI)/Fixed_k_sumrule_w(k));
+    return((Integrate_rec_using_table (SF_2p_w, args_to_SF_2p, 1,
+				       Itable, wl, wu, req_prec, max_rec)/twoPI)/Fixed_k_sumrule_w(k));
   }
 
   DP SF_2p_check_fixed_k_sumrule_alt (DP k, DP req_prec, int max_rec, I_table Itable)
@@ -225,7 +222,8 @@ namespace ABACUS {
     args_to_SF_2p[1] = 0.0; // this will be alpha
     args_to_SF_2p[2] = ABACUS::max(1.0e-14, 0.01 * req_prec);
 
-    return((Integrate_rec_using_table (SF_2p_w_alt, args_to_SF_2p, 1, Itable, 0.0, acosh(wu/wl), req_prec, max_rec)/twoPI)/Fixed_k_sumrule_w(k));
+    return((Integrate_rec_using_table (SF_2p_w_alt, args_to_SF_2p, 1, Itable, 0.0, acosh(wu/wl),
+				       req_prec, max_rec)/twoPI)/Fixed_k_sumrule_w(k));
   }
 
   DP SF_2p_check_fixed_k_sumrule_opt (DP k, DP req_prec, int Npts, I_table Itable)
@@ -240,7 +238,8 @@ namespace ABACUS {
     args_to_SF_2p[1] = 0.0; // this will be alpha
     args_to_SF_2p[2] = ABACUS::max(1.0e-14, 0.01 * req_prec);
 
-    return(((Integrate_optimal_using_table (SF_2p_w_alt, args_to_SF_2p, 1, Itable, 0.0, acosh(wu/wl), req_prec, 1.0e-32, Npts)).integ_est/twoPI)/Fixed_k_sumrule_w(k));
+    return(((Integrate_optimal_using_table (SF_2p_w_alt, args_to_SF_2p, 1, Itable, 0.0, acosh(wu/wl),
+					    req_prec, 1.0e-32, Npts)).integ_est/twoPI)/Fixed_k_sumrule_w(k));
   }
 
 
@@ -253,9 +252,6 @@ namespace ABACUS {
     complex<DP> g[4];
     for (int l = 0; l < 4; ++l) g[l] = 0.0;
 
-    //DP prefactor = 256.0 * pow(PI, 14.0);
-    //DP prefactor = 1.0; // All factors taken into account later
-
     complex<DP> Plm[4];
     complex<DP> Pm[4];
 
@@ -280,27 +276,7 @@ namespace ABACUS {
     }
 
     // Do m = 0 terms:
-    /*
-    Pm[0] *= Gamma_min_0p5 * exp(ln_Gamma(-0.5 + irhoj1[0]) - ln_Gamma(1.0 + irhoj1[0])
-				 + ln_Gamma(-0.5 + irhoj2[0]) - ln_Gamma(1.0 + irhoj2[0])
-				 + ln_Gamma(-0.5 + irhoj3[0]) - ln_Gamma(1.0 + irhoj3[0]));
-    Pm[1] *= Gamma_min_0p5 * exp(ln_Gamma(-0.5 + irhoj0[1]) - ln_Gamma(1.0 + irhoj0[1])
-				 + ln_Gamma(-0.5 + irhoj2[1]) - ln_Gamma(1.0 + irhoj2[1])
-				 + ln_Gamma(-0.5 + irhoj3[1]) - ln_Gamma(1.0 + irhoj3[1]));
-    Pm[2] *= Gamma_min_0p5 * exp(ln_Gamma(-0.5 + irhoj0[2]) - ln_Gamma(1.0 + irhoj0[2])
-				 + ln_Gamma(-0.5 + irhoj1[2]) - ln_Gamma(1.0 + irhoj1[2])
-				 + ln_Gamma(-0.5 + irhoj3[2]) - ln_Gamma(1.0 + irhoj3[2]));
-    Pm[3] *= Gamma_min_0p5 * exp(ln_Gamma(-0.5 + irhoj0[3]) - ln_Gamma(1.0 + irhoj0[3])
-				 + ln_Gamma(-0.5 + irhoj1[3]) - ln_Gamma(1.0 + irhoj1[3])
-				 + ln_Gamma(-0.5 + irhoj2[3]) - ln_Gamma(1.0 + irhoj2[3]));
-    */
     for (int j = 0; j < 4; ++j) {
-      /*
-      Pm[j] *= exp(ln_Gamma(-0.5 + irhoj0[j]) - ln_Gamma(1.0 + irhoj0[j])
-		   + ln_Gamma(-0.5 + irhoj1[j]) - ln_Gamma(1.0 + irhoj1[j])
-		   + ln_Gamma(-0.5 + irhoj2[j]) - ln_Gamma(1.0 + irhoj2[j])
-		   + ln_Gamma(-0.5 + irhoj3[j]) - ln_Gamma(1.0 + irhoj3[j]));
-      */
       // Calling only Gamma (z) for Re(z) >= 0.5, in view of Lanczos method:
       Pm[j] *= exp(ln_Gamma(0.5 + irhoj0[j]) - ln_Gamma(1.0 + irhoj0[j])
 		   + ln_Gamma(0.5 + irhoj1[j]) - ln_Gamma(1.0 + irhoj1[j])
@@ -315,23 +291,12 @@ namespace ABACUS {
 
 	if (j <= l) g[l] += Plm[j] * Pm[j]; // otherwise no m = 0 term
 
-	//cout << "j = " << j << "\tl = " << l << "\tPlm[j] = " << Plm[j] << "\tPm[j] = " << Pm[j] << "\tprod = " << Plm[j] * Pm[j] << endl;
       }
     }
 
-    /*
-    for (int j = 0; j < 4; ++j) {
-      if (j == 0) g[0] += irhoj1[j] * irhoj2[j] * irhoj3[j] * Pm[j];
-      if (j <= 1) g[1] += (-0.5 + irhoj0[j]) * irhoj2[j] * irhoj3[j] * Pm[j];
-      if (j <= 2) g[2] += (-0.5 + irhoj0[j]) * (-0.5 + irhoj1[j]) * irhoj3[j] * Pm[j];
-      g[3] += (-0.5 + irhoj0[j]) * (-0.5 + irhoj1[j]) * (-0.5 + irhoj2[j]) * Pm[j];
-    }
-    */
-
     DP sum_norm_gl = norm(g[0]) + norm(g[1]) + norm(g[2]) + norm(g[3]);
     DP old_sum_norm_gl = sum_norm_gl;
 
-    //cout << "|g1|^2 = " << prefactor * norm(g[0]) << "\t2 " << prefactor * norm(g[1]) << "\t3 " << prefactor * norm(g[2]) << "\t4 " << prefactor * norm(g[3]) << endl;
 
     // Do m = 1, 2, ... terms:
 
@@ -353,68 +318,17 @@ namespace ABACUS {
 	  Pm[j] *= (m - 1.5 + irhoj0[j]) * (m - 1.5 + irhoj1[j]) * (m - 1.5 + irhoj2[j]) * (m - 1.5 + irhoj3[j])
 	    / ((DP(m) + irhoj0[j]) * (DP(m) + irhoj1[j]) * (DP(m) + irhoj2[j]) * (DP(m) + irhoj3[j]));
 
-	    //for (int l = 0; l < 4; ++l) {
-
-	    //Plm[j] = 1.0;
-	    //for (int i = 0; i < 4; ++i) if (i != l) Plm[j] *= m - (l > i ? 0.5 : 0.0) + II * (rho[j] - rho[i]);
-
-	    //g[l] += Plm[j] * Pm[j];
-	  //}
-
 	  // FASTER:  unwrap l, i loops
 	  // l = 0:
-	  //Plm[j] = (DP(m) + II * (rho[j] - rho[1])) * (DP(m) + II * (rho[j] - rho[2])) * (DP(m) + II * (rho[j] - rho[3]));
-	  //Plm[j] = (DP(m) + irhoj1[j]) * (DP(m) + irhoj2[j]) * (DP(m) + irhoj3[j]);
-	  //g[0] += Plm[j] * Pm[j];
 	  g[0] += (DP(m) + irhoj1[j]) * (DP(m) + irhoj2[j]) * (DP(m) + irhoj3[j]) * Pm[j];
 	  // l = 1;
-	  //Plm[j] = (m - 0.5 + II * (rho[j] - rho[0])) * (DP(m) + II * (rho[j] - rho[2])) * (DP(m) + II * (rho[j] - rho[3]));
-	  //Plm[j] = (m - 0.5 + irhoj0[j]) * (DP(m) + irhoj2[j]) * (DP(m) + irhoj3[j]);
-	  //g[1] += Plm[j] * Pm[j];
 	  g[1] += (m - 0.5 + irhoj0[j]) * (DP(m) + irhoj2[j]) * (DP(m) + irhoj3[j]) * Pm[j];
 	  // l = 2;
-	  //Plm[j] = (m - 0.5 + II * (rho[j] - rho[0])) * (m - 0.5 + II * (rho[j] - rho[1])) * (DP(m) + II * (rho[j] - rho[3]));
-	  //Plm[j] = (m - 0.5 + irhoj0[j]) * (m - 0.5 + irhoj1[j]) * (DP(m) + irhoj3[j]);
-	  //g[2] += Plm[j] * Pm[j];
 	  g[2] += (m - 0.5 + irhoj0[j]) * (m - 0.5 + irhoj1[j]) * (DP(m) + irhoj3[j]) * Pm[j];
 	  // l = 3;
-	  //Plm[j] = (m - 0.5 + II * (rho[j] - rho[0])) * (m - 0.5 + II * (rho[j] - rho[1])) * (m - 0.5 + II * (rho[j] - rho[2]));
-	  //Plm[j] = (m - 0.5 + irhoj0[j]) * (m - 0.5 + irhoj1[j]) * (m - 0.5 + irhoj2[j]);
-	  //g[3] += Plm[j] * Pm[j];
 	  g[3] += (m - 0.5 + irhoj0[j]) * (m - 0.5 + irhoj1[j]) * (m - 0.5 + irhoj2[j]) * Pm[j];
 	}
 
-	/*
-	// Also unwrap j loop:
-	Pm[0] *= (m - 1.5 + irhoj0[0]) * (m - 1.5 + irhoj1[0]) * (m - 1.5 + irhoj2[0]) * (m - 1.5 + irhoj3[0])
-	  / ((DP(m) + irhoj0[0]) * (DP(m) + irhoj1[0]) * (DP(m) + irhoj2[0]) * (DP(m) + irhoj3[0]));
-	Pm[1] *= (m - 1.5 + irhoj0[1]) * (m - 1.5 + irhoj1[1]) * (m - 1.5 + irhoj2[1]) * (m - 1.5 + irhoj3[1])
-	  / ((DP(m) + irhoj0[1]) * (DP(m) + irhoj1[1]) * (DP(m) + irhoj2[1]) * (DP(m) + irhoj3[1]));
-	Pm[2] *= (m - 1.5 + irhoj0[2]) * (m - 1.5 + irhoj1[2]) * (m - 1.5 + irhoj2[2]) * (m - 1.5 + irhoj3[2])
-	  / ((DP(m) + irhoj0[2]) * (DP(m) + irhoj1[2]) * (DP(m) + irhoj2[2]) * (DP(m) + irhoj3[2]));
-	Pm[3] *= (m - 1.5 + irhoj0[3]) * (m - 1.5 + irhoj1[3]) * (m - 1.5 + irhoj2[3]) * (m - 1.5 + irhoj3[3])
-	  / ((DP(m) + irhoj0[3]) * (DP(m) + irhoj1[3]) * (DP(m) + irhoj2[3]) * (DP(m) + irhoj3[3]));
-
-	g[0] += ((DP(m) + irhoj1[0]) * (DP(m) + irhoj2[0]) * (DP(m) + irhoj3[0])) * Pm[0]
-	  + ((DP(m)) * (DP(m) + irhoj2[1]) * (DP(m) + irhoj3[1])) * Pm[1]
-	  + ((DP(m) + irhoj1[2]) * (DP(m)) * (DP(m) + irhoj3[0])) * Pm[2]
-	  + ((DP(m) + irhoj1[3]) * (DP(m) + irhoj2[3]) * (DP(m))) * Pm[3];
-
-	g[1] += ((m - 0.5) * (DP(m) + irhoj2[0]) * (DP(m) + irhoj3[0])) * Pm[0]
-	  + ((m - 0.5 + irhoj0[1]) * (DP(m) + irhoj2[1]) * (DP(m) + irhoj3[1])) * Pm[1]
-	  + ((m - 0.5 + irhoj0[2]) * (DP(m)) * (DP(m) + irhoj3[2])) * Pm[2]
-	  + ((m - 0.5 + irhoj0[3]) * (DP(m) + irhoj2[3]) * (DP(m))) * Pm[3];
-
-	g[2] += ((m - 0.5) * (m - 0.5 + irhoj1[0]) * (DP(m) + irhoj3[0])) * Pm[0]
-	  + ((m - 0.5 + irhoj0[1]) * (m - 0.5) * (DP(m) + irhoj3[1])) * Pm[1]
-	  + ((m - 0.5 + irhoj0[2]) * (m - 0.5 + irhoj1[2]) * (DP(m) + irhoj3[2])) * Pm[2]
-	  + ((m - 0.5 + irhoj0[3]) * (m - 0.5 + irhoj1[3]) * (DP(m))) * Pm[3];
-
-	g[3] += ((m - 0.5) * (m - 0.5 + irhoj1[0]) * (m - 0.5 + irhoj2[0])) * Pm[0]
-	  + ((m - 0.5 + irhoj0[1]) * (m - 0.5) * (m - 0.5 + irhoj2[1])) * Pm[1]
-	  + ((m - 0.5 + irhoj0[2]) * (m - 0.5 + irhoj1[2]) * (m - 0.5)) * Pm[2]
-	  + ((m - 0.5 + irhoj0[3]) * (m - 0.5 + irhoj1[3]) * (m - 0.5 + irhoj2[3])) * Pm[3];
-	*/
 	m++;
 
       } while (m < m_to_reach);
@@ -423,11 +337,6 @@ namespace ABACUS {
 
     } while (m < 10 || sum_norm_gl/old_sum_norm_gl - 1.0 > req_prec && m < 100000);
 
-    //cout << "g converged using " << m << " terms." << endl;
-
-    //cout << "|g1|^2 = " << prefactor * norm(g[0]) << "\t2 " << prefactor * norm(g[1]) << "\t3 " << prefactor * norm(g[2]) << "\t4 " << prefactor * norm(g[3]) << endl;
-
-    //return(prefactor * (norm(g[0]) + norm(g[1]) + norm(g[2]) + norm(g[3])));
     return(norm(g[0]) + norm(g[1]) + norm(g[2]) + norm(g[3]));
 
   }
@@ -436,13 +345,8 @@ namespace ABACUS {
   {
     Vect_DP args(2);
 
-    DP answer = exp(-8.0 * real(ln_Gamma (0.25)) - 9.0 * log(2.0) + 8.0 * Integrate_rec (Integrand_A, args, 0, 0.0, 50.0, req_prec, 16))/3.0;
-    //DP answer = exp(-8.0 * real(ln_Gamma (0.25)) - 21.0 * log(2.0) - 14.0 * log(PI) + 8.0 * Integrate_rec (Integrand_A, args, 0, 0.0, 100.0, req_prec, 16))/3.0;
-
-    //cout << "|A|^2 = " << exp(-2.0 * Integrate_rec (Integrand_A, args, 0, 0.0, 100.0, req_prec))
-    //   << "\t Gamma (1/4) = " << exp ((ln_Gamma(0.25))) << endl;
-    //cout << "NPB: " << exp(-8.0 * real(ln_Gamma (0.25)) - 9.0 * log(2.0) + 8.0 * Integrate_rec (Integrand_A, args, 0, 0.0, 50.0, req_prec))/3.0 << endl;
-    //cout << "c-m: " << exp(-8.0 * real(ln_Gamma (0.25)) - 21.0 * log(2.0) - 14.0 * log(PI) + 8.0 * Integrate_rec (Integrand_A, args, 0, 0.0, 50.0, req_prec))/3.0 << endl;
+    DP answer = exp(-8.0 * real(ln_Gamma (0.25)) - 9.0 * log(2.0)
+		    + 8.0 * Integrate_rec (Integrand_A, args, 0, 0.0, 50.0, req_prec, 16))/3.0;
 
     return(answer);
   }
@@ -459,18 +363,11 @@ namespace ABACUS {
 
     sum_I_integrals = 0.0;
     for (int i1 = 0; i1 < 3; ++i1) for (int i2 = i1+1; i2 < 4; ++i2) {
-      //cout << "rho_ij = " << rho[i1] - rho[i2] << "\tI(rho_ij) = " << Itable.Return_val (rho[i1] - rho[i2]) << "\t" << I_integral (rho[i1] - rho[i2], req_prec) << endl;
-      //sum_I_integrals += I_integral(rho[i1] - rho[i2], req_prec);
-      sum_I_integrals += Itable.Return_val (rho[i1] - rho[i2]);
-    }
-    //cout << "sum_I_integrals = " << sum_I_integrals << "\texp(-sum) = " << exp(-sum_I_integrals) << endl;
+	sum_I_integrals += Itable.Return_val (rho[i1] - rho[i2]);
+      }
 
-    //sum_norm_g = 0.0;
-    //for (int i = 0; i < 4; ++i) sum_norm_g += norm(g(i, rho));
     sum_norm_g = Sum_norm_gl (rho, req_prec);
 
-    //cout << "sum_norm_g = " << sum_norm_g << "\t sqrt() = " << sqrt(Wu * Wu - W * W) << endl;
-
     return(exp(-sum_I_integrals) * sum_norm_g/sqrt(Wu * Wu - W * W));
   }
 
@@ -483,9 +380,9 @@ namespace ABACUS {
 
     sum_I_integrals = 0.0;
     for (int i1 = 0; i1 < 3; ++i1) for (int i2 = i1+1; i2 < 4; ++i2) {
-      if (fabs(rho[i1] - rho[i2]) < 1.0e-10 || fabs(rho[i1] - rho[i2]) >= 1000.0) return(0.0); // safety here
-      sum_I_integrals += Itable.Return_val (rho[i1] - rho[i2]);
-    }
+	if (fabs(rho[i1] - rho[i2]) < 1.0e-10 || fabs(rho[i1] - rho[i2]) >= 1000.0) return(0.0); // safety here
+	sum_I_integrals += Itable.Return_val (rho[i1] - rho[i2]);
+      }
 
     sum_norm_g = Sum_norm_gl (rho, req_prec);
 
@@ -498,7 +395,8 @@ namespace ABACUS {
 
     DP argacos1, argacos2;
 
-    if (fabs(argacos1 = W/(twoPI * sin(0.5*K))) > 1.0 || fabs(argacos2 = (w - W)/(twoPI * sin (0.5 * fabs(k - K)))) > 1.0) return(false);
+    if (fabs(argacos1 = W/(twoPI * sin(0.5*K))) > 1.0
+	|| fabs(argacos2 = (w - W)/(twoPI * sin (0.5 * fabs(k - K)))) > 1.0) return(false);
 
     DP acos1 = acos(argacos1);
     DP acos2 = acos(argacos2);
@@ -516,7 +414,7 @@ namespace ABACUS {
       p[3] = 0.5 * (K-k) - PI - acos2;
     }
 
-    for (int i = 0; i < 4; ++i) if (p[i] < -PI || p[i] > 0.0) return(false); // { cout << k << "\t" << w << "\t" << K << "\t" << W << "\t" << p; ABACUSerror("p out of bounds"); }
+    for (int i = 0; i < 4; ++i) if (p[i] < -PI || p[i] > 0.0) return(false);
 
     return(true);
   }
@@ -527,11 +425,9 @@ namespace ABACUS {
 
     if (!Set_p_given_kwKW (args_to_G[0], args_to_G[1], args_to_G[2], args_to_G[3], p)) return(0.0);
 
-    DP answer = Jacobian_p3p4_KW (args_to_G[0], args_to_G[1], args_to_G[2], args_to_G[3]) * SF_contrib (p, args_to_G[4], Itable);
+    DP answer = Jacobian_p3p4_KW (args_to_G[0], args_to_G[1], args_to_G[2], args_to_G[3])
+      * SF_contrib (p, args_to_G[4], Itable);
 
-    //  cout << "kwKW = " << args_to_G[0] << " " << args_to_G[1] << " " << args_to_G[2] << " " << args_to_G[3] << "\tp = " << p << "Jac = " << Jacobian_p3p4_KW (args_to_G[0], args_to_G[1], args_to_G[2], args_to_G[3]) << "\tG = " << answer << endl;
-
-    //return(Jacobian_p3p4_KW (args_to_G[0], args_to_G[1], args_to_G[2], args_to_G[3]) * SF_contrib (p, 0.01 * args_to_G[4], Itable));
     return(answer);
   }
 
@@ -583,12 +479,11 @@ namespace ABACUS {
 
     if (!Set_p_given_kwKW (args_to_G[0], args_to_G[1], args_to_G[2], W, p)) return(0.0);
 
-    DP answer = J_fn (p, args_to_G[4], Itable) * sqrt(W * (2.0 * args_to_G[6] - W)
-						      /((args_to_G[8] - W * W) * (args_to_G[9] - pow(args_to_G[1] - W, 2.0))));
+    DP answer = J_fn (p, args_to_G[4], Itable)
+      * sqrt(W * (2.0 * args_to_G[6] - W)/((args_to_G[8] - W * W) * (args_to_G[9] - pow(args_to_G[1] - W, 2.0))));
 
     if (is_nan(answer)) {
       cerr << setprecision(10) << "args_to_G1_fn_mid = " << args_to_G << "G1 = " << answer << "\tPut to zero..." << endl;
-      //ABACUSerror("non !");
       answer = 0.0;
     }
     return(answer);
@@ -609,13 +504,12 @@ namespace ABACUS {
     if (!Set_p_given_kwKW (args_to_G[0], args_to_G[1], args_to_G[2], W, p)) return(0.0);
 
     DP answer = J_fn (p, args_to_G[4], Itable)
-      //* sqrt((args_to_G[7] * args_to_G[7] - W * W)/((args_to_G[8] - W * W) * (args_to_G[9] - pow(args_to_G[1] - W, 2.0))));
       * args_to_G[7] * sin(args_to_G[3]) /sqrt((args_to_G[8] - W * W) * (args_to_G[9] - pow(args_to_G[1] - W, 2.0)));
 
     if (is_nan(answer)) {
       cerr << setprecision(10) << "args_to_G2_fn_mid = " << args_to_G << "G2 = " << answer << endl;
-      cerr << W << "\t" << (args_to_G[7] * args_to_G[7] - W * W) << "\t" << (args_to_G[8] - W * W) << "\t" << (args_to_G[9] - pow(args_to_G[1] - W, 2.0)) << endl;
-      //ABACUSerror("non !");
+      cerr << W << "\t" << (args_to_G[7] * args_to_G[7] - W * W) << "\t" << (args_to_G[8] - W * W)
+	   << "\t" << (args_to_G[9] - pow(args_to_G[1] - W, 2.0)) << endl;
       answer = 0.0;
     }
     return(answer);
@@ -634,7 +528,8 @@ namespace ABACUS {
     DP Wu1 = args_to_G[6];
     DP Wu2 = args_to_G[7];
 
-    return(J_fn (p, args_to_G[8], Itable) * sqrt((W * W - Wmin * Wmin)/((Wu1 * Wu1 - W * W) * (Wu2 * Wu2 - (args_to_G[1] - W) * (args_to_G[1] - W)))));
+    return(J_fn (p, args_to_G[8], Itable)
+	   * sqrt((W * W - Wmin * Wmin)/((Wu1 * Wu1 - W * W) * (Wu2 * Wu2 - (args_to_G[1] - W) * (args_to_G[1] - W)))));
   }
 
   DP H_fn (Vect_DP args_to_H, I_table Itable)
@@ -657,8 +552,8 @@ namespace ABACUS {
     DP Wmin_used = Wmin (k, w, K);
     DP Wmax_used = Wmax (k, w, K);
 
-    return(Wmax_used > Wmin_used ? Integrate_rec_using_table (G_fn, args_to_G, 3, Itable, Wmin_used, Wmax_used, req_prec, max_rec) : 0.0);
-    //return(Riemann_Integrate_rec_using_table (G_fn, args_to_G, 3, Itable, 0.0, 10.0, 500));
+    return(Wmax_used > Wmin_used ?
+	   Integrate_rec_using_table (G_fn, args_to_G, 3, Itable, Wmin_used, Wmax_used, req_prec, max_rec) : 0.0);
   }
 
   DP H2_fn (Vect_DP args_to_H, I_table Itable)
@@ -741,8 +636,10 @@ namespace ABACUS {
     DP alpha_L2 = 0.0;
     DP alpha_U2 = acos(Wmid/Wmax_used);
 
-    answer += Integrate_rec_using_table (G1_fn_mid, args_to_G, 3, Itable, alpha_L1, alpha_U1, args_to_H[3], int(args_to_H[4]));
-    answer += Integrate_rec_using_table (G2_fn_mid, args_to_G, 3, Itable, alpha_L2, alpha_U2, args_to_H[3], int(args_to_H[4]));
+    answer += Integrate_rec_using_table (G1_fn_mid, args_to_G, 3, Itable, alpha_L1,
+					 alpha_U1, args_to_H[3], int(args_to_H[4]));
+    answer += Integrate_rec_using_table (G2_fn_mid, args_to_G, 3, Itable, alpha_L2,
+					 alpha_U2, args_to_H[3], int(args_to_H[4]));
 
     return(answer);
   }
@@ -790,8 +687,10 @@ namespace ABACUS {
     DP alpha_L2 = 0.0;
     DP alpha_U2 = acos(Wmid/Wmax_used);
 
-    answer += (Integrate_optimal_using_table (G1_fn_mid, args_to_G, 3, Itable, alpha_L1, alpha_U1, args_to_H[3], 1.0e-32, int(args_to_H[4]))).integ_est;
-    answer += (Integrate_optimal_using_table (G2_fn_mid, args_to_G, 3, Itable, alpha_L2, alpha_U2, args_to_H[3], 1.0e-32, int(args_to_H[4]))).integ_est;
+    answer += (Integrate_optimal_using_table (G1_fn_mid, args_to_G, 3, Itable, alpha_L1, alpha_U1,
+					      args_to_H[3], 1.0e-32, int(args_to_H[4]))).integ_est;
+    answer += (Integrate_optimal_using_table (G2_fn_mid, args_to_G, 3, Itable, alpha_L2, alpha_U2,
+					      args_to_H[3], 1.0e-32, int(args_to_H[4]))).integ_est;
 
     return(answer);
   }
@@ -823,10 +722,9 @@ namespace ABACUS {
     args_to_G[9] = DP(max_rec);
 
     return(Integrate_rec_using_table (G_fn_alt, args_to_G, 3, Itable, 0.0, acosh(Wmax_used/Wmin_used), req_prec, max_rec));
-    //return(Riemann_Integrate_rec_using_table (G_fn, args_to_G, 3, Itable, 0.0, 10.0, 500));
   }
 
-  //DP SF_4p_kwKW (DP k, DP omega, DP req_prec, int max_rec, I_table Itable)
+
   DP SF_4p_kwKW (Vect_DP args, I_table Itable)
   {
     // Translate:
@@ -842,21 +740,20 @@ namespace ABACUS {
     Vect_DP args_to_H(5);
     args_to_H[0] = k;  // shift of PI in Bougourzi:  because they do FM case.
     // We want AFM, so SF_4p (k, omega) is correctly obtained directly from the RHS of their formula.
-    DP w = 2.0 * omega;  // Rescale energies by factor 2 because of definitions of H_XXX (omega:  S.S;  w: 0.5 * sigma.sigma = 2 S.S)
+    DP w = 2.0 * omega;
+    // Rescale energies by factor 2 because of definitions of H_XXX (omega:  S.S;  w: 0.5 * sigma.sigma = 2 S.S)
     args_to_H[1] = w;
     args_to_H[2] = 0.0;  // this is K
     args_to_H[3] = ABACUS::max(1.0e-14, 0.01 * req_prec);
     args_to_H[4] = DP(max_rec);
 
     if (w > wmax_4p(k) || w < wmin_4p(k)) {
-      //cout << "w out of bounds in SF_4p: " << "wmin = " << PI * sin(k) << " wmax = " <<  4.0 * PI * sin(0.25 * k) << " w = " << w << endl;
       return(0.0);
     }
 
     DP prefactor = 2.0 * 0.5 * 4.0 * Compute_C4 (req_prec);  // 4 comes from using p1 > p2 & p3 > p4 instead of whole interval.
     // 2 from Jacobian |dw/domega|
     // 0.5 from S^{zz} = S^{pm}/2
-    //DP prefactor = 4.0;
 
     // Define the K integral domain
     Domain<DP> Kdomain;
@@ -897,26 +794,17 @@ namespace ABACUS {
       Kdomain.Exclude (K3em, K3ep);
     }
 
-    //cout << "Kdomain: " << endl << Kdomain << endl;
-
     // Use (K,W) -> (k-K, w-W) symmetry to restrict to K in [k/2, k/2+PI]
     Kdomain.Exclude (0.0, 0.5 * k);
     Kdomain.Exclude (0.5 * k + PI, twoPI);
-    //Kdomain.Exclude (0.5 * k, 0.5 * k + PI);
     prefactor *= 2.0;
 
-    //cout << "Kdomain restricted: " << endl << Kdomain << endl;
-
     DP answer = 0.0;
 
     for (int idom = 0; idom < Kdomain.Ndomains(); ++idom)
-      //answer += Integrate_rec_using_table (H_fn, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, max_rec);
-      //answer += Integrate_rec_using_table (H2_fn, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, max_rec);
-      //answer += Integrate_rec_using_table (H_fn_alt, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, max_rec);
-      answer += Integrate_rec_using_table (H_fn_mid, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, max_rec);
+      answer += Integrate_rec_using_table (H_fn_mid, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom),
+					   req_prec, max_rec);
 
-    //return(prefactor * Integrate_rec_using_table (H_fn, args_to_H, 2, Itable, 0.0, twoPI, req_prec, max_rec));
-    //return(prefactor * Riemann_Integrate_rec_using_table (H_fn, args_to_H, 2, Itable, 0.0, twoPI, 500));
     return (prefactor * answer);
   }
 
@@ -938,21 +826,21 @@ namespace ABACUS {
     Vect_DP args_to_H(5);
     args_to_H[0] = k;  // shift of PI in Bougourzi:  because they do FM case.
     // We want AFM, so SF_4p (k, omega) is correctly obtained directly from the RHS of their formula.
-    DP w = 2.0 * omega;  // Rescale energies by factor 2 because of definitions of H_XXX (omega:  S.S;  w: 0.5 * sigma.sigma = 2 S.S)
+    DP w = 2.0 * omega;
+    // Rescale energies by factor 2 because of definitions of H_XXX (omega:  S.S;  w: 0.5 * sigma.sigma = 2 S.S)
     args_to_H[1] = w;
     args_to_H[2] = 0.0;  // this is K
     args_to_H[3] = ABACUS::max(1.0e-14, 0.01 * req_prec);
     args_to_H[4] = DP(Npts_W);
 
     if (w > wmax_4p(k) || w < wmin_4p(k)) {
-      //cout << "w out of bounds in SF_4p: " << "wmin = " << PI * sin(k) << " wmax = " <<  4.0 * PI * sin(0.25 * k) << " w = " << w << endl;
       return(0.0);
     }
 
-    DP prefactor = 2.0 * 0.5 * 4.0 * Compute_C4 (req_prec);  // 4 comes from using p1 > p2 & p3 > p4 instead of whole interval.
+    DP prefactor = 2.0 * 0.5 * 4.0 * Compute_C4 (req_prec);
+    // 4 comes from using p1 > p2 & p3 > p4 instead of whole interval.
     // 2 from Jacobian |dw/domega|
     // 0.5 from S^{zz} = S^{pm}/2
-    //DP prefactor = 4.0;
 
     // Define the K integral domain
     Domain<DP> Kdomain;
@@ -993,28 +881,17 @@ namespace ABACUS {
       Kdomain.Exclude (K3em, K3ep);
     }
 
-    //cout << "Kdomain: " << endl << Kdomain << endl;
-
     // Use (K,W) -> (k-K, w-W) symmetry to restrict to K in [k, k+PI]
     Kdomain.Exclude (0.0, 0.5 * k);
     Kdomain.Exclude (0.5 * k + PI, twoPI);
-    //Kdomain.Exclude (0.5 * k, 0.5 * k + PI);
     prefactor *= 2.0;
 
-    //cout << "Kdomain restricted: " << endl << Kdomain << endl;
-
     DP answer = 0.0;
 
     for (int idom = 0; idom < Kdomain.Ndomains(); ++idom)
-      //answer += Integrate_rec_using_table (H_fn, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, max_rec);
-      //answer += Integrate_rec_using_table (H2_fn, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, max_rec);
-      //answer += Integrate_rec_using_table (H_fn_alt, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, max_rec);
-      //answer += Integrate_rec_using_table (H_fn_mid, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, max_rec);
-      //answer += Integrate_rec_using_table (H_fn_mid, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, 1);
-      answer += (Integrate_optimal_using_table (H_fn_mid_opt, args_to_H, 2, Itable, Kdomain.xmin(idom), Kdomain.xmax(idom), req_prec, 1.0e-32, Npts_K)).integ_est;
-
-    //return(prefactor * Integrate_rec_using_table (H_fn, args_to_H, 2, Itable, 0.0, twoPI, req_prec, max_rec));
-    //return(prefactor * Riemann_Integrate_rec_using_table (H_fn, args_to_H, 2, Itable, 0.0, twoPI, 500));
+      answer += (Integrate_optimal_using_table (H_fn_mid_opt, args_to_H, 2, Itable, Kdomain.xmin(idom),
+						Kdomain.xmax(idom), req_prec, 1.0e-32, Npts_K)).integ_est;
+
     return (prefactor * answer);
   }
 
@@ -1070,11 +947,9 @@ namespace ABACUS {
 
     Vect_DP args_to_SF_4p_kwKW = args;
     DP omegamin = 0.5 * wmin_4p (args[0]);
-    //DP omegamax = 0.5 * wmax_4p (args[0]);
 
     args_to_SF_4p_kwKW[1] = omegamin * cosh(args[1]);
 
-    //return((omegamax - omegamin) * sin(args[1]) * SF_4p_kwKW_opt (args_to_SF_4p_kwKW, Itable));
     return(omegamin * sinh(args[1]) * SF_4p_kwKW_opt (args_to_SF_4p_kwKW, Itable));
   }
 
@@ -1117,7 +992,8 @@ namespace ABACUS {
 
   /******************************************************************************************/
 
-  void Translate_raw_4p_data (DP k, int dim_w, const char* SFraw_Cstr, const char* SF_Cstr, const char* SFsrc_Cstr, I_table Itable)
+  void Translate_raw_4p_data (DP k, int dim_w, const char* SFraw_Cstr, const char* SF_Cstr,
+			      const char* SFsrc_Cstr, I_table Itable)
   {
     DP omegamin = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
     DP omegamax = 0.5 * wmax_4p (k);
@@ -1127,7 +1003,6 @@ namespace ABACUS {
     DP alpha_in_old = -1.0;
     DP SF_in_old = -1.0;
 
-    //int dim_w = int(pow(3.0, max_rec_w + 2));
     DP* alpha = new DP[dim_w];
     DP* omega = new DP[dim_w];
     DP* SF_4p_dat = new DP[dim_w];
@@ -1167,8 +1042,6 @@ namespace ABACUS {
 
     QuickSort (omega, index, 0, dim_w - 1);
 
-    //for (int j = 0; j < dim_w; ++j) cout << j << "\t" << omega[j] << "\t" << index[j] << endl;
-
     DP fixed_k_sr_2p = 0.0;
     DP fixed_k_sr_4p = 0.0;
     DP full_sr_2p = 0.0;
@@ -1199,9 +1072,12 @@ namespace ABACUS {
       full_sr_2p += Jac_dalpha * SF_2p_dat[index[i] ];
     }
 
-    Jac_dalpha = (omegamax - omegamin) * sin(alpha[index[dim_w - 2] ]) * 0.5 * (alpha[index[dim_w - 1] ] - alpha[index[dim_w - 3] ]);
-    fixed_k_sr_4p += Jac_dalpha * (omega[dim_w - 2] * SF_4p_dat[index[dim_w - 2] ] + omega[dim_w - 1] * SF_4p_dat[index[dim_w - 1] ]);
-    fixed_k_sr_2p += Jac_dalpha * (omega[dim_w - 2] * SF_2p_dat[index[dim_w - 2] ] + omega[dim_w - 1] * SF_2p_dat[index[dim_w - 1] ]);
+    Jac_dalpha = (omegamax - omegamin) * sin(alpha[index[dim_w - 2] ])
+      * 0.5 * (alpha[index[dim_w - 1] ] - alpha[index[dim_w - 3] ]);
+    fixed_k_sr_4p += Jac_dalpha * (omega[dim_w - 2] * SF_4p_dat[index[dim_w - 2] ]
+				   + omega[dim_w - 1] * SF_4p_dat[index[dim_w - 1] ]);
+    fixed_k_sr_2p += Jac_dalpha * (omega[dim_w - 2] * SF_2p_dat[index[dim_w - 2] ]
+				   + omega[dim_w - 1] * SF_2p_dat[index[dim_w - 1] ]);
     full_sr_4p += Jac_dalpha * (SF_4p_dat[index[dim_w - 2] ] + SF_4p_dat[index[dim_w - 1] ]);
     full_sr_2p += Jac_dalpha * (SF_2p_dat[index[dim_w - 2] ] + SF_2p_dat[index[dim_w - 1] ]);
 
@@ -1234,19 +1110,18 @@ namespace ABACUS {
     return;
   }
 
-  void Translate_raw_4p_data_cosh (DP k, int dim_w, const char* SFraw_Cstr, const char* SF_Cstr, const char* SFsrc_Cstr, I_table Itable)
+  void Translate_raw_4p_data_cosh (DP k, int dim_w, const char* SFraw_Cstr, const char* SF_Cstr,
+				   const char* SFsrc_Cstr, I_table Itable)
   {
     // Here, omega = omegamin * cosh(alpha)
 
     DP omegamin = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
-    //DP omegamax = 0.5 * wmax_4p (k);
 
     DP alpha_in;
     DP SF_in;
     DP alpha_in_old = -1.0;
     DP SF_in_old = -1.0;
 
-    //int dim_w = int(pow(3.0, max_rec_w + 2));
     DP* alpha = new DP[dim_w];
     DP* omega = new DP[dim_w];
     DP* SF_4p_dat = new DP[dim_w];
@@ -1267,11 +1142,9 @@ namespace ABACUS {
       SFraw >> alpha_in >> SF_in;
 
       alpha[i] = alpha_in;
-      //omega[i] = omegamin + (omegamax - omegamin) * (1.0 - cos(alpha_in));
       omega[i] = omegamin * cosh(alpha_in);
 
       // CAREFUL !!!  SF_in is S (k, w), and we want S (k, omega) = 2 S(k, w)
-      //SF_4p_dat[i] = 2.0 * SF_in/((omegamax - omegamin) * sin(alpha_in));
       SF_4p_dat[i] = 2.0 * SF_in/(omegamin * sinh(alpha_in));
 
       SF_2p_dat[i] = SF_2p (k, omega[i], Itable);  // This already is S(k, omega)
@@ -1288,13 +1161,10 @@ namespace ABACUS {
 
     QuickSort (omega, index, 0, dim_w - 1);
 
-    //for (int j = 0; j < dim_w; ++j) cout << j << "\t" << omega[j] << "\t" << index[j] << endl;
-
     DP fixed_k_sr_2p = 0.0;
     DP fixed_k_sr_4p = 0.0;
     DP full_sr_2p = 0.0;
     DP full_sr_4p = 0.0;
-    //DP Jac_dalpha = 0.0;  // This is domega = (omegamax - omegamin) sin alpha dalpha
     DP Jac_dalpha = 0.0;  // This is domega = omegamin sinh alpha dalpha
 
     ofstream SF;
@@ -1307,7 +1177,6 @@ namespace ABACUS {
     SF.close();
 
     // Compute first moment sum rule
-    //Jac_dalpha = (omegamax - omegamin) * sin(alpha[index[1] ]) * 0.5 * (alpha[index[2] ] - alpha[index[0] ]);
     Jac_dalpha = omegamin * sinh(alpha[index[1] ]) * 0.5 * (alpha[index[2] ] - alpha[index[0] ]);
     fixed_k_sr_4p += Jac_dalpha * (omega[0] * SF_4p_dat[index[0] ] + omega[1] * SF_4p_dat[index[1] ]);
     fixed_k_sr_2p += Jac_dalpha * (omega[0] * SF_2p_dat[index[0] ] + omega[1] * SF_2p_dat[index[1] ]);
@@ -1315,7 +1184,6 @@ namespace ABACUS {
     full_sr_2p += Jac_dalpha * (SF_2p_dat[index[0] ] + SF_2p_dat[index[1] ]);
 
     for (int i = 2; i < dim_w - 2; ++i) {
-      //Jac_dalpha = (omegamax - omegamin) * sin(alpha[index[i] ]) * 0.5 * (alpha[index[i + 1] ] - alpha[index[i - 1] ]);
       Jac_dalpha = omegamin * sinh(alpha[index[i] ]) * 0.5 * (alpha[index[i + 1] ] - alpha[index[i - 1] ]);
       fixed_k_sr_4p += Jac_dalpha * omega[i] * SF_4p_dat[index[i] ];
       fixed_k_sr_2p += Jac_dalpha * omega[i] * SF_2p_dat[index[i] ];
@@ -1323,10 +1191,11 @@ namespace ABACUS {
       full_sr_2p += Jac_dalpha * SF_2p_dat[index[i] ];
     }
 
-    //Jac_dalpha = (omegamax - omegamin) * sin(alpha[index[dim_w - 2] ]) * 0.5 * (alpha[index[dim_w - 1] ] - alpha[index[dim_w - 3] ]);
     Jac_dalpha = omegamin * sinh(alpha[index[dim_w - 2] ]) * 0.5 * (alpha[index[dim_w - 1] ] - alpha[index[dim_w - 3] ]);
-    fixed_k_sr_4p += Jac_dalpha * (omega[dim_w - 2] * SF_4p_dat[index[dim_w - 2] ] + omega[dim_w - 1] * SF_4p_dat[index[dim_w - 1] ]);
-    fixed_k_sr_2p += Jac_dalpha * (omega[dim_w - 2] * SF_2p_dat[index[dim_w - 2] ] + omega[dim_w - 1] * SF_2p_dat[index[dim_w - 1] ]);
+    fixed_k_sr_4p += Jac_dalpha * (omega[dim_w - 2] * SF_4p_dat[index[dim_w - 2] ]
+				   + omega[dim_w - 1] * SF_4p_dat[index[dim_w - 1] ]);
+    fixed_k_sr_2p += Jac_dalpha * (omega[dim_w - 2] * SF_2p_dat[index[dim_w - 2] ]
+				   + omega[dim_w - 1] * SF_2p_dat[index[dim_w - 1] ]);
     full_sr_4p += Jac_dalpha * (SF_4p_dat[index[dim_w - 2] ] + SF_4p_dat[index[dim_w - 1] ]);
     full_sr_2p += Jac_dalpha * (SF_2p_dat[index[dim_w - 2] ] + SF_2p_dat[index[dim_w - 1] ]);
 
@@ -1365,19 +1234,22 @@ namespace ABACUS {
   {
     stringstream SFraw_stringstream;
     string SFraw_string;
-    SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w << "_max_rec_" << max_rec << ".raw";
+    SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w
+		       << "_max_rec_" << max_rec << ".raw";
     SFraw_string = SFraw_stringstream.str();
     const char* SFraw_Cstr = SFraw_string.c_str();
 
     stringstream SF_stringstream;
     string SF_string;
-    SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w << "_max_rec_" << max_rec << ".dat";
+    SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w
+		    << "_max_rec_" << max_rec << ".dat";
     SF_string = SF_stringstream.str();
     const char* SF_Cstr = SF_string.c_str();
 
     stringstream SFsrc_stringstream;
     string SFsrc_string;
-    SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w << "_max_rec_" << max_rec << ".src";
+    SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_max_rec_w_" << max_rec_w
+		       << "_max_rec_" << max_rec << ".src";
     SFsrc_string = SFsrc_stringstream.str();
     const char* SFsrc_Cstr = SFsrc_string.c_str();
 
@@ -1386,16 +1258,13 @@ namespace ABACUS {
     ofstream SFsrc_outfile;
     SFsrc_outfile.open(SFsrc_Cstr, ofstream::app);
 
-    //DP omegamin_used = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
-    //DP omegamax_used = 0.5 * wmax_4p (k);
-
     Vect_DP args_to_SF(4);
     args_to_SF[0] = k;
     args_to_SF[1] = 0.0;  // integration variable
     args_to_SF[2] = req_prec;
     args_to_SF[3] = DP(max_rec);
 
-    //DP answer = Integrate_rec_using_table (SF_4p_kwKW, args_to_SF, 1, Itable, omegamin_used, omegamax_used, req_prec, max_rec, SF_outfile);
+
     // Version using omega = omegamin + (omegamax - omegamin) * (1-cos(alpha))
     DP answer = Integrate_rec_using_table (SF_4p_kwKW_alpha, args_to_SF, 1, Itable, 0.0, 0.5*PI, req_prec, max_rec_w, SFraw_outfile)/twoPI;
 
@@ -1405,7 +1274,6 @@ namespace ABACUS {
     SFsrc_outfile.close();
 
     // Translate raw data into SF_4p (k,omega) data
-
     Translate_raw_4p_data (k, int(pow(3.0, max_rec_w + 2)), SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
 
     return(answer);
@@ -1415,22 +1283,22 @@ namespace ABACUS {
   {
     stringstream SFraw_stringstream;
     string SFraw_string;
-    SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".raw";
-    //SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << "_ch.raw";
+    SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_"
+		       << Npts_K << "_" << Npts_W << ".raw";
     SFraw_string = SFraw_stringstream.str();
     const char* SFraw_Cstr = SFraw_string.c_str();
 
     stringstream SF_stringstream;
     string SF_string;
-    SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".dat";
-    //SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << "_ch.dat";
+    SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_"
+		    << Npts_K << "_" << Npts_W << ".dat";
     SF_string = SF_stringstream.str();
     const char* SF_Cstr = SF_string.c_str();
 
     stringstream SFsrc_stringstream;
     string SFsrc_string;
-    SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".src";
-    //SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << "_ch.src";
+    SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_"
+		       << Npts_K << "_" << Npts_W << ".src";
     SFsrc_string = SFsrc_stringstream.str();
     const char* SFsrc_Cstr = SFsrc_string.c_str();
 
@@ -1439,9 +1307,6 @@ namespace ABACUS {
     ofstream SFsrc_outfile;
     SFsrc_outfile.open(SFsrc_Cstr);
 
-    //DP omegamin_used = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
-    //DP omegamax_used = 0.5 * wmax_4p (k);
-
     Vect_DP args_to_SF(5);
     args_to_SF[0] = k;
     args_to_SF[1] = 0.0;  // integration variable
@@ -1450,9 +1315,11 @@ namespace ABACUS {
     args_to_SF[4] = DP(Npts_W);
 
     // Version using omega = omegamin + (omegamax - omegamin) * (1-cos(alpha))
-    Integral_result answer = Integrate_optimal_using_table (SF_4p_kwKW_alpha_opt, args_to_SF, 1, Itable, 0.0, 0.5*PI, req_prec, 1.0e-32, Npts_w, SFraw_outfile);
+    Integral_result answer = Integrate_optimal_using_table (SF_4p_kwKW_alpha_opt, args_to_SF, 1,
+							    Itable, 0.0, 0.5*PI, req_prec, 1.0e-32, Npts_w, SFraw_outfile);
     // Version using omega = omegamin * cosh(alpha)
-    //Integral_result answer = Integrate_optimal_using_table (SF_4p_kwKW_cosh_alpha_opt, args_to_SF, 1, Itable, 0.0, acosh(wmax_4p(k)/wmin_4p(k)), req_prec, 1.0e-32, Npts_w, SFraw_outfile);
+    //Integral_result answer = Integrate_optimal_using_table (SF_4p_kwKW_cosh_alpha_opt, args_to_SF, 1, Itable, 0.0,
+    //acosh(wmax_4p(k)/wmin_4p(k)), req_prec, 1.0e-32, Npts_w, SFraw_outfile);
     answer.integ_est /= twoPI;
     answer.abs_prec /= twoPI;
 
@@ -1462,9 +1329,7 @@ namespace ABACUS {
     SFsrc_outfile.close();
 
     // Translate raw data into SF_4p (k,omega) data
-
     Translate_raw_4p_data (k, answer.n_vals, SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
-    //Translate_raw_4p_data_cosh (k, answer.n_vals, SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
 
     return(answer);
   }
@@ -1578,7 +1443,8 @@ namespace ABACUS {
 
     stringstream SF_stringstream;
     string SF_string;
-    SF_stringstream << "SF_4p_N_" << N << "_Nw_" << Nomega << "_wmax_" << omegamax << "_prec_" << req_prec << "_max_rec_" << max_rec << ".dat";
+    SF_stringstream << "SF_4p_N_" << N << "_Nw_" << Nomega << "_wmax_" << omegamax << "_prec_" << req_prec
+		    << "_max_rec_" << max_rec << ".dat";
     SF_string = SF_stringstream.str();
     const char* SF_Cstr = SF_string.c_str();
 
@@ -1623,7 +1489,7 @@ namespace ABACUS {
     stringstream SRC_stringstream;
     string SRC_string;
     SRC_stringstream << "SF_4p_N_" << N << "_Nw_" << Nomega << "_wmax_" << omegamax << "_prec_" << req_prec
-		    << "_max_rec_" << max_rec << ".src";
+		     << "_max_rec_" << max_rec << ".src";
     SRC_string = SRC_stringstream.str();
     const char* SRC_Cstr = SRC_string.c_str();
 
@@ -1638,7 +1504,7 @@ namespace ABACUS {
     stringstream SR1_stringstream;
     string SR1_string;
     SR1_stringstream << "SF_4p_N_" << N << "_Nw_" << Nomega << "_wmax_" << omegamax << "_prec_" << req_prec
-		    << "_max_rec_" << max_rec << ".sr1";
+		     << "_max_rec_" << max_rec << ".sr1";
     SR1_string = SR1_stringstream.str();
     const char* SR1_Cstr = SR1_string.c_str();
 
@@ -1714,7 +1580,7 @@ namespace ABACUS {
     stringstream SRC_stringstream;
     string SRC_string;
     SRC_stringstream << "SF_4p_N_" << N << "_Nw_" << Nomega << "_wmax_" << omegamax << "_prec_" << req_prec
-		    << "_Npts_K_" << Npts_K << "_Npts_W_" << Npts_W << ".src";
+		     << "_Npts_K_" << Npts_K << "_Npts_W_" << Npts_W << ".src";
     SRC_string = SRC_stringstream.str();
     const char* SRC_Cstr = SRC_string.c_str();
 
@@ -1729,7 +1595,7 @@ namespace ABACUS {
     stringstream SR1_stringstream;
     string SR1_string;
     SR1_stringstream << "SF_4p_N_" << N << "_Nw_" << Nomega << "_wmax_" << omegamax << "_prec_" << req_prec
-		    << "_Npts_K_" << Npts_K << "_Npts_W_" << Npts_W << ".sr1";
+		     << "_Npts_K_" << Npts_K << "_Npts_W_" << Npts_W << ".sr1";
     SR1_string = SR1_stringstream.str();
     const char* SR1_Cstr = SR1_string.c_str();
 
@@ -1748,7 +1614,4 @@ namespace ABACUS {
   }
 
 
-
-
-
 } // namespace ABACUS

src/XXX_VOA/XXX_VOA_par.cc

@@ -26,22 +26,22 @@ namespace ABACUS {
   {
     stringstream SFraw_stringstream;
     string SFraw_string;
-    SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".raw";
-    //SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << "_ch.raw";
+    SFraw_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K
+		       << "_" << Npts_W << ".raw";
     SFraw_string = SFraw_stringstream.str();
     const char* SFraw_Cstr = SFraw_string.c_str();
 
     stringstream SF_stringstream;
     string SF_string;
-    SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".dat";
-    //SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << "_ch.dat";
+    SF_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K
+		    << "_" << Npts_W << ".dat";
     SF_string = SF_stringstream.str();
     const char* SF_Cstr = SF_string.c_str();
 
     stringstream SFsrc_stringstream;
     string SFsrc_string;
-    SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << ".src";
-    //SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K << "_" << Npts_W << "_ch.src";
+    SFsrc_stringstream << "SF_4p_k_" << k << "_prec_" << req_prec << "_Npts_" << Npts_w << "_" << Npts_K
+		       << "_" << Npts_W << ".src";
     SFsrc_string = SFsrc_stringstream.str();
     const char* SFsrc_Cstr = SFsrc_string.c_str();
 
@@ -50,8 +50,6 @@ namespace ABACUS {
     ofstream SFsrc_outfile;
     SFsrc_outfile.open(SFsrc_Cstr);
 
-    //DP omegamin_used = 0.5 * wmin_4p (k); // Correct for factor of 2 in E between me & Bougourzi
-    //DP omegamax_used = 0.5 * wmax_4p (k);
 
     Vect_DP args_to_SF(5);
     args_to_SF[0] = k;
@@ -73,7 +71,6 @@ namespace ABACUS {
     SFsrc_outfile.close();
 
     // Translate raw data into SF_4p (k,omega) data
-
     Translate_raw_4p_data (k, answer.n_vals, SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
     //Translate_raw_4p_data_cosh (k, answer.n_vals, SFraw_Cstr, SF_Cstr, SFsrc_Cstr, Itable);
 

src/XXX_VOA/XXX_h0_v2.cc

@@ -198,8 +198,6 @@ namespace ABACUS {
 	      omega = -0.5 * PI * (sinp0 + sinp1 + sinp2 + sin(p[3]));
 	      iomega = int(omega * Npts_o/omegamax);
 
-	      //cout << ik << "\t" << iomega << endl;
-
 	      J_fn_cont = J_fn (p, req_prec, Itable);
 	      sum_J_fn += (ik == Npts_p ? 1.0 : 2.0) * J_fn_cont;
 

src/XXZ_VOA/XXZ_VOA.cc

@@ -67,7 +67,6 @@ namespace ABACUS {
 
     return(answer);
 
-    //return(sinh(args[0]*(1.0 + args[2])) * sinh(args[0]) * cos(4.0 * args[0] * args[1])/(args[0] * sinh(args[0] * args[2]) * pow(cosh(args[0]), 2.0)));
   }
 
   DP I_xi_11_integral (DP xi, DP rho, DP req_prec, int max_nr_pts, DP t1bar)
@@ -106,8 +105,8 @@ namespace ABACUS {
   }
 
   /*
-  inline DP Integrand_xi_2 (Vect_DP args)
-  {
+    inline DP Integrand_xi_2 (Vect_DP args)
+    {
     // This version is used for rho <= 1
 
     // args[0] corresponds to t, args[1] to rho, args[2] to xi
@@ -116,30 +115,34 @@ namespace ABACUS {
 
     if (args[0] * args[2] <= 1.0) {
 
-      if (args[0] <= 1.0) {
-	answer = sinh(args[0] * (args[2] + 1.0)) * pow(sin(2.0 * args[0] * args[1]), 2.0)
-	  /(args[0] * sinh(args[2] * args[0]) * sinh(args[0]) * pow(cosh(args[0]), 2.0));
-      }
+    if (args[0] <= 1.0) {
+    answer = sinh(args[0] * (args[2] + 1.0)) * pow(sin(2.0 * args[0] * args[1]), 2.0)
+    /(args[0] * sinh(args[2] * args[0]) * sinh(args[0]) * pow(cosh(args[0]), 2.0));
+    }
 
-      else if (args[0] >= 1.0) {
-	DP expm2t = exp(-2.0 * args[0]);
-	DP expm2txi = exp(-2.0*args[0]*args[2]);
-	//answer = 8.0 * expm2t * pow(sin(2.0 * args[0] * args[1]), 2.0)/(args[0] * (1.0 - expm2t) * (1.0 + expm2t) * (1.0 + expm2t));
-	answer = 8.0 * (1.0 - expm2t*expm2txi) * expm2t *
-	  pow(sin(2.0 * args[0] * args[1]), 2.0)/(args[0] * (1.0 - expm2txi) * (1.0 - expm2t) * (1.0 + expm2t) * (1.0 + expm2t));
-      }
+    else if (args[0] >= 1.0) {
+    DP expm2t = exp(-2.0 * args[0]);
+    DP expm2txi = exp(-2.0*args[0]*args[2]);
+    //answer = 8.0 * expm2t * pow(sin(2.0 * args[0] * args[1]), 2.0)
+    /(args[0] * (1.0 - expm2t) * (1.0 + expm2t) * (1.0 + expm2t));
+    answer = 8.0 * (1.0 - expm2t*expm2txi) * expm2t *
+    pow(sin(2.0 * args[0] * args[1]), 2.0)/(args[0] * (1.0 - expm2txi) * (1.0 - expm2t)
+    * (1.0 + expm2t) * (1.0 + expm2t));
+    }
 
     DP expm2t = exp(-2.0 * args[0]);
     DP expm2txi = exp(-2.0*args[0]*args[2]);
-    //answer = 8.0 * expm2t * pow(sin(2.0 * args[0] * args[1]), 2.0)/(args[0] * (1.0 - expm2t) * (1.0 + expm2t) * (1.0 + expm2t));
+    //answer = 8.0 * expm2t * pow(sin(2.0 * args[0] * args[1]), 2.0)
+    /(args[0] * (1.0 - expm2t) * (1.0 + expm2t) * (1.0 + expm2t));
     answer = 8.0 * (1.0 - expm2t*expm2txi) * expm2t *
-      pow(sin(2.0 * args[0] * args[1]), 2.0)/(args[0] * (1.0 - expm2txi) * (1.0 - expm2t) * (1.0 + expm2t) * (1.0 + expm2t));
+    pow(sin(2.0 * args[0] * args[1]), 2.0)/(args[0] * (1.0 - expm2txi) * (1.0 - expm2t)
+    * (1.0 + expm2t) * (1.0 + expm2t));
 
     return(answer);
 
-      ... NOT USED
+    ... NOT USED
 
-  }
+    }
   */
 
   inline DP Integrand_xi_22 (Vect_DP args)
@@ -153,7 +156,8 @@ namespace ABACUS {
     else if (args[0] >= 1.0) {
       DP expm2t = exp(-2.0 * args[0]);
       DP expm2txi = exp(-2.0*args[0]*args[2]);
-      answer = 4.0 * expm2t * (1.0 + expm2txi) * pow(sin(2.0 * args[0] * args[1]), 2.0)/(args[0] * (1.0 - expm2txi) * (1.0 + expm2t) * (1.0 + expm2t));
+      answer = 4.0 * expm2t * (1.0 + expm2txi) * pow(sin(2.0 * args[0] * args[1]), 2.0)
+	/(args[0] * (1.0 - expm2txi) * (1.0 + expm2t) * (1.0 + expm2t));
     }
     return(answer);
   }
@@ -170,9 +174,6 @@ namespace ABACUS {
 
     DP answer = 0.0;
 
-    //if (rho_used <= 1.0) answer = (Integrate_optimal (Integrand_xi_2, args, 0, 0.0, tinf, req_prec, req_prec, max_nr_pts)).integ_est;
-
-    //else
     answer = PI * rho + log(0.5 * (1.0 + exp(-2.0 * PI * rho_used))) // This is I^{(21)}
       + (Integrate_optimal (Integrand_xi_22, args, 0, 0.0, tinf, req_prec, req_prec, max_nr_pts)).integ_est;
 
@@ -201,22 +202,20 @@ namespace ABACUS {
   {
     // Careful !  This is S(k, omega) = S (k, w) |dw/domega| = 2 S(k, w)
 
-    DP w = 2.0 * omega;  // Rescale energies by factor 2 because of definitions of H_XXX (omega:  S.S;  w: 0.5 * sigma.sigma = 2 S.S)
+    DP w = 2.0 * omega;
+    // Rescale energies by factor 2 because of definitions of H_XXX (omega:  S.S;  w: 0.5 * sigma.sigma = 2 S.S)
 
     DP vF = Fermi_velocity_XXZ_h0 (Delta); // in units of omega
 
-    //DP wu = twoPI * sin(0.5 * k);
     DP wu = 4.0 * vF * sin(0.5 * k);
-    //DP wl = PI * fabs(sin(k));
     DP wl = 2.0 * vF * fabs(sin(k));
 
     DP rho = acosh(sqrt((wu * wu - wl * wl)/(w * w - wl * wl)))/PI;
     DP xi = PI/acos(Delta) - 1.0;
     // Factor of 2:  return S(k, omega), not S(k, w)
-    // 0.25 factor:  1/4 * 2 * 1/2, where 1/4 comes from Bougourzi, 2 is the Jacobian |dw/domega| and 1/2 is S^{zz} = 1/2 * S^{+-}
-    //return(w < wu && w > wl ? 2.0 * 0.5 * exp(-Itable.Return_val (acosh(sqrt((wu * wu - wl * wl)/(w * w - wl * wl)))/PI))/sqrt(wu * wu - w * w) : 0.0);
+    // 0.25 factor:  1/4 * 2 * 1/2, where 1/4 comes from Bougourzi, 2 is the Jacobian |dw/domega|
+    // and 1/2 is S^{zz} = 1/2 * S^{+-}
     DP expmtwoPIrhooverxi = exp(-twoPI * rho/xi);
-    //return(w < wu && w > wl ? 2.0 * exp(-Itable.Return_val (rho))/(sqrt(wu * wu - w * w) * (cosh(twoPI * rho/xi) + cos(PI/xi))) : 0.0);
     return(w < wu && w > wl ? 2.0 * pow(1.0 + 1.0/xi, 2.0) * exp(-Itable.Return_val (rho))
 	   * expmtwoPIrhooverxi/(sqrt(wu * wu - w * w)
 				 * (0.5 * (1.0 + expmtwoPIrhooverxi * expmtwoPIrhooverxi) + expmtwoPIrhooverxi * cos(PI/xi)))
@@ -236,30 +235,6 @@ namespace ABACUS {
 
     return(Szz_XXZ_h0_2spinons (Delta, args[0], args[1], Itable));
 
-    /*
-
-    // This uses args[0] = k, args[1] = w, args[2] = xi
-
-    DP Delta = cos(PI/(args[2] + 1.0));
-
-    DP vF = Fermi_velocity_XXZ_h0 (Delta); // in units of omega
-
-    //DP wu = twoPI * sin(0.5 * k);
-    DP wu = 4.0 * vF * sin(0.5 * args[0]);
-    //DP wl = PI * fabs(sin(k));
-    DP wl = 2.0 * vF * fabs(sin(args[0]));
-
-    DP rho = acosh(sqrt((wu * wu - wl * wl)/(args[1] * args[1] - wl * wl)))/PI;
-    DP expmtwoPIrhooverxi = exp(-twoPI * rho/args[2]);
-
-    // 0.5 factor:  1 from Bougourzi, and 1/2 is S^{zz} = 1/2 * S^{+-}
-    return(args[1] < wu && args[1] > wl ?
-	   //0.5 * exp(-Itable.Return_val (acosh(sqrt((wu * wu - wl * wl)/(args[1] * args[1] - wl * wl)))/PI))/sqrt(wu * wu - args[1] * args[1]) : 0.0);
-	   pow(1.0 + 1.0/args[2], 2.0) * exp(-Itable.Return_val (rho)) * expmtwoPIrhooverxi
-	   /(sqrt(wu * wu - args[1] * args[1])
-	     * (0.5 * (1.0 + expmtwoPIrhooverxi * expmtwoPIrhooverxi) + expmtwoPIrhooverxi * cos(PI/args[2]))) : 0.0);
-
-    */
   }
 
   DP Szz_XXZ_h0_2spinons_alt (Vect_DP args, Integral_table Itable)
@@ -283,30 +258,6 @@ namespace ABACUS {
     DP Jacobian = sqrt(omega * omega - omegalow * omegalow);
 
     return(Jacobian * Szz_XXZ_h0_2spinons (Delta, args[0], omega, Itable));
-
-    /*
-    //DP wu = twoPI * sin(0.5 * k);
-    DP wu = 4.0 * vF * sin(0.5 * args[0]);
-    //DP wl = PI * fabs(sin(k));
-    DP wl = 2.0 * vF * fabs(sin(args[0]));
-
-    //DP w = wu * cos(args[1]);
-    //DP factor = 1.0;
-    DP w = wl * cosh(args[1]);
-
-    if (w >= wu || w <= wl) return(0.0);
-
-    DP factor = sqrt((w * w - wl * wl)/(wu * wu - w * w));
-
-    DP rho = acosh(sqrt((wu * wu - wl * wl)/(w * w - wl * wl)))/PI;
-    DP expmtwoPIrhooverxi = exp(-twoPI * rho/args[2]);
-
-    // 0.5 factor:  1 from Bougourzi, and 1/2 is S^{zz} = 1/2 * S^{+-}
-    //return(factor * 0.5 * exp(-Itable.Return_val (acosh(sqrt((wu * wu - wl * wl)/(w * w - wl * wl)))/PI)));
-    return(pow(1.0 + 1.0/args[2], 2.0) * factor
-	   * exp(-Itable.Return_val (rho)) * expmtwoPIrhooverxi/(0.5 * (1.0 + expmtwoPIrhooverxi * expmtwoPIrhooverxi) + expmtwoPIrhooverxi * cos(PI/args[2])));
-	   */
-
   }
 
   DP Szz_XXZ_h0_2spinons_omega (Vect_DP args, Integral_table Itable)
@@ -450,7 +401,8 @@ namespace ABACUS {
     args[0] = 0.0;
     args[1] = xi;
 
-    return(-0.25 * sqrt(1.0 - Delta * Delta) * (2.0/acos(Delta)) * 2.0 * (Integrate_optimal (Integrand_GSE_XXZ_h0, args, 0, 0.0, tinf, req_prec, req_prec, max_nr_pts).integ_est));
+    return(-0.25 * sqrt(1.0 - Delta * Delta) * (2.0/acos(Delta)) * 2.0
+	   * (Integrate_optimal (Integrand_GSE_XXZ_h0, args, 0, 0.0, tinf, req_prec, req_prec, max_nr_pts).integ_est));
   }
 
   DP Integrand_2_fSR_XXZ_h0 (Vect_DP args)
@@ -474,8 +426,10 @@ namespace ABACUS {
     args[0] = 0.0;
     args[1] = xi;
 
-    DP Xavg = -(0.25/(acos(Delta) * sqrt(1.0 - Delta * Delta))) * 2.0 * (Integrate_optimal (Integrand_GSE_XXZ_h0, args, 0, 0.0, tinf, req_prec, req_prec, max_nr_pts).integ_est)
-      + 0.25 * (Delta/pow(acos(Delta), 2.0)) * 2.0 * (Integrate_optimal (Integrand_2_fSR_XXZ_h0, args, 0, 0.0, tinf, req_prec, req_prec, max_nr_pts).integ_est);
+    DP Xavg = -(0.25/(acos(Delta) * sqrt(1.0 - Delta * Delta))) * 2.0
+      * (Integrate_optimal (Integrand_GSE_XXZ_h0, args, 0, 0.0, tinf, req_prec, req_prec, max_nr_pts).integ_est)
+      + 0.25 * (Delta/pow(acos(Delta), 2.0)) * 2.0
+      * (Integrate_optimal (Integrand_2_fSR_XXZ_h0, args, 0, 0.0, tinf, req_prec, req_prec, max_nr_pts).integ_est);
 
     return (-2.0 * (1.0 - cos(k)) * Xavg);
   }
@@ -495,7 +449,9 @@ namespace ABACUS {
     args_to_SF_2p[2] = PI/acos(Delta) - 1.0;
     args_to_SF_2p[3] = ABACUS::max(1.0e-14, 0.01 * req_prec);
 
-    return(((Integrate_optimal_using_table (Szz_XXZ_h0_2spinons_omega, args_to_SF_2p, 1, Itable, omegalow, omegaup, req_prec, req_prec, max_nr_pts)).integ_est/twoPI)/Fixed_k_sumrule_omega_Szz_XXZ_h0(Delta, k, req_prec, max_nr_pts));
+    return(((Integrate_optimal_using_table (Szz_XXZ_h0_2spinons_omega, args_to_SF_2p, 1, Itable,
+					    omegalow, omegaup, req_prec, req_prec, max_nr_pts)).integ_est/twoPI)
+	   /Fixed_k_sumrule_omega_Szz_XXZ_h0(Delta, k, req_prec, max_nr_pts));
   }
 
   DP Szz_XXZ_h0_2spinons_check_fixed_k_Szz_sumrule_alt (DP Delta, DP k, DP req_prec, int max_nr_pts, Integral_table Itable)
@@ -513,7 +469,9 @@ namespace ABACUS {
     args_to_SF_2p[2] = PI/acos(Delta) - 1.0;
     args_to_SF_2p[3] = ABACUS::max(1.0e-14, 0.01 * req_prec);
 
-    return(((Integrate_optimal_using_table (Szz_XXZ_h0_2spinons_omega_alt, args_to_SF_2p, 1, Itable, 0.0, acosh(omegaup/omegalow), req_prec, req_prec, max_nr_pts)).integ_est/twoPI)/Fixed_k_sumrule_omega_Szz_XXZ_h0(Delta, k, req_prec, max_nr_pts));
+    return(((Integrate_optimal_using_table (Szz_XXZ_h0_2spinons_omega_alt, args_to_SF_2p, 1, Itable,
+					    0.0, acosh(omegaup/omegalow), req_prec, req_prec, max_nr_pts)).integ_est/twoPI)
+	   /Fixed_k_sumrule_omega_Szz_XXZ_h0(Delta, k, req_prec, max_nr_pts));
   }
 
 
@@ -527,7 +485,8 @@ namespace ABACUS {
 
     stringstream SF_stringstream;
     string SF_string;
-    SF_stringstream << "Szz_XXZ_h0_2spinons_Delta_" << Delta << "_N_" << N << "_Nom_" << Nomega << "_ommax_" << omegamax << ".dat";
+    SF_stringstream << "Szz_XXZ_h0_2spinons_Delta_" << Delta << "_N_" << N << "_Nom_" << Nomega
+		    << "_ommax_" << omegamax << ".dat";
     SF_string = SF_stringstream.str();
     const char* SF_Cstr = SF_string.c_str();
 
@@ -571,7 +530,8 @@ namespace ABACUS {
 
     stringstream SRC_stringstream;
     string SRC_string;
-    SRC_stringstream << "Szz_XXZ_h0_2spinons_Delta_" << Delta << "_N_" << N << "_Nom_" << Nomega << "_ommax_" << omegamax << ".src";
+    SRC_stringstream << "Szz_XXZ_h0_2spinons_Delta_" << Delta << "_N_" << N << "_Nom_" << Nomega
+		     << "_ommax_" << omegamax << ".src";
     SRC_string = SRC_stringstream.str();
     const char* SRC_Cstr = SRC_string.c_str();
 
@@ -585,7 +545,8 @@ namespace ABACUS {
 
     stringstream SR1_stringstream;
     string SR1_string;
-    SR1_stringstream << "Szz_XXZ_h0_2spinons_Delta_" << Delta << "_N_" << N << "_Nom_" << Nomega << "_ommax_" << omegamax << ".sr1";
+    SR1_stringstream << "Szz_XXZ_h0_2spinons_Delta_" << Delta << "_N_" << N << "_Nom_" << Nomega
+		     << "_ommax_" << omegamax << ".sr1";
     SR1_string = SR1_stringstream.str();
     const char* SR1_Cstr = SR1_string.c_str();
 
@@ -606,9 +567,7 @@ namespace ABACUS {
 
     for (int iK = 1; iK < dim_K; ++iK)
       SR1_outfile << iK << "\t" << K[iK] << "\t" << sr1[iK] * omegamax/(twoPI * Nomega)
-	//<< "\t" << -((1.0 - cos(K[iK])) * 2.0 * (0.25 - log(2.0))/3.0) << "\t"
 		  << "\t" << (1.0 - cos(K[iK])) * sr1factor << "\t"
-	//<< -sr1[iK] * omegamax/(twoPI * Nomega)/((1.0 - cos(K[iK])) * 2.0 * (0.25 - log(2.0))/3.0) << endl;
 		  << sr1[iK] * omegamax/(twoPI * Nomega)/((1.0 - cos(K[iK])) * sr1factor) << endl;
 
     SR1_outfile.close();
@@ -636,7 +595,9 @@ namespace ABACUS {
     DP omegaup = 2.0 * vF * sin(0.5 * K);
     DP omegalow = vF * fabs(sin(K));
 
-    for (int iw = 0; iw < Nomega; ++iw) omega[iw] = 0.99 * omegalow + (1.01 * omegaup - 0.99 * omegalow) * (iw + 0.5)/Nomega; // factor of 1.01: just to have zeroes on either side of continuum.
+    for (int iw = 0; iw < Nomega; ++iw)
+      omega[iw] = 0.99 * omegalow + (1.01 * omegaup - 0.99 * omegalow) * (iw + 0.5)/Nomega;
+    // factor of 1.01: just to have zeroes on either side of continuum.
 
     DP* SF_XXZ_2p_dat = new DP[Nomega];
 
@@ -658,41 +619,8 @@ namespace ABACUS {
 
     SF_outfile.close();
 
-    // Do sum rule files:
-    /*
-      NOT ACCURATE SINCE WE'RE PLOTTING SOMEWHAT OUTSIDE OF CONTINUUM AS WELL (to get nice figures)
-    stringstream SR1_stringstream;
-    string SR1_string;
-    SR1_stringstream << "Szz_XXZ_h0_2spinons_Delta_" << Delta << "_Kover2PI_" << Kover2PI
-		     << "_Nom_" << Nomega << ".sr1";
-    SR1_string = SR1_stringstream.str();
-    const char* SR1_Cstr = SR1_string.c_str();
-
-    ofstream SR1_outfile;
-    SR1_outfile.open(SR1_Cstr);
-    SR1_outfile.precision(14);
-
-    // Figure out the f-sumrule factor:
-    int Nfsr = 600;
-    int Mfsr = 300;
-    DP Xavg = 0.0;
-    if (Delta > 0.0) Xavg = X_avg ('x', Delta, Nfsr, Mfsr);
-    else Xavg = 0.0;
-
-    DP sr1factor = 1.0;
-    if (Delta > 0.0) sr1factor = -2.0 * Xavg/Nfsr;
-    else sr1factor = 1.0;
-
-    SR1_outfile << Kover2PI << "\t" << sr1 * (omegaup - omegalow)/(twoPI * Nomega)
-		<< "\t" << (1.0 - cos(K)) * sr1factor << "\t"
-		<< sr1 * (omegaup - omegalow)/(twoPI * Nomega)/((1.0 - cos(K)) * sr1factor) << endl;
-
-    SR1_outfile.close();
-    */
-
     return;
   }
 
 
-
 } // namespace ABACUS

src/YOUNG/Young_Tableau.cc

@@ -20,7 +20,8 @@ using namespace std;
 namespace ABACUS {
 
   Young_Tableau::Young_Tableau () : Nrows(0), Ncols(0), Row_L(0), Col_L(0), id(0LL), maxid(0LL),
-				    map(new long long int [1]), map_computed(false), idnr_reached(0LL), nboxes_reached(-1),
+				    map(new long long int [1]), map_computed(false),
+				    idnr_reached(0LL), nboxes_reached(-1),
 				    dimchoose(0), choose_table(0LL)
   {}
 
@@ -47,32 +48,11 @@ namespace ABACUS {
       }
 
     // Fill map with zeros:
-    for (int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i) map[i] = 0LL;
+    for (int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i)
+      map[i] = 0LL;
 
   }
-  /*  SEGFAULTS
-  Young_Tableau::Young_Tableau (int Nr, int Nc, long long int idnr)
-    : Nrows(Nr), Ncols(Nc), Row_L(new int[Nrows]), Col_L(new int[Ncols]), id(idnr),
-      maxid(choose_lli(Nr + Nc, Nc) - 1LL),
-      map(new long long int [YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1]),
-      map_computed(false), idnr_reached(0LL), nboxes_reached(-1),
-      dimchoose (ABACUS::min(Nr, Nc) + 1),
-      choose_table(new long long int[(Nr + Nc + 1) * dimchoose])
-  {
-    // Constructs Young tableau of given idnr, if consistent with Nr, Nc.
-
-    // Construct the choose_table
-    for (int cti = 0; cti < Nr + Nc + 1; ++cti)
-      for (int ctj = 0; ctj < dimchoose; ++ctj) {
-	if (cti >= ctj) choose_table[dimchoose * cti + ctj] = choose_lli(cti, ctj);
-	else choose_table[dimchoose * cti + ctj] = 0LL;
-      }
-
-    for (int i = 0; i < YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1; ++i) map[i] = 0LL;
 
-    (*this).Set_to_id(idnr);
-  }
-  */
   Young_Tableau::Young_Tableau (const Young_Tableau& RefTableau)  // copy constructor
     : Nrows(RefTableau.Nrows), Ncols(RefTableau.Ncols), Row_L(new int[RefTableau.Nrows]), Col_L(new int[RefTableau.Ncols]),
       id(RefTableau.id), maxid(RefTableau.maxid),
@@ -93,47 +73,11 @@ namespace ABACUS {
       }
 
     // The map:
-    for (int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i) map[i] = RefTableau.map[i];
+    for (int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i)
+      map[i] = RefTableau.map[i];
 
   }
-  /*
-  Young_Tableau::Young_Tableau (int Nr, int Nc, long long int* ref_choose_table, int dimref)
-    : Nrows(Nr), Ncols(Nc), Row_L(new int[Nrows]), Col_L(new int[Ncols]), id(0LL),
-      maxid(choose_lli(Nr + Nc, Nc) - 1LL),
-      //choose_table(new long long int[(Nr + Nc + 1) * (Nr + Nc + 1)]),
-      choose_table(new long long int[(Nr + Nc + 1) * (ABACUS::min(Nr, Nc) + 1)]),
-      //map(new long long int[ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT)]),
-      map(new long long int[YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1]),
-      map_computed(false), idnr_reached(0LL), nboxes_reached(-1)
-
-  {
-    // Constructs empty tableau of appropriate size
-
-    for (int i = 0; i < Nrows; ++i) Row_L[i] = 0;
-    for (int i = 0; i < Ncols; ++i) Col_L[i] = 0;
 
-    // Construct the choose_table
-
-    // Copy entries from reference table
-    for (int cti = 0; cti < ABACUS::min(Nr + Nc + 1, dimref); ++cti)
-      for (int ctj = 0; ctj < ABACUS::min(Nr + Nc + 1, dimref); ++ctj)
-	  choose_table[(Nr + Nc + 1) * cti + ctj] = cti >= ctj ? ref_choose_table[dimref * cti + ctj] : 0LL;
-
-    // add missing parts if there are any
-    if (dimref < Nr + Nc + 1) {
-      for (int cti = 0; cti < Nr + Nc + 1; ++cti)
-	for (int ctj = dimref; ctj < Nr + Nc + 1; ++ctj)
-	  choose_table[(Nr + Nc + 1) * cti + ctj] = 0LL;
-      for (int cti = dimref; cti < Nr + Nc + 1; ++cti)
-	for (int ctj = 0; ctj < Nr + Nc + 1; ++ctj)
-	  choose_table[(Nr + Nc + 1) * cti + ctj] = cti >= ctj ? choose_lli(cti, ctj) : 0LL;
-    }
-
-    // The map:
-    //for (int i = 0; i < ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT); ++i) map[i] = 0LL;
-    for (int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i) map[i] = 0LL;
-  }
-  */
   Young_Tableau::Young_Tableau (int Nr, int Nc, const Young_Tableau& RefTableau)
     : Nrows(Nr), Ncols(Nc), Row_L(new int[Nrows]), Col_L(new int[Ncols]), id(0LL),
       maxid(choose_lli(Nr + Nc, Nc) - 1LL),
@@ -163,7 +107,8 @@ namespace ABACUS {
 	  choose_table[dimchoose * cti + ctj] = cti >= ctj ? choose_lli(cti, ctj) : 0LL;
 
     // The map:
-    for (int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i) map[i] = 0LL;
+    for (int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i)
+      map[i] = 0LL;
   }
 
   Young_Tableau& Young_Tableau::operator= (const Young_Tableau& RefTableau)
@@ -190,7 +135,9 @@ namespace ABACUS {
 
       if (map != 0LL) delete[] map;
       map = new long long int[YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1];
-      for (long long int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2 ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i) map[i] = RefTableau.map[i];
+      for (long long int i = 0; i < (YOUNG_TABLEAU_ID_OPTION == 2
+				     ? ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT) : 1); ++i)
+	map[i] = RefTableau.map[i];
       map_computed = RefTableau.map_computed;
       idnr_reached = RefTableau.idnr_reached;
       nboxes_reached = RefTableau.nboxes_reached;
@@ -263,7 +210,8 @@ namespace ABACUS {
     }
 
     else if (nboxes_to_dist > Ncols * (Nrows - level)) {
-      cout << Nrows << "\t" << Ncols << "\t" << level << "\t" << nboxes_to_dist << "\t" << idnr_reached << "\t" << nboxes_reached << endl;
+      cout << Nrows << "\t" << Ncols << "\t" << level << "\t" << nboxes_to_dist << "\t"
+	   << idnr_reached << "\t" << nboxes_reached << endl;
       ABACUSerror("nboxes_to_dist too high");
     }
     else if (nboxes_to_dist == 0) {
@@ -309,10 +257,11 @@ namespace ABACUS {
 					    + ABACUS::min(highest_occupied_row, Ncols_Desc - j)];
 
 	Vect_INT Desc_Desc_Row_L(highest_occupied_row);
-	for (int i = 0; i < highest_occupied_row; ++i) Desc_Desc_Row_L[i] = Desc_Row_L[i] - Desc_Row_L[highest_occupied_row];
+	for (int i = 0; i < highest_occupied_row; ++i)
+	  Desc_Desc_Row_L[i] = Desc_Row_L[i] - Desc_Row_L[highest_occupied_row];
 
-	answer += Compute_Descendent_id (0, Desc_Desc_Row_L, highest_occupied_row, Ncols_Desc - Desc_Row_L[highest_occupied_row],
-					 RefTableau);
+	answer += Compute_Descendent_id (0, Desc_Desc_Row_L, highest_occupied_row,
+					 Ncols_Desc - Desc_Row_L[highest_occupied_row], RefTableau);
 
       }
     }
@@ -338,7 +287,7 @@ namespace ABACUS {
 	else {
 
 	  for (int j = 0; j < ndiag; ++j) answer += RefTableau.choose_table[RefTableau.dimchoose * Nrows_Desc + j]
-	    * RefTableau.choose_table[RefTableau.dimchoose * Ncols_Desc + j];
+					    * RefTableau.choose_table[RefTableau.dimchoose * Ncols_Desc + j];
 
 	  Vect_INT Desc1_Row_L(ndiag);
 	  for (int i = 0; i < ndiag; ++i) Desc1_Row_L[i] = Desc_Row_L[i] - ndiag;
@@ -381,8 +330,9 @@ namespace ABACUS {
 	int highest_occupied_row = Nrows - 1;
 	while (Row_L[highest_occupied_row] == 0) highest_occupied_row--;  // index of highest occupied row;
 
-	for (int j = 0; j < Row_L[highest_occupied_row]; ++j) idnr += choose_table[dimchoose * (highest_occupied_row + Ncols - j)
-										   + ABACUS::min(highest_occupied_row, Ncols - j)];
+	for (int j = 0; j < Row_L[highest_occupied_row]; ++j)
+	  idnr += choose_table[dimchoose * (highest_occupied_row + Ncols - j)
+			       + ABACUS::min(highest_occupied_row, Ncols - j)];
 
 	Vect_INT Desc_Row_L(highest_occupied_row);
 
@@ -432,7 +382,8 @@ namespace ABACUS {
 
       Compute_id (0);  // sets the id according to rule 0
       Compute_Map (idnr);  // make sure the state map is computed
-      while (map[idnr] != id && idnr < ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT)) idnr++;  // match with inverse map to get the idnr according to rule 2
+      while (map[idnr] != id && idnr < ABACUS::min(maxid + 1LL, TABLEAU_ID_UPPER_LIMIT))
+	idnr++;  // match with inverse map to get the idnr according to rule 2
     }
 
     else ABACUSerror("Wrong option for Tableau ids");
@@ -448,13 +399,15 @@ namespace ABACUS {
     return(*this);
   }
 
-  Young_Tableau& Young_Tableau::Set_to_id (long long int idnr, int option) // sets the tableau to the one corresponding to idnr
+  Young_Tableau& Young_Tableau::Set_to_id (long long int idnr, int option)
+  // sets the tableau to the one corresponding to idnr
   {
 
     if (option == 0) {
 
       if ((idnr < 0) || ((maxid < idnr) && (Nrows*Ncols != 0))) {
-	cout << "Nrows = " << Nrows << "\tNcols = " << Ncols << "\tmaxid = " << maxid << "\trequested id = " << idnr << endl;
+	cout << "Nrows = " << Nrows << "\tNcols = " << Ncols
+	     << "\tmaxid = " << maxid << "\trequested id = " << idnr << endl;
 	ABACUSerror("Wrong idnr in Set_to_id for Young Tableau.");
       }
       id = idnr;
@@ -489,7 +442,8 @@ namespace ABACUS {
 
     else if (option == 1) {
 
-      if ((idnr < 0LL) || ((maxid < idnr) && (Nrows*Ncols != 0))) ABACUSerror("Wrong idnr in Set_to_id for Young Tableau.");
+      if ((idnr < 0LL) || ((maxid < idnr) && (Nrows*Ncols != 0)))
+	ABACUSerror("Wrong idnr in Set_to_id for Young Tableau.");
 
       if (Nrows*Ncols == 0 && idnr != 0LL) ABACUSerror("Trying nonzero id on empty Tableau.");
 
@@ -508,7 +462,8 @@ namespace ABACUS {
 	  sum += choose_table[dimchoose * Nrows + ndiag] * choose_table[dimchoose * Ncols + ndiag];
 	}
 
-	long long int residual_id = idnr - 1 - sum + choose_table[dimchoose * Nrows + ndiag] * choose_table[dimchoose * Ncols + ndiag];
+	long long int residual_id = idnr - 1 - sum + choose_table[dimchoose * Nrows + ndiag]
+	  * choose_table[dimchoose * Ncols + ndiag];
 
 	if (ndiag == 0 && idnr != 0LL) ABACUSerror("Zero ndiag for nonzero idnr in Tableau.");
 
@@ -561,9 +516,12 @@ namespace ABACUS {
 
   Young_Tableau& Young_Tableau::Set_Row_L (Vect_INT& Row_Lengths)  // set row lengths to elements of given vector
   {
-    if (Row_Lengths.size() != Nrows) ABACUSerror("Vector of incompatible dimension used to initialize Young Tableau.");
+    if (Row_Lengths.size() != Nrows)
+      ABACUSerror("Vector of incompatible dimension used to initialize Young Tableau.");
 
-    for (int i = 0; i < Row_Lengths.size() - 1; ++i) if (Row_Lengths[i] < Row_Lengths[i+1]) ABACUSerror("Vector is not a proper Young tableau.");
+    for (int i = 0; i < Row_Lengths.size() - 1; ++i)
+      if (Row_Lengths[i] < Row_Lengths[i+1])
+	ABACUSerror("Vector is not a proper Young tableau.");
 
     for (int i = 0; i < Nrows; ++i) Row_L[i] = Row_Lengths[i];
     (*this).Set_Col_L_given_Row_L();
@@ -663,8 +621,6 @@ namespace ABACUS {
   {
     // adds a box to the lowest nonzero length Row, recomputes id, returns true if tableau has changed
 
-    //cout << "Check before: "; (*this).Print();
-
     if (id == 0LL || Nrows == 0 || Ncols == 0) return(false);  // Tableau is empty
 
     // otherwise find the lowest nonzero row:
@@ -674,13 +630,12 @@ namespace ABACUS {
     if (iln0r < 0) ABACUSerror("id wrongly set in Young_Tableau (Raise_Lowest_Nonzero_Row).");
     // This should not happen, since if iln0r == -1, id should be 0.
 
-    else if (iln0r == 0 && Row_L[0] < Ncols || iln0r > 0 && Row_L[iln0r - 1] > Row_L[iln0r]) {  // there is space for at least one more box !
+    else if (iln0r == 0 && Row_L[0] < Ncols || iln0r > 0 && Row_L[iln0r - 1] > Row_L[iln0r]) {
+      // there is space for at least one more box !
       Row_L[iln0r] += 1;
       Set_Col_L_given_Row_L();
       Compute_id();
 
-      //cout << "Check after: iln0r = " << iln0r; (*this).Print();
-
       return(true);
     }
 
@@ -693,28 +648,20 @@ namespace ABACUS {
 
     // Important:  allow raising first row if tableau is empty.
 
-    //cout << "Check before: "; (*this).Print();
-
     if (Ncols == 0 || Nrows == 0) return(false); // no space !
 
     // Find index of lowest nonzero row:  can be -1 if Tableau is empty
     int iln0r = Nrows - 1;
     while (Row_L[iln0r] == 0 && iln0r >= 0) iln0r--;
 
-    //cout << "iln0r = " << iln0r << "\t" << Row_L[iln0r] << "\t" << Row_L[iln0r + 1] << endl;
-
-    //if (iln0r == Nrows - 1) return(false); // no row under that one;  allow raising of row 0
-
     if (iln0r == -1 && Row_L[0] < Ncols || iln0r >= 0 && iln0r < Nrows - 1 && Row_L[iln0r] > Row_L[iln0r + 1]) {
-	// there is space for at least one more box !
-	Row_L[iln0r + 1] += 1;
-	Set_Col_L_given_Row_L();
-	Compute_id();
-
-	//cout << "Check after: iln0r = " << iln0r; (*this).Print();
+      // there is space for at least one more box !
+      Row_L[iln0r + 1] += 1;
+      Set_Col_L_given_Row_L();
+      Compute_id();
 
-	return(true);
-      }
+      return(true);
+    }
 
     return(false);
   }
@@ -836,8 +783,6 @@ namespace ABACUS {
     // descendents considered here are thus those for which the raised
     // box is the highest still occupied box of the originally boosted state.
 
-    //cout << "Tableau in Desc_Boosted: " << (*this) << endl;
-
     int ndesc = 0;
 
     // Is tableau non-empty ?
@@ -860,19 +805,17 @@ namespace ABACUS {
     if (!fixed_Nboxes) {
       // The convention here is that we *remove* the highest yet unraised box only
 
-      //cout << "Removing box from " << (*this) << " with id " << (*this).id << endl;
       Young_Tableau descendent_attempt = (*this);
       if (descendent_attempt.Lower_Row(level_from)) ndesc = 1;
-      //cout << "Obtained: " << descendent_attempt << " with id " << descendent_attempt.id << endl;
 
       //if (ndesc > 0) {
       if (ndesc == 1) {
 	Vect<Young_Tableau> Tableau_desc(ndesc);
-	//if (ndesc == 1) Tableau_desc[0] = descendent_attempt;
 	Tableau_desc[0] = descendent_attempt;
 	return(Tableau_desc);
       }
-      else if (ndesc != 0) ABACUSerror("There should be either 0 or 1 descendents in Descended_Boosted_State with fixed_iK == true.");
+      else if (ndesc != 0)
+	ABACUSerror("There should be either 0 or 1 descendents in Descended_Boosted_State with fixed_iK == true.");
 
     } // if (!fixed_Nboxes)
 
@@ -886,10 +829,12 @@ namespace ABACUS {
       Young_Tableau Tableau_ref = (*this);
       Young_Tableau Tableau_check1 = (*this);
       bool check1 = (Tableau_check1.Lower_Row(level_from) && Tableau_check1.Raise_Lowest_Nonzero_Row());
-      if (check1 && Tableau_check1.Row_L[level_from] == Tableau_ref.Row_L[level_from] - 1) ndesc++;  // to make sure we don't Raise the one we've just removed
+      if (check1 && Tableau_check1.Row_L[level_from] == Tableau_ref.Row_L[level_from] - 1)
+	ndesc++;  // to make sure we don't Raise the one we've just removed
       Young_Tableau Tableau_check2 = (*this);
       bool check2 = (Tableau_check2.Lower_Row(level_from) && Tableau_check2.Raise_Next_to_Lowest_Nonzero_Row());
-      if (check2 && Tableau_check2.Row_L[level_from] == Tableau_ref.Row_L[level_from] - 1) ndesc++;   // to make sure we don't Raise the one we've just removed
+      if (check2 && Tableau_check2.Row_L[level_from] == Tableau_ref.Row_L[level_from] - 1)
+	ndesc++;   // to make sure we don't Raise the one we've just removed
 
       if (ndesc > 0) {
 	Vect<Young_Tableau> Tableau_desc(ndesc);
@@ -908,8 +853,6 @@ namespace ABACUS {
     // tries to add Nboxes to Tableau, returns number of boxes added.
     if (Ncols == 0 || Nrows == 0) return(0); // can't do anything !
 
-    //cout << "Requesting Nboxes " << Nboxes << " in tableau." << endl;
-
     int Nboxes_added = 0;
     int previous_Row_L = 0;
     for (int working_level = 0; working_level < Nrows; ++working_level) {