Merge pull request #125 from CompFUSE/fix_116 (0074aa1b) · Commits · NDIP / Tool Sources / Direct-Geometry Spectroscopy / DCA / DCA Main

include/dca/function/domains/dmn_variadic.hpp

+32 −30

Original line number	Diff line number	Diff line
		@@ -59,30 +59,32 @@ public:
		// If sizeof(args) == sizeof(domains): calls index via branch domains.
		// If sizeof(args) == sizeof(leaf domains): calls index via leaf domains.
		template <typename... Args>
		int operator()(Args&&... args) const;
		std::size_t operator()(Args&&... args) const;

		protected:
		// Indexing operator: accesses elements of the domain via branches.
		// index_lookup is overloaded on std::integral_constant<bool, true>::type so that if
		// sizeof...(Args) == sizeof...(domain_list) then this is called.
		template <typename... Args>
		int index_lookup(std::integral_constant<bool, true>::type, int branch_i0, Args... args) const;
		std::size_t index_lookup(std::integral_constant<bool, true>::type, int branch_i0,
		Args... args) const;

		// Indexing operator: accesses elements of the domain via leaf domains.
		// index_lookup is overloaded on std::integral_constant<bool, true>::type so that if
		// sizeof...(Args) == sizeof...(domain_list) then this is called.
		template <typename... Args>
		int index_lookup(std::integral_constant<bool, false>::type, int leaf_i0, Args... args) const;
		std::size_t index_lookup(std::integral_constant<bool, false>::type, int leaf_i0, Args... args) const;

		// Gets the branch domain sizes for each of the domain template arguments.
		// Returns a vector of the sizes.
		template <typename Tuple, std::size_t... DomainIndex>
		std::vector<int> init_branch_domain_sizes(Tuple& t, std::index_sequence<DomainIndex...>);
		std::vector<std::size_t> init_branch_domain_sizes(Tuple& t, std::index_sequence<DomainIndex...>);

		// Gets the number of leaf domains for each of the domain template arguments.
		// Returns a vector of the counts.
		template <typename Tuple, std::size_t... DomainIndex>
		std::vector<int> init_leaf_domain_sizes(Tuple& domaintuple, std::index_sequence<DomainIndex...>);
		std::vector<std::size_t> init_leaf_domain_sizes(Tuple& domaintuple,
		std::index_sequence<DomainIndex...>);

		protected:
		std::tuple<domain_list...> domains;
		@@ -90,14 +92,14 @@ protected:

		template <typename... domain_list>
		template <typename Tuple, std::size_t... DomainIndex>
		std::vector<int> dmn_variadic<domain_list...>::init_branch_domain_sizes(
		std::vector<std::size_t> dmn_variadic<domain_list...>::init_branch_domain_sizes(
		Tuple& domaintuple, std::index_sequence<DomainIndex...>) {
		return {(std::get<DomainIndex>(domaintuple).get_size())...};
		}

		template <typename... domain_list>
		template <typename Tuple, std::size_t... DomainIndex>
		std::vector<int> dmn_variadic<domain_list...>::init_leaf_domain_sizes(
		std::vector<std::size_t> dmn_variadic<domain_list...>::init_leaf_domain_sizes(
		Tuple& domaintuple, std::index_sequence<DomainIndex...>) {
		return {(std::get<DomainIndex>(domaintuple).get_Nb_leaf_domains())...};
		}
		@@ -141,12 +143,12 @@ T sum(T first, Args... args) {
		}

		template <typename... Args, std::size_t... Is>
		int multiply_offsets(const std::vector<int>& multipliers, std::index_sequence<Is...>,
		Args&&... offsets) {
		std::size_t multiply_offsets(const std::vector<std::size_t>& multipliers,
		std::index_sequence<Is...>, Args&&... offsets) {
		return sum((offsets * (multipliers[Is]))...);
		}

		} // detail
		} // namespace detail

		template <typename... domain_list>
		dmn_variadic<domain_list...>::dmn_variadic() : domain() {
		@@ -169,7 +171,7 @@ void dmn_variadic<domain_list...>::reset() {
		// std::endl
		// << "domain sizes : ";
		// std::copy(branch_domain_sizes.begin(), branch_domain_sizes.end(),
		// std::ostream_iterator<int>(std::cout, ","));
		// std::ostream_iterator<std::size_t>(std::cout, ","));
		// std::cout << std::endl;

		branch_domain_steps.resize(branch_domain_sizes.size(), 1);
		@@ -181,17 +183,17 @@ void dmn_variadic<domain_list...>::reset() {

		// std::cout << "Steps ";
		// std::copy(branch_domain_steps.begin(), branch_domain_steps.end(),
		// std::ostream_iterator<int>(std::cout, ","));
		// std::ostream_iterator<std::size_t>(std::cout, ","));
		// std::cout << std::endl;

		// Generate the leaf domain sizes from each sub domain.
		auto leaf_stuff = init_leaf_domain_sizes(domains, indices);
		// std::cout << "Leaf stuff ";
		// std::copy(leaf_stuff.begin(), leaf_stuff.end(), std::ostream_iterator<int>(std::cout, ","));
		// std::cout << std::endl;
		// std::copy(leaf_stuff.begin(), leaf_stuff.end(), std::ostream_iterator<std::size_t>(std::cout,
		// ",")); std::cout << std::endl;

		detail::for_each_in_tuple(domains, [this](auto& d) {
		std::vector<int> temp = d.get_leaf_domain_sizes();
		std::vector<std::size_t> temp = d.get_leaf_domain_sizes();
		std::copy(std::begin(temp), std::end(temp), std::back_inserter(leaf_domain_sizes));
		});

		@@ -206,7 +208,7 @@ void dmn_variadic<domain_list...>::reset() {

		// std::cout << "leaf step size ";
		// std::copy(leaf_domain_steps.begin(), leaf_domain_steps.end(),
		// std::ostream_iterator<int>(std::cout, ","));
		// std::ostream_iterator<std::size_t>(std::cout, ","));
		// std::cout << std::endl;

		size = 1;
		@@ -220,20 +222,20 @@ void dmn_variadic<domain_list...>::reset() {

		template <typename... domain_list>
		template <typename... Args>
		int dmn_variadic<domain_list...>::operator()(Args&&... args) const {
		std::size_t dmn_variadic<domain_list...>::operator()(Args&&... args) const {
		static_assert(sizeof...(Args) >= sizeof...(domain_list), "not enough args");
		return index_lookup(std::integral_constant<bool, (sizeof...(Args) == sizeof...(domain_list))>(),
		std::forward<Args>(args)...);
		}

		template <typename... Args, std::size_t... Is>
		void check_indices(const char* /msg/, const std::vector<int>& sizes, std::index_sequence<Is...>,
		Args&&... indices) {
		void check_indices(const char* /msg/, const std::vector<std::size_t>& sizes,
		std::index_sequence<Is...>, Args&&... indices) {
		if (std::min({(sizes[Is] - indices)...}) <= 0) {
		dca::util::ignoreReturnValues(
		(std::cerr << "size " << sizes[Is] << " index " << indices << " ")...);
		std::cerr << " : Index too big error" << std::endl;
		std::copy(sizes.begin(), sizes.end(), std::ostream_iterator<int>(std::cerr, ","));
		std::copy(sizes.begin(), sizes.end(), std::ostream_iterator<std::size_t>(std::cerr, ","));
		throw std::runtime_error("Index too big error");
		}
		if (std::min({indices...}) < 0) {
		@@ -244,7 +246,7 @@ void check_indices(const char* /msg/, const std::vector<int>& sizes, std::inde

		template <typename... domain_list>
		template <typename... Args>
		int dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, true>::type,
		std::size_t dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, true>::type,
		int branch_i0, Args... branch_indices) const {
		static_assert(sizeof...(Args) + 1 == sizeof...(domain_list), "not enough args");

		@@ -257,14 +259,14 @@ int dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, true
		std::forward<Args>(branch_indices)...);
		#endif // NDEBUG

		int N = branch_i0 +
		detail::multiply_offsets(branch_domain_steps, seq, std::forward<Args>(branch_indices)...);
		std::size_t N = branch_i0 + detail::multiply_offsets(branch_domain_steps, seq,
		std::forward<Args>(branch_indices)...);
		return N;
		}

		template <typename... domain_list>
		template <typename... Args>
		int dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, false>::type,
		std::size_t dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, false>::type,
		int leaf_i0, Args... leaf_indices) const {
		// Create an index sequence starting from 1, with length sizeof...(args)-1.
		auto seq = detail::make_index_sequence_with_offset<1, sizeof...(Args)>();
		@@ -274,12 +276,12 @@ int dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, fals
		check_indices("leaf", leaf_domain_sizes, seq2, leaf_i0, std::forward<Args>(leaf_indices)...);
		#endif // NDEBUG

		int N = leaf_i0 +
		detail::multiply_offsets(leaf_domain_steps, seq, std::forward<Args>(leaf_indices)...);
		std::size_t N = leaf_i0 + detail::multiply_offsets(leaf_domain_steps, seq,
		std::forward<Args>(leaf_indices)...);
		return N;
		}

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

		#endif // DCA_FUNCTION_DOMAINS_DMN_VARIADIC_HPP

include/dca/function/domains/domain.hpp

+16 −16

Original line number	Diff line number	Diff line
		@@ -25,11 +25,11 @@ public:
		void reset();

		// domain interface functions
		int get_size() const {
		std::size_t get_size() const {
		return size;
		}

		const std::vector<int>& get_branch_domain_sizes() const {
		const std::vector<std::size_t>& get_branch_domain_sizes() const {
		return branch_domain_sizes;
		}
		int get_Nb_branch_domains() const {
		@@ -39,38 +39,38 @@ public:
		return branch_domain_sizes[branch_index];
		}

		const std::vector<int>& get_leaf_domain_sizes() const {
		const std::vector<std::size_t>& get_leaf_domain_sizes() const {
		return leaf_domain_sizes;
		}
		int get_Nb_leaf_domains() const {
		std::size_t get_Nb_leaf_domains() const {
		return leaf_domain_sizes.size();
		}
		int get_subdomain_size(const int subdomain_index) const {
		std::size_t get_subdomain_size(const int subdomain_index) const {
		return leaf_domain_sizes[subdomain_index];
		}

		const std::vector<int>& get_leaf_domain_steps() const {
		const std::vector<std::size_t>& get_leaf_domain_steps() const {
		return leaf_domain_steps;
		}
		const std::vector<int>& get_branch_domain_steps() const {
		const std::vector<std::size_t>& get_branch_domain_steps() const {
		return branch_domain_steps;
		}

		// linind <--> subdomain_indices != branch_indices
		void linind_2_subind(int linind, int* subind) const;
		void subind_2_linind(const int* subind, int& linind) const;
		void linind_2_subind(std::size_t linind, int* subind) const;
		void subind_2_linind(const int* subind, std::size_t& linind) const;

		protected:
		int size;
		std::size_t size;

		std::vector<int> branch_domain_sizes;
		std::vector<int> leaf_domain_sizes;
		std::vector<std::size_t> branch_domain_sizes;
		std::vector<std::size_t> leaf_domain_sizes;

		std::vector<int> branch_domain_steps;
		std::vector<int> leaf_domain_steps;
		std::vector<std::size_t> branch_domain_steps;
		std::vector<std::size_t> leaf_domain_steps;
		};

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

		#endif // DCA_FUNCTION_DOMAINS_DOMAIN_HPP

include/dca/function/function.hpp

+4 −4

Original line number	Diff line number	Diff line
		@@ -97,7 +97,7 @@ public:
		int signature() const {
		return Nb_sbdms;
		}
		int size() const {
		std::size_t size() const {
		return Nb_elements;
		}
		// Returns the size of the leaf domain with the given index.
		@@ -238,12 +238,12 @@ private:

		domain dmn; // TODO: Remove domain object?

		int Nb_elements;
		std::size_t Nb_elements;

		// The subdomains (sbdmn) represent the leaf domains, not the branch domains.
		int Nb_sbdms;
		const std::vector<int>& size_sbdm; // TODO: Remove?
		const std::vector<int>& step_sbdm; // TODO: Remove?
		const std::vector<std::size_t>& size_sbdm; // TODO: Remove?
		const std::vector<std::size_t>& step_sbdm; // TODO: Remove?

		scalartype* fnc_values;
		};

include/dca/math/nfft/dnfft_1d.hpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -254,7 +254,7 @@ inline void Dnfft1D<ScalarType, WDmn, PDmn, oversampling, mode>::accumulate(cons
		const ScalarType t_val,
		const ScalarType f_val) {
		const static PDmn p_dmn_obj;
		int linind = 0;
		std::size_t linind = 0;
		p_dmn_obj.subind_2_linind(subind, linind);
		accumulate(linind, t_val, f_val);
		}

include/dca/parallel/mpi_concurrency/mpi_collective_max.hpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@ public:
		void max(Scalar& value) const {
		Scalar result;

		MPI_Allreduce(&value, &result, MPITypeMap<Scalar>::factor(), MPITypeMap<Scalar>::value(),
		MPI_Allreduce(&value, &result, 1, MPITypeMap<Scalar>::value(),
		MPI_MAX, MPIProcessorGrouping::get());

		value = result;