b_utilities Namespace Reference

Functions
void	Arguments (benchmark::internal::Benchmark *b)
double	duration (std::chrono::high_resolution_clock::time_point start, std::chrono::high_resolution_clock::time_point end)
bool	updateImage (t_uint newSize, Image< t_complex > &image, t_uint &sizex, t_uint &sizey)
bool	updateEmptyImage (t_uint newSize, Vector< t_complex > &image, t_uint &sizex, t_uint &sizey)
bool	updateMeasurements (t_uint newSize, utilities::vis_params &data)
bool	updateMeasurements (t_uint newSize, utilities::vis_params &data, t_real &epsilon, bool newImage, Image< t_complex > &image)
std::tuple< utilities::vis_params, t_real >	dirty_measurements (Image< t_complex > const &ground_truth_image, t_uint number_of_vis, t_real snr, const t_real &cellsize)
utilities::vis_params	random_measurements (t_int size, const t_real max_w, const t_int id, const bool cache_visibilities)

Function Documentation

Arguments()

void b_utilities::Arguments

(

benchmark::internal::Benchmark *

b

)

Definition at line 16 of file utilities.cc.

                                              {
  int im_size_max = 4096;      // 4096
  int uv_size_max = 10000000;  // 1M, 10M, 100M
  int kernel_max = 16;         // 16
  for (int i = 128; i <= im_size_max; i *= 2)
    for (int j = 1000000; j <= uv_size_max; j *= 10)
      for (int k = 2; k <= kernel_max; k *= 2)
        if (k * k < i) b->Args({i, j, k});
}

dirty_measurements()

std::tuple< utilities::vis_params, t_real > b_utilities::dirty_measurements	(	Image< t_complex > const &	ground_truth_image,
		t_uint	number_of_vis,
		t_real	snr,
		const t_real &	cellsize
	)

Definition at line 77 of file utilities.cc.

                            {
  auto uv_data = random_measurements(number_of_vis);
  // creating operator to generate measurements
  auto measurement_op = measurementoperator::init_degrid_operator_2d<Vector<t_complex>>(
      uv_data, ground_truth_image.rows(), ground_truth_image.cols(), cellsize, cellsize, 2,
      kernels::kernel::kb, 8, 8, false);
  // Generates measurements from image
  uv_data.vis = (*measurement_op) *
                Image<t_complex>::Map(ground_truth_image.data(), ground_truth_image.size(), 1);
 
  // working out value of signal given SNR
  auto const sigma = utilities::SNR_to_standard_deviation(uv_data.vis, snr);
  // adding noise to visibilities
  uv_data.vis = utilities::add_noise(uv_data.vis, 0., sigma);
  return std::make_tuple(uv_data, sigma);
}

References purify::utilities::add_noise(), purify::kernels::kb, random_measurements(), and purify::utilities::SNR_to_standard_deviation().

Referenced by updateMeasurements().

duration()

double b_utilities::duration	(	std::chrono::high_resolution_clock::time_point	start,
		std::chrono::high_resolution_clock::time_point	end
	)

Definition at line 26 of file utilities.cc.

                                                              {
  auto elapsed_seconds = std::chrono::duration_cast<std::chrono::duration<double>>(end - start);
  return elapsed_seconds.count();
}

Referenced by BENCHMARK_DEFINE_F(), degrid_operator_ctor(), and wavelet_operator_constructor().

random_measurements()

utilities::vis_params b_utilities::random_measurements	(	t_int	size,
		const t_real	max_w,
		const t_int	id,
		const bool	cache_visibilities
	)

Definition at line 96 of file utilities.cc.

                                                                         {
  utilities::vis_params uv_data;
 
  std::stringstream filename;
  filename << "random_" << size << "_";
  filename << std::to_string(id) << ".vis";
  std::string const vis_file = visibility_filename(filename.str());
  std::ifstream vis_file_str(vis_file);
 
  if (cache_visibilities and vis_file_str.good()) {
    PURIFY_INFO("Reading random visibilities from file {}", vis_file);
    uv_data = utilities::read_visibility(vis_file, true);
    uv_data.units = utilities::vis_units::radians;
  } else {
    PURIFY_INFO("Generating random visibilities");
    t_real const sigma_m = constant::pi / 3;
    uv_data = utilities::random_sample_density(size, 0, sigma_m, max_w);
    uv_data.units = utilities::vis_units::radians;
    if (cache_visibilities) {
      utilities::write_visibility(uv_data, vis_file, true);
    }
  }
  return uv_data;
}

References purify::constant::pi, PURIFY_INFO, purify::utilities::radians, purify::utilities::random_sample_density(), purify::utilities::read_visibility(), purify::utilities::vis_params::units, purify::visibility_filename(), and purify::utilities::write_visibility().

Referenced by degrid_operator_ctor(), dirty_measurements(), DegridOperatorCtorFixturePar::SetUp(), and updateMeasurements().

updateEmptyImage()

bool b_utilities::updateEmptyImage	(	t_uint	newSize,
		Vector< t_complex > &	image,
		t_uint &	sizex,
		t_uint &	sizey
	)

Definition at line 44 of file utilities.cc.

                                                                                              {
  if (sizex == newSize) {
    return false;
  }
  image.resize(newSize * newSize);
  sizex = newSize;
  sizey = newSize;
  return true;
}

Referenced by DegridOperatorAdjointFixture::updateImage(), and DegridOperatorAdjointFixturePar::updateImage().

updateImage()

bool b_utilities::updateImage	(	t_uint	newSize,
		Image< t_complex > &	image,
		t_uint &	sizex,
		t_uint &	sizey
	)

Definition at line 32 of file utilities.cc.

                                                                                        {
  if (sizex == newSize) {
    return false;
  }
  image = Image<t_complex>::Random(newSize, newSize);
  sizex = image.cols();
  sizey = image.rows();
  t_real const max = image.array().abs().maxCoeff();
  image = image * 1. / max;
  return true;
}

Referenced by AlgoFixture::SetUp(), AlgoFixtureMPI::SetUp(), DegridOperatorFixture::SetUp(), DegridOperatorFixturePar::SetUp(), DegridOperatorDirectFixture::updateImage(), and DegridOperatorDirectFixturePar::updateImage().

updateMeasurements() [1/2]

bool b_utilities::updateMeasurements	(	t_uint	newSize,
		utilities::vis_params &	data
	)

Definition at line 54 of file utilities.cc.

                                                                   {
  if (data.vis.size() == newSize) {
    return false;
  }
  data = b_utilities::random_measurements(newSize);
  return true;
}

References random_measurements(), and purify::utilities::vis_params::vis.

Referenced by AlgoFixture::SetUp(), AlgoFixtureMPI::SetUp(), DegridOperatorFixture::SetUp(), DegridOperatorCtorFixturePar::SetUp(), and DegridOperatorFixturePar::SetUp().

updateMeasurements() [2/2]

bool b_utilities::updateMeasurements	(	t_uint	newSize,
		utilities::vis_params &	data,
		t_real &	epsilon,
		bool	newImage,
		Image< t_complex > &	image
	)

Definition at line 62 of file utilities.cc.

                                                 {
  if (data.vis.size() == newSize && !newImage) {
    return false;
  }
  const t_real FoV = 1;  // deg
  const t_real cellsize = FoV / image.size() * 60. * 60.;
  std::tuple<utilities::vis_params, t_real> temp =
      b_utilities::dirty_measurements(image, newSize, 30., cellsize);
  data = std::get<0>(temp);
  epsilon = utilities::calculate_l2_radius(data.vis.size(), std::get<1>(temp));
 
  return true;
}

References purify::utilities::calculate_l2_radius(), dirty_measurements(), and purify::utilities::vis_params::vis.