25#include <boost/archive/binary_iarchive.hpp>
26#include <boost/archive/binary_oarchive.hpp>
27#include <boost/iostreams/device/array.hpp>
28#include <boost/iostreams/stream.hpp>
29#include <boost/range/algorithm/transform.hpp>
30#include <boost/serialization/string.hpp>
31#include <boost/serialization/vector.hpp>
46int min(
int i,
unsigned int j) {
return std::min(i,
static_cast<int>(j)); }
52 std::vector<double>
const &A2) {
53 assert(A1.size() == A2.size());
54 std::vector<double> A_compressed(A1.size());
56 std::transform(A1.begin(), A1.end(), A2.begin(), A_compressed.begin(),
57 [](
double a,
double b) ->
double { return 0.5 * (a + b); });
64 std::vector<double>
const &A2) {
65 assert(A1.size() == A2.size());
66 std::vector<double> A_compressed(A2);
72 std::vector<double>
const &A2) {
73 assert(A1.size() == A2.size());
74 std::vector<double> A_compressed(A1);
79 std::vector<double>
const &B,
81 if (A.size() != B.size()) {
82 throw std::runtime_error(
83 "Error in scalar product: The vector sizes do not match");
86 auto const result = std::inner_product(A.begin(), A.end(), B.begin(), 0.0);
91 std::vector<double>
const &B,
93 std::vector<double> C(A.size());
94 if (A.size() != B.size()) {
95 throw std::runtime_error(
96 "Error in componentwise product: The vector sizes do not match");
99 std::transform(A.begin(), A.end(), B.begin(), C.begin(), std::multiplies<>());
105 std::vector<double>
const &B,
107 std::vector<double> C(A.size() * B.size());
108 auto C_it = C.begin();
120 std::vector<double>
const &B,
122 if (A.size() != B.size()) {
123 throw std::runtime_error(
124 "Error in square distance componentwise: The vector sizes do not "
128 std::vector<double> C(A.size());
131 A.begin(), A.end(), B.begin(), C.begin(),
132 [](
double a,
double b) ->
double { return Utils::sqr(a - b); });
139std::vector<double>
fcs_acf(std::vector<double>
const &A,
140 std::vector<double>
const &B,
142 if (A.size() != B.size()) {
143 throw std::runtime_error(
144 "Error in fcs_acf: The vector sizes do not match.");
147 auto const C_size = A.size() / 3;
148 assert(3 * C_size == A.size());
150 std::vector<double> C(C_size, 0);
152 for (std::size_t i = 0; i < C_size; i++) {
153 for (
int j = 0; j < 3; j++) {
154 auto const &a = A[3 * i + j];
155 auto const &b = B[3 * i + j];
161 std::transform(C.begin(), C.end(), C.begin(),
162 [](
double c) ->
double { return std::exp(c); });
167void Correlator::initialize() {
170 if (m_tau_lin == 1) {
171 m_tau_lin =
static_cast<int>(ceil(m_tau_max / m_dt));
177 throw std::runtime_error(
"tau_lin must be >= 2");
181 throw std::runtime_error(
"tau_lin must be divisible by 2");
184 if (m_tau_max <= m_dt) {
185 throw std::runtime_error(
"tau_max must be >= delta_t (delta_N too large)");
188 if ((m_tau_max / m_dt) < m_tau_lin) {
189 m_hierarchy_depth = 1;
191 m_hierarchy_depth =
static_cast<int>(
192 ceil(1 + log((m_tau_max / m_dt) / (m_tau_lin - 1)) / log(2.0)));
197 dim_A = A_obs->n_values();
198 dim_B = B_obs->n_values();
201 throw std::runtime_error(
"dimension of first observable has to be >= 1");
204 throw std::runtime_error(
"dimension of second observable has to be >= 1");
208 if (corr_operation_name ==
"componentwise_product") {
210 m_shape = A_obs->shape();
213 }
else if (corr_operation_name ==
"tensor_product") {
214 m_dim_corr = dim_A * dim_B;
215 m_shape = {dim_A, dim_B};
218 }
else if (corr_operation_name ==
"square_distance_componentwise") {
220 m_shape = A_obs->shape();
223 }
else if (corr_operation_name ==
"fcs_acf") {
226 if (m_correlation_args[0] <= 0 || m_correlation_args[1] <= 0 ||
227 m_correlation_args[2] <= 0) {
228 throw std::runtime_error(
"missing parameter for fcs_acf: w_x w_y w_z");
233 throw std::runtime_error(
"dimA must be divisible by 3 for fcs_acf");
234 m_dim_corr = dim_A / 3;
235 m_shape = A_obs->shape();
236 if (m_shape.back() != 3)
237 throw std::runtime_error(
238 "the last dimension of dimA must be 3 for fcs_acf");
241 }
else if (corr_operation_name ==
"scalar_product") {
247 throw std::invalid_argument(
"correlation operation '" +
248 corr_operation_name +
"' not implemented");
252 if (compressA_name ==
"discard2") {
254 }
else if (compressA_name ==
"discard1") {
256 }
else if (compressA_name ==
"linear") {
259 throw std::invalid_argument(
"unknown compression method '" +
260 compressA_name +
"' for first observable");
263 if (compressB_name ==
"discard2") {
265 }
else if (compressB_name ==
"discard1") {
267 }
else if (compressB_name ==
"linear") {
270 throw std::invalid_argument(
"unknown compression method '" +
271 compressB_name +
"' for second observable");
274 using index_type =
decltype(result)::index;
276 A.resize(std::array<int, 2>{{m_hierarchy_depth, m_tau_lin + 1}});
277 std::fill_n(A.data(), A.num_elements(), std::vector<double>(dim_A, 0));
278 B.resize(std::array<int, 2>{{m_hierarchy_depth, m_tau_lin + 1}});
279 std::fill_n(B.data(), B.num_elements(), std::vector<double>(dim_B, 0));
282 A_accumulated_average = std::vector<double>(dim_A, 0);
283 B_accumulated_average = std::vector<double>(dim_B, 0);
286 n_sweeps = std::vector<std::size_t>(n_result, 0);
287 n_vals = std::vector<long>(m_hierarchy_depth, 0);
289 result.resize(std::array<std::size_t, 2>{{n_result, m_dim_corr}});
290 for (index_type i = 0; i < static_cast<index_type>(n_result); i++) {
291 for (index_type j = 0; j < static_cast<index_type>(m_dim_corr); j++) {
296 newest = std::vector<long>(m_hierarchy_depth, m_tau_lin);
298 tau.resize(n_result);
299 for (
int i = 0; i < m_tau_lin + 1; i++) {
303 for (
int j = 1; j < m_hierarchy_depth; j++) {
304 for (
int k = 0; k < m_tau_lin / 2; k++) {
305 tau[m_tau_lin + 1 + (j - 1) * m_tau_lin / 2 + k] =
306 (k + (m_tau_lin / 2) + 1) * (1 << j);
313 throw std::runtime_error(
314 "No data can be added after finalize() was called.");
317 if (comm.rank() != 0) {
319 A_obs->operator()(comm);
320 if (A_obs != B_obs) {
321 B_obs->operator()(comm);
330 int highest_level_to_compress = -1;
337 auto const max_depth = m_hierarchy_depth - 1;
340 if (i >= max_depth or n_vals[i] <= m_tau_lin) {
343 auto const modulo = 1 << (i + 1);
344 auto const remainder = (t - (m_tau_lin + 1) * (modulo - 1) - 1) % modulo;
345 if (remainder != 0) {
348 highest_level_to_compress += 1;
356 for (
int i = highest_level_to_compress; i >= 0; i--) {
359 newest[i + 1] = (newest[i + 1] + 1) % (m_tau_lin + 1);
361 A[i + 1][newest[i + 1]] =
362 (*compressA)(A[i][(newest[i] + 1) % (m_tau_lin + 1)],
363 A[i][(newest[i] + 2) % (m_tau_lin + 1)]);
364 B[i + 1][newest[i + 1]] =
365 (*compressB)(B[i][(newest[i] + 1) % (m_tau_lin + 1)],
366 B[i][(newest[i] + 2) % (m_tau_lin + 1)]);
369 newest[0] = (newest[0] + 1) % (m_tau_lin + 1);
372 A[0][newest[0]] = A_obs->operator()(comm);
373 if (A_obs != B_obs) {
374 B[0][newest[0]] = B_obs->operator()(comm);
376 B[0][newest[0]] = A[0][newest[0]];
381 for (std::size_t k = 0; k < dim_A; k++) {
382 A_accumulated_average[k] += A[0][newest[0]][k];
385 for (std::size_t k = 0; k < dim_B; k++) {
386 B_accumulated_average[k] += B[0][newest[0]][k];
389 using index_type =
decltype(result)::index;
391 for (
long j = 0; j < min(m_tau_lin + 1, n_vals[0]); j++) {
392 auto const index_new = newest[0];
393 auto const index_old = (newest[0] - j + m_tau_lin + 1) % (m_tau_lin + 1);
395 (corr_operation)(A[0][index_old], B[0][index_new], m_correlation_args);
396 assert(temp.size() == m_dim_corr);
399 for (index_type k = 0; k < static_cast<index_type>(m_dim_corr); k++) {
400 result[j][k] += temp[k];
404 for (
int i = 1; i < highest_level_to_compress + 2; i++) {
405 for (
long j = (m_tau_lin + 1) / 2 + 1; j < min(m_tau_lin + 1, n_vals[i]);
407 auto const index_new = newest[i];
408 auto const index_old = (newest[i] - j + m_tau_lin + 1) % (m_tau_lin + 1);
409 auto const index_res =
410 m_tau_lin + (i - 1) * m_tau_lin / 2 + (j - m_tau_lin / 2 + 1) - 1;
411 auto const temp = (corr_operation)(A[i][index_old], B[i][index_new],
413 assert(temp.size() == m_dim_corr);
415 n_sweeps[index_res]++;
416 for (index_type k = 0; k < static_cast<index_type>(m_dim_corr); k++) {
417 result[index_res][k] += temp[k];
424 using index_type =
decltype(result)::index;
426 throw std::runtime_error(
"Correlator::finalize() can only be called once.");
436 if (comm.rank() != 0) {
440 for (
int ll = 0; ll < m_hierarchy_depth - 1; ll++) {
442 if (n_vals[ll] > m_tau_lin + 1)
443 vals_ll = m_tau_lin + n_vals[ll] % 2;
445 vals_ll = n_vals[ll];
449 auto highest_level_to_compress = (vals_ll % 2) ? ll : -1;
454 auto const max_depth = m_hierarchy_depth - 1;
456 while (highest_level_to_compress > -1) {
457 if (i >= max_depth or n_vals[i] % 2 == 0 or n_vals[i] <= m_tau_lin) {
460 highest_level_to_compress += 1;
470 for (
int i = highest_level_to_compress; i >= ll; i--) {
473 newest[i + 1] = (newest[i + 1] + 1) % (m_tau_lin + 1);
476 (*compressA)(A[i][(newest[i] + 1) % (m_tau_lin + 1)],
477 A[i][(newest[i] + 2) % (m_tau_lin + 1)]);
478 (*compressB)(B[i][(newest[i] + 1) % (m_tau_lin + 1)],
479 B[i][(newest[i] + 2) % (m_tau_lin + 1)]);
481 newest[ll] = (newest[ll] + 1) % (m_tau_lin + 1);
484 for (
int i = ll + 1; i < highest_level_to_compress + 2; i++) {
485 for (
long j = (m_tau_lin + 1) / 2 + 1;
486 j < min(m_tau_lin + 1, n_vals[i]); j++) {
487 auto const index_new = newest[i];
488 auto const index_old =
489 (newest[i] - j + m_tau_lin + 1) % (m_tau_lin + 1);
490 auto const index_res =
491 m_tau_lin + (i - 1) * m_tau_lin / 2 + (j - m_tau_lin / 2 + 1) - 1;
493 auto const temp = (corr_operation)(A[i][index_old], B[i][index_new],
495 assert(temp.size() == m_dim_corr);
497 n_sweeps[index_res]++;
498 for (index_type k = 0; k < static_cast<index_type>(m_dim_corr); k++) {
499 result[index_res][k] += temp[k];
509 using index_type =
decltype(result)::index;
511 std::vector<double>
res(n_result * m_dim_corr);
513 for (std::size_t i = 0; i < n_result; i++) {
514 auto const index =
static_cast<index_type
>(m_dim_corr * i);
515 for (index_type k = 0; k < static_cast<index_type>(m_dim_corr); k++) {
517 res[index + k] = result[
static_cast<index_type
>(i)][k] /
518 static_cast<double>(n_sweeps[i]);
527 boost::transform(tau,
res.begin(),
528 [
dt = m_dt](
auto const &a) { return a * dt; });
533 std::stringstream ss;
534 boost::archive::binary_oarchive oa(ss);
544 oa << A_accumulated_average;
545 oa << B_accumulated_average;
552 namespace iostreams = boost::iostreams;
553 iostreams::array_source src(state.data(), state.size());
554 iostreams::stream<iostreams::array_source> ss(src);
555 boost::archive::binary_iarchive ia(ss);
565 ia >> A_accumulated_average;
566 ia >> B_accumulated_average;
Vector implementation and trait types for boost qvm interoperability.
std::size_t n_values() const
std::string get_internal_state() const
Partial serialization of state that is not accessible via the interface.
void set_internal_state(std::string const &)
std::vector< double > get_lag_times() const
int finalize(boost::mpi::communicator const &comm)
At the end of data collection, go through the whole hierarchy and correlate data left there.
std::vector< double > get_correlation()
Return correlation result.
void update(boost::mpi::communicator const &comm) override
The function to process a new datapoint of A and B.
std::vector< double > componentwise_product(std::vector< double > const &A, std::vector< double > const &B, Utils::Vector3d const &)
std::vector< double > tensor_product(std::vector< double > const &A, std::vector< double > const &B, Utils::Vector3d const &)
std::vector< double > compress_linear(std::vector< double > const &A1, std::vector< double > const &A2)
Compress computing arithmetic mean: A_compressed=(A1+A2)/2.
std::vector< double > scalar_product(std::vector< double > const &A, std::vector< double > const &B, Utils::Vector3d const &)
std::vector< double > compress_discard1(std::vector< double > const &A1, std::vector< double > const &A2)
Compress discarding the 1st argument and return the 2nd.
std::vector< double > compress_discard2(std::vector< double > const &A1, std::vector< double > const &A2)
Compress discarding the 2nd argument and return the 1st.
std::vector< double > fcs_acf(std::vector< double > const &A, std::vector< double > const &B, Utils::Vector3d const &wsquare)
std::vector< double > square_distance_componentwise(std::vector< double > const &A, std::vector< double > const &B, Utils::Vector3d const &)
DEVICE_QUALIFIER constexpr T sqr(T x)
Calculates the SQuaRe of x.
auto hadamard_product(Vector< T, N > const &a, Vector< U, N > const &b)
int min(int i, unsigned int j)