Clean up sources up to (before) src/SCAN.

ABACUS.org

 #+TODO: TODO(t@) | DONE(d@)
-#+TODO: BUGREPORT(b@) CRITICAL(#@) | SOLVED(s@)
+#+TODO: BUGREPORT(b@) BUGRISK(?@) CRITICAL(#@) | SOLVED(s@)
 #+TODO: CONCEPT(c@) UPDATED(u@) | REJECTED(r@)
 #+TODO: PICKEDUP(p@) | ABANDONED(k@) IMPLEMENTED(i@)
 
   :END:
 
 
+* Bugrisks						:ABACUS:Dev:Bugrisks:
+  :PROPERTIES:
+  :ARCHIVE:  %s_archive::* Bugrisks
+  :CUSTOM_ID: Bugrisks
+  :END:
+
+TIP: Search for the string BUGRISK in the codebase
+
+** BUGRISK Value of LiebLin ln_Density_ME
+   - State "BUGRISK"    from ""           [2018-02-11 Sun 09:11]
+
+File: ln_Density_ME.cc
+line 66
+
+Why real?
+
+
 * Priority 					       :ABACUS:Dev:Priority:
   :PROPERTIES:
   :ARCHIVE:  %s_archive::* Priority

README.md

 ```
 This will produce all executables, together with a library `ABACUS_[vn]` where vn is of the form [digit][character].
 
+## Warnings
+* The ODSLF part (for one-dimensional spinless fermions) is not functional: it is based on the old Young Tableaux ids, and must be upgraded to `State_Label`s.
+* The Richardson part is not implemented; what exists is old and long deprecated.
 
 ## Acknowledgements
 __Antoine Klauser__ provided functions for computing neighbour-operator-product matrix elements in XXX: `ln_Szz_ME`, `ln_Szm_p_Smz_ME` and `ln_Smm_ME`.
 
-__Jacopo De Nardis__ provided the code for the `ln_g2_ME` function for Lieb-Liniger.
+__Miłosz Panfil__ contributed to code to help in the calculation of finite-temperature correlations of Lieb-Liniger.
+
+__Jacopo De Nardis__ contributed code for the `ln_g2_ME` function for Lieb-Liniger.
 
 __Teun Zwart__ has given much useful advice concerning C++ code organization.
 

src/LIEBLIN/LiebLin_Bethe_State.cc

 
   LiebLin_Bethe_State::LiebLin_Bethe_State ()
     : c_int (0.0), L(0.0), cxL(0.0), N(0),
-      //OriginStateIxe(Vect<int>(0,1)),
       Ix2_available(Vect<int>(0, 1)), index_first_hole_to_right (Vect<int>(0,1)), displacement (Vect<int>(0,1)),
-      Ix2(Vect<int>(0, 1)), lambdaoc(Vect<DP>(0.0, 1)), //BE(Vect<DP>(0.0, 1)),
+      Ix2(Vect<int>(0, 1)), lambdaoc(Vect<DP>(0.0, 1)),
       S(Vect<DP>(0.0, 1)), dSdlambdaoc(Vect<DP>(0.0, 1)),
       diffsq(0.0), prec(ITER_REQ_PREC_LIEBLIN), conv(0), iter_Newton(0), E(0.0), iK(0), K(0.0), lnnorm(-100.0)
   {
-    stringstream Nout; Nout << N; label = Nout.str() + LABELSEP + ABACUScoding[0] + LABELSEP;//"_0_";
+    stringstream Nout; Nout << N; label = Nout.str() + LABELSEP + ABACUScoding[0] + LABELSEP;
   }
 
   LiebLin_Bethe_State::LiebLin_Bethe_State (DP c_int_ref, DP L_ref, int N_ref)
     : c_int(c_int_ref), L(L_ref), cxL(c_int_ref * L_ref), N(N_ref),
-      //OriginStateIx2(Vect<int>(0,N),
       Ix2_available(Vect<int>(0, 2)), index_first_hole_to_right (Vect<int>(0,N)), displacement (Vect<int>(0,N)),
-      Ix2(Vect<int>(0, N)), lambdaoc(Vect<DP>(0.0, N)), //BE(Vect<DP>(0.0, N)),
+      Ix2(Vect<int>(0, N)), lambdaoc(Vect<DP>(0.0, N)),
       S(Vect<DP>(0.0, N)), dSdlambdaoc(Vect<DP>(0.0, N)),
-      diffsq(0.0), prec(ABACUS::max(1.0, 1.0/(c_int * c_int)) * ITER_REQ_PREC_LIEBLIN), conv(0), iter_Newton(0), E(0.0), iK(0), K(0.0), lnnorm(-100.0)
+      diffsq(0.0), prec(ABACUS::max(1.0, 1.0/(c_int * c_int)) * ITER_REQ_PREC_LIEBLIN),
+      conv(0), iter_Newton(0), E(0.0), iK(0), K(0.0), lnnorm(-100.0)
   {
     if (c_int < 0.0) ABACUSerror("You must use a positive interaction parameter !");
     if (N < 0) ABACUSerror("Particle number must be strictly positive.");
 
-    stringstream Nout; Nout << N; label = Nout.str() + LABELSEP + ABACUScoding[0] + LABELSEP;//+ "_0_";
+    stringstream Nout; Nout << N; label = Nout.str() + LABELSEP + ABACUScoding[0] + LABELSEP;
 
     // Set quantum numbers to ground-state configuration:
     for (int i = 0; i < N; ++i) Ix2[i] = -(N-1) + 2*i;
     Vect<int> OriginIx2 = Ix2;
 
     (*this).Set_Label_from_Ix2 (OriginIx2);
-    //(*this).Set_Label_Internals_from_Ix2 (OriginIx2);
   }
 
 
       displacement = RefState.displacement;
       Ix2 = RefState.Ix2;
       lambdaoc = RefState.lambdaoc;
-      //BE = RefState.BE;
       S = RefState.S;
       dSdlambdaoc = RefState.dSdlambdaoc;
       diffsq = RefState.diffsq;
     // Now reorder the Ix2 to follow convention:
     Ix2.QuickSort();
 
-    //cout << "Setting label:" << label_ref << endl << "Ix2old = " << labeldata.Ix2old[0] << endl << "Ix2exc = " << labeldata.Ix2exc[0] << endl;
-    //cout << "on " << OriginStateIx2ordered << endl << "giving " << Ix2 << endl;
-
     (*this).Set_Label_from_Ix2 (OriginStateIx2ordered);
-    //(*this).Set_Label_Internals_from_Ix2 (OriginStateIx2ordered);
   }
 
   void LiebLin_Bethe_State::Set_to_Label (string label_ref)
 
     if (N != OriginStateIx2.size()) ABACUSerror("N != OriginStateIx2.size() in Set_Label_from_Ix2.");
 
-    //cout << "Setting label on Ix2 " << endl << Ix2 << endl;
 
     // Set the state label:
     Vect<int> type_ref(0,1);
     label = Return_State_Label (labeldata, OriginStateIx2);
   }
 
-  /*
-  void LiebLin_Bethe_State::Set_Label_from_Ix2 (const Vect<int>& OriginStateIx2)
-  {
-    // This function was deprecated since it assumed that the Ix2 of the state were
-    // in a particular order mirroring the indices of OriginStateIx2.
-
-    if (N != OriginStateIx2.size()) ABACUSerror("N != OriginStateIx2.size() in Set_Label_from_Ix2.");
-
-    Vect<int> OriginStateIx2ordered = OriginStateIx2;
-    OriginStateIx2ordered.QuickSort();
-
-    // Set the state label:
-    Vect<int> type_ref(0,1);
-    Vect<int> M_ref(N, 1);
-    Vect<int> nexc_ref(0, 1);
-    // Count nr of particle-holes:
-    for (int i = 0; i < N; ++i) if (Ix2[i] != OriginStateIx2ordered[i]) nexc_ref[0] += 1;
-    Vect<Vect<int> > Ix2old_ref(1);
-    Vect<Vect<int> > Ix2exc_ref(1);
-    Ix2old_ref[0] = Vect<int>(ABACUS::max(nexc_ref[0],1));
-    Ix2exc_ref[0] = Vect<int>(ABACUS::max(nexc_ref[0],1));
-    int nexccheck = 0;
-    for (int i = 0; i < N; ++i)
-      if (Ix2[i] != OriginStateIx2ordered[i]) {
-	Ix2old_ref[0][nexccheck] = OriginStateIx2ordered[i];
-	Ix2exc_ref[0][nexccheck++] = Ix2[i];
-      }
-
-    State_Label_Data labeldata(type_ref, M_ref, nexc_ref, Ix2old_ref, Ix2exc_ref);
-
-    label = Return_State_Label (labeldata);
-  }
-  */
-
   void LiebLin_Bethe_State::Set_Label_Internals_from_Ix2 (const Vect<int>& OriginStateIx2)
   {
-    //ABACUSerror("LiebLin_Bethe_State::Set_Label_Internals_from_Ix2 deprecated 20110604");
-
     if (N != OriginStateIx2.size()) ABACUSerror("N != OriginStateIx2.size() in Set_Label_Internals_from_Ix2.");
 
     Vect<int> OriginStateIx2ordered = OriginStateIx2;
     label = Return_State_Label (labeldata, OriginStateIx2);
 
     // Construct the Ix2_available vector: we give one more quantum number on left and right:
-    int navailable = 2 + (ABACUS::max(Ix2.max(), OriginStateIx2.max()) - ABACUS::min(Ix2.min(), OriginStateIx2.min()))/2 - N + 1;
+    int navailable = 2 + (ABACUS::max(Ix2.max(), OriginStateIx2.max())
+			  - ABACUS::min(Ix2.min(), OriginStateIx2.min()))/2 - N + 1;
     Ix2_available = Vect<int>(navailable);
     index_first_hole_to_right = Vect<int>(N);
 
     // First set Ix2_available to all holes from left
-    for (int i = 0; i < Ix2_available.size(); ++i) Ix2_available[i] = ABACUS::min(Ix2.min(), OriginStateIx2.min()) - 2 + 2*i;
+    for (int i = 0; i < Ix2_available.size(); ++i)
+      Ix2_available[i] = ABACUS::min(Ix2.min(), OriginStateIx2.min()) - 2 + 2*i;
 
     // Now shift according to Ix2 of OriginState:
     for (int j = 0; j < N; ++j) {
     for (int j = 0; j < N; ++j) {
       if (Ix2[j] < OriginStateIx2ordered[j]) {
 	// Ix2[j] must be equal to some OriginState_Ix2_available[i] for i < OriginState_index_first_hole_to_right[j]
-	//cout << "Going down\t" << Ix2[j] << "\t" << index_first_hole_to_right[j] << "\t" << displacement[j] << endl;
 	while (Ix2[j] != Ix2_available[index_first_hole_to_right[j] + displacement[j] ]) {
-	  //cout << j << "\t" << index_first_hole_to_right[j] << "\t" << displacement[j] << "\t" << Ix2_available[index_first_hole_to_right[j] + displacement[j] ] << endl;
 	  if (index_first_hole_to_right[j] + displacement[j] == 0) {
-	    cout << label << endl << j << endl << OriginStateIx2 << endl << Ix2 << endl << Ix2_available << endl << index_first_hole_to_right << endl << displacement << endl;
+	    cout << label << endl << j << endl << OriginStateIx2 << endl << Ix2 << endl << Ix2_available
+		 << endl << index_first_hole_to_right << endl << displacement << endl;
 	    ABACUSerror("Going down too far in Set_Label_Internals...");
 	  }
 	  displacement[j]--;
       }
       if (Ix2[j] > OriginStateIx2ordered[j]) {
 	// Ix2[j] must be equal to some Ix2_available[i] for i >= index_first_hole_to_right[j]
-	//cout << "Going up\t" << Ix2[j] << "\t" << index_first_hole_to_right[j] << "\t" << displacement[j] << endl;
 	displacement[j] = 1; // start with this value to prevent segfault
 	while (Ix2[j] != Ix2_available[index_first_hole_to_right[j] - 1 + displacement[j] ]) {
-	  //cout << j << "\t" << index_first_hole_to_right[j] << "\t" << displacement[j] << "\t" << Ix2_available[index_first_hole_to_right[j] + displacement[j] ] << endl;
 	  if (index_first_hole_to_right[j] + displacement[j] == Ix2_available.size() - 1) {
-	    cout << label << endl << j << endl << OriginStateIx2 << endl << Ix2 << endl << Ix2_available << endl << index_first_hole_to_right << endl << displacement << endl;
+	    cout << label << endl << j << endl << OriginStateIx2 << endl << Ix2 << endl << Ix2_available
+		 << endl << index_first_hole_to_right << endl << displacement << endl;
 	    ABACUSerror("Going up too far in Set_Label_Internals...");
 	  }
 	  displacement[j]++;
 	}
       }
     }
-    //cout << "label " << label << endl;
-    //cout << "Ix2: " << Ix2 << endl << "Ix2_available: " << Ix2_available << endl << "index...: " << index_first_hole_to_right << endl << "displacement: " << displacement << endl;
-    //char a; cin >> a;
-
-
   }
 
   bool LiebLin_Bethe_State::Check_Admissibility (char whichDSF)
     diffsq = 1.0;
 
     if (reset_rapidities) (*this).Set_Free_lambdaocs();
-    /*
-    // Start with normal iterations:
-    //for (int niternormal = 0; niternormal < 10; ++niternormal) {
-    for (int niternormal = 0; niternormal < N; ++niternormal) {
-      //(*this).Iterate_BAE(0.99);
-      (*this).Iterate_BAE(0.9);
-      cout << "Normal: " << niternormal << "\t" << diffsq << endl;
-      cout << (*this).lambdaoc << endl;
-      if (diffsq < sqrt(prec)) break;
-    }
-    */
+
     iter_Newton = 0;
 
     DP damping = 1.0;
     DP diffsq_prev = 1.0e+6;
-    //while (diffsq > prec && !is_nan(diffsq) && iter_Newton < 40) {
     while (diffsq > prec && !is_nan(diffsq) && iter_Newton < 100) {
-    //while (diffsq > prec && !is_nan(diffsq) && iter_Newton < 400) {
       (*this).Iterate_BAE_Newton(damping);
-      //(*this).Iterate_BAE_S(damping); // Not as fast as Newton for N up to ~ 256
-      //if (diffsq > diffsq_prev) damping /= 2.0;
       if (diffsq > diffsq_prev && damping > 0.5) damping /= 2.0;
       else if (diffsq < diffsq_prev) damping = 1.0;
       diffsq_prev = diffsq;
-      //cout << iter_Newton << "\t" << diffsq << "\t" << damping << endl;
-      //cout << (*this).lambdaoc << endl;
     }
 
     conv = ((diffsq < prec) && (*this).Check_Rapidities()) ? 1 : 0;
 
     if (!conv) {
-      cout << "Alert! State " << label << " did not converge... diffsq " << diffsq << "\titer_Newton " << iter_Newton << (*this) << endl;
-      //char a; cin >> a;
+      cout << "Alert! State " << label << " did not converge... diffsq " << diffsq
+	   << "\titer_Newton " << iter_Newton << (*this) << endl;
     }
 
-    //cout << (*this) << endl;
-
     return;
   }
 
 
       // Add the pieces outside of Gaudin determinant
 
-      for (int j = 0; j < N - 1; ++j) for (int k = j+1; k < N; ++k) lnnorm += log(1.0 + 1.0/pow(lambdaoc[j] - lambdaoc[k], 2.0));
+      for (int j = 0; j < N - 1; ++j) for (int k = j+1; k < N; ++k)
+					lnnorm += log(1.0 + 1.0/pow(lambdaoc[j] - lambdaoc[k], 2.0));
 
     }
 
   void LiebLin_Bethe_State::Set_Free_lambdaocs()
   {
     if (cxL >= 1.0)
-    for (int a = 0; a < N; ++a) lambdaoc[a] = PI * Ix2[a]/cxL;
+      for (int a = 0; a < N; ++a) lambdaoc[a] = PI * Ix2[a]/cxL;
 
     // For small values of c, use better approximation using approximate zeroes of Hermite polynomials: see Gaudin eqn 4.71.
     if (cxL < 1.0) {
-      //DP sqrtcL = pow(cxL, 0.5);
       DP oneoversqrtcLN = 1.0/pow(cxL * N, 0.5);
       for (int a = 0; a < N; ++a) lambdaoc[a] = oneoversqrtcLN * PI * Ix2[a];
-
-      //for (int a = 0; a < N; ++a) lambdaoc[a] = sqrtcL * PI * Ix2[a];  // wrong values, correct scaling with c
-      //for (int a = 0; a < N; ++a) lambdaoc[a] = PI * Ix2[a]/(cxL + 2.0 * N);  // set to minimal distance lattice
     }
 
-    //cout << "Set free lambdaocs to: " << endl << lambdaoc << endl;
     return;
   }
 
     }
 
     diffsq = 0.0;
-    //DP sumsq = 0.0;
     for (int i = 0; i < N; ++i) {
       lambdaoc[i] += dlambdaoc[i];
-      //sumsq += lambdaoc[i] * lambdaoc[i];
-      //diffsq += dlambdaoc[i] * dlambdaoc[i];
-      //if (cxL > 1.0) diffsq += dlambdaoc[i] * dlambdaoc[i];
-      //else diffsq += cxL * cxL * dlambdaoc[i] * dlambdaoc[i];
       // Normalize the diffsq by the typical value of the rapidities:
       if (cxL > 1.0) diffsq += dlambdaoc[i] * dlambdaoc[i]/(lambdaoc[i] * lambdaoc[i] + 1.0e-6);
       else diffsq += cxL * cxL * dlambdaoc[i] * dlambdaoc[i]/(lambdaoc[i] * lambdaoc[i] + 1.0e-6);
     }
     diffsq /= DP(N);
-    //diffsq /= sqrt(sumsq) * DP(N);
 
     return;
   }
   void LiebLin_Bethe_State::Iterate_BAE_S (DP damping)
   {
     // This is essentially Newton's method but only in one variable.
-    // The logic is that the derivative of the LHS of the BE_j w/r to lambdaoc_j is much larger than with respect to lambdaoc_l with l != j.
+    // The logic is that the derivative of the LHS of the BE_j w/r to lambdaoc_j is much larger
+    // than with respect to lambdaoc_l with l != j.
 
     Vect_DP dlambdaoc (0.0, N);
 
       S[j] *= 2.0/cxL;
 
       dSdlambdaoc[j] = 0.0;
-      for (int k = 0; k < N; ++k) dSdlambdaoc[j] += 1.0/((lambdaoc[j] - lambdaoc[k]) * (lambdaoc[j] - lambdaoc[k]) + 1.0);
+      for (int k = 0; k < N; ++k)
+	dSdlambdaoc[j] += 1.0/((lambdaoc[j] - lambdaoc[k]) * (lambdaoc[j] - lambdaoc[k]) + 1.0);
       dSdlambdaoc[j] *= 2.0/(PI * cxL);
 
       dlambdaoc[j] = (PI*Ix2[j]/cxL - S[j] + lambdaoc[j] * dSdlambdaoc[j])/(1.0 + dSdlambdaoc[j]) - lambdaoc[j];
 	}
       sumtheta *= 2.0;
 
-      //cout << j << "\t" << Ix2[j] << "\t" << atanintshift << endl;
-
       RHSBAE[j] = cxL * lambdaoc[j] + sumtheta - PI*(Ix2[j] - atanintshift);
     }
 
 
     for (int j = 0; j < N; ++j) dlambdaoc[j] = - RHSBAE[j];
 
-    //cout << "dlambdaoc pre lubksb = " << dlambdaoc << endl;
-
     DP d;
     ludcmp (Gaudin, indx, d);
     lubksb (Gaudin, indx, dlambdaoc);
 
-    //cout << "dlambdaoc post lubksb = " << dlambdaoc << endl;
-
     bool ordering_changed = false;
     for (int j = 0; j < N-1; ++j) if (lambdaoc[j] + dlambdaoc[j] > lambdaoc[j+1] + dlambdaoc[j+1]) ordering_changed = true;
 
       DP maxdlambdaoc = 0.0;
       do {
 	ordering_still_changed = false;
-	if (dlambdaoc[0] < 0.0 && fabs(dlambdaoc[0]) > (maxdlambdaoc = 10.0*ABACUS::max(fabs(lambdaoc[0]), fabs(lambdaoc[N-1]))))
+	if (dlambdaoc[0] < 0.0 && fabs(dlambdaoc[0])
+	    > (maxdlambdaoc = 10.0*ABACUS::max(fabs(lambdaoc[0]), fabs(lambdaoc[N-1]))))
 	  dlambdaoc[0] = -maxdlambdaoc;
 	if (lambdaoc[0] + dlambdaoc[0] > lambdaoc[1] + dlambdaoc[1]) {
 	  dlambdaoc[0] = 0.25 * (lambdaoc[1] + dlambdaoc[1] - lambdaoc[0] ); // max quarter distance
 	  ordering_still_changed = true;
-	  //cout << "reason 1" << endl;
 	}
-	if (dlambdaoc[N-1] > 0.0 && fabs(dlambdaoc[N-1]) > (maxdlambdaoc = 10.0*ABACUS::max(fabs(lambdaoc[0]), fabs(lambdaoc[N-1]))))
+	if (dlambdaoc[N-1] > 0.0 && fabs(dlambdaoc[N-1])
+	    > (maxdlambdaoc = 10.0*ABACUS::max(fabs(lambdaoc[0]), fabs(lambdaoc[N-1]))))
 	  dlambdaoc[N-1] = maxdlambdaoc;
 	if (lambdaoc[N-1] + dlambdaoc[N-1] < lambdaoc[N-2] + dlambdaoc[N-2]) {
 	  dlambdaoc[N-1] = 0.25 * (lambdaoc[N-2] + dlambdaoc[N-2] - lambdaoc[N-1]);
 	  ordering_still_changed = true;
-	  //cout << "reason 2" << endl;
 	}
 	for (int j = 1; j < N-1; ++j) {
 	  if (lambdaoc[j] + dlambdaoc[j] > lambdaoc[j+1] + dlambdaoc[j+1]) {
 	    dlambdaoc[j] = 0.25 * (lambdaoc[j+1] + dlambdaoc[j+1] - lambdaoc[j]);
 	    ordering_still_changed = true;
-	    //cout << "reason 3" << endl;
 	  }
 	  if (lambdaoc[j] + dlambdaoc[j] < lambdaoc[j-1] + dlambdaoc[j-1]) {
 	    dlambdaoc[j] = 0.25 * (lambdaoc[j-1] + dlambdaoc[j-1] - lambdaoc[j]);
 	    ordering_still_changed = true;
-	    //cout << "reason 4" << endl;
 	  }
 	}
       } while (ordering_still_changed);
     }
 
-    //if (ordering_changed) cout << "dlambdaoc post checking = " << dlambdaoc << endl;
-
-    /*
-    bool orderingchanged = false;
-    //bool dlambdaexceedsmaxrapdiff = false;
-    DP damping_to_use = damping;
-    for (int j = 0; j < N-1; ++j) {
-      if (lambdaoc[j] + dlambdaoc[j] > lambdaoc[j+1] + dlambdaoc[j+1]) // unacceptable, order changed!
-	orderingchanged = true;
-      // We must damp the dlambda such that the ordering is unchanged:
-      // the condition is lambdaoc[j] + damping*dlambdaoc[j] < lambdaoc[j+1] + damping*dlambdaoc[j+1]
-      damping_to_use = ABACUS::min(damping_to_use, 0.5 * (lambdaoc[j+1] - lambdaoc[j])/(dlambdaoc[j] - dlambdaoc[j+1]));
-    }
-    */
-    //for (int j = 0; j < N; ++j)
-    //if (fabs(dlambdaoc[j]) > maxrapdiff) dlambdaexceedsmaxrapdiff = true;
-    /*
-    // The dlambdaoc must be smaller than the distance to neighbouring rapidities:
-    // If any dlambdaoc is greater than half the distance, set all to half the previous distance:
-    if (orderingchanged || dlambdaexceedsmaxrapdiff) {
-      if (dlambdaoc[0] > 0.0) dlambdaoc[0] = 0.25 * (lambdaoc[1] - lambdaoc[0]);
-      //else dlambdaoc[0] = 0.25 * (lambdaoc[0] - lambdaoc[1]);
-      else dlambdaoc[0] = -fabs(lambdaoc[0]);  // strictly limit the growth of lambdaoc[0]
-      //if (dlambdaoc[N-1] > 0.0) dlambdaoc[N-1] = 0.25 * (lambdaoc[N-1] - lambdaoc[N-2]);
-      if (dlambdaoc[N-1] > 0.0) dlambdaoc[N-1] = fabs(lambdaoc[N-1]); // strictly limit the growth of lambdaoc[N-1]
-      else dlambdaoc[N-1] = 0.25 * (lambdaoc[N-2] - lambdaoc[N-1]);
-      for (int j = 1; j < N-1; ++j) {
-	if (dlambdaoc[j] > 0.0) dlambdaoc[j] = 0.25 * (lambdaoc[j+1] - lambdaoc[j]);
-	if (dlambdaoc[j] < 0.0) dlambdaoc[j] = 0.25 * (lambdaoc[j-1] - lambdaoc[j]);
-      }
-      //cout << "Corrected dlambdaoc = " << dlambdaoc << endl;
-    }
-    */
     diffsq = 0.0;
     for (int i = 0; i < N; ++i) {
-      //diffsq += dlambdaoc[i] * dlambdaoc[i];
       // Normalize the diffsq by the typical value of the rapidities:
       if (cxL > 1.0) diffsq += dlambdaoc[i] * dlambdaoc[i]/(lambdaoc[i] * lambdaoc[i] + 1.0e-6);
       else diffsq += cxL * cxL * dlambdaoc[i] * dlambdaoc[i]/(lambdaoc[i] * lambdaoc[i] + 1.0e-6);
     if (ordering_changed) diffsq = 1.0; // reset if Newton wanted to change ordering
 
     for (int j = 0; j < N; ++j) lambdaoc[j] += damping * dlambdaoc[j];
-    //for (int j = 0; j < N; ++j) lambdaoc[j] += damping_to_use * dlambdaoc[j];
 
     iter_Newton++;
 
     // if we've converged, calculate the norm here, since the work has been done...
 
-    //if (diffsq < prec && !orderingchanged && !dlambdaexceedsmaxrapdiff) {
     if (diffsq < prec && !ordering_changed) {
 
       lnnorm = 0.0;
       for (int j = 0; j < N; j++) lnnorm += log(fabs(Gaudin[j][j]));
 
       // Add the pieces outside of Gaudin determinant
-      for (int j = 0; j < N - 1; ++j) for (int k = j+1; k < N; ++k) lnnorm += log(1.0 + 1.0/pow(lambdaoc[j] - lambdaoc[k], 2.0));
+      for (int j = 0; j < N - 1; ++j)
+	for (int k = j+1; k < N; ++k)
+	  lnnorm += log(1.0 + 1.0/pow(lambdaoc[j] - lambdaoc[k], 2.0));
     }
 
     return;
   {
     iK = 0;
     for (int j = 0; j < N; ++j) {
-      //cout << j << "\t" << iK << "\t" << Ix2[j] << endl;
       iK += Ix2[j];
     }
     if (iK % 2) {
   void LiebLin_Bethe_State::Build_Reduced_Gaudin_Matrix (SQMat<DP>& Gaudin_Red)
   {
 
-    if (Gaudin_Red.size() != N) ABACUSerror("Passing matrix of wrong size in Build_Reduced_Gaudin_Matrix.");
+    if (Gaudin_Red.size() != N)
+      ABACUSerror("Passing matrix of wrong size in Build_Reduced_Gaudin_Matrix.");
 
     DP sum_Kernel = 0.0;
 
 
     if (!ck) ABACUSerror("Choose a parity invariant state please");
 
-    if (Gaudin_Red.size() != N/2) ABACUSerror("Passing matrix of wrong size in Build_Reduced_Gaudin_Matrix.");
+    if (Gaudin_Red.size() != N/2)
+      ABACUSerror("Passing matrix of wrong size in Build_Reduced_Gaudin_Matrix.");
 
     DP sum_Kernel = 0.0;
 
 
 	if (j == k) {
 	  sum_Kernel = 0.0;
-	  for (int kp = N/2; kp < N; ++kp) if (j + N/2 != kp) sum_Kernel += Kernel (lambdaoc[j+N/2] - lambdaoc[kp]) + Kernel (lambdaoc[j+N/2] + lambdaoc[kp]);
+	  for (int kp = N/2; kp < N; ++kp)
+	    if (j + N/2 != kp)
+	      sum_Kernel += Kernel (lambdaoc[j+N/2] - lambdaoc[kp]) + Kernel (lambdaoc[j+N/2] + lambdaoc[kp]);
 	  Gaudin_Red[j][k] = cxL + sum_Kernel;
 	}
 
-	else Gaudin_Red[j][k] = - (Kernel (lambdaoc[j+ N/2] - lambdaoc[k+ N/2]) + Kernel (lambdaoc[j+ N/2] + lambdaoc[k+ N/2])   );
+	else Gaudin_Red[j][k] = - (Kernel (lambdaoc[j+ N/2] - lambdaoc[k+ N/2])
+				   + Kernel (lambdaoc[j+ N/2] + lambdaoc[k+ N/2]) );
 
       }
 
     // This function changes the Ix2 of a given state by annihilating a particle and hole
     // pair specified by ipart and ihole (counting from the left, starting with index 0).
 
-    //cout << "Annihilating ipart " << ipart << " and ihole " << ihole << " of state with label " << (*this).label << endl;
-
     State_Label_Data currentdata = Read_State_Label ((*this).label, OriginStateIx2);
-    //cout << "current Ix2old " << currentdata.Ix2old[0] << endl;
-    //cout << "current Ix2exc " << currentdata.Ix2exc[0] << endl;
 
-    if (ipart >= currentdata.nexc[0]) ABACUSerror("Particle label too large in LiebLin_Bethe_State::Annihilate_ph_pair.");
-    if (ihole >= currentdata.nexc[0]) ABACUSerror("Hole label too large in LiebLin_Bethe_State::Annihilate_ph_pair.");
+    if (ipart >= currentdata.nexc[0])
+      ABACUSerror("Particle label too large in LiebLin_Bethe_State::Annihilate_ph_pair.");
+    if (ihole >= currentdata.nexc[0])
+      ABACUSerror("Hole label too large in LiebLin_Bethe_State::Annihilate_ph_pair.");
 
     // Simply remove the given pair:
     Vect<int> type_new = currentdata.type;
       for (int i = 0; i < nexc_new[it]; ++i) {
 	Ix2old_new[it][i] = currentdata.Ix2old[it][i + (i >= ihole)];
 	Ix2exc_new[it][i] = currentdata.Ix2exc[it][i + (i >= ipart)];
-	}
       }
-    //cout << "Ix2old_new " << Ix2old_new[0] << endl;
-    //cout << "Ix2exc_new " << Ix2exc_new[0] << endl;
+    }
 
     State_Label_Data newdata (type_new, M_new, nexc_new, Ix2old_new, Ix2exc_new);
 
     (*this).Set_to_Label (Return_State_Label(newdata, OriginStateIx2));
-
-    //cout << "Obtained label " << (*this).label << endl;
   }
 
   void LiebLin_Bethe_State::Parity_Flip ()

src/LIEBLIN/LiebLin_Chem_Pot.cc

     // RefState is used here to provide the c_int, L and N parameters.
 
     LiebLin_Bethe_State Nplus1State(RefState.c_int, RefState.L, RefState.N + 1);
-    //LiebLin_Bethe_State NState(RefState.c_int, RefState.L, RefState.N);
     LiebLin_Bethe_State Nmin1State(RefState.c_int, RefState.L, RefState.N - 1);
 
     Nplus1State.Compute_All(true);
-    //NState.Compute_All(true);
     Nmin1State.Compute_All(true);
 
-    //return(NState.E - Nmin1State.E);
     return(0.5 * (Nplus1State.E - Nmin1State.E));
   }
 

src/LIEBLIN/LiebLin_Matrix_Element_Contrib.cc

 
 namespace ABACUS {
 
-  //DP Compute_Matrix_Element_Contrib (char whichDSF, bool fixed_iK, LiebLin_Bethe_State& LeftState,
-  //				     LiebLin_Bethe_State& RefState, DP Chem_Pot, fstream& DAT_outfile)
-  //DP Compute_Matrix_Element_Contrib (char whichDSF, int iKmin, int iKmax, LiebLin_Bethe_State& LeftState,
-  //				     LiebLin_Bethe_State& RefState, DP Chem_Pot, fstream& DAT_outfile)
   DP Compute_Matrix_Element_Contrib (char whichDSF, int iKmin, int iKmax, LiebLin_Bethe_State& LeftState,
 				     LiebLin_Bethe_State& RefState, DP Chem_Pot, stringstream& DAT_outfile)
   {
     else if (whichDSF == 'g')
       ME = real(exp(ln_Psi_ME (RefState, LeftState)));
     else if (whichDSF == 'q') // geometrical quench
-      //ME_CX = (LiebLin_Twisted_ln_Overlap(1.0, RefState.lambdaoc, RefState.lnnorm, LeftState));
-      //ME_CX = (LiebLin_ln_Overlap(RefState.lambdaoc, RefState.lnnorm, LeftState));
       ME_CX = LiebLin_ln_Overlap(LeftState.lambdaoc, LeftState.lnnorm, RefState);
     else if (whichDSF == 'B') { // BEC to finite c quench: g2(x=0)
-      //ME_CX = exp(ln_Overlap_with_BEC (LeftState)); // overlap part
-      ME_CX = exp(ln_Overlap_with_BEC (LeftState) - ln_Overlap_with_BEC (RefState)); // overlap part, relative to saddle-point state
-      ME = real(exp(ln_g2_ME (RefState, LeftState))); // matrix element part
+      // overlap part, relative to saddle-point state
+      ME_CX = exp(ln_Overlap_with_BEC (LeftState) - ln_Overlap_with_BEC (RefState));
+      // matrix element part
+      ME = real(exp(ln_g2_ME (RefState, LeftState)));
       // The product is ME_CX * ME = e^{-\delta S_e} \langle \rho_{sp} | g2 (x=0) | \rho_{sp} + e \rangle
       // and is the first half of the t-dep expectation value formula coming from the Quench Action formalism
     }
       if (whichDSF == 'Z') {
 	DAT_outfile << endl << LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot << "\t"
 		    << LeftState.iK - RefState.iK
-	  //<< "\t" << LeftState.conv
 		    << 0 << "\t" // This is the deviation, here always 0
 		    << "\t" << LeftState.label;
       }
 	DAT_outfile << endl << LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot << "\t"
 		    << LeftState.iK - RefState.iK << "\t"
 		    << real(ME_CX) << "\t" << imag(ME_CX) - twoPI * int(imag(ME_CX)/twoPI + 1.0e-10) << "\t"
-	  //<< LeftState.conv << "\t"
 		    << 0 << "\t" // This is the deviation, here always 0
 		    << LeftState.label;
       }
 	DAT_outfile << endl << LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot << "\t"
 		    << LeftState.iK - RefState.iK << "\t"
 		    << ME << "\t"
-	  //<< LeftState.conv << "\t"
 		    << 0 << "\t" // This is the deviation, here always 0
 		    << LeftState.label;
 	DAT_outfile << "\t" << Momentum_Right_Excitations(LeftState) << "\t" << Momentum_Left_Excitations(LeftState);
-	//cout << Momentum_Right_Excitations(LeftState) << "\t" << Momentum_Left_Excitations(LeftState);
       }
       else if (whichDSF == 'B') { // BEC to finite c > 0 quench; g2 (x=0)
 	if (fabs(real(ME_CX) * ME) > 1.0e-100)
 		      << LeftState.iK - RefState.iK << "\t"
 		      << real(ME_CX) << "\t" // the overlap is always real
 		      << ME << "\t"
-	    //<< 0 << "\t" // This is the deviation, here always 0 // omit this here
 		      << LeftState.label;
       }
       else if (whichDSF == 'C') { // BEC to finite c, overlap sq
 		      << LeftState.iK - RefState.iK << "\t"
 		      << real(ME_CX) << "\t" // the overlap is always real
 		      << ME << "\t"
-	    //<< 0 << "\t" // This is the deviation, here always 0 // omit this here
 		      << LeftState.label;
       }
       else {
 	DAT_outfile << endl << LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot << "\t"
 		    << LeftState.iK - RefState.iK << "\t"
 		    << ME << "\t"
-	  //<< LeftState.conv << "\t"
 		    << 0 << "\t" // This is the deviation, here always 0
 		    << LeftState.label;
       }
       data_value = 1.0/(1.0 + LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot);
     else if (whichDSF == 'd' || whichDSF == '1') {
       if (fixed_iK)
-	/*
-	// use omega * MEsq/iK^2
-	//data_value = (LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot)
-      // MEsq/ABACUS::max(1, (LeftState.iK - RefState.iK) * (LeftState.iK - RefState.iK))
-	//: 0.0;
-	*/
-	// Careful: use fabs(E) since this must also work with Tgt0 or arbitrary RefState DEPRECATED ++G_1, USE abs_data_value
 	data_value = (LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot) * ME * ME;
-      else if (!fixed_iK) // use ME if momentum in fundamental window -iK_UL <= iK <= iK_UL
-	//data_value = abs(LeftState.iK - RefState.iK) <= RefState.Tableau[0].Ncols ?  // this last nr is iK_UL
-	    //MEsq : 0.0;
-	//data_value = (LeftState.iK - RefState.iK == 0 ? 1.0 : 2.0) * MEsq;
-	//data_value = ME * ME;
-	// use omega * MEsq/iK^2
-	// Careful: use fabs(E) since this must also work with Tgt0 or arbitrary RefState DEPRECATED ++G_1, USE abs_data_value
-	data_value = (LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot) * ME * ME/ABACUS::max(1, (LeftState.iK - RefState.iK) * (LeftState.iK - RefState.iK));
+      else if (!fixed_iK)
+	data_value = (LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot) * ME * ME
+	  /ABACUS::max(1, (LeftState.iK - RefState.iK) * (LeftState.iK - RefState.iK));
     }
     else if (whichDSF == 'g' || whichDSF == 'o') {
       if (fixed_iK)
-	/*
-	// use omega * MEsq/((k^2 - mu + 4 c N/L)/L)
-	data_value = (LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot)
-	* MEsq/((((LeftState.K - RefState.K) * (LeftState.K - RefState.K) - Chem_Pot) + 4.0 * RefState.c_int * RefState.N/RefState.L)/RefState.L)
-	: 0.0;
-	*/
-	// Careful: use fabs(E) since this must also work with Tgt0 or arbitrary RefState
 	data_value = (LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot) * ME * ME;
-      else if (!fixed_iK) { // simply use MEsq if momentum in fundamental window -iK_UL <= iK <= iK_UL
-	//data_value = abs(LeftState.iK - RefState.iK) <= RefState.Tableau[0].Ncols ?  // this last nr is iK_UL
-	//MEsq : 0.0;
-	//data_value = (LeftState.iK - RefState.iK == 0 ? 1.0 : 2.0) * MEsq;
+      else if (!fixed_iK) {
 	data_value = ME * ME;
-	//data_value = fabs(LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot) * ME * ME;
-	// In the case of whichDSF == 'o', the state with label (N-1)_0_ gives zero data_value. Force to 1.
-	//if (whichDSF == 'o' && fabs(LeftState.E - RefState.E - (LeftState.N - RefState.N) * Chem_Pot) < 1.0e-10) data_value = 1.0;
       }
     }
-    //else if (whichDSF == 'o')
-    //data_value = abs(LeftState.iK - RefState.iK) <= RefState.Tableau[0].Ncols ?  // this last nr is iK_UL
-    //MEsq : 0.0;
     else if (whichDSF == 'q')
       data_value = exp(2.0 * real(ME_CX));
     else if (whichDSF == 'B')

src/LIEBLIN/LiebLin_State_Ensemble.cc

     : nstates(nstates_req), state(Vect<LiebLin_Bethe_State>(RefState, nstates_req)), weight(1.0/nstates_req, nstates_req)
   {
   }
-  /*
-  LiebLin_Diagonal_State_Ensemble::LiebLin_Diagonal_State_Ensemble (const LiebLin_Bethe_State& RefState, int nstates_req, const Vect<DP>& weight_ref)
-    : nstates(nstates_req), state(Vect<LiebLin_Bethe_State>(RefState, nstates_req)), weight(weight_ref)
-  {
-    if (weight_ref.size() != nstates_req) ABACUSerror("Incompatible vector size in LiebLin_Diagonal_State_Ensemble constructor.");
-  }
-  */
 
   // Recursively go through all arbitrary-order type 2 descendents
   void Generate_type_2_descendents (LiebLin_Bethe_State& ActualState, int* ndesc_ptr, const LiebLin_Bethe_State& OriginState)
   }
 
 
-
-
-  //LiebLin_Diagonal_State_Ensemble::LiebLin_Diagonal_State_Ensemble (DP c_int, DP L, int N, const Root_Density& rho, int nstates_req)
-  //: nstates(nstates_req)
   LiebLin_Diagonal_State_Ensemble::LiebLin_Diagonal_State_Ensemble (DP c_int, DP L, int N, const Root_Density& rho)
   {
+    // This function returns a state ensemble matching the continuous density rho.
+    // The logic closely resembles the one used in Discretized_LiebLin_Bethe_State.
+
     //version with 4 states in ensemble
 
     Root_Density x(rho.Npts, rho.lambdamax);
 	x.value[ix] += 2.0 * rho.value[ip] * rho.dlambda[ip] * atan ((x.lambda[ix] - rho.lambda[ip])/c_int);
       }
       x.value[ix] /= 2.0*PI; //normalization
-
-      //cout << x.lambda[ix] << "\t" << x.value[ix] << "\t" << rho.lambda[ix] "\t" << rho.value[ix] <<endl;
     }
 
     // Now carry on as per Discretized_LiebLin_Bethe_State:
     for (int i = 0; i < rho.Npts; ++i) {
       integral_prev = integral;
       integral += L * rho.value[i] * rho.dlambda[i];
-      //cout << x.value[i] << "\t" << integral << endl;
       if (integral > Nfound + 0.5) {
 	// Subtle error: if the rho is too discontinuous, i.e. if more than one rapidity is found, must correct for this.
-		if (integral > Nfound + 1.5 && integral < Nfound + 2.5) { // found two rapidities
-		  ABACUSerror("The distribution of particles is too discontinous for discretisation");
-		}
-
-		else {
-		  // few variables to clarify the computations, they do not need to be vectors, not used outside this loop
-		  //Ix2_found[Nfound] = 2.0 * L *  (x.value[i] * (integral - Nfound - 0.5) + x.value[i-1] * (Nfound + 0.5 - integral_prev))/(integral - integral_prev);
-		  Ix2_found[Nfound] = 2.0 * L * x.Return_Value(rho.lambda[i]);
-
-		  Ix2_left = floor(Ix2_found[Nfound]);
-		  Ix2_left -= (Ix2_left + N + 1)%2 ? 1 : 0;	//adjust parity
-
-		  Ix2_right = ceil(Ix2_found[Nfound]);
-		  Ix2_right += (Ix2_right + N + 1)%2 ? 1 : 0;	//adjust parity
-
-		  int Ix2_in = (Ix2_found[Nfound] > 0 ? Ix2_left : Ix2_right);
-		  int Ix2_out = (Ix2_found[Nfound] > 0 ? Ix2_right : Ix2_left);
-		  cout << rho.lambda[i] << "\t" << x.Return_Value(rho.lambda[i]) << "\t" << Ix2_found[Nfound] << endl;
-
-		  //choose the saddle point state and remember the uncertain choices
-		  if(Ix2_found[Nfound] - Ix2_left < 0.5) {
-			state[0].Ix2[Nfound] = Ix2_left;
-			state[1].Ix2[Nfound] = Ix2_left;
-			state[2].Ix2[Nfound] = Ix2_left;
-			state[3].Ix2[Nfound] = Ix2_left;
-		  }
-		  else if (Ix2_right - Ix2_found[Nfound] < 0.5) {
-			state[0].Ix2[Nfound] = Ix2_right;
-			state[1].Ix2[Nfound] = Ix2_right;
-			state[2].Ix2[Nfound] = Ix2_right;
-			state[3].Ix2[Nfound] = Ix2_right;
-		  }
-		  else { //it's a kind of magic: the zeroth goes in whle the first goes out, the second goes left if the third goes right
-		  	state[0].Ix2[Nfound] = Ix2_in;
-		  	state[1].Ix2[Nfound] = Ix2_out;
-		  	state[2+change].Ix2[Nfound] = Ix2_left;
-		  	state[2+!change].Ix2[Nfound] = Ix2_right;
-		  	change = !change;
-		  	++n_moves;
-		  }
-		  Nfound++;
-		}
+	if (integral > Nfound + 1.5 && integral < Nfound + 2.5) { // found two rapidities
+	  ABACUSerror("The distribution of particles is too discontinous for discretisation");
+	}
+
+	else {
+	  // few variables to clarify the computations, they do not need to be vectors, not used outside this loop
+	  Ix2_found[Nfound] = 2.0 * L * x.Return_Value(rho.lambda[i]);
+
+	  Ix2_left = floor(Ix2_found[Nfound]);
+	  Ix2_left -= (Ix2_left + N + 1)%2 ? 1 : 0;	//adjust parity
+
+	  Ix2_right = ceil(Ix2_found[Nfound]);
+	  Ix2_right += (Ix2_right + N + 1)%2 ? 1 : 0;	//adjust parity
+
+	  int Ix2_in = (Ix2_found[Nfound] > 0 ? Ix2_left : Ix2_right);
+	  int Ix2_out = (Ix2_found[Nfound] > 0 ? Ix2_right : Ix2_left);
+	  cout << rho.lambda[i] << "\t" << x.Return_Value(rho.lambda[i]) << "\t" << Ix2_found[Nfound] << endl;
+
+	  //choose the saddle point state and remember the uncertain choices
+	  if(Ix2_found[Nfound] - Ix2_left < 0.5) {
+	    state[0].Ix2[Nfound] = Ix2_left;
+	    state[1].Ix2[Nfound] = Ix2_left;
+	    state[2].Ix2[Nfound] = Ix2_left;
+	    state[3].Ix2[Nfound] = Ix2_left;
+	  }
+	  else if (Ix2_right - Ix2_found[Nfound] < 0.5) {
+	    state[0].Ix2[Nfound] = Ix2_right;
+	    state[1].Ix2[Nfound] = Ix2_right;
+	    state[2].Ix2[Nfound] = Ix2_right;
+	    state[3].Ix2[Nfound] = Ix2_right;
+	  }
+	  else {
+	    //it's a kind of magic: the zeroth goes in whle the first goes out,
+	    //the second goes left if the third goes right
+	    state[0].Ix2[Nfound] = Ix2_in;
+	    state[1].Ix2[Nfound] = Ix2_out;
+	    state[2+change].Ix2[Nfound] = Ix2_left;
+	    state[2+!change].Ix2[Nfound] = Ix2_right;
+	    change = !change;
+	    ++n_moves;
+	  }
+	  Nfound++;
+	}
       }
-      //cout << "\ti = " << i << "\tintegral = " << integral << "\tNfound = " << Nfound << endl;
     }
-    //cout << endl;
 
     //fix state[3] and state[4]
     for(int i=0; i<N-1; ++i) {
     if(!all_Diff) {
       //check if the first two states are different
       if(state[0].Ix2 == state[1].Ix2)
-	ABACUSerror("Cannot create 4 (nor 2) different states in LiebLin_Diagonal_State_Ensemble. Consider increasing system size");
+	ABACUSerror("Cannot create 4 (nor 2) different states in LiebLin_Diagonal_State_Ensemble. "
+		    "Consider increasing system size");
       else {
 	nstates = 2;
 	weight[0] = 0.5;
 	weight[1] = 0.5;
       }
     }
-    //set the weights accordingly to the distance between the states.
-//   	int n_moves_2 = 0, n_moves_3 = 0;
-//   	for(int i=0; i < N; ++i) {
-//   		if (!state[0].Ix2.is_in(state[2].Ix2[i])) ++n_moves_2;
-//   		if (!state[0].Ix2.is_in(state[3].Ix2[i])) ++n_moves_3;
-//   	}
-//
-//   	n_moves_2 = min(n_moves_2, n_moves - n_moves_2);
-//   	n_moves_3 = min(n_moves_3, n_moves - n_moves_3);
-//
-//   	weight[2] *= 2.0*n_moves_2/n_moves;
-//   	weight[3] *= 2.0*n_moves_3/n_moves;
-//
-//   	DP sum_weight = weight[0] + weight[1] + weight[2] + weight[3];
 
     for(int i=0; i<nstates; ++i) {
-      //weight[i] /= sum_weight;
       state[i].Set_Label_from_Ix2(state[0].Ix2);
       state[i].Compute_All(true);
     }
 
 
-    cout << weight[0] << "\t" << state[0].Ix2 << endl << weight[0] << "\t" << state[1].Ix2 << endl;// << state[2].Ix2 << endl << state[3].Ix2 << endl;
+    cout << weight[0] << "\t" << state[0].Ix2 << endl << weight[0] << "\t" << state[1].Ix2 << endl;
 
     return;
-
-
-    //old working version but not enough to saturate +fsumrule
-/*
-  	Root_Density x = rho;
-  	for(int ix=0; ix<x.Npts; ++ix) {
-  		x.value[ix] = x.lambda[ix];
-  		for( int ip=0; ip<rho.Npts; ++ip) {
-  			x.value[ix] += 2.0 * rho.value[ip] * rho.dlambda[ip] * atan ((x.lambda[ix] - rho.lambda[ip])/c_int);
-  		}
-  		x.value[ix] /= 2.0*PI; //normalization
-  	}
-
-    // Now carry on as per Discretized_LiebLin_Bethe_State:
-    // Each time N \int_{-\infty}^\lambda d\lambda' \rho(\lambda') crosses a half integer, add a particle:
-    DP integral = 0.0;
-    DP integral_prev = 0.0;
-    int Nfound = 0;
-    Vect<DP> Ix2_found(0.0, N);
-    int Ix2_left, Ix2_right;
-    Vect<int> Ix2(N);
-    Vect<int> Ix2_uncertain(0, N);
-    Vect<int> index_uncertain(0, N);
-    int n_uncertain = 0, n_states_raw = 1;
-
-    for (int i = 0; i < rho.Npts; ++i) {
-      integral_prev = integral;
-      integral += L * rho.value[i] * rho.dlambda[i];
-      //cout << x.value[i] << "\t" << integral << endl;
-      if (integral > Nfound + 0.5) {
-	// Subtle error: if the rho is too discontinuous, i.e. if more than one rapidity is found, must correct for this.
-		if (integral > Nfound + 1.5 && integral < Nfound + 2.5) { // found two rapidities
-		  ABACUSerror("The distribution of particles is too discontinous for discretisation");
-		}
-
-		else {
-		  // few variables to clarify the computations, they do not need to be vectors, not used outside this loop
-		  Ix2_found[Nfound] = 2.0 * L *  (x.value[i] * (integral - Nfound - 0.5) + x.value[i-1] * (Nfound + 0.5 - integral_prev))/(integral - integral_prev);
-
-		  Ix2_left = floor(Ix2_found[Nfound]);
-		  Ix2_left -= (Ix2_left + N + 1)%2 ? 1 : 0;	//adjust parity
-
-		  Ix2_right = ceil(Ix2_found[Nfound]);
-		  Ix2_right += (Ix2_right + N + 1)%2 ? 1 : 0;	//adjust parity
-
-		  //cout << Ix2_found[Nfound] << "\t";
-
-		  //choose the saddle point state and remember the uncertain choices
-		  if(Ix2_found[Nfound] - Ix2_left < 1) {
-			Ix2[Nfound] = Ix2_left;
-			if(Ix2_found[Nfound] - Ix2_left > 0.75) {
-				Ix2_uncertain[n_uncertain] = -1;
-				index_uncertain[n_uncertain] = Nfound;
-				++n_uncertain;
-				n_states_raw *= 2;
-			}
-		  }
-		  else if (Ix2_right - Ix2_found[Nfound] < 1) {
-			Ix2[Nfound] = Ix2_right;
-			if(Ix2_right - Ix2_found[Nfound] > 0.75) {
-				Ix2_uncertain[n_uncertain] = 1;
-				index_uncertain[n_uncertain] = Nfound;
-				++n_uncertain;
-				n_states_raw *= 2;
-			}
-		  }
-		  else ABACUSerror("Cannot deduce a quantum number from x(lambda)");
-		  Nfound++;
-		}
-      }
-      //cout << "\ti = " << i << "\tintegral = " << integral << "\tNfound = " << Nfound << endl;
-    }
-  	//cout << endl;
-
-  	//cout << Ix2 << endl;
-
-  	// create ensamble of states and compute its weights with respect to exact Ix2 saddle point
-  	Vect<Vect<int> > Ix2states(Ix2, n_states_raw);
-  	Vect<DP> Ix2weight(0.0, n_states_raw);
-
-// 	Ix2states[0] = Ix2;
-//	Ix2weight[0] = ;
-  	int n_states_proper = 0;
-	for(int i=0; i < n_states_raw; ++i) {
-		//only symmetric modifications
-		for(int mod_index = 0; mod_index<n_uncertain; ++mod_index) {
-			if((i & (1 << mod_index)) >> mod_index != 0) {
-				Ix2states[n_states_proper][index_uncertain[mod_index]] += (-2)*Ix2_uncertain[mod_index];
-				////Ix2states[state_index][N - 1 - hole_position[mod_index]] += (2)*holes[hole_position[mod_index]];
-			}
-		}
-		//check if it's a proper set of quantum numbers
-		bool OK = true;
-		for(int j=0; j<N-1; ++j) if(Ix2states[n_states_proper][j] == Ix2states[n_states_proper][j+1]) OK = false;
-
-		if(OK) {
-			DP sum = 0;
-			for(int j=0; j<N; ++j) sum += abs(Ix2_found[j] - Ix2states[n_states_proper][j]);
-			Ix2weight[n_states_proper] = exp(-sum);
-			n_states_proper++;
-		}
-		else Ix2states[n_states_proper] = Ix2;
-	}
-
-
-
-	//sort the states in increasing weight order;
-	Vect<int> index(0, n_states_raw);
-    for (int nrs = 0; nrs < n_states_raw; ++nrs) index[nrs] = nrs;
-    Ix2weight.QuickSort(index);
-
-    //cut the number of states if above 21 <- arbitrary number for now
-    nstates = min(n_states_proper, 21);
-    cout << n_states_raw << "\t" << n_states_proper << "\t" << nstates << endl;
-
-    //create ensamble of states with normalised weights and ordered accordingly
-	LiebLin_Bethe_State rhostate(c_int, N, L);
-    rhostate.Ix2 = Ix2;
-    rhostate.Compute_All(true);
-
-	state = Vect<LiebLin_Bethe_State>(rhostate, nstates);
-    weight = Vect<DP>(nstates);
-
-    DP sum_weight = 0.0;
-    for(int i=0; i<nstates; ++i) {
-    	state[i].Ix2 = Ix2states[index[n_states_raw - i - 1]];
-    	state[i].Set_Label_from_Ix2 (state[0].Ix2);
-    	weight[i] = Ix2weight[n_states_raw - i - 1];
-    	sum_weight += weight[i];
-    }
-
-    //renormalise
-    for(int i=0; i<nstates; ++i) weight[i] /= sum_weight;
-
-//    for(int i=0; i<nstates; ++i) {
-//    	cout << weight[i] << "\t" << state[i].Ix2 << endl;
-//    }
-
-    return;
-*/
-  	//cout << rho_t.value << endl;
-
-  	// different attempts - to delete soon
-//  	ABACUSerror("Stop here.");
-/*
-
-    // This function returns a state ensemble matching the continuous density rho.
-    // The logic closely resembles the one used in Discretized_LiebLin_Bethe_State.
-
-    // Now carry on as per Discretized_LiebLin_Bethe_State:
-    // Each time N \int_{-\infty}^\lambda d\lambda' \rho(\lambda') crosses a half integer, add a particle:
-    DP integral = 0.0;
-    DP integral_prev = 0.0;
-    int Nfound = 0;
-    Vect<DP> lambda_found(0.0, 2*N);
-
-    for (int i = 0; i < rho.Npts; ++i) {
-      integral_prev = integral;
-      integral += L * rho.value[i] * rho.dlambda[i];
-      //cout << x.value[i] << "\t" << integral << endl;
-      if (integral > Nfound + 0.5) {
-      cout << L*x.value[i] << "\t" << integral << endl;
-	// Subtle error: if the rho is too discontinuous, i.e. if more than one rapidity is found, must correct for this.
-	if (integral > Nfound + 1.5 && integral < Nfound + 2.5) { // found two rapidities
-	  lambda_found[Nfound++] = 0.25 * (3.0 * rho.lambda[i-1] + rho.lambda[i]);
-	  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:
-    for (int il = 0; il < ABACUS::min(N, Nfound); ++il) lambda[il] = lambda_found[il];
-    // If there are missing ones, put them at the end; ideally, this should never be called
-    for (int il = Nfound; il < N; ++il) lambda[il] = lambda_found[Nfound-1] + (il - Nfound + 1) * (lambda_found[Nfound-1] - lambda_found[Nfound-2]);
-
-	//cout << lambda << endl;
-*/
-	//try a different method
-	//first determine bins, that is intervals in lambda which contain a single rapidity
-/*
-	Vect<int> lambda_bin(0.0, N+1);
-	integral = 0.0;
-	Nfound = 0;
-
-	lambda_bin[0] = 0;
-	lambda_bin[N] = rho.Npts-1;
-	for(int i=0; i<rho.Npts; ++i) {
-		integral += L * rho.value[i] * rho.dlambda[i];
-		if (integral > Nfound + 1.0) lambda_bin[++Nfound] = i - (rho.lambda[i]>0);
-	}
-
-	//put rapidity at the mean value of the distribution inside the bin
-	for(int ib=0; ib < N; ++ib) {
-		lambda_found[ib] = 0.0;
-		for(int i=lambda_bin[ib]; i<lambda_bin[ib+1]; ++i) lambda_found[ib] += L * rho.value[i] * rho.lambda[i] * rho.dlambda[i];
-	}
-
-	//cout << lambda_found << endl;
-
-	for(int i=0; i<N; ++i) cout << L*lambda[i]/PI << "\t" << L*lambda_found[i]/PI << endl;
-
-
-	ABACUSerror("Stop here.");
-*/
-/*
-    // Calculate quantum numbers: 2\pi * (L lambda + \sum_j 2 atan((lambda - lambda_j)/c)) = I_j
-    // Use rounding.
-    Vect<DP> Ix2_exact(N);
-    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_exact[i] = (L * lambda[i] + sum)/PI;
-	  Ix2_left[i] = floor(Ix2_exact[i]);
-	  Ix2_left[i] -= (Ix2_left[i] + N + 1)%2 ? 1 : 0;
-	  Ix2_right[i] = ceil(Ix2_exact[i]);
-	  Ix2_right[i] += (Ix2_right[i] + N + 1)%2 ? 1 : 0;
-
-	  //cout << Ix2_left[i] << "\t" << Ix2_exact[i] << "\t" << Ix2_right[i] << endl;
-      //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;
-*/
-
-/*
-	//create the reference state and mark possible hole positions
-	Vect<int> Ix2(N);
-	Vect<float> holes(0.0, N);
-	for(int i=0; i < N; ++i) {
-		if(Ix2_found[i] - Ix2_left[i] < 1) {
-			Ix2[i] = Ix2_left[i];
-				if(Ix2_found[i] - Ix2_left[i] > 0.75) holes[i] = -1;
-		}
-		else {
-			Ix2[i] = Ix2_right[i];
-			if(Ix2_right[i] - Ix2_found[i] > 0.75) holes[i] = 1;
-		}
-	}
-*/
-//	cout << endl << Ix2 << endl;
-//	cout << endl << holes << endl;
-/*
-	//count number of possible states
-	int n = 0;
-	for(int i=0; i < N; ++i) {
-		if(holes[i] != 0) ++n;
-	}
-	int n_states_raw = 1;
-*/
-/* only symmetric modifications
-	for(int i=0; i<0.5*n; ++i) n_states_raw *= 2.0; //we count only symmetric modiications
-
-	Vect<Vect<int> > Ix2states(Ix2, n_states_raw);
-
-	Vect<int> hole_position(0, 0.5*n);
-	int hole_index = 0;
-	for(int i=N/2 + N%2; i<N; ++i) {
-		if(holes[i] != 0) hole_position[hole_index++] = i;
-	}
-
-
-	//create modifications, we use bit representation of integers between 0 and n_states-1 treating zero as no change and 1 as mutltiplication by -1
-	int state_index = 1;
-	for(int i=1; i < n_states_raw; ++i) {
-		//only symmetric modifications
-		for(int mod_index = 0; mod_index<0.5*n; ++mod_index) {
-			if((i & (1 << mod_index)) >> mod_index != 0) {
-				Ix2states[state_index][hole_position[mod_index]] += (-2)*holes[hole_position[mod_index]];
-				Ix2states[state_index][N - 1 - hole_position[mod_index]] += (2)*holes[hole_position[mod_index]];
-			}
-		}
-		//check if it's a proper set of quantum numbers
-		bool OK = true;
-		for(int j=0; j<N-1; ++j) if(Ix2states[state_index][j] == Ix2states[state_index][j+1]) OK = false;
-
-		if(OK) state_index++;
-		else Ix2states[state_index] = Ix2;
-	}
-*/
-/*
-	for(int i=0; i<n; ++i) n_states_raw *= 2.0; //we count all posibilities
-
-	Vect<Vect<int> > Ix2states(Ix2, n_states_raw);
-
-	Vect<int> hole_position(0, n);
-	int hole_index = 0;
-	for(int i=0; i<N; ++i) {
-		if(holes[i] != 0) hole_position[hole_index++] = i;
-	}
-
-
-	//create modifications, we use bit representation of integers between 0 and n_states-1 treating zero as no change and 1 as mutltiplication by -1
-	int state_index = 1;
-	for(int i=1; i < n_states_raw; ++i) {
-		//only symmetric modifications
-		for(int mod_index = 0; mod_index<n; ++mod_index) {
-			if((i & (1 << mod_index)) >> mod_index != 0) {
-				Ix2states[state_index][hole_position[mod_index]] += (-2)*holes[hole_position[mod_index]];
-				//Ix2states[state_index][N - 1 - hole_position[mod_index]] += (2)*holes[hole_position[mod_index]];
-			}
-		}
-		//check if it's a proper set of quantum numbers
-		bool OK = true;
-		for(int j=0; j<N-1; ++j) if(Ix2states[state_index][j] == Ix2states[state_index][j+1]) OK = false;
-
-		if(OK) state_index++;
-		else Ix2states[state_index] = Ix2;
-	}
-
-*/
-/*
-	n_states_raw = state_index;
-//	for(int i=0; i<n_states; ++i) cout << Ix2states[i] << endl;
-
-	LiebLin_Bethe_State rhostate(c_int, N, L);
-    rhostate.Ix2 = Ix2;
-    rhostate.Compute_All(true);
-
-	Vect<LiebLin_Bethe_State> state_raw = Vect<LiebLin_Bethe_State>(rhostate, n_states_raw);
-    Vect<DP> weight_raw(0.0, n_states_raw);
-*/
-
-/*
-    DP energy_rho = 0;
-    for (int i = 0; i < rho.Npts; ++i) {
-		energy_rho += L * rho.value[i] * rho.dlambda[i] * rho.lambda[i] * rho.lambda[i];
-    }
-
-    cout << energy_rho << endl;
-
-    DP energy_discrete = 0;
-    for (int i=0; i < N; ++i) {
-    	energy_discrete += lambda[i] * lambda[i];
-    }
-    energy_discrete /= N;
-    cout << energy_discrete;
-*/
-/*
-	DP sum_weight_raw = 0.0;
-    for(int i=0; i<n_states_raw; ++i) {
-    	//state_raw[i].Ix2 = Ix2states[i];
-    	//state_raw[i].Set_Label_from_Ix2 (state_raw[0].Ix2);
-    	//state_raw[i].Compute_All(true);
-    	DP sum = 0;
-    	for(int j=0; j<N; ++j) sum += fabs(Ix2states[i][j] - Ix2_found[j]);
-    	weight_raw[i] = exp(sum)/L;
-
-    	sum_weight_raw += weight_raw[i];
-    }
-
-    for(int i=0; i<n_states_raw; ++i) weight_raw[i] /= sum_weight_raw;
-
-    // Order the weights in decreasing value:
-    Vect<int> index(n_states_raw);
-    for (int nrs = 0; nrs < n_states_raw; ++nrs) index[nrs] = nrs;
-    weight_raw.QuickSort(index);
-
-    //nstates = 0;
-    //for(int i=0; i<n_states_raw; ++i) if (weight_raw[i] > 0.01) ++nstates;
-
-    nstates = ABACUS::min(n_states_raw, 21);
-
-    cout << nstates << endl;
-
-	state = Vect<LiebLin_Bethe_State>(rhostate, nstates);
-    weight = Vect<DP>(nstates);
-
-    DP sum_weight = 0.0;
-    for(int i=0; i<nstates; ++i) {
-    	state[i].Ix2 = Ix2states[index[i]];
-    	state[i].Set_Label_from_Ix2 (state[0].Ix2);
-    	weight[i] = weight_raw[index[i]];
-    	sum_weight += weight[i];
-    }
-
-    //renormalise
-    for(int i=0; i<nstates; ++i) weight[i] /= sum_weight;
-
-    for(int i=0; i<nstates; ++i) {
-    	cout << weight[i] << "\t" << state[i].Ix2 << endl;
-    }
-*/
-	//ABACUSerror("Stop here.");
-
-	// end of different attempts
-/*
-    // Check that the quantum numbers are all distinct:
-    bool allOK = false;
-    while (!allOK) {
-      for (int i = 0; i < N-1; ++i) if (Ix2[i] == Ix2[i+1] && Ix2[i] < 0) Ix2[i] -= 2;
-      for (int i = 1; i < N; ++i) if (Ix2[i] == Ix2[i-1] && Ix2[i] > 0) Ix2[i] += 2;
-      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, N, L);
-    rhostate.Ix2 = Ix2;
-    rhostate.Compute_All(true);
-    //cout << "rapidities of state found: " << rhostate.lambda << endl;
-
-    // Until here, the code is identical to that in Discretized_LiebLin_Bethe_State.
-    // Construct states in the vicinity by going through type 2 descendents recursively:
-    int ndesc_type2 = 0;
-    int* ndesc_type2_ptr = &ndesc_type2;
-    Generate_type_2_descendents (rhostate, ndesc_type2_ptr, rhostate);
-
-
-    cout << "Found " << ndesc_type2 << " descendents for state " << rhostate << endl;
-    //ABACUSerror("Stop here...");
-
-    // Now try to construct states in the vicinity.
-    int nrstates1mod = 1;
-    for (int i = 0; i < N; ++i) {
-      if (i == 0 || Ix2[i-1] < Ix2[i] - 2) nrstates1mod++;
-      if (i == N-1 || Ix2[i+1] > Ix2[i] + 2) nrstates1mod++;
-    }
-    //if (nrstates1mod < nstates_req) ABACUSerror("nrstates1mod < nstates_req in LiebLin_Diagonal_State_Ensemble.");
-    nstates = nrstates1mod;
-
-    Vect<Vect<int> > Ix2states1mod(nrstates1mod);
-    for (int nrs = 0; nrs < nrstates1mod; ++nrs) Ix2states1mod[nrs] = Vect<int> (N);
-
-    int nfound = 0;
-    Ix2states1mod[nfound++] = Ix2; // this is the sp state
-    for (int i = 0; i < N; ++i) {
-      if (i == 0 || Ix2[i-1] < Ix2[i] - 2) {
-	Ix2states1mod[nfound] = Ix2;
-	Ix2states1mod[nfound++][i] -= 2;
-      }
-      if (i == N-1 || Ix2[i+1] > Ix2[i] + 2) {
-	Ix2states1mod[nfound] = Ix2;
-	Ix2states1mod[nfound++][i] += 2;
-      }
-    }
-
-    // Evaluate the weight of all found states:
-    Vect<DP> rawweight(nrstates1mod);
-
-    for (int nrs = 0; nrs < nrstates1mod; ++nrs) {
-      DP sumweight = 0.0;
-      for (int i = 0; i < N; ++i) sumweight += fabs(Ix2states1mod[nrs][i] - Ix2_exact[i]);
-      rawweight[nrs] = exp(-sumweight/log(L));
-    }
-
-    // Order the weights in decreasing value:
-    Vect<int> index(nrstates1mod);
-    for (int nrs = 0; nrs < nrstates1mod; ++nrs) index[nrs] = nrs;
-    rawweight.QuickSort(index);
-
-    // Calculate weight normalization:
-    DP weightnorm = 0.0;
-    //for (int ns = 0; ns < nstates_req; ++ns) weightnorm += rawweight[nrstates1mod - 1 - ns];
-    for (int ns = 0; ns < nstates; ++ns) weightnorm += rawweight[nrstates1mod - 1 - ns];
-
-    state = Vect<LiebLin_Bethe_State>(rhostate, nstates);
-    weight = Vect<DP> (nstates);
-
-    for (int ns = 0; ns < nstates; ++ns) {
-      weight[ns] = rawweight[nrstates1mod - 1 - ns]/weightnorm;
-      state[ns].Ix2 = Ix2states1mod[index[nrstates1mod - 1 - ns] ];
-      state[ns].Set_Label_from_Ix2 (rhostate.Ix2);
-      state[ns].Compute_All(true);
-    }
-*/
-
-
-  }
-
-  /*
-  LiebLin_Diagonal_State_Ensemble::LiebLin_Diagonal_State_Ensemble (DP c_int, DP L, int N, const Root_Density& rho, int nstates_req)
-    : nstates(nstates_req)
-  {
-    // This function returns a state ensemble matching the continuous density rho.
-    // The logic closely resembles the one used in Discretized_LiebLin_Bethe_State.
-
-    // Each `exact' (from rho) quantum number is matched to its two possible values,
-    // assigning a probability to each according to the proximity of the quantum number values.
-
-    // The set is then ordered in energy, and split into nstates_req boxes from which one
-    // representative is selected, and given the probability = sum of probabilities in the box.
-
-
-    // Begin as per Discretized_LiebLin_Bethe_State, to find the saddle-point state.
-    // Each time N \int_{-\infty}^\lambda d\lambda' \rho(\lambda') crosses a half integer, add a particle:
-    DP integral = 0.0;
-    DP integral_prev = 0.0;
-    int Nfound = 0;
-    Vect<DP> lambda_found(0.0, 2*N);
-
-    for (int i = 0; i < rho.Npts; ++i) {
-      integral_prev = integral;
-      integral += L * rho.value[i] * rho.dlambda[i];
-      if (integral > Nfound + 0.5) {
-	// Subtle error: if the rho is too discontinuous, i.e. if more than one rapidity is found, must correct for this.
-	if (integral > Nfound + 1.5 && integral < Nfound + 2.5) { // found two rapidities
-	  lambda_found[Nfound++] = 0.25 * (3.0 * rho.lambda[i-1] + rho.lambda[i]);
-	  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:
-    for (int il = 0; il < ABACUS::min(N, Nfound); ++il) lambda[il] = lambda_found[il];
-    // If there are missing ones, put them at the end; ideally, this should never be called
-    for (int il = Nfound; il < N; ++il) lambda[il] = lambda_found[Nfound-1] + (il - Nfound + 1) * (lambda_found[Nfound-1] - lambda_found[Nfound-2]);
-
-    // Calculate quantum numbers: 2\pi * (L lambda + \sum_j 2 atan((lambda - lambda_j)/c)) = I_j
-    // Use rounding.
-    Vect<DP> Ix2_exact(N);
-    Vect<int> Ix2(N);
-    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_exact[i] = (L * lambda[i] + sum)/PI;
-      //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;
-    while (!allOK) {
-      for (int i = 0; i < N-1; ++i) if (Ix2[i] == Ix2[i+1] && Ix2[i] < 0) Ix2[i] -= 2;
-      for (int i = 1; i < N; ++i) if (Ix2[i] == Ix2[i-1] && Ix2[i] > 0) Ix2[i] += 2;
-      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, N, L);
-    rhostate.Ix2 = Ix2;
-    rhostate.Compute_All(true);
-    //cout << "rapidities of state found: " << rhostate.lambda << endl;
-
-    // Until here, the code is identical to that in Discretized_LiebLin_Bethe_State.
-
-    // Now try to construct states in the vicinity.
-    int nrstates1mod = 1;
-    for (int i = 0; i < N; ++i) {
-      if (i == 0 || Ix2[i-1] < Ix2[i] - 2) nrstates1mod++;
-      if (i == N-1 || Ix2[i+1] > Ix2[i] + 2) nrstates1mod++;
-    }
-    if (nrstates1mod < nstates_req) ABACUSerror("nrstates1mod < nstates_req in LiebLin_Diagonal_State_Ensemble.");
-
-    Vect<Vect<int> > Ix2states1mod(nrstates1mod);
-    for (int nrs = 0; nrs < nrstates1mod; ++nrs) Ix2states1mod[nrs] = Vect<int> (N);
-
-    int nfound = 0;
-    Ix2states1mod[nfound++] = Ix2; // this is the sp state
-    for (int i = 0; i < N; ++i) {
-      if (i == 0 || Ix2[i-1] < Ix2[i] - 2) {
-	Ix2states1mod[nfound] = Ix2;
-	Ix2states1mod[nfound++][i] -= 2;
-      }
-      if (i == N-1 || Ix2[i+1] > Ix2[i] + 2) {
-	Ix2states1mod[nfound] = Ix2;
-	Ix2states1mod[nfound++][i] += 2;
-      }
-    }
-
-    // Evaluate the weight of all found states:
-    Vect<DP> rawweight(nrstates1mod);
-
-    for (int nrs = 0; nrs < nrstates1mod; ++nrs) {
-      DP sumweight = 0.0;
-      for (int i = 0; i < N; ++i) sumweight += fabs(Ix2states1mod[nrs][i] - Ix2_exact[i]);
-      rawweight[nrs] = exp(-sumweight/log(L));
-    }
-
-    // Order the weights in decreasing value:
-    Vect<int> index(nrstates1mod);
-    for (int nrs = 0; nrs < nrstates1mod; ++nrs) index[nrs] = nrs;
-    rawweight.QuickSort(index);
-
-    // Calculate weight normalization:
-    DP weightnorm = 0.0;
-    for (int ns = 0; ns < nstates_req; ++ns) weightnorm += rawweight[nrstates1mod - 1 - ns];
-
-    state = Vect<LiebLin_Bethe_State>(rhostate, nstates_req);
-    weight = Vect<DP> (nstates_req);
-
-    for (int ns = 0; ns < nstates_req; ++ns) {
-      weight[ns] = rawweight[nrstates1mod - 1 - ns]/weightnorm;
-      state[ns].Ix2 = Ix2states1mod[index[nrstates1mod - 1 - ns] ];
-      state[ns].Set_Label_from_Ix2 (rhostate.Ix2);
-      state[ns].Compute_All(true);
-    }
   }
-  */
 
   LiebLin_Diagonal_State_Ensemble& LiebLin_Diagonal_State_Ensemble::operator= (const LiebLin_Diagonal_State_Ensemble& rhs)
   {
     while (getline(infile, dummy))  ++nrlines;
     infile.close();
 
-    //cout << "Found " << nrlines << " lines in ens file." << endl;
     nstates = nrlines;
     LiebLin_Bethe_State examplestate (c_int, L, N);
     state = Vect<LiebLin_Bethe_State> (examplestate, nstates);
   }
 
 
-  //LiebLin_Diagonal_State_Ensemble LiebLin_Thermal_Saddle_Point_Ensemble (DP c_int, DP L, int N, DP kBT, int nstates_req)
   LiebLin_Diagonal_State_Ensemble LiebLin_Thermal_Saddle_Point_Ensemble (DP c_int, DP L, int N, DP kBT)
   {
     // This function constructs a manifold of states around the thermal saddle-point.
     cout << "ebar: " << TBAsol.ebar << endl;
 
     cout << ensemble.state[0].E << endl;
-    //return(LiebLin_Diagonal_State_Ensemble (c_int, L, N, TBAsol.rho, nstates_req));
     return(ensemble);
   }
 

src/LIEBLIN/LiebLin_Sumrules.cc

 
 namespace ABACUS {
 
-  //DP Sumrule_Factor (char whichDSF, LiebLin_Bethe_State& RefState, DP Chem_Pot, bool fixed_iK, int iKneeded)
   DP Sumrule_Factor (char whichDSF, LiebLin_Bethe_State& RefState, DP Chem_Pot, int iKmin, int iKmax)
   {
     DP sumrule_factor = 1.0;
 
-    //if (!fixed_iK) {
     if (iKmin != iKmax) {
       if (whichDSF == 'Z') sumrule_factor = 1.0;
       else if (whichDSF == 'd' || whichDSF == '1') {
 	// Here, we use a measure decreasing in K with K^2.
 	// We sum up omega * MEsq/(iK^2) for all values of iKmin <= iK <= iKmax, discounting iK == 0 (where DSF vanishes)
 	// We therefore have (N/L) x L^{-1} x (2\pi/L)^2 x (iKmax - iKmin + 1) = 4 \pi^2 x N x (iKmax - iKmin + 1)/L^4
-	// Discounting iK == 0 (where DSF vanishes), if iKmin <= 0 && iKmax >= 0 (in which case 0 is containted in [iKmin, iKmax])
+	// Discounting iK == 0 (where DSF vanishes),
+	// if iKmin <= 0 && iKmax >= 0 (in which case 0 is containted in [iKmin, iKmax])
 	sumrule_factor = (iKmin <= 0 && iKmax >= 0) ?
 	  (RefState.L * RefState.L * RefState.L * RefState.L)/(4.0 * PI * PI * RefState.N * (iKmax - iKmin))
 	  : (RefState.L * RefState.L * RefState.L * RefState.L)/(4.0 * PI * PI * RefState.N * (iKmax - iKmin + 1));
-
-	/*
-	// Measure using the g2(0) + delta function:  // DOES NOT WORK VERY WELL
-	DP dE0_dc = LiebLin_dE0_dc (RefState.c_int, RefState.L, RefState.N);
-	//sumrule_factor = 1.0/((dE0_dc + (2.0 * RefState.Tableau[0].Ncols + 1.0)*RefState.N/RefState.L)/RefState.L);
-	// Assume that iKmin == 0 here:
-	//sumrule_factor = 1.0/((dE0_dc + (2*iKmax + 1)*RefState.N/RefState.L)/RefState.L);
-	// For iKmin != 0:
-	sumrule_factor = 1.0/((dE0_dc + (iKmax - iKmin + 1)*RefState.N/RefState.L)/RefState.L);
-	*/
       }
       // For the Green's function, it's the delta function \delta(x = 0) plus the density:
-      //else if (whichDSF == 'g') sumrule_factor = 1.0/((2.0 * RefState.Tableau[0].Ncols + 1.0)/RefState.L + RefState.N/RefState.L);
-      // Assume that iKmin == 0 here:
-      //else if (whichDSF == 'g') sumrule_factor = 1.0/(2.0* iKmax + 1.0)/RefState.L + RefState.N/RefState.L);
       else if (whichDSF == 'g')
 	sumrule_factor = 1.0/((abs(iKmax - iKmin) + 1.0)/RefState.L + RefState.N/RefState.L);
-	//sumrule_factor = 1.0/((pow(twoPI * iKmax/RefState.L, 2.0) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L)/RefState.L);
       // For the one-body function, it's just the density:
       else if (whichDSF == 'o') sumrule_factor = RefState.L/RefState.N;
       else if (whichDSF == 'q') sumrule_factor = 1.0;
       else ABACUSerror("whichDSF option not consistent in Sumrule_Factor");
     }
 
-    //else if (fixed_iK) {
     else if (iKmin == iKmax) {
       if (whichDSF == 'Z') sumrule_factor = 1.0;
       else if (whichDSF == 'd' || whichDSF == '1')
-	//// We sum up omega * MEsq/(iK^2):  this should give (1/L) x (N/L) x k^2 = N x (2\pi)^2/L^4
-	//sumrule_factor = pow(RefState.L, 4.0)/(4.0 * PI * PI * RefState.N);
 	// We sum up omega * MEsq
-	//sumrule_factor = pow(RefState.L, 4.0)/(4.0 * PI * PI * iKneeded * iKneeded * RefState.N);
 	sumrule_factor = pow(RefState.L, 4.0)/(4.0 * PI * PI * iKmax * iKmax * RefState.N);
       else if (whichDSF == 'g' || whichDSF == 'o') {
 	// We sum up omega * MEsq
-	//sumrule_factor = 1.0/((pow(twoPI * iKneeded/RefState.L, 2.0) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L)/RefState.L);
-	sumrule_factor = 1.0/((pow(twoPI * iKmax/RefState.L, 2.0) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L)/RefState.L);
+	sumrule_factor = 1.0/((pow(twoPI * iKmax/RefState.L, 2.0) - Chem_Pot
+			       + 4.0 * RefState.c_int * RefState.N/RefState.L)/RefState.L);
       }
-      //else if (whichDSF == 'o') sumrule_factor = RefState.L/RefState.N;
       else if (whichDSF == 'q') sumrule_factor = 1.0;
       else if (whichDSF == 'B') sumrule_factor = 1.0;
       else if (whichDSF == 'C') sumrule_factor = 1.0;
     return(sumrule_factor);
   }
 
-  void Evaluate_F_Sumrule (char whichDSF, const LiebLin_Bethe_State& RefState, DP Chem_Pot, int iKmin, int iKmax, const char* RAW_Cstr, const char* FSR_Cstr)
+  void Evaluate_F_Sumrule (char whichDSF, const LiebLin_Bethe_State& RefState, DP Chem_Pot,
+			   int iKmin, int iKmax, const char* RAW_Cstr, const char* FSR_Cstr)
   {
 
     ifstream infile;
     }
 
     // We run through the data file to check the f sumrule at each positive momenta:
-    //int iK_UL = RefState.Tableau[0].Ncols;  // this is iK_UL
-    //Vect<DP> Sum_omega_MEsq(0.0, iK_UL + 1);
     Vect_DP Sum_omega_MEsq (0.0, iKmax - iKmin + 1);
     Vect_DP Sum_abs_omega_MEsq (0.0, iKmax - iKmin + 1);
 
 
     DP omega, ME;
     int iK;
-    //int conv;
     DP dev;
     string label;
     int nr, nl;
       nraw++;
       infile >> omega >> iK >> ME >> dev >> label;
       if (whichDSF == '1') infile >> nr >> nl;
-      //if (iK > 0 && iK <= iK_UL) Sum_omega_MEsq[iK] += omega * MEsq;
       if (iK >= iKmin && iK <= iKmax) Sum_omega_MEsq[iK - iKmin] += omega * ME * ME;
       if (iK >= iKmin && iK <= iKmax) Sum_abs_omega_MEsq[iK - iKmin] += fabs(omega * ME * ME);
       Sum_MEsq += ME * ME;
 
     infile.close();
 
-    //cout << "Read " << nraw << " entries in raw file." << endl;
-
     ofstream outfile;
     outfile.open(FSR_Cstr);
     outfile.precision(16);
 
     if (whichDSF == 'd' || whichDSF == '1') {
-      /*
-      outfile << 0 << "\t" << 1;  // full saturation at k = 0 !
-      for (int i = 1; i <= iK_UL; ++i)
-	outfile << endl << i << "\t" << Sum_omega_MEsq[i] * RefState.L * RefState.L
-	  * RefState.L * RefState.L/(4.0 * PI * PI * i * i * RefState.N);
-	  */
 
       for (int i = iKmin; i <= iKmax; ++i) {
 
 	if (i > iKmin) outfile << endl;
-	//outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * pow(RefState.L, 4.0)/(pow(2.0 * PI * ABACUS::max(abs(i), 1), 2.0) * RefState.N);
-	outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * pow(RefState.L, 4.0)/(pow(2.0 * PI * ABACUS::max(abs(i), 1), 2.0) * RefState.N)
+
+	outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * pow(RefState.L, 4.0)
+	  /(pow(2.0 * PI * ABACUS::max(abs(i), 1), 2.0) * RefState.N)
 	  // Include average of result at +iK and -iK in a third column: iK is at index index(iK) = iK - iKmin
 	  // so -iK is at index index(-iK) = -iK - iKmin
 	  // We can only use this index if it is >= 0 and < iKmax - iKmin + 1, otherwise third column is copy of second:
       }
     }
     else if (whichDSF == 'g' || whichDSF == 'o') {
-      /*
-      for (int i = 0; i <= iK_UL; ++i)
-	outfile << endl << i << "\t" << Sum_omega_MEsq[i] * RefState.L
-	  /((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L);
-      //cout << "Sum_MEsq = " << Sum_MEsq << "\tN/L = " << RefState.N/RefState.L << endl;
-      */
       for (int i = iKmin; i <= iKmax; ++i) {
 	if (i > iKmin) outfile << endl;
-	//outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * RefState.L
-	///((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L);
 	outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * RefState.L
 	  /((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L)
 		<< "\t" << ((i + iKmin <= 0 && -i < iKmax + 1) ?
 			    0.5 * (Sum_omega_MEsq[i - iKmin] + Sum_omega_MEsq[-i - iKmin]) : Sum_omega_MEsq[i - iKmin])
-			    * RefState.L/((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L);
+	  * RefState.L/((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L);
       }
     }
 
 
   }
 
-  void Evaluate_F_Sumrule (string prefix, char whichDSF, const LiebLin_Bethe_State& RefState, DP Chem_Pot, int iKmin, int iKmax)
+  void Evaluate_F_Sumrule (string prefix, char whichDSF, const LiebLin_Bethe_State& RefState,
+			   DP Chem_Pot, int iKmin, int iKmax)
   {
 
     stringstream RAW_stringstream;    string RAW_string;
   }
 
   // Using diagonal state ensemble:
-  void Evaluate_F_Sumrule (char whichDSF, DP c_int, DP L, int N, DP kBT, int nstates_req, DP Chem_Pot, int iKmin, int iKmax, const char* FSR_Cstr)
+  void Evaluate_F_Sumrule (char whichDSF, DP c_int, DP L, int N, DP kBT, int nstates_req,
+			   DP Chem_Pot, int iKmin, int iKmax, const char* FSR_Cstr)
   {
 
     // We run through the data file to check the f sumrule at each positive momenta:
 
     DP omega, ME;
     int iK;
-    //int conv;
     DP dev;
     string label;
     int nr, nl;
     LiebLin_Diagonal_State_Ensemble ensemble;
 
     stringstream ensfilestrstream;
-    //ensfilestrstream << "LiebLin_c_int_" << c_int << "_L_" << L << "_N_" << N << "_kBT_" << kBT << "_ns_" << nstates_req << ".ens";
     ensfilestrstream << "LiebLin_c_int_" << c_int << "_L_" << L << "_N_" << N << "_kBT_" << kBT << ".ens";
     string ensfilestr = ensfilestrstream.str();
     const char* ensfile_Cstr = ensfilestr.c_str();
 
       // Define the raw input file name:
       stringstream filenameprefix;
-      //Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, kBT, ensemble.state[ns], ensemble.state[ns], ensemble.state[ns].label);
-      Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, 0.0, ensemble.state[ns], ensemble.state[ns], ensemble.state[ns].label);
+      Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, 0.0, ensemble.state[ns],
+		      ensemble.state[ns], ensemble.state[ns].label);
       string prefix = filenameprefix.str();
       stringstream RAW_stringstream;    string RAW_string;
       RAW_stringstream << prefix << ".raw";
       while (infile.peek() != EOF) {
 	infile >> omega >> iK >> ME >> dev >> label;
 	if (whichDSF == '1') infile >> nr >> nl;
-	//if (iK > 0 && iK <= iK_UL) Sum_omega_MEsq[iK] += omega * MEsq;
 	if (iK >= iKmin && iK <= iKmax) Sum_omega_MEsq[iK - iKmin] += ensemble.weight[ns] * omega * ME * ME;
 	Sum_MEsq += ensemble.weight[ns] * ME * ME;
       }
     outfile.precision(16);
 
     if (whichDSF == 'd' || whichDSF == '1') {
-      /*
-      outfile << 0 << "\t" << 1;  // full saturation at k = 0 !
-      for (int i = 1; i <= iK_UL; ++i)
-	outfile << endl << i << "\t" << Sum_omega_MEsq[i] * RefState.L * RefState.L
-	  * RefState.L * RefState.L/(4.0 * PI * PI * i * i * RefState.N);
-	  */
       for (int i = iKmin; i <= iKmax; ++i) {
 	if (i > iKmin) outfile << endl;
-	//outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * pow(RefState.L, 4.0)/(pow(2.0 * PI * ABACUS::max(abs(i), 1), 2.0) * RefState.N);
-	outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * pow(RefState.L, 4.0)/(pow(2.0 * PI * ABACUS::max(abs(i), 1), 2.0) * RefState.N)
+	outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * pow(RefState.L, 4.0)
+	  /(pow(2.0 * PI * ABACUS::max(abs(i), 1), 2.0) * RefState.N)
 	  // Include average of result at +iK and -iK in a third column: iK is at index index(iK) = iK - iKmin
 	  // so -iK is at index index(-iK) = -iK - iKmin
 	  // We can only use this index if it is >= 0 and < iKmax - iKmin + 1, otherwise third column is copy of second:
       }
     }
     else if (whichDSF == 'g' || whichDSF == 'o') {
-      /*
-      for (int i = 0; i <= iK_UL; ++i)
-	outfile << endl << i << "\t" << Sum_omega_MEsq[i] * RefState.L
-	  /((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L);
-      //cout << "Sum_MEsq = " << Sum_MEsq << "\tN/L = " << RefState.N/RefState.L << endl;
-      */
       for (int i = iKmin; i <= iKmax; ++i) {
 	if (i > iKmin) outfile << endl;
-	//outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * RefState.L
-	///((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L);
 	outfile << i << "\t" << Sum_omega_MEsq[i - iKmin] * RefState.L
 	  /((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L)
 		<< "\t" << ((i + iKmin <= 0 && -i < iKmax + 1) ?
-			    0.5 * (Sum_omega_MEsq[i - iKmin] + Sum_omega_MEsq[-i - iKmin]) : Sum_omega_MEsq[i - iKmin])
-			    * RefState.L/((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L);
+			    0.5 * (Sum_omega_MEsq[i - iKmin] + Sum_omega_MEsq[-i - iKmin])
+			    : Sum_omega_MEsq[i - iKmin]) * RefState.L
+	  /((4.0 * PI * PI * i * i)/(RefState.L * RefState.L) - Chem_Pot + 4.0 * RefState.c_int * RefState.N/RefState.L);
       }
     }
 

src/LIEBLIN/LiebLin_Tgt0.cc

 namespace ABACUS {
 
 
-  /*
-  DP Entropy (LiebLin_Bethe_State& RefState, DP epsilon)
-  {
-    // This function calculates the entropy of a finite Lieb-Liniger state,
-    // using the quantum number space particle and hole densities.
-
-    // The densities are a sum of Gaussians with width epsilon.
-
-    // We calculate \rho (x) and \rho_h (x) for x_j on a fine lattice.
-
-    int Ix2max = RefState.Ix2.max();
-    int Ix2min = RefState.Ix2.min();
-
-    //cout << Ix2max << "\t" << Ix2min << endl;
-
-    // Give a bit of room for leftmost and rightmost particles Gaussians to attain asymptotic values:
-    Ix2max += int(10.0 * RefState.L * epsilon);
-    Ix2min -= int(10.0 * RefState.L * epsilon);
-
-    //cout << Ix2max << "\t" << Ix2min << endl;
-
-    DP xmax = Ix2max/(2.0* RefState.L);
-    DP xmin = Ix2min/(2.0* RefState.L);
-
-    //xmax += 10.0* epsilon;
-    //xmin -= 10.0* epsilon;
-
-    DP dx = 0.1/RefState.L;
-    int Nptsx = int((xmax - xmin)/dx);
-
-    Vect<bool> occupied (false, (Ix2max - Ix2min)/2 + 1); // whether there is a particle or not
-    for (int i = 0; i < RefState.N; ++i) occupied[(RefState.Ix2[i] - Ix2min)/2] = true;
-
-    Vect<double> rho(0.0, Nptsx);
-    Vect<double> rhoh(0.0, Nptsx);
-
-    //cout << xmin << "\t" << xmax << "\t" << dx << "\t" << Nptsx << endl;
-
-    DP x;
-    DP epsilonsq = epsilon * epsilon;
-    DP twoepsilonsq = 2.0 * epsilon * epsilon;
-
-    //Vect<DP> xparticle(RefState.N);
-    //for (int i = 0; i < RefState.N; ++i) xparticle[i] = RefState.Ix2[i]/(2.0* RefState.L);
-    Vect<DP> xarray((Ix2max - Ix2min)/2 + 1);
-    for (int i = 0; i < (Ix2max - Ix2min)/2 + 1; ++i) xarray[i] = (0.5*Ix2min + i)/RefState.L;
-
-    for (int ix = 0; ix < Nptsx; ++ix) {
-      x = xmin + dx * (ix + 0.5);
-      //for (int i = 0; i < RefState.N; ++i) rho[ix] += 1.0/((x - xparticle[i]) * (x - xparticle[i]) + epsilonsq);
-      //rho[ix] *= epsilon/(PI * RefState.L);
-      for (int i = 0; i < (Ix2max - Ix2min)/2 + 1; ++i) {
-	// Using Gaussians:
-	//if (occupied[i]) rho[ix] += exp(-(x - xarray[i]) * (x - xarray[i])/twoepsilonsq);
-	//else rhoh[ix] += exp(-(x - xarray[i]) * (x - xarray[i])/twoepsilonsq);
-	// Using Lorentzians:
-	if (occupied[i]) rho[ix] += 1.0/((x - xarray[i]) * (x - xarray[i]) + epsilonsq);
-	else rhoh[ix] += 1.0/((x - xarray[i]) * (x - xarray[i]) + epsilonsq);
-      }
-      //rho[ix] /= sqrt(twoPI) * epsilon * RefState.L;
-      //rhoh[ix] /= sqrt(twoPI) * epsilon * RefState.L;
-      rho[ix] *= epsilon/(PI * RefState.L);
-      rhoh[ix] *= epsilon/(PI * RefState.L);
-      //cout << ix << " x = " << x << "\trho = " << rho[ix] << "\trhoh = " << rhoh[ix] << "\trho + rhoh = " << rho[ix] + rhoh[ix] << endl;
-    }
-
-    // Now calculate the entropy:
-    complex<DP> entropy = 0.0;
-    DP Deltax = log(RefState.L)/RefState.L;
-    for (int ix = 0; ix < Nptsx; ++ix)
-      //entropy -= ln_Gamma (1.0 + rho[ix]) + ln_Gamma (2.0 - rho[ix]); // This is ln (\rho_tot choose \rho) with \rho_tot = 1.
-      entropy += ln_Gamma (RefState.L * (rho[ix] + rhoh[ix]) * Deltax + 1.0) - ln_Gamma(RefState.L * rho[ix] * Deltax + 1.0) - ln_Gamma (RefState.L * rhoh[ix] * Deltax + 1.0); // This is ln (\rho_tot choose \rho) with \rho_tot = 1.
-    entropy *= dx/Deltax;
-
-    //cout << "Entropy found " << entropy << "\t" << real(entropy) << endl;
-
-    return(real(entropy));
-  }
-  */
-
-  /*
-  DP Entropy_rho (LiebLin_Bethe_State& RefState, int Delta)
-  {
-    // This function calculates the discrete entropy of a finite Lieb-Liniger state,
-    // counting the possible permutations within windows of fixed width.
-
-    // We assume that the quantum numbers are ordered.
-
-    // Calculate a density \rho_\Delta (x) for x_j on the lattice:
-
-    int iK_UL = ABACUS::max(RefState.Ix2[0], RefState.Ix2[RefState.N - 1]);
-
-    Vect<double> rhoD(0.0, 2* iK_UL);
-
-    int fourDeltasq = 4 * Delta * Delta;
-    for (int ix = 0; ix < 2* iK_UL; ++ix) {
-      // x = (-iK_UL + 1/2 + ix)/L
-      for (int i = 0; i < RefState.N; ++i) rhoD[ix] += 1.0/((-2*iK_UL + 1 + 2*ix -RefState.Ix2[i]) * (-2*iK_UL + 1 + 2*ix -RefState.Ix2[i]) + fourDeltasq);
-      rhoD[ix] *= 4.0 * Delta/PI;
-      //cout << "x = " << (-iK_UL + 1/2 + ix)/RefState.L << "\trhoD = " << rhoD[ix] << endl;
-    }
-
-    // Now calculate the entropy:
-    DP entropy = 0.0;
-    for (int ix = 0; ix < 2* iK_UL; ++ix)
-      entropy -= rhoD[ix] * log(rhoD[ix]) + (1.0 - rhoD[ix]) * log(1.0 - rhoD[ix]);
-
-    return(entropy);
-  }
-  */
 
   DP Entropy_Fixed_Delta (LiebLin_Bethe_State& RefState, int Delta)
   {
     // We assume that the quantum numbers are ordered.
 
     // Fill in vector of occupancies:
-    int nrIs = (RefState.Ix2[RefState.N-1] - RefState.Ix2[0])/2 + 1 + 2*Delta; // assume Ix2 are ordered, leave space of Delta on both sides
+    // assume Ix2 are ordered, leave space of Delta on both sides
+    int nrIs = (RefState.Ix2[RefState.N-1] - RefState.Ix2[0])/2 + 1 + 2*Delta;
     Vect<int> occupancy(0, nrIs);  // leave space of Delta on both sides
     for (int i = 0; i < RefState.N; ++i) occupancy[Delta + (RefState.Ix2[i] -RefState.Ix2[0])/2] = 1;
     // Check:
     int ncheck = 0;
     for (int i = 0; i < nrIs; ++i) if(occupancy[i] == 1) ncheck++;
-    //cout << "Check occupancy: " << endl << occupancy << endl;
     if (ncheck != RefState.N) {
       cout << ncheck << "\t" << RefState.N << endl;
       ABACUSerror("Counting q numbers incorrectly in Entropy.");
     // Define some useful numbers:
     Vect_DP oneoverDeltalnchoose(Delta + 1);
     for (int i = 0; i <= Delta; ++i) oneoverDeltalnchoose[i] = ln_choose(Delta, i)/Delta;
-    //Vect_DP oneoverDeltalnchoosecheck(Delta + 1);
-    //for (int i = 0; i <= Delta; ++i) oneoverDeltalnchoosecheck[i] = log(DP(choose(Delta, i)))/Delta;
-    //cout << oneoverDeltalnchoose << endl;
-    //cout << oneoverDeltalnchoosecheck << endl;
 
     // Compute entropy:
     DP entropy = 0.0;
     int Delta = int(log(RefState.L));
     return(Entropy (RefState, Delta));
   }
-  /*
-  DP Canonical_Free_Energy (LiebLin_Bethe_State& RefState, DP kBT, int Delta)
-  {
-    return(RefState.E - kBT * Entropy (RefState, Delta));
-  }
 
-  DP Canonical_Free_Energy (LiebLin_Bethe_State& RefState, DP kBT, int Delta)
-  {
-    return(RefState.E - kBT * Entropy (RefState, Delta));
-  }
-  */
   DP Canonical_Free_Energy (LiebLin_Bethe_State& RefState, DP kBT)
   {
     return(RefState.E - kBT * Entropy (RefState));
   }
 
-  /*
-  //LiebLin_Bethe_State Canonical_Saddle_Point_State (DP c_int, DP L, int N, DP kBT, int Delta)
-  LiebLin_Bethe_State Canonical_Saddle_Point_State_pre20110618 (DP c_int, DP L, int N, DP kBT, DP epsilon)
-  {
-    // This function returns the discretized state minimizing the canonical free energy
-    // F = E - T S.
-
-    LiebLin_Bethe_State spstate(c_int, L, N);
-    spstate.Compute_All (true);
-
-    if (kBT < 1.0e-3) return(spstate); // interpret as zero T case
-
-    LiebLin_Bethe_State spstateup = spstate;
-    LiebLin_Bethe_State spstatedown = spstate;
-
-    bool converged = false;
-    bool convergedati = false;
-
-    DP canfreeenstay, canfreeenup, canfreeendown;
-    DP Estay, Eup, Edown;
-    DP Sstay, Sup, Sdown;
-
-    while (!converged) {
-
-      spstate.Compute_All (false);
-      converged = true;  // set to false if we change anything
-
-      // If we can minimize the free energy by changing the quantum number, we do:
-      // NOTE:  we keep the state symmetric w/r to parity.
-
-      for (int i = 0; i < N/2; ++i) {
-	// Try to increase or decrease this quantum number
-
-	convergedati = false;
-
-	while (!convergedati) {
-
-	  convergedati = true; // set to false if we change anything
-
-	  Estay = spstate.E;
-	  //Sstay = Entropy (spstate, Delta);
-	  Sstay = Entropy (spstate, epsilon);
-	  //canfreeenstay = Canonical_Free_Energy (spstate, kBT, Delta);
-	  canfreeenstay = Estay - kBT * Sstay;
-
-	  spstateup = spstate;
-	  if (i == 0 || spstateup.Ix2[i-1] < spstateup.Ix2[i] - 2) {
-	    spstateup.Ix2[i] -= 2;
-	    spstateup.Ix2[N-1-i] += 2;
-	    spstateup.Compute_All(false);
-	    Eup = spstateup.E;
-	    //Sup = Entropy(spstateup, Delta);
-	    Sup = Entropy(spstateup, epsilon);
-	    //canfreeenup = Canonical_Free_Energy (spstateup, kBT, Delta);
-	    canfreeenup = Eup - kBT * Sup;
-	  }
-	  else canfreeenup = canfreeenstay + 1.0e-6;
-
-	  spstatedown = spstate;
-	  if (spstatedown.Ix2[i+1] > spstatedown.Ix2[i] + 2) {
-	    spstatedown.Ix2[i] += 2;
-	    spstatedown.Ix2[N-1-i] -= 2;
-	    spstatedown.Compute_All(false);
-	    Edown = spstatedown.E;
-	    //Sdown = Entropy(spstatedown, Delta);
-	    Sdown = Entropy(spstatedown, epsilon);
-	    //canfreeendown = Canonical_Free_Energy (spstatedown, kBT, Delta);
-	    canfreeendown = Edown - kBT * Sdown;
-	  }
-	  else canfreeendown = canfreeenstay + 1.0e-6;
-
-	  //cout << "i = " << i << "\t" << spstate.Ix2[i] << "\t\t" << canfreeenstay << "\t" << canfreeenup << "\t" << canfreeendown
-	  // << "\t\t" << Estay << "\t" << Eup << "\t" << Edown << "\t\t" << Sstay << "\t" << Sup << "\t" << Sdown << endl;
-	  // Choose what to do:
-	  if (canfreeenup < canfreeenstay && canfreeendown < canfreeenstay)
-	    cout << canfreeenstay << "\t" << canfreeenup << "\t" << canfreeendown << "\tWarning:  unclear option for minimization." << endl;
-	  else if (canfreeenup < canfreeenstay) {
-	    spstate = spstateup;
-	    convergedati = false;
-	    converged = false;
-	  }
-	  else if (canfreeendown < canfreeenstay) {
-	    spstate = spstatedown;
-	    convergedati = false;
-	    converged = false;
-	  }
-	  // else do nothing.
-	} // while !convergedati
-
-      } // for i
-    } // while (!converged)
-
-    return(spstate);
-  }
-  */
-
-  /* REMOVED FROM ++G_3 ONWARDS
-  //LiebLin_Bethe_State Canonical_Saddle_Point_State (DP c_int, DP L, int N, DP kBT, int Delta)
-  //LiebLin_Bethe_State Canonical_Saddle_Point_State (DP c_int, DP L, int N, DP kBT, DP epsilon)
-  LiebLin_Bethe_State Canonical_Saddle_Point_State_pre8 (DP c_int, DP L, int N, DP kBT)
-  {
-    // This function returns the discretized state minimizing the canonical free energy
-    // F = E - T S.
-
-    // Improvement on version pre20110618: allow for pairwise `in' and `out' movements
-    // keeping the energy the same to order 1/L^2 but changing the entropy.
-
-    // The regulator Delta also has become an `internal' parameter.
-
-    LiebLin_Bethe_State spstate(c_int, L, N);
-    spstate.Compute_All (true);
-
-    if (kBT < 1.0e-3) return(spstate); // interpret as zero T case
-
-    LiebLin_Bethe_State spstateup = spstate;
-    LiebLin_Bethe_State spstatedown = spstate;
-    LiebLin_Bethe_State spstatein = spstate;
-    LiebLin_Bethe_State spstateout = spstate;
-
-    bool converged = false;
-    bool convergedati = false;
-
-    DP canfreeenstay, canfreeenup, canfreeendown, canfreeenin, canfreeenout;
-    DP Estay, Eup, Edown, Ein, Eout;
-    DP Sstay, Sup, Sdown, Sin, Sout;
-    Estay = 0.0; Eup = 0.0; Edown = 0.0; Ein = 0.0; Eout = 0.0;
-    Sstay = 0.0; Sup = 0.0; Sdown = 0.0; Sin = 0.0; Sout = 0.0;
-
-    while (!converged) {
-
-      spstate.Compute_All (false);
-      converged = true;  // set to false if we change anything
-
-      // If we can minimize the free energy by changing the quantum number, we do:
-      // NOTE:  we keep the state symmetric w/r to parity.
-
-      for (int i = 0; i < N/2 - 1; ++i) {
-
-	// Try to increase or decrease the quantum numbers at i ,
-	// or do an (approximately) energy-preserving move with i+1 (and parity pairs)
-	// giving 5 possible options: stay same, (\pm 1, 0), (+1, -1), (-1, +1)
-
-	convergedati = false;
-
-	while (!convergedati) {
-
-	  convergedati = true; // set to false if we change anything
-
-	  Estay = spstate.E;
-	  Sstay = Entropy (spstate);
-	  //Sstay = Entropy (spstate, Delta);
-	  //Sstay = Entropy (spstate, epsilon);
-	  //canfreeenstay = Canonical_Free_Energy (spstate, kBT, Delta);
-	  canfreeenstay = Estay - kBT * Sstay;
-
-	  spstateup = spstate;
-	  if (i == 0 || spstateup.Ix2[i-1] < spstateup.Ix2[i] - 2) {
-	    spstateup.Ix2[i] -= 2;
-	    spstateup.Ix2[N-1-i] += 2;
-	    spstateup.Compute_All(false);
-	    Eup = spstateup.E;
-	    Sup = Entropy(spstateup);
-	    //Sup = Entropy(spstateup, Delta);
-	    //Sup = Entropy(spstateup, epsilon);
-	    //canfreeenup = Canonical_Free_Energy (spstateup, kBT, Delta);
-	    canfreeenup = Eup - kBT * Sup;
-	  }
-	  else canfreeenup = canfreeenstay + 1.0e-6;
-
-	  spstatedown = spstate;
-	  if (spstatedown.Ix2[i+1] > spstatedown.Ix2[i] + 2) {
-	    spstatedown.Ix2[i] += 2;
-	    spstatedown.Ix2[N-1-i] -= 2;
-	    spstatedown.Compute_All(false);
-	    Edown = spstatedown.E;
-	    Sdown = Entropy(spstatedown);
-	    //Sdown = Entropy(spstatedown, Delta);
-	    //Sdown = Entropy(spstatedown, epsilon);
-	    //canfreeendown = Canonical_Free_Energy (spstatedown, kBT, Delta);
-	    canfreeendown = Edown - kBT * Sdown;
-	  }
-	  else canfreeendown = canfreeenstay + 1.0e-6;
-
-	  spstatein = spstate;
-	  if (spstatein.Ix2[i+1] > spstatein.Ix2[i] + 4) { // can move them closer
-	    spstatein.Ix2[i] += 2;
-	    spstatein.Ix2[i+1] -= 2;
-	    spstatein.Ix2[N-1-i] -= 2;
-	    spstatein.Ix2[N-1-i-1] += 2;
-	    spstatein.Compute_All(false);
-	    Ein = spstatein.E;
-	    Sin = Entropy(spstatein);
-	    //Sin = Entropy(spstatein, Delta);
-	    //Sin = Entropy(spstatein, epsilon);
-	    //canfreeenin = Canonical_Free_Energy (spstatein, kBT, Delta);
-	    canfreeenin = Ein - kBT * Sin;
-	  }
-	  else canfreeenin = canfreeenstay + 1.0e-6;
-
-	  spstateout = spstate;
-	  if (i == 0 && spstateout.Ix2[1] + 2 < spstateout.Ix2[2]
-	      || (i < N/2 - 1 && spstateout.Ix2[i] - 2 > spstateout.Ix2[i-1]
-		  && spstateout.Ix2[i+1] + 2 < spstateout.Ix2[i+2])) { // can move them further apart
-	    spstateout.Ix2[i] -= 2;
-	    spstateout.Ix2[i+1] += 2;
-	    spstateout.Ix2[N-1-i] += 2;
-	    spstateout.Ix2[N-1-i-1] -= 2;
-	    spstateout.Compute_All(false);
-	    Eout = spstateout.E;
-	    Sout = Entropy(spstateout);
-	    //Sout = Entropy(spstateout, Delta);
-	    //Sout = Entropy(spstateout, epsilon);
-	    //canfreeenout = Canonical_Free_Energy (spstateout, kBT, Delta);
-	    canfreeenout = Eout - kBT * Sout;
-	  }
-	  else canfreeenout = canfreeenstay + 1.0e-6;
-
-	  //cout << setprecision(8) << "i = " << i << "\t" << spstate.Ix2[i] << "\t" << spstate.Ix2[i+1] << "\t\t" << canfreeenstay << "\t" << canfreeenup << "\t" << canfreeendown << "\t" << canfreeenin << "\t" << canfreeenout << endl;
-	  //cout << "\t\tE: " << Estay << "\t" << Eup << "\t" << Edown << "\t" << Ein << "\t" << Eout << endl;
-	  //cout << "\t\tS: " << Sstay << "\t" << Sup << "\t" << Sdown << "\t" << Sin << "\t" << Sout << endl;
-
-	  // Choose what to do: find minimum,
-	  if (canfreeenstay < canfreeenup && canfreeenstay < canfreeendown && canfreeenstay < canfreeenin && canfreeenstay < canfreeenout) {
-	    // do nothing, convergetati is already true
-	  }
-	  else if (canfreeenup < canfreeenstay && canfreeenup < canfreeendown && canfreeenup < canfreeenin && canfreeenup < canfreeenout) {
-	    spstate = spstateup;
-	    convergedati = false;
-	    converged = false;
-	  }
-	  else if (canfreeendown < canfreeenstay && canfreeendown < canfreeenup && canfreeendown < canfreeenin && canfreeendown < canfreeenout) {
-	    spstate = spstatedown;
-	    convergedati = false;
-	    converged = false;
-	  }
-	  else if (canfreeenin < canfreeenstay && canfreeenin < canfreeenup && canfreeenin < canfreeendown && canfreeenin < canfreeenout) {
-	    spstate = spstatein;
-	    convergedati = false;
-	    converged = false;
-	  }
-	  else if (canfreeenout < canfreeenstay && canfreeenout < canfreeenup && canfreeenout < canfreeendown && canfreeenout < canfreeenin) {
-	    spstate = spstateout;
-	    convergedati = false;
-	    converged = false;
-	  }
-	  else cout << canfreeenstay << "\t" << canfreeenup << "\t" << canfreeendown << "\t" << canfreeenin << "\t" << canfreeenout << "\tWarning:  unclear option for minimization." << endl;
-
-	  // else do nothing.
-	} // while !convergedati
-
-      } // for i
-    } // while (!converged)
-
-    //cout << "Number of holes between I's: " << endl;
-    //for (int i = 0; i < N/2; ++i) cout << (spstate.Ix2[i+1] - spstate.Ix2[i])/2 - 1 << "\t";
-    //cout << endl;
-
-    return(spstate);
-  }
-  */
-
   DP rho_of_lambdaoc_1 (LiebLin_Bethe_State& RefState, DP lambdaoc, DP delta)
   {
     DP answer = 0.0;
     for (int i = 0; i < RefState.N; ++i)
-      answer += atan((lambdaoc - RefState.lambdaoc[i])/delta + 0.5) - atan((lambdaoc - RefState.lambdaoc[i])/delta - 0.5);
+      answer += atan((lambdaoc - RefState.lambdaoc[i])/delta + 0.5)
+	- atan((lambdaoc - RefState.lambdaoc[i])/delta - 0.5);
     answer *= 1.0/(PI * delta * RefState.L);
 
     return(answer);
     DP answer = 0.0;
     for (int i = 0; i < RefState.N; ++i)
       answer += 1.0/(pow(lambdaoc - RefState.lambdaoc[i], 2.0) + delta*delta);
-      answer *= delta/(PI * RefState.L);
+    answer *= delta/(PI * RefState.L);
 
     return(answer);
   }

src/LIEBLIN/LiebLin_Twisted_ln_Overlap.cc

     return(1.0/Fn_V (j, -sign, lstate_lambdaoc, rstate));
   }
 
-  complex<DP> LiebLin_Twisted_ln_Overlap (DP expbeta, Vect<DP> lstate_lambdaoc, DP lstate_lnnorm, LiebLin_Bethe_State& rstate)
+  complex<DP> LiebLin_Twisted_ln_Overlap (DP expbeta, Vect<DP> lstate_lambdaoc,
+					  DP lstate_lnnorm, LiebLin_Bethe_State& rstate)
   {
     Vect<complex<DP> > lstate_lambdaoc_CX(lstate_lambdaoc.size());
     for (int i = 0; i < lstate_lambdaoc.size(); ++i) lstate_lambdaoc_CX[i] = complex<DP>(lstate_lambdaoc[i]);
     return(LiebLin_Twisted_ln_Overlap (complex<DP>(expbeta), lstate_lambdaoc_CX, lstate_lnnorm, rstate));
   }
 
-  complex<DP> LiebLin_Twisted_ln_Overlap (complex<DP> expbeta, Vect<complex<DP> > lstate_lambdaoc, DP lstate_lnnorm, LiebLin_Bethe_State& rstate)
+  complex<DP> LiebLin_Twisted_ln_Overlap (complex<DP> expbeta, Vect<complex<DP> > lstate_lambdaoc,
+					  DP lstate_lnnorm, LiebLin_Bethe_State& rstate)
   {
     // Computes the log of the overlap between the left state and the Bethe rstate
 
       Fn_Prod[a] = 1.0;
       for (int m = 0; m < rstate.N; ++m)
 	if (m != a) Fn_Prod[a] *= (lstate_lambdaoc[m] - rstate.lambdaoc[a])/(rstate.lambdaoc[m] - rstate.lambdaoc[a]);
-      //rKern[a] = rstate.Kernel (a, p);
       rKern[a] = Kernel_Twisted (expbeta, rstate.lambdaoc[p] - rstate.lambdaoc[a]);
     }
 
     for (int a = 0; a < rstate.N; ++a)
       for (int b = 0; b < rstate.N; ++b)
-	one_plus_U[a][b] = (a == b ? 1.0 : 0.0) + ((lstate_lambdaoc[a] - rstate.lambdaoc[a])/(1.0/Vplus_Nikita[a] - 1.0/Vminus_Nikita[a]))
+	one_plus_U[a][b] = (a == b ? 1.0 : 0.0)
+	  + ((lstate_lambdaoc[a] - rstate.lambdaoc[a])/(1.0/Vplus_Nikita[a] - 1.0/Vminus_Nikita[a]))
 	  * Fn_Prod[a] * (Kernel_Twisted(expbeta, rstate.lambdaoc[a] - rstate.lambdaoc[b]) - rKern[b]);
 
     complex<DP> ln_ddalpha_sigma = lndet_LU_CX_dstry(one_plus_U);
       for (int b = 0; b < rstate.N; ++b)
 	ln_prod_2 += log((lstate_lambdaoc[a] - rstate.lambdaoc[b] - II)/(rstate.lambdaoc[a] - lstate_lambdaoc[b]));
 
-    //cout << endl << ln_ddalpha_sigma << "\t" << ln_prod_V << "\t" << ln_prod_2 << "\t" << - log(2.0 * II * imag(Vplus[p])) << endl;
-    //cout << endl << ln_ddalpha_sigma << "\t" << ln_prod_V << "\t" << ln_prod_2 << "\t" << - log(Vplus[p] - Vminus[p]) << endl;
-
     ln_ddalpha_sigma += ln_prod_V + ln_prod_2 - log(Vplus_Nikita[p] - expbeta * Vminus_Nikita[p]);
 
-    //cout << "shift = " << (complex<DP>(rstate.N) * (lstate_lambdaoc[0] - rstate.lambdaoc[0])/twoPI) << "\tKout = " << Kout << "\texp(-II*Kout) = " << exp(-II * Kout)
-    // << "\tlog(exp(-II * Kout) - 1.0) = " << log(exp(-II * Kout) - 1.0) << endl;
-    //cout << ln_ddalpha_sigma << "\t" << ln_prod_V << "\t" << ln_prod_2 << "\t" << lstate_lnnorm << endl << endl;
-
-    //return (log(1.0 - expbeta) + ln_ddalpha_sigma - 0.5 * (lstate_lnnorm + rstate.lnnorm));
     return (log(1.0 - exp(-II * Kout)) + ln_ddalpha_sigma - 0.5 * (lstate_lnnorm + rstate.lnnorm));
   }
 

src/LIEBLIN/LiebLin_Twisted_lnnorm.cc

       for (int k = 0; k < N; ++k) {
 	if (j == k) {
 	  sum_Kernel = 0.0;
-	  for (int kp = 0; kp < N; ++kp) if (j != kp) sum_Kernel += 2.0/((lambdaoc[j] - lambdaoc[kp]) * (lambdaoc[j] - lambdaoc[kp]) + 1.0);
+	  for (int kp = 0; kp < N; ++kp)
+	    if (j != kp) sum_Kernel += 2.0/((lambdaoc[j] - lambdaoc[kp]) * (lambdaoc[j] - lambdaoc[kp]) + 1.0);
 	  Gaudin[j][k] = cxL + sum_Kernel;
 	}
 	else Gaudin[j][k] = - 2.0/((lambdaoc[j] - lambdaoc[k]) * (lambdaoc[j] - lambdaoc[k]) + 1.0);

src/LIEBLIN/LiebLin_Utils.cc

     lambda.Build_Reduced_Gaudin_Matrix (  Gaudin);
     lambda.Build_Reduced_BEC_Quench_Gaudin_Matrix (Gaudin_Quench);
 
-    //DP ln_prefactor =  N/2.0  * log(2./fabs(c_int*L)   ) + 0.5 * (N*log(N) - N + 0.5*log(2. * PI * N));
-
     DP ln_prefactor =  N/2.0  * log(2./(c_int*L)   ) + 0.5 * real(ln_Gamma(complex<double>(N+1.0)));
 
-    for(int i =N/2; i<N; i ++) ln_prefactor -= log(fabs(lambda.lambdaoc[i ])) + 0.5*log( 1. + 4. * lambda.lambdaoc[i ]*lambda.lambdaoc[i ]) ;
+    for(int i =N/2; i<N; i ++)
+      ln_prefactor -= log(fabs(lambda.lambdaoc[i ])) + 0.5*log( 1. + 4. * lambda.lambdaoc[i ]*lambda.lambdaoc[i ]) ;
 
-    //cout << ln_prefactor << endl;
     return (ln_prefactor  + real(lndet_LU_dstry(Gaudin_Quench))  - 0.5 * real(lndet_LU_dstry(Gaudin)));
   }
 

src/LIEBLIN/LiebLin_ln_Overlap.cc

 using namespace ABACUS;
 
 namespace ABACUS {
-  /*
-  complex<DP> Fn_V (int j, int sign, Vect<complex<DP> >& lstate_lambdaoc, LiebLin_Bethe_State& rstate)
-  {
-    complex<DP> result_num = 1.0;
-    complex<DP> result_den = 1.0;
-
-    complex<DP> signcx = complex<DP>(sign);
-
-    for (int m = 0; m < rstate.N; ++m) {
-      result_num *= (lstate_lambdaoc[m] - rstate.lambdaoc[j] + signcx * II);
-      result_den *= (rstate.lambdaoc[m] - rstate.lambdaoc[j] + signcx * II);
-    }
-
-    return(result_num/result_den);
-  }
-  */
 
   complex<DP> LiebLin_ln_Overlap (Vect<DP> lstate_lambdaoc, DP lstate_lnnorm, LiebLin_Bethe_State& rstate)
   {
 
     for (int j = 0; j < rstate.N; ++j)
       for (int k = 0; k < rstate.N; ++k)
-	//Omega[j][k] = exp(-II * rstate.cxL * lstate_lambdaoc[k] + ln_prod_plus[k] - ln_prod_ll_plus[k])
-	//* (II/((rstate.lambdaoc[j] - lstate_lambdaoc[k])*(rstate.lambdaoc[j] - lstate_lambdaoc[k] + II)))
-	//- (II/((rstate.lambdaoc[j] - lstate_lambdaoc[k])*(rstate.lambdaoc[j] - lstate_lambdaoc[k] - II)))
-	//* exp(ln_prod_minus[k] - ln_prod_ll_plus[k]);
 	Omega[j][k] = exp(-II * rstate.cxL * lstate_lambdaoc[k] - ln_prod_plus[k] + ln_prod_minus[k])
 	  * (II/((rstate.lambdaoc[j] - lstate_lambdaoc[k])*(rstate.lambdaoc[j] - lstate_lambdaoc[k] - II)))
 	  - (II/((rstate.lambdaoc[j] - lstate_lambdaoc[k])*(rstate.lambdaoc[j] - lstate_lambdaoc[k] + II)));
 
-
-    //for (int j = 0; j < rstate.N; ++j) {
-    //for (int k = 0; k < rstate.N; ++k)
-    //cout << Omega[j][k] << "\t";
-    //cout << endl;
-    //}
-
-
     complex<DP> lndetOmega = lndet_LU_CX_dstry(Omega);
 
-    //cout << "lndetOmega = " << lndetOmega << endl;
-
     // Prefactors:
     complex<DP> ln_prod_d_mu = II * 0.5 * rstate.cxL * rstate.lambdaoc.sum();
     complex<DP> ln_prod_d_lambdaoc = II * 0.5 * rstate.cxL * lstate_lambdaoc.sum();
     for (int j = 0; j < rstate.N - 1; ++j)
       for (int k = j+1; k < rstate.N; ++k) {
 	ln_prod_mu += log(rstate.lambdaoc[k] - rstate.lambdaoc[j]);
-	//ln_prod_lambdaoc += log((lstate_lambdaoc[j] - lstate_lambdaoc[k] + II) * (lstate_lambdaoc[j] - lstate_lambdaoc[k] - II)/(lstate_lambdaoc[k] - lstate_lambdaoc[j]));
 	ln_prod_lambdaoc += log(lstate_lambdaoc[k] - lstate_lambdaoc[j]);
       }
 
       for (int k = 0; k < rstate.N; ++k)
 	ln_prod_plusminus += log((rstate.lambdaoc[j] - lstate_lambdaoc[k] + II));
 
-    //cout << "ln_prod_mu " << ln_prod_mu << "\tln_prod_lambdaoc " << ln_prod_lambdaoc << "\tln_prod_plusminus " << ln_prod_plusminus
-    // << "\texp1 " << exp(-ln_prod_mu - ln_prod_lambdaoc) << "\texp2 " << exp(ln_prod_plusminus) << endl;
-
-    //if (real(ln_prod_d_mu + ln_prod_d_lambdaoc - ln_prod_mu + ln_prod_lambdaoc + lndetOmega - 0.5 * (lstate_lnnorm + rstate.lnnorm)) > 10.0) {
-    //cout << ln_prod_d_mu << "\t" << ln_prod_d_lambdaoc << "\t" << -ln_prod_mu << "\t" << ln_prod_lambdaoc << "\t" << lndetOmega << "\t" << -0.5 * lstate_lnnorm << "\t" << -0.5 * rstate.lnnorm << endl;      cout << ln_prod_d_mu + ln_prod_d_lambdaoc - ln_prod_mu + ln_prod_lambdaoc + lndetOmega - 0.5 * (lstate_lnnorm + rstate.lnnorm) << endl;
-    //ABACUSerror("Overlap exceeds 1.");
-    //}
-
-    //return(ln_prod_d_mu + ln_prod_d_lambdaoc - ln_prod_mu + ln_prod_lambdaoc + lndetOmega - 0.5 * (lstate_lnnorm + rstate.lnnorm));
-    return(ln_prod_d_mu + ln_prod_d_lambdaoc - ln_prod_mu - ln_prod_lambdaoc + ln_prod_plusminus + lndetOmega - 0.5 * (lstate_lnnorm + rstate.lnnorm));
-  }
-
-  /*
-  // Incorrect version
-  complex<DP> LiebLin_ln_Overlap (Vect<complex<DP> > lstate_lambdaoc, DP lstate_lnnorm, LiebLin_Bethe_State& rstate)
-  {
-    // Computes the log of the overlap between the left state and the Bethe rstate
-
-    // If momentum difference is zero but states are different, then form factor is zero:
-
-    SQMat_CX one_plus_U (0.0, rstate.N);
-
-    Vect_CX Vplus (0.0, rstate.N);  // contains V^+_j
-    Vect_CX Vminus (0.0, rstate.N);  // contains V^-_j
-    Vect_CX Fn_Prod (0.0, rstate.N);  // product_{m\neq j} (\mu_m - \lambdaoc_j)/(\lambdaoc_m - \lambdaoc_j)
-    //Vect_DP rKern (0.0, rstate.N);   // K(lambdaoc_j - lambdaoc_p)
-
-    //int p = 0;
-
-    complex<DP> Kout = lstate_lambdaoc.sum() - rstate.K;
-
-    for (int a = 0; a < rstate.N; ++a) {
-      Vplus[a] = Fn_V (a, 1, lstate_lambdaoc, rstate);
-      Vminus[a] = Fn_V (a, -1, lstate_lambdaoc, rstate);
-      Fn_Prod[a] = 1.0;
-      for (int m = 0; m < rstate.N; ++m)
-	if (m != a) Fn_Prod[a] *= (lstate_lambdaoc[m] - rstate.lambdaoc[a])/(rstate.lambdaoc[m] - rstate.lambdaoc[a]);
-      //rKern[a] = rstate.Kernel (a, p);
-    }
-
-    for (int a = 0; a < rstate.N; ++a)
-      for (int b = 0; b < rstate.N; ++b)
-	one_plus_U[a][b] = (a == b ? 1.0 : 0.0) + II * ((lstate_lambdaoc[a] - rstate.lambdaoc[a])/(Vplus[a] - Vminus[a]))
-	  * Fn_Prod[a] * rstate.Kernel(a,b);
-
-    complex<DP> ln_ddalpha_sigma = lndet_LU_CX_dstry(one_plus_U);
-
-    complex<DP> ln_prod_V = 0.0;
-    for (int a = 0; a < rstate.N; ++a) ln_prod_V += log(Vplus[a] - Vminus[a]);
-
-    complex<DP> ln_prod_2 = 0.0;
-    for (int a = 0; a < rstate.N; ++a)
-      for (int b = 0; b < rstate.N; ++b)
-	ln_prod_2 += log((rstate.lambdaoc[a] - rstate.lambdaoc[b] + II)/(lstate_lambdaoc[a] - rstate.lambdaoc[b]));
-
-    //cout << endl << ln_ddalpha_sigma << "\t" << ln_prod_V << "\t" << ln_prod_2 << "\t" << - log(2.0 * II * imag(Vplus[p])) << endl;
-    cout << endl << ln_ddalpha_sigma << "\t" << ln_prod_V << "\t" << ln_prod_2 << "\t" << 0.5 * lstate_lnnorm << "\t" << 0.5 * rstate.lnnorm << endl;//- log(Vplus[p] - Vminus[p]) << endl;
-
-    ln_ddalpha_sigma += ln_prod_V + ln_prod_2;// - log(Vplus[p] - Vminus[p]);
-
-    //cout << "shift = " << (complex<DP>(rstate.N) * (lstate_lambdaoc[0] - rstate.lambdaoc[0])/twoPI) << "\tKout = " << Kout << "\texp(-II*Kout) = " << exp(-II * Kout)
-    // << "\tlog(exp(-II * Kout) - 1.0) = " << log(exp(-II * Kout) - 1.0) << endl;
-    //cout << ln_ddalpha_sigma << "\t" << ln_prod_V << "\t" << ln_prod_2 << "\t" << - log(Vplus[p] - Vminus[p]) << "\t" << lstate_lnnorm << endl << endl;
-
-    return (ln_ddalpha_sigma - 0.5 * (lstate_lnnorm + rstate.lnnorm));
+    return(ln_prod_d_mu + ln_prod_d_lambdaoc - ln_prod_mu - ln_prod_lambdaoc + ln_prod_plusminus
+	   + lndetOmega - 0.5 * (lstate_lnnorm + rstate.lnnorm));
   }
-  */
 
 } // namespace ABACUS

src/LIEBLIN/ln_Density_ME.cc

 
   complex<DP> Fn_V (int j, LiebLin_Bethe_State& lstate, LiebLin_Bethe_State& rstate)
   {
-    //complex<DP> result_num = 1.0;
-    //complex<DP> result_den = 1.0;
     complex<DP> result = 1.0;
 
     for (int m = 0; m < lstate.N; ++m) {
-      //result_num *= (lstate.lambdaoc[m] - rstate.lambdaoc[j] + II);
-      //result_den *= (rstate.lambdaoc[m] - rstate.lambdaoc[j] + II);
       result *= (lstate.lambdaoc[m] - rstate.lambdaoc[j] + II)/(rstate.lambdaoc[m] - rstate.lambdaoc[j] + II);
     }
 
-    //return(result_num/result_den);
     return(result);
   }
 
     // Computes the log of the density operator \rho(x = 0) matrix element between lstate and rstate.
 
     // If we have lstate == rstate, density matrix element = N/L:
-
     if (lstate.Ix2 == rstate.Ix2) return(log(lstate.N/lstate.L));
 
     // If momentum difference is zero but states are different, then matrix element is zero:
-
     else if (lstate.iK == rstate.iK) return(-200.0);  // so exp(.) is zero
 
     SQMat_DP one_plus_U (0.0, lstate.N);
 
     Vect_CX Vplus (0.0, lstate.N);  // contains V^+_j;  V^-_j is the conjugate
-    //Vect_DP Fn_Prod (0.0, lstate.N);  // product_{m\neq j} (\mu_m - \lambdaoc_j)/(\lambdaoc_m - \lambdaoc_j)
-    // From ABACUS++G_3 onwards: use logs to stabilize numerical values at small c, at the cost of execution speed.
     Vect_CX ln_Fn_Prod (0.0, lstate.N);  // product_{m\neq j} (\mu_m - \lambdaoc_j)/(\lambdaoc_m - \lambdaoc_j)
     Vect_DP rKern (0.0, lstate.N);   // K(lambdaoc_j - lambdaoc_(p == arbitrary))
 
 
     for (int a = 0; a < lstate.N; ++a) {
       Vplus[a] = Fn_V (a, lstate, rstate);
-      //Fn_Prod[a] = 1.0;
       ln_Fn_Prod[a] = 0.0;;
       for (int m = 0; m < lstate.N; ++m)
-	//if (m != a) Fn_Prod[a] *= (lstate.lambdaoc[m] - rstate.lambdaoc[a])/(rstate.lambdaoc[m] - rstate.lambdaoc[a]);
-	if (m != a) ln_Fn_Prod[a] += log(complex<DP>(lstate.lambdaoc[m] - rstate.lambdaoc[a])/(rstate.lambdaoc[m] - rstate.lambdaoc[a]));
+	if (m != a) ln_Fn_Prod[a] += log(complex<DP>(lstate.lambdaoc[m] - rstate.lambdaoc[a])
+					 /(rstate.lambdaoc[m] - rstate.lambdaoc[a]));
       rKern[a] = rstate.Kernel (a, p);
     }
 
     for (int a = 0; a < lstate.N; ++a)
       for (int b = 0; b < lstate.N; ++b)
 	one_plus_U[a][b] = (a == b ? 1.0 : 0.0) + 0.5 * ((lstate.lambdaoc[a] - rstate.lambdaoc[a])/imag(Vplus[a]))
-	  //* Fn_Prod[a] * (rstate.Kernel(a,b) - rKern[b]);
-	  * real(exp(ln_Fn_Prod[a])) * (rstate.Kernel(a,b) - rKern[b]);
+	  * real(exp(ln_Fn_Prod[a])) * (rstate.Kernel(a,b) - rKern[b]); // BUGRISK: why real here?
 
     complex<DP> ln_ddalpha_sigma = lndet_LU_dstry(one_plus_U);
 
       for (int b = 0; b < lstate.N; ++b)
 	ln_prod_2 += log((rstate.lambdaoc[a] - rstate.lambdaoc[b] + II)/(lstate.lambdaoc[a] - rstate.lambdaoc[b]));
 
-    //cout << "ln_Fn_Prod = " << ln_Fn_Prod << endl;
-    //cout << endl << ln_ddalpha_sigma << "\t" << ln_prod_V << "\t" << ln_prod_2 << "\t" << - log(2.0 * II * imag(Vplus[p])) << "\t" << - 0.5 * (lstate.lnnorm + rstate.lnnorm) << "\t" << ln_ddalpha_sigma + ln_prod_V + ln_prod_2 - log(2.0 * II * imag(Vplus[p])) - 0.5 * (lstate.lnnorm + rstate.lnnorm) << endl;
-
     ln_ddalpha_sigma += ln_prod_V + ln_prod_2 - log(2.0 * II * imag(Vplus[p]));
 
     return (log(-II * Kout) + ln_ddalpha_sigma - 0.5 * (lstate.lnnorm + rstate.lnnorm));

src/LIEBLIN/ln_Psi_ME.cc

     complex<DP> ln_prod_lambdaocsq_plus_one = 0.0;
     for (int a = 0; a < rstate.N - 1; ++a)
       for (int b = a; b < rstate.N; ++b)
-	ln_prod_lambdaocsq_plus_one += log(complex<DP>((rstate.lambdaoc[a] - rstate.lambdaoc[b]) * (rstate.lambdaoc[a] - rstate.lambdaoc[b])) + 1.0);
+	ln_prod_lambdaocsq_plus_one += log(complex<DP>((rstate.lambdaoc[a] - rstate.lambdaoc[b])
+						       * (rstate.lambdaoc[a] - rstate.lambdaoc[b])) + 1.0);
 
     complex<DP> ln_prod_lambdaoca_min_mub = 0.0;
     for (int a = 0; a < rstate.N; ++a)
       for (int b = 0; b < lstate.N; ++b)
 	ln_prod_lambdaoca_min_mub += log(complex<DP>(rstate.lambdaoc[a] - lstate.lambdaoc[b]));
 
-    //cout << endl << "Factors are " << ln_det_U_Psi << "\t" << ln_prod_lambdaocsq_plus_one << "\t" << ln_prod_lambdaoca_min_mub << endl;
-
-    return (ln_det_U_Psi + 0.5 * log(lstate.c_int) + ln_prod_lambdaocsq_plus_one - ln_prod_lambdaoca_min_mub - 0.5 * (lstate.lnnorm + rstate.lnnorm));
+    return (ln_det_U_Psi + 0.5 * log(lstate.c_int) + ln_prod_lambdaocsq_plus_one - ln_prod_lambdaoca_min_mub
+	    - 0.5 * (lstate.lnnorm + rstate.lnnorm));
   }
 
-}
+} // namespace ABACUS

src/LIEBLIN/ln_g2_ME.cc

 using namespace ABACUS;
 
 namespace ABACUS {
-/*
-  complex<DP> ln_g2_ME_old_jacopo (LiebLin_Bethe_State& mu, LiebLin_Bethe_State& lambda)
-  {
-
-    if (mu.Ix2 == lambda.Ix2) return(-200.);
-
-    DP c_int = mu.c_int;
-
-    SQMat_CX G(lambda.N);
-    SQMat_CX GpB(lambda.N);
-    SQMat_CX B(lambda.N);
-
-    complex<DP> log_themp;
-    complex<DP> lnprefactor = 0.  ;
-
-    lnprefactor += 2.*log(c_int) ;
-
-    for(int j=0; j < mu.N; ++j){
-      for(int k=0; k < j; ++k){
-	lnprefactor -= log((mu.lambdaoc[j] - mu.lambdaoc[k]));
-	lnprefactor -= log((lambda.lambdaoc[j] - lambda.lambdaoc[k]));
-      }
-    }
 
+  complex<DP> Fn_V_g2 (int j, LiebLin_Bethe_State& lstate, LiebLin_Bethe_State& rstate)
+  {
+    complex<DP> result = 1.0;
 
-    for(int j=0; j < mu.N; ++j){
-      for(int k=0; k <mu.N; ++k){
-	lnprefactor += log(mu.lambdaoc[j] - mu.lambdaoc[k] + II);
-      }
-    }
-
-    Vect_CX VVP (0.0, mu.N);
-    Vect_CX VVM (0.0, mu.N);
-
-    //compute the vectors
-    for(int j=0; j < mu.N; ++j) {
-      log_themp = 0.;
-      for(int k=0; k < mu.N; ++k) log_themp += log(mu.lambdaoc[j] - lambda.lambdaoc[k] + II) - log(mu.lambdaoc[j] - mu.lambdaoc[k] + II);
-      VVP[j] = exp(log_themp);
-    }
-
-    for(int j=0; j < mu.N; ++j) {
-      log_themp = 0.;
-      for(int k=0; k < mu.N; ++k) log_themp += log(mu.lambdaoc[j] - lambda.lambdaoc[k] - II) - log(mu.lambdaoc[j] - mu.lambdaoc[k] - II);
-      VVM[j] = exp(log_themp);
-    }
-
-    //compute the sum of determinants
-    complex<DP> sum_n =0.;
-    for(int n=0; n < mu.N; ++n) {
-        // compute the matrices
-      for (int a = 0; a < mu.N; ++a){
-	for (int b = 0; b < mu.N; ++b){
-	  if(b == n){
-	    G[a][b] = 2.*II* lambda.lambdaoc[a];
-	  }
-	  else{
-	    G[a][b] = II*1./(lambda.lambdaoc[a] - mu.lambdaoc[b])*( VVP[b]*1.0/(mu.lambdaoc[b] - lambda.lambdaoc[a] + II)  +
-								VVM[b]*1.0/(mu.lambdaoc[b] - lambda.lambdaoc[a] - II)  );
-	  }
-	}
-      }
-
-      for (int a = 0; a < mu.N; ++a){
-	for (int b = 0; b < mu.N; ++b){
-	  if(b == n){
-	    B[a][b] = 0.;
-	  }
-	  else{
-	    B[a][b] = II*1.0/(mu.lambdaoc[b] - mu.lambdaoc[n] - II) ;
-	  }
-	}
-      }
-
-      for (int a = 0; a < mu.N; ++a){
-	for (int b = 0; b < mu.N; ++b){
-	  GpB[a][b] = G[a][b] + B[a][b];
-	}
-      }
-      //finally add
-      sum_n +=   exp(	lndet_LU_CX(GpB) ) -  exp(lndet_LU_CX(G) ) ;
+    for (int m = 0; m < lstate.N; ++m) {
+      result *= (lstate.lambdaoc[m] - rstate.lambdaoc[j] + II)/(rstate.lambdaoc[m] - rstate.lambdaoc[j] + II);
     }
 
-    return(log(sum_n ) + lnprefactor  - 0.5 * (mu.lnnorm + lambda.lnnorm));
+    return(result);
   }
-*/
-    complex<DP> Fn_V_g2 (int j, LiebLin_Bethe_State& lstate, LiebLin_Bethe_State& rstate)
-    {
-        //complex<DP> result_num = 1.0;
-        //complex<DP> result_den = 1.0;
-        complex<DP> result = 1.0;
-
-        for (int m = 0; m < lstate.N; ++m) {
-            //result_num *= (lstate.lambdaoc[m] - rstate.lambdaoc[j] + II);
-            //result_den *= (rstate.lambdaoc[m] - rstate.lambdaoc[j] + II);
-            result *= (lstate.lambdaoc[m] - rstate.lambdaoc[j] + II)/(rstate.lambdaoc[m] - rstate.lambdaoc[j] + II);
-        }
-
-        //return(result_num/result_den);
-        return(result);
-    }
-
-
-    complex<DP> ln_g2_ME (LiebLin_Bethe_State& lstate, LiebLin_Bethe_State& rstate)
-    {
-        // Computes the log of the density operator \rho(x = 0) matrix element between lstate and rstate.
-
-        // If we have lstate == rstate, density matrix element = 0:
-
-
-        if (lstate.Ix2 == rstate.Ix2) return(-200.);
-
-
 
 
-        SQMat_DP one_plus_U (0.0, lstate.N);
-
-        Vect_CX Vplus (0.0, lstate.N);  // contains V^+_j;  V^-_j is the conjugate
-        //Vect_DP Fn_Prod (0.0, lstate.N);  // product_{m\neq j} (\mu_m - \lambdaoc_j)/(\lambdaoc_m - \lambdaoc_j)
-        // From ABACUS++G_3 onwards: use logs to stabilize numerical values at small c, at the cost of execution speed.
-        Vect_CX ln_Fn_Prod (0.0, lstate.N);  // product_{m\neq j} (\mu_m - \lambdaoc_j)/(\lambdaoc_m - \lambdaoc_j)
-        Vect_DP rKern (0.0, lstate.N);   // K(lambdaoc_j - lambdaoc_(p == arbitrary))
-
-        //int p = 0;
-        int p = rstate.N/2-1; // choice doesn't matter, see 1990_Slavnov_TMP_82 after (3.8). Choose rapidity around the middle.
-
-
-        DP c_int = rstate.c_int;
+  complex<DP> ln_g2_ME (LiebLin_Bethe_State& lstate, LiebLin_Bethe_State& rstate)
+  {
+    // Computes the log of the density operator \rho(x = 0) matrix element between lstate and rstate.
 
-        DP Eout = log(pow(lstate.E - rstate.E,2.)) - (2)*log(c_int)  - log(2*lstate.N);
+    // If we have lstate == rstate, density matrix element = 0:
+    if (lstate.Ix2 == rstate.Ix2) return(-200.);
 
-        for (int a = 0; a < lstate.N; ++a) {
-            Vplus[a] = Fn_V_g2 (a, lstate, rstate);
-            //Fn_Prod[a] = 1.0;
-            ln_Fn_Prod[a] = 0.0;;
-            for (int m = 0; m < lstate.N; ++m)
-                //if (m != a) Fn_Prod[a] *= (lstate.lambdaoc[m] - rstate.lambdaoc[a])/(rstate.lambdaoc[m] - rstate.lambdaoc[a]);
-                if (m != a) ln_Fn_Prod[a] += log(complex<DP>(lstate.lambdaoc[m] - rstate.lambdaoc[a])/(rstate.lambdaoc[m] - rstate.lambdaoc[a]));
-            rKern[a] = rstate.Kernel (a, p);
-        }
+    SQMat_DP one_plus_U (0.0, lstate.N);
 
-        for (int a = 0; a < lstate.N; ++a)
-            for (int b = 0; b < lstate.N; ++b)
-                one_plus_U[a][b] = (a == b ? 1.0 : 0.0) + 0.5 * 1./imag(Vplus[a])
-                //* Fn_Prod[a] * (rstate.Kernel(a,b) - rKern[b]);
-                * ((lstate.lambdaoc[a] - rstate.lambdaoc[a])*real(exp(ln_Fn_Prod[a])) * (rstate.Kernel(a,b) - rKern[b]) + rKern[b]);
+    Vect_CX Vplus (0.0, lstate.N);  // contains V^+_j;  V^-_j is the conjugate
+    Vect_CX ln_Fn_Prod (0.0, lstate.N);  // product_{m\neq j} (\mu_m - \lambdaoc_j)/(\lambdaoc_m - \lambdaoc_j)
+    Vect_DP rKern (0.0, lstate.N);   // K(lambdaoc_j - lambdaoc_(p == arbitrary))
 
-        complex<DP> ln_ddalpha_sigma = lndet_LU_dstry(one_plus_U);
+    int p = rstate.N/2-1; // choice doesn't matter, see 1990_Slavnov_TMP_82 after (3.8). Choose rapidity around the middle.
 
-        complex<DP> ln_prod_V = 0.0;
-        for (int a = 0; a < lstate.N; ++a) ln_prod_V += log(2.0 * II * imag(Vplus[a]));
+    DP c_int = rstate.c_int;
 
-        complex<DP> ln_prod_2 = 0.0;
-        for (int a = 0; a < lstate.N; ++a)
-            for (int b = 0; b < lstate.N; ++b)
-                ln_prod_2 += log((rstate.lambdaoc[a] - rstate.lambdaoc[b] + II)/(lstate.lambdaoc[a] - rstate.lambdaoc[b]));
+    DP Eout = log(pow(lstate.E - rstate.E,2.)) - (2)*log(c_int)  - log(2*lstate.N);
 
-        //cout << "ln_Fn_Prod = " << ln_Fn_Prod << endl;
-        //cout << endl << ln_ddalpha_sigma << "\t" << ln_prod_V << "\t" << ln_prod_2 << "\t" << - log(2.0 * II * imag(Vplus[p])) << "\t" << - 0.5 * (lstate.lnnorm + rstate.lnnorm) << "\t" << ln_ddalpha_sigma + ln_prod_V + ln_prod_2 - log(2.0 * II * imag(Vplus[p])) - 0.5 * (lstate.lnnorm + rstate.lnnorm) << endl;
+    for (int a = 0; a < lstate.N; ++a) {
+      Vplus[a] = Fn_V_g2 (a, lstate, rstate);
+      ln_Fn_Prod[a] = 0.0;;
+      for (int m = 0; m < lstate.N; ++m)
+	if (m != a) ln_Fn_Prod[a] += log(complex<DP>(lstate.lambdaoc[m] - rstate.lambdaoc[a])
+					 /(rstate.lambdaoc[m] - rstate.lambdaoc[a]));
+      rKern[a] = rstate.Kernel (a, p);
+    }
 
-        ln_ddalpha_sigma += ln_prod_V + ln_prod_2 - log(2.0 * II * imag(Vplus[p]));
+    for (int a = 0; a < lstate.N; ++a)
+      for (int b = 0; b < lstate.N; ++b)
+	one_plus_U[a][b] = (a == b ? 1.0 : 0.0) + 0.5 * 1./imag(Vplus[a])
+	  * ((lstate.lambdaoc[a] - rstate.lambdaoc[a])*real(exp(ln_Fn_Prod[a]))
+	     * (rstate.Kernel(a,b) - rKern[b]) + rKern[b]);
 
-        return (log(II) + Eout + ln_ddalpha_sigma - 0.5 * (lstate.lnnorm + rstate.lnnorm));
-    }
+    complex<DP> ln_ddalpha_sigma = lndet_LU_dstry(one_plus_U);
 
+    complex<DP> ln_prod_V = 0.0;
+    for (int a = 0; a < lstate.N; ++a) ln_prod_V += log(2.0 * II * imag(Vplus[a]));
 
+    complex<DP> ln_prod_2 = 0.0;
+    for (int a = 0; a < lstate.N; ++a)
+      for (int b = 0; b < lstate.N; ++b)
+	ln_prod_2 += log((rstate.lambdaoc[a] - rstate.lambdaoc[b] + II)/(lstate.lambdaoc[a] - rstate.lambdaoc[b]));
 
+    ln_ddalpha_sigma += ln_prod_V + ln_prod_2 - log(2.0 * II * imag(Vplus[p]));
 
+    return (log(II) + Eout + ln_ddalpha_sigma - 0.5 * (lstate.lnnorm + rstate.lnnorm));
+  }
 
 } // namespace ABACUS

src/MATRIX/ludcmp_CX.cc

   const complex<DP> TINY = 1.0e-200;
   int i, j, k;
   int imax = 0;
-  //  DP big, dum, sum, temp;
   complex<DP> big, dum, sum, temp;
 
   int n = a.size();
   for (i = 0; i < n; i++) {
     big = 0.0;
     for (j = 0; j < n; j++)
-      //      if ((temp = fabs(a[i][j])) > big) big = temp;
       if ((abs(temp = a[i][j])) > abs(big)) big = temp;
-      //if ((norm(temp = a[i][j])) > norm(big)) big = temp;
-    if (big == 0.0) throw Divide_by_zero(); //ABACUSerror("Singular matrix in routine ludcmp.");
+    if (big == 0.0) throw Divide_by_zero();
     vv[i] = 1.0/big;
   }
   for (j = 0; j < n; j++) {
       sum = a[i][j];
       for (k = 0; k < j; k++) sum -= a[i][k] * a[k][j];
       a[i][j] = sum;
-      //      if ((dum = vv[i]*fabs(sum)) >= big) {
       if ((abs(dum = vv[i]*sum)) >= abs(big)) {
-      //if ((norm(dum = vv[i]*sum)) >= norm(big)) {
 	big = dum;
 	imax = i;
       }

src/MATRIX/tred2.cc

       for (k = 0; k < l + 1; k++) scale += fabs(a[i][k]);
       if (scale == 0.0) e[i] = a[i][l];
       else {
-	//  scale = 1.0;  // <- added this myself...
 	for (k = 0; k < l + 1; k++) {
 	  a[i][k] /= scale;
 	  h += a[i][k] * a[i][k];

src/NRG/NRG_DME_Matrix_Block_builder.cc

 
 namespace ABACUS {
 
-  void Build_DME_Matrix_Block_for_NRG (DP c_int, DP L, int N, int iKmin, int iKmax, int Nstates_required, bool symmetric_states, int iKmod,
-				       int weighing_option, int nrglabel_left_begin, int nrglabel_left_end, int nrglabel_right_begin, int nrglabel_right_end,
+  void Build_DME_Matrix_Block_for_NRG (DP c_int, DP L, int N, int iKmin, int iKmax,
+				       int Nstates_required, bool symmetric_states, int iKmod,
+				       int weighing_option, int nrglabel_left_begin, int nrglabel_left_end,
+				       int nrglabel_right_begin, int nrglabel_right_end,
 				       int block_option, DP* DME_block_1, DP* DME_block_2, Vect_DP Kweight)
   {
     // Given a list of states produced by Select_States_for_NRG, this function
     // We assume the DME_blocks are already reserved in memory.
     // If !symmetric states, DME_block_2 doesn't need to be allocated.
 
-    if (nrglabel_left_begin < 0 || nrglabel_right_begin < 0) ABACUSerror("beginning nrglabels negative in Build_DME_Matrix_Block_for_NRG");
-    if (nrglabel_left_end >= Nstates_required) ABACUSerror("nrglabel_left_end too large in Build_DME_Matric_Block_for_NRG");
-    if (nrglabel_right_end >= Nstates_required) ABACUSerror("nrglabel_right_end too large in Build_DME_Matric_Block_for_NRG");
+    if (nrglabel_left_begin < 0 || nrglabel_right_begin < 0)
+      ABACUSerror("beginning nrglabels negative in Build_DME_Matrix_Block_for_NRG");
+    if (nrglabel_left_end >= Nstates_required)
+      ABACUSerror("nrglabel_left_end too large in Build_DME_Matric_Block_for_NRG");
+    if (nrglabel_right_end >= Nstates_required)
+      ABACUSerror("nrglabel_right_end too large in Build_DME_Matric_Block_for_NRG");
+
+    if (nrglabel_left_begin > nrglabel_left_end)
+      ABACUSerror("nrglabels of left states improperly chosen in DME block builder.");
+    if (nrglabel_right_begin > nrglabel_right_end)
+      ABACUSerror("nrglabels of right states improperly chosen in DME block builder.");
 
-    if (nrglabel_left_begin > nrglabel_left_end) ABACUSerror("nrglabels of left states improperly chosen in DME block builder.");
-    if (nrglabel_right_begin > nrglabel_right_end) ABACUSerror("nrglabels of right states improperly chosen in DME block builder.");
     // DME_block is a pointer of size row_l * col_l, where
     int block_row_length = nrglabel_right_end - nrglabel_right_begin + 1;
     int block_col_length = nrglabel_left_end - nrglabel_left_begin + 1;
     }
 
     // Read the whole data file:
-    //const int MAXDATA = 5000000;
     const int MAXDATA = ABACUS::max(nrglabel_left_end, nrglabel_right_end) + 10; // 10 for safety...
 
     int* nrglabel = new int[MAXDATA];
 
       Kept_States_left[nrglabel_left - nrglabel_left_begin] = Scanstate;
 
-      if (!Scanstate.conv) cout << "State of label " << label[nrglabel_left] << " did not converge after " << Scanstate.iter_Newton
-				<< " Newton step; diffsq = " << Scanstate.diffsq << endl;
+      if (!Scanstate.conv)
+	cout << "State of label " << label[nrglabel_left] << " did not converge after " << Scanstate.iter_Newton
+	     << " Newton step; diffsq = " << Scanstate.diffsq << endl;
     } // for nrglabel_left
 
     for (int nrglabel_right = nrglabel_right_begin; nrglabel_right <= nrglabel_right_end; ++nrglabel_right) {
 
       Kept_States_right[nrglabel_right - nrglabel_right_begin] = Scanstate;
 
-      if (!Scanstate.conv) cout << "State of label " << label[nrglabel_right] << " did not converge after " << Scanstate.iter_Newton
-				<< " Newton step; diffsq = " << Scanstate.diffsq << endl;
+      if (!Scanstate.conv)
+	cout << "State of label " << label[nrglabel_right] << " did not converge after " << Scanstate.iter_Newton
+	     << " Newton step; diffsq = " << Scanstate.diffsq << endl;
     } // for nrglabel_left
 
 
       for (int lr = 0; lr < block_row_length; ++lr) {
 
 	if (Kept_States_left[ll].conv && Kept_States_right[lr].conv
-	    //&& abs(Kept_States[il].iK - Kept_States[ir].iK) % iKmod == 0)
 	    && abs(Kept_States_left[ll].iK) % iKmod == 0
 	    && abs(Kept_States_right[lr].iK) % iKmod == 0) {
 
 
 	      if (block_option == 1) {
 		DME_block_1[ll* block_row_length + lr] =
-		  (Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])))
-		   + Kweight[abs(Kept_States_left[ll].iK - PRstate.iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], PRstate))));
+		  (Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)]
+		   * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])))
+		   + Kweight[abs(Kept_States_left[ll].iK - PRstate.iK)]
+		   * real(exp(ln_Density_ME (Kept_States_left[ll], PRstate))));
 		// We don't do anything with block 2, we don't even assume it's been allocated.
 	      }
 	      else if (block_option == 2) {
 		DME_block_1[ll* block_row_length + lr] =
-		  Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])));
+		  Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)]
+		  * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])));
 		DME_block_2[ll* block_row_length + lr] =
-		  Kweight[abs(Kept_States_left[ll].iK - PRstate.iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], PRstate)));
+		  Kweight[abs(Kept_States_left[ll].iK - PRstate.iK)]
+		  * real(exp(ln_Density_ME (Kept_States_left[ll], PRstate)));
 	      }
 	    }
 
 
 	      if (block_option == 1) {
 		DME_block_1[ll* block_row_length + lr] = sqrt(0.5) *
-		  (Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])))
-		   + Kweight[abs(Kept_States_left[ll].iK - PRstate.iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], PRstate))));
+		  (Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)]
+		   * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])))
+		   + Kweight[abs(Kept_States_left[ll].iK - PRstate.iK)]
+		   * real(exp(ln_Density_ME (Kept_States_left[ll], PRstate))));
 		// We don't do anything with block 2, we don't even assume it's been allocated.
 	      }
 	      else if (block_option == 2) {
 		DME_block_1[ll* block_row_length + lr] = sqrt(0.5) *
-		  Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])));
+		  Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)]
+		  * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])));
 		DME_block_2[ll* block_row_length + lr] = sqrt(0.5) *
-		  Kweight[abs(Kept_States_left[ll].iK - PRstate.iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], PRstate)));
+		  Kweight[abs(Kept_States_left[ll].iK - PRstate.iK)]
+		  * real(exp(ln_Density_ME (Kept_States_left[ll], PRstate)));
 	      }
 	    }
 
 
 	      if (block_option == 1) {
 		DME_block_1[ll* block_row_length + lr] = sqrt(0.5) *
-		  (Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])))
-		   + Kweight[abs(PLstate.iK - Kept_States_right[lr].iK)] * real(exp(ln_Density_ME (PLstate, Kept_States_right[lr]))));
+		  (Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)]
+		   * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])))
+		   + Kweight[abs(PLstate.iK - Kept_States_right[lr].iK)]
+		   * real(exp(ln_Density_ME (PLstate, Kept_States_right[lr]))));
 		// We don't do anything with block 2, we don't even assume it's been allocated.
 	      }
 	      else if (block_option == 2) {
 		DME_block_1[ll* block_row_length + lr] = sqrt(0.5) *
-		  Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)] * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])));
+		  Kweight[abs(Kept_States_left[ll].iK - Kept_States_right[lr].iK)]
+		  * real(exp(ln_Density_ME (Kept_States_left[ll], Kept_States_right[lr])));
 		DME_block_2[ll* block_row_length + lr] = sqrt(0.5) *
-		  Kweight[abs(PLstate.iK - Kept_States_right[lr].iK)] * real(exp(ln_Density_ME (PLstate, Kept_States_right[lr])));
+		  Kweight[abs(PLstate.iK - Kept_States_right[lr].iK)]
+		  * real(exp(ln_Density_ME (PLstate, Kept_States_right[lr])));
 	      }
 	    }
 
 
 	else {
 	  DME_block_1[ll* block_row_length + lr] = 0.0;
-	  if (symmetric_states && block_option == 2) DME_block_2[ll* block_row_length + lr] = 0.0;  // condition, to prevent segfault if DME_block_2 not allocated.
+	  // condition, to prevent segfault if DME_block_2 not allocated.
+	  if (symmetric_states && block_option == 2) DME_block_2[ll* block_row_length + lr] = 0.0;
 	}
-
-	//cout << ll << "\t" << lr << "\t" << DME_block[ll* block_row_length + lr] << endl;
-
       } // for lr
     } // for ll
 
     return;
   }
 
-
 } // namespace ABACUS

src/NRG/NRG_K_Weight_integrand.cc

     return(value);
   }
 
-
-
 } // namespace ABACUS

src/NRG/NRG_State_Selector.cc

 
   DP Estimate_Contribution_of_Single_ph_Annihilation_Path_to_2nd_Order_PT (LiebLin_Bethe_State& TopState,
 									   LiebLin_Bethe_State& GroundState,
-									   //Vect_DP Weight_integral)
 									   Vect<complex <DP> >& FT_of_potential)
   {
-    //cout << TopState.label << "\t" << GroundState.label << endl;
-    //cout << TopState.lambdaoc << endl;
-
     DP contrib_estimate = 0.0;
 
     // Define OriginIx2 for labelling:
     int nr_cont = 0;
 
     // Add first-order PT contribution, and 2nd order from ground state (V_{00} == 1)
-    //contrib_estimate += Weight_integral[Weight_integral.size()/2 + (TopState.iK - GroundState.iK)]
-    //* (densityME/(GroundState.E - TopState.E)) * (1.0 - (GroundState.N/GroundState.L)/(GroundState.E - TopState.E));
     contrib_estimate += abs(FT_of_potential[FT_of_potential.size()/2 + (TopState.iK - GroundState.iK)]
 			    * (densityME/(GroundState.E - TopState.E))
 			    * (1.0 - (GroundState.N/GroundState.L)/(GroundState.E - TopState.E)));
     nr_cont++;
 
     // Add second order PT contribution coming from TopState:
-    //contrib_estimate += Weight_integral[Weight_integral.size()/2 + 0]
-    //* Weight_integral[Weight_integral.size()/2 + (TopState.iK - GroundState.iK)]
-    //* 1.0 * densityME * (GroundState.N/GroundState.L) // 1.0 is V_{TopState, TopState}
-	///((GroundState.E - TopState.E) * (GroundState.E - TopState.E));
     contrib_estimate += abs(FT_of_potential[FT_of_potential.size()/2 + 0]
 			    * FT_of_potential[FT_of_potential.size()/2 + (TopState.iK - GroundState.iK)]
 			    * 1.0 * densityME * (GroundState.N/GroundState.L) // 1.0 is V_{TopState, TopState}
 
     nr_cont++;
 
-    //cout << "Here b" << endl;
-
     // Now add 2nd order terms coming from single particle-hole annihilation paths:
     // this is only to be included for states with at least 4 excitations (2 ph pairs)
-
     if (nphpairs >= 2) {
 
       for (int ipart = 0; ipart < nphpairs; ++ipart) {
 	for (int ihole = 0; ihole < nphpairs; ++ihole) {
 
 	  LiebLin_Bethe_State DescendedState = TopState;
-	  //cout << "Here 2a" << "\tipart " << ipart << "\tihole " << ihole << " out of " << nphpairs << " nphpairs, label " << TopState.label << endl;
-	  //cout << "TopState.Ix2 " << TopState.Ix2 << endl;
-	  //cout << "DescendedIx2 " << DescendedState.Ix2 << endl;
 	  DescendedState.Annihilate_ph_pair(ipart, ihole, OriginIx2);
 	  DescendedState.Compute_All(true);
-	  //cout << "DescendedIx2 " << DescendedState.Ix2 << endl;
 
 	  DP densityME_top_desc = real(exp(ln_Density_ME (TopState, DescendedState)));
 	  DP densityME_desc_ground = real(exp(ln_Density_ME (DescendedState, GroundState)));
 
-	  //contrib_estimate += Weight_integral[Weight_integral.size()/2 + (TopState.iK - DescendedState.iK)]
-	  //* Weight_integral[Weight_integral.size()/2 + (DescendedState.iK - GroundState.iK)]
-	  //* densityME_top_desc * densityME_desc_ground
-	  ///((GroundState.E - TopState.E) * (GroundState.E - DescendedState.E));
-
 	  // if intermediate state has momentum within allowable window, OK, otherwise discard contribution:
 	  if (abs(TopState.iK - DescendedState.iK) < FT_of_potential.size()/2 &&
 	      abs(DescendedState.iK - GroundState.iK) < FT_of_potential.size()/2) {
 	      for (int ihole2 = ihole; ihole2 < nphpairs - 1; ++ihole2) {
 
 		LiebLin_Bethe_State DescendedState2 = DescendedState;
-		//cout << "Here 3a" << "\tipart2 " << ipart2 << "\tihole2 " << ihole2 << endl;
-		//cout << DescendedState2.Ix2 << endl;
 		DescendedState2.Annihilate_ph_pair(ipart2, ihole2, OriginIx2);
 		DescendedState2.Compute_All(true);
-		//cout << DescendedState2.Ix2 << endl;
-		//cout << DescendedState2.lambdaoc << endl;
 
 		DP densityME_top_desc2 = real(exp(ln_Density_ME (TopState, DescendedState2)));
 		DP densityME_desc2_ground = real(exp(ln_Density_ME (DescendedState2, GroundState)));
 
-		//contrib_estimate += Weight_integral[Weight_integral.size()/2 + (TopState.iK - DescendedState2.iK)]
-		//* Weight_integral[Weight_integral.size()/2 + (DescendedState2.iK - GroundState.iK)]
-		//* densityME_top_desc2 * densityME_desc2_ground
-		///((GroundState.E - TopState.E) * (GroundState.E - DescendedState2.E));
-
 		// if intermediate state has momentum within allowable window, OK, otherwise discard contribution:
 		if (abs(TopState.iK - DescendedState2.iK) < FT_of_potential.size()/2 &&
 		    abs(DescendedState2.iK - GroundState.iK) < FT_of_potential.size()/2) {
 		    for (int ihole3 = ihole2; ihole3 < nphpairs - 2; ++ihole3) {
 
 		      LiebLin_Bethe_State DescendedState3 = DescendedState2;
-		      //cout << "Here 4a" << "\tipart3 " << ipart3 << "\tihole3 " << ihole3 << endl;
 		      DescendedState3.Annihilate_ph_pair(ipart3, ihole3, OriginIx2);
-		      //cout << DescendedState3.Ix2 << endl;
 		      DescendedState3.Compute_All(true);
-		      //cout << DescendedState3.Ix2 << endl;
 
 		      DP densityME_top_desc3 = real(exp(ln_Density_ME (TopState, DescendedState3)));
 		      DP densityME_desc3_ground = real(exp(ln_Density_ME (DescendedState3, GroundState)));
 
-		      //contrib_estimate += Weight_integral[Weight_integral.size()/2 + (TopState.iK - DescendedState3.iK)]
-		      //* Weight_integral[Weight_integral.size()/2 + (DescendedState3.iK - GroundState.iK)]
-		      //* densityME_top_desc3 * densityME_desc3_ground
-		      ///((GroundState.E - TopState.E) * (GroundState.E - DescendedState3.E));
-
 		      // if intermediate state has momentum within allowable window, OK, otherwise discard contribution:
 		      if (abs(TopState.iK - DescendedState3.iK) < FT_of_potential.size()/2 &&
 			  abs(DescendedState3.iK - GroundState.iK) < FT_of_potential.size()/2) {
 
 			contrib_estimate += abs(FT_of_potential[FT_of_potential.size()/2 + (TopState.iK - DescendedState3.iK)]
-						* FT_of_potential[FT_of_potential.size()/2 + (DescendedState3.iK - GroundState.iK)]
+						* FT_of_potential[FT_of_potential.size()/2
+								  + (DescendedState3.iK - GroundState.iK)]
 						* densityME_top_desc3 * densityME_desc3_ground
 						/((GroundState.E - TopState.E) * (GroundState.E - DescendedState3.E)));
 
       } // for ipart
     } // if nphpairs >= 2
 
-    //cout << "Here b" << endl;
-    //cout << "type_id " << TopState.type_id << "\tid " << TopState.id << "\tcontrib_est = " << contrib_estimate << "\tnr_cont = " << nr_cont << endl;
-
     return(contrib_estimate);
   }
 
-  /*
-  DP Estimate_Contribution_of_Base_to_2nd_Order_PT (LiebLin_Bethe_State& ScanState, LiebLin_Bethe_State& GroundState,
-						    Vect_DP Weight_integral, LiebLin_States_and_Density_ME_of_Base& StatesBase)
-  {
-    // This function calculates the second-order perturbation theory contribution to
-    // state ScanState coming from states of base defined in StatesBase.
-
-    DP sum_contrib = 0.0;
-
-    for (int i = 0; i <= StatesBase.maxid; ++i)
-      sum_contrib += Weight_integral[Weight_integral.size()/2 + (ScanState.iK - StatesBase.State[i].iK)]
-	* Weight_integral[Weight_integral.size()/2 + (StatesBase.State[i].iK - GroundState.iK)]
-	* real(exp(ln_Density_ME (ScanState, StatesBase.State[i]))) * StatesBase.densityME[i]
-	/((GroundState.E - StatesBase.State[i].E) * (GroundState.E - ScanState.E));
-    // The strange vector size is so that iK == 0 corresponds to index size/2, as per convention
-    return(sum_contrib);
-  }
-  */
 
-  void Select_States_for_NRG (DP c_int, DP L, int N, int iKmin, int iKmax, int Nstates_required, bool symmetric_states, int iKmod,
-			      //int weighing_option, DP (*weight_integrand_fn) (Vect_DP), Vect_DP& args_to_weight_integrand)
-			      int weighing_option, Vect<complex <DP> >& FT_of_potential)
+  void Select_States_for_NRG (DP c_int, DP L, int N, int iKmin, int iKmax, int Nstates_required,
+			      bool symmetric_states, int iKmod, int weighing_option, Vect<complex <DP> >& FT_of_potential)
   {
     // This function reads an existing partition function file and determines whether
     // each state is to be included in NRG by applying an energy, momentum and form factor criterion.
     // weighing_option == 1:  ordering according to perturbation theory in single p-h annihilation path
     // weighing_option == 2:  same as 1, but output of list is ordered in weight
 
-
     stringstream filenameprefix;
     Data_File_Name (filenameprefix, 'Z', c_int, L, N, iKmin, iKmax, 0.0, 0.0, "");
     string prefix = filenameprefix.str();
     NRG_outfile.open(NRG_Cstr);
     if (NRG_outfile.fail()) ABACUSerror("Could not open NRG_outfile... ");
 
-    //NRG_outfile.setf(ios::scientific);
     NRG_outfile.precision(16);
 
 
     // Read the whole data file:
-    /*
-    // estimate its size:
-    struct stat statbuf;
-    stat (RAW_Cstr, &statbuf);
-    int filesize = statbuf.st_size;
-    // Determine the number of entries approximately
-    int entry_size = 1* sizeof(double) + 2*sizeof(int) + 3* sizeof(long long int);
-
-    int estimate_nr_entries = filesize/entry_size;
-    */
 
     // Count the number of entries in raw file:
     int estimate_nr_entries = 0;
       getline(infile, line);
       estimate_nr_entries++;
     }
-
     const int MAXDATA = estimate_nr_entries;
-    //cout << "estimate_nr_entries: " << estimate_nr_entries << endl;
 
     DP* E = new DP[MAXDATA];
     int* iK = new int[MAXDATA];
-    //int* conv = new int[MAXDATA];
     string* label = new string[MAXDATA];
     bool* sym = new bool[MAXDATA];
 
     while (((infile.peek()) != EOF) && (Ndata < MAXDATA)) {
       infile >> E[Ndata];
       infile >> iK[Ndata];
-      //infile >> conv[Ndata];
       infile >> label[Ndata];
       Ndata++;
     }
 
-    //cout << "input " << Ndata << " data lines." << endl;
     infile.close();
 
     // Define the ground state:
     // To cover negative and positive momenta (in case potential is not symmetric),
     // we define the Weight_integral vector entry with index size/2 as corresponding to iK == 0.
 
-    /*
-    // DEPRECATED 25/1/2012: from now on (ABACUS++T_8 onwards), use FT of potential as argument to this function.
-    Vect_DP Weight_integral (0.0, 4* (iKmax - iKmin)); // we give a large window
-
-    //Vect_DP args(0.0, 2);
-    DP req_rel_prec = 1.0e-6;
-    DP req_abs_prec = 1.0e-6;
-    int max_nr_pts = 10000;
-
-    for (int iK = -Weight_integral.size()/2; iK < Weight_integral.size()/2; ++iK) {
-
-      args_to_weight_integrand[1] = DP(iK);
-
-      Integral_result answer = Integrate_optimal (weight_integrand_fn, args_to_weight_integrand,
-						  0, 0.0, 0.5, req_rel_prec, req_abs_prec, max_nr_pts);
-
-      Weight_integral[Weight_integral.size()/2 + iK] = answer.integ_est;
-
-    }
-    */
-
     // Calculate weight of states using selection criterion function
 
-    //DP absdensityME = 0.0;
     DP* weight = new DP[Ndata];
 
     // For weighing using 2nd order PT, we only trace over 2 excitation states (1 p-h pair)
 
     for (int i = 0; i < Ndata; ++i) {
 
-      //cout << i << " out of " << Ndata << "\tlabel = " << label[i] << endl;
-
       if (abs(iK[i]) % iKmod != 0) {     // if iK not a multiple of iKmod:  give stupidly high weight.
 	weight[i] = 1.0e+100;
 	sym[i] = false;  // doesn't matter
 	if (weighing_option == 1 || weighing_option == 2) ScanState.Compute_All(true);
 	sym[i] = ScanState.Check_Symmetry();
 
-	//cout << "Setting state " << i << "\t to label " << label[i] << "\tsym: " << sym[i] << endl;
-
-	// WEIGHING THE STATES:  **********************************************
-
 	State_Label_Data currentdata = Read_State_Label (label[i], OriginIx2);
 	if (currentdata.nexc[0] == 0) weight[i] = 0.0;
 
 	else if (symmetric_states && iK[i] < 0 || iK[i] < iKmin || iK[i] > iKmax) weight[i] = 1.0e+100;
 
-	//else if (symmetric_states && iK[i] == 0 && !ScanState.Check_Symmetry()) {
 	else if (symmetric_states && iK[i] == 0 && !sym[i]) {
 	  // This state is at zero momentum but not symmetric.  we keep it only if
 	  // the first non-symmetric pair of quantum numbers is right-weighted:
 	    if (weighing_option == 0) weight[i] = E[i];
 	    else if (weighing_option == 1 || weighing_option == 2)
 	      weight[i] = 1.0/(1.0e-100 + fabs(Estimate_Contribution_of_Single_ph_Annihilation_Path_to_2nd_Order_PT
-					       //(ScanState, GroundState, Weight_integral)));
 					       (ScanState, GroundState, FT_of_potential)));
 	  }
 	  else weight[i] = 1.0e+100;
 	  if (weighing_option == 0) weight[i] = E[i];
 	  else if (weighing_option == 1 || weighing_option == 2)
 	    weight[i] = 1.0/(1.0e-100 + fabs(Estimate_Contribution_of_Single_ph_Annihilation_Path_to_2nd_Order_PT
-					     //(ScanState, GroundState, Weight_integral)));
 					     (ScanState, GroundState, FT_of_potential)));
 	}
-	//cout << i << " out of " << Ndata << "\tlabel = " << label[i] << "\tweight = " << weight[i] << endl;
       }
     } // for i
 
 
     QuickSort(weight, index, 0, Ndata - 1);
 
-
     // Select states by increasing weight, with a max of Nstates_required entries
 
     DP* E_kept = new DP[Nstates_required];
     int* iK_kept = new int[Nstates_required];
-    //int* conv_kept = new int[Nstates_required];
     string* label_kept = new string[Nstates_required];
     bool* sym_kept = new bool[Nstates_required];
     DP* weight_kept = new DP[Nstates_required];
 
     // Copy selected states into new vectors:
-
     for (int i = 0; i < ABACUS::min(Ndata, Nstates_required); ++i) {
       E_kept[i] = E[index[i] ];
       iK_kept[i] = iK[index[i] ];
 
 
     // If needed, order selected states by increasing energy:
-
     int* index_kept = new int[Nstates_required];
     for (int i = 0; i < Nstates_required; ++i) index_kept[i] = i;
 
     for (int i = 0; i < Nstates_required; ++i) {
       if (i > 0) NRG_outfile << endl;
       NRG_outfile << i << "\t" << E_kept[i] << "\t" << iK_kept[index_kept[i] ]
-	//<< "\t" << conv_kept[index_kept[i] ]
 		  << "\t" << label_kept[index_kept[i] ]
 		  << "\t" << sym_kept[index_kept[i] ] << "\t" << weight_kept[index_kept[i] ];
     }
 
     delete[] E;
     delete[] iK;
-    //delete[] conv;
     delete[] label;
     delete[] sym;
     delete[] E_kept;
     delete[] iK_kept;
-    //delete[] conv_kept;
     delete[] label_kept;
     delete[] sym_kept;
     delete[] weight;
     return;
   }
 
-
 } // namespace ABACUS

src/ODSLF/ODSLF_Chem_Pot.cc

 
 namespace ABACUS {
 
-  /*
-  DP Ezero (DP Delta, int N, int M)
-  {
-    // Returns the energy of the ground state with M down spins
-
-    if (M < 0 || M > N/2) ABACUSerror("M out of bounds in Ezero.");
-
-    DP E = -1.0; // sentinel value
-
-    if (M == 0) E = N * Delta/4.0;
-
-    else {
-
-      Heis_Chain BD1(1.0, Delta, 0.0, N);
-
-      Vect_INT Nrapidities_groundstate(0, BD1.Nstrings);
-
-      Nrapidities_groundstate[0] = M;
-
-      ODSLF_Base baseconfig_groundstate(BD1, Nrapidities_groundstate);
-
-      if ((Delta > 0.0) && (Delta < 1.0)) {
-	ODSLF_XXZ_Bethe_State groundstate(BD1, baseconfig_groundstate);
-	groundstate.Compute_All(true);
-	E = groundstate.E;
-      }
-
-      else if (Delta == 1.0) {
-	XXX_Bethe_State groundstate(BD1, baseconfig_groundstate);
-	groundstate.Compute_All(true);
-	E = groundstate.E;
-      }
-
-      else if (Delta > 1.0) {
-	XXZ_gpd_Bethe_State groundstate(BD1, baseconfig_groundstate);
-	groundstate.Compute_All(true);
-	E = groundstate.E;
-      }
-
-      else ABACUSerror("Anisotropy out of bounds in Ezero.");
-    }
-
-    return(E);
-  }
-
-  DP H_vs_M (DP Delta, int N, int M)
-  {
-    // Assumes dE/dM = 0 = dE_0/dM + h, with dE_0/dM = E_0(M) - E_0 (M - 1)
-
-    DP H = 0.0;
-
-    if (2*M == N) H = 0.0;
-
-    else if (Delta <= 1.0) H = Ezero (Delta, N, M - 1) - Ezero (Delta, N, M);
-
-    return(H);
-  }
-
-  DP HZmin (DP Delta, int N, int M, Vect_DP& Ezero_ref)
-  {
-    if (M < 0 || M > N/2 - 1) {
-      cout << "M = " << M << endl;
-      ABACUSerror("M out of bounds in HZmin.");
-    }
-
-    if (Ezero_ref[M] == -1.0) Ezero_ref[M] = Ezero(Delta, N, M);
-    if (Ezero_ref[M + 1] == -1.0) Ezero_ref[M + 1] = Ezero(Delta, N, M + 1);
-
-    return(Ezero_ref[M] - Ezero_ref[M + 1]);
-  }
-
-  int M_vs_H (DP Delta, int N, DP HZ)
-  {
-    // Returns the value of M for given field HZ
-
-    if (HZ < 0.0) ABACUSerror("Please use a positive field in M_vs_H.");
-
-    else if (HZ == 0.0) return(N/2);
-
-    // Here, -1.0 is a sentinel value.
-    Vect_DP Ezero(-1.0, N/2 + 1);  // contains the GSE[M].
-
-    // We look for M s.t. HZmin[M] < HZ <= HZmin[M + 1]
-
-    int M_actual = N/4; // start somewhere in middle
-    int M_step = N/8 - 1; // step
-    DP HZmin_actual = 0.0;
-    DP HZmax_actual = 0.0;
-    bool M_found = false;
-
-    if (HZ >= 1.0 + Delta) M_actual = 0;  // saturation
-
-    else {
-
-      HZmin_actual = HZmin (Delta, N, M_actual, Ezero);
-      HZmax_actual = HZmin (Delta, N, M_actual - 1, Ezero);
-
-      while (!M_found) {
-
-	if (HZmin_actual > HZ) M_actual += M_step;
-	else if (HZmax_actual <= HZ) M_actual -= M_step;
-
-	M_step = (M_step + 1)/2;
-
-	HZmin_actual = HZmin (Delta, N, M_actual, Ezero);
-	HZmax_actual = HZmin (Delta, N, M_actual - 1, Ezero);
-
-	M_found = (HZmin_actual < HZ && HZ <= HZmax_actual);
-
-	//cout << "M_actual = " << M_actual << "\tM_step = " << M_step
-	//   << "\tHZmin_actual = " << HZmin_actual << "\tHZmax_actual = " << HZmax_actual << "\tHZ = " << HZ << "\t" << M_found << endl;
-      }
-    }
-    //cout << "M found = " << M_actual << "\tHZmax = " << Ezero[M_actual] - Ezero[M_actual + 1] << "\tHZmin = " << Ezero[M_actual - 1] - Ezero[M_actual] << endl;
-
-    return(M_actual);
-  }
-  */
-
   DP Chemical_Potential (const ODSLF_Bethe_State& RefState)
   {
     return(-H_vs_M (RefState.chain.Delta, RefState.chain.Nsites, RefState.base.Mdown));  // - sign since E_{M+1} - E_M = -H

src/ODSLF/ODSLF_Matrix_Element_Contrib.cc

 
 namespace ABACUS {
 
-  //DP Compute_Matrix_Element_Contrib (char whichDSF, bool fixed_iK, ODSLF_XXZ_Bethe_State& LeftState,
-				     //ODSLF_XXZ_Bethe_State& RefState, DP Chem_Pot, fstream& DAT_outfile)
   DP Compute_Matrix_Element_Contrib (char whichDSF, int iKmin, int iKmax, ODSLF_XXZ_Bethe_State& LeftState,
 				     ODSLF_XXZ_Bethe_State& RefState, DP Chem_Pot, fstream& DAT_outfile)
   {
       ME = exp(real(ln_Smin_ME (RefState, LeftState)));
     else if (whichDSF == 'z') {
       if (LeftState.base_id == RefState.base_id && LeftState.type_id == RefState.type_id && LeftState.id == RefState.id)
-	//MEsq = RefState.chain.Nsites * 0.25 * pow((1.0 - 2.0*RefState.base.Mdown/RefState.chain.Nsites), 2.0);
 	ME = sqrt(RefState.chain.Nsites * 0.25) * (1.0 - 2.0*RefState.base.Mdown/RefState.chain.Nsites);
       else ME = exp(real(ln_Sz_ME (RefState, LeftState)));
     }
       if (whichDSF == 'Z') {
 	DAT_outfile << endl << LeftState.E - RefState.E - (LeftState.base.Mdown - RefState.base.Mdown) * Chem_Pot << "\t"
 		    << iKout << "\t"
-	  //<< LeftState.conv << "\t"
 		    << LeftState.base_id << "\t" << LeftState.type_id << "\t" << LeftState.id;
       }
       else {
 	DAT_outfile << endl << LeftState.E - RefState.E - (LeftState.base.Mdown - RefState.base.Mdown) * Chem_Pot << "\t"
 		    << iKout << "\t"
 		    << ME << "\t"
-	  //<< LeftState.conv << "\t"
 		    << LeftState.base_id << "\t" << LeftState.type_id << "\t" << LeftState.id;
       }
     } // if iKmin <= iKout <= iKmax
 
     // Calculate and return the data_value:
     DP data_value = ME * ME;
-    //DP data_value = (iKout == 0 ? 1.0 : 2.0) * MEsq;
     if (whichDSF == 'Z') // use 1/(1 + omega)
       data_value = 1.0/(1.0 + LeftState.E - RefState.E - (LeftState.base.Mdown - RefState.base.Mdown) * Chem_Pot);
     else if (fixed_iK) // data value is MEsq * omega:
     return(data_value);
   }
 
-
 } // namespace ABACUS

src/ODSLF/ODSLF_Sumrules.cc

 
       E0_Delta_eps = gstate2.E;
     }
-    /*
-    else if (Delta == 1.0) {
-      // Define the ground state
-      XXX_Bethe_State gstate(chain, gbase);
-
-      // Compute everything about the ground state
-      gstate.Compute_All(true);
-
-      E0_Delta = gstate.E;
-
-      // Define the ground state
-      XXZ_gpd_Bethe_State gstate2(chain2, gbase2);  // need XXZ_gpd here
-
-      // Compute everything about the ground state
-      gstate2.Compute_All(true);
-
-      E0_Delta_eps = gstate2.E;
-    }
-
-    else if (Delta > 1.0) {
-      // Define the ground state
-      XXZ_gpd_Bethe_State gstate(chain, gbase);
 
-      // Compute everything about the ground state
-      gstate.Compute_All(true);
-
-      E0_Delta = gstate.E;
-
-      // Define the ground state
-      XXZ_gpd_Bethe_State gstate2(chain2, gbase2);
-
-      // Compute everything about the ground state
-      gstate2.Compute_All(true);
-
-      E0_Delta_eps = gstate2.E;
-    }
-    */
     else ABACUSerror("Wrong anisotropy in ODSLF_S1_sumrule_factor.");
 
     DP answer = 0.0;
 
     DP sumrule = 0.0;
 
-    if (mporz == 'm' || mporz == 'p') sumrule = - 2.0 * ((1.0 - Delta * cos((twoPI * iK)/N)) * X_x + (Delta - cos((twoPI * iK)/N)) * X_z)/N;
-    //if (mporz == 'm' || mporz == 'p') sumrule = - 1.0 * ((1.0 - Delta * cos((twoPI * iK)/N)) * 2.0 * X_x + (Delta - cos((twoPI * iK)/N)) * (X_x + X_z))/N;
+    if (mporz == 'm' || mporz == 'p')
+      sumrule = - 2.0 * ((1.0 - Delta * cos((twoPI * iK)/N)) * X_x + (Delta - cos((twoPI * iK)/N)) * X_z)/N;
 
     else if (mporz == 'z') sumrule = iK == 0 ? 1.0 : -2.0 * X_x * (1.0 - cos((twoPI * iK)/N))/N;
 
 
     else ABACUSerror("option not implemented in ODSLF_S1_sumrule_factor.");
 
-    //return(1.0/sumrule);
-    return(1.0/(sumrule + 1.0e-16)); // sumrule is 0 for iK == 0 or N
+    return(1.0/(sumrule + 1.0e-32)); // sumrule is 0 for iK == 0 or N
   }
 
   DP ODSLF_S1_sumrule_factor (char mporz, DP Delta, int N, DP X_x, DP X_z, int iK)
   {
-
-    //DP X_x = X_avg ('x', Delta, N, M);
-    //DP X_z = X_avg ('z', Delta, N, M);
-
     DP sumrule = 0.0;
 
-    if (mporz == 'm' || mporz == 'p') sumrule = - 2.0 * ((1.0 - Delta * cos((twoPI * iK)/N)) * X_x + (Delta - cos((twoPI * iK)/N)) * X_z)/N;
-    //if (mporz == 'm' || mporz == 'p') sumrule = - 1.0 * ((1.0 - Delta * cos((twoPI * iK)/N)) * 2.0 * X_x + (Delta - cos((twoPI * iK)/N)) * (X_x + X_z))/N;
+    if (mporz == 'm' || mporz == 'p')
+      sumrule = - 2.0 * ((1.0 - Delta * cos((twoPI * iK)/N)) * X_x + (Delta - cos((twoPI * iK)/N)) * X_z)/N;
 
     else if (mporz == 'z') sumrule = -2.0 * X_x * (1.0 - cos((twoPI * iK)/N))/N;
 
 
     else ABACUSerror("option not implemented in ODSLF_S1_sumrule_factor.");
 
-    //return(1.0/sumrule);
-    return(1.0/(sumrule + 1.0e-16)); // sumrule is 0 for iK == 0 or N
+    return(1.0/(sumrule + 1.0e-32)); // sumrule is 0 for iK == 0 or N
   }
 
-  //DP Sumrule_Factor (char whichDSF, Heis_Bethe_State& RefState, DP Chem_Pot, bool fixed_iK, int iKneeded)
   DP Sumrule_Factor (char whichDSF, ODSLF_Bethe_State& RefState, DP Chem_Pot, int iKmin, int iKmax)
   {
     DP sumrule_factor = 1.0;
-    //if (!fixed_iK) {
     if (iKmin != iKmax) {
       if (whichDSF == 'Z') sumrule_factor = 1.0;
       else if (whichDSF == 'm')
 
       else ABACUSerror("whichDSF option not consistent in Sumrule_Factor");
     }
-    //else if (fixed_iK) {
     else if (iKmin == iKmax) {
       if (whichDSF == 'Z') sumrule_factor = 1.0;
       else if (whichDSF == 'm' || whichDSF == 'z' || whichDSF == 'p')
-	//sumrule_factor = S1_sumrule_factor (whichDSF, RefState.chain.Delta, RefState.chain.Nsites, RefState.base.Mdown, iKneeded);
-	sumrule_factor = ODSLF_S1_sumrule_factor (whichDSF, RefState.chain.Delta, RefState.chain.Nsites, RefState.base.Mdown, iKmax);
+	sumrule_factor = ODSLF_S1_sumrule_factor (whichDSF, RefState.chain.Delta, RefState.chain.Nsites,
+						  RefState.base.Mdown, iKmax);
       else if (whichDSF == 'a') sumrule_factor = 1.0;
       else if (whichDSF == 'b') sumrule_factor = 1.0;
       else if (whichDSF == 'q') sumrule_factor = 1.0;
     return(sumrule_factor);
   }
 
-  //void Evaluate_F_Sumrule (char whichDSF, const ODSLF_Bethe_State& RefState, DP Chem_Pot, int iKmin, int iKmax, const char* FFsq_Cstr, const char* FSR_Cstr)
-  void Evaluate_F_Sumrule (string prefix, char whichDSF, const ODSLF_Bethe_State& RefState, DP Chem_Pot, int iKmin, int iKmax)
+  void Evaluate_F_Sumrule (string prefix, char whichDSF, const ODSLF_Bethe_State& RefState,
+			   DP Chem_Pot, int iKmin, int iKmax)
   {
 
     stringstream RAW_stringstream;    string RAW_string;
     if(infile.fail()) ABACUSerror("Could not open input file in Evaluate_F_Sumrule(ODSLF...).");
 
     // We run through the data file to chech the f sumrule at each positive momenta:
-    //Vect<DP> Sum_omega_FFsq(0.0, RefState.chain.Nsites/2 + 1);  //
     Vect<DP> Sum_omega_FFsq(0.0, iKmax - iKmin + 1);  //
 
     DP omega, FF;
 
     while (infile.peek() != EOF) {
       infile >> omega >> iK >> FF >> conv >> base_id >> type_id >> id;
-      //if (iK > 0 && iK <= RefState.chain.Nsites/2) Sum_omega_FFsq[iK] += omega * FFsq;
       if (iK >= iKmin && iK <= iKmax) Sum_omega_FFsq[iK - iKmin] += omega * FF * FF;
     }
 
     DP X_x = X_avg ('x', RefState.chain.Delta, RefState.chain.Nsites, RefState.base.Mdown);
     DP X_z = X_avg ('z', RefState.chain.Delta, RefState.chain.Nsites, RefState.base.Mdown);
 
-    /*
-    outfile << 0 << "\t" << Sum_omega_FFsq[0] * S1_sumrule_factor (whichDSF, RefState.chain.Delta, RefState.chain.Nsites, X_x, X_z, 0);
-    for (int i = 1; i <= RefState.chain.Nsites/2; ++i)
-      outfile << endl << i << "\t" << Sum_omega_FFsq[i] * S1_sumrule_factor (whichDSF, RefState.chain.Delta, RefState.chain.Nsites, X_x, X_z, i);
-    */
-
     for (int i = iKmin; i <= iKmax; ++i) {
       if (i > iKmin) outfile << endl;
-      outfile << i << "\t" << Sum_omega_FFsq[i] * ODSLF_S1_sumrule_factor (whichDSF, RefState.chain.Delta, RefState.chain.Nsites, X_x, X_z, i);
+      outfile << i << "\t" << Sum_omega_FFsq[i] * ODSLF_S1_sumrule_factor (whichDSF, RefState.chain.Delta,
+									   RefState.chain.Nsites, X_x, X_z, i);
     }
 
     outfile.close();

src/ODSLF/ODSLF_XXZ_Bethe_State.cc

   // Function definitions:  class ODSLF_XXZ_Bethe_State
 
   ODSLF_XXZ_Bethe_State::ODSLF_XXZ_Bethe_State ()
-    : ODSLF_Bethe_State(), sinhlambda(ODSLF_Lambda(chain, 1)), coshlambda(ODSLF_Lambda(chain, 1)), tanhlambda(ODSLF_Lambda(chain, 1))
+    : ODSLF_Bethe_State(), sinhlambda(ODSLF_Lambda(chain, 1)), coshlambda(ODSLF_Lambda(chain, 1)),
+      tanhlambda(ODSLF_Lambda(chain, 1))
   {};
 
   ODSLF_XXZ_Bethe_State::ODSLF_XXZ_Bethe_State (const ODSLF_XXZ_Bethe_State& RefState) // copy constructor
-    : ODSLF_Bethe_State(RefState), sinhlambda(ODSLF_Lambda(RefState.chain, RefState.base)), coshlambda(ODSLF_Lambda(RefState.chain, RefState.base)),
+    : ODSLF_Bethe_State(RefState), sinhlambda(ODSLF_Lambda(RefState.chain, RefState.base)),
+      coshlambda(ODSLF_Lambda(RefState.chain, RefState.base)),
       tanhlambda(ODSLF_Lambda(RefState.chain, RefState.base))
   {
     // copy arrays into new ones
     //cout << "Here in XXZ BS constructor." << endl;
     //cout << (*this).lambda[0][0] << endl;
     //cout << "OK" << endl;
-    if ((RefChain.Delta <= -1.0) || (RefChain.Delta >= 1.0)) ABACUSerror("Delta out of range in ODSLF_XXZ_Bethe_State constructor");
+    if ((RefChain.Delta <= -1.0) || (RefChain.Delta >= 1.0))
+      ABACUSerror("Delta out of range in ODSLF_XXZ_Bethe_State constructor");
   }
 
   ODSLF_XXZ_Bethe_State::ODSLF_XXZ_Bethe_State (const Heis_Chain& RefChain, const ODSLF_Base& RefBase)
     : ODSLF_Bethe_State(RefChain, RefBase),
-      sinhlambda(ODSLF_Lambda(RefChain, RefBase)), coshlambda(ODSLF_Lambda(RefChain, RefBase)), tanhlambda(ODSLF_Lambda(RefChain, RefBase))
+      sinhlambda(ODSLF_Lambda(RefChain, RefBase)), coshlambda(ODSLF_Lambda(RefChain, RefBase)),
+      tanhlambda(ODSLF_Lambda(RefChain, RefBase))
   {
-    if ((RefChain.Delta <= -1.0) || (RefChain.Delta >= 1.0)) ABACUSerror("Delta out of range in ODSLF_XXZ_Bethe_State constructor");
+    if ((RefChain.Delta <= -1.0) || (RefChain.Delta >= 1.0))
+      ABACUSerror("Delta out of range in ODSLF_XXZ_Bethe_State constructor");
   }
 
-  ODSLF_XXZ_Bethe_State::ODSLF_XXZ_Bethe_State (const Heis_Chain& RefChain, long long int base_id_ref, long long int type_id_ref)
+  ODSLF_XXZ_Bethe_State::ODSLF_XXZ_Bethe_State (const Heis_Chain& RefChain,
+						long long int base_id_ref, long long int type_id_ref)
     : ODSLF_Bethe_State(RefChain, base_id_ref, type_id_ref),
       sinhlambda(ODSLF_Lambda(chain, base)), coshlambda(ODSLF_Lambda(chain, base)), tanhlambda(ODSLF_Lambda(chain, base))
   {
-    if ((RefChain.Delta <= -1.0) || (RefChain.Delta >= 1.0)) ABACUSerror("Delta out of range in ODSLF_XXZ_Bethe_State constructor");
+    if ((RefChain.Delta <= -1.0) || (RefChain.Delta >= 1.0))
+      ABACUSerror("Delta out of range in ODSLF_XXZ_Bethe_State constructor");
   }
 
 
 
       for (int alpha = 0; alpha < base[i]; ++alpha) {
 
-	if(chain.par[i] == 1) lambda[i][alpha] = (tan(chain.Str_L[i] * 0.5 * chain.anis) * tan(PI * 0.5 * Ix2[i][alpha]/chain.Nsites));
-	else if (chain.par[i] == -1) lambda[i][alpha] = (-tan((PI * 0.5 * Ix2[i][alpha])/chain.Nsites)/tan(chain.Str_L[i] * 0.5 * chain.anis));
+	if(chain.par[i] == 1)
+	  lambda[i][alpha] = (tan(chain.Str_L[i] * 0.5 * chain.anis) * tan(PI * 0.5 * Ix2[i][alpha]/chain.Nsites));
+	else if (chain.par[i] == -1)
+	  lambda[i][alpha] = (-tan((PI * 0.5 * Ix2[i][alpha])/chain.Nsites)/tan(chain.Str_L[i] * 0.5 * chain.anis));
 
 	else ABACUSerror("Invalid parities in Set_Free_lambdas.");
 
-	//	if (lambda[i][alpha] == 0.0) lambda[i][alpha] = 0.001 * (1.0 + i) * (1.0 + alpha) / chain.Nsites;  // some arbitrary starting point here...
-
       }
     }
 
     bool higher_string_on_zero = false;
     for (int j = 0; j < chain.Nstrings; ++j) {
       // The following line puts answer to true if there is at least one higher string with zero Ix2
-      for (int alpha = 0; alpha < base[j]; ++alpha) if ((Ix2[j][alpha] == 0) && (chain.Str_L[j] >= 2) /*&& !(chain.Str_L[j] % 2)*/)
-	higher_string_on_zero = true;
+      for (int alpha = 0; alpha < base[j]; ++alpha) if ((Ix2[j][alpha] == 0) && (chain.Str_L[j] >= 2))
+						      higher_string_on_zero = true;
       for (int alpha = 0; alpha < base[j]; ++alpha) if (Ix2[j][alpha] == 0) Zero_at_level[j] = true;
       // NOTE:  if base[j] == 0, Zero_at_level[j] remains false.
     }
     bool string_coincidence = false;
     for (int j1 = 0; j1 < chain.Nstrings; ++j1) {
       for (int j2 = j1 + 1; j2 < chain.Nstrings; ++j2)
-	if (Zero_at_level[j1] && Zero_at_level[j2] && (chain.par[j1] == chain.par[j2]) && (!((chain.Str_L[j1] + chain.Str_L[j2])%2)))
+	if (Zero_at_level[j1] && Zero_at_level[j2] && (chain.par[j1] == chain.par[j2])
+	    && (!((chain.Str_L[j1] + chain.Str_L[j2])%2)))
 	  string_coincidence = true;
     }
 
     bool M_odd_and_onep_on_zero = false;
     if (option == 'z') { // for Sz, if M is odd, exclude symmetric states with a 1+ on zero
                          // (zero rapidities in left and right states, so FF det not defined).
-      bool is_ground_state = base.Nrap[0] == base.Mdown && Ix2[0][0] == -(base.Mdown - 1) && Ix2[0][base.Mdown-1] == base.Mdown - 1;
+      bool is_ground_state = base.Nrap[0] == base.Mdown && Ix2[0][0] == -(base.Mdown - 1)
+	&& Ix2[0][base.Mdown-1] == base.Mdown - 1;
       if (Zero_at_level[0] && (base.Mdown % 2) && !is_ground_state) M_odd_and_onep_on_zero = true;
     }
 
       if (Zero_at_level[0] && Zero_at_level[1]) onep_onem_on_zero = true;
     }
 
-    answer = !(symmetric_state && (higher_string_on_zero || string_coincidence || onep_onem_on_zero || M_odd_and_onep_on_zero));
+    answer = !(symmetric_state && (higher_string_on_zero || string_coincidence
+				   || onep_onem_on_zero || M_odd_and_onep_on_zero));
 
     // Now check that no Ix2 is equal to +N (since we take -N into account, and I + N == I by periodicity of exp)
 
     for (int j = 0; j < chain.Nstrings; ++j)
-      for (int alpha = 0; alpha < base[j]; ++alpha) if ((Ix2[j][alpha] < -chain.Nsites) || (Ix2[j][alpha] >= chain.Nsites)) answer = false;
+      for (int alpha = 0; alpha < base[j]; ++alpha)
+	if ((Ix2[j][alpha] < -chain.Nsites) || (Ix2[j][alpha] >= chain.Nsites)) answer = false;
 
     if (!answer) {
       E = 0.0;
       for (int beta = 0; beta < base[k]; ++beta) {
 	if ((chain.Str_L[j] == 1) && (chain.Str_L[k] == 1))
 	  sumtheta += (chain.par[j] == chain.par[k])
-	    ? atan((tanhlambda[j][alpha] - tanhlambda[k][beta])/((1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta]) * chain.ta_n_anis_over_2[2]))
-	    : - atan(((tanhlambda[j][alpha] - tanhlambda[k][beta])/(1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta])) * chain.ta_n_anis_over_2[2]) ;
-	else sumtheta += 0.5 * ODSLF_Theta_XXZ((tanhlambda[j][alpha] - tanhlambda[k][beta])/(1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta]),
-					 chain.Str_L[j], chain.Str_L[k], chain.par[j], chain.par[k], chain.ta_n_anis_over_2);
+	    ? atan((tanhlambda[j][alpha] - tanhlambda[k][beta])
+		   /((1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta]) * chain.ta_n_anis_over_2[2]))
+	    : - atan(((tanhlambda[j][alpha] - tanhlambda[k][beta])
+		      /(1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta])) * chain.ta_n_anis_over_2[2]) ;
+	else sumtheta += 0.5 * ODSLF_Theta_XXZ((tanhlambda[j][alpha] - tanhlambda[k][beta])
+					       /(1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta]),
+					       chain.Str_L[j], chain.Str_L[k], chain.par[j], chain.par[k],
+					       chain.ta_n_anis_over_2);
       }
     sumtheta *= 2.0;
 
-    BE[j][alpha] = ((chain.par[j] == 1) ? 2.0 * atan(tanhlambda[j][alpha]/chain.ta_n_anis_over_2[chain.Str_L[j]])
-		    : -2.0 * atan(tanhlambda[j][alpha] * chain.ta_n_anis_over_2[chain.Str_L[j]])) - (sumtheta + PI*Ix2[j][alpha])/chain.Nsites;
+    BE[j][alpha] =
+      ((chain.par[j] == 1) ? 2.0 * atan(tanhlambda[j][alpha]/chain.ta_n_anis_over_2[chain.Str_L[j]])
+       : -2.0 * atan(tanhlambda[j][alpha] * chain.ta_n_anis_over_2[chain.Str_L[j]]))
+      - (sumtheta + PI*Ix2[j][alpha])/chain.Nsites;
 
-   }
+  }
 
   void ODSLF_XXZ_Bethe_State::Compute_BE ()
   {
 	  for (int beta = 0; beta < base[k]; ++beta) {
 	    if ((chain.Str_L[j] == 1) && (chain.Str_L[k] == 1))
 	      sumtheta += (chain.par[j] == chain.par[k])
-		? atan((tanhlambda[j][alpha] - tanhlambda[k][beta])/((1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta]) * chain.ta_n_anis_over_2[2]))
-		: - atan(((tanhlambda[j][alpha] - tanhlambda[k][beta])/(1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta])) * chain.ta_n_anis_over_2[2]) ;
-	    else sumtheta += 0.5 * ODSLF_Theta_XXZ((tanhlambda[j][alpha] - tanhlambda[k][beta])/(1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta]),
-					     chain.Str_L[j], chain.Str_L[k], chain.par[j], chain.par[k], chain.ta_n_anis_over_2);
+		? atan((tanhlambda[j][alpha] - tanhlambda[k][beta])
+		       /((1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta]) * chain.ta_n_anis_over_2[2]))
+		: - atan(((tanhlambda[j][alpha] - tanhlambda[k][beta])
+			  /(1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta])) * chain.ta_n_anis_over_2[2]) ;
+	    else sumtheta += 0.5 * ODSLF_Theta_XXZ((tanhlambda[j][alpha] - tanhlambda[k][beta])
+						   /(1.0 - tanhlambda[j][alpha] * tanhlambda[k][beta]),
+						   chain.Str_L[j], chain.Str_L[k], chain.par[j], chain.par[k],
+						   chain.ta_n_anis_over_2);
 	  }
 	sumtheta *= 2.0;
 
-	BE[j][alpha] = ((chain.par[j] == 1) ? 2.0 * atan(tanhlambda[j][alpha]/chain.ta_n_anis_over_2[chain.Str_L[j]])
-			: -2.0 * atan(tanhlambda[j][alpha] * chain.ta_n_anis_over_2[chain.Str_L[j]])) - (sumtheta + PI*Ix2[j][alpha])/chain.Nsites;
+	BE[j][alpha] =
+	  ((chain.par[j] == 1) ? 2.0 * atan(tanhlambda[j][alpha]/chain.ta_n_anis_over_2[chain.Str_L[j]])
+	   : -2.0 * atan(tanhlambda[j][alpha] * chain.ta_n_anis_over_2[chain.Str_L[j]]))
+	  - (sumtheta + PI*Ix2[j][alpha])/chain.Nsites;
 
-	//if (is_nan(BE[j][alpha])) cout << "BE nan: " << j << "\t" << alpha << "\t" << lambda[j][alpha] << "\t" << tanhlambda[j][alpha] << endl;
       }
   }
 
     DP arg = 0.0;
 
     if (chain.par[j] == 1) arg = chain.ta_n_anis_over_2[chain.Str_L[j]]
-      * tan(0.5 *
-	    //(PI * Ix2[j][alpha] + sumtheta)/chain.Nsites
-	    (2.0 * atan(tanhlambda[j][alpha]/chain.ta_n_anis_over_2[chain.Str_L[j]]) - BE[j][alpha])
-	    );
+			     * tan(0.5 *
+				   //(PI * Ix2[j][alpha] + sumtheta)/chain.Nsites
+				   (2.0 * atan(tanhlambda[j][alpha]/chain.ta_n_anis_over_2[chain.Str_L[j]]) - BE[j][alpha])
+				   );
 
-    else if (chain.par[j] == -1) arg = -tan(0.5 *
-					    //(PI * Ix2[j][alpha] + sumtheta)/chain.Nsites)
-					    (-2.0 * atan(tanhlambda[j][alpha] * chain.ta_n_anis_over_2[chain.Str_L[j]]) - BE[j][alpha]))
-      /chain.ta_n_anis_over_2[chain.Str_L[j]];
+    else if (chain.par[j] == -1)
+      arg = -tan(0.5 *
+		 (-2.0 * atan(tanhlambda[j][alpha] * chain.ta_n_anis_over_2[chain.Str_L[j]]) - BE[j][alpha]))
+	/chain.ta_n_anis_over_2[chain.Str_L[j]];
 
     if (fabs(arg) < 1.0) {
       new_lambda = atanh(arg);
 	  for (int beta = 0; beta < base[k]; ++beta)
 	    if ((chain.Str_L[j] == 1) && (chain.Str_L[k] == 1))
 	      sumtheta += (chain.par[j] == chain.par[k])
-		? atan((new_tanhlambda - tanhlambda[k][beta])/((1.0 - new_tanhlambda * tanhlambda[k][beta]) * chain.ta_n_anis_over_2[2]))
-		: - atan(((new_tanhlambda - tanhlambda[k][beta])/(1.0 - new_tanhlambda * tanhlambda[k][beta])) * chain.ta_n_anis_over_2[2]) ;
-	    else sumtheta += 0.5 * ODSLF_Theta_XXZ((new_tanhlambda - tanhlambda[k][beta])/(1.0 - new_tanhlambda * tanhlambda[k][beta]),
-					     chain.Str_L[j], chain.Str_L[k], chain.par[j], chain.par[k], chain.ta_n_anis_over_2);
+		? atan((new_tanhlambda - tanhlambda[k][beta])
+		       /((1.0 - new_tanhlambda * tanhlambda[k][beta]) * chain.ta_n_anis_over_2[2]))
+		: - atan(((new_tanhlambda - tanhlambda[k][beta])
+			  /(1.0 - new_tanhlambda * tanhlambda[k][beta])) * chain.ta_n_anis_over_2[2]) ;
+	    else sumtheta += 0.5 * ODSLF_Theta_XXZ((new_tanhlambda - tanhlambda[k][beta])
+						   /(1.0 - new_tanhlambda * tanhlambda[k][beta]),
+						   chain.Str_L[j], chain.Str_L[k], chain.par[j], chain.par[k],
+						   chain.ta_n_anis_over_2);
 	}
 	sumtheta *= 2.0;
-	if (chain.par[j] == 1) arg = chain.ta_n_anis_over_2[chain.Str_L[j]] * tan(0.5 * (PI * Ix2[j][alpha] + sumtheta)/chain.Nsites);
+	if (chain.par[j] == 1)
+	  arg = chain.ta_n_anis_over_2[chain.Str_L[j]] * tan(0.5 * (PI * Ix2[j][alpha] + sumtheta)/chain.Nsites);
 
-	else if (chain.par[j] == -1) arg = -tan(0.5 * (PI * Ix2[j][alpha] + sumtheta)/chain.Nsites)/chain.ta_n_anis_over_2[chain.Str_L[j]];
+	else if (chain.par[j] == -1)
+	  arg = -tan(0.5 * (PI * Ix2[j][alpha] + sumtheta)/chain.Nsites)/chain.ta_n_anis_over_2[chain.Str_L[j]];
 
 	else ABACUSerror("Invalid parities in Iterate_BAE.");
 
       }
 
-      //cout << "Rapidity blows up !\t" << lambda[j][alpha] << "\t" << new_lambda << endl;
     }
 
     return(new_lambda);
 
     for (int j = 0; j < chain.Nstrings; ++j) {
       for (int alpha = 0; alpha < base[j]; ++alpha) {
-	sum += sin(chain.Str_L[j] * chain.anis) / (chain.par[j] * cosh(2.0 * lambda[j][alpha]) - cos(chain.Str_L[j] * chain.anis));
+	sum += sin(chain.Str_L[j] * chain.anis)
+	  / (chain.par[j] * cosh(2.0 * lambda[j][alpha]) - cos(chain.Str_L[j] * chain.anis));
       }
     }
 
     return;
   }
 
-  /*
-  void XXZ_Bethe_State::Compute_Momentum ()
-  {
-    int sum_Ix2 = 0;
-    DP sum_M = 0.0;
-
-    for (int j = 0; j < chain.Nstrings; ++j) {
-      sum_M += 0.5 * (1.0 + chain.par[j]) * base[j];
-      for (int alpha = 0; alpha < base[j]; ++alpha) {
-	sum_Ix2 += Ix2[j][alpha];
-      }
-    }
-
-    iK = (chain.Nsites/2) * int(sum_M + 0.1) - (sum_Ix2/2);  // + 0.1:  for safety...
-
-    while (iK >= chain.Nsites) iK -= chain.Nsites;
-    while (iK < 0) iK += chain.Nsites;
-
-    K = PI * sum_M - PI * sum_Ix2/chain.Nsites;
-
-    while (K >= 2.0*PI) K -= 2.0*PI;
-    while (K < 0.0) K += 2.0*PI;
-
-    return;
-  }
-  */
   void ODSLF_XXZ_Bethe_State::Build_Reduced_Gaudin_Matrix (SQMat<complex<DP> >& Gaudin_Red)
   {
 
 		for (int betap = 0; betap < base[kp]; ++betap) {
 		  if (!((j == kp) && (alpha == betap)))
 		    sum_hbar_XXZ
-		      += ODSLF_ddlambda_Theta_XXZ (lambda[j][alpha] - lambda[kp][betap], chain.Str_L[j], chain.Str_L[kp], chain.par[j], chain.par[kp],
-					     chain.si_n_anis_over_2);
+		      += ODSLF_ddlambda_Theta_XXZ (lambda[j][alpha] - lambda[kp][betap], chain.Str_L[j], chain.Str_L[kp],
+						   chain.par[j], chain.par[kp], chain.si_n_anis_over_2);
 		}
 	      }
 
 	      Gaudin_Red[index_jalpha][index_kbeta]
-		= complex<DP> ( chain.Nsites * ODSLF_hbar_XXZ (lambda[j][alpha], chain.Str_L[j], chain.par[j], chain.si_n_anis_over_2) - sum_hbar_XXZ);
+		= complex<DP> ( chain.Nsites * ODSLF_hbar_XXZ (lambda[j][alpha], chain.Str_L[j], chain.par[j],
+							       chain.si_n_anis_over_2) - sum_hbar_XXZ);
 	    }
 
 	    else {
 	      if ((chain.Str_L[j] == 1) && (chain.Str_L[k] == 1))
 		Gaudin_Red[index_jalpha][index_kbeta] =
 		  complex<DP> ((chain.par[j] * chain.par[k] == 1)
-			       ? chain.si_n_anis_over_2[4]/(pow(sinhlambda[j][alpha] * coshlambda[k][beta]
-								 - coshlambda[j][alpha] * sinhlambda[k][beta], 2.0) + sinzetasq)
-			       : chain.si_n_anis_over_2[4]/(-pow(coshlambda[j][alpha] * coshlambda[k][beta]
-								  - sinhlambda[j][alpha] * sinhlambda[k][beta], 2.0) + sinzetasq) );
+			       ? chain.si_n_anis_over_2[4]
+			       /(pow(sinhlambda[j][alpha] * coshlambda[k][beta]
+				     - coshlambda[j][alpha] * sinhlambda[k][beta], 2.0) + sinzetasq)
+			       : chain.si_n_anis_over_2[4]
+			       /(-pow(coshlambda[j][alpha] * coshlambda[k][beta]
+				      - sinhlambda[j][alpha] * sinhlambda[k][beta], 2.0) + sinzetasq) );
 	      else
-		Gaudin_Red[index_jalpha][index_kbeta] = complex<DP> (ODSLF_ddlambda_Theta_XXZ (lambda[j][alpha] - lambda[k][beta], chain.Str_L[j], chain.Str_L[k],
-											  chain.par[j], chain.par[k], chain.si_n_anis_over_2));
+		Gaudin_Red[index_jalpha][index_kbeta] =
+		  complex<DP> (ODSLF_ddlambda_Theta_XXZ (lambda[j][alpha] - lambda[k][beta], chain.Str_L[j], chain.Str_L[k],
+							 chain.par[j], chain.par[k], chain.si_n_anis_over_2));
 	    }
 	    index_kbeta++;
 	  }
 
       result = (nj == nk) ? 0.0 : ODSLF_fbar_XXZ(tanhlambda, parj*park, tannzetaover2[fabs(nj - nk)]);
 
-      for (int a = 1; a < ABACUS::min(nj, nk); ++a) result += 2.0 * ODSLF_fbar_XXZ(tanhlambda, parj*park, tannzetaover2[fabs(nj - nk) + 2*a]);
+      for (int a = 1; a < ABACUS::min(nj, nk); ++a)
+	result += 2.0 * ODSLF_fbar_XXZ(tanhlambda, parj*park, tannzetaover2[fabs(nj - nk) + 2*a]);
 
       result += ODSLF_fbar_XXZ(tanhlambda, parj*park, tannzetaover2[nj + nk]);
     }
   {
     DP result = (nj == nk) ? 0.0 : ODSLF_hbar_XXZ(lambda, fabs(nj - nk), parj*park, si_n_anis_over_2);
 
-    for (int a = 1; a < ABACUS::min(nj, nk); ++a) result += 2.0 * ODSLF_hbar_XXZ(lambda, fabs(nj - nk) + 2*a, parj*park, si_n_anis_over_2);
+    for (int a = 1; a < ABACUS::min(nj, nk); ++a)
+      result += 2.0 * ODSLF_hbar_XXZ(lambda, fabs(nj - nk) + 2*a, parj*park, si_n_anis_over_2);
 
     result += ODSLF_hbar_XXZ(lambda, nj + nk, parj*park, si_n_anis_over_2);
 

src/ODSLF/ln_Smin_ME_ODSLF_XXZ.cc

 
 namespace ABACUS {
 
-inline complex<DP> ln_Fn_F (ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
-{
-  complex<DP> ans = 0.0;
-  complex<DP> prod_temp = 1.0;
-  int counter = 0;
-  int arg = 0;
-  int absarg = 0;
-  int par_comb_1, par_comb_2;
+  inline complex<DP> ln_Fn_F (ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
+  {
+    complex<DP> ans = 0.0;
+    complex<DP> prod_temp = 1.0;
+    int counter = 0;
+    int arg = 0;
+    int absarg = 0;
+    int par_comb_1, par_comb_2;
+
+    for (int j = 0; j < B.chain.Nstrings; ++j) {
+
+      par_comb_1 = B.chain.par[j] == B.chain.par[k] ? 1 : 0;
+      par_comb_2 = B.chain.par[k] == B.chain.par[j] ? 0 : B.chain.par[k];
+
+      for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
+	for (int a = 1; a <= B.chain.Str_L[j]; ++a) {
+
+	  if (!((j == k) && (alpha == beta) && (a == b))) {
+
+	    arg = B.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
+	    absarg = abs(arg);
+
+	    prod_temp *= ((B.sinhlambda[j][alpha] * B.coshlambda[k][beta]
+			   - B.coshlambda[j][alpha] * B.sinhlambda[k][beta])
+			  * (B.chain.co_n_anis_over_2[absarg] * par_comb_1
+			     - sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * par_comb_2)
+			  + II * (B.coshlambda[j][alpha] * B.coshlambda[k][beta]
+				  - B.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
+			  * (sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * par_comb_1
+			     + B.chain.co_n_anis_over_2[absarg] * par_comb_2));
+	  }
+
+	  if (counter++ > 100) {  // we do at most 100 products before taking a log
+	    ans += log(prod_temp);
+	    prod_temp = 1.0;
+	    counter = 0;
+	  }
+
+	}}}
+
+    return(ans + log(prod_temp));
+  }
 
-  for (int j = 0; j < B.chain.Nstrings; ++j) {
+  inline complex<DP> ln_Fn_G (ODSLF_XXZ_Bethe_State& A, ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
+  {
+    complex<DP> ans = 0.0;
+    complex<DP> prod_temp = 1.0;
+    int counter = 0;
+    int arg = 0;
+    int absarg = 0;
+    int par_comb_1, par_comb_2;
 
-    par_comb_1 = B.chain.par[j] == B.chain.par[k] ? 1 : 0;
-    par_comb_2 = B.chain.par[k] == B.chain.par[j] ? 0 : B.chain.par[k];
+    for (int j = 0; j < A.chain.Nstrings; ++j) {
 
-    for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
-      for (int a = 1; a <= B.chain.Str_L[j]; ++a) {
+      par_comb_1 = A.chain.par[j] == B.chain.par[k] ? 1 : 0;
+      par_comb_2 = B.chain.par[k] == A.chain.par[j] ? 0 : B.chain.par[k];
 
-	if (!((j == k) && (alpha == beta) && (a == b))) {
+      for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
+	for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
 
-	  arg = B.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
+	  arg = A.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
 	  absarg = abs(arg);
-	  /*
-	  prod_temp *= 0.5 * //done later...
-	    ((B.sinhlambda[j][alpha] * B.coshlambda[k][beta] - B.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-	     * (B.chain.co_n_anis_over_2[absarg] * (1.0 + B.chain.par[j] * B.chain.par[k])
-		- sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * (B.chain.par[k] - B.chain.par[j]))
-			+ II * (B.coshlambda[j][alpha] * B.coshlambda[k][beta] - B.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-			* (sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * (1.0 + B.chain.par[j] * B.chain.par[k])
-			   + B.chain.co_n_anis_over_2[absarg] * (B.chain.par[k] - B.chain.par[j])) );
-	  */
-
-	  prod_temp *= ((B.sinhlambda[j][alpha] * B.coshlambda[k][beta] - B.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-			* (B.chain.co_n_anis_over_2[absarg] * par_comb_1 - sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * par_comb_2)
-			+ II * (B.coshlambda[j][alpha] * B.coshlambda[k][beta] - B.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-			* (sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * par_comb_1 + B.chain.co_n_anis_over_2[absarg] * par_comb_2));
-	}
+	  prod_temp *= ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta]
+			 - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
+			* (A.chain.co_n_anis_over_2[absarg] * par_comb_1
+			   - sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * par_comb_2)
+			+ II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta]
+				- A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
+			* (sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * par_comb_1
+			   + A.chain.co_n_anis_over_2[absarg] * par_comb_2));
+
+	  if (counter++ > 100) {  // we do at most 100 products before taking a log
+	    ans += log(prod_temp);
+	    prod_temp = 1.0;
+	    counter = 0;
+	  }
+	}}}
+
+    return(ans + log(prod_temp));
+  }
 
-	if (counter++ > 100) {  // we do at most 100 products before taking a log
-	  ans += log(prod_temp);
-	  prod_temp = 1.0;
-	  counter = 0;
-	}
+  inline complex<DP> Fn_K (ODSLF_XXZ_Bethe_State& A, int j, int alpha, int a,
+			   ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
+  {
+    int arg1 = A.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
+    int absarg1 = abs(arg1);
+    int arg2 = arg1 + 2;
+    int absarg2 = abs(arg2);
+
+    return(4.0/(
+		((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
+		 * (A.chain.co_n_anis_over_2[absarg1] * (1.0 + A.chain.par[j] * B.chain.par[k])
+		    - sgn_int(arg1) * A.chain.si_n_anis_over_2[absarg1] * (B.chain.par[k] - A.chain.par[j]))
+		 + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
+		 * (sgn_int(arg1) * A.chain.si_n_anis_over_2[absarg1] * (1.0 + A.chain.par[j] * B.chain.par[k])
+		    + A.chain.co_n_anis_over_2[absarg1] * (B.chain.par[k] - A.chain.par[j])) )
+		*
+		((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
+		 * (A.chain.co_n_anis_over_2[absarg2] * (1.0 + A.chain.par[j] * B.chain.par[k])
+		    - sgn_int(arg2) * A.chain.si_n_anis_over_2[absarg2] * (B.chain.par[k] - A.chain.par[j]))
+		 + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
+		 * (sgn_int(arg2) * A.chain.si_n_anis_over_2[absarg2] * (1.0 + A.chain.par[j] * B.chain.par[k])
+		    + A.chain.co_n_anis_over_2[absarg2] * (B.chain.par[k] - A.chain.par[j])) )
+		));
 
-      }}}
-
-  return(ans + log(prod_temp));
-}
-
-inline complex<DP> ln_Fn_G (ODSLF_XXZ_Bethe_State& A, ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
-{
-  complex<DP> ans = 0.0;
-  complex<DP> prod_temp = 1.0;
-  int counter = 0;
-  int arg = 0;
-  int absarg = 0;
-  int par_comb_1, par_comb_2;
-
-  for (int j = 0; j < A.chain.Nstrings; ++j) {
-
-    par_comb_1 = A.chain.par[j] == B.chain.par[k] ? 1 : 0;
-    par_comb_2 = B.chain.par[k] == A.chain.par[j] ? 0 : B.chain.par[k];
-
-    for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
-      for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
-
-	arg = A.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
-	absarg = abs(arg);
-	/*
-	prod_temp *= 0.5 * //done later...
-	  ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (A.chain.co_n_anis_over_2[absarg] * (1.0 + A.chain.par[j] * B.chain.par[k])
-			 - sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * (B.chain.par[k] - A.chain.par[j]))
-		      + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * (1.0 + A.chain.par[j] * B.chain.par[k])
-			 + A.chain.co_n_anis_over_2[absarg] * (B.chain.par[k] - A.chain.par[j])) );
-	*/
-	prod_temp *= ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (A.chain.co_n_anis_over_2[absarg] * par_comb_1 - sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * par_comb_2)
-		      + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * par_comb_1 + A.chain.co_n_anis_over_2[absarg] * par_comb_2));
-
-	if (counter++ > 100) {  // we do at most 100 products before taking a log
-	  ans += log(prod_temp);
-	  prod_temp = 1.0;
-	  counter = 0;
-	}
-      }}}
-
-  return(ans + log(prod_temp));
-}
-
-inline complex<DP> Fn_K (ODSLF_XXZ_Bethe_State& A, int j, int alpha, int a, ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
-{
-  int arg1 = A.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
-  int absarg1 = abs(arg1);
-  int arg2 = arg1 + 2;
-  int absarg2 = abs(arg2);
-
-  return(4.0/(
-	      ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (A.chain.co_n_anis_over_2[absarg1] * (1.0 + A.chain.par[j] * B.chain.par[k])
-			 - sgn_int(arg1) * A.chain.si_n_anis_over_2[absarg1] * (B.chain.par[k] - A.chain.par[j]))
-		      + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (sgn_int(arg1) * A.chain.si_n_anis_over_2[absarg1] * (1.0 + A.chain.par[j] * B.chain.par[k])
-			 + A.chain.co_n_anis_over_2[absarg1] * (B.chain.par[k] - A.chain.par[j])) )
-	 *
-	 ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (A.chain.co_n_anis_over_2[absarg2] * (1.0 + A.chain.par[j] * B.chain.par[k])
-			 - sgn_int(arg2) * A.chain.si_n_anis_over_2[absarg2] * (B.chain.par[k] - A.chain.par[j]))
-		      + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (sgn_int(arg2) * A.chain.si_n_anis_over_2[absarg2] * (1.0 + A.chain.par[j] * B.chain.par[k])
-			 + A.chain.co_n_anis_over_2[absarg2] * (B.chain.par[k] - A.chain.par[j])) )
-	      ));
-
-}
-
-inline complex<DP> Fn_L (ODSLF_XXZ_Bethe_State& A, int j, int alpha, int a, ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
-{
-  return (sinh(2.0 * (A.lambda[j][alpha] - B.lambda[k][beta]
-		      + 0.5 * II * B.chain.anis * (A.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b - 0.5))
-		      + 0.25 * II * PI * complex<DP>(-A.chain.par[j] + B.chain.par[k])))
-	  * pow(Fn_K (A, j, alpha, a, B, k, beta, b), 2.0));
-}
-
-complex<DP> ln_Smin_ME (ODSLF_XXZ_Bethe_State& A, ODSLF_XXZ_Bethe_State& B)
-{
-  // This function returns the natural log of the S^- operator matrix element.
-  // The A and B states can contain strings.
-
-  // Check that the two states are compatible
-
-  if (A.chain != B.chain) ABACUSerror("Incompatible ODSLF_XXZ_Chains in Smin matrix element.");
-
-  // Check that A and B are Mdown-compatible:
-
-  if (A.base.Mdown != B.base.Mdown + 1) ABACUSerror("Incompatible Mdown between the two states in Smin matrix element!");
-
-  // Compute the sinh and cosh of rapidities
-
-  A.Compute_sinhlambda();
-  A.Compute_coshlambda();
-  B.Compute_sinhlambda();
-  B.Compute_coshlambda();
-
-  // Some convenient arrays
-
-  ODSLF_Lambda re_ln_Fn_F_B_0(B.chain, B.base);
-  ODSLF_Lambda im_ln_Fn_F_B_0(B.chain, B.base);
-  ODSLF_Lambda re_ln_Fn_G_0(B.chain, B.base);
-  ODSLF_Lambda im_ln_Fn_G_0(B.chain, B.base);
-  ODSLF_Lambda re_ln_Fn_G_2(B.chain, B.base);
-  ODSLF_Lambda im_ln_Fn_G_2(B.chain, B.base);
-
-  complex<DP> ln_prod1 = 0.0;
-  complex<DP> ln_prod2 = 0.0;
-  complex<DP> ln_prod3 = 0.0;
-  complex<DP> ln_prod4 = 0.0;
-
-  for (int i = 0; i < A.chain.Nstrings; ++i)
-    for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
-      for (int a = 1; a <= A.chain.Str_L[i]; ++a)
-	ln_prod1 += log(norm(sinh(A.lambda[i][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
-				  + 0.25 * II * PI * (1.0 - A.chain.par[i]))));
-
-  for (int i = 0; i < B.chain.Nstrings; ++i)
-    for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
-      for (int a = 1; a <= B.chain.Str_L[i]; ++a)
-	if (norm(sinh(B.lambda[i][alpha] + 0.5 * II * B.chain.anis * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
-		      + 0.25 * II * PI * (1.0 - B.chain.par[i]))) > 100.0 * MACHINE_EPS_SQ)
-	  ln_prod2 += log(norm(sinh(B.lambda[i][alpha] + 0.5 * II * B.chain.anis * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
-				    + 0.25 * II * PI * (1.0 - B.chain.par[i]))));
-
-  // Define the F ones earlier...
-
-  for (int j = 0; j < B.chain.Nstrings; ++j) {
-    for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
-      re_ln_Fn_F_B_0[j][alpha] = real(ln_Fn_F(B, j, alpha, 0));
-      im_ln_Fn_F_B_0[j][alpha] = imag(ln_Fn_F(B, j, alpha, 0));
-      re_ln_Fn_G_0[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 0));
-      im_ln_Fn_G_0[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 0));
-      re_ln_Fn_G_2[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 2));
-      im_ln_Fn_G_2[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 2));
-    }
   }
 
-  DP logabssinzeta = log(abs(sin(A.chain.anis)));
+  inline complex<DP> Fn_L (ODSLF_XXZ_Bethe_State& A, int j, int alpha, int a,
+			   ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
+  {
+    return (sinh(2.0 * (A.lambda[j][alpha] - B.lambda[k][beta]
+			+ 0.5 * II * B.chain.anis * (A.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b - 0.5))
+			+ 0.25 * II * PI * complex<DP>(-A.chain.par[j] + B.chain.par[k])))
+	    * pow(Fn_K (A, j, alpha, a, B, k, beta, b), 2.0));
+  }
 
-  // Define regularized products in prefactors
+  complex<DP> ln_Smin_ME (ODSLF_XXZ_Bethe_State& A, ODSLF_XXZ_Bethe_State& B)
+  {
+    // This function returns the natural log of the S^- operator matrix element.
+    // The A and B states can contain strings.
+
+    // Check that the two states are compatible
+
+    if (A.chain != B.chain)
+      ABACUSerror("Incompatible ODSLF_XXZ_Chains in Smin matrix element.");
+
+    // Check that A and B are Mdown-compatible:
+
+    if (A.base.Mdown != B.base.Mdown + 1)
+      ABACUSerror("Incompatible Mdown between the two states in Smin matrix element!");
+
+    // Compute the sinh and cosh of rapidities
+
+    A.Compute_sinhlambda();
+    A.Compute_coshlambda();
+    B.Compute_sinhlambda();
+    B.Compute_coshlambda();
+
+    // Some convenient arrays
+
+    ODSLF_Lambda re_ln_Fn_F_B_0(B.chain, B.base);
+    ODSLF_Lambda im_ln_Fn_F_B_0(B.chain, B.base);
+    ODSLF_Lambda re_ln_Fn_G_0(B.chain, B.base);
+    ODSLF_Lambda im_ln_Fn_G_0(B.chain, B.base);
+    ODSLF_Lambda re_ln_Fn_G_2(B.chain, B.base);
+    ODSLF_Lambda im_ln_Fn_G_2(B.chain, B.base);
+
+    complex<DP> ln_prod1 = 0.0;
+    complex<DP> ln_prod2 = 0.0;
+    complex<DP> ln_prod3 = 0.0;
+    complex<DP> ln_prod4 = 0.0;
+
+    for (int i = 0; i < A.chain.Nstrings; ++i)
+      for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
+	for (int a = 1; a <= A.chain.Str_L[i]; ++a)
+	  ln_prod1 += log(norm(sinh(A.lambda[i][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
+				    + 0.25 * II * PI * (1.0 - A.chain.par[i]))));
+
+    for (int i = 0; i < B.chain.Nstrings; ++i)
+      for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
+	for (int a = 1; a <= B.chain.Str_L[i]; ++a)
+	  if (norm(sinh(B.lambda[i][alpha] + 0.5 * II * B.chain.anis * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
+			+ 0.25 * II * PI * (1.0 - B.chain.par[i]))) > 100.0 * MACHINE_EPS_SQ)
+	    ln_prod2 += log(norm(sinh(B.lambda[i][alpha] + 0.5 * II * B.chain.anis * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
+				      + 0.25 * II * PI * (1.0 - B.chain.par[i]))));
+
+    // Define the F ones earlier...
+
+    for (int j = 0; j < B.chain.Nstrings; ++j) {
+      for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
+	re_ln_Fn_F_B_0[j][alpha] = real(ln_Fn_F(B, j, alpha, 0));
+	im_ln_Fn_F_B_0[j][alpha] = imag(ln_Fn_F(B, j, alpha, 0));
+	re_ln_Fn_G_0[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 0));
+	im_ln_Fn_G_0[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 0));
+	re_ln_Fn_G_2[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 2));
+	im_ln_Fn_G_2[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 2));
+      }
+    }
 
-  for (int j = 0; j < A.chain.Nstrings; ++j)
-    for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha)
-      for (int a = 1; a <= A.chain.Str_L[j]; ++a)
-	ln_prod3 += ln_Fn_F(A, j, alpha, a - 1);  // assume only one-strings here
+    DP logabssinzeta = log(abs(sin(A.chain.anis)));
 
-  ln_prod3 -= A.base.Mdown * log(abs(sin(A.chain.anis)));
+    // Define regularized products in prefactors
 
-  for (int k = 0; k < B.chain.Nstrings; ++k)
-    for (int beta = 0; beta < B.base.Nrap[k]; ++beta)
-      for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
-	if (b == 1) ln_prod4 += re_ln_Fn_F_B_0[k][beta];
-	else if (b > 1) ln_prod4 += ln_Fn_F(B, k, beta, b - 1);
-    }
+    for (int j = 0; j < A.chain.Nstrings; ++j)
+      for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha)
+	for (int a = 1; a <= A.chain.Str_L[j]; ++a)
+	  ln_prod3 += ln_Fn_F(A, j, alpha, a - 1);  // assume only one-strings here
 
-  ln_prod4 -= B.base.Mdown * log(abs(sin(B.chain.anis)));
+    ln_prod3 -= A.base.Mdown * log(abs(sin(A.chain.anis)));
 
-  // Now proceed to build the Hm matrix
+    for (int k = 0; k < B.chain.Nstrings; ++k)
+      for (int beta = 0; beta < B.base.Nrap[k]; ++beta)
+	for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
+	  if (b == 1) ln_prod4 += re_ln_Fn_F_B_0[k][beta];
+	  else if (b > 1) ln_prod4 += ln_Fn_F(B, k, beta, b - 1);
+	}
 
-  SQMat_CX Hm(0.0, A.base.Mdown);
+    ln_prod4 -= B.base.Mdown * log(abs(sin(B.chain.anis)));
 
-  int index_a = 0;
-  int index_b = 0;
+    // Now proceed to build the Hm matrix
 
-  complex<DP> sum1 = 0.0;
-  complex<DP> sum2 = 0.0;
-  complex<DP> prod_num = 0.0;
-  complex<DP> Fn_K_0_G_0 = 0.0;
-  complex<DP> Prod_powerN = 0.0;
-  complex<DP> Fn_K_1_G_2 = 0.0;
-  complex<DP> one_over_A_sinhlambda_sq_plus_sinzetaover2sq;
+    SQMat_CX Hm(0.0, A.base.Mdown);
 
+    int index_a = 0;
+    int index_b = 0;
 
-  for (int j = 0; j < A.chain.Nstrings; ++j) {
-    for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
-      for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
+    complex<DP> sum1 = 0.0;
+    complex<DP> sum2 = 0.0;
+    complex<DP> prod_num = 0.0;
+    complex<DP> Fn_K_0_G_0 = 0.0;
+    complex<DP> Prod_powerN = 0.0;
+    complex<DP> Fn_K_1_G_2 = 0.0;
+    complex<DP> one_over_A_sinhlambda_sq_plus_sinzetaover2sq;
 
-	index_b = 0;
 
-	one_over_A_sinhlambda_sq_plus_sinzetaover2sq = 1.0/((sinh(A.lambda[j][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[j] + 1.0 - 2.0 * a)
-								  + 0.25 * II * PI * (1.0 - A.chain.par[j])))
-							    * (sinh(A.lambda[j][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[j] + 1.0 - 2.0 * a)
-								  + 0.25 * II * PI * (1.0 - A.chain.par[j])))
-							    + pow(sin(0.5*A.chain.anis), 2.0));
+    for (int j = 0; j < A.chain.Nstrings; ++j) {
+      for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
+	for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
 
-	for (int k = 0; k < B.chain.Nstrings; ++k) {
-	  for (int beta = 0; beta < B.base.Nrap[k]; ++beta) {
-	    for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
+	  index_b = 0;
 
-	      if (B.chain.Str_L[k] == 1) {
+	  one_over_A_sinhlambda_sq_plus_sinzetaover2sq =
+	    1.0/((sinh(A.lambda[j][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[j] + 1.0 - 2.0 * a)
+		       + 0.25 * II * PI * (1.0 - A.chain.par[j])))
+		 * (sinh(A.lambda[j][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[j] + 1.0 - 2.0 * a)
+			 + 0.25 * II * PI * (1.0 - A.chain.par[j])))
+		 + pow(sin(0.5*A.chain.anis), 2.0));
 
-		// use simplified code for one-string here:  original form of Hm matrix
+	  for (int k = 0; k < B.chain.Nstrings; ++k) {
+	    for (int beta = 0; beta < B.base.Nrap[k]; ++beta) {
+	      for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
 
-		Fn_K_0_G_0 = Fn_K (A, j, alpha, a, B, k, beta, 0) *
-		  exp(re_ln_Fn_G_0[k][beta] + II * im_ln_Fn_G_0[k][beta] - re_ln_Fn_F_B_0[k][beta] + logabssinzeta);
-		Fn_K_1_G_2 = Fn_K (A, j, alpha, a, B, k, beta, 1) *
-		  exp(re_ln_Fn_G_2[k][beta] + II * im_ln_Fn_G_2[k][beta] - re_ln_Fn_F_B_0[k][beta] + logabssinzeta);
+		if (B.chain.Str_L[k] == 1) {
 
-		Prod_powerN = pow( B.chain.par[k] == 1 ?
-				   (B.sinhlambda[k][beta] * B.chain.co_n_anis_over_2[1] + II * B.coshlambda[k][beta] * B.chain.si_n_anis_over_2[1])
-				   /(B.sinhlambda[k][beta] * B.chain.co_n_anis_over_2[1] - II * B.coshlambda[k][beta] * B.chain.si_n_anis_over_2[1])
-				   :
-				   (B.coshlambda[k][beta] * B.chain.co_n_anis_over_2[1] + II * B.sinhlambda[k][beta] * B.chain.si_n_anis_over_2[1])
-				   /(B.coshlambda[k][beta] * B.chain.co_n_anis_over_2[1] - II * B.sinhlambda[k][beta] * B.chain.si_n_anis_over_2[1])
-				   , complex<DP> (B.chain.Nsites));
+		  // use simplified code for one-string here:  original form of Hm matrix
 
-		Hm[index_a][index_b] = Fn_K_0_G_0 - (1.0 - 2.0 * (B.base.Mdown % 2)) * // MODIF from XXZ
-		  Prod_powerN * Fn_K_1_G_2;
+		  Fn_K_0_G_0 = Fn_K (A, j, alpha, a, B, k, beta, 0) *
+		    exp(re_ln_Fn_G_0[k][beta] + II * im_ln_Fn_G_0[k][beta] - re_ln_Fn_F_B_0[k][beta] + logabssinzeta);
+		  Fn_K_1_G_2 = Fn_K (A, j, alpha, a, B, k, beta, 1) *
+		    exp(re_ln_Fn_G_2[k][beta] + II * im_ln_Fn_G_2[k][beta] - re_ln_Fn_F_B_0[k][beta] + logabssinzeta);
 
-	      } // if (B.chain.Str_L == 1)
+		  Prod_powerN = pow( B.chain.par[k] == 1 ?
+				     (B.sinhlambda[k][beta] * B.chain.co_n_anis_over_2[1]
+				      + II * B.coshlambda[k][beta] * B.chain.si_n_anis_over_2[1])
+				     /(B.sinhlambda[k][beta] * B.chain.co_n_anis_over_2[1]
+				       - II * B.coshlambda[k][beta] * B.chain.si_n_anis_over_2[1])
+				     :
+				     (B.coshlambda[k][beta] * B.chain.co_n_anis_over_2[1]
+				      + II * B.sinhlambda[k][beta] * B.chain.si_n_anis_over_2[1])
+				     /(B.coshlambda[k][beta] * B.chain.co_n_anis_over_2[1]
+				       - II * B.sinhlambda[k][beta] * B.chain.si_n_anis_over_2[1])
+				     , complex<DP> (B.chain.Nsites));
 
-	      else {
+		  Hm[index_a][index_b] = Fn_K_0_G_0 - (1.0 - 2.0 * (B.base.Mdown % 2)) * // MODIF from XXZ
+		    Prod_powerN * Fn_K_1_G_2;
 
-		if (b <= B.chain.Str_L[k] - 1) Hm[index_a][index_b] = Fn_K(A, j, alpha, a, B, k, beta, b);
-		else if (b == B.chain.Str_L[k]) {
+		} // if (B.chain.Str_L == 1)
 
-		  Vect_CX ln_FunctionF(B.chain.Str_L[k] + 2);
-		  for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionF[i] = ln_Fn_F (B, k, beta, i);
+		else {
 
-		  Vect_CX ln_FunctionG(B.chain.Str_L[k] + 2);
-		  for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionG[i] = ln_Fn_G (A, B, k, beta, i);
+		  if (b <= B.chain.Str_L[k] - 1) Hm[index_a][index_b] = Fn_K(A, j, alpha, a, B, k, beta, b);
+		  else if (b == B.chain.Str_L[k]) {
 
-		  sum1 = 0.0;
+		    Vect_CX ln_FunctionF(B.chain.Str_L[k] + 2);
+		    for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionF[i] = ln_Fn_F (B, k, beta, i);
 
-		  sum1 += Fn_K (A, j, alpha, a, B, k, beta, 0) * exp(ln_FunctionG[0] + ln_FunctionG[1] - ln_FunctionF[0] - ln_FunctionF[1]);
+		    Vect_CX ln_FunctionG(B.chain.Str_L[k] + 2);
+		    for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionG[i] = ln_Fn_G (A, B, k, beta, i);
 
-		  sum1 += (1.0 - 2.0 * (B.base.Mdown % 2)) * // MODIF from XXZ
-		    Fn_K (A, j, alpha, a, B, k, beta, B.chain.Str_L[k])
-		    * exp(ln_FunctionG[B.chain.Str_L[k]] + ln_FunctionG[B.chain.Str_L[k] + 1]
-			  - ln_FunctionF[B.chain.Str_L[k]] - ln_FunctionF[B.chain.Str_L[k] + 1]);
+		    sum1 = 0.0;
 
-		  for (int jsum = 1; jsum < B.chain.Str_L[k]; ++jsum)
+		    sum1 += Fn_K (A, j, alpha, a, B, k, beta, 0)
+		      * exp(ln_FunctionG[0] + ln_FunctionG[1] - ln_FunctionF[0] - ln_FunctionF[1]);
 
-		    sum1 -= Fn_L (A, j, alpha, a, B, k, beta, jsum) *
-		      exp(ln_FunctionG[jsum] + ln_FunctionG[jsum + 1] - ln_FunctionF[jsum] - ln_FunctionF[jsum + 1]);
+		    sum1 += (1.0 - 2.0 * (B.base.Mdown % 2)) * // MODIF from XXZ
+		      Fn_K (A, j, alpha, a, B, k, beta, B.chain.Str_L[k])
+		      * exp(ln_FunctionG[B.chain.Str_L[k]] + ln_FunctionG[B.chain.Str_L[k] + 1]
+			    - ln_FunctionF[B.chain.Str_L[k]] - ln_FunctionF[B.chain.Str_L[k] + 1]);
 
-		  /*
-		  sum2 = 0.0;
+		    for (int jsum = 1; jsum < B.chain.Str_L[k]; ++jsum)
 
-		  for (int jsum = 1; jsum <= B.chain.Str_L[k]; ++jsum)  sum2 += exp(ln_FunctionG[jsum] - ln_FunctionF[jsum]);
+		      sum1 -= Fn_L (A, j, alpha, a, B, k, beta, jsum) *
+			exp(ln_FunctionG[jsum] + ln_FunctionG[jsum + 1] - ln_FunctionF[jsum] - ln_FunctionF[jsum + 1]);
 
-		  */
-		  prod_num = exp(II * im_ln_Fn_F_B_0[k][beta] + ln_FunctionF[1] - ln_FunctionG[B.chain.Str_L[k]] + logabssinzeta);
+		    prod_num = exp(II * im_ln_Fn_F_B_0[k][beta] + ln_FunctionF[1]
+				   - ln_FunctionG[B.chain.Str_L[k]] + logabssinzeta);
 
-		  for (int jsum = 2; jsum <= B.chain.Str_L[k]; ++jsum)
-		    prod_num *= exp(ln_FunctionG[jsum] - real(ln_Fn_F(B, k, beta, jsum - 1)) + logabssinzeta);
-		  // include all string contributions F_B_0 in this term
+		    for (int jsum = 2; jsum <= B.chain.Str_L[k]; ++jsum)
+		      prod_num *= exp(ln_FunctionG[jsum] - real(ln_Fn_F(B, k, beta, jsum - 1)) + logabssinzeta);
+		    // include all string contributions F_B_0 in this term
 
-		  Hm[index_a][index_b] = prod_num * sum1;
+		    Hm[index_a][index_b] = prod_num * sum1;
 
-		} // else if (b == B.chain.Str_L[k])
-	      } // else
+		  } // else if (b == B.chain.Str_L[k])
+		} // else
 
-	      index_b++;
-	    }}} // sums over k, beta, b
+		index_b++;
+	      }}} // sums over k, beta, b
 
-	// now define the elements Hm[a][M]
+	  // now define the elements Hm[a][M]
 
-	Hm[index_a][B.base.Mdown] = one_over_A_sinhlambda_sq_plus_sinzetaover2sq;
+	  Hm[index_a][B.base.Mdown] = one_over_A_sinhlambda_sq_plus_sinzetaover2sq;
 
-	index_a++;
-      }}} // sums over j, alpha, a
+	  index_a++;
+	}}} // sums over j, alpha, a
 
-  complex<DP> ln_ME_sq = log(1.0 * A.chain.Nsites) + real(ln_prod1 - ln_prod2) - real(ln_prod3) + real(ln_prod4)
-    + 2.0 * real(lndet_LU_CX_dstry(Hm)) + logabssinzeta - A.lnnorm - B.lnnorm;
+    complex<DP> ln_ME_sq = log(1.0 * A.chain.Nsites) + real(ln_prod1 - ln_prod2) - real(ln_prod3) + real(ln_prod4)
+      + 2.0 * real(lndet_LU_CX_dstry(Hm)) + logabssinzeta - A.lnnorm - B.lnnorm;
 
-  //return(ln_ME_sq);
-  return(0.5 * ln_ME_sq); // Return ME, not MEsq
+    return(0.5 * ln_ME_sq); // Return ME, not MEsq
 
-}
+  }
 
 } // namespace ABACUS

src/ODSLF/ln_Sz_ME_ODSLF_XXZ.cc

 
 namespace ABACUS {
 
-inline complex<DP> ln_Fn_F (ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
-{
-  complex<DP> ans = 0.0;
-  complex<DP> prod_temp = 1.0;
-  int counter = 0;
-  int arg = 0;
-  int absarg = 0;
-  int par_comb_1, par_comb_2;
+  inline complex<DP> ln_Fn_F (ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
+  {
+    complex<DP> ans = 0.0;
+    complex<DP> prod_temp = 1.0;
+    int counter = 0;
+    int arg = 0;
+    int absarg = 0;
+    int par_comb_1, par_comb_2;
 
-  for (int j = 0; j < B.chain.Nstrings; ++j) {
+    for (int j = 0; j < B.chain.Nstrings; ++j) {
 
-    par_comb_1 = B.chain.par[j] == B.chain.par[k] ? 1 : 0;
-    par_comb_2 = B.chain.par[k] == B.chain.par[j] ? 0 : B.chain.par[k];
+      par_comb_1 = B.chain.par[j] == B.chain.par[k] ? 1 : 0;
+      par_comb_2 = B.chain.par[k] == B.chain.par[j] ? 0 : B.chain.par[k];
 
-    for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
+      for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
 
-      for (int a = 1; a <= B.chain.Str_L[j]; ++a) {
+	for (int a = 1; a <= B.chain.Str_L[j]; ++a) {
 
-	if (!((j == k) && (alpha == beta) && (a == b))) {
+	  if (!((j == k) && (alpha == beta) && (a == b))) {
 
-	  arg = B.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
-	  absarg = abs(arg);
-	  /*
-	  prod_temp *= 0.5 *
-	    ((B.sinhlambda[j][alpha] * B.coshlambda[k][beta] - B.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-			* (B.chain.co_n_anis_over_2[absarg] * (1.0 + B.chain.par[j] * B.chain.par[k])
-			   - sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * (B.chain.par[k] - B.chain.par[j]))
-			+ II * (B.coshlambda[j][alpha] * B.coshlambda[k][beta] - B.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-			* (sgn_int(arg)
-			   * B.chain.si_n_anis_over_2[absarg] * (1.0 + B.chain.par[j] * B.chain.par[k])
-			   + B.chain.co_n_anis_over_2[absarg] * (B.chain.par[k] - B.chain.par[j])) );
-	  */
-	  prod_temp *= ((B.sinhlambda[j][alpha] * B.coshlambda[k][beta] - B.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-			* (B.chain.co_n_anis_over_2[absarg] * par_comb_1 - sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * par_comb_2)
-			+ II * (B.coshlambda[j][alpha] * B.coshlambda[k][beta] - B.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-			* (sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * par_comb_1 + B.chain.co_n_anis_over_2[absarg] * par_comb_2));
+	    arg = B.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
+	    absarg = abs(arg);
+	    prod_temp *= ((B.sinhlambda[j][alpha] * B.coshlambda[k][beta]
+			   - B.coshlambda[j][alpha] * B.sinhlambda[k][beta])
+			  * (B.chain.co_n_anis_over_2[absarg] * par_comb_1
+			     - sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * par_comb_2)
+			  + II * (B.coshlambda[j][alpha] * B.coshlambda[k][beta]
+				  - B.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
+			  * (sgn_int(arg) * B.chain.si_n_anis_over_2[absarg] * par_comb_1
+			     + B.chain.co_n_anis_over_2[absarg] * par_comb_2));
 
-	}
+	  }
 
-	if (counter++ > 100) {  // we do at most 100 products before taking a log
-	  ans += log(prod_temp);
-	  prod_temp = 1.0;
-	  counter = 0;
-	}
+	  if (counter++ > 100) {  // we do at most 100 products before taking a log
+	    ans += log(prod_temp);
+	    prod_temp = 1.0;
+	    counter = 0;
+	  }
 
-      }}}
-
-  return(ans + log(prod_temp));
-}
-
-inline complex<DP> ln_Fn_G (ODSLF_XXZ_Bethe_State& A, ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
-{
-  complex<DP> ans = 0.0;
-  complex<DP> prod_temp = 1.0;
-  int counter = 0;
-  int arg = 0;
-  int absarg = 0;
-  int par_comb_1, par_comb_2;
-
-  for (int j = 0; j < A.chain.Nstrings; ++j) {
-
-    par_comb_1 = A.chain.par[j] == B.chain.par[k] ? 1 : 0;
-    par_comb_2 = B.chain.par[k] == A.chain.par[j] ? 0 : B.chain.par[k];
-
-    for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
-
-      for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
-
-	arg = A.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
-	absarg = abs(arg);
-
-	/*
-	prod_temp *= 0.5 *
-	  ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (A.chain.co_n_anis_over_2[absarg] * (1.0 + A.chain.par[j] * B.chain.par[k])
-			 - sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * (B.chain.par[k] - A.chain.par[j]))
-		      + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * (1.0 + A.chain.par[j] * B.chain.par[k])
-			 + A.chain.co_n_anis_over_2[absarg] * (B.chain.par[k] - A.chain.par[j])) );
-	*/
-	prod_temp *= ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (A.chain.co_n_anis_over_2[absarg] * par_comb_1 - sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * par_comb_2)
-		      + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-		      * (sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * par_comb_1 + A.chain.co_n_anis_over_2[absarg] * par_comb_2));
-
-	if (counter++ > 100) {  // we do at most 100 products before taking a log
-	  ans += log(prod_temp);
-	  prod_temp = 1.0;
-	  counter = 0;
-	}
-      }}}
-
-  return(ans + log(prod_temp));
-}
-
-inline complex<DP> Fn_K (ODSLF_XXZ_Bethe_State& A, int j, int alpha, int a, ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
-{
-  int arg1 = A.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
-  int absarg1 = abs(arg1);
-  int arg2 = arg1 + 2;
-  int absarg2 = abs(arg2);
-
-  return(4.0/(
-	      ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-	       * (A.chain.co_n_anis_over_2[absarg1] * (1.0 + A.chain.par[j] * B.chain.par[k])
-		  - sgn_int(arg1) * A.chain.si_n_anis_over_2[absarg1] * (B.chain.par[k] - A.chain.par[j]))
-	       + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-	       * (sgn_int(arg1) * A.chain.si_n_anis_over_2[absarg1] * (1.0 + A.chain.par[j] * B.chain.par[k])
-		  + A.chain.co_n_anis_over_2[absarg1] * (B.chain.par[k] - A.chain.par[j])) )
-	      *
-	      ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
-	       * (A.chain.co_n_anis_over_2[absarg2] * (1.0 + A.chain.par[j] * B.chain.par[k])
-		  - sgn_int(arg2) * A.chain.si_n_anis_over_2[absarg2] * (B.chain.par[k] - A.chain.par[j]))
-	       + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
-	       * (sgn_int(arg2) * A.chain.si_n_anis_over_2[absarg2] * (1.0 + A.chain.par[j] * B.chain.par[k])
-		  + A.chain.co_n_anis_over_2[absarg2] * (B.chain.par[k] - A.chain.par[j])) )
-	      ));
-
-}
-
-inline complex<DP> Fn_L (ODSLF_XXZ_Bethe_State& A, int j, int alpha, int a, ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
-{
-  return (sinh(2.0 * (A.lambda[j][alpha] - B.lambda[k][beta]
-		      + 0.5 * II * B.chain.anis * (A.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b - 0.5))
-		      + 0.25 * II * PI * complex<DP>(-A.chain.par[j] + B.chain.par[k])))
-	  * pow(Fn_K (A, j, alpha, a, B, k, beta, b), 2.0));
-}
-
-complex<DP> ln_Sz_ME (ODSLF_XXZ_Bethe_State& A, ODSLF_XXZ_Bethe_State& B)
-{
-  // This function returns the natural log of the S^z operator matrix element.
-  // The A and B states can contain strings.
-
-  // Check that the two states refer to the same XXZ_Chain
-
-  if (A.chain != B.chain) ABACUSerror("Incompatible ODSLF_XXZ_Chains in Sz matrix element.");
-
-  // Check that A and B are compatible:  same Mdown
-
-  if (A.base.Mdown != B.base.Mdown) ABACUSerror("Incompatible Mdown between the two states in Sz matrix element!");
-
-  // Compute the sinh and cosh of rapidities
-
-  A.Compute_sinhlambda();
-  A.Compute_coshlambda();
-  B.Compute_sinhlambda();
-  B.Compute_coshlambda();
-
-  // Some convenient arrays
-
-  ODSLF_Lambda re_ln_Fn_F_B_0(B.chain, B.base);
-  ODSLF_Lambda im_ln_Fn_F_B_0(B.chain, B.base);
-  ODSLF_Lambda re_ln_Fn_G_0(B.chain, B.base);
-  ODSLF_Lambda im_ln_Fn_G_0(B.chain, B.base);
-  ODSLF_Lambda re_ln_Fn_G_2(B.chain, B.base);
-  ODSLF_Lambda im_ln_Fn_G_2(B.chain, B.base);
-
-  complex<DP> ln_prod1 = 0.0;
-  complex<DP> ln_prod2 = 0.0;
-  complex<DP> ln_prod3 = 0.0;
-  complex<DP> ln_prod4 = 0.0;
-
-  for (int i = 0; i < A.chain.Nstrings; ++i)
-    for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
-      for (int a = 1; a <= A.chain.Str_L[i]; ++a)
-	ln_prod1 += log(norm(sinh(A.lambda[i][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
-				  + 0.25 * II * PI * (1.0 - A.chain.par[i]))));
-
-  for (int i = 0; i < B.chain.Nstrings; ++i)
-    for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
-      for (int a = 1; a <= B.chain.Str_L[i]; ++a)
-	if (norm(sinh(B.lambda[i][alpha] + 0.5 * II * B.chain.anis * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
-		      + 0.25 * II * PI * (1.0 - B.chain.par[i]))) > 100.0 * MACHINE_EPS_SQ)
-	  ln_prod2 += log(norm(sinh(B.lambda[i][alpha] + 0.5 * II * B.chain.anis * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
-				    + 0.25 * II * PI * (1.0 - B.chain.par[i]))));
-
-  // Define the F ones earlier...
-
-  for (int j = 0; j < B.chain.Nstrings; ++j) {
-    for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
-      re_ln_Fn_F_B_0[j][alpha] = real(ln_Fn_F(B, j, alpha, 0));
-      im_ln_Fn_F_B_0[j][alpha] = imag(ln_Fn_F(B, j, alpha, 0));
-      re_ln_Fn_G_0[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 0));
-      im_ln_Fn_G_0[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 0));
-      re_ln_Fn_G_2[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 2));
-      im_ln_Fn_G_2[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 2));
-    }
+	}}}
+
+    return(ans + log(prod_temp));
   }
 
-  DP logabssinzeta = log(abs(sin(A.chain.anis)));
+  inline complex<DP> ln_Fn_G (ODSLF_XXZ_Bethe_State& A, ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
+  {
+    complex<DP> ans = 0.0;
+    complex<DP> prod_temp = 1.0;
+    int counter = 0;
+    int arg = 0;
+    int absarg = 0;
+    int par_comb_1, par_comb_2;
 
-  // Define regularized products in prefactors
+    for (int j = 0; j < A.chain.Nstrings; ++j) {
 
-  for (int j = 0; j < A.chain.Nstrings; ++j)
-    for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha)
-      for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
-	ln_prod3 += ln_Fn_F (A, j, alpha, a - 1);
-      }
+      par_comb_1 = A.chain.par[j] == B.chain.par[k] ? 1 : 0;
+      par_comb_2 = B.chain.par[k] == A.chain.par[j] ? 0 : B.chain.par[k];
 
-  ln_prod3 -= A.base.Mdown * log(abs(sin(A.chain.anis)));
+      for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
 
-  for (int k = 0; k < B.chain.Nstrings; ++k)
-    for (int beta = 0; beta < B.base.Nrap[k]; ++beta)
-      for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
-	if (b == 1) ln_prod4 += re_ln_Fn_F_B_0[k][beta];
-	else if (b > 1) ln_prod4 += ln_Fn_F(B, k, beta, b - 1);
+	for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
+
+	  arg = A.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
+	  absarg = abs(arg);
+
+	  prod_temp *= ((A.sinhlambda[j][alpha] * B.coshlambda[k][beta]
+			 - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
+			* (A.chain.co_n_anis_over_2[absarg] * par_comb_1
+			   - sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * par_comb_2)
+			+ II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta]
+				- A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
+			* (sgn_int(arg) * A.chain.si_n_anis_over_2[absarg] * par_comb_1
+			   + A.chain.co_n_anis_over_2[absarg] * par_comb_2));
+
+	  if (counter++ > 100) {  // we do at most 100 products before taking a log
+	    ans += log(prod_temp);
+	    prod_temp = 1.0;
+	    counter = 0;
+	  }
+	}}}
+
+    return(ans + log(prod_temp));
+  }
+
+  inline complex<DP> Fn_K (ODSLF_XXZ_Bethe_State& A, int j, int alpha, int a,
+			   ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
+  {
+    int arg1 = A.chain.Str_L[j] - B.chain.Str_L[k] - 2 * (a - b);
+    int absarg1 = abs(arg1);
+    int arg2 = arg1 + 2;
+    int absarg2 = abs(arg2);
+
+    return(4.0/(
+		((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
+		 * (A.chain.co_n_anis_over_2[absarg1] * (1.0 + A.chain.par[j] * B.chain.par[k])
+		    - sgn_int(arg1) * A.chain.si_n_anis_over_2[absarg1] * (B.chain.par[k] - A.chain.par[j]))
+		 + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
+		 * (sgn_int(arg1) * A.chain.si_n_anis_over_2[absarg1] * (1.0 + A.chain.par[j] * B.chain.par[k])
+		    + A.chain.co_n_anis_over_2[absarg1] * (B.chain.par[k] - A.chain.par[j])) )
+		*
+		((A.sinhlambda[j][alpha] * B.coshlambda[k][beta] - A.coshlambda[j][alpha] * B.sinhlambda[k][beta])
+		 * (A.chain.co_n_anis_over_2[absarg2] * (1.0 + A.chain.par[j] * B.chain.par[k])
+		    - sgn_int(arg2) * A.chain.si_n_anis_over_2[absarg2] * (B.chain.par[k] - A.chain.par[j]))
+		 + II * (A.coshlambda[j][alpha] * B.coshlambda[k][beta] - A.sinhlambda[j][alpha] * B.sinhlambda[k][beta])
+		 * (sgn_int(arg2) * A.chain.si_n_anis_over_2[absarg2] * (1.0 + A.chain.par[j] * B.chain.par[k])
+		    + A.chain.co_n_anis_over_2[absarg2] * (B.chain.par[k] - A.chain.par[j])) )
+		));
+
+  }
+
+  inline complex<DP> Fn_L (ODSLF_XXZ_Bethe_State& A, int j, int alpha, int a,
+			   ODSLF_XXZ_Bethe_State& B, int k, int beta, int b)
+  {
+    return (sinh(2.0 * (A.lambda[j][alpha] - B.lambda[k][beta]
+			+ 0.5 * II * B.chain.anis * (A.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b - 0.5))
+			+ 0.25 * II * PI * complex<DP>(-A.chain.par[j] + B.chain.par[k])))
+	    * pow(Fn_K (A, j, alpha, a, B, k, beta, b), 2.0));
+  }
+
+  complex<DP> ln_Sz_ME (ODSLF_XXZ_Bethe_State& A, ODSLF_XXZ_Bethe_State& B)
+  {
+    // This function returns the natural log of the S^z operator matrix element.
+    // The A and B states can contain strings.
+
+    // Check that the two states refer to the same XXZ_Chain
+
+    if (A.chain != B.chain)
+      ABACUSerror("Incompatible ODSLF_XXZ_Chains in Sz matrix element.");
+
+    // Check that A and B are compatible:  same Mdown
+
+    if (A.base.Mdown != B.base.Mdown)
+      ABACUSerror("Incompatible Mdown between the two states in Sz matrix element!");
+
+    // Compute the sinh and cosh of rapidities
+
+    A.Compute_sinhlambda();
+    A.Compute_coshlambda();
+    B.Compute_sinhlambda();
+    B.Compute_coshlambda();
+
+    // Some convenient arrays
+
+    ODSLF_Lambda re_ln_Fn_F_B_0(B.chain, B.base);
+    ODSLF_Lambda im_ln_Fn_F_B_0(B.chain, B.base);
+    ODSLF_Lambda re_ln_Fn_G_0(B.chain, B.base);
+    ODSLF_Lambda im_ln_Fn_G_0(B.chain, B.base);
+    ODSLF_Lambda re_ln_Fn_G_2(B.chain, B.base);
+    ODSLF_Lambda im_ln_Fn_G_2(B.chain, B.base);
+
+    complex<DP> ln_prod1 = 0.0;
+    complex<DP> ln_prod2 = 0.0;
+    complex<DP> ln_prod3 = 0.0;
+    complex<DP> ln_prod4 = 0.0;
+
+    for (int i = 0; i < A.chain.Nstrings; ++i)
+      for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
+	for (int a = 1; a <= A.chain.Str_L[i]; ++a)
+	  ln_prod1 += log(norm(sinh(A.lambda[i][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
+				    + 0.25 * II * PI * (1.0 - A.chain.par[i]))));
+
+    for (int i = 0; i < B.chain.Nstrings; ++i)
+      for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
+	for (int a = 1; a <= B.chain.Str_L[i]; ++a)
+	  if (norm(sinh(B.lambda[i][alpha] + 0.5 * II * B.chain.anis * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
+			+ 0.25 * II * PI * (1.0 - B.chain.par[i]))) > 100.0 * MACHINE_EPS_SQ)
+	    ln_prod2 += log(norm(sinh(B.lambda[i][alpha] + 0.5 * II * B.chain.anis * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)
+				      + 0.25 * II * PI * (1.0 - B.chain.par[i]))));
+
+    // Define the F ones earlier...
+
+    for (int j = 0; j < B.chain.Nstrings; ++j) {
+      for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
+	re_ln_Fn_F_B_0[j][alpha] = real(ln_Fn_F(B, j, alpha, 0));
+	im_ln_Fn_F_B_0[j][alpha] = imag(ln_Fn_F(B, j, alpha, 0));
+	re_ln_Fn_G_0[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 0));
+	im_ln_Fn_G_0[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 0));
+	re_ln_Fn_G_2[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 2));
+	im_ln_Fn_G_2[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 2));
       }
+    }
 
-  ln_prod4 -= B.base.Mdown * log(abs(sin(B.chain.anis)));
+    DP logabssinzeta = log(abs(sin(A.chain.anis)));
 
-  // Now proceed to build the Hm2P matrix
+    // Define regularized products in prefactors
 
-  SQMat_CX Hm2P(0.0, A.base.Mdown);
+    for (int j = 0; j < A.chain.Nstrings; ++j)
+      for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha)
+	for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
+	  ln_prod3 += ln_Fn_F (A, j, alpha, a - 1);
+	}
 
-  int index_a = 0;
-  int index_b = 0;
+    ln_prod3 -= A.base.Mdown * log(abs(sin(A.chain.anis)));
 
-  complex<DP> sum1 = 0.0;
-  complex<DP> sum2 = 0.0;
-  complex<DP> prod_num = 0.0;
-  complex<DP> Fn_K_0_G_0 = 0.0;
-  complex<DP> Prod_powerN = 0.0;
-  complex<DP> Fn_K_1_G_2 = 0.0;
-  complex<DP> two_over_A_sinhlambda_sq_plus_sinzetaover2sq;
+    for (int k = 0; k < B.chain.Nstrings; ++k)
+      for (int beta = 0; beta < B.base.Nrap[k]; ++beta)
+	for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
+	  if (b == 1) ln_prod4 += re_ln_Fn_F_B_0[k][beta];
+	  else if (b > 1) ln_prod4 += ln_Fn_F(B, k, beta, b - 1);
+	}
 
+    ln_prod4 -= B.base.Mdown * log(abs(sin(B.chain.anis)));
 
-  for (int j = 0; j < A.chain.Nstrings; ++j) {
-    for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
-      for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
+    // Now proceed to build the Hm2P matrix
 
-	index_b = 0;
+    SQMat_CX Hm2P(0.0, A.base.Mdown);
 
-	two_over_A_sinhlambda_sq_plus_sinzetaover2sq = 2.0/((sinh(A.lambda[j][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[j] + 1.0 - 2.0 * a)
-								  + 0.25 * II * PI * (1.0 - A.chain.par[j])))
-							    * (sinh(A.lambda[j][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[j] + 1.0 - 2.0 * a)
-								  + 0.25 * II * PI * (1.0 - A.chain.par[j])))
-							     + pow(sin(0.5*A.chain.anis), 2.0));
+    int index_a = 0;
+    int index_b = 0;
 
-	for (int k = 0; k < B.chain.Nstrings; ++k) {
-	  for (int beta = 0; beta < B.base.Nrap[k]; ++beta) {
-	    for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
+    complex<DP> sum1 = 0.0;
+    complex<DP> sum2 = 0.0;
+    complex<DP> prod_num = 0.0;
+    complex<DP> Fn_K_0_G_0 = 0.0;
+    complex<DP> Prod_powerN = 0.0;
+    complex<DP> Fn_K_1_G_2 = 0.0;
+    complex<DP> two_over_A_sinhlambda_sq_plus_sinzetaover2sq;
 
-	      if (B.chain.Str_L[k] == 1) {
 
-		// use simplified code for one-string here:  original form of Hm2P matrix
+    for (int j = 0; j < A.chain.Nstrings; ++j) {
+      for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
+	for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
 
-		Fn_K_0_G_0 = Fn_K (A, j, alpha, a, B, k, beta, 0) *
-		  exp(re_ln_Fn_G_0[k][beta] + II * im_ln_Fn_G_0[k][beta] - re_ln_Fn_F_B_0[k][beta] + logabssinzeta);
-		Fn_K_1_G_2 = Fn_K (A, j, alpha, a, B, k, beta, 1) *
-		  exp(re_ln_Fn_G_2[k][beta] + II * im_ln_Fn_G_2[k][beta] - re_ln_Fn_F_B_0[k][beta] + logabssinzeta);
+	  index_b = 0;
 
-		Prod_powerN = pow( B.chain.par[k] == 1 ?
-				   (B.sinhlambda[k][beta] * B.chain.co_n_anis_over_2[1] + II * B.coshlambda[k][beta] * B.chain.si_n_anis_over_2[1])
-				   /(B.sinhlambda[k][beta] * B.chain.co_n_anis_over_2[1] - II * B.coshlambda[k][beta] * B.chain.si_n_anis_over_2[1])
-				   :
-				   (B.coshlambda[k][beta] * B.chain.co_n_anis_over_2[1] + II * B.sinhlambda[k][beta] * B.chain.si_n_anis_over_2[1])
-				   /(B.coshlambda[k][beta] * B.chain.co_n_anis_over_2[1] - II * B.sinhlambda[k][beta] * B.chain.si_n_anis_over_2[1])
-				   , complex<DP> (B.chain.Nsites));
+	  two_over_A_sinhlambda_sq_plus_sinzetaover2sq =
+	    2.0/((sinh(A.lambda[j][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[j] + 1.0 - 2.0 * a)
+		       + 0.25 * II * PI * (1.0 - A.chain.par[j])))
+		 * (sinh(A.lambda[j][alpha] + 0.5 * II * A.chain.anis * (A.chain.Str_L[j] + 1.0 - 2.0 * a)
+			 + 0.25 * II * PI * (1.0 - A.chain.par[j])))
+		 + pow(sin(0.5*A.chain.anis), 2.0));
 
-		Hm2P[index_a][index_b] = Fn_K_0_G_0 - (-1.0 + 2.0 * (B.base.Mdown % 2)) * // MODIF from XXZ
-		  Prod_powerN * Fn_K_1_G_2 - two_over_A_sinhlambda_sq_plus_sinzetaover2sq
-		    * exp(II*im_ln_Fn_F_B_0[k][beta] + logabssinzeta);
+	  for (int k = 0; k < B.chain.Nstrings; ++k) {
+	    for (int beta = 0; beta < B.base.Nrap[k]; ++beta) {
+	      for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
 
-	      }
+		if (B.chain.Str_L[k] == 1) {
 
-	      else {
+		  // use simplified code for one-string here:  original form of Hm2P matrix
 
-		if (b <= B.chain.Str_L[k] - 1) Hm2P[index_a][index_b] = Fn_K(A, j, alpha, a, B, k, beta, b);
-		else if (b == B.chain.Str_L[k]) {
+		  Fn_K_0_G_0 = Fn_K (A, j, alpha, a, B, k, beta, 0) *
+		    exp(re_ln_Fn_G_0[k][beta] + II * im_ln_Fn_G_0[k][beta] - re_ln_Fn_F_B_0[k][beta] + logabssinzeta);
+		  Fn_K_1_G_2 = Fn_K (A, j, alpha, a, B, k, beta, 1) *
+		    exp(re_ln_Fn_G_2[k][beta] + II * im_ln_Fn_G_2[k][beta] - re_ln_Fn_F_B_0[k][beta] + logabssinzeta);
 
-		  Vect_CX ln_FunctionF(B.chain.Str_L[k] + 2);
-		  for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionF[i] = ln_Fn_F (B, k, beta, i);
+		  Prod_powerN = pow( B.chain.par[k] == 1 ?
+				     (B.sinhlambda[k][beta] * B.chain.co_n_anis_over_2[1]
+				      + II * B.coshlambda[k][beta] * B.chain.si_n_anis_over_2[1])
+				     /(B.sinhlambda[k][beta] * B.chain.co_n_anis_over_2[1]
+				       - II * B.coshlambda[k][beta] * B.chain.si_n_anis_over_2[1])
+				     :
+				     (B.coshlambda[k][beta] * B.chain.co_n_anis_over_2[1]
+				      + II * B.sinhlambda[k][beta] * B.chain.si_n_anis_over_2[1])
+				     /(B.coshlambda[k][beta] * B.chain.co_n_anis_over_2[1]
+				       - II * B.sinhlambda[k][beta] * B.chain.si_n_anis_over_2[1])
+				     , complex<DP> (B.chain.Nsites));
 
-		  Vect_CX ln_FunctionG(B.chain.Str_L[k] + 2);
-		  for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionG[i] = ln_Fn_G (A, B, k, beta, i);
+		  Hm2P[index_a][index_b] = Fn_K_0_G_0 - (-1.0 + 2.0 * (B.base.Mdown % 2)) * // MODIF from XXZ
+		    Prod_powerN * Fn_K_1_G_2 - two_over_A_sinhlambda_sq_plus_sinzetaover2sq
+		    * exp(II*im_ln_Fn_F_B_0[k][beta] + logabssinzeta);
+
+		}
+
+		else {
 
-		  sum1 = 0.0;
+		  if (b <= B.chain.Str_L[k] - 1) Hm2P[index_a][index_b] = Fn_K(A, j, alpha, a, B, k, beta, b);
+		  else if (b == B.chain.Str_L[k]) {
 
-		  sum1 += Fn_K (A, j, alpha, a, B, k, beta, 0) * exp(ln_FunctionG[0] + ln_FunctionG[1] - ln_FunctionF[0] - ln_FunctionF[1]);
+		    Vect_CX ln_FunctionF(B.chain.Str_L[k] + 2);
+		    for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionF[i] = ln_Fn_F (B, k, beta, i);
 
-		  sum1 += (-1.0 + 2.0 * (B.base.Mdown % 2)) * // MODIF from XXZ
-		    Fn_K (A, j, alpha, a, B, k, beta, B.chain.Str_L[k])
-		    * exp(ln_FunctionG[B.chain.Str_L[k]] + ln_FunctionG[B.chain.Str_L[k] + 1]
-			  - ln_FunctionF[B.chain.Str_L[k]] - ln_FunctionF[B.chain.Str_L[k] + 1]);
+		    Vect_CX ln_FunctionG(B.chain.Str_L[k] + 2);
+		    for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionG[i] = ln_Fn_G (A, B, k, beta, i);
 
-		  for (int jsum = 1; jsum < B.chain.Str_L[k]; ++jsum)
+		    sum1 = 0.0;
 
-		    sum1 -= Fn_L (A, j, alpha, a, B, k, beta, jsum) *
-		      exp(ln_FunctionG[jsum] + ln_FunctionG[jsum + 1] - ln_FunctionF[jsum] - ln_FunctionF[jsum + 1]);
+		    sum1 += Fn_K (A, j, alpha, a, B, k, beta, 0)
+		      * exp(ln_FunctionG[0] + ln_FunctionG[1] - ln_FunctionF[0] - ln_FunctionF[1]);
 
-		  sum2 = 0.0;
+		    sum1 += (-1.0 + 2.0 * (B.base.Mdown % 2)) * // MODIF from XXZ
+		      Fn_K (A, j, alpha, a, B, k, beta, B.chain.Str_L[k])
+		      * exp(ln_FunctionG[B.chain.Str_L[k]] + ln_FunctionG[B.chain.Str_L[k] + 1]
+			    - ln_FunctionF[B.chain.Str_L[k]] - ln_FunctionF[B.chain.Str_L[k] + 1]);
 
-		  for (int jsum = 1; jsum <= B.chain.Str_L[k]; ++jsum)  sum2 += exp(ln_FunctionG[jsum] - ln_FunctionF[jsum]);
+		    for (int jsum = 1; jsum < B.chain.Str_L[k]; ++jsum)
 
-		  prod_num = exp(II * im_ln_Fn_F_B_0[k][beta] + ln_FunctionF[1] - ln_FunctionG[B.chain.Str_L[k]] + logabssinzeta);
+		      sum1 -= Fn_L (A, j, alpha, a, B, k, beta, jsum) *
+			exp(ln_FunctionG[jsum] + ln_FunctionG[jsum + 1] - ln_FunctionF[jsum] - ln_FunctionF[jsum + 1]);
 
-		  for (int jsum = 2; jsum <= B.chain.Str_L[k]; ++jsum)
-		    prod_num *= exp(ln_FunctionG[jsum] - real(ln_FunctionF[jsum - 1]) + logabssinzeta);
-		  // include all string contributions F_B_0 in this term
+		    sum2 = 0.0;
 
-		  Hm2P[index_a][index_b] = prod_num * (sum1 - sum2 * two_over_A_sinhlambda_sq_plus_sinzetaover2sq);
+		    for (int jsum = 1; jsum <= B.chain.Str_L[k]; ++jsum)
+		      sum2 += exp(ln_FunctionG[jsum] - ln_FunctionF[jsum]);
 
-		} // else if (b == B.chain.Str_L[k])
-	      } // else
+		    prod_num = exp(II * im_ln_Fn_F_B_0[k][beta] + ln_FunctionF[1]
+				   - ln_FunctionG[B.chain.Str_L[k]] + logabssinzeta);
 
-	      index_b++;
-	    }}} // sums over k, beta, b
-	index_a++;
-      }}} // sums over j, alpha, a
+		    for (int jsum = 2; jsum <= B.chain.Str_L[k]; ++jsum)
+		      prod_num *= exp(ln_FunctionG[jsum] - real(ln_FunctionF[jsum - 1]) + logabssinzeta);
+		    // include all string contributions F_B_0 in this term
 
-  DP re_ln_det = real(lndet_LU_CX_dstry(Hm2P));
+		    Hm2P[index_a][index_b] = prod_num * (sum1 - sum2 * two_over_A_sinhlambda_sq_plus_sinzetaover2sq);
 
-  complex<DP> ln_ME_sq = log(0.25 * A.chain.Nsites) + real(ln_prod1 - ln_prod2) - real(ln_prod3) + real(ln_prod4)
-    + 2.0 * /*real(lndet_LU_CX_dstry(Hm2P))*/ re_ln_det - A.lnnorm - B.lnnorm;
+		  } // else if (b == B.chain.Str_L[k])
+		} // else
 
-  //cout << endl << ln_prod1 << "\t" << ln_prod2 << "\t" << ln_prod3 << "\t" << ln_prod4 << "\t" << A.lnnorm << "\t" << B.lnnorm
-  //  << "\t" << re_ln_det << "\t" << ln_ME_sq << endl;
+		index_b++;
+	      }}} // sums over k, beta, b
+	  index_a++;
+	}}} // sums over j, alpha, a
 
-  //return(ln_ME_sq);
-  return(0.5 * ln_ME_sq); // Return ME, not MEsq
+    DP re_ln_det = real(lndet_LU_CX_dstry(Hm2P));
 
-}
+    complex<DP> ln_ME_sq = log(0.25 * A.chain.Nsites) + real(ln_prod1 - ln_prod2) - real(ln_prod3) + real(ln_prod4)
+      + 2.0 * re_ln_det - A.lnnorm - B.lnnorm;
+
+    return(0.5 * ln_ME_sq); // Return ME, not MEsq
+
+  }
 
 } // namespace ABACUS

src/RICHARDSON/Richardson.cc

     //DP bquad = -1.0/g_int - sumoneovereps[j];
     //DP cquad = sumSovereps[j];
     /*
-    DP discr = 0.0;
-    bool retval = false;
-    //if ((discr = bquad * bquad - 4.0 * cquad) >= 0.0) {
-    if ((discr = (1.0/g_int + sumoneovereps[j]) * (1.0/g_int + sumoneovereps[j]) - 4.0 * sumSovereps[j]) >= 0.0) {
+      DP discr = 0.0;
+      bool retval = false;
+      //if ((discr = bquad * bquad - 4.0 * cquad) >= 0.0) {
+      if ((discr = (1.0/g_int + sumoneovereps[j]) * (1.0/g_int + sumoneovereps[j]) - 4.0 * sumSovereps[j]) >= 0.0) {
       discr = sqrt(discr);
       Sjleft = 0.5 * (-(1.0/g_int + sumoneovereps[j]) - discr);
       Sjright = 0.5 * (-(1.0/g_int + sumoneovereps[j]) + discr);
       retval = true;
-    }
+      }
 
-    return(retval);
+      return(retval);
     */
 
     complex<DP> discr = sqrt((1.0/g_int + sumoneovereps[j]) * (1.0/g_int + sumoneovereps[j]) - 4.0 * sumSovereps[j]);
-    //complex<DP> discr = sqrt(ABACUS::max(0.0, real((1.0/g_int + sumoneovereps[j]) * (1.0/g_int + sumoneovereps[j]) - 4.0 * sumSovereps[j])));
     Sjleft = 0.5 * (1.0/g_int + sumoneovereps[j] - discr);
     Sjright = 0.5 * (1.0/g_int + sumoneovereps[j] + discr);
     return(true);
 
       // Re-solve for jmax:
       if (Solve_Richardson_Quad_S (g_int, epsilon, sumoneovereps, S, sumSovereps, jmax, Sleft, Sright)) {
-	//if (leftroot[jmax] == true) S[jmax] = damping * Sleft + (1.0 - damping) * S[jmax];
-	//else S[jmax] = damping * Sright + (1.0 - damping) * S[jmax];
 	if (abs(S[jmax] - Sleft) < abs(S[jmax] - Sright)) S[jmax] = damping * Sleft + (1.0 - damping) * S[jmax];
 	else S[jmax] = damping * Sright + (1.0 - damping) * S[jmax];
       }
       cout << " to " << S[jmax] << endl;
 
       // Re-solve also for a random j, given by
-      //int jrand = int(maxabsLHSRE * 1.0e+6) % Nlevels;
       int jrand = rand() % Nlevels;
       cout << "identified jrand = " << jrand << endl;
       cout << "S[jrand]: from " << S[jrand];
 
       if (Solve_Richardson_Quad_S (g_int, epsilon, sumoneovereps, S, sumSovereps, jrand, Sleft, Sright)) {
-	//if (leftroot[jrand] == true) S[jrand] = damping * Sleft + (1.0 - damping) * S[jrand];
-	//else S[jrand] = damping * Sright + (1.0 - damping) * S[jrand];
 	if (abs(S[jrand] - Sleft) < abs(S[jrand] - Sright)) S[jrand] = damping * Sleft + (1.0 - damping) * S[jrand];
 	else S[jrand] = damping * Sright + (1.0 - damping) * S[jrand];
       }
       }
       cout << " to " << S[jrand] << endl;
 
-      /*
-      for (int j = 0; j < Nlevels; ++j) {
-	if (Solve_Richardson_Quad_S (g_int, epsilon, sumoneovereps, S, sumSovereps, j, Sleft, Sright)) {
-	  if (leftroot[j] == true) S[j] = damping * Sleft + (1.0 - damping) * S[j];
-	  else S[j] = damping * Sright + (1.0 - damping) * S[j];
-	}
-	else {
-	  ABACUSerror("Complex root.");
-	}
-      }
-      */
-
       // Recalculate all sums:
       for (int j = 0; j < Nlevels; ++j) {
 	sumSovereps[j] = 0.0;
   }
 
 
-
-
 } // namespace ABACUS