purify::casa Namespace Reference

Namespaces
	details

Classes
class	MeasurementSet
	Interface around measurement sets. More...

Functions
utilities::vis_params	read_measurementset (std::string const &filename, const stokes pol=stokes::I, const std::vector< t_int > &channels=std::vector< t_int >(), std::string const &filter="")
	Read measurement set into vis_params structure. More...
utilities::vis_params	read_measurementset (std::string const &filename, const utilities::vis_params &uv1, const stokes pol, const std::vector< t_int > &channels, std::string const &filter)
	Read measurement set object then combine it with a uv_params structure. More...
utilities::vis_params	read_measurementset (std::vector< std::string > const &filename, const stokes pol=stokes::I, const std::vector< t_int > &channels=std::vector< t_int >(), std::string const &filter="")
	Read multiple measurement sets into one vis_params structure. More...
utilities::vis_params	read_measurementset (MeasurementSet const &ms_file, const stokes pol=stokes::I, const std::vector< t_int > &channels=std::vector< t_int >(), std::string const &filter="")
	Read measurement set object into vis_params structure. More...
std::vector< utilities::vis_params >	read_measurementset_channels (std::string const &filename, const stokes pol=stokes::I, const t_int &channel_width=1, std::string const &filter="")
	Read meassurement set into a vector of vis_params. More...
t_real	average_frequency (const purify::casa::MeasurementSet &ms_file, std::string const &filter, const std::vector< t_int > &channels)
	Return average frequency over channels. More...
template<class T >
Matrix< T >	table_column (::casacore::Table const &table, std::string const &column, std::string const &filter="")
MeasurementSet::const_iterator	operator+ (MeasurementSet::const_iterator::difference_type n, MeasurementSet::const_iterator const &c)
MeasurementSet::const_iterator	operator- (MeasurementSet::const_iterator::difference_type n, MeasurementSet::const_iterator const &c)

Function Documentation

average_frequency()

t_real purify::casa::average_frequency	(	const purify::casa::MeasurementSet &	ms_file,
		std::string const &	filter,
		const std::vector< t_int > &	channels
	)

Return average frequency over channels.

Definition at line 353 of file casacore.cc.

                                                           {
  // calculate average frequency
  t_real frequency_sum = 0;
  t_real width_sum = 0.;
  for (auto channel_number : channels) {
    auto const channel = ms_file[channel_number];
    auto const frequencies = channel.frequencies();
    auto const width = channel.width();
    frequency_sum += (frequencies.array() * width.array()).sum();
    width_sum += width.sum();
  }
  return frequency_sum / width_sum / 1e6;
}

Referenced by read_measurementset().

operator+()

MeasurementSet::const_iterator purify::casa::operator+ ( MeasurementSet::const_iterator::difference_type  n, MeasurementSet::const_iterator const &  c  )

inline

Definition at line 388 of file casacore.h.

                                                                                       {
  return c.operator+(n);
}

References purify::constant::c.

operator-()

MeasurementSet::const_iterator purify::casa::operator- ( MeasurementSet::const_iterator::difference_type  n, MeasurementSet::const_iterator const &  c  )

inline

Definition at line 392 of file casacore.h.

                                                                                       {
  return c.operator-(n);
}

References purify::constant::c.

read_measurementset() [1/4]

utilities::vis_params purify::casa::read_measurementset	(	MeasurementSet const &	ms_file,
		const stokes	polarization,
		const std::vector< t_int > &	channels_input,
		std::string const &	filter
	)

Read measurement set object into vis_params structure.

Definition at line 191 of file casacore.cc.

                                                                   {
  utilities::vis_params uv_data;
  t_uint rows = 0;
  std::vector<t_int> channels = channels_input;
  if (channels.empty()) {
    PURIFY_LOW_LOG("All Channels = {}", ms_file.size());
    Vector<t_int> temp_vector = Vector<t_int>::LinSpaced(ms_file.size(), 0, ms_file.size());
    if (temp_vector.size() == 1)  // fixing unwanted behavior of LinSpaced when ms_file.size() = 1
      temp_vector(0) = 0;
    channels = std::vector<t_int>(temp_vector.data(), temp_vector.data() + temp_vector.size());
  }
 
  // counting number of rows
  for (auto channel_number : channels) {
    rows += ms_file[channel_number].size();
  }
 
  PURIFY_LOW_LOG("Visibilities = {}", rows);
  uv_data.u = Vector<t_real>::Zero(rows);
  uv_data.v = Vector<t_real>::Zero(rows);
  uv_data.w = Vector<t_real>::Zero(rows);
  uv_data.vis = Vector<t_complex>::Zero(rows);
  uv_data.weights = Vector<t_complex>::Zero(rows);
  uv_data.ra =
      ms_file[channels[0]].right_ascension();  // convert directions from radians to degrees
  uv_data.dec = ms_file[channels[0]].declination();
  // calculate average frequency
  uv_data.average_frequency = average_frequency(ms_file, filter, channels);
 
  // add data to channel
  t_uint row = 0;
 
  for (auto channel_number : channels) {
    PURIFY_DEBUG("Adding channel {} to plane...", channel_number);
    if (channel_number < ms_file.size()) {
      auto const channel = ms_file[channel_number];
      if (channel.size() > 0) {
        if (uv_data.ra != channel.right_ascension() or uv_data.dec != channel.declination())
          throw std::runtime_error("Channels contain multiple pointings.");
        Vector<t_real> const frequencies = channel.frequencies();
        uv_data.u.segment(row, channel.size()) = channel.lambda_u();
        uv_data.v.segment(row, channel.size()) = -channel.lambda_v();
        uv_data.w.segment(row, channel.size()) = channel.lambda_w();
        t_real const the_casa_factor = 2;
        switch (polarization) {
        case stokes::I:
          uv_data.vis.segment(row, channel.size()) = channel.I("DATA") * 0.5;
          uv_data.weights.segment(row, channel.size()).real() =
              channel.wI(MeasurementSet::ChannelWrapper::Sigma::OVERALL) *
              the_casa_factor;  // go for sigma rather than sigma_spectrum
          break;
        case stokes::Q:
          uv_data.vis.segment(row, channel.size()) = channel.Q("DATA") * 0.5;
          uv_data.weights.segment(row, channel.size()).real() =
              channel.wQ(MeasurementSet::ChannelWrapper::Sigma::OVERALL) *
              the_casa_factor;  // go for sigma rather than sigma_spectrum
          break;
        case stokes::U:
          uv_data.vis.segment(row, channel.size()) = channel.U("DATA") * 0.5;
          uv_data.weights.segment(row, channel.size()).real() =
              channel.wU(MeasurementSet::ChannelWrapper::Sigma::OVERALL) *
              the_casa_factor;  // go for sigma rather than sigma_spectrum
          break;
        case stokes::V:
          uv_data.vis.segment(row, channel.size()) = channel.V("DATA") * 0.5;
          uv_data.weights.segment(row, channel.size()).real() =
              channel.wV(MeasurementSet::ChannelWrapper::Sigma::OVERALL) *
              the_casa_factor;  // go for sigma rather than sigma_spectrum
          break;
        case stokes::LL:
          uv_data.vis.segment(row, channel.size()) = channel.LL("DATA");
          uv_data.weights.segment(row, channel.size()).real() = channel.wLL(
              MeasurementSet::ChannelWrapper::Sigma::OVERALL);  // go for sigma rather than
          // sigma_spectrum
          break;
        case stokes::LR:
          uv_data.vis.segment(row, channel.size()) = channel.LR("DATA");
          uv_data.weights.segment(row, channel.size()).real() = channel.wRL(
              MeasurementSet::ChannelWrapper::Sigma::OVERALL);  // go for sigma rather than
          // sigma_spectrum
          break;
        case stokes::RL:
          uv_data.vis.segment(row, channel.size()) = channel.RL("DATA");
          uv_data.weights.segment(row, channel.size()).real() = channel.wRL(
              MeasurementSet::ChannelWrapper::Sigma::OVERALL);  // go for sigma rather than
          // sigma_spectrum
          break;
        case stokes::RR:
          uv_data.vis.segment(row, channel.size()) = channel.RR("DATA");
          uv_data.weights.segment(row, channel.size()).real() = channel.wRR(
              MeasurementSet::ChannelWrapper::Sigma::OVERALL);  // go for sigma rather than
          // sigma_spectrum
          break;
        case stokes::XX:
          uv_data.vis.segment(row, channel.size()) = channel.XX("DATA");
          uv_data.weights.segment(row, channel.size()).real() = channel.wXX(
              MeasurementSet::ChannelWrapper::Sigma::OVERALL);  // go for sigma rather than
          // sigma_spectrum
          break;
        case stokes::XY:
          uv_data.vis.segment(row, channel.size()) = channel.XY("DATA");
          uv_data.weights.segment(row, channel.size()).real() = channel.wXY(
              MeasurementSet::ChannelWrapper::Sigma::OVERALL);  // go for sigma rather than
          // sigma_spectrum
          break;
        case stokes::YX:
          uv_data.vis.segment(row, channel.size()) = channel.YX("DATA");
          uv_data.weights.segment(row, channel.size()).real() = channel.wYX(
              MeasurementSet::ChannelWrapper::Sigma::OVERALL);  // go for sigma rather than
          // sigma_spectrum
          break;
        case stokes::YY:
          uv_data.vis.segment(row, channel.size()) = channel.YY("DATA");
          uv_data.weights.segment(row, channel.size()).real() = channel.wYY(
              MeasurementSet::ChannelWrapper::Sigma::OVERALL);  // go for sigma rather than
          // sigma_spectrum
          break;
        case stokes::P:
          t_complex I(0., 1.);
          uv_data.vis.segment(row, channel.size()) = channel.Q("DATA") + I * channel.U("DATA");
          uv_data.weights.segment(row, channel.size()).real() =
              (channel.wQ(MeasurementSet::ChannelWrapper::Sigma::OVERALL).array() *
                   channel.wQ(MeasurementSet::ChannelWrapper::Sigma::OVERALL).array() +
               channel.wU(MeasurementSet::ChannelWrapper::Sigma::OVERALL).array() *
                   channel.wU(MeasurementSet::ChannelWrapper::Sigma::OVERALL).array())
                  .sqrt();  // go for sigma rather than
          // sigma_spectrum
          break;
        }
        row += channel.size();
      }
    }
  }
  // make consistent with vis file format exported from casa
  uv_data.weights = 1. / uv_data.weights.array();
  uv_data.units = utilities::vis_units::lambda;
  return uv_data;
}

References average_frequency(), purify::utilities::vis_params::average_frequency, purify::utilities::vis_params::dec, purify::casa::MeasurementSet::declination(), purify::I, purify::utilities::lambda, purify::LL, purify::LR, purify::casa::MeasurementSet::ChannelWrapper::OVERALL, purify::P, PURIFY_DEBUG, PURIFY_LOW_LOG, purify::Q, purify::utilities::vis_params::ra, purify::casa::MeasurementSet::right_ascension(), purify::RL, purify::RR, purify::casa::MeasurementSet::size(), purify::U, purify::utilities::vis_params::u, purify::utilities::vis_params::units, purify::V, purify::utilities::vis_params::v, purify::utilities::vis_params::vis, purify::utilities::vis_params::w, purify::utilities::vis_params::weights, purify::XX, purify::XY, purify::YX, and purify::YY.

read_measurementset() [2/4]

utilities::vis_params purify::casa::read_measurementset	(	std::string const &	filename,
		const stokes	polarization,
		const std::vector< t_int > &	channels_input,
		std::string const &	filter
	)

Read measurement set into vis_params structure.

Definition at line 147 of file casacore.cc.

                                                                   {
  auto const ms_file = purify::casa::MeasurementSet(filename);
  return read_measurementset(ms_file, polarization, channels_input, filter);
};

References purify::casa::MeasurementSet::filename().

Referenced by purify::read_measurements::read_measurements(), read_measurementset(), and read_measurementset_channels().

read_measurementset() [3/4]

utilities::vis_params purify::casa::read_measurementset	(	std::string const &	filename,
		const utilities::vis_params &	uv1,
		const stokes	pol,
		const std::vector< t_int > &	channels,
		std::string const &	filter
	)

Read measurement set object then combine it with a uv_params structure.

Definition at line 153 of file casacore.cc.

                                                                   {
  utilities::vis_params uv;
  const auto uv2 = read_measurementset(filename, pol, channels, filter);
  if (std::abs(uv1.ra - uv2.ra) > 1e-6)
    throw std::runtime_error(filename + ": wrong RA in pointing.");
  if (std::abs(uv1.dec - uv2.dec) > 1e-6)
    throw std::runtime_error(filename + ": wrong DEC in pointing.");
  uv.ra = uv1.ra;
  uv.dec = uv1.dec;
  uv.u = Vector<t_real>::Zero(uv1.size() + uv2.size());
  uv.v = Vector<t_real>::Zero(uv1.size() + uv2.size());
  uv.w = Vector<t_real>::Zero(uv1.size() + uv2.size());
  uv.vis = Vector<t_complex>::Zero(uv1.size() + uv2.size());
  uv.weights = Vector<t_complex>::Zero(uv1.size() + uv2.size());
  uv.u.segment(0, uv1.size()) = uv1.u;
  uv.v.segment(0, uv1.size()) = uv1.v;
  uv.w.segment(0, uv1.size()) = uv1.w;
  uv.vis.segment(0, uv1.size()) = uv1.vis;
  uv.weights.segment(0, uv1.size()) = uv1.weights;
  uv.u.segment(uv1.size(), uv2.size()) = uv2.u;
  uv.v.segment(uv1.size(), uv2.size()) = uv2.v;
  uv.w.segment(uv1.size(), uv2.size()) = uv2.w;
  uv.vis.segment(uv1.size(), uv2.size()) = uv2.vis;
  uv.weights.segment(uv1.size(), uv2.size()) = uv2.weights;
  return uv;
}

References purify::utilities::vis_params::dec, purify::casa::MeasurementSet::filename(), purify::utilities::vis_params::ra, read_measurementset(), purify::utilities::vis_params::size(), 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.

read_measurementset() [4/4]

utilities::vis_params purify::casa::read_measurementset	(	std::vector< std::string > const &	filename,
		const stokes	pol,
		const std::vector< t_int > &	channel,
		std::string const &	filter
	)

Read multiple measurement sets into one vis_params structure.

Definition at line 182 of file casacore.cc.

                                                                   {
  utilities::vis_params output = read_measurementset(filename.at(0), pol, channel, filter);
  if (filename.size() == 1) return output;
  for (int i = 1; i < filename.size(); i++)
    output = read_measurementset(filename.at(i), output, pol, channel, filter);
  return output;
}

References purify::casa::MeasurementSet::filename(), and read_measurementset().

read_measurementset_channels()

std::vector< utilities::vis_params > purify::casa::read_measurementset_channels	(	std::string const &	filename,
		const stokes	pol,
		const t_int &	channel_width,
		std::string const &	filter
	)

Read meassurement set into a vector of vis_params.

Definition at line 332 of file casacore.cc.

                                                                                         {
  // Read and average the channels into a vector of vis_params
  std::vector<utilities::vis_params> channels_vis;
  auto const ms_file = purify::casa::MeasurementSet(filename);
  t_int const total_channels = ms_file.size();
  t_int const planes = (channel_width == 0) ? 1 : std::floor(total_channels / channel_width);
  PURIFY_DEBUG("Number of planes {} ...", planes);
  for (int i = 0; i < planes; i++) {
    PURIFY_DEBUG("Reading plane {} ...", i);
    t_int const end = std::min((i + 1) * channel_width, total_channels);
    Vector<t_int> temp_block = Vector<t_int>::LinSpaced(channel_width, i * channel_width, end);
    if (channel_width == 1 or total_channels == i) temp_block(0) = i;
    auto const block = std::vector<t_int>(temp_block.data(), temp_block.data() + temp_block.size());
    channels_vis.push_back(read_measurementset(ms_file, pol, block, filter));
  }
  return channels_vis;
};

References purify::casa::MeasurementSet::end(), purify::casa::MeasurementSet::filename(), PURIFY_DEBUG, and read_measurementset().

table_column()

template<class T >

Matrix< T > purify::casa::table_column	(	::casacore::Table const &	table,
		std::string const &	column,
		std::string const &	filter = ""
	)

Definition at line 203 of file casacore.h.

                                                {
  return details::table_column<T>(table, column, filter,
                                  std::integral_constant<bool, sopt::is_complex<T>::value>());
}