def test_griddata_invert_wterm(self):
self.actualSetUp(zerow=False)
gcf, cf = create_awterm_convolutionfunction(self.model,
nw=100,
wstep=8.0,
oversampling=8,
support=32,
use_aaf=True)
cf_image = convert_convolutionfunction_to_image(cf)
cf_image.data = numpy.real(cf_image.data)
if self.persist:
export_image_to_fits(cf_image,
"%s/test_gridding_wterm_cf.fits" % self.dir)
griddata = create_griddata_from_image(self.model, nw=1)
griddata, sumwt = grid_visibility_to_griddata(self.vis,
griddata=griddata,
cf=cf)
im = fft_griddata_to_image(griddata, gcf)
im = normalize_sumwt(im, sumwt)
if self.persist:
export_image_to_fits(
im, '%s/test_gridding_dirty_wterm.fits' % self.dir)
self.check_peaks(im, 97.13215242859648)
def test_griddata_invert_awterm(self):
self.actualSetUp(zerow=False)
make_pb = functools.partial(create_pb_generic,
diameter=35.0,
blockage=0.0,
use_local=False)
pb = make_pb(self.model)
if self.persist:
export_image_to_fits(pb,
"%s/test_gridding_awterm_pb.fits" % self.dir)
gcf, cf = create_awterm_convolutionfunction(self.model,
make_pb=make_pb,
nw=100,
wstep=8.0,
oversampling=16,
support=32,
use_aaf=True)
cf_image = convert_convolutionfunction_to_image(cf)
cf_image.data = numpy.real(cf_image.data)
if self.persist:
export_image_to_fits(cf_image,
"%s/test_gridding_awterm_cf.fits" % self.dir)
griddata = create_griddata_from_image(self.model, nw=100, wstep=8.0)
griddata, sumwt = grid_visibility_to_griddata(self.vis,
griddata=griddata,
cf=cf)
im = fft_griddata_to_image(griddata, gcf)
im = normalize_sumwt(im, sumwt)
if self.persist:
export_image_to_fits(
im, '%s/test_gridding_dirty_awterm.fits' % self.dir)
self.check_peaks(im, 97.13240677427714)
def test_griddata_invert_aterm_noover(self):
self.actualSetUp(zerow=True)
make_pb = functools.partial(create_pb_generic,
diameter=35.0,
blockage=0.0,
use_local=False)
pb = make_pb(self.model)
if self.persist:
export_image_to_fits(pb,
"%s/test_gridding_aterm_pb.fits" % self.dir)
gcf, cf = create_awterm_convolutionfunction(self.model,
make_pb=make_pb,
nw=1,
oversampling=1,
support=16,
use_aaf=True)
griddata = create_griddata_from_image(self.model)
griddata, sumwt = grid_visibility_to_griddata(self.vis,
griddata=griddata,
cf=cf)
im = fft_griddata_to_image(griddata, gcf)
im = normalize_sumwt(im, sumwt)
if self.persist:
export_image_to_fits(
im, '%s/test_gridding_dirty_aterm_noover.fits' % self.dir)
self.check_peaks(im, 97.10594988491549)
def test_griddata_invert_box(self):
self.actualSetUp(zerow=True)
gcf, cf = create_box_convolutionfunction(self.model)
griddata = create_griddata_from_image(self.model)
griddata, sumwt = grid_visibility_to_griddata(self.vis,
griddata=griddata,
cf=cf)
im = fft_griddata_to_image(griddata, gcf)
im = normalize_sumwt(im, sumwt)
if self.persist:
export_image_to_fits(im,
'%s/test_gridding_dirty_box.fits' % self.dir)
self.check_peaks(im, 97.10594988491546, tol=1e-7)
def test_griddata_invert_pswf_w(self):
self.actualSetUp(zerow=False)
gcf, cf = create_pswf_convolutionfunction(self.model)
griddata = create_griddata_from_image(self.model, self.vis)
griddata, sumwt = grid_visibility_to_griddata(self.vis,
griddata=griddata,
cf=cf)
cim = fft_griddata_to_image(griddata, gcf)
cim = normalize_sumwt(cim, sumwt)
im = convert_polimage_to_stokes(cim)
if self.persist:
export_image_to_fits(
im, '%s/test_gridding_dirty_pswf_w.fits' % self.dir)
self.check_peaks(im, 97.13240718331633, tol=1e-7)
def test_griddata_invert_pswf_stokesIQ(self):
self.actualSetUp(zerow=True, image_pol=PolarisationFrame("stokesIQ"))
gcf, cf = create_pswf_convolutionfunction(self.model)
griddata = create_griddata_from_image(self.model, self.vis)
griddata, sumwt = grid_visibility_to_griddata(self.vis,
griddata=griddata,
cf=cf)
cim = fft_griddata_to_image(griddata, gcf)
cim = normalize_sumwt(cim, sumwt)
im = convert_polimage_to_stokes(cim)
if self.persist:
export_image_to_fits(im,
'%s/test_gridding_dirty_pswf.fits' % self.dir)
self.check_peaks(im, 97.10594988491545, tol=1e-7)
def test_griddata_invert_pswf_w(self):
self.actualSetUp(zerow=False)
gcf, cf = create_pswf_convolutionfunction(self.model,
support=6,
oversampling=32)
griddata = create_griddata_from_image(self.model)
griddata, sumwt = grid_visibility_to_griddata(self.vis,
griddata=griddata,
cf=cf)
im = fft_griddata_to_image(griddata, gcf)
im = normalize_sumwt(im, sumwt)
if self.persist:
export_image_to_fits(
im, '%s/test_gridding_dirty_pswf_w.fits' % self.dir)
self.check_peaks(im, 97.01838776845877, tol=1e-7)
def test_griddata_weight(self):
self.actualSetUp(zerow=True)
gcf, cf = create_box_convolutionfunction(self.model)
gd = create_griddata_from_image(self.model)
gd_list = [
grid_weight_to_griddata(self.vis, gd, cf) for i in range(10)
]
gd, sumwt = griddata_merge_weights(gd_list, algorithm='uniform')
self.vis = griddata_reweight(self.vis, gd, cf)
gd, sumwt = grid_visibility_to_griddata(self.vis, griddata=gd, cf=cf)
im = fft_griddata_to_image(gd, gcf)
im = normalize_sumwt(im, sumwt)
if self.persist:
export_image_to_fits(
im, '%s/test_gridding_dirty_2d_uniform.fits' % self.dir)
self.check_peaks(im, 99.40822097133994)
def test_griddata_visibility_weight_IQ(self):
self.actualSetUp(zerow=True, image_pol=PolarisationFrame("stokesIQUV"))
gcf, cf = create_pswf_convolutionfunction(self.model)
gd = create_griddata_from_image(self.model, self.vis)
gd_list = [
grid_visibility_weight_to_griddata(self.vis, gd, cf)
for i in range(10)
]
gd, sumwt = griddata_merge_weights(gd_list, algorithm='uniform')
self.vis = griddata_visibility_reweight(self.vis, gd, cf)
gd, sumwt = grid_visibility_to_griddata(self.vis, griddata=gd, cf=cf)
cim = fft_griddata_to_image(gd, gcf)
cim = normalize_sumwt(cim, sumwt)
im = convert_polimage_to_stokes(cim)
if self.persist:
export_image_to_fits(
im, '%s/test_gridding_dirty_2d_IQ_uniform.fits' % self.dir)
self.check_peaks(im, 99.40822097133994)
def test_griddata_blockvisibility_weight(self):
self.actualSetUp(zerow=True,
block=True,
image_pol=PolarisationFrame("stokesIQUV"))
gcf, cf = create_pswf_convolutionfunction(self.model)
gd = create_griddata_from_image(self.model, self.vis)
gd_list = [
grid_blockvisibility_weight_to_griddata(self.vis, gd, cf)
for i in range(10)
]
assert numpy.max(numpy.abs(gd_list[0][0].data)) > 10.0
gd, sumwt = griddata_merge_weights(gd_list, algorithm='uniform')
self.vis = griddata_blockvisibility_reweight(self.vis, gd, cf)
gd, sumwt = grid_blockvisibility_to_griddata(self.vis,
griddata=gd,
cf=cf)
cim = fft_griddata_to_image(gd, gcf)
cim = normalize_sumwt(cim, sumwt)
im = convert_polimage_to_stokes(cim)
if self.persist:
export_image_to_fits(
im, '%s/test_gridding_dirty_2d_uniform_block.fits' % self.dir)
self.check_peaks(im, 100.13540418821904)
def invert_ng(bvis: BlockVisibility,
model: Image,
dopsf: bool = False,
normalize: bool = True,
**kwargs) -> (Image, numpy.ndarray):
""" Invert using nifty-gridder module
https://gitlab.mpcdf.mpg.de/ift/nifty_gridder
Use the image im as a template. Do PSF in a separate call.
In the imaging and pipeline workflows, this may be invoked using context='ng'.
:param dopsf: Make the PSF instead of the dirty image
:param bvis: BlockVisibility to be inverted
:param im: image template (not changed)
:param normalize: Normalize by the sum of weights (True)
:return: (resulting image, sum of the weights for each frequency and polarization)
"""
assert image_is_canonical(model)
assert isinstance(bvis, BlockVisibility), bvis
im = copy_image(model)
nthreads = get_parameter(kwargs, "threads", 4)
epsilon = get_parameter(kwargs, "epsilon", 1e-12)
do_wstacking = get_parameter(kwargs, "do_wstacking", True)
verbosity = get_parameter(kwargs, "verbosity", 0)
sbvis = copy_visibility(bvis)
sbvis = shift_vis_to_image(sbvis, im, tangent=True, inverse=False)
freq = sbvis.frequency # frequency, Hz
nrows, nants, _, vnchan, vnpol = sbvis.vis.shape
# if dopsf:
# sbvis = fill_vis_for_psf(sbvis)
ms = sbvis.vis.reshape([nrows * nants * nants, vnchan, vnpol])
ms = convert_pol_frame(ms,
bvis.polarisation_frame,
im.polarisation_frame,
polaxis=2)
uvw = sbvis.uvw.reshape([nrows * nants * nants, 3])
wgt = sbvis.flagged_imaging_weight.reshape(
[nrows * nants * nants, vnchan, vnpol])
if epsilon > 5.0e-6:
ms = ms.astype("c8")
wgt = wgt.astype("f4")
# Find out the image size/resolution
npixdirty = im.nwidth
pixsize = numpy.abs(numpy.radians(im.wcs.wcs.cdelt[0]))
fuvw = uvw.copy()
# We need to flip the u and w axes.
fuvw[:, 0] *= -1.0
fuvw[:, 2] *= -1.0
nchan, npol, ny, nx = im.shape
im.data[...] = 0.0
sumwt = numpy.zeros([nchan, npol])
# There's a latent problem here with the weights.
# wgt = numpy.real(convert_pol_frame(wgt, bvis.polarisation_frame, im.polarisation_frame, polaxis=2))
# Set up the conversion from visibility channels to image channels
vis_to_im = numpy.round(model.wcs.sub([4]).wcs_world2pix(
freq, 0)[0]).astype('int')
# Nifty gridder likes to receive contiguous arrays so we transpose
# at the beginning
mfs = nchan == 1
if dopsf:
mst = ms.T
mst[...] = 0.0
mst[0, ...] = 1.0
wgtt = wgt.T
if mfs:
dirty = ng.ms2dirty(fuvw.astype(numpy.float64),
bvis.frequency.astype(numpy.float64),
numpy.ascontiguousarray(mst[0, :, :].T),
numpy.ascontiguousarray(wgtt[0, :, :].T),
npixdirty,
npixdirty,
pixsize,
pixsize,
epsilon,
do_wstacking=do_wstacking,
nthreads=nthreads,
verbosity=verbosity)
sumwt[0, :] += numpy.sum(wgtt[0, 0, :].T, axis=0)
im.data[0, :] += dirty.T
else:
for vchan in range(vnchan):
ichan = vis_to_im[vchan]
frequency = numpy.array(freq[vchan:vchan + 1]).astype(
numpy.float64)
dirty = ng.ms2dirty(
fuvw.astype(numpy.float64),
frequency.astype(numpy.float64),
numpy.ascontiguousarray(mst[0,
vchan, :][...,
numpy.newaxis]),
numpy.ascontiguousarray(wgtt[0,
vchan, :][...,
numpy.newaxis]),
npixdirty,
npixdirty,
pixsize,
pixsize,
epsilon,
do_wstacking=do_wstacking,
nthreads=nthreads,
verbosity=verbosity)
sumwt[ichan, :] += numpy.sum(wgtt[0, ichan, :].T, axis=0)
im.data[ichan, :] += dirty.T
else:
mst = ms.T
wgtt = wgt.T
for pol in range(npol):
if mfs:
dirty = ng.ms2dirty(
fuvw.astype(numpy.float64),
bvis.frequency.astype(numpy.float64),
numpy.ascontiguousarray(mst[pol, :, :].T),
numpy.ascontiguousarray(wgtt[pol, :, :].T),
npixdirty,
npixdirty,
pixsize,
pixsize,
epsilon,
do_wstacking=do_wstacking,
nthreads=nthreads,
verbosity=verbosity)
sumwt[0, pol] += numpy.sum(wgtt[pol, 0, :].T, axis=0)
im.data[0, pol] += dirty.T
else:
for vchan in range(vnchan):
ichan = vis_to_im[vchan]
frequency = numpy.array(freq[vchan:vchan + 1]).astype(
numpy.float64)
dirty = ng.ms2dirty(fuvw.astype(numpy.float64),
frequency.astype(numpy.float64),
numpy.ascontiguousarray(
mst[pol,
vchan, :][...,
numpy.newaxis]),
numpy.ascontiguousarray(
wgtt[pol,
vchan, :][...,
numpy.newaxis]),
npixdirty,
npixdirty,
pixsize,
pixsize,
epsilon,
do_wstacking=do_wstacking,
nthreads=nthreads,
verbosity=verbosity)
sumwt[ichan, pol] += numpy.sum(wgtt[pol, ichan, :].T,
axis=0)
im.data[ichan, pol] += dirty.T
if normalize:
im = normalize_sumwt(im, sumwt)
return im, sumwt
def invert_ng(bvis: BlockVisibility,
model: Image,
dopsf: bool = False,
normalize: bool = True,
**kwargs) -> (Image, numpy.ndarray):
""" Invert using nifty-gridder module
https://gitlab.mpcdf.mpg.de/ift/nifty_gridder
Use the image im as a template. Do PSF in a separate call.
This is at the bottom of the layering i.e. all transforms are eventually expressed in terms
of this function. . Any shifting needed is performed here.
:param bvis: BlockVisibility to be inverted
:param im: image template (not changed)
:param normalize: Normalize by the sum of weights (True)
:return: (resulting image, sum of the weights for each frequency and polarization)
"""
assert image_is_canonical(model)
assert isinstance(bvis, BlockVisibility), bvis
im = copy_image(model)
nthreads = get_parameter(kwargs, "threads", 4)
epsilon = get_parameter(kwargs, "epsilon", 1e-12)
do_wstacking = get_parameter(kwargs, "do_wstacking", True)
verbosity = get_parameter(kwargs, "verbosity", 0)
sbvis = copy_visibility(bvis)
sbvis = shift_vis_to_image(sbvis, im, tangent=True, inverse=False)
vis = bvis.vis
freq = sbvis.frequency # frequency, Hz
nrows, nants, _, vnchan, vnpol = vis.shape
uvw = sbvis.uvw.reshape([nrows * nants * nants, 3])
ms = vis.reshape([nrows * nants * nants, vnchan, vnpol])
wgt = sbvis.imaging_weight.reshape(
[nrows * nants * nants, vnchan, vnpol])
if dopsf:
ms[...] = 1.0 + 0.0j
if epsilon > 5.0e-6:
ms = ms.astype("c8")
wgt = wgt.astype("f4")
# Find out the image size/resolution
npixdirty = im.nwidth
pixsize = numpy.abs(numpy.radians(im.wcs.wcs.cdelt[0]))
fuvw = uvw.copy()
# We need to flip the u and w axes.
fuvw[:, 0] *= -1.0
fuvw[:, 2] *= -1.0
nchan, npol, ny, nx = im.shape
im.data[...] = 0.0
sumwt = numpy.zeros([nchan, npol])
ms = convert_pol_frame(ms,
bvis.polarisation_frame,
im.polarisation_frame,
polaxis=2)
# There's a latent problem here with the weights.
# wgt = numpy.real(convert_pol_frame(wgt, bvis.polarisation_frame, im.polarisation_frame, polaxis=2))
# Set up the conversion from visibility channels to image channels
vis_to_im = numpy.round(model.wcs.sub([4]).wcs_world2pix(
freq, 0)[0]).astype('int')
for vchan in range(vnchan):
ichan = vis_to_im[vchan]
for pol in range(npol):
# Nifty gridder likes to receive contiguous arrays
ms_1d = numpy.array([
ms[row, vchan:vchan + 1, pol]
for row in range(nrows * nants * nants)
],
dtype='complex')
ms_1d.reshape([ms_1d.shape[0], 1])
wgt_1d = numpy.array([
wgt[row, vchan:vchan + 1, pol]
for row in range(nrows * nants * nants)
])
wgt_1d.reshape([wgt_1d.shape[0], 1])
dirty = ng.ms2dirty(fuvw,
freq[vchan:vchan + 1],
ms_1d,
wgt_1d,
npixdirty,
npixdirty,
pixsize,
pixsize,
epsilon,
do_wstacking=do_wstacking,
nthreads=nthreads,
verbosity=verbosity)
sumwt[ichan, pol] += numpy.sum(wgt[:, vchan, pol])
im.data[ichan, pol] += dirty.T
if normalize:
im = normalize_sumwt(im, sumwt)
return im, sumwt
