Created simple equal time accumulator test. Renamed initialize() -> resetAccumulation(). (fdc4e525) · Commits · NDIP / Tool Sources / Direct-Geometry Spectroscopy / DCA / DCA Main

include/dca/phys/dca_step/cluster_solver/ctaux/accumulator/tp/tp_equal_time_accumulator.hpp

+215 −291

File changed.

Preview size limit exceeded, changes collapsed.

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

+84 −123

Original line number	Diff line number	Diff line
		@@ -3,11 +3,11 @@
		// All rights reserved.
		//
		// See LICENSE for terms of usage.
		// See CITATION.md for citation guidelines, if DCA++ is used for scientific
		// publications.
		// See CITATION.md for citation guidelines, if DCA++ is used for scientific publications.
		//
		// Author: Peter Staar (taa@zurich.ibm.com)
		// Raffaele Solca' (rasolca@itp.phys.ethz.ch)
		// Giovanni Balduzzi (gbalduzz@itp.phys.ethz.ch)
		//
		// This class organizes the measurements in the CT-AUX QMC.

		@@ -64,8 +64,7 @@ public:

		using t = func::dmn_0<domains::time_domain>;
		using w = func::dmn_0<domains::frequency_domain>;
		using w_VERTEX =
		func::dmn_0<domains::vertex_frequency_domain<domains::COMPACT>>;
		using w_VERTEX = func::dmn_0<domains::vertex_frequency_domain<domains::COMPACT>>;

		using b = func::dmn_0<domains::electron_band_domain>;
		using s = func::dmn_0<domains::electron_spin_domain>;
		@@ -85,31 +84,29 @@ public:

		CtauxAccumulator(Parameters& parameters_ref, Data& data_ref, int id);

		template <typename Writer> void write(Writer &writer);
		template <typename Writer>
		void write(Writer& writer);

		void initialize(int dca_iteration);

		template <typename walker_type> void updateFrom(walker_type &walker);
		template <typename walker_type>
		void updateFrom(walker_type& walker);

		void measure();

		// Sums all accumulated objects of this accumulator to the equivalent objects
		// of the 'other'
		// accumulator.
		// of the 'other' accumulator.
		void sumTo(this_type& other);

		void finalize();

		std::vector<vertex_singleton_type> &
		get_configuration(e_spin_states_type e_spin = e_UP);
		std::vector<vertex_singleton_type>& get_configuration(e_spin_states_type e_spin = e_UP);

		func::function<double, func::dmn_0<domains::numerical_error_domain>> &
		get_error_distribution() {
		func::function<double, func::dmn_0<domains::numerical_error_domain>>& get_error_distribution() {
		return error;
		}

		func::function<double, func::dmn_0<Feynman_expansion_order_domain>> &
		get_visited_expansion_order_k() {
		func::function<double, func::dmn_0<Feynman_expansion_order_domain>>& get_visited_expansion_order_k() {
		return visited_expansion_order_k;
		}

		@@ -117,21 +114,17 @@ public:
		func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>>& get_G_r_t() {
		return G_r_t;
		}
		func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>> &
		get_G_r_t_stddev() {
		func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>>& get_G_r_t_stddev() {
		return G_r_t_stddev;
		}

		func::function<double, func::dmn_variadic<b, r_dmn_t>> &
		get_charge_cluster_moment() {
		func::function<double, func::dmn_variadic<b, r_dmn_t>>& get_charge_cluster_moment() {
		return charge_cluster_moment;
		}
		func::function<double, func::dmn_variadic<b, r_dmn_t>> &
		get_magnetic_cluster_moment() {
		func::function<double, func::dmn_variadic<b, r_dmn_t>>& get_magnetic_cluster_moment() {
		return magnetic_cluster_moment;
		}
		func::function<double, func::dmn_variadic<b, r_dmn_t>> &
		get_dwave_pp_correlator() {
		func::function<double, func::dmn_variadic<b, r_dmn_t>>& get_dwave_pp_correlator() {
		return dwave_pp_correlator;
		}

		@@ -149,7 +142,9 @@ public:
		return two_particle_accumulator_.get_sign_times_G4();
		}

		bool compute_std_deviation() const { return compute_std_deviation_; }
		bool compute_std_deviation() const {
		return compute_std_deviation_;
		}

		#ifdef MEASURE_ERROR_BARS
		void store_standard_deviation(int nr_measurements, std::ofstream& points_file,
		@@ -164,8 +159,7 @@ public:
		}

		static std::size_t staticDeviceFingerprint() {
		return accumulator::TpAccumulator<Parameters,
		device_t>::staticDeviceFingerprint();
		return accumulator::TpAccumulator<Parameters, device_t>::staticDeviceFingerprint();
		}

		private:
		@@ -173,10 +167,8 @@ private:

		void accumulate_equal_time_quantities();
		using AccumType = typename Parameters::MC_measurement_scalar_type;
		void accumulate_equal_time_quantities(
		const std::array<linalg::Matrix<AccumType, linalg::GPU>, 2> &M);
		void accumulate_equal_time_quantities(
		const std::array<linalg::Matrix<AccumType, linalg::CPU>, 2> &M);
		void accumulate_equal_time_quantities(const std::array<linalg::Matrix<AccumType, linalg::GPU>, 2>& M);
		void accumulate_equal_time_quantities(const std::array<linalg::Matrix<AccumType, linalg::CPU>, 2>& M);

		void accumulate_two_particle_quantities();

		@@ -203,25 +195,20 @@ protected:
		std::array<dca::linalg::Matrix<AccumType, linalg::CPU>, 2> M_host_;

		func::function<double, func::dmn_0<domains::numerical_error_domain>> error;
		func::function<double, func::dmn_0<Feynman_expansion_order_domain>>
		visited_expansion_order_k;
		func::function<double, func::dmn_0<Feynman_expansion_order_domain>> visited_expansion_order_k;

		func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>> G_r_t;
		func::function<double, func::dmn_variadic<nu, nu, r_dmn_t, t>> G_r_t_stddev;

		func::function<double, func::dmn_variadic<b, r_dmn_t>> charge_cluster_moment;
		func::function<double, func::dmn_variadic<b, r_dmn_t>>
		magnetic_cluster_moment;
		func::function<double, func::dmn_variadic<b, r_dmn_t>> magnetic_cluster_moment;
		func::function<double, func::dmn_variadic<b, r_dmn_t>> dwave_pp_correlator;

		func::function<std::complex<double>, func::dmn_variadic<nu, nu, r_dmn_t, w>>
		M_r_w_stddev;
		func::function<std::complex<double>, func::dmn_variadic<nu, nu, r_dmn_t, w>> M_r_w_stddev;

		accumulator::SpAccumulator<Parameters, device_t>
		single_particle_accumulator_obj;
		accumulator::SpAccumulator<Parameters, device_t> single_particle_accumulator_obj;

		ctaux::TpEqualTimeAccumulator<Parameters, Data>
		MC_two_particle_equal_time_accumulator_obj;
		ctaux::TpEqualTimeAccumulator<Parameters, Data> MC_two_particle_equal_time_accumulator_obj;

		accumulator::TpAccumulator<Parameters, device_t> two_particle_accumulator_;

		@@ -229,11 +216,12 @@ protected:
		};

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		CtauxAccumulator<device_t, Parameters, Data>::CtauxAccumulator(
		Parameters &parameters_ref, Data &data_ref, int id)
		CtauxAccumulator<device_t, Parameters, Data>::CtauxAccumulator(Parameters& parameters_ref,
		Data& data_ref, int id)
		: MC_accumulator_data(),

		parameters_(parameters_ref), data_(data_ref),
		parameters_(parameters_ref),
		data_(data_ref),
		concurrency(parameters_.get_concurrency()),

		thread_id(id),
		@@ -244,7 +232,8 @@ CtauxAccumulator<device_t, Parameters, Data>::CtauxAccumulator(
		error("numerical-error-distribution-of-N-matrices"),
		visited_expansion_order_k("<k>"),

		G_r_t("G_r_t_measured"), G_r_t_stddev("G_r_t_stddev"),
		G_r_t("G_r_t_measured"),
		G_r_t_stddev("G_r_t_stddev"),

		charge_cluster_moment("charge-cluster-moment"),
		magnetic_cluster_moment("magnetic-cluster-moment"),
		@@ -259,8 +248,7 @@ CtauxAccumulator<device_t, Parameters, Data>::CtauxAccumulator(
		two_particle_accumulator_(data_.G0_k_w_cluster_excluded, parameters_) {}

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		void CtauxAccumulator<device_t, Parameters, Data>::initialize(
		int dca_iteration) {
		void CtauxAccumulator<device_t, Parameters, Data>::initialize(int dca_iteration) {
		// Note: profiling this function breaks the PAPI profiler as both the master
		// thread and the first
		// worker call this with the same thread_id.
		@@ -290,7 +278,7 @@ void CtauxAccumulator<device_t, Parameters, Data>::initialize(
		magnetic_cluster_moment = 0;
		dwave_pp_correlator = 0;

		MC_two_particle_equal_time_accumulator_obj.initialize();
		MC_two_particle_equal_time_accumulator_obj.resetAccumulation();
		}
		}

		@@ -303,11 +291,9 @@ void CtauxAccumulator<device_t, Parameters, Data>::finalize() {

		if (compute_std_deviation_) {
		const auto& M_r_w = single_particle_accumulator_obj.get_sign_times_M_r_w();
		const auto &M_r_w_squared =
		single_particle_accumulator_obj.get_sign_times_M_r_w_sqr();
		const auto& M_r_w_squared = single_particle_accumulator_obj.get_sign_times_M_r_w_sqr();
		for (int l = 0; l < M_r_w_stddev.size(); l++)
		M_r_w_stddev(l) =
		std::sqrt(abs(M_r_w_squared(l)) - std::pow(abs(M_r_w(l)), 2));
		M_r_w_stddev(l) = std::sqrt(abs(M_r_w_squared(l)) - std::pow(abs(M_r_w(l)), 2));

		double factor = 1. / std::sqrt(parameters_.get_measurements() - 1);

		@@ -318,15 +304,12 @@ void CtauxAccumulator<device_t, Parameters, Data>::finalize() {
		MC_two_particle_equal_time_accumulator_obj.finalize();

		G_r_t = MC_two_particle_equal_time_accumulator_obj.get_G_r_t();
		G_r_t_stddev =
		MC_two_particle_equal_time_accumulator_obj.get_G_r_t_stddev();

		charge_cluster_moment =
		MC_two_particle_equal_time_accumulator_obj.get_charge_cluster_moment();
		magnetic_cluster_moment = MC_two_particle_equal_time_accumulator_obj
		.get_magnetic_cluster_moment();
		dwave_pp_correlator =
		MC_two_particle_equal_time_accumulator_obj.get_dwave_pp_correlator();
		G_r_t_stddev = MC_two_particle_equal_time_accumulator_obj.get_G_r_t_stddev();

		charge_cluster_moment = MC_two_particle_equal_time_accumulator_obj.get_charge_cluster_moment();
		magnetic_cluster_moment =
		MC_two_particle_equal_time_accumulator_obj.get_magnetic_cluster_moment();
		dwave_pp_correlator = MC_two_particle_equal_time_accumulator_obj.get_dwave_pp_correlator();
		}

		if (perform_tp_accumulation_)
		@@ -334,8 +317,7 @@ void CtauxAccumulator<device_t, Parameters, Data>::finalize() {
		}

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		std::vector<vertex_singleton> &
		CtauxAccumulator<device_t, Parameters, Data>::get_configuration(
		std::vector<vertex_singleton>& CtauxAccumulator<device_t, Parameters, Data>::get_configuration(
		e_spin_states_type e_spin) {
		if (e_spin == e_UP)
		return hs_configuration_[0];
		@@ -379,10 +361,8 @@ void CtauxAccumulator<device_t, Parameters, Data>::write(Writer &writer) {
		*/
		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		template <typename walker_type>
		void CtauxAccumulator<device_t, Parameters, Data>::updateFrom(
		walker_type &walker) {
		profiler_type profiler("update from", "CT-AUX accumulator", __LINE__,
		thread_id);
		void CtauxAccumulator<device_t, Parameters, Data>::updateFrom(walker_type& walker) {
		profiler_type profiler("update from", "CT-AUX accumulator", __LINE__, thread_id);

		GFLOP += walker.get_Gflop();

		@@ -443,8 +423,7 @@ void CtauxAccumulator<device_t, Parameters, Data>::measure() {
		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		void CtauxAccumulator<device_t, Parameters, Data>::store_standard_deviation(
		int nr_measurements, std::ofstream& points_file, std::ofstream& norm_file) {
		single_particle_accumulator_obj.store_standard_deviation(
		nr_measurements, points_file, norm_file);
		single_particle_accumulator_obj.store_standard_deviation(nr_measurements, points_file, norm_file);
		}

		/*!
		@@ -465,13 +444,10 @@ void CtauxAccumulator<device_t, Parameters, Data>::update_sum_squares() {
		*************************************************************/

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		void CtauxAccumulator<device_t, Parameters,
		Data>::accumulate_single_particle_quantities() {
		profiler_type profiler("sp-accumulation", "CT-AUX accumulator", __LINE__,
		thread_id);
		void CtauxAccumulator<device_t, Parameters, Data>::accumulate_single_particle_quantities() {
		profiler_type profiler("sp-accumulation", "CT-AUX accumulator", __LINE__, thread_id);

		single_particle_accumulator_obj.accumulate(M_, hs_configuration_,
		current_sign);
		single_particle_accumulator_obj.accumulate(M_, hs_configuration_, current_sign);

		GFLOP += 2. * 8. * M_[1].size().first * M_[1].size().first * (1.e-9);
		GFLOP += 2. * 8. * M_[0].size().first * M_[0].size().first * (1.e-9);
		@@ -484,17 +460,14 @@ void CtauxAccumulator<device_t, Parameters,
		*************************************************************/

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		void CtauxAccumulator<device_t, Parameters,
		Data>::accumulate_equal_time_quantities() {
		profiler_type profiler("equal-time-measurements", "CT-AUX accumulator",
		__LINE__, thread_id);
		void CtauxAccumulator<device_t, Parameters, Data>::accumulate_equal_time_quantities() {
		profiler_type profiler("equal-time-measurements", "CT-AUX accumulator", __LINE__, thread_id);

		return accumulate_equal_time_quantities(M_);
		}

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		void CtauxAccumulator<device_t, Parameters, Data>::
		accumulate_equal_time_quantities(
		void CtauxAccumulator<device_t, Parameters, Data>::accumulate_equal_time_quantities(
		const std::array<linalg::Matrix<AccumType, linalg::GPU>, 2>& M) {
		for (int s = 0; s < 2; ++s)
		M_host_[s].setAsync(M[s], thread_id, s);
		@@ -505,18 +478,10 @@ void CtauxAccumulator<device_t, Parameters, Data>::
		}

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		void CtauxAccumulator<device_t, Parameters, Data>::
		accumulate_equal_time_quantities(
		void CtauxAccumulator<device_t, Parameters, Data>::accumulate_equal_time_quantities(
		const std::array<linalg::Matrix<AccumType, linalg::CPU>, 2>& M) {
		MC_two_particle_equal_time_accumulator_obj.compute_G_r_t(
		hs_configuration_[0], M[0], hs_configuration_[1], M[1]);

		MC_two_particle_equal_time_accumulator_obj.accumulate_G_r_t(current_sign);

		MC_two_particle_equal_time_accumulator_obj.accumulate_moments(current_sign);

		MC_two_particle_equal_time_accumulator_obj.accumulate_dwave_pp_correlator(
		current_sign);
		MC_two_particle_equal_time_accumulator_obj.accumulateAll(
		hs_configuration_[0], M[0], hs_configuration_[1], M[1], current_sign);

		GFLOP += MC_two_particle_equal_time_accumulator_obj.get_GFLOP();
		}
		@@ -528,12 +493,9 @@ void CtauxAccumulator<device_t, Parameters, Data>::
		*************************************************************/

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		void CtauxAccumulator<device_t, Parameters,
		Data>::accumulate_two_particle_quantities() {
		profiler_type profiler("tp-accumulation", "CT-AUX accumulator", __LINE__,
		thread_id);
		/GFLOP +=/two_particle_accumulator_.accumulate(M_, hs_configuration_,
		current_sign);
		void CtauxAccumulator<device_t, Parameters, Data>::accumulate_two_particle_quantities() {
		profiler_type profiler("tp-accumulation", "CT-AUX accumulator", __LINE__, thread_id);
		/GFLOP +=/two_particle_accumulator_.accumulate(M_, hs_configuration_, current_sign);
		}

		template <dca::linalg::DeviceType device_t, class Parameters, class Data>
		@@ -552,8 +514,7 @@ void CtauxAccumulator<device_t, Parameters, Data>::sumTo(this_type &other) {
		// equal time measurements
		if (DCA_iteration == parameters_.get_dca_iterations() - 1 &&
		parameters_.additional_time_measurements())
		MC_two_particle_equal_time_accumulator_obj.sumTo(
		other.MC_two_particle_equal_time_accumulator_obj);
		MC_two_particle_equal_time_accumulator_obj.sumTo(other.MC_two_particle_equal_time_accumulator_obj);

		// tp-measurements
		if (perform_tp_accumulation_)

test/unit/phys/dca_step/cluster_solver/CMakeLists.txt

+1 −1

Original line number	Diff line number	Diff line
		# test/unit/phys/dca_step/cluster_solver

		add_subdirectory(ctaux/structs)
		add_subdirectory(ctaux)
		add_subdirectory(shared_tools)
		add_subdirectory(thread_qmci)

test/unit/phys/dca_step/cluster_solver/ctaux/CMakeLists.txt

0 → 100644

+4 −0

Original line number	Diff line number	Diff line
		# test/unit/phys/dca_step/cluster_solver/ctaux

		add_subdirectory(accumulator/tp)
		add_subdirectory(structs)

test/unit/phys/dca_step/cluster_solver/ctaux/accumulator/tp/CMakeLists.txt

0 → 100644

+6 −0

Original line number	Diff line number	Diff line
		dca_add_gtest(tp_equal_time_accumulator_test
		FAST
		GTEST_MAIN
		INCLUDE_DIRS ${DCA_INCLUDE_DIRS};${PROJECT_SOURCE_DIR}
		LIBS ${DCA_LIBS}
		)