Properly write complex types. Comptattible with h5py. (d61b054e) · Commits · NDIP / Tool Sources / Direct-Geometry Spectroscopy / DCA / DCA Main

include/dca/io/hdf5/hdf5_reader.hpp

+0 −69

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);

		@@ -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;
		@@ -284,23 +257,6 @@ bool HDF5Reader::execute(const std::string& name, dca::linalg::Vector<Scalar, dc
		return true;
		}

		template <typename Scalar>
		bool HDF5Reader::execute(const std::string& name,
		dca::linalg::Vector<std::complex<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);
		V.resize(dims.at(0));

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

		return true;
		}

		template <typename Scalar>
		bool HDF5Reader::execute(const std::string& name, dca::linalg::Matrix<Scalar, dca::linalg::CPU>& A) {
		std::string full_name = get_path() + "/" + name;
		@@ -326,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

+0 −93

Original line number	Diff line number	Diff line
		@@ -72,9 +72,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);
		@@ -91,29 +88,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);
		@@ -200,15 +183,6 @@ 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) {
		std::string full_name = get_path() + "/" + name;
		@@ -256,17 +230,6 @@ 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)
		@@ -290,34 +253,6 @@ void HDF5Writer::execute(const std::string& name, const func::function<Scalar, d
		addAttribute(dataset, "domain-sizes", std::vector<hsize_t>{dims.size()}, type, dims.data());
		}

		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;

		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]);

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

		// Add real-imaginary dimension
		dims.push_back(2);

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

		addAttribute(dataset, "name", f.get_name());

		dims.pop_back();
		std::reverse(dims.begin(), dims.end());
		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) {
		@@ -328,16 +263,6 @@ void HDF5Writer::execute(const std::string& name,
		addAttribute(dataset, "name", V.get_name());
		}

		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;
		auto dataset = 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>
		void HDF5Writer::execute(const std::string& name,
		const dca::linalg::Matrix<Scalar, dca::linalg::CPU>& A) {
		@@ -356,24 +281,6 @@ void HDF5Writer::execute(const std::string& name,
		addAttribute(dataset, "name", A.get_name());
		}

		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;
		auto dataset = write(full_name, dims, HDF5_TYPE<Scalar>::get_PredType(), linearized.data());

		addAttribute(dataset, "name", A.get_name());
		}

		template <class T>
		void HDF5Writer::execute(const std::string& name, const std::unique_ptr<T>& obj) {
		if (obj)

test/integration/cluster_solver/ctaux/bilayer_lattice/Nc1_interband/check_data.QMC.hdf5

+5.73 KiB (264 KiB)

File changed.

No diff preview for this file type.

View original file

View changed file

test/integration/cluster_solver/ctaux/bilayer_lattice/Nc1_interband/data.ED.hdf5

−6.73 KiB (3.14 MiB)

File changed.

No diff preview for this file type.

View original file

View changed file