purify Namespace Reference

Namespaces
	casa
	constant
	convol
	details
	distribute
	factory
	H5
	integration
	kernels
	logging
	measurementoperator
	operators
	pfitsio
	projection_kernels
	random_updater
	read_measurements
	utilities
	widefield
	wproj_utilities

Classes
class	IndexMapping
class	YamlParser

Typedefs
typedef std::complex< float >	t_complexf
typedef Eigen::Triplet< t_complex >	t_tripletList
	Root of the type hierarchy for triplet lists. More...
template<class T = t_real, class I = t_int>
using	Sparse = Eigen::SparseMatrix< T, Eigen::RowMajor, I >
	A matrix of a given type. More...
template<class T = t_real, class I = t_int>
using	SparseVector = Eigen::SparseVector< T, Eigen::RowMajor, I >

Enumerations
enum class	diff_func_type { L2Norm , L2Norm_with_CRR }
enum class	nondiff_func_type { L1Norm , Denoiser , RealIndicator }
enum class	stokes {   I , Q , U , V ,   XX , YY , XY , YX ,   LL , RR , LR , RL ,   P }
enum class	dde_type { wkernel_radial , wkernel_2d }
	Types of DDEs in purify. More...

Functions
std::vector< t_int >	all_to_all_send_sizes (const std::vector< t_int > &recv_sizes, const sopt::mpi::Communicator &comm)
std::string	version ()
	Returns library version. More...
std::tuple< uint8_t, uint8_t, uint8_t >	version_tuple ()
	Returns library version. More...
std::string	gitref ()
	Returns library git reference, if known. More...
std::string	default_logging_level ()
	Default logging level. More...
template<class T0 , class STORAGE_INDEX_TYPE = t_int>
std::set< STORAGE_INDEX_TYPE >	non_empty_outers (Eigen::SparseMatrixBase< T0 > const &matrix)
	Indices of non empty outer indices. More...
template<class T0 >
Sparse< typename T0::Scalar >	compress_outer (T0 const &matrix)
	Indices of non empty outer indices. More...
std::tuple< std::function< t_real(t_real)>, std::function< t_real(t_real)>, std::function< t_real(t_real)>, std::function< t_real(t_real)> >	create_kernels (const kernels::kernel kernel_name_, const t_uint Ju_, const t_uint Jv_, const t_real imsizey_, const t_real imsizex_, const t_real oversample_ratio)
std::tuple< std::function< t_real(t_real)>, std::function< t_real(t_real)> >	create_radial_ftkernel (const kernels::kernel kernel_name_, const t_uint Ju_, const t_real oversample_ratio)
std::vector< std::string >	split (const std::string &s, char delim)
	splits string into vector More...
void	mkdir_recursive (const std::string &path)
	recursively create directories when they do not exist More...
template<class T >
void	mkdir_recursive (const T &path)
	boost wrapper More...
template<typename T >
void	split (const std::string &s, char delim, T result)
	adds split string to container More...
template<typename T >
T	get_vector (const YAML::Node &node_map, const std::initializer_list< const char * > indicies)
template<class T >
std::enable_if< std::is_scalar< T >::value, std::vector< T > >::type	read_data (const std::string &filename)
	read real values from data file More...
template<class T >
std::enable_if< std::is_same< t_complex, T >::value, std::vector< T > >::type	read_data (const std::string &filename)
	read complex values from data file More...
std::vector< t_complex >	read_data (const std::vector< t_real > &input)
std::string	data_directory ()
	Holds data and such. More...
std::string	models_directory ()
	Holds TF models. More...
std::string	output_directory ()
	Where test outputs go. More...
std::string	data_filename (std::string const &filename)
	Holds data and such. More...
std::string	image_filename (std::string const &filename)
	Image filename. More...
std::string	visibility_filename (std::string const &filename)
	Visibility filename. More...
std::string	vla_filename (std::string const &filename)
	Specific vla data. More...
std::string	atca_filename (std::string const &filename)
	Specific atca data. More...
std::string	mwa_filename (std::string const &filename)
	Specific mwa data. More...
std::string	gridding_filename (std::string const &filename)
	Some gridding regression data. More...
std::string	degridding_filename (std::string const &filename)
	Some degridding regression data. More...
std::string	output_filename (std::string const &filename)
	Test output file. More...
std::string	ngc3256_ms ()

Variables
const std::map< std::string, diff_func_type >	diff_type_string
const std::map< std::string, nondiff_func_type >	nondiff_type_string
const std::map< stokes, t_int >	stokes_int
const std::map< std::string, stokes >	stokes_string

Detailed Description

YamlParser definition for the purify project

Author

Roland Guichard

Version

1.0

YamlParser header for purify project

Author

Roland Guichard

Version

1.0 The YamlParser class definition.

It browses and searches through the config.yaml file in the data folder and sets the class variable members accordingly, to be used by the purify algorithm.

Parameters

filepath

path to the config file

Typedef Documentation

Sparse

template<class T = t_real, class I = t_int>

using purify::Sparse = typedef Eigen::SparseMatrix<T, Eigen::RowMajor, I>

A matrix of a given type.

Operates as mathematical sparse matrix.

Definition at line 40 of file types.h.

SparseVector

template<class T = t_real, class I = t_int>

using purify::SparseVector = typedef Eigen::SparseVector<T, Eigen::RowMajor, I>

Definition at line 42 of file types.h.

t_complexf

typedef std::complex<float> purify::t_complexf

Definition at line 21 of file types.h.

t_tripletList

typedef Eigen::Triplet<t_complex> purify::t_tripletList

Root of the type hierarchy for triplet lists.

Definition at line 23 of file types.h.

Enumeration Type Documentation

dde_type

enum purify::dde_type

strong

Types of DDEs in purify.

Enumerator
wkernel_radial
wkernel_2d

Definition at line 59 of file types.h.

{ wkernel_radial, wkernel_2d };

diff_func_type

enum purify::diff_func_type

strong

Enumerator
L2Norm
L2Norm_with_CRR

Definition at line 26 of file types.h.

{ L2Norm, L2Norm_with_CRR };

nondiff_func_type

enum purify::nondiff_func_type

strong

Enumerator
L1Norm
Denoiser
RealIndicator

Definition at line 31 of file types.h.

{ L1Norm, Denoiser, RealIndicator };

stokes

enum purify::stokes

strong

Enumerator
I
Q
U
V
XX
YY
XY
YX
LL
RR
LR
RL
P

Definition at line 44 of file types.h.

{ I, Q, U, V, XX, YY, XY, YX, LL, RR, LR, RL, P };

Function Documentation

all_to_all_send_sizes()

std::vector<t_int> purify::all_to_all_send_sizes	(	const std::vector< t_int > &	recv_sizes,
		const sopt::mpi::Communicator &	comm
	)

Definition at line 5 of file AllToAllSparseVector.cc.

                                                                          {
  std::vector<t_int> send_sizes(recv_sizes.size(), 0);
  for (t_int i = 0; i < comm.size(); i++) {
    if (i == comm.rank())
      send_sizes = comm.gather<t_int>(recv_sizes[i], i);
    else
      comm.gather<t_int>(recv_sizes[i], i);
  }
  return send_sizes;
}

atca_filename()

std::string purify::atca_filename ( std::string const &  filename )

inline

Specific atca data.

Definition at line 32 of file directories.in.h.

                                                          {
  return data_filename("atca/" + filename);
}

References data_filename().

Referenced by TEST_CASE().

compress_outer()

template<class T0 >

Sparse<typename T0::Scalar> purify::compress_outer

(

T0 const &

matrix

)

Indices of non empty outer indices.

Definition at line 71 of file IndexMapping.h.

                                                           {
  static_assert(T0::IsRowMajor, "Not tested for col major");
  auto const indices = non_empty_outers(matrix);
 
  SparseVector<typename T0::Index, typename T0::Index> mapping(matrix.cols());
  mapping.reserve(indices.size());
  t_int i(0);
  for (auto const &index : indices) mapping.coeffRef(index) = i++;
 
  std::vector<typename Sparse<typename T0::Scalar>::Index> rows(matrix.rows() + 1, 0);
  std::vector<typename Sparse<typename T0::Scalar>::Index> cols(matrix.nonZeros(), 0);
  rows[matrix.rows()] = matrix.nonZeros();
  t_int index = 0;
  for (typename T0::Index k = 0; k < matrix.outerSize(); ++k) {
    rows[k] = index;
    for (typename T0::InnerIterator it(matrix, k); it; ++it) {
      cols[index] = mapping.coeff(it.col());
      index++;
    }
  }
  return Eigen::MappedSparseMatrix<typename T0::Scalar, Eigen::RowMajor,
                                   typename Sparse<typename T0::Scalar>::Index>(
      matrix.rows(), indices.size(), matrix.nonZeros(), rows.data(), cols.data(),
      const_cast<typename T0::Scalar *>(matrix.derived().valuePtr()));
}

References non_empty_outers().

Referenced by TEST_CASE().

create_kernels()

std::tuple< std::function< t_real(t_real)>, std::function< t_real(t_real)>, std::function< t_real(t_real)>, std::function< t_real(t_real)> > purify::create_kernels	(	const kernels::kernel	kernel_name_,
		const t_uint	Ju_,
		const t_uint	Jv_,
		const t_real	imsizey_,
		const t_real	imsizex_,
		const t_real	oversample_ratio
	)

Definition at line 249 of file kernels.cc.

                                                                                            {
  // PURIFY_MEDIUM_LOG("Kernel Name: {}", kernel_name_.c_str());
  PURIFY_MEDIUM_LOG("Kernel Support: {} x {}", Ju_, Jv_);
  const t_uint ftsizev_ = std::floor(imsizey_ * oversample_ratio);
  const t_uint ftsizeu_ = std::floor(imsizex_ * oversample_ratio);
  if ((kernel_name_ == kernels::kernel::pswf) and (Ju_ != 6 or Jv_ != 6)) {
    PURIFY_ERROR("Error: Only a support of 6 is implemented for PSWFs.");
    throw std::runtime_error("Incorrect input: PSWF requires a support of 6");
  }
  switch (kernel_name_) {
  case kernels::kernel::kb: {
    auto kbu = [=](const t_real x) { return kernels::kaiser_bessel(x, Ju_); };
    auto kbv = [=](const t_real x) { return kernels::kaiser_bessel(x, Jv_); };
    auto ftkbu = [=](const t_real x) { return kernels::ft_kaiser_bessel(x / ftsizeu_ - 0.5, Ju_); };
    auto ftkbv = [=](const t_real x) { return kernels::ft_kaiser_bessel(x / ftsizev_ - 0.5, Jv_); };
    return std::make_tuple(kbu, kbv, ftkbu, ftkbv);
    break;
  }
  case kernels::kernel::kb_presample: {
    if (Ju_ != Jv_)
      throw std::runtime_error("Ju and Jv must be the same support size for presampling kernels.");
    const auto samples = kernels::kernel_samples(
        1e5, [&](const t_real x) { return kernels::kaiser_bessel(x, Ju_); });
    auto kbu = [=](const t_real x) { return kernels::kernel_zero_interp(samples, x, Ju_); };
    auto kbv = [=](const t_real x) { return kernels::kernel_zero_interp(samples, x, Jv_); };
    auto ftkbu = [=](const t_real x) { return kernels::ft_kaiser_bessel(x / ftsizeu_ - 0.5, Ju_); };
    auto ftkbv = [=](const t_real x) { return kernels::ft_kaiser_bessel(x / ftsizev_ - 0.5, Jv_); };
    return std::make_tuple(kbu, kbv, ftkbu, ftkbv);
    break;
  }
  case kernels::kernel::kbmin: {
    const t_real kb_interp_alpha_Ju =
        constant::pi * std::sqrt(Ju_ * Ju_ / (oversample_ratio * oversample_ratio) *
                                     (oversample_ratio - 0.5) * (oversample_ratio - 0.5) -
                                 0.8);
    const t_real kb_interp_alpha_Jv =
        constant::pi * std::sqrt(Jv_ * Jv_ / (oversample_ratio * oversample_ratio) *
                                     (oversample_ratio - 0.5) * (oversample_ratio - 0.5) -
                                 0.8);
    auto kbu = [=](const t_real x) {
      return kernels::kaiser_bessel_general(x, Ju_, kb_interp_alpha_Ju);
    };
    auto kbv = [=](const t_real x) {
      return kernels::kaiser_bessel_general(x, Jv_, kb_interp_alpha_Jv);
    };
    auto ftkbu = [=](const t_real x) {
      return kernels::ft_kaiser_bessel_general(x / ftsizeu_ - 0.5, Ju_, kb_interp_alpha_Ju);
    };
    auto ftkbv = [=](const t_real x) {
      return kernels::ft_kaiser_bessel_general(x / ftsizev_ - 0.5, Jv_, kb_interp_alpha_Jv);
    };
    return std::make_tuple(kbu, kbv, ftkbu, ftkbv);
    break;
  }
  case kernels::kernel::pswf: {
    auto pswfu = [=](const t_real x) { return kernels::pswf(x, Ju_); };
    auto pswfv = [=](const t_real x) { return kernels::pswf(x, Jv_); };
    auto ftpswfu = [=](const t_real x) { return kernels::ft_pswf(x / ftsizeu_ - 0.5, Ju_); };
    auto ftpswfv = [=](const t_real x) { return kernels::ft_pswf(x / ftsizev_ - 0.5, Jv_); };
    return std::make_tuple(pswfu, pswfv, ftpswfu, ftpswfv);
    break;
  }
  case kernels::kernel::gauss: {
    auto gaussu = [=](const t_real x) { return kernels::gaussian(x, Ju_); };
    auto gaussv = [=](const t_real x) { return kernels::gaussian(x, Jv_); };
    auto ftgaussu = [=](const t_real x) { return kernels::ft_gaussian(x / ftsizeu_ - 0.5, Ju_); };
    auto ftgaussv = [=](const t_real x) { return kernels::ft_gaussian(x / ftsizev_ - 0.5, Jv_); };
    return std::make_tuple(gaussu, gaussv, ftgaussu, ftgaussv);
    break;
  }
  case kernels::kernel::box: {
    auto boxu = [=](const t_real x) { return kernels::pill_box(x, Ju_); };
    auto boxv = [=](const t_real x) { return kernels::pill_box(x, Jv_); };
    auto ftboxu = [=](const t_real x) { return kernels::ft_pill_box(x / ftsizeu_ - 0.5, Ju_); };
    auto ftboxv = [=](const t_real x) { return kernels::ft_pill_box(x / ftsizev_ - 0.5, Jv_); };
    return std::make_tuple(boxu, boxv, ftboxu, ftboxv);
    break;
  }
  case kernels::kernel::gauss_alt: {
    const t_real sigma = 1;  // In units of radians, Rafael uses sigma = 2 * pi / ftsizeu_. However,
    // this should be 1 in units of pixels.
    auto gaussu = [=](const t_real x) { return kernels::gaussian_general(x, Ju_, sigma); };
    auto gaussv = [=](const t_real x) { return kernels::gaussian_general(x, Jv_, sigma); };
    auto ftgaussu = [=](const t_real x) {
      return kernels::ft_gaussian_general(x / ftsizeu_ - 0.5, Ju_, sigma);
    };
    auto ftgaussv = [=](const t_real x) {
      return kernels::ft_gaussian_general(x / ftsizev_ - 0.5, Jv_, sigma);
    };
    return std::make_tuple(gaussu, gaussv, ftgaussu, ftgaussv);
    break;
  }
  default:
    throw std::runtime_error("Did not choose valid kernel.");
  }
}

References purify::kernels::box, purify::kernels::ft_gaussian(), purify::kernels::ft_gaussian_general(), purify::kernels::ft_kaiser_bessel(), purify::kernels::ft_kaiser_bessel_general(), purify::kernels::ft_pill_box(), purify::kernels::ft_pswf(), purify::kernels::gauss, purify::kernels::gauss_alt, purify::kernels::gaussian(), purify::kernels::gaussian_general(), purify::kernels::kaiser_bessel(), purify::kernels::kaiser_bessel_general(), purify::kernels::kb, purify::kernels::kb_presample, purify::kernels::kbmin, purify::kernels::kernel_samples(), purify::kernels::kernel_zero_interp(), purify::constant::pi, purify::kernels::pill_box(), purify::kernels::pswf, PURIFY_ERROR, and PURIFY_MEDIUM_LOG.

Referenced by purify::operators::base_degrid_operator_2d(), GridOperatorFixture::SetUp(), and TEST_CASE().

create_radial_ftkernel()

std::tuple< std::function< t_real(t_real)>, std::function< t_real(t_real)> > purify::create_radial_ftkernel	(	const kernels::kernel	kernel_name_,
		const t_uint	Ju_,
		const t_real	oversample_ratio
	)

Definition at line 347 of file kernels.cc.

                                                                                       {
  // PURIFY_MEDIUM_LOG("Kernel Name: {}", kernel_name_.c_str());
  PURIFY_MEDIUM_LOG("Radial Kernel Support: {}", Ju_);
  if ((kernel_name_ == kernels::kernel::pswf) and (Ju_ != 6)) {
    PURIFY_ERROR("Error: Only a support of 6 is implemented for PSWFs.");
    throw std::runtime_error("Incorrect input: PSWF requires a support of 6");
  }
  switch (kernel_name_) {
  case kernels::kernel::kb: {
    return std::make_tuple(
        [=](const t_real x) { return kernels::ft_kaiser_bessel(x, static_cast<t_real>(Ju_)); },
        [=](const t_real x) { return kernels::kaiser_bessel(x, static_cast<t_real>(Ju_)); });
    break;
  }
  case kernels::kernel::kbmin: {
    const t_real kb_interp_alpha_Ju =
        constant::pi * std::sqrt(Ju_ * Ju_ / (oversample_ratio * oversample_ratio) *
                                     (oversample_ratio - 0.5) * (oversample_ratio - 0.5) -
                                 0.8);
    auto kbuv = [=](const t_real x) {
      return kernels::kaiser_bessel_general(x, Ju_, kb_interp_alpha_Ju);
    };
    auto ftkbuv = [=](const t_real x) {
      return kernels::ft_kaiser_bessel_general(x, Ju_, kb_interp_alpha_Ju);
    };
    return std::make_tuple(ftkbuv, kbuv);
    break;
  }
  case kernels::kernel::pswf: {
    return std::make_tuple(
        [=](const t_real x) { return kernels::ft_pswf(x, static_cast<t_real>(Ju_)); },
        [=](const t_real x) { return kernels::pswf(x, Ju_); });
    break;
  }
  case kernels::kernel::gauss: {
    return std::make_tuple(
        [=](const t_real x) { return kernels::ft_gaussian(x, static_cast<t_real>(Ju_)); },
        [=](const t_real x) { return kernels::gaussian(x, Ju_); });
    break;
  }
  case kernels::kernel::box: {
    return std::make_tuple(
        [=](const t_real x) { return kernels::ft_pill_box(x, static_cast<t_real>(Ju_)); },
        [=](const t_real x) { return kernels::pill_box(x, Ju_); });
    break;
  }
  default:
    throw std::runtime_error("Did not choose valid radial kernel.");
  }
}

References purify::kernels::box, purify::kernels::ft_gaussian(), purify::kernels::ft_kaiser_bessel(), purify::kernels::ft_kaiser_bessel_general(), purify::kernels::ft_pill_box(), purify::kernels::ft_pswf(), purify::kernels::gauss, purify::kernels::gaussian(), purify::kernels::kaiser_bessel(), purify::kernels::kaiser_bessel_general(), purify::kernels::kb, purify::kernels::kbmin, purify::constant::pi, purify::kernels::pill_box(), purify::kernels::pswf, PURIFY_ERROR, and PURIFY_MEDIUM_LOG.

Referenced by purify::operators::base_degrid_operator_2d().

data_directory()

std::string purify::data_directory ( )

inline

Holds data and such.

Definition at line 9 of file directories.in.h.

{ return "@CMAKE_INSTALL_PREFIX@/data"; }

Referenced by data_filename().

data_filename()

std::string purify::data_filename ( std::string const &  filename )

inline

Holds data and such.

Definition at line 16 of file directories.in.h.

                                                          {
  return data_directory() + "/" + filename;
}

References data_directory().

Referenced by atca_filename(), degridding_filename(), gridding_filename(), image_filename(), mwa_filename(), StochasticAlgoFixture::SetUp(), TEST_CASE(), visibility_filename(), and vla_filename().

default_logging_level()

std::string purify::default_logging_level ( )

inline

Default logging level.

Definition at line 51 of file config.in.h.

{ return "@PURIFY_TEST_LOG_LEVEL@"; }

Referenced by main().

degridding_filename()

std::string purify::degridding_filename ( std::string const &  filename )

inline

Some degridding regression data.

Definition at line 44 of file directories.in.h.

                                                                {
  return data_filename("expected/degridding/" + filename);
}

References data_filename().

get_vector()

template<typename T >

T purify::get_vector	(	const YAML::Node &	node_map,
		const std::initializer_list< const char * >	indicies
	)

Definition at line 74 of file yaml-parser.cc.

                                                                                        {
  YAML::Node node = YAML::Clone(node_map);
  std::string faulty_variable;
  for (const char* index : indicies) {
    faulty_variable = std::string(index);
    node = node[index];
    if (!node.IsDefined()) {
      throw std::runtime_error("The initialisation of " + faulty_variable + " is wrong.");
    }
  }
  try {
    T output;
    for (int i = 0; i < node.size(); i++) output.push_back(node[i].as<typename T::value_type>());
    return output;
  } catch (std::exception e) {
    throw std::runtime_error("There is a mismatch in the type conversion of " + faulty_variable);
  }
}

gitref()

std::string purify::gitref ( )

inline

Returns library git reference, if known.

Definition at line 49 of file config.in.h.

{ return "@Purify_GITREF@"; }

gridding_filename()

std::string purify::gridding_filename ( std::string const &  filename )

inline

Some gridding regression data.

Definition at line 40 of file directories.in.h.

                                                              {
  return data_filename("expected/gridding/" + filename);
}

References data_filename().

image_filename()

std::string purify::image_filename ( std::string const &  filename )

inline

Image filename.

Definition at line 20 of file directories.in.h.

                                                           {
  return data_filename("images/" + filename);
}

References data_filename().

Referenced by main().

mkdir_recursive() [1/2]

void purify::mkdir_recursive

(

const std::string &

path

)

recursively create directories when they do not exist

Definition at line 151 of file read_measurements.cc.

                                            {
  if (read_measurements::dir_exists(path)) return;
  const auto folders = split(path, '/');
  std::string current_path = "";
  for (const auto f : folders) {
    if (f == "") {
      current_path += "/";
      continue;
    }
    current_path += f;
    if (not read_measurements::dir_exists(current_path)) {
      const t_int status = mkdir(current_path.c_str(), ACCESSPERMS);
      if (status != 0)
        throw std::runtime_error("Error making recursive directory: " + current_path);
    }
    current_path += "/";
  }
  return;
}

References purify::read_measurements::dir_exists(), and split().

Referenced by main(), mkdir_recursive(), TEST_CASE(), and purify::YamlParser::writeOutput().

mkdir_recursive() [2/2]

template<class T >

void purify::mkdir_recursive

(

const T &

path

)

boost wrapper

Definition at line 45 of file read_measurements.h.

                                    {
  mkdir_recursive(path.native());
}

References mkdir_recursive().

models_directory()

std::string purify::models_directory ( )

inline

Holds TF models.

Definition at line 11 of file directories.in.h.

{ return "@CMAKE_INSTALL_PREFIX@/models"; }

mwa_filename()

std::string purify::mwa_filename ( std::string const &  filename )

inline

Specific mwa data.

Definition at line 36 of file directories.in.h.

                                                         {
  return data_filename("mwa/" + filename);
}

References data_filename().

Referenced by main(), and TEST_CASE().

ngc3256_ms()

std::string purify::ngc3256_ms ( )

inline

Definition at line 53 of file directories.in.h.

{ return "@NGC3256_MS@"; }

Referenced by main().

non_empty_outers()

template<class T0 , class STORAGE_INDEX_TYPE = t_int>

std::set<STORAGE_INDEX_TYPE> purify::non_empty_outers

(

Eigen::SparseMatrixBase< T0 > const &

matrix

)

Indices of non empty outer indices.

Definition at line 61 of file IndexMapping.h.

                                                                                     {
  std::set<STORAGE_INDEX_TYPE> result;
  for (typename T0::Index k = 0; k < matrix.derived().outerSize(); ++k)
    for (typename T0::InnerIterator it(matrix.derived(), k); it; ++it)
      result.insert(static_cast<STORAGE_INDEX_TYPE>(it.col()));
  return result;
}

Referenced by compress_outer(), and TEST_CASE().

output_directory()

std::string purify::output_directory ( )

inline

Where test outputs go.

Definition at line 13 of file directories.in.h.

{ return "@CMAKE_INSTALL_PREFIX@/outputs"; }

Referenced by output_filename().

output_filename()

std::string purify::output_filename ( std::string const &  filename )

inline

Test output file.

Definition at line 49 of file directories.in.h.

                                                            {
  return output_directory() + "/" + filename;
}

References output_directory().

Referenced by main(), padmm(), and TEST_CASE().

read_data() [1/3]

template<class T >

std::enable_if<std::is_scalar<T>::value, std::vector<T> >::type purify::read_data

(

const std::string &

filename

)

read real values from data file

Definition at line 14 of file data.in.h.

                               {
  std::ifstream data_file(filename);
  if (!data_file) throw std::runtime_error("Test data is missing: " + filename);
  std::string s;
  // read data
  std::vector<T> data;
  for (std::string s; std::getline(data_file, s, ',');) {
    data.push_back(std::stod(s));
  }
  return data;
}

read_data() [2/3]

template<class T >

std::enable_if<std::is_same<t_complex, T>::value, std::vector<T> >::type purify::read_data

(

const std::string &

filename

)

read complex values from data file

Definition at line 28 of file data.in.h.

                               {
  std::ifstream data_file(filename);
  if (!data_file) throw std::runtime_error("Test data is missing: " + filename);
  std::string real = "";
  std::string imag = "";
  // read data
  std::vector<T> data;
  for (std::string real; std::getline(data_file, real, ',');) {
    real.erase(0, 1);
    if (!std::getline(data_file, imag, ')')) break;
    data.push_back(T(std::stod(real), std::stod(imag)));
    real = "";
    imag = "";
  }
  return data;
}

read_data() [3/3]

std::vector<t_complex> purify::read_data

(

const std::vector< t_real > &

input

)

Definition at line 46 of file data.in.h.

                                                               {
  std::vector<t_complex> output;
  for (auto a = input.begin(); a != input.end(); a++) output.push_back(t_complex(*a, 0.));
  return output;
}

split() [1/2]

std::vector< std::string > purify::split	(	const std::string &	s,
		char	delim
	)

splits string into vector

Definition at line 146 of file read_measurements.cc.

                                                           {
  std::vector<std::string> elems;
  split(s, delim, std::back_inserter(elems));
  return elems;
}

Referenced by mkdir_recursive().

split() [2/2]

template<typename T >

void purify::split	(	const std::string &	s,
		char	delim,
		T	result
	)

adds split string to container

Definition at line 50 of file read_measurements.h.

                                                     {
  std::stringstream ss(s);
  std::string item;
  while (std::getline(ss, item, delim)) {
    *(result++) = item;
  }
};

version()

std::string purify::version ( )

inline

Returns library version.

Definition at line 40 of file config.in.h.

{ return "@Purify_VERSION@"; }

Referenced by main(), and TEST_CASE().

version_tuple()

std::tuple<uint8_t, uint8_t, uint8_t> purify::version_tuple ( )

inline

Returns library version.

Definition at line 42 of file config.in.h.

                                                           {
  // clang-format off
  return std::tuple<uint8_t, uint8_t, uint8_t>(
      @Purify_VERSION_MAJOR@, @Purify_VERSION_MINOR@, @Purify_VERSION_PATCH@);
  // clang-format on
}

visibility_filename()

std::string purify::visibility_filename ( std::string const &  filename )

inline

Visibility filename.

Definition at line 24 of file directories.in.h.

                                                                {
  return data_filename("vis_" + filename);
}

References data_filename().

Referenced by b_utilities::random_measurements().

vla_filename()

std::string purify::vla_filename ( std::string const &  filename )

inline

Specific vla data.

Definition at line 28 of file directories.in.h.

                                                         {
  return data_filename("vla/" + filename);
}

References data_filename().

Referenced by main(), and TEST_CASE().

Variable Documentation

diff_type_string

const std::map<std::string, diff_func_type> purify::diff_type_string

Initial value:

= {
    {"l2", diff_func_type::L2Norm}, {"CRR", diff_func_type::L2Norm_with_CRR}}

Definition at line 27 of file types.h.

Referenced by purify::YamlParser::parseAndSetAlgorithmOptions().

nondiff_type_string

const std::map<std::string, nondiff_func_type> purify::nondiff_type_string

Initial value:

= {
    {"l1", nondiff_func_type::L1Norm},
    {"denoiser", nondiff_func_type::Denoiser},
    {"realIndicator", nondiff_func_type::RealIndicator}}

Definition at line 32 of file types.h.

Referenced by purify::YamlParser::parseAndSetAlgorithmOptions().

stokes_int

const std::map<stokes, t_int> purify::stokes_int

Initial value:

= {{stokes::I, 1},   {stokes::Q, 2},   {stokes::U, 3},
                                            {stokes::V, 4},   {stokes::RR, -1}, {stokes::LL, -2},
                                            {stokes::RL, -3}, {stokes::LR, -4}, {stokes::XX, -5},
                                            {stokes::YY, -6}, {stokes::XY, -7}, {stokes::YX, -8}}

Definition at line 45 of file types.h.

Referenced by purify::pfitsio::header_params::header_params(), and TEST_CASE().

stokes_string

const std::map<std::string, stokes> purify::stokes_string

Initial value:

= {
    {"I", stokes::I},   {"i", stokes::I},   {"Q", stokes::Q},   {"q", stokes::Q},
    {"U", stokes::U},   {"u", stokes::U},   {"V", stokes::V},   {"v", stokes::V},
    {"XX", stokes::XX}, {"xx", stokes::XX}, {"YY", stokes::YY}, {"yy", stokes::YY},
    {"XY", stokes::XY}, {"xy", stokes::XY}, {"YX", stokes::YX}, {"yx", stokes::YX},
    {"LL", stokes::LL}, {"ll", stokes::LL}, {"RR", stokes::RR}, {"rr", stokes::RR},
    {"LR", stokes::LR}, {"lr", stokes::LR}, {"RL", stokes::RL}, {"rl", stokes::RL},
    {"P", stokes::P},   {"p", stokes::P}}

Definition at line 49 of file types.h.

Referenced by purify::YamlParser::parseAndSetGeneralConfiguration(), and TEST_CASE().