# Source code for africanus.gridding.wgridder.im2vis

```
# -*- coding: utf-8 -*-
try:
from ducc0.wgridder import dirty2ms
except ImportError as e:
ducc_import_error = e
else:
ducc_import_error = None
import numpy as np
from africanus.util.docs import DocstringTemplate
from africanus.util.requirements import requires_optional
@requires_optional('ducc0.wgridder', ducc_import_error)
def _model_internal(uvw, freq, image, freq_bin_idx, freq_bin_counts, cell,
weights, flag, celly, epsilon, nthreads, do_wstacking):
# adjust for chunking
# need a copy here if using multiple row chunks
freq_bin_idx2 = freq_bin_idx - freq_bin_idx.min()
nband, nx, ny = image.shape
nrow = uvw.shape[0]
nchan = freq.size
vis = np.zeros((nrow, nchan), dtype=np.result_type(image, np.complex64))
for i in range(nband):
ind = slice(freq_bin_idx2[i], freq_bin_idx2[i] + freq_bin_counts[i])
if weights is not None:
wgt = weights[:, ind]
else:
wgt = None
if flag is not None:
mask = flag[:, ind]
else:
mask = None
vis[:, ind] = dirty2ms(uvw=uvw, freq=freq[ind], dirty=image[i],
wgt=wgt, pixsize_x=cell, pixsize_y=celly,
nu=0, nv=0, epsilon=epsilon, mask=mask,
nthreads=nthreads, do_wstacking=do_wstacking)
return vis
[docs]@requires_optional('ducc0.wgridder', ducc_import_error)
def model(uvw, freq, image, freq_bin_idx, freq_bin_counts, cell, weights=None,
flag=None, celly=None, epsilon=1e-5, nthreads=1, do_wstacking=True):
if celly is None:
celly = cell
if not nthreads:
import multiprocessing
nthreads = multiprocessing.cpu_count()
return _model_internal(uvw, freq, image, freq_bin_idx, freq_bin_counts,
cell, weights, flag, celly, epsilon, nthreads,
do_wstacking)
MODEL_DOCS = DocstringTemplate(
r"""
Compute image to visibility mapping using ducc degridder i.e.
.. math::
V = Rx
where :math:`R` is an implicit degridding operator, :math:`V`
denotes visibilities of shape :code:`(row, chan)` and
:math:`x` is the image of shape :code:`(band, nx, ny)`.
The number of imaging bands :code:`(band)` has to
be less than or equal to the number of channels
:code:`(chan)` at which the data were obtained.
The mapping from :code:`(chan)` to :code:`(band)` is described
by :code:`freq_bin_idx` and :code:`freq_bin_counts` as
described below.
There is an option to provide weights during degridding
to cater for self adjoint gridding and degridding operators.
In this case :code:`weights` should actually be the square
root of what is typically referred to as imaging weights.
In this case the degridder computes the whitened model
visibilities i.e.
.. math::
V = \Sigma^{-\frac{1}{2}} R x
where :math:`\Sigma` refers to the inverse of the weights
(i.e. the data covariance matrix when using natural weighting).
Parameters
----------
uvw : $(array_type)
uvw coordinates at which visibilities were
obtained with shape :code:`(row, 3)`.
freq : $(array_type)
Observational frequencies of shape :code:`(chan,)`.
model : $(array_type)
Model image to degrid of shape :code:`(nband, nx, ny)`.
freq_bin_idx : $(array_type)
Starting indices of frequency bins for each imaging
band of shape :code:`(band,)`.
freq_bin_counts : $(array_type)
The number of channels in each imaging band of shape :code:`(band,)`.
cell : float
The cell size of a pixel along the :math:`x` direction in radians.
weights : $(array_type), optional
Imaging weights of shape :code:`(row, chan)`.
flag: $(array_type), optional
Flags of shape :code:`(row,chan)`. Will only process visibilities
for which flag!=0
celly : float, optional
The cell size of a pixel along the :math:`y` direction in radians.
By default same as cell size along :math:`x` direction.
epsilon : float, optional
The precision of the gridder with respect to the direct Fourier
transform. By deafult, this is set to :code:`1e-5` for single
precision and :code:`1e-7` for double precision.
nthreads : int, optional
The number of threads to use. Defaults to one.
If set to zero will use all available cores.
do_wstacking : bool, optional
Whether to correct for the w-term or not. Defaults to True
Returns
-------
vis : $(array_type)
Visibilities corresponding to :code:`model` of shape
:code:`(row,chan)`.
""")
try:
model.__doc__ = MODEL_DOCS.substitute(
array_type=":class:`numpy.ndarray`")
except AttributeError:
pass
```