purify::distribute Namespace Reference

Enumerations
enum class	plan { none , equal , radial , w_term }

Functions
std::vector< t_int >	distribute_measurements (Vector< t_real > const &u, Vector< t_real > const &v, Vector< t_real > const &w, t_int const number_of_nodes, distribute::plan const distribution_plan=plan::equal, t_int const &grid_size=128)
	Distribute visiblities into groups. More...
Vector< t_int >	w_distribution (Vector< t_real > const &u, const Vector< t_real > &v, const Vector< t_real > &w)
	Distribute visibilities into nodes in order of w terms (useful for w-stacking) More...
Vector< t_int >	w_distribution (Vector< t_real > const &w)
Vector< t_int >	distance_distribution (Vector< t_real > const &u, Vector< t_real > const &v)
	Distribute visiblities into nodes in order of distance from the centre. More...
Vector< t_int >	equal_distribution (Vector< t_real > const &u, Vector< t_real > const &v, t_int const &grid_size)
	Distribute the visiblities into nodes in order of density. More...
std::tuple< std::vector< t_int >, std::vector< t_real > >	kmeans_algo (const Vector< t_real > &w, const t_int number_of_nodes, const t_int iters, const std::function< t_real(t_real)> &cost=[](t_real x) { return x *x;}, const t_real rel_diff=1e-3)
	patition w terms using k-means More...

Enumeration Type Documentation

plan

enum purify::distribute::plan

strong

Enumerator
none
equal
radial
w_term

Definition at line 16 of file distribute.h.

{ none, equal, radial, w_term };

Function Documentation

distance_distribution()

Vector< t_int > purify::distribute::distance_distribution	(	Vector< t_real > const &	u,
		Vector< t_real > const &	v
	)

Distribute visiblities into nodes in order of distance from the centre.

Definition at line 69 of file distribute.cc.

                                                                                      {
  // sort visibilities by distance from centre
  Vector<t_int> index = Vector<t_int>::LinSpaced(u.size(), 0, u.size());
  std::sort(index.data(), index.data() + index.size(), [&u, &v](int a, int b) {
    return std::sqrt(u(a) * u(a) + v(a) * v(a)) < std::sqrt(u(b) * u(b) + v(b) * v(b));
  });
  return index;
}

References operators_test::u, and operators_test::v.

Referenced by distribute_measurements().

distribute_measurements()

std::vector< t_int > purify::distribute::distribute_measurements	(	Vector< t_real > const &	u,
		Vector< t_real > const &	v,
		Vector< t_real > const &	w,
		t_int const	number_of_nodes,
		distribute::plan const	distribution_plan,
		t_int const &	grid_size
	)

Distribute visiblities into groups.

Definition at line 6 of file distribute.cc.

                                                                   {
  // distrubte visibilities from a measurement
  Vector<t_int> index = Vector<t_int>::LinSpaced(u.size(), 0, u.size());
  t_int const partition_size =
      std::ceil(static_cast<t_real>(u.size()) / static_cast<t_real>(number_of_nodes));
  // return a vector of vectors of indicies for each node
  std::string plan_name = "";
  switch (distribution_plan) {
  case plan::none: {
    plan_name = "none";
    break;
  }
  case plan::equal: {
    index = equal_distribution(u, v, grid_size);
    plan_name = "equal";
    break;
  }
  case plan::radial: {
    index = distance_distribution(u, v);
    plan_name = "radial";
    break;
  }
  case plan::w_term: {
    index = w_distribution(w);
    plan_name = "w_term";
    break;
  }
  default: {
    throw std::runtime_error("Distribution plan not recognised or implimented.");
    break;
  }
  }
  PURIFY_DEBUG(
      "Using {} to make {} partitions from {} visibilities, with {} visibilities per a node.",
      plan_name, number_of_nodes, index.size(), partition_size);
  std::vector<t_int> partitions(u.size());
  if (std::floor(static_cast<t_real>(index.size() - 1) / static_cast<t_real>(partition_size)) >
      number_of_nodes - 1) {
    PURIFY_ERROR("Error: Probably a bug in distribution plan.");
    throw std::runtime_error("Distributing data into too many nodes");
  }
  // creating partitions
  for (t_int i = 0; i < index.size(); ++i) {
    partitions[index(i)] = std::floor(static_cast<t_real>(i) / static_cast<t_real>(partition_size));
  }
  return partitions;
}

References distance_distribution(), equal, equal_distribution(), none, PURIFY_DEBUG, PURIFY_ERROR, radial, operators_test::u, operators_test::v, w_distribution(), and w_term.

Referenced by dirty_visibilities(), purify::utilities::distribute_params(), and TEST_CASE().

equal_distribution()

Vector< t_int > purify::distribute::equal_distribution	(	Vector< t_real > const &	u,
		Vector< t_real > const &	v,
		t_int const &	grid_size
	)

Distribute the visiblities into nodes in order of density.

Definition at line 78 of file distribute.cc.

                                                         {
  // distribute visibilities by density calculated from histogram
  t_real const max_u = u.array().maxCoeff();
  t_real const max_v = v.array().maxCoeff();
  t_real const min_u = u.array().minCoeff();
  t_real const min_v = v.array().minCoeff();
  // scaling for histogram grid
  Vector<t_real> const scaled_u = (u.array() - min_u) * (grid_size - 1) / (max_u - min_u);
  Vector<t_real> const scaled_v = (v.array() - min_v) * (grid_size - 1) / (max_v - min_v);
  Image<t_int> histogram = Image<t_int>::Zero(grid_size, grid_size);
  Vector<t_int> index = Vector<t_int>::LinSpaced(u.size(), 0, u.size());
  // creating histogram grid
  for (t_int i = 0; i < index.size(); i++) {
    histogram((t_int)std::floor(scaled_u(i)), (t_int)std::floor(scaled_v(i))) += 1;
  }
  // sorting indicies
  std::sort(index.data(), index.data() + index.size(),
            [&histogram, &scaled_u, &scaled_v](int a, int b) {
              return (histogram((t_int)std::floor(scaled_u(a)), (t_int)std::floor(scaled_v(a))) <
                      histogram((t_int)std::floor(scaled_u(b)), (t_int)std::floor(scaled_v(b))));
            });
  return index;
}

References operators_test::u, and operators_test::v.

Referenced by distribute_measurements().

kmeans_algo()

std::tuple< std::vector< t_int >, std::vector< t_real > > purify::distribute::kmeans_algo	(	const Vector< t_real > &	w,
		const t_int	number_of_nodes,
		const t_int	iters,
		const std::function< t_real(t_real)> &	cost,
		const t_real	rel_diff
	)

patition w terms using k-means

Definition at line 103 of file distribute.cc.

                                                                    {
  std::vector<t_int> w_node(w.size(), 0);
  std::vector<t_real> w_centre(number_of_nodes, 0);
  std::vector<t_real> w_sum(number_of_nodes, 0);
  std::vector<t_real> w_count(number_of_nodes, 0);
  t_real diff = 1;
  t_real const wmin = w.minCoeff();
  t_real const wmax = w.maxCoeff();
  PURIFY_DEBUG("Min w = {}", wmin);
  PURIFY_DEBUG("Max w = {}", wmax);
  for (int i = 0; i < w_centre.size(); i++)
    w_centre[i] = (i * (wmax - wmin) / number_of_nodes + wmin);
  // lopp through even nodes to reduces w-term
  for (int n = 0; n < iters; n++) {
    PURIFY_DEBUG("clustering iteration {}", n);
    for (int i = 0; i < w.size(); i++) {
      t_real min = 2 * cost(wmax - wmin);
      for (int node = 0; node < number_of_nodes; node++) {
        const t_real cost_val = cost(w(i) - w_centre.at(node));
        if (cost_val < min) {
          min = cost_val;
          w_node[i] = node;
        }
      }
      w_sum[w_node.at(i)] += w(i);
      w_count[w_node.at(i)]++;
    }
    for (int j = 0; j < number_of_nodes; j++) {
      diff += std::abs(((w_count.at(j) > 0) ? w_sum.at(j) / w_count.at(j) : 0) - w_centre.at(j)) /
              std::abs(w_centre.at(j) * number_of_nodes);
      w_centre[j] = (w_count.at(j) > 0) ? w_sum.at(j) / w_count.at(j) : 0;
      PURIFY_DEBUG("Node {} has {} visibilities, using w-stack w = {}.", j, w_count.at(j),
                   w_centre.at(j));
      w_sum[j] = 0;
      w_count[j] = 0;
    }
    if (diff < rel_diff) {
      PURIFY_DEBUG("Converged!");
      break;
    } else {
      PURIFY_DEBUG("relative_diff = {}", diff);
      diff = 0;
    }
  }
 
  return std::make_tuple(w_node, w_centre);
}

References PURIFY_DEBUG.

Referenced by TEST_CASE(), purify::utilities::w_stacking(), and purify::utilities::w_stacking_with_all_to_all().

w_distribution() [1/2]

Vector< t_int > purify::distribute::w_distribution	(	const Vector< t_real > &	u,
		const Vector< t_real > &	v,
		Vector< t_real > const &	w
	)

Distribute visibilities into nodes in order of w terms (useful for w-stacking)

Definition at line 57 of file distribute.cc.

                                                      {
  return w_distribution(w);
}

Referenced by distribute_measurements().

w_distribution() [2/2]

Vector< t_int > purify::distribute::w_distribution

(

Vector< t_real > const &

w

)

Definition at line 62 of file distribute.cc.

                                                      {
  // sort visibilities by w from  w_max to w_min
  Vector<t_int> index = Vector<t_int>::LinSpaced(w.size(), 0, w.size());
  std::sort(index.data(), index.data() + index.size(), [&w](int a, int b) { return w(a) < w(b); });
  return index;
}