Commit 3fb612b3 authored by gbalduzz's avatar gbalduzz
Browse files

Merge remote-tracking branch 'origin/master' into rearrange_g4

parents 300fb778 3db9256c

include/dca/phys/dca_step/cluster_solver/ctaux/accumulator/tp/tp_equal_time_accumulator.hpp

+61 −40
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
// See CITATION.md for citation guidelines, if DCA++ is used for scientific publications.

//

// Author: Peter Staar (taa@zurich.ibm.com)

//         Giovanni Balduzzi (gbalduzz@itp.phys.ethz.ch)

//

// This class measures the equal time operator functions.
@@ -25,12 +26,12 @@ 
#include "dca/math/interpolation/akima_interpolation.hpp"

#include "dca/phys/dca_step/cluster_solver/ctaux/structs/vertex_singleton.hpp"

#include "dca/phys/domains/cluster/cluster_domain.hpp"

#include "dca/phys/domains/cluster/cluster_domain_aliases.hpp"

#include "dca/phys/domains/quantum/electron_band_domain.hpp"

#include "dca/phys/domains/quantum/electron_spin_domain.hpp"

#include "dca/phys/domains/time_and_frequency/time_domain.hpp"

#include "dca/phys/domains/time_and_frequency/time_domain_left_oriented.hpp"

#include "dca/phys/domains/time_and_frequency/vertex_time_domain.hpp"

#include "dca/phys/domains/cluster/cluster_domain_aliases.hpp"

#include "dca/util/plot.hpp"



namespace dca {
@@ -72,10 +73,12 @@ public: 
public:

  TpEqualTimeAccumulator(parameters_type& parameters_ref, MOMS_type& MOMS_ref, int id);



  void initialize();

  void resetAccumulation();



  void finalize();



  void sumTo(TpEqualTimeAccumulator<parameters_type, MOMS_type>& other) const;



  func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>>& get_G_r_t() {

    return G_r_t;

  }
@@ -105,6 +108,14 @@ public: 


  void accumulate_dwave_pp_correlator(double sign);



  // Accumulate all relevant quantities. This is equivalent to calling compute_G_r_t followed by all

  // the accumulation methods.

  template <class configuration_type, typename RealInp>

  void accumulateAll(const configuration_type& configuration_e_up,

                     const dca::linalg::Matrix<RealInp, dca::linalg::CPU>& M_up,

                     const configuration_type& configuration_e_dn,

                     const dca::linalg::Matrix<RealInp, dca::linalg::CPU>& M_dn, int sign);



  double get_GFLOP();



private:
@@ -241,7 +252,21 @@ TpEqualTimeAccumulator<parameters_type, MOMS_type>::TpEqualTimeAccumulator( 
      charge_cluster_moment("charge-cluster-moment"),

      magnetic_cluster_moment("magnetic-cluster-moment"),



      dwave_pp_correlator("dwave-pp-correlator") {}

      dwave_pp_correlator("dwave-pp-correlator") {

  for (int k_ind = 0; k_ind < k_dmn_t::dmn_size(); k_ind++)

    dwave_k_factor(k_ind) =

        cos(k_dmn_t::get_elements()[k_ind][0]) - cos(k_dmn_t::get_elements()[k_ind][1]);



  math::transform::FunctionTransform<k_dmn_t, r_dmn_t>::execute(dwave_k_factor, dwave_r_factor);



  initialize_my_configuration();



  initialize_akima_coefficients();



  initialize_G0_indices();



  initialize_G0_original();

}



template <class parameters_type, class MOMS_type>

double TpEqualTimeAccumulator<parameters_type, MOMS_type>::get_GFLOP() {
@@ -251,7 +276,7 @@ double TpEqualTimeAccumulator<parameters_type, MOMS_type>::get_GFLOP() { 
}



template <class parameters_type, class MOMS_type>

void TpEqualTimeAccumulator<parameters_type, MOMS_type>::initialize() {

void TpEqualTimeAccumulator<parameters_type, MOMS_type>::resetAccumulation() {

  GFLOP = 0;



  G_r_t = 0;
@@ -264,36 +289,6 @@ void TpEqualTimeAccumulator<parameters_type, MOMS_type>::initialize() { 
  magnetic_cluster_moment = 0;



  dwave_pp_correlator = 0;



  {

    for (int k_ind = 0; k_ind < k_dmn_t::dmn_size(); k_ind++)

      dwave_k_factor(k_ind) =

          cos(k_dmn_t::get_elements()[k_ind][0]) - cos(k_dmn_t::get_elements()[k_ind][1]);



    math::transform::FunctionTransform<k_dmn_t, r_dmn_t>::execute(dwave_k_factor, dwave_r_factor);



    /*

    if(thread_id==0)

      {

        std::cout << "\n\n";

        for(int r_ind=0; r_ind<r_dmn_t::dmn_size(); r_ind++)

          std::cout << "\t" << r_ind

               << "\t" << r_dmn_t::get_elements()[r_ind][0]

               << "\t" << r_dmn_t::get_elements()[r_ind][1]

               << "\t" << dwave_r_factor(r_ind) << "\n";



        std::cout << "\n\n";

      }

    */

  }



  initialize_my_configuration();



  initialize_akima_coefficients();



  initialize_G0_indices();



  initialize_G0_original();

}



template <class parameters_type, class MOMS_type>
@@ -694,8 +689,7 @@ void TpEqualTimeAccumulator<parameters_type, MOMS_type>::accumulate_moments(doub 


        double charge_val = G_r_t_up(i, j) * G_r_t_dn(i, j);  // double occupancy = <n_d*n_u>

        double magnetic_val =

            1. -

            2. * G_r_t_up(i, j) * G_r_t_dn(i, j);  // <m^2> = 1-2*<n_d*n_u> (T. Paiva, PRB 2001)

            1. - 2. * G_r_t_up(i, j) * G_r_t_dn(i, j);  // <m^2> = 1-2*<n_d*n_u> (T. Paiva, PRB 2001)



        charge_cluster_moment(b_ind, r_i) += sign * charge_val / t_VERTEX::dmn_size();

        magnetic_cluster_moment(b_ind, r_i) += sign * magnetic_val / t_VERTEX::dmn_size();
@@ -893,9 +887,36 @@ inline double TpEqualTimeAccumulator<parameters_type, MOMS_type>::interpolate_ak 
  return result;

}



}  // ctaux

}  // solver

}  // phys

}  // dca

template <class parameters_type, class MOMS_type>

template <class configuration_type, typename RealInp>

void TpEqualTimeAccumulator<parameters_type, MOMS_type>::accumulateAll(

    const configuration_type& configuration_e_up,

    const dca::linalg::Matrix<RealInp, dca::linalg::CPU>& M_up,

    const configuration_type& configuration_e_dn,

    const dca::linalg::Matrix<RealInp, dca::linalg::CPU>& M_dn, int sign) {

  compute_G_r_t(configuration_e_up, M_up, configuration_e_dn, M_dn);



  accumulate_G_r_t(sign);



  accumulate_moments(sign);



  accumulate_dwave_pp_correlator(sign);

}



template <class parameters_type, class MOMS_type>

void TpEqualTimeAccumulator<parameters_type, MOMS_type>::sumTo(

    dca::phys::solver::ctaux::TpEqualTimeAccumulator<parameters_type, MOMS_type>& other) const {

  other.G_r_t_accumulated += G_r_t_accumulated;

  other.G_r_t_accumulated_squared += G_r_t_accumulated_squared;

  other.charge_cluster_moment += charge_cluster_moment;

  other.magnetic_cluster_moment += magnetic_cluster_moment;

  other.dwave_pp_correlator += dwave_pp_correlator;

  other.GFLOP += GFLOP;

}



}  // namespace ctaux

}  // namespace solver

}  // namespace phys

}  // namespace dca



#endif  // DCA_PHYS_DCA_STEP_CLUSTER_SOLVER_CTAUX_ACCUMULATOR_TP_TP_EQUAL_TIME_ACCUMULATOR_HPP

include/dca/phys/dca_step/cluster_solver/ctaux/ctaux_accumulator.hpp

+48 −78
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ 
//

// Author: Peter Staar (taa@zurich.ibm.com)

//         Raffaele Solca' (rasolca@itp.phys.ethz.ch)

//         Giovanni Balduzzi (gbalduzz@itp.phys.ethz.ch)

//

// This class organizes the measurements in the CT-AUX QMC.
@@ -23,14 +24,14 @@ 
#include "dca/function/function.hpp"

#include "dca/linalg/matrix.hpp"

#include "dca/linalg/util/cuda_event.hpp"

#include "dca/phys/dca_step/cluster_solver/shared_tools/accumulation/tp/tp_accumulator.hpp"

#include "dca/phys/dca_step/cluster_solver/shared_tools/accumulation/sp/sp_accumulator.hpp"

#include "dca/phys/dca_step/cluster_solver/ctaux/accumulator/tp/tp_equal_time_accumulator.hpp"

#include "dca/phys/dca_step/cluster_solver/ctaux/domains/feynman_expansion_order_domain.hpp"

#include "dca/phys/dca_step/cluster_solver/ctaux/structs/ct_aux_hs_configuration.hpp"

#include "dca/phys/dca_step/cluster_solver/ctaux/structs/vertex_pair.hpp"

#include "dca/phys/dca_step/cluster_solver/ctaux/structs/vertex_singleton.hpp"

#include "dca/phys/dca_step/cluster_solver/shared_tools/accumulation/mc_accumulator_data.hpp"

#include "dca/phys/dca_step/cluster_solver/shared_tools/accumulation/sp/sp_accumulator.hpp"

#include "dca/phys/dca_step/cluster_solver/shared_tools/accumulation/tp/tp_accumulator.hpp"

#include "dca/phys/domains/cluster/cluster_domain.hpp"

#include "dca/phys/domains/quantum/electron_band_domain.hpp"

#include "dca/phys/domains/quantum/electron_spin_domain.hpp"
@@ -93,8 +94,8 @@ public: 


  void measure();



  // Sums all accumulated objects of this accumulator to the equivalent objects of the 'other'

  // accumulator.

  // Sums all accumulated objects of this accumulator to the equivalent objects

  // of the 'other' accumulator.

  void sumTo(this_type& other);



  void finalize();
@@ -110,21 +111,22 @@ public: 
  }



  // equal time-measurements

  // TODO: Make equal time getters const.

  func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>>& get_G_r_t() {

    return G_r_t;

    return equal_time_accumulator_.get_G_r_t();

  }

  func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>>& get_G_r_t_stddev() {

    return G_r_t_stddev;

    return equal_time_accumulator_.get_G_r_t_stddev();

  }



  func::function<double, func::dmn_variadic<b, r_dmn_t>>& get_charge_cluster_moment() {

    return charge_cluster_moment;

    return equal_time_accumulator_.get_charge_cluster_moment();

  }

  func::function<double, func::dmn_variadic<b, r_dmn_t>>& get_magnetic_cluster_moment() {

    return magnetic_cluster_moment;

    return equal_time_accumulator_.get_magnetic_cluster_moment();

  }

  func::function<double, func::dmn_variadic<b, r_dmn_t>>& get_dwave_pp_correlator() {

    return dwave_pp_correlator;

    return equal_time_accumulator_.get_dwave_pp_correlator();

  }



  // sp-measurements
@@ -196,18 +198,11 @@ protected: 
  func::function<double, func::dmn_0<domains::numerical_error_domain>> error;

  func::function<double, func::dmn_0<Feynman_expansion_order_domain>> visited_expansion_order_k;



  func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>> G_r_t;

  func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>> G_r_t_stddev;



  func::function<double, func::dmn_variadic<b, r_dmn_t>> charge_cluster_moment;

  func::function<double, func::dmn_variadic<b, r_dmn_t>> magnetic_cluster_moment;

  func::function<double, func::dmn_variadic<b, r_dmn_t>> dwave_pp_correlator;



  func::function<std::complex<double>, func::dmn_variadic<nu, nu, r_dmn_t, w>> M_r_w_stddev;



  accumulator::SpAccumulator<Parameters, device_t> single_particle_accumulator_obj;



  ctaux::TpEqualTimeAccumulator<Parameters, Data> MC_two_particle_equal_time_accumulator_obj;

  ctaux::TpEqualTimeAccumulator<Parameters, Data> equal_time_accumulator_;



  accumulator::TpAccumulator<Parameters, device_t> two_particle_accumulator_;
@@ -231,27 +226,22 @@ CtauxAccumulator<device_t, Parameters, Data>::CtauxAccumulator(Parameters& param 
      error("numerical-error-distribution-of-N-matrices"),

      visited_expansion_order_k("<k>"),



      G_r_t("G_r_t_measured"),

      G_r_t_stddev("G_r_t_stddev"),



      charge_cluster_moment("charge-cluster-moment"),

      magnetic_cluster_moment("magnetic-cluster-moment"),

      dwave_pp_correlator("dwave-pp-correlator"),



      M_r_w_stddev("M_r_w_stddev"),



      single_particle_accumulator_obj(parameters_, compute_std_deviation_),



      MC_two_particle_equal_time_accumulator_obj(parameters_, data_, id),

      equal_time_accumulator_(parameters_, data_, id),



      two_particle_accumulator_(data_.G0_k_w_cluster_excluded, parameters_) {}



template <dca::linalg::DeviceType device_t, class Parameters, class Data>

void CtauxAccumulator<device_t, Parameters, Data>::initialize(int dca_iteration) {

  // Note: profiling this function breaks the PAPI profiler as both the master thread and the first

  // Note: profiling this function breaks the PAPI profiler as both the master

  // thread and the first

  // worker call this with the same thread_id.

  // TODO: fix thread id assignment.

  //  profiler_type profiler(__FUNCTION__, "CT-AUX accumulator", __LINE__, thread_id);

  //  profiler_type profiler(__FUNCTION__, "CT-AUX accumulator", __LINE__,

  //  thread_id);



  MC_accumulator_data::initialize(dca_iteration);
@@ -266,16 +256,8 @@ void CtauxAccumulator<device_t, Parameters, Data>::initialize(int dca_iteration) 
  if (perform_tp_accumulation_)

    two_particle_accumulator_.resetAccumulation(dca_iteration);



  if (parameters_.additional_time_measurements()) {

    G_r_t = 0.;

    G_r_t_stddev = 0.;



    charge_cluster_moment = 0;

    magnetic_cluster_moment = 0;

    dwave_pp_correlator = 0;



    MC_two_particle_equal_time_accumulator_obj.initialize();

  }

  if (parameters_.additional_time_measurements())

    equal_time_accumulator_.resetAccumulation();

}



template <dca::linalg::DeviceType device_t, class Parameters, class Data>
@@ -296,17 +278,8 @@ void CtauxAccumulator<device_t, Parameters, Data>::finalize() { 
    M_r_w_stddev *= factor;

  }



  if (parameters_.additional_time_measurements()) {

    MC_two_particle_equal_time_accumulator_obj.finalize();  // G_r_t, G_r_t_stddev);



    G_r_t = MC_two_particle_equal_time_accumulator_obj.get_G_r_t();

    G_r_t_stddev = MC_two_particle_equal_time_accumulator_obj.get_G_r_t_stddev();



    charge_cluster_moment = MC_two_particle_equal_time_accumulator_obj.get_charge_cluster_moment();

    magnetic_cluster_moment =

        MC_two_particle_equal_time_accumulator_obj.get_magnetic_cluster_moment();

    dwave_pp_correlator = MC_two_particle_equal_time_accumulator_obj.get_dwave_pp_correlator();

  }

  if (parameters_.additional_time_measurements())

    equal_time_accumulator_.finalize();



  if (perform_tp_accumulation_)

    two_particle_accumulator_.finalize();
@@ -336,19 +309,20 @@ void CtauxAccumulator<device_t, Parameters, Data>::write(Writer& writer) { 
  //       writer.execute(M_r_w_stddev);



  if (parameters_.additional_time_measurements()) {

    writer.execute(charge_cluster_moment);

    writer.execute(magnetic_cluster_moment);

    writer.execute(dwave_pp_correlator);

    writer.execute(get_charge_cluster_moment());

    writer.execute(get_magnetic_cluster_moment());

    writer.execute(get_dwave_pp_correlator());



    writer.execute(G_r_t);

    writer.execute(G_r_t_stddev);

    writer.execute(get_G_r_t());

    writer.execute(get_G_r_t_stddev());

  }



  //       writer.close_group();

}



/*!

 *  \brief Get all the information from the walker in order to start a measurement.

 *  \brief Get all the information from the walker in order to start a

 * measurement.

 *

 *   \f{eqnarray}{

 *    M_{i,j} &=& (e^{V_i}-1) N_{i,j}
@@ -405,11 +379,14 @@ void CtauxAccumulator<device_t, Parameters, Data>::measure() { 
/*!

 *  \brief Output and store standard deviation and error.

 *

 *  It computes and write to the given files the standard deviation of the measurements of the one

 *  It computes and write to the given files the standard deviation of the

 * measurements of the one

 * particle accumulator.

 *  It outputs the L1-Norm, i.e. \f$\sum_{i=1}^N \left|x_i\right|/N\f$, the L2-Norm, i.e.

 *  It outputs the L1-Norm, i.e. \f$\sum_{i=1}^N \left|x_i\right|/N\f$, the

 * L2-Norm, i.e.

 * \f$\sqrt{\sum_{i=1}^N \left|x_i\right|^2/N}\f$,

 *  and the Linf-Norm, i.e. \f$\max_{i=1}^N \left|x_i\right|\f$ of the standard deviation and of the

 *  and the Linf-Norm, i.e. \f$\max_{i=1}^N \left|x_i\right|\f$ of the standard

 * deviation and of the

 * error.

 */

template <dca::linalg::DeviceType device_t, class Parameters, class Data>
@@ -419,7 +396,8 @@ void CtauxAccumulator<device_t, Parameters, Data>::store_standard_deviation( 
}



/*!

 *  \brief Update the sum of the squares of the measurements of the single particle accumulator.

 *  \brief Update the sum of the squares of the measurements of the single

 * particle accumulator.

 *         It has to be called after each measurement.

 */

template <dca::linalg::DeviceType device_t, class Parameters, class Data>
@@ -471,16 +449,10 @@ void CtauxAccumulator<device_t, Parameters, Data>::accumulate_equal_time_quantit 
template <dca::linalg::DeviceType device_t, class Parameters, class Data>

void CtauxAccumulator<device_t, Parameters, Data>::accumulate_equal_time_quantities(

    const std::array<linalg::Matrix<AccumType, linalg::CPU>, 2>& M) {

  MC_two_particle_equal_time_accumulator_obj.compute_G_r_t(hs_configuration_[0], M[0],

                                                           hs_configuration_[1], M[1]);



  MC_two_particle_equal_time_accumulator_obj.accumulate_G_r_t(current_sign);



  MC_two_particle_equal_time_accumulator_obj.accumulate_moments(current_sign);



  MC_two_particle_equal_time_accumulator_obj.accumulate_dwave_pp_correlator(current_sign);

  equal_time_accumulator_.accumulateAll(hs_configuration_[0], M[0], hs_configuration_[1], M[1],

                                        current_sign);



  GFLOP += MC_two_particle_equal_time_accumulator_obj.get_GFLOP();

  GFLOP += equal_time_accumulator_.get_GFLOP();

}



/*************************************************************
@@ -505,24 +477,22 @@ void CtauxAccumulator<device_t, Parameters, Data>::sumTo(this_type& other) { 
  other.get_visited_expansion_order_k() += visited_expansion_order_k;

  other.get_error_distribution() += error;



  // equal time measurements

  other.get_G_r_t() += G_r_t;

  other.get_G_r_t_stddev() += G_r_t_stddev;

  other.get_charge_cluster_moment() += charge_cluster_moment;

  other.get_magnetic_cluster_moment() += magnetic_cluster_moment;

  other.get_dwave_pp_correlator() += dwave_pp_correlator;



  // sp-measurements

  single_particle_accumulator_obj.sumTo(other.single_particle_accumulator_obj);



  // equal time measurements

  if (DCA_iteration == parameters_.get_dca_iterations() - 1 &&

      parameters_.additional_time_measurements())

    equal_time_accumulator_.sumTo(other.equal_time_accumulator_);



  // tp-measurements

  if (perform_tp_accumulation_)

    two_particle_accumulator_.sumTo(other.two_particle_accumulator_);

}



}  // ctaux

}  // solver

}  // phys

}  // dca

}  // namespace ctaux

}  // namespace solver

}  // namespace phys

}  // namespace dca



#endif  // DCA_PHYS_DCA_STEP_CLUSTER_SOLVER_CTAUX_CTAUX_ACCUMULATOR_HPP

include/dca/phys/dca_step/cluster_solver/shared_tools/accumulation/tp/tp_accumulator.hpp

+6 −8
Original line number Diff line number Diff line
@@ -79,7 +79,6 @@ protected: 
      func::dmn_variadic<BDmn, BDmn, BDmn, BDmn, KDmn, KDmn, KExchangeDmn, WTpDmn, WTpDmn, WExchangeDmn>;



public:



  // Constructor:

  // In: G0: non interacting greens function.

  // In: pars: parameters object.
@@ -121,7 +120,6 @@ public: 
  }



protected:



  void initializeG0();



  double computeG();
@@ -447,7 +445,7 @@ double TpAccumulator<Parameters, linalg::CPU>::updateG4(TpGreensFunction& G4) { 
              const int k_ex = exchange_mom[k_ex_idx];

              for (int k2 = 0; k2 < KDmn::dmn_size(); ++k2)

                for (int k1 = 0; k1 < KDmn::dmn_size(); ++k1) {

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, k2, k_ex_idx, w1, w2, w_ex_idx);

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, w1, k2, w2, k_ex_idx, w_ex_idx);

                  for (int s = 0; s < 2; ++s)

                    updateG4Atomic(G4_ptr, s, k1, k2, w1, w2, not s, momentum_sum(k2, k_ex),

                                   momentum_sum(k1, k_ex), w_plus_w_ex(w2, w_ex),
@@ -472,7 +470,7 @@ double TpAccumulator<Parameters, linalg::CPU>::updateG4(TpGreensFunction& G4) { 
            for (int k2 = 0; k2 < KDmn::dmn_size(); ++k2)

              for (int w1 = 0; w1 < WTpDmn::dmn_size(); ++w1)

                for (int k1 = 0; k1 < KDmn::dmn_size(); ++k1) {

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, k2, k_ex_idx, w1, w2, w_ex_idx);

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, w1, k2, w2, k_ex_idx, w_ex_idx);

                  updateG4SpinDifference(G4_ptr, -1, k1, momentum_sum(k1, k_ex), w1,

                                         w_plus_w_ex(w1, w_ex), momentum_sum(k2, k_ex), k2,

                                         w_plus_w_ex(w2, w_ex), w2, sign_over_2, false);
@@ -500,7 +498,7 @@ double TpAccumulator<Parameters, linalg::CPU>::updateG4(TpGreensFunction& G4) { 
            for (int k2 = 0; k2 < KDmn::dmn_size(); ++k2)

              for (int w1 = 0; w1 < WTpDmn::dmn_size(); ++w1)

                for (int k1 = 0; k1 < KDmn::dmn_size(); ++k1) {

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, k2, k_ex_idx, w1, w2, w_ex_idx);

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, w1, k2, w2, k_ex_idx, w_ex_idx);

                  updateG4SpinDifference(G4_ptr, 1, k1, momentum_sum(k1, k_ex), w1,

                                         w_plus_w_ex(w1, w_ex), momentum_sum(k2, k_ex), k2,

                                         w_plus_w_ex(w2, w_ex), w2, sign_over_2, false);
@@ -527,7 +525,7 @@ double TpAccumulator<Parameters, linalg::CPU>::updateG4(TpGreensFunction& G4) { 
            for (int k2 = 0; k2 < KDmn::dmn_size(); ++k2)

              for (int w1 = 0; w1 < WTpDmn::dmn_size(); ++w1)

                for (int k1 = 0; k1 < KDmn::dmn_size(); ++k1) {

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, k2, k_ex_idx, w1, w2, w_ex_idx);

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, w1, k2, w2, k_ex_idx, w_ex_idx);



                  for (int s = 0; s < 2; ++s)

                    updateG4Atomic(G4_ptr, s, k1, momentum_sum(k1, k_ex), w1, w_plus_w_ex(w1, w_ex),
@@ -555,7 +553,7 @@ double TpAccumulator<Parameters, linalg::CPU>::updateG4(TpGreensFunction& G4) { 
              const int k_ex = exchange_mom[k_ex_idx];

              for (int k2 = 0; k2 < KDmn::dmn_size(); ++k2)

                for (int k1 = 0; k1 < KDmn::dmn_size(); ++k1) {

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, k2, k_ex_idx, w1, w2, w_ex_idx);

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, w1, k2, w2, k_ex_idx, w_ex_idx);

                  for (int s = 0; s < 2; ++s)

                    updateG4Atomic(G4_ptr, s, k1, momentum_sum(k1, k_ex), w1, w_plus_w_ex(w1, w_ex),

                                   !s, momentum_sum(k2, k_ex), k2, w_plus_w_ex(w2, w_ex), w2,
@@ -577,7 +575,7 @@ double TpAccumulator<Parameters, linalg::CPU>::updateG4(TpGreensFunction& G4) { 
            for (int k2 = 0; k2 < KDmn::dmn_size(); ++k2)

              for (int w1 = 0; w1 < WTpDmn::dmn_size(); ++w1)

                for (int k1 = 0; k1 < KDmn::dmn_size(); ++k1) {

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, k2, k_ex_idx, w1, w2, w_ex_idx);

                  Complex* const G4_ptr = &G4(0, 0, 0, 0, k1, w1, k2, w2, k_ex_idx, w_ex_idx);

                  for (int s = 0; s < 2; ++s)

                    updateG4Atomic(G4_ptr, s, k1, k2, w1, w2, !s, q_minus_k(k1, k_ex),

                                   q_minus_k(k2, k_ex), w_ex_minus_w(w1, w_ex),

test/unit/phys/dca_step/cluster_solver/CMakeLists.txt

+1 −1
Original line number Diff line number Diff line 
# test/unit/phys/dca_step/cluster_solver



add_subdirectory(ctaux/structs)

add_subdirectory(ctaux)

add_subdirectory(shared_tools)

add_subdirectory(thread_qmci)

test/unit/phys/dca_step/cluster_solver/ctaux/CMakeLists.txt

0 → 100644
+4 −0
Original line number Diff line number Diff line 
# test/unit/phys/dca_step/cluster_solver/ctaux



add_subdirectory(accumulator/tp)

add_subdirectory(structs)