Clang-format all source files

Author: Wentzell

c++/triqs_ctseg-J/configuration.cpp

@@ -226,7 +226,7 @@ double K_overlap(std::vector<segment_t> const &seglist, tau_t const &tau, bool i
 // List of operators containing all colors.
 // Time are ordered in decreasing order, in agreement with the whole physic literature.
 std::vector<colored_ops_t> colored_ordered_ops(std::vector<std::vector<segment_t>> const &seglists) {
-  int c = 0;  // index of color
+  int c = 0;                           // index of color
   std::vector<colored_ops_t> ops_list; // list of all the operators
   for (auto const &seglist : seglists) {
     for (auto const &s : seglist) {
@@ -275,7 +275,7 @@ std::ostream &operator<<(std::ostream &out, configuration_t const &config) {
 
 std::ostream &operator<<(std::ostream &out, std::vector<colored_ops_t> const &col) {
   for (auto const &[i, co] : itertools::enumerate(col))
-    out << "\n" << "i: " << i << ", tau: " << co.tau << ", color: " << co.color 
-        << ", " << (co.is_cdag ? "cdag" : "c");
+    out << "\n"
+        << "i: " << i << ", tau: " << co.tau << ", color: " << co.color << ", " << (co.is_cdag ? "cdag" : "c");
   return out;
 }

c++/triqs_ctseg-J/configuration.hpp

@@ -11,17 +11,17 @@
 // ================= Data structures =================
 
 // The configuration is made of n_color ordered lists of segments
-// and (if needed) a list of J_perp lines. 
+// and (if needed) a list of J_perp lines.
 
 // --------------- Segment -------------------
 //
 // A segment represents a couple (c, cdag), at given tau_t times in [0, beta]
-// Segment is cyclic if tau_c < tau_cdag, non-cyclic otherwise. 
+// Segment is cyclic if tau_c < tau_cdag, non-cyclic otherwise.
 //
 // Some segments are aligned between 2 colors, corresponding to a S^+, S^- operators
 // The S operators will not be linked to Delta, the hybridization, but to Jperp lines.
-// The segment stores two booleans (J_c, J_cdag) that indicate whether its operators are 
-// linked to J_perp lines. 
+// The segment stores two booleans (J_c, J_cdag) that indicate whether its operators are
+// linked to J_perp lines.
 //
 // Special case : full lines.
 // When a line has no operator, we need to take into account 2 states : empty or full.
@@ -45,8 +45,8 @@ using vec_seg_iter_t = std::vector<segment_t>::const_iterator;
 
 // ----------------- J_perp line -------------------
 // Stores the times of a couple (S+, S-)
-// Note: J_perp expansion only implemented for single orbital 
-// (two colors, spin up and spin down). 
+// Note: J_perp expansion only implemented for single orbital
+// (two colors, spin up and spin down).
 struct jperp_line_t {
   tau_t tau_Sminus, tau_Splus; // times of the S-, S+
 };
@@ -60,7 +60,7 @@ struct colored_ops_t {
 };
 
 // --------------- Configuration ----------------------
-// The configuration is a list of of segments for each color, 
+// The configuration is a list of of segments for each color,
 // and a list of J_perp lines.
 struct configuration_t {
   // A list of segments for each color.

c++/triqs_ctseg-J/dets.hpp

@@ -9,7 +9,7 @@ using namespace triqs::mesh;
 
 /// A lambda to adapt Delta(tau) for the call by det_manip.
 struct delta_block_adaptor {
-  gf<imtime, matrix_real_valued> delta; 
+  gf<imtime, matrix_real_valued> delta;
 
   double operator()(std::pair<tau_t, int> const &x, std::pair<tau_t, int> const &y) const {
     double res = delta(double(x.first - y.first))(x.second, y.second);

c++/triqs_ctseg-J/invariants.cpp

@@ -28,7 +28,7 @@ void check_segments(configuration_t const &config) {
 
 void check_dets(configuration_t const &config, work_data_t const &wdata) {
   for (auto bl : range(wdata.dets.size())) {
-    auto const &D  = wdata.dets[bl];
+    auto const &D    = wdata.dets[bl];
     auto const n_orb = wdata.gf_struct[bl].second;
     // Times in det must be ordered
     if (D.size() != 0) {
@@ -47,21 +47,21 @@ void check_dets(configuration_t const &config, work_data_t const &wdata) {
         long det_index_c = 0, det_index_cdag = 0;
         for (auto const &seg : sl) {
           if (not seg.J_c and !is_full_line(seg)) {
-            ALWAYS_EXPECTS(D.size() != 0, "Det error, block {}: there is a hybridized c but det is empty. Config: {}", bl,
-                          config);
+            ALWAYS_EXPECTS(D.size() != 0, "Det error, block {}: there is a hybridized c but det is empty. Config: {}",
+                           bl, config);
             auto det_c_time = [&](long i) { return D.get_y(i).first; };
             det_index_c     = lower_bound(det_c_time, D.size(), seg.tau_c);
             ALWAYS_EXPECTS(det_c_time(det_index_c) == seg.tau_c,
-                          "Det error, block {}: tau_c = {} is not in det! Config: {}", bl, seg.tau_c, config);
+                           "Det error, block {}: tau_c = {} is not in det! Config: {}", bl, seg.tau_c, config);
             ++n_hyb_c;
           }
           if (not seg.J_cdag and !is_full_line(seg)) {
-            ALWAYS_EXPECTS(D.size() != 0, "Det error, block {}: there is a hybridized cdag but det is empty. Config: {}",
-                          bl, config);
+            ALWAYS_EXPECTS(D.size() != 0,
+                           "Det error, block {}: there is a hybridized cdag but det is empty. Config: {}", bl, config);
             auto det_cdag_time = [&](long i) { return D.get_x(i).first; };
             det_index_cdag     = lower_bound(det_cdag_time, D.size(), seg.tau_cdag);
             ALWAYS_EXPECTS(det_cdag_time(det_index_cdag) == seg.tau_cdag,
-                          "Det error, block {}: tau_cdag = {} is not in det! Config: {}", bl, seg.tau_cdag, config);
+                           "Det error, block {}: tau_cdag = {} is not in det! Config: {}", bl, seg.tau_cdag, config);
             ++n_hyb_cdag;
           }
         }

c++/triqs_ctseg-J/logs.hpp

@@ -11,7 +11,7 @@ static constexpr bool ctseg_debug = false;
 #ifdef PRINT_LOGS
 static constexpr bool print_logs = true;
 #else
-static constexpr bool print_logs  = false;
+static constexpr bool print_logs = false;
 #endif
 
 #include <fmt/format.h>

c++/triqs_ctseg-J/measures/g_f_tau.cpp

@@ -40,7 +40,7 @@ namespace measures {
           auto val  = (y.first >= x.first ? s : -s) * Minv;
           auto dtau = double(y.first - x.first);
           g[closest_mesh_pt(dtau)](y.second, x.second) += val;
-          if (measure_ft) f[closest_mesh_pt(dtau)](y.second, x.second) += val * f_fact; 
+          if (measure_ft) f[closest_mesh_pt(dtau)](y.second, x.second) += val * f_fact;
         }
       }
     }

c++/triqs_ctseg-J/measures/perturbation_order_histo.cpp

@@ -7,8 +7,8 @@ namespace measures {
                                                      configuration_t const &config, results_t &results)
      : wdata{wdata}, config{config}, results{results} {
 
-    histo_delta = triqs::stat::histogram{0, p.histogram_max_order}; 
-    histo_Jperp = triqs::stat::histogram{0, p.histogram_max_order}; 
+    histo_delta = triqs::stat::histogram{0, p.histogram_max_order};
+    histo_Jperp = triqs::stat::histogram{0, p.histogram_max_order};
   }
 
   // -------------------------------------

c++/triqs_ctseg-J/measures/sign.cpp

@@ -7,21 +7,21 @@ namespace measures {
   sign::sign(params_t const &, work_data_t const &wdata, configuration_t const &config, results_t &results)
      : wdata{wdata}, config{config}, results{results} {
     Z = 0.0;
-    N = 0.0; 
+    N = 0.0;
   }
 
   // -------------------------------------
 
   void sign::accumulate(double s) {
     Z += s;
-    N += 1.0; 
+    N += 1.0;
   }
 
   // -------------------------------------
 
   void sign::collect_results(mpi::communicator const &c) {
-    Z        = mpi::all_reduce(Z, c);
-    N        = mpi::all_reduce(N, c);
+    Z            = mpi::all_reduce(Z, c);
+    N            = mpi::all_reduce(N, c);
     results.sign = Z / N;
   }
 } // namespace measures

c++/triqs_ctseg-J/measures/sign.hpp

@@ -11,7 +11,7 @@ namespace measures {
     configuration_t const &config;
     results_t &results;
 
-    double N = 0; 
+    double N = 0;
     double Z = 0;
 
     sign(params_t const &params, work_data_t const &wdata, configuration_t const &config, results_t &results);

c++/triqs_ctseg-J/measures/state_hist.cpp

@@ -6,8 +6,8 @@ namespace measures {
   state_hist::state_hist(params_t const &p, work_data_t const &wdata, configuration_t const &config, results_t &results)
      : wdata{wdata}, config{config}, results{results} {
 
-    beta    = p.beta;
-    H       = nda::zeros<double>(ipow(2, config.n_color()));
+    beta = p.beta;
+    H    = nda::zeros<double>(ipow(2, config.n_color()));
   }
 
   // -------------------------------------
@@ -26,19 +26,19 @@ namespace measures {
     *
     * - the length of the histogram is 2^n_colors
     */
-    
+
     Z += s;
 
-    double tau_prev = beta; // time of prevous operator; start with beta
+    double tau_prev         = beta; // time of prevous operator; start with beta
     nda::vector<bool> state = nda::zeros<bool>(config.n_color());
     for (auto const &op : colored_ordered_ops(config.seglists)) {
-        int state_idx = 0;
-        for (auto c : range(config.n_color())) 
-            if (state(c)) state_idx += ipow(2, c); // get the index of the impurity state
-        H(state_idx) += (tau_prev - op.tau);
-        tau_prev = (double)op.tau;
-        ALWAYS_EXPECTS((state(op.color) == op.is_cdag), "Operator error at color {}", op.color);
-        state(op.color) = !op.is_cdag;
+      int state_idx = 0;
+      for (auto c : range(config.n_color()))
+        if (state(c)) state_idx += ipow(2, c); // get the index of the impurity state
+      H(state_idx) += (tau_prev - op.tau);
+      tau_prev = (double)op.tau;
+      ALWAYS_EXPECTS((state(op.color) == op.is_cdag), "Operator error at color {}", op.color);
+      state(op.color) = !op.is_cdag;
     }
 
     // get edge state contribution; tau_prev has time of last operator

c++/triqs_ctseg-J/params.cpp

@@ -62,7 +62,6 @@ void h5_write(h5::group h5group, std::string subgroup_name, solve_params_t const
   h5_write(grp, "det_precision_error", c.det_precision_error);
   h5_write(grp, "det_singular_threshold", c.det_singular_threshold);
   h5_write(grp, "histogram_max_order", c.histogram_max_order);
-  
 }
 
 //------------------------------------
@@ -105,6 +104,4 @@ void h5_read(h5::group h5group, std::string subgroup_name, solve_params_t &c) {
   h5_read(grp, "det_precision_error", c.det_precision_error);
   h5_read(grp, "det_singular_threshold", c.det_singular_threshold);
   h5_read(grp, "histogram_max_order", c.histogram_max_order);
-
 }
-

c++/triqs_ctseg-J/params.hpp

@@ -131,8 +131,8 @@ struct solve_params_t {
   /// Bound for the determinant matrix being singular, abs(det) > singular_threshold. If <0, it is !isnormal(abs(det))
   double det_singular_threshold = -1;
 
-  /// Maximum order for the perturbation order histograms 
-  int histogram_max_order = 1000; 
+  /// Maximum order for the perturbation order histograms
+  int histogram_max_order = 1000;
 };
 
 /// A struct combining both constr_params_t and solve_params_t

c++/triqs_ctseg-J/results.hpp

@@ -14,16 +14,16 @@ struct results_t {
   /// Self-energy improved estimator :math:`F(\tau)`.
   std::optional<block_gf<imtime>> F_tau;
 
-  /// Density-density time correlation function :math:`\langle n_a(\tau) n_b(0) \rangle`.  
+  /// Density-density time correlation function :math:`\langle n_a(\tau) n_b(0) \rangle`.
   std::optional<gf<imtime>> nn_tau;
 
   /// Perpendicular spin-spin correlation function :math:`\langle s_x(\tau) s_x(0) \rangle`.
   std::optional<gf<imtime>> sperp_tau;
 
-  /// Density-density static correlation function :math:`\langle n_a(0) n_b(0) \rangle`. 
+  /// Density-density static correlation function :math:`\langle n_a(0) n_b(0) \rangle`.
   std::optional<nda::matrix<double>> nn_static;
 
-  /// Density per color. 
+  /// Density per color.
   nda::array<double, 1> densities;
 
   /// Delta perturbation order histogram
@@ -35,7 +35,7 @@ struct results_t {
   /// State histogram
   std::optional<nda::vector<double>> state_hist;
 
-  /// Average sign 
+  /// Average sign
   double sign;
 };
 

c++/triqs_ctseg-J/solver_core.cpp

@@ -46,12 +46,10 @@ void solver_core::solve(solve_params_t const &solve_params) {
 
   // Initialize work data
   work_data_t wdata{p, inputs, c};
-  // Initialize configuration 
+  // Initialize configuration
   configuration_t config{wdata.n_color};
   // Start from a non-empty configuration when Delta(tau) = 0
-  if (not wdata.has_delta) {
-    config.seglists[0].push_back(segment_t::full_line());
-  }
+  if (not wdata.has_delta) { config.seglists[0].push_back(segment_t::full_line()); }
 
   // ................   QMC  ...................
 

c++/triqs_ctseg-J/solver_core.hpp

@@ -25,14 +25,14 @@ class solver_core {
   /// Solver solve parameters (from last call)
   std::optional<solve_params_t> last_solve_params;
 
-  /// The set of results 
+  /// The set of results
   // Will be passed to measures and initialized by them.
   results_t results;
 
   /// Initialize the solver
   CPP2PY_ARG_AS_DICT solver_core(constr_params_t const &p);
 
-  /// Solve the impurity problem 
+  /// Solve the impurity problem
   CPP2PY_ARG_AS_DICT void solve(solve_params_t const &p);
 
   // Green's function views for Python interface

c++/triqs_ctseg-J/util.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-inline long modulo(long i, long N) { return (i + N)%N;}
+inline long modulo(long i, long N) { return (i + N) % N; }
 
 // Same as std::lower_bound, but i-th element of vector is returned by f[i]
 // f is called on 0:N strictly
@@ -28,6 +28,4 @@ long det_lower_bound_y(auto const &d, auto const &y) {
 }
 
 // Integer power
-constexpr unsigned int ipow(unsigned int n, unsigned int m) {
-  return m == 0 ? 1 : m == 1 ? n : n * ipow(n, m - 1);
-}
+constexpr unsigned int ipow(unsigned int n, unsigned int m) { return m == 0 ? 1 : m == 1 ? n : n * ipow(n, m - 1); }

c++/triqs_ctseg-J/work_data.cpp

@@ -131,7 +131,7 @@ work_data_t::work_data_t(params_t const &p, inputs_t const &inputs, mpi::communi
   // Is there a non-zero Delta(tau)?
   for (auto const &bl : range(inputs.delta.size())) {
     if (max_element(abs(inputs.delta[bl].data())) > 1.e-13) has_delta = true;
-    // Report if Delta(tau) has imaginary part. 
+    // Report if Delta(tau) has imaginary part.
     if (!is_gf_real(inputs.delta[bl], 1e-10)) {
       if (c.rank() == 0) {
         spdlog::info("WARNING: The Delta(tau) block number {} is not real in tau space", bl);
@@ -187,10 +187,10 @@ double trace_sign(work_data_t const &wdata) {
   // For every block, we compute the sign of the permutation that takes
   // [(c c_dag) (c c_dag) (c c_dag) ...] with the cdag and c in increasing time order
   // (the reference order of the det) to the  decreasing-time-and-color-ordered list
-  //  of operators (the order that makes the trace positive). 
-  // This is equivalent to computing the sign of the permutation that takes 
+  //  of operators (the order that makes the trace positive).
+  // This is equivalent to computing the sign of the permutation that takes
   // [(c_dag c) (c_dag c) (c_dag c) ...] with the cdag and c in increasing time order
-  // to the increasing time-and-color-ordered list of operators. 
+  // to the increasing time-and-color-ordered list of operators.
   for (auto bl : range(dets.size())) {
     auto s              = long(dets[bl].size());
     auto n_colors_in_bl = wdata.gf_struct[bl].second;
@@ -250,9 +250,9 @@ double trace_sign(work_data_t const &wdata) {
           } // if color == k
           idx_c--;
         } // loop over c
-      }   // loop over colors
-    }     // if block not empty
-  }       // loop over blocks
+      } // loop over colors
+    } // if block not empty
+  } // loop over blocks
   return sign;
 } // sign computation
 

test/c++/dynamical_U.cpp

@@ -57,7 +57,7 @@ TEST(CTSEGJ, Dynamical_U) {
   auto D0w  = gf<imfreq>({beta, Boson, n_iw}, {1, 1});
   auto D0t  = gf<imtime>({beta, Boson, param_constructor.n_tau}, {1, 1});
   D0w(om_) << 2 * l * l * w0 / (om_ * om_ - w0 * w0);
-  D0t()                                 = fourier(D0w);
+  D0t()                                    = fourier(D0w);
   Solver.D0_tau().data()(range::all, 0, 0) = D0t.data()(range::all, 0, 0);
   Solver.D0_tau().data()(range::all, 0, 1) = D0t.data()(range::all, 0, 0);
   Solver.D0_tau().data()(range::all, 1, 0) = D0t.data()(range::all, 0, 0);