purify::H5 Namespace Reference

Classes
class	H5Handler
	Purify interface class to handle HDF5 input files. More...

Functions
utilities::vis_params	read_visibility (const std::string &vis_name, const bool w_term)
	Reads an HDF5 file with u,v visibilities, constructs a vis_params object and returns it. More...
utilities::vis_params	stochread_visibility (H5Handler &file, const size_t N, const bool w_term)
	Stochastically reads dataset slices from the supplied HDF5-file handler, constructs a vis_params object from them and returns it. More...
void	write_visibility (const utilities::vis_params &uv_vis, const std::string &h5name, const bool w_term, const size_t chunksize=0)
	Write an HDF5 file with u,v visibilities from a vis_params object. More...

Function Documentation

read_visibility()

utilities::vis_params purify::H5::read_visibility	(	const std::string &	vis_name,
		const bool	w_term
	)

Reads an HDF5 file with u,v visibilities, constructs a vis_params object and returns it.

Note

vis_name: name of input HDF5 file containing [u, v, real(V), imag(V)].

Definition at line 166 of file h5reader.h.

                                                                                  {
  H5Handler vis_file(vis_name);
  utilities::vis_params uv_vis;
 
  std::vector<t_real> utemp = vis_file.read<t_real>("u");
  uv_vis.u = Eigen::Map<Vector<t_real>>(utemp.data(), utemp.size(), 1);
 
  // found that a reflection is needed for the orientation
  // of the gridded image to be correct
  std::vector<t_real> vtemp = vis_file.read<t_real>("v");
  uv_vis.v = -Eigen::Map<Vector<t_real>>(vtemp.data(), vtemp.size(), 1);
 
  if (w_term) {
    std::vector<t_real> wtemp = vis_file.read<t_real>("w");
    uv_vis.w = Eigen::Map<Vector<t_real>>(wtemp.data(), wtemp.size(), 1);
  } else {
    uv_vis.w = Vector<t_real>::Zero(utemp.size());
  }
 
  std::vector<t_real> retemp = vis_file.read<t_real>("re");
  std::vector<t_real> imtemp = vis_file.read<t_real>("im");
  std::vector<t_real> sigma = vis_file.read<t_real>("sigma");
  assert(retemp.size() == imtemp.size());
 
  uv_vis.vis = Vector<t_complex>::Zero(retemp.size());
  uv_vis.weights = Vector<t_complex>::Zero(retemp.size());
  for (size_t i = 0; i < retemp.size(); ++i) {
    uv_vis.vis(i) = t_complex(retemp[i], imtemp[i]);
    uv_vis.weights(i) = 1 / sigma[i];
  }
 
  uv_vis.ra = 0;
  uv_vis.dec = 0;
  uv_vis.average_frequency = 0;
 
  return uv_vis;
}

References purify::utilities::vis_params::average_frequency, purify::utilities::vis_params::dec, purify::utilities::vis_params::ra, purify::H5::H5Handler::read(), purify::utilities::vis_params::u, purify::utilities::vis_params::v, purify::utilities::vis_params::vis, purify::utilities::vis_params::w, and purify::utilities::vis_params::weights.

Referenced by purify::utilities::read_visibility().

stochread_visibility()

utilities::vis_params purify::H5::stochread_visibility	(	H5Handler &	file,
		const size_t	N,
		const bool	w_term
	)

Stochastically reads dataset slices from the supplied HDF5-file handler, constructs a vis_params object from them and returns it.

Definition at line 206 of file h5reader.h.

                                                                                             {
  utilities::vis_params uv_vis;
 
  std::vector<t_real> utemp =
      file.stochread<t_real>("u", N, true);  //< shuffle batch starting position
  uv_vis.u = Eigen::Map<Vector<t_real>>(utemp.data(), utemp.size(), 1);
 
  // found that a reflection is needed for the orientation
  // of the gridded image to be correct
  std::vector<t_real> vtemp = file.stochread<t_real>("v", N);
  uv_vis.v = -Eigen::Map<Vector<t_real>>(vtemp.data(), vtemp.size(), 1);
 
  if (w_term) {
    std::vector<t_real> wtemp = file.stochread<t_real>("w", N);
    uv_vis.w = Eigen::Map<Vector<t_real>>(wtemp.data(), wtemp.size(), 1);
  } else {
    uv_vis.w = Vector<t_real>::Zero(utemp.size());
  }
 
  std::vector<t_real> retemp = file.stochread<t_real>("re", N);
  std::vector<t_real> imtemp = file.stochread<t_real>("im", N);
  std::vector<t_real> sigma = file.stochread<t_real>("sigma", N);
 
  uv_vis.vis = Vector<t_complex>::Zero(retemp.size());
  uv_vis.weights = Vector<t_complex>::Zero(retemp.size());
  for (size_t i = 0; i < retemp.size(); ++i) {
    uv_vis.vis(i) = t_complex(retemp[i], imtemp[i]);
    uv_vis.weights(i) = 1 / sigma[i];
  }
 
  uv_vis.ra = 0;
  uv_vis.dec = 0;
  uv_vis.average_frequency = 0;
 
  return uv_vis;
}

References purify::utilities::vis_params::average_frequency, purify::utilities::vis_params::dec, purify::utilities::vis_params::ra, purify::H5::H5Handler::stochread(), purify::utilities::vis_params::u, purify::utilities::vis_params::v, purify::utilities::vis_params::vis, purify::utilities::vis_params::w, and purify::utilities::vis_params::weights.

Referenced by BENCHMARK_DEFINE_F(), and TEST_CASE().

write_visibility()

void purify::H5::write_visibility	(	const utilities::vis_params &	uv_vis,
		const std::string &	h5name,
		const bool	w_term,
		const size_t	chunksize = 0
	)

Write an HDF5 file with u,v visibilities from a vis_params object.

Definition at line 244 of file h5reader.h.

                                                                     {
  // Set up HDF5 file
  HighFive::File h5file(h5name, HighFive::File::OpenOrCreate | HighFive::File::Truncate);
  // Set up file properties, such as chunking and compression
  // Note: the I/O is minimised if compression is disabled (obvs)
  // If using decompressed data is not an option, then the
  // I/O performance can be optimised by chunking the dataset
  // in such a way that each MPI rank only has to decompress
  // its allocated segment (or a subset thereof)
  HighFive::DataSetCreateProps props;
  if (uv_vis.u.size()) {
    if (chunksize > 0) {
      props.add(HighFive::Chunking(std::vector<hsize_t>{chunksize}));
    } else {
      props.add(HighFive::Chunking(std::vector<hsize_t>{static_cast<hsize_t>(uv_vis.u.size())}));
    }
    props.add(HighFive::Deflate(9));  // maximal compression
  }
  // Create the H5 datasets
  h5file.createDataSet("u", std::vector<t_real>(uv_vis.u.data(), uv_vis.u.data() + uv_vis.u.size()),
                       props);
  h5file.createDataSet("v", std::vector<t_real>(uv_vis.v.data(), uv_vis.v.data() + uv_vis.v.size()),
                       props);
  if (w_term) {
    h5file.createDataSet(
        "w", std::vector<t_real>(uv_vis.w.data(), uv_vis.w.data() + uv_vis.w.size()), props);
  }
 
  std::vector<t_real> redata, imdata, sigma;
  redata.reserve(uv_vis.vis.size());
  imdata.reserve(uv_vis.vis.size());
  sigma.reserve(uv_vis.weights.size());
  for (size_t i = 0; i < uv_vis.vis.size(); ++i) {
    redata.push_back(uv_vis.vis(i).real());
    imdata.push_back(uv_vis.vis(i).imag());
    sigma.push_back(1.0 / uv_vis.weights(i).real());
  }
  h5file.createDataSet("re", std::move(redata), props);
  h5file.createDataSet("im", std::move(imdata), props);
  h5file.createDataSet("sigma", std::move(imdata), props);
}

References purify::utilities::vis_params::u, purify::utilities::vis_params::v, purify::utilities::vis_params::vis, purify::utilities::vis_params::w, and purify::utilities::vis_params::weights.

Referenced by TEST_CASE().