Merge branch 'write_checkpoints' into write_config_timestamps (08ab30ec) · Commits · NDIP / Tool Sources / Direct-Geometry Spectroscopy / DCA / DCA Main

CMakeLists.txt

+1 −0

Original line number	Diff line number	Diff line
		@@ -142,6 +142,7 @@ set(DCA_LIBS
		signals
		symmetrization
		coarsegraining
		stdc++fs # std::filesystem
		${DCA_CONCURRENCY_LIB}
		${DCA_THREADING_LIBS}
		lapack

include/dca/io/hdf5/hdf5_writer.hpp

+4 −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,
		@@ -159,6 +159,8 @@ private:
		bool verbose_;

		std::mutex mutex_;

		std::vector<hsize_t> size_check_;
		};

		template <typename arbitrary_struct_t>

include/dca/phys/dca_analysis/bse_solver/bse_solver.hpp

+6 −23

Original line number	Diff line number	Diff line
		@@ -121,23 +121,10 @@ BseSolver<ParametersType, DcaDataType>::BseSolver(ParametersType& parameters, Dc

		template <typename ParametersType, typename DcaDataType>
		void BseSolver<ParametersType, DcaDataType>::write() {
		const std::string& output_format = parameters_.get_output_format();
		const std::string& file_name = parameters_.get_directory() + parameters_.get_filename_analysis();

		std::cout << "Start writing " << file_name << "." << std::endl;

		if (output_format == "JSON") {
		dca::io::JSONWriter writer;
		writer.open_file(file_name);

		parameters_.write(writer);
		// dca_data_.write(writer);
		this->write(writer);

		writer.close_file();
		}

		else if (output_format == "HDF5") {
		dca::io::HDF5Writer writer;
		writer.open_file(file_name);

		@@ -148,10 +135,6 @@ void BseSolver<ParametersType, DcaDataType>::write() {
		writer.close_file();
		}

		else
		throw std::logic_error(__FUNCTION__);
		}

		template <typename ParametersType, typename DcaDataType>
		template <typename Writer>
		void BseSolver<ParametersType, DcaDataType>::write(Writer& writer) {

include/dca/phys/dca_data/dca_data.hpp

+9 −35

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();
		@@ -314,26 +314,12 @@ void DcaData<Parameters>::read(std::string filename) {
		std::cout << "\n\n\t starts reading \n\n";

		if (concurrency_.id() == concurrency_.first()) {
		const std::string& output_format = parameters_.get_output_format();

		if (output_format == static_cast<const std::string>("JSON")) {
		dca::io::JSONReader reader;
		reader.open_file(filename);
		this->read(reader);
		reader.close_file();
		}

		else if (output_format == static_cast<const std::string>("HDF5")) {
		dca::io::HDF5Reader reader;
		reader.open_file(filename);
		this->read(reader);
		reader.close_file();
		}

		else
		throw std::logic_error(__FUNCTION__);
		}

		concurrency_.broadcast(parameters_.get_chemical_potential());

		concurrency_.broadcast_object(Sigma);
		@@ -553,12 +539,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 +555,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

+51 −29

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();
		@@ -111,6 +111,9 @@ private:

		std::string file_name_;
		io::HDF5Writer output_file_;
		io::HDF5Writer output_file_tmp_;

		unsigned dca_iteration_ = 0;

		protected:
		MCIntegratorType monte_carlo_integrator_;
		@@ -134,22 +137,18 @@ 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_tmp_);
		dca::util::SignalHandler::registerFile(output_file_);

		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()) {
		@@ -161,20 +160,43 @@ void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::write() {
		DCA_info_struct.write(output_file_);

		output_file_.close_file();
		output_file_tmp_.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_.open_file(file_name_, true);
		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();
		@@ -183,17 +205,17 @@ 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

		writeWalkerData(i);
		writeWalkerData(dca_iteration_);

		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\|
		@@ -372,20 +394,20 @@ void DcaLoop<ParametersType, DcaDataType, MCIntegratorType>::writeWalkerData(int

		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();
		DCA_info_struct.last_completed_iteration = i;

		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();
		if (output_file_tmp_) {
		output_file_tmp_.open_group("functions");
		output_file_tmp_.execute(MOMS.Sigma);
		output_file_tmp_.close_group();

		output_file_.open_group("DCA-loop-functions");
		output_file_.execute("completed-iteration", i);
		output_file_.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_);
		}
		}