Merge remote-tracking branch 'origin/master' into write_checkpoints (b6d05d40) · Commits · NDIP / Tool Sources / Direct-Geometry Spectroscopy / DCA / DCA Main

cmake/dca_config.cmake

+28 −12

Original line number	Diff line number	Diff line
		################################################################################
		# Author: Urs R. Haehner (haehneru@itp.phys.ethz.ch)
		# Giovanni Badlduzzi (gbalduzz@itp.phys.ethz.ch)
		#
		# Build options for DCA++.

		@@ -53,8 +54,8 @@ endif()
		# TODO: Add more point groups and lattices.

		# Point group
		set(DCA_POINT_GROUP "D4" CACHE STRING "Point group symmetry, options are: C6 \| D4.")
		set_property(CACHE DCA_POINT_GROUP PROPERTY STRINGS C6 D4)
		set(DCA_POINT_GROUP "D4" CACHE STRING "Point group symmetry, options are: C6 \| D4 \| no_symmetry<2>.")
		set_property(CACHE DCA_POINT_GROUP PROPERTY STRINGS C6 D4 no_symmetry<2>)

		if (DCA_POINT_GROUP STREQUAL "C6")
		set(DCA_POINT_GROUP_INCLUDE
		@@ -63,14 +64,18 @@ if (DCA_POINT_GROUP STREQUAL "C6")
		elseif (DCA_POINT_GROUP STREQUAL "D4")
		set(DCA_POINT_GROUP_INCLUDE "dca/phys/domains/cluster/symmetries/point_groups/2d/2d_square.hpp")

		elseif (DCA_POINT_GROUP STREQUAL "no_symmetry<2>")
		set(DCA_POINT_GROUP_INCLUDE "dca/phys/domains/cluster/symmetries/point_groups/no_symmetry.hpp")

		else()
		message(FATAL_ERROR "Please set DCA_POINT_GROUP to a valid option: C6 \| D4.")
		endif()

		# Lattice type
		set(DCA_LATTICE "square" CACHE STRING
		"Lattice type, options are: bilayer \| square \| triangular \| twoband_chain \| singleband_chain.")
		set_property(CACHE DCA_LATTICE PROPERTY STRINGS bilayer square triangular twoband_chain singleband_chain)
		set(DCA_LATTICE "square" CACHE STRING "Lattice type, options are: bilayer \| square \| triangular \|
		hund \| twoband_Cu \| threeband \| FeAs.")
		set_property(CACHE DCA_LATTICE PROPERTY STRINGS bilayer square triangular hund twoband_Cu threeband
		FeAs)

		if (DCA_LATTICE STREQUAL "bilayer")
		set(DCA_LATTICE_TYPE dca::phys::models::bilayer_lattice<PointGroup>)
		@@ -86,19 +91,30 @@ elseif (DCA_LATTICE STREQUAL "triangular")
		set(DCA_LATTICE_TYPE dca::phys::models::triangular_lattice<PointGroup>)
		set(DCA_LATTICE_INCLUDE
		"dca/phys/models/analytic_hamiltonians/triangular_lattice.hpp")
		elseif (DCA_LATTICE STREQUAL "hund")
		set(DCA_LATTICE_TYPE dca::phys::models::HundLattice<PointGroup>)

		elseif (DCA_LATTICE STREQUAL "threeband")
		set(DCA_LATTICE_TYPE dca::phys::models::ThreebandHubbard<PointGroup>)
		set(DCA_LATTICE_INCLUDE
		"dca/phys/models/analytic_hamiltonians/threeband_hubbard.hpp")

		elseif (DCA_LATTICE STREQUAL "twoband_chain")
		set(DCA_LATTICE_TYPE dca::phys::models::twoband_chain<dca::phys::domains::no_symmetry<1>>)
		set(DCA_LATTICE_INCLUDE
		"dca/phys/models/analytic_hamiltonians/twoband_chain.hpp")

		elseif (DCA_LATTICE STREQUAL "singleband_chain")
		set(DCA_LATTICE_TYPE dca::phys::models::singleband_chain<dca::phys::domains::no_symmetry<1>>)
		"dca/phys/models/analytic_hamiltonians/hund_lattice.hpp")
		elseif (DCA_LATTICE STREQUAL "FeAs")
		set(DCA_LATTICE_TYPE dca::phys::models::FeAsLattice<PointGroup>)
		set(DCA_LATTICE_INCLUDE
		"dca/phys/models/analytic_hamiltonians/singleband_chain.hpp")
		"dca/phys/models/analytic_hamiltonians/fe_as_lattice.hpp")
		elseif (DCA_LATTICE STREQUAL "twoband_Cu")
		set(DCA_LATTICE_TYPE dca::phys::models::TwoBandCu<PointGroup>)
		set(DCA_LATTICE_INCLUDE
		"dca/phys/models/analytic_hamiltonians/twoband_Cu.hpp")

		else()
		message(FATAL_ERROR
		"Please set DCA_LATTICE to a valid option: bilayer \| square \| triangular \| twoband_chain \| singleband_chain.")
		message(FATAL_ERROR "Please set DCA_LATTICE to a valid option: bilayer \| square \| triangular \|
		hund \| twoband_Cu \| threeband \| FeAs.")
		endif()

		# Model type

include/dca/function/domains/dmn_0.hpp

+3 −3

Original line number	Diff line number	Diff line
		@@ -37,7 +37,7 @@ public:
		return parameters::get_size();
		}

		static std::vector<element_type>& get_elements() {
		static const std::vector<element_type>& get_elements() {
		return parameters::get_elements();
		}

		@@ -75,7 +75,7 @@ void dmn_0<parameters>::reset() {
		dmn_0::initialize();
		}

		} // func
		} // dca
		} // namespace func
		} // namespace dca

		#endif // DCA_FUNCTION_DOMAINS_DMN_0_HPP

include/dca/io/hdf5/hdf5_reader.hpp

+34 −106

Original line number	Diff line number	Diff line
		@@ -68,9 +68,6 @@ public:
		template <typename Scalar>
		bool execute(const std::string& name, std::vector<Scalar>& value);

		template <typename Scalar>
		bool execute(const std::string& name, std::vector<std::complex<Scalar>>& value);

		template <typename Scalar>
		bool execute(const std::string& name, std::vector<std::vector<Scalar>>& value);

		@@ -96,17 +93,9 @@ public:
		template <typename Scalar>
		bool execute(const std::string& name, dca::linalg::Vector<Scalar, dca::linalg::CPU>& A);

		template <typename Scalar>
		bool execute(const std::string& name,
		dca::linalg::Vector<std::complex<Scalar>, dca::linalg::CPU>& A);

		template <typename Scalar>
		bool execute(const std::string& name, dca::linalg::Matrix<Scalar, dca::linalg::CPU>& A);

		template <typename Scalar>
		bool execute(const std::string& name,
		dca::linalg::Matrix<std::complex<Scalar>, dca::linalg::CPU>& A);

		template <typename Scalar>
		bool execute(dca::linalg::Matrix<Scalar, dca::linalg::CPU>& A);

		@@ -117,7 +106,7 @@ public:
		private:
		bool exists(const std::string& name) const;

		void read(const std::string& name, H5::PredType type, void* data) const;
		void read(const std::string& name, H5::DataType type, void* data) const;
		std::vector<hsize_t> readSize(const std::string& name) const;

		std::unique_ptr<H5::H5File> file_;
		@@ -162,22 +151,6 @@ bool HDF5Reader::execute(const std::string& name, std::vector<Scalar>& value) {
		return true;
		}

		template <typename Scalar>
		bool HDF5Reader::execute(const std::string& name, std::vector<std::complex<Scalar>>& value) {
		std::string full_name = get_path() + "/" + name;

		if (!exists(full_name)) {
		return false;
		}

		auto dims = readSize(full_name);
		assert(dims.size() == 2);
		value.resize(dims.at(0));

		read(full_name, HDF5_TYPE<Scalar>::get_PredType(), value.data());
		return true;
		}

		template <typename Scalar>
		bool HDF5Reader::execute(const std::string& name, std::vector<std::vector<Scalar>>& value) {
		std::string full_name = get_path() + "/" + name;
		@@ -185,37 +158,21 @@ bool HDF5Reader::execute(const std::string& name, std::vector<std::vector<Scalar
		return false;
		}

		const bool equal_size = !exists(full_name + "/data");
		auto size = readSize(full_name)[0];
		const auto type = H5::VarLenType(HDF5_TYPE<Scalar>::get_PredType());

		if (equal_size) {
		auto dims = readSize(full_name);
		assert(dims.size() == 2);
		std::vector<Scalar> linearized(dims[0] * dims[1]);
		std::vector<hvl_t> data(size);

		read(full_name, HDF5_TYPE<Scalar>::get_PredType(), linearized.data());
		value.resize(dims[0]);
		const Scalar* read_location = linearized.data();
		for (auto& v : value) {
		v.resize(dims[1]);
		std::copy_n(read_location, dims[1], v.data());
		read_location += dims[1];
		}
		}
		else {
		open_group(name);
		H5::DataSet dataset = file_->openDataSet(name.c_str());
		dataset.read(data.data(), type);

		int size = -1;
		execute("size", size);
		value.resize(size);

		open_group("data");
		for (int i = 0; i < value.size(); ++i) {
		execute("row_" + std::to_string(i), value[i]);
		for (int i = 0; i < size; ++i) {
		value[i].resize(data[i].len);
		std::copy_n(static_cast<Scalar*>(data[i].p), data[i].len, value[i].data());
		}
		close_group();

		close_group();
		}
		dataset.vlenReclaim(data.data(), type, dataset.getSpace());

		return true;
		}
		@@ -256,47 +213,43 @@ bool HDF5Reader::execute(const std::string& name, func::function<Scalartype, dom

		std::cout << "\n\tstart reading function : " << name;

		// Check sizes.
		H5::DataSet dataset = file_->openDataSet(full_name.c_str());

		try {
		// Read sizes.
		std::vector<hsize_t> dims;
		execute(name + "/" + "domain-sizes", dims);
		auto domain_attribute = dataset.openAttribute("domain-sizes");
		hsize_t n_dims;
		domain_attribute.getSpace().getSimpleExtentDims(&n_dims);
		dims.resize(n_dims);
		domain_attribute.read(HDF5_TYPE<hsize_t>::get_PredType(), dims.data());

		// Check sizes.
		if (dims.size() != f.signature())
		throw(std::length_error("The number of domains is different"));
		for (int i = 0; i < f.signature(); ++i) {
		if (dims[i] != f[i])
		throw(std::length_error("The size of domain " + std::to_string(i) + " is different"));
		}

		read(full_name + "/data", HDF5_TYPE<Scalartype>::get_PredType(), f.values());

		return true;
		}

		template <typename Scalar>
		bool HDF5Reader::execute(const std::string& name, dca::linalg::Vector<Scalar, dca::linalg::CPU>& V) {
		std::string full_name = get_path() + "/" + name;
		if (!exists(full_name)) {
		return false;
		catch (H5::Exception& err) {
		std::cerr << "Could not perform a size check on the function " << name << std::endl;
		}

		auto dims = readSize(full_name);
		assert(dims.size() == 1);
		V.resize(dims.at(0));

		read(full_name, HDF5_TYPE<Scalar>::get_PredType(), V.ptr());
		read(full_name, HDF5_TYPE<Scalartype>::get_PredType(), f.values());

		return true;
		}

		template <typename Scalar>
		bool HDF5Reader::execute(const std::string& name,
		dca::linalg::Vector<std::complex<Scalar>, dca::linalg::CPU>& V) {
		bool HDF5Reader::execute(const std::string& name, dca::linalg::Vector<Scalar, dca::linalg::CPU>& V) {
		std::string full_name = get_path() + "/" + name;
		if (!exists(full_name)) {
		return false;
		}

		auto dims = readSize(full_name);
		assert(dims.size() == 2);
		assert(dims.size() == 1);
		V.resize(dims.at(0));

		read(full_name, HDF5_TYPE<Scalar>::get_PredType(), V.ptr());
		@@ -329,31 +282,6 @@ bool HDF5Reader::execute(const std::string& name, dca::linalg::Matrix<Scalar, dc
		return true;
		}

		template <typename Scalar>
		bool HDF5Reader::execute(const std::string& name,
		dca::linalg::Matrix<std::complex<Scalar>, dca::linalg::CPU>& A) {
		std::string full_name = get_path() + "/" + name;
		if (!exists(full_name)) {
		return false;
		}

		auto dims = readSize(full_name);
		assert(dims.size() == 3);

		std::vector<std::complex<Scalar>> linearized(dims[0] * dims[1]);
		read(full_name, HDF5_TYPE<Scalar>::get_PredType(), linearized.data());

		// HDF5 is column major, while Matrix is row major.
		A.resizeNoCopy(std::make_pair(dims[0], dims[1]));
		for (int i = 0, linindex = 0; i < A.nrRows(); ++i) {
		for (int j = 0; j < A.nrCols(); ++j)
		A(i, j) = linearized[linindex++];
		}

		A.set_name(name);
		return true;
		}

		template <typename Scalar>
		bool HDF5Reader::execute(dca::linalg::Matrix<Scalar, dca::linalg::CPU>& A) {
		return execute(A.get_name(), A);

include/dca/io/hdf5/hdf5_types.hpp

+17 −25

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)
		//
		// HDF5 types.

		@@ -143,42 +144,33 @@ public:
		};

		template <>
		class HDF5_TYPE<std::complex<float>> {
		class HDF5_TYPE<unsigned char> {
		public:
		static hid_t get() {
		return H5T_NATIVE_FLOAT;
		return H5T_NATIVE_UCHAR;
		}

		static H5::PredType get_PredType() {
		return H5::PredType::NATIVE_FLOAT;
		return H5::PredType::NATIVE_UCHAR;
		}
		};

		template <>
		class HDF5_TYPE<std::complex<double>> {
		template <class T>
		class HDF5_TYPE<std::complex<T>> {
		public:
		static hid_t get() {
		return H5T_NATIVE_DOUBLE;
		}

		static H5::PredType get_PredType() {
		return H5::PredType::NATIVE_DOUBLE;
		}
		static H5::CompType get_PredType() {
		auto build_type = []() {
		H5::CompType complex_data_type(2 * sizeof(T));
		complex_data_type.insertMember("r", 0, HDF5_TYPE<T>::get_PredType());
		complex_data_type.insertMember("i", sizeof(T), HDF5_TYPE<T>::get_PredType());
		return complex_data_type;
		};

		template <>
		class HDF5_TYPE<unsigned char> {
		public:
		static hid_t get() {
		return H5T_NATIVE_UCHAR;
		}

		static H5::PredType get_PredType() {
		return H5::PredType::NATIVE_UCHAR;
		static H5::CompType type = build_type();
		return type;
		}
		};

		} // io
		} // dca
		} // namespace io
		} // namespace dca

		#endif // DCA_IO_HDF5_HDF5_TYPES_HPP

include/dca/io/hdf5/hdf5_writer.hpp

+24 −139

Original line number	Diff line number	Diff line
		@@ -74,9 +74,6 @@ public:
		template <typename Scalar>
		void execute(const std::string& name, const std::vector<Scalar>& value);

		template <typename Scalar>
		void execute(const std::string& name, const std::vector<std::complex<Scalar>>& value);

		void execute(const std::string& name, const std::string& value);

		void execute(const std::string& name, const std::vector<std::string>& value);
		@@ -93,29 +90,15 @@ public:
		template <typename Scalar, typename domain_type>
		void execute(const func::function<Scalar, domain_type>& f);

		template <typename Scalar, typename domain_type>
		void execute(const func::function<std::complex<Scalar>, domain_type>& f);

		template <typename Scalar, typename domain_type>
		void execute(const std::string& name, const func::function<Scalar, domain_type>& f);

		template <typename Scalar, typename domain_type>
		void execute(const std::string& name, const func::function<std::complex<Scalar>, domain_type>& f);

		template <typename Scalar>
		void execute(const std::string& name, const dca::linalg::Vector<Scalar, dca::linalg::CPU>& A);

		template <typename Scalar>
		void execute(const std::string& name,
		const dca::linalg::Vector<std::complex<Scalar>, dca::linalg::CPU>& A);

		template <typename Scalar>
		void execute(const std::string& name, const dca::linalg::Matrix<Scalar, dca::linalg::CPU>& A);

		template <typename Scalar>
		void execute(const std::string& name,
		const dca::linalg::Matrix<std::complex<Scalar>, dca::linalg::CPU>& A);

		template <typename Scalar>
		void execute(const dca::linalg::Matrix<Scalar, dca::linalg::CPU>& A) {
		execute(A.get_name(), A);
		@@ -150,8 +133,11 @@ public:
		private:
		bool exists(const std::string& name) const;

		void write(const std::string& name, const std::vector<hsize_t>& size, H5::PredType type,
		H5::DataSet write(const std::string& name, const std::vector<hsize_t>& size, H5::DataType type,
		const void* data);
		void addAttribute(const H5::DataSet& set, const std::string& name,
		const std::vector<hsize_t>& size, H5::DataType type, const void* data);
		void addAttribute(const H5::DataSet& set, const std::string& name, const std::string& value);

		std::unique_ptr<H5::H5File> file_;

		@@ -201,57 +187,19 @@ void HDF5Writer::execute(const std::string& name,
		}
		}

		template <typename Scalar>
		void HDF5Writer::execute(const std::string& name, const std::vector<std::complex<Scalar>>& value) {
		if (value.size() > 0) {
		std::string full_name = get_path() + "/" + name;
		std::vector<hsize_t> dims{value.size(), 2};
		write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), value.data());
		}
		}

		template <typename Scalar>
		void HDF5Writer::execute(const std::string& name, const std::vector<std::vector<Scalar>>& value) {
		if (value.size() > 0) {
		std::string full_name = get_path() + "/" + name;

		bool all_the_same_size = true;
		const std::size_t cols = value[0].size();
		for (auto& v : value) {
		if (v.size() != cols) {
		all_the_same_size = false;
		break;
		}
		}

		if (all_the_same_size) {
		std::vector<hsize_t> dims{value.size(), cols};
		std::vector<Scalar> linearized(dims[0] * dims[1]);

		for (std::size_t i = 0, linindex = 0; i < value.size(); ++i)
		for (std::size_t j = 0; j < cols; ++j)
		linearized[linindex++] = value[i][j];

		write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), linearized.data());
		std::vector<hvl_t> data(value.size());
		for (int i = 0; i < value.size(); ++i) {
		data[i].p = const_cast<void>(static_cast<const void>((value[i].data())));
		data[i].len = value[i].size();
		}
		else {
		open_group(full_name);

		execute("size", value.size());
		const auto type = H5::VarLenType(HDF5_TYPE<Scalar>::get_PredType());

		open_group("data");

		std::vector<hsize_t> dims(1);
		for (std::size_t i = 0; i < value.size(); ++i) {
		const std::string new_name = full_name + "/data/row_" + std::to_string(i);
		dims[0] = value[i].size();
		write(new_name, dims, HDF5_TYPE<Scalar>::get_PredType(), value[i].data());
		}

		close_group();
		close_group();
		}
		}
		write(full_name, std::vector<hsize_t>{data.size()}, type, data.data());
		}

		template <typename Scalar, std::size_t n>
		@@ -286,86 +234,37 @@ void HDF5Writer::execute(const func::function<Scalar, domain_type>& f) {
		execute(f.get_name(), f);
		}

		template <typename Scalar, typename domain_type>
		void HDF5Writer::execute(const func::function<std::complex<Scalar>, domain_type>& f) {
		if (f.size() == 0)
		return;

		if (verbose_)
		std::cout << "\t starts writing function : " << f.get_name() << "\n";

		execute(f.get_name(), f);
		}

		template <typename Scalar, typename domain_type>
		void HDF5Writer::execute(const std::string& name, const func::function<Scalar, domain_type>& f) {
		if (f.size() == 0)
		return;

		open_group(name);

		std::string new_path = get_path();

		execute("name", f.get_name());
		const std::string full_name = get_path() + "/" + name;

		std::vector<hsize_t> dims;

		for (int l = 0; l < f.signature(); ++l)
		dims.push_back(f[l]);

		execute("domain-sizes", dims);

		// be carefull --> HDF5 is by default row-major, while the function-class is column-major !
		std::reverse(dims.begin(), dims.end());

		std::string full_name = new_path + "/data";

		write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), f.values());

		close_group();
		}

		template <typename Scalar, typename domain_type>
		void HDF5Writer::execute(const std::string& name,
		const func::function<std::complex<Scalar>, domain_type>& f) {
		if (f.size() == 0)
		return;

		open_group(name);

		std::string new_path = get_path();

		execute("name", f.get_name());

		std::vector<hsize_t> dims;

		for (int l = 0; l < f.signature(); ++l)
		dims.push_back(f[l]);
		auto dataset = write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), f.values());

		execute("domain-sizes", dims);
		addAttribute(dataset, "name", f.get_name());

		// be carefull --> HDF5 is by default row-major, while the function-class is column-major !
		std::reverse(dims.begin(), dims.end());

		dims.push_back(2);
		std::string full_name = get_path() + "/data";
		write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), f.values());

		close_group();
		auto type = HDF5_TYPE<hsize_t>::get_PredType();
		addAttribute(dataset, "domain-sizes", std::vector<hsize_t>{dims.size()}, type, dims.data());
		}

		template <typename Scalar>
		void HDF5Writer::execute(const std::string& name,
		const dca::linalg::Vector<Scalar, dca::linalg::CPU>& V) {
		std::string full_name = get_path() + "/" + name;
		auto dataset =
		write(full_name, std::vector<hsize_t>{V.size()}, HDF5_TYPE<Scalar>::get_PredType(), V.ptr());
		}

		template <typename Scalar>
		void HDF5Writer::execute(const std::string& name,
		const dca::linalg::Vector<std::complex<Scalar>, dca::linalg::CPU>& V) {
		std::string full_name = get_path() + "/" + name;
		write(full_name, std::vector<hsize_t>{V.size(), 2}, HDF5_TYPE<Scalar>::get_PredType(), V.ptr());
		addAttribute(dataset, "name", V.get_name());
		}

		template <typename Scalar>
		@@ -381,23 +280,9 @@ void HDF5Writer::execute(const std::string& name,
		linearized[linindex++] = A(i, j);

		std::string full_name = get_path() + "/" + name;
		write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), linearized.data());
		}
		auto dataset = write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), linearized.data());

		template <typename Scalar>
		void HDF5Writer::execute(const std::string& name,
		const dca::linalg::Matrix<std::complex<Scalar>, dca::linalg::CPU>& A) {
		std::vector<hsize_t> dims{hsize_t(A.nrRows()), hsize_t(A.nrCols()), hsize_t(2)};
		std::vector<std::complex<Scalar>> linearized(A.nrRows() * A.nrCols());

		int linindex = 0;
		// Note: Matrices are row major, while HDF5 is column major
		for (int i = 0; i < A.nrRows(); ++i)
		for (int j = 0; j < A.nrCols(); ++j)
		linearized[linindex++] = A(i, j);

		std::string full_name = get_path() + "/" + name;
		write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), linearized.data());
		addAttribute(dataset, "name", A.get_name());
		}

		template <class T>