Commit 1acc371a authored by gbalduzz's avatar gbalduzz
Browse files

Write checkpoint in separate file.

parent 3269576e

include/dca/io/hdf5/hdf5_writer.hpp

+2 −2
Original line number Diff line number Diff line
@@ -33,6 +33,8 @@ namespace dca { 
namespace io {

// dca::io



bool fileExists(const std::string& filename);



class HDF5Writer {

public:

  typedef H5::H5File file_type;
@@ -143,8 +145,6 @@ public: 
  }



private:

  bool fexists(const char* filename);



  bool exists(const std::string& name);



  void write(const std::string& name, const std::vector<hsize_t>& size, H5::PredType type,

include/dca/phys/dca_data/dca_data.hpp

+5 −17
Original line number Diff line number Diff line
@@ -114,7 +114,7 @@ public: 
  void initialize();

  void initialize_H_0_and_H_i();

  void initialize_G0();

  void initialize_Sigma();

  void initializeSigma(const std::string& filename);



  void compute_single_particle_properties();

  void compute_Sigma_bands();
@@ -553,12 +553,10 @@ void DcaData<Parameters>::initialize_G0() { 
}



template <class Parameters>

void DcaData<Parameters>::initialize_Sigma() {

  if (parameters_.get_initial_self_energy() == "zero")

    return;



  auto initialize = [&](auto&& reader) {

    reader.open_file(parameters_.get_initial_self_energy());

void DcaData<Parameters>::initializeSigma(const std::string& filename) {

  if (concurrency_.id() == concurrency_.first()) {

    io::HDF5Reader reader;

    reader.open_file(filename);



    if (parameters_.adjust_chemical_potential()) {

      reader.open_group("parameters");
@@ -571,16 +569,6 @@ void DcaData<Parameters>::initialize_Sigma() { 
    reader.open_group("functions");

    reader.execute(Sigma);

    reader.close_group();

  };



  if (concurrency_.id() == 0) {

    const std::string& format = parameters_.get_output_format();

    if (format == "HDF5")

      initialize(io::HDF5Reader());

    else if (format == "JSON")

      initialize(io::JSONReader());

    else

      throw std::logic_error(__FUNCTION__);

  }



  concurrency_.broadcast(parameters_.get_chemical_potential());

include/dca/phys/dca_loop/dca_loop.hpp

+57 −37
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 


#include <cmath>

#include <iostream>

#include <filesystem>

#include <stdexcept>

#include <string>
@@ -66,7 +67,6 @@ public: 


  DcaLoop(ParametersType& parameters_ref, DcaDataType& MOMS_ref, concurrency_type& concurrency_ref);



  void read();

  void write();



  void initialize();
@@ -109,7 +109,9 @@ private: 
  update_chemical_potential_type update_chemical_potential_obj;



  std::string file_name_;

  io::HDF5Writer output_file_;

  io::HDF5Writer output_file_tmp_;



  unsigned dca_iteration_ = 0;



protected:

  MCIntegratorType monte_carlo_integrator_;
@@ -133,47 +135,65 @@ DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::DcaLoop(ParametersType& 


      update_chemical_potential_obj(parameters, MOMS, cluster_mapping_obj),



      monte_carlo_integrator_(parameters_ref, MOMS_ref, &output_file_) {

      output_file_tmp_(false),



      monte_carlo_integrator_(parameters_ref, MOMS_ref) {

  if (concurrency.id() == concurrency.first()) {

    file_name_ = parameters.get_directory() + parameters.get_filename_dca();

    output_file_.open_file(file_name_);

    dca::util::SignalHandler::registerFile(output_file_);

    dca::util::SignalHandler::registerFile(output_file_tmp_);



    std::cout << "\n\n\t" << __FUNCTION__ << " has started \t" << dca::util::print_time() << "\n\n";

  }

}



template <typename ParametersType, typename DcaDataType, typename MCIntegratorType>

void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::read() {

  if (parameters.get_initial_self_energy() != "zero")

    MOMS.read(parameters.get_initial_self_energy());

}



template <typename ParametersType, typename DcaDataType, typename MCIntegratorType>

void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::write() {

  if (concurrency.id() == concurrency.first()) {

    std::cout << "\n\n\t\t start writing " << file_name_ << "\t" << dca::util::print_time() << "\n\n";

    io::HDF5Writer output_file;

    output_file.open_file(file_name_);



    parameters.write(output_file_);

    MOMS.write(output_file_);

    monte_carlo_integrator_.write(output_file_);

    DCA_info_struct.write(output_file_);

    parameters.write(output_file);

    MOMS.write(output_file);

    monte_carlo_integrator_.write(output_file);

    DCA_info_struct.write(output_file);



    output_file_.close_file();

    output_file.close_file();



    std::error_code code;

    std::filesystem::remove(file_name_ + ".tmp", code);

  }

}



template <typename ParametersType, typename DcaDataType, typename MCIntegratorType>

void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::initialize() {

  if (parameters.get_initial_self_energy() != "zero") {

    MOMS.initialize_Sigma();

  int last_completed = -1;



  if (parameters.autoresume()) {  // Try to read state of previous run.

    last_completed = DCA_info_struct.tryToRead(file_name_ + ".tmp", concurrency);

  }

  if (last_completed >= 0) {

    if (concurrency.id() == concurrency.first())

      std::cout << "\n   *******  Resuming DCA from iteration " << last_completed + 1 << "  *******\n"

                << std::endl;



    dca_iteration_ = std::min(last_completed + 1, parameters.get_dca_iterations() - 1);

    MOMS.initializeSigma(file_name_ + ".tmp");

    perform_lattice_mapping();

  }

  else if (parameters.get_initial_self_energy() != "zero") {

    MOMS.initializeSigma(parameters.get_initial_self_energy());

    perform_lattice_mapping();

  }



  if (concurrency.id() == concurrency.first()) {

    output_file_tmp_.open_file(file_name_ + ".tmp", false);

  }

}



template <typename ParametersType, typename DcaDataType, typename MCIntegratorType>

void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::execute() {

  for (int i = 0; i < parameters.get_dca_iterations(); i++) {

  for (; dca_iteration_ < parameters.get_dca_iterations(); dca_iteration_++) {

    adjust_chemical_potential();



    perform_cluster_mapping();
@@ -182,15 +202,15 @@ void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::execute() { 


    perform_cluster_exclusion_step();



    double L2_Sigma_difference = solve_cluster_problem(i);  // returned from cluster_solver::finalize

    double L2_Sigma_difference =

        solve_cluster_problem(dca_iteration_);  // returned from cluster_solver::finalize



    adjust_impurity_self_energy();  // double-counting-correction



    perform_lattice_mapping();



    logSelfEnergy(i);  // Write a check point.



    update_DCA_loop_data_functions(i);

    update_DCA_loop_data_functions(dca_iteration_);

    logSelfEnergy(dca_iteration_);  // Write a check point.



    if (L2_Sigma_difference <

        parameters.get_dca_accuracy())  // set the acquired accuracy on |Sigma_QMC - Sigma_cg|
@@ -350,20 +370,20 @@ void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::update_DCA_loop_dat 


template <typename ParametersType, typename DcaDataType, typename MCIntegratorType>

void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::logSelfEnergy(int i) {

  if (output_file_) {

    output_file_.open_group("functions");

    output_file_.execute(MOMS.Sigma);

    output_file_.close_group();



    output_file_.open_group("parameters");

    output_file_.open_group("physics");

    output_file_.execute("chemical-potential", parameters.get_chemical_potential());

    output_file_.close_group();

    output_file_.close_group();



    output_file_.open_group("DCA-loop-functions");

    output_file_.execute("completed-iteration", i);

    output_file_.close_group();

  DCA_info_struct.last_completed_iteration = i;



  if (output_file_tmp_) {

    output_file_tmp_.open_group("functions");

    output_file_tmp_.execute(MOMS.Sigma);

    output_file_tmp_.close_group();



    output_file_tmp_.open_group("parameters");

    output_file_tmp_.open_group("physics");

    output_file_tmp_.execute("chemical-potential", parameters.get_chemical_potential());

    output_file_tmp_.close_group();

    output_file_tmp_.close_group();



    DCA_info_struct.write(output_file_tmp_);

  }

}

include/dca/phys/dca_loop/dca_loop_data.hpp

+49 −4
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ namespace phys { 
template <typename ParametersType>

class DcaLoopData {

public:

  using Concurrency = typename ParametersType::concurrency_type;

  using expansion_dmn_t = func::dmn_0<func::dmn<32, int>>;

  using DCA_iteration_domain_type = func::dmn_0<domains::DCA_iteration_domain>;
@@ -44,6 +45,10 @@ public: 
  template <typename Writer>

  void write(Writer& writer);



  // Attempts to read the loop functions from 'filename'. If successful returns

  // the last completed iteration from the input file, otherwise it returns -1.

  int tryToRead(const std::string& filename, const Concurrency& concurrency);



  func::function<double, DCA_iteration_domain_type> Gflop_per_mpi_task;

  func::function<double, DCA_iteration_domain_type> times_per_mpi_task;
@@ -60,8 +65,7 @@ public: 
  func::function<double, func::dmn_variadic<nu, k_DCA, DCA_iteration_domain_type>> Sigma_zero_moment;

  func::function<double, func::dmn_variadic<nu, k_DCA, DCA_iteration_domain_type>> standard_deviation;



  func::function<std::complex<double>,

                 func::dmn_variadic<nu, nu, expansion_dmn_t, DCA_iteration_domain_type>>

  func::function<std::complex<double>, func::dmn_variadic<nu, nu, expansion_dmn_t, DCA_iteration_domain_type>>

      sigma_lambda;



  func::function<double, func::dmn_variadic<nu, k_DCA, DCA_iteration_domain_type>> n_k;
@@ -71,6 +75,8 @@ public: 
  func::function<double, DCA_iteration_domain_type> density;

  func::function<double, DCA_iteration_domain_type> chemical_potential;

  func::function<double, DCA_iteration_domain_type> average_expansion_order;



  int last_completed_iteration = -1;

};



template <typename ParametersType>
@@ -124,12 +130,51 @@ void DcaLoopData<ParametersType>::write(Writer& writer) { 
    writer.execute(n_k);

    writer.execute(A_k);

    writer.execute(orbital_occupancies);



    writer.execute("completed-iteration", last_completed_iteration);

  }



  writer.close_group();

}



}  // phys

}  // dca

template <typename ParametersType>

int DcaLoopData<ParametersType>::tryToRead(const std::string& filename,

                                           const Concurrency& concurrency) {

  if (concurrency.id() == concurrency.first() && io::fileExists(filename)) {

    io::HDF5Reader reader;

    reader.open_file(filename);

    reader.open_group("DCA-loop-functions");



    reader.execute("completed-iteration", last_completed_iteration);



    reader.execute(Gflop_per_mpi_task);

    reader.execute(times_per_mpi_task);

    reader.execute(Gflops_per_mpi_task);



    reader.execute(sign);



    reader.execute(L2_Sigma_difference);

    reader.execute(standard_deviation);



    reader.execute(chemical_potential);

    reader.execute(density);

    reader.execute(average_expansion_order);



    reader.execute(Sigma_zero_moment);



    reader.execute(n_k);

    reader.execute(A_k);

    reader.execute(orbital_occupancies);



    reader.open_group("DCA-loop-functions");

    reader.close_file();

  }



  concurrency.broadcast(last_completed_iteration);

  return last_completed_iteration;

}



}  // namespace phys

}  // namespace dca



#endif  // DCA_PHYS_DCA_LOOP_DCA_LOOP_DATA_HPP

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

+1 −0
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)

//

// Cluster Monte Carlo integrator based on a continuous-time auxilary field (CT-AUX) expansion.

//