Commit cca3e683 authored by gbalduzz's avatar gbalduzz
Browse files

Remove number of creatable and only create used non-interacting.

parent 25997e8d

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

+36 −35
Original line number Diff line number Diff line
@@ -113,7 +113,7 @@ public: 
  }



private:

  void add_non_interacting_spins_to_configuration();

  void addNonInteractingSpinsToMatrices();



  void generate_delayed_spins(int& single_spin_updates_todo);
@@ -277,6 +277,8 @@ private: 
  int warm_up_sweeps_done_;

  util::Accumulator<std::size_t> warm_up_expansion_order_;

  util::Accumulator<std::size_t> num_delayed_spins_;

  int currently_proposed_creations_ = 0;

  int currently_proposed_annihilations_ = 0;



  //  std::array<linalg::Matrix<Real, device_t>, 2> M_;

  std::array<linalg::Vector<Real, linalg::CPU>, 2> exp_v_minus_one_;
@@ -490,17 +492,17 @@ void CtauxWalker<device_t, Parameters, Data, Real>::doSweep() { 


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

void CtauxWalker<device_t, Parameters, Data, Real>::do_step(int& single_spin_updates_todo) {

  add_non_interacting_spins_to_configuration();

  configuration.prepare_configuration();



  {

  generate_delayed_spins(single_spin_updates_todo);



  addNonInteractingSpinsToMatrices();



  download_from_device();



  compute_Gamma_matrices();



  upload_to_device();

  }



  update_N_matrix_with_Gamma_matrix();
@@ -569,15 +571,12 @@ std::enable_if_t<dev_t == device_t && device_t == dca::linalg::CPU, void> CtauxW 
}



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

void CtauxWalker<device_t, Parameters, Data, Real>::add_non_interacting_spins_to_configuration() {

void CtauxWalker<device_t, Parameters, Data, Real>::addNonInteractingSpinsToMatrices() {

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



  Gamma_up.resizeNoCopy(0);

  Gamma_dn.resizeNoCopy(0);



  // shuffle the configuration + do some configuration checks

  configuration.shuffle_noninteracting_vertices();



  {  // update G0 for new shuffled vertices

     // profiler_type profiler("G0-matrix (update)", "CT-AUX walker", __LINE__, thread_id);
@@ -623,6 +622,7 @@ void CtauxWalker<device_t, Parameters, Data, Real>::generate_delayed_spins( 
          ? generateDelayedSpinsNeglectBennett(single_spin_updates_todo)

          : generateDelayedSpinsAbortAtBennett(single_spin_updates_todo);



  //  assert(single_spin_updates_proposed > 0);

  single_spin_updates_todo -= single_spin_updates_proposed;

  assert(single_spin_updates_todo >= 0);
@@ -638,15 +638,15 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsAbortAtBe 
  assert(single_spin_updates_todo > 0);



  const auto max_num_delayed_spins = parameters.get_max_submatrix_size();

  const auto num_non_interacting_spins_initial = configuration.get_number_of_creatable_HS_spins();



  delayed_spins.resize(0);



  int num_creations = 0;

  int num_annihilations = 0;

  int num_statics = 0;

  int single_spin_updates_proposed = 0;



  currently_proposed_annihilations_ = 0;

  currently_proposed_creations_ = 0;



  // Do the aborted annihilation proposal.

  if (annihilation_proposal_aborted_) {

    delayed_spin_struct delayed_spin;
@@ -663,7 +663,7 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsAbortAtBe 
      delayed_spin.new_HS_spin_value = HS_ZERO;



      delayed_spins.push_back(delayed_spin);

      ++num_annihilations;

      ++currently_proposed_annihilations_;

    }



    // Propose removal of a different vertex or do a static step if the configuration is empty.
@@ -676,7 +676,7 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsAbortAtBe 
        delayed_spin.new_HS_spin_value = HS_ZERO;



        delayed_spins.push_back(delayed_spin);

        ++num_annihilations;

        ++currently_proposed_annihilations_;

      }



      else {
@@ -689,8 +689,7 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsAbortAtBe 
  }



  // Generate more delayed spins.

  while (!annihilation_proposal_aborted_ && num_creations < num_non_interacting_spins_initial &&

         single_spin_updates_proposed < single_spin_updates_todo &&

  while (!annihilation_proposal_aborted_ && single_spin_updates_proposed < single_spin_updates_todo &&

         delayed_spins.size() < max_num_delayed_spins) {

    delayed_spin_struct delayed_spin;

    delayed_spin.is_accepted_move = false;
@@ -716,17 +715,18 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsAbortAtBe 


      if (!annihilation_proposal_aborted_) {

        delayed_spins.push_back(delayed_spin);

        ++num_annihilations;

        ++currently_proposed_annihilations_;

        ++single_spin_updates_proposed;

      }

    }



    else if (delayed_spin.HS_current_move == CREATION) {

      delayed_spin.random_vertex_ind = configuration.get_random_noninteracting_vertex(true);

      delayed_spin.random_vertex_ind = configuration.size();

      configuration.insert_random_noninteracting_vertex(true);

      delayed_spin.new_HS_spin_value = rng() > 0.5 ? HS_UP : HS_DN;



      delayed_spins.push_back(delayed_spin);

      ++num_creations;

      ++currently_proposed_creations_;

      ++single_spin_updates_proposed;

    }
@@ -736,7 +736,6 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsAbortAtBe 
      ++single_spin_updates_proposed;

    }

  }



  // We need to unmark all "virtual" interacting spins, that we have temporarily marked as

  // annihilatable in CT_AUX_HS_configuration::get_random_noninteracting_vertex().

  // TODO: Eliminate the need to mark and unmark these spins.
@@ -744,7 +743,8 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsAbortAtBe 
    if (spin.HS_current_move == CREATION)

      configuration.unmarkAsAnnihilatable(spin.random_vertex_ind);



  assert(single_spin_updates_proposed == num_creations + num_annihilations + num_statics);

  assert(single_spin_updates_proposed ==

         currently_proposed_creations_ + currently_proposed_annihilations_ + num_statics);



  return single_spin_updates_proposed;

}
@@ -755,18 +755,18 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsNeglectBe 
  assert(single_spin_updates_todo > 0);



  const auto max_num_delayed_spins = parameters.get_max_submatrix_size();

  const auto num_non_interacting_spins_initial = configuration.get_number_of_creatable_HS_spins();

  const auto num_interacting_spins_initial = configuration.get_number_of_interacting_HS_spins();



  delayed_spins.resize(0);



  int num_creations = 0;

  int num_annihilations = 0;

  int num_statics = 0;

  int single_spin_updates_proposed = 0;

  int num_statics = 0;



  currently_proposed_annihilations_ = 0;

  currently_proposed_creations_ = 0;



  while ((num_interacting_spins_initial == 0 || num_annihilations < num_interacting_spins_initial) &&

         num_creations < num_non_interacting_spins_initial &&

  while ((num_interacting_spins_initial == 0 ||

          currently_proposed_annihilations_ < num_interacting_spins_initial) &&

         single_spin_updates_proposed < single_spin_updates_todo &&

         delayed_spins.size() < max_num_delayed_spins) {

    delayed_spin_struct delayed_spin;
@@ -791,16 +791,17 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsNeglectBe 
      }



      delayed_spins.push_back(delayed_spin);

      ++num_annihilations;

      ++currently_proposed_annihilations_;

      ++single_spin_updates_proposed;

    }



    else if (delayed_spin.HS_current_move == CREATION) {

      delayed_spin.random_vertex_ind = configuration.get_random_noninteracting_vertex(false);

      delayed_spin.random_vertex_ind = configuration.size();

      configuration.insert_random_noninteracting_vertex(false);

      delayed_spin.new_HS_spin_value = rng() > 0.5 ? HS_UP : HS_DN;



      delayed_spins.push_back(delayed_spin);

      ++num_creations;

      ++currently_proposed_creations_;

      ++single_spin_updates_proposed;

    }
@@ -811,7 +812,8 @@ int CtauxWalker<device_t, Parameters, Data, Real>::generateDelayedSpinsNeglectBe 
    }

  }



  assert(single_spin_updates_proposed == num_creations + num_annihilations + num_statics);

  assert(single_spin_updates_proposed ==

         currently_proposed_creations_ + currently_proposed_annihilations_ + num_statics);



  return single_spin_updates_proposed;

}
@@ -1030,7 +1032,6 @@ void CtauxWalker<device_t, Parameters, Data, Real>::add_delayed_spins_to_the_con 
        configuration.add_delayed_HS_spin(configuration_index, delayed_spins[i].new_HS_spin_value);

      }

      else {

        configuration[configuration_index].set_creatable(false);

        configuration[configuration_index].set_annihilatable(false);

      }

    }

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

+69 −135
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#include <cstdint>  // uint64_t

#include <cstdlib>  // std::size_t

#include <iostream>

#include <set>

#include <stdexcept>

#include <vector>
@@ -49,16 +50,14 @@ public: 
  vertex_pair_type& operator[](int index);



  std::vector<vertex_singleton_type>& get(e_spin_states_type e_spin_type);

  auto& get() {

    return configuration;

  }

  const std::vector<vertex_singleton_type>& get(e_spin_states_type e_spin_type) const;



  void reset();



  // Creates an initial configuration with "initial-configuration-size" (input parameter) random

  // interacting vertices.

  void initialize();

  void shuffle_noninteracting_vertices();

  void prepare_configuration();

  void update_configuration_e_spin(vertex_pair_type& vertex_pair);



  void remove_HS_spin(int index);
@@ -79,26 +78,23 @@ public: 
  std::vector<HS_spin_states_type>& get_changed_spin_values_e_spin(e_spin_states_type e_spin_type);



  int get_number_of_interacting_HS_spins();

  int get_number_of_creatable_HS_spins();



  int get_random_interacting_vertex();



  // Returns the index of a random non-interacting vertex.

  // If mark_annihilatable = true, marks this vertex as annihilatable such that it can be chosen in

  // a later annihilation proposal.

  int get_random_noninteracting_vertex(bool mark_annihilatable);

  void insert_random_noninteracting_vertex(bool mark_annihilatable);



  // Remove element at index 'idx' in O(1). Vertices order is not preserved. The electron spin

  // configuration needs to be updated independently.

  void erase(unsigned idx);



  // debug tools

  void print();

  void print(e_spin_states_type e_spin_type);

  void print() /*const*/;

  void print(e_spin_states_type e_spin_type) /*const*/;



  bool assert_block_form(e_spin_states_type e_spin_type);  // [non-shuffled-spin | shuffled-spins]

  bool assert_counters();

  bool assert_consistency();

  bool assert_block_form(

      e_spin_states_type e_spin_type) /*const*/;  // [non-shuffled-spin | shuffled-spins]

  bool assert_counters() /*const*/;

  bool assert_consistency() /*const*/;



  // Unmarks the vertex vertex_index as annihilatable.

  // Precondition: The vertex vertex_index is marked as annihilatable.
@@ -107,7 +103,7 @@ public: 
  void unmarkAsAnnihilatable(const int vertex_index) {

    assert(configuration[vertex_index].is_annihilatable() == true);

    configuration[vertex_index].set_annihilatable(false);

    --current_Nb_of_annihilatable_spins;

    --current_Nb_of_annihilatable_spins_;

  }



  // Returns the position of the vertex with ID vertex_id or the size of the configuration if no
@@ -130,8 +126,7 @@ private: 
  std::vector<vertex_singleton_type> configuration_e_UP;  // = { configuration | e_spin == e_UP}

  std::vector<vertex_singleton_type> configuration_e_DN;  // = { configuration | e_spin == e_DN}



  int current_Nb_of_creatable_spins;

  int current_Nb_of_annihilatable_spins;

  unsigned current_Nb_of_annihilatable_spins_ = 0;



  std::vector<int> changed_spin_indices;

  std::vector<HS_spin_states_type> changed_spin_values;
@@ -144,6 +139,7 @@ private: 
  std::vector<HS_spin_states_type> changed_spin_values_e_DN;



  const int max_num_noninteracting_spins_;

  std::array<std::size_t, 2> size_at_last_step_;



  uint64_t next_vertex_id_;

};
@@ -199,6 +195,15 @@ std::vector<vertex_singleton>& CT_AUX_HS_configuration<parameters_type>::get(e_s 
    return configuration_e_DN;

}



template <class parameters_type>

const std::vector<vertex_singleton>& CT_AUX_HS_configuration<parameters_type>::get(

    e_spin_states_type e_spin) const {

  if (e_spin == e_UP)

    return configuration_e_UP;

  else

    return configuration_e_DN;

}



template <class parameters_type>

void CT_AUX_HS_configuration<parameters_type>::reset() {

  configuration.clear();
@@ -206,8 +211,7 @@ void CT_AUX_HS_configuration<parameters_type>::reset() { 
  configuration_e_UP.clear();

  configuration_e_DN.clear();



  current_Nb_of_creatable_spins = 0;

  current_Nb_of_annihilatable_spins = 0;

  current_Nb_of_annihilatable_spins_ = 0;



  changed_spin_indices.clear();

  changed_spin_values.clear();
@@ -229,35 +233,26 @@ void CT_AUX_HS_configuration<parameters_type>::initialize() { 
    vertex_pair_type vertex(parameters, rng, configuration.size(), next_vertex_id_++);

    vertex.set_random_interacting();



    ++current_Nb_of_annihilatable_spins;

    ++current_Nb_of_annihilatable_spins_;

    configuration.push_back(vertex);

    update_configuration_e_spin(configuration.back());

  }

}



template <class parameters_type>

void CT_AUX_HS_configuration<parameters_type>::shuffle_noninteracting_vertices() {

void CT_AUX_HS_configuration<parameters_type>::prepare_configuration() {

  assert(changed_spin_indices_e_UP.size() == 0);

  assert(changed_spin_indices_e_DN.size() == 0);

  assert(changed_spin_indices.size() == 0);



  size_at_last_step_ = {configuration_e_UP.size(), configuration_e_DN.size()};



  for (size_t i = 0; i < configuration.size(); i++) {

    configuration[i].set_shuffled(false);

    configuration[i].set_successfully_flipped(false);

    configuration[i].set_Bennett(false);



    assert(configuration[i].is_annihilatable() || configuration[i].is_creatable());

    assert(configuration[i].is_annihilatable() != configuration[i].is_creatable());

  }



  // Add non-interacting spins.

  while (current_Nb_of_creatable_spins < max_num_noninteracting_spins_) {

    vertex_pair_type vertex(parameters, rng, configuration.size(), next_vertex_id_++);

    vertex.set_random_noninteracting();



    ++current_Nb_of_creatable_spins;

    configuration.push_back(vertex);

    update_configuration_e_spin(configuration.back());

    assert(configuration[i].is_annihilatable());

  }



  assert(assert_consistency());
@@ -305,19 +300,18 @@ int CT_AUX_HS_configuration<parameters_type>::get_first_non_interacting_spin_ind 


template <class parameters_type>

int CT_AUX_HS_configuration<parameters_type>::get_first_shuffled_spin_index(e_spin_states_type e_spin) {

  std::vector<vertex_singleton_type>& spin_configuration = get(e_spin);

  // FIXME: What and when to return if configuration_size = 0?



  assert(assert_block_form(e_spin));



  const int first_shuffled_index = std::distance(

      spin_configuration.begin(),

      std::find_if(spin_configuration.begin(), spin_configuration.end(), [&](const auto& elem) {

        const int index = elem.get_configuration_index();

        return configuration[index].is_shuffled();

      }));

  //  const int first_shuffled_index = std::distance(

  //      spin_configuration.begin(),

  //      std::find_if(spin_configuration.begin(), spin_configuration.end(), [&](const auto& elem) {

  //        const int index = elem.get_configuration_index();

  //        return configuration[index].is_shuffled();

  //      }));



  return first_shuffled_index;

  return e_spin == e_UP ? size_at_last_step_[0] : size_at_last_step_[1];

}



template <class parameters_type>
@@ -344,8 +338,6 @@ void CT_AUX_HS_configuration<parameters_type>::commit_accepted_spins() { 
template <class parameters_type>

void CT_AUX_HS_configuration<parameters_type>::add_delayed_HS_spin(int configuration_index,

                                                                   spin_state_type spin_value) {

  assert(configuration[configuration_index].is_creatable() == false);



  add_delayed_HS_spin_to_configuration_e_spin(configuration_index, spin_value);



  if (configuration[configuration_index].is_successfully_flipped() &&
@@ -355,7 +347,7 @@ void CT_AUX_HS_configuration<parameters_type>::add_delayed_HS_spin(int configura 
      if (changed_spin_indices[i] == configuration_index)

        changed_spin_values[i] = spin_value;



    current_Nb_of_annihilatable_spins -= 1;

    current_Nb_of_annihilatable_spins_ -= 1;



    configuration[configuration_index].set_annihilatable(false);

    configuration[configuration_index].set_Bennett(true);
@@ -369,14 +361,14 @@ void CT_AUX_HS_configuration<parameters_type>::add_delayed_HS_spin(int configura 
  if (spin_value == HS_ZERO) {

    // cout << "\t--> annihilate spin : " << configuration_index << std::endl;



    current_Nb_of_annihilatable_spins -= 1;

    current_Nb_of_annihilatable_spins_ -= 1;



    configuration[configuration_index].set_annihilatable(false);

  }

  else {

    // cout << "\t--> create spin : " << configuration_index << std::endl;



    current_Nb_of_annihilatable_spins += 1;

    current_Nb_of_annihilatable_spins_ += 1;



    configuration[configuration_index].set_annihilatable(true);

  }
@@ -453,7 +445,7 @@ std::vector<HS_spin_states_type>& CT_AUX_HS_configuration<parameters_type>::get_ 


template <class parameters_type>

int CT_AUX_HS_configuration<parameters_type>::get_random_interacting_vertex() {

  assert(current_Nb_of_annihilatable_spins > 0);

  assert(current_Nb_of_annihilatable_spins_ > 0);



  int vertex_index;
@@ -465,30 +457,21 @@ int CT_AUX_HS_configuration<parameters_type>::get_random_interacting_vertex() { 
}



template <class parameters_type>

int CT_AUX_HS_configuration<parameters_type>::get_random_noninteracting_vertex(bool mark_annihilatable) {

  assert(current_Nb_of_creatable_spins > 0);



  // Find the first non-interacting spin from the left.

  int vertex_index = 0;

  while (!configuration[vertex_index].is_creatable())

    ++vertex_index;



  assert(vertex_index < size());

  assert(!configuration[vertex_index].is_Bennett());

void CT_AUX_HS_configuration<parameters_type>::insert_random_noninteracting_vertex(

    bool mark_annihilatable) {

  vertex_pair_type vertex(parameters, rng, configuration.size(), next_vertex_id_++);

  vertex.set_random_noninteracting();



  // Make sure that this spin will not be proposed for insertion again.

  configuration[vertex_index].set_creatable(false);

  --current_Nb_of_creatable_spins;

  configuration.push_back(vertex);

  update_configuration_e_spin(configuration.back());



  if (mark_annihilatable) {

  // However, this "virtual" interacting spin is eligible for removal.

  // INTERNAL: CtauxWalker::generateDelayedSpinsAbortAtBennett unmarks the "virtual" interacting

  //           spins as annihilatable when all delayed spins have been generated.

    configuration[vertex_index].set_annihilatable(true);

    ++current_Nb_of_annihilatable_spins;

  if (mark_annihilatable) {

    configuration.back().set_annihilatable(true);

    ++current_Nb_of_annihilatable_spins_;

  }



  return vertex_index;

}



template <class parameters_type>
@@ -498,11 +481,12 @@ void CT_AUX_HS_configuration<parameters_type>::erase(unsigned idx) { 
  assert(configuration[idx].get_configuration_e_spin_indices().second == -1);



  if (configuration[idx].is_annihilatable())

    --current_Nb_of_annihilatable_spins;

  if (configuration[idx].is_creatable())

    --current_Nb_of_creatable_spins;

    --current_Nb_of_annihilatable_spins_;



  configuration[idx] = configuration.back();

  configuration.pop_back();

  if (idx == size())

    return;



  const auto& e_spin_indices = configuration[idx].get_configuration_e_spin_indices();

  const auto& e_spins = configuration[idx].get_e_spins();
@@ -518,25 +502,17 @@ void CT_AUX_HS_configuration<parameters_type>::erase(unsigned idx) { 
  update_index(e_spins.second, e_spin_indices.second);



  configuration[idx].get_configuration_index() = idx;



  configuration.pop_back();

}



template <class parameters_type>

int CT_AUX_HS_configuration<parameters_type>::get_number_of_creatable_HS_spins() {

  assert(assert_counters());

  return current_Nb_of_creatable_spins;

}



template <class parameters_type>

int CT_AUX_HS_configuration<parameters_type>::get_number_of_interacting_HS_spins() {

  assert(assert_counters());

  return current_Nb_of_annihilatable_spins;

  return current_Nb_of_annihilatable_spins_;

}



template <class parameters_type>

bool CT_AUX_HS_configuration<parameters_type>::assert_block_form(e_spin_states_type e_spin) {

  std::vector<vertex_singleton_type>& configuration_e_spin = get(e_spin);

bool CT_AUX_HS_configuration<parameters_type>::assert_block_form(e_spin_states_type e_spin) /*const*/ {

  const std::vector<vertex_singleton_type>& configuration_e_spin = get(e_spin);

  int configuration_size = configuration_e_spin.size();



  int vertex_index = 0;
@@ -559,29 +535,21 @@ bool CT_AUX_HS_configuration<parameters_type>::assert_block_form(e_spin_states_t 
}



template <class parameters_type>

bool CT_AUX_HS_configuration<parameters_type>::assert_counters() {

  int tmp1 = 0;

  int tmp2 = 0;

bool CT_AUX_HS_configuration<parameters_type>::assert_counters() /*const*/ {

  int tmp = 0;



  for (size_t i = 0; i < configuration.size(); i++) {

    if (configuration[i].is_annihilatable())

      tmp1++;



    if (configuration[i].is_creatable())

      tmp2++;

      ++tmp;

  }



  if (tmp1 != current_Nb_of_annihilatable_spins)

  if (tmp != current_Nb_of_annihilatable_spins_)

    throw std::logic_error("tmp != current_Nb_of_annihilatable_spins");



  if (tmp2 != current_Nb_of_creatable_spins)

    throw std::logic_error("tmp != current_Nb_of_creatable_spins");



  return true;

}



template <class parameters_type>

bool CT_AUX_HS_configuration<parameters_type>::assert_consistency() {

bool CT_AUX_HS_configuration<parameters_type>::assert_consistency() /*const*/ {

  assert(2 * configuration.size() == (configuration_e_UP.size() + configuration_e_DN.size()));



  assert_counters();
@@ -631,7 +599,7 @@ bool CT_AUX_HS_configuration<parameters_type>::assert_consistency() { 


  {  // assert internal pointers

    for (int i = 0; i < (int)configuration_e_UP.size(); i++) {

      vertex_singleton_type& partner = configuration_e_UP[i].get_partner(*this);

      const vertex_singleton_type& partner = configuration_e_UP[i].get_partner(*this);

      // assert( partner.get_configuration_index() ==

      // configuration_e_UP[i].get_configuration_index());

      if (partner.get_configuration_index() != configuration_e_UP[i].get_configuration_index())
@@ -639,7 +607,7 @@ bool CT_AUX_HS_configuration<parameters_type>::assert_consistency() { 
    }



    for (int i = 0; i < (int)configuration_e_DN.size(); i++) {

      vertex_singleton_type& partner = configuration_e_DN[i].get_partner(*this);

      const vertex_singleton_type& partner = configuration_e_DN[i].get_partner(*this);

      // assert( partner.get_configuration_index() ==

      // configuration_e_DN[i].get_configuration_index());

      if (partner.get_configuration_index() != configuration_e_DN[i].get_configuration_index())
@@ -651,7 +619,7 @@ bool CT_AUX_HS_configuration<parameters_type>::assert_consistency() { 
}



template <class parameters_type>

void CT_AUX_HS_configuration<parameters_type>::print() {

void CT_AUX_HS_configuration<parameters_type>::print() /*const*/ {

  std::stringstream ss;

  ss << std::scientific;

  ss.precision(6);
@@ -662,8 +630,7 @@ void CT_AUX_HS_configuration<parameters_type>::print() { 
    ss << "\t"

       << "==============";



  std::cout << "current_Nb_of_creatable_spins     \t" << current_Nb_of_creatable_spins << std::endl;

  std::cout << "current_Nb_of_annihilatable_spins \t" << current_Nb_of_annihilatable_spins

  std::cout << "current_Nb_of_annihilatable_spins \t" << current_Nb_of_annihilatable_spins_

            << std::endl;

  std::cout << std::endl;
@@ -717,11 +684,6 @@ void CT_AUX_HS_configuration<parameters_type>::print() { 
  for (size_t i = 0; i < configuration.size(); i++)

    ss << "\t\t" << configuration[i].is_annihilatable();



  ss << "\n creatable\n\t";



  for (size_t i = 0; i < configuration.size(); i++)

    ss << "\t\t" << configuration[i].is_creatable();



  ss << "\n";



  ss << "\n changed\n\t";
@@ -750,40 +712,13 @@ void CT_AUX_HS_configuration<parameters_type>::print() { 


  ss << "\n";



  /*

    for(size_t i=0; i<configuration.size(); i++)

    ss << "\t" << "==============";



    ss << "\n";



    ss << "\n";



    for(size_t i=0; i<changed_spin_values.size(); i++)

    ss << "\t" << "==============";



    ss << "\n values\n";



    for(size_t i=0; i<changed_spin_values.size(); i++)

    ss << "\t\t" << changed_spin_values[i];



    ss << "\n indices\n";



    for(size_t i=0; i<changed_spin_values.size(); i++)

    ss << "\t\t" << changed_spin_indices[i];







    for(size_t i=0; i<changed_spin_values.size(); i++)

    ss << "\t" << "==============";

  */



  ss << std::endl << std::endl;



  std::cout << ss.str();

}



template <class parameters_type>

void CT_AUX_HS_configuration<parameters_type>::print(e_spin_states_type e_spin) {

void CT_AUX_HS_configuration<parameters_type>::print(e_spin_states_type e_spin) /*const*/ {

  std::stringstream ss;

  ss << std::scientific;

  ss.precision(6);
@@ -860,10 +795,9 @@ bool CT_AUX_HS_configuration<parameters_type>::operator==( 
    const CT_AUX_HS_configuration<parameters_type>& rhs) const {

  using math::util::operator==;



  // assert(assert_counters());

  return configuration == rhs.configuration && configuration_e_UP == rhs.configuration_e_UP &&

         configuration_e_DN == rhs.configuration_e_DN &&

         current_Nb_of_annihilatable_spins == rhs.current_Nb_of_annihilatable_spins &&

         current_Nb_of_creatable_spins == rhs.current_Nb_of_creatable_spins;

         configuration_e_DN == rhs.configuration_e_DN;

}



}  // namespace ctaux

include/dca/phys/dca_step/cluster_solver/ctaux/structs/read_write_config.hpp

+1 −2
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ io::Buffer& operator<<(io::Buffer& buff, const vertex_pair<Parameters>& v) { 


template <class Parameters>

io::Buffer& operator>>(io::Buffer& buff, vertex_pair<Parameters>& v) {

  v.creatable = false;

  v.annihilatable = true;

  v.successfully_flipped = false;

  v.Bennett = false;
@@ -70,7 +69,7 @@ io::Buffer& operator>>(io::Buffer& buff, CT_AUX_HS_configuration<Parameters>& co 


    buff >> vertex;



    ++config.current_Nb_of_annihilatable_spins;

    ++config.current_Nb_of_annihilatable_spins_;

    config.update_configuration_e_spin(vertex);

    config.configuration.push_back(vertex);

  }

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

+3 −15
Original line number Diff line number Diff line
@@ -82,9 +82,6 @@ public: 
  }

  std::pair<int, int>& get_configuration_e_spin_indices();



  void set_creatable(bool val) {

    creatable = val;

  }

  void set_annihilatable(bool val) {

    annihilatable = val;

  }
@@ -98,9 +95,6 @@ public: 
    Bennett = val;

  }



  bool is_creatable() const {

    return creatable;

  }

  bool is_annihilatable() const {

    return annihilatable;

  }
@@ -146,7 +140,6 @@ private: 
  int configuration_index;  // TODO: remove redundant info.

  std::pair<int, int> configuration_e_spin_indices;



  bool creatable;

  bool annihilatable;

  bool successfully_flipped;

  bool Bennett;
@@ -177,7 +170,6 @@ vertex_pair<parameters_type>::vertex_pair(parameters_type& parameters_ref, rng_t 


      configuration_e_spin_indices(-1, -1),



      creatable(true),

      annihilatable(false),

      successfully_flipped(false),

      Bennett(false),
@@ -201,7 +193,6 @@ vertex_pair<parameters_type>& vertex_pair<parameters_type>::operator=( 
  configuration_index = other_vertex_pair.configuration_index;

  configuration_e_spin_indices = other_vertex_pair.configuration_e_spin_indices;



  creatable = other_vertex_pair.creatable;

  annihilatable = other_vertex_pair.annihilatable;

  successfully_flipped = other_vertex_pair.successfully_flipped;

  Bennett = other_vertex_pair.Bennett;
@@ -240,7 +231,6 @@ void vertex_pair<parameters_type>::set_random_interacting() { 


  tau = parameters.get_beta() * rng();



  creatable = false;

  annihilatable = true;



  successfully_flipped = false;
@@ -262,7 +252,6 @@ void vertex_pair<parameters_type>::set_random_noninteracting() { 


  tau = parameters.get_beta() * rng();



  creatable = true;

  annihilatable = false;



  successfully_flipped = false;
@@ -327,9 +316,8 @@ bool vertex_pair<parameters_type>::operator==( 
         r_sites == rhs.r_sites && HS_spin == rhs.HS_spin && delta_r == rhs.delta_r &&

         tau == rhs.tau && configuration_index == rhs.configuration_index &&

         configuration_e_spin_indices == rhs.configuration_e_spin_indices &&

         creatable == rhs.creatable && annihilatable == rhs.annihilatable &&

         successfully_flipped == rhs.successfully_flipped && Bennett == rhs.Bennett &&

         shuffled == rhs.shuffled;

         annihilatable == rhs.annihilatable && successfully_flipped == rhs.successfully_flipped &&

         Bennett == rhs.Bennett && shuffled == rhs.shuffled;

}



}  // namespace ctaux

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

+2 −2

File changed.

Preview size limit exceeded, changes collapsed.