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_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 sum_invert_results(image_list):
""" Sum a set of invert results with appropriate weighting
:param image_list: List of [image, sum weights] pairs
:return: image, sum of weights
"""
if len(image_list) == 1:
return image_list[0]
first = True
sumwt = 0.0
im = None
for i, arg in enumerate(image_list):
if arg is not None:
if isinstance(arg[1], numpy.ndarray):
scale = arg[1][..., numpy.newaxis, numpy.newaxis]
else:
scale = arg[1]
if first:
im = copy_image(arg[0])
im.data *= scale
sumwt = arg[1]
first = False
else:
im.data += scale * arg[0].data
sumwt += arg[1]
assert not first, "No invert results"
im = normalize_sumwt(im, sumwt)
return im, sumwt
def test_griddata_invert_fast(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)
export_image_to_fits(im, '%s/test_gridding_dirty_fast.fits' % self.dir)
self.check_peaks(im, 96.74492791536595, 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)
export_image_to_fits(im, '%s/test_gridding_dirty_pswf_w.fits' % self.dir)
self.check_peaks(im, 96.62754566597258, tol=1e-7)
def invert_serial(vis, im: Image, dopsf=False, normalize=True, context='2d', vis_slices=1,
facets=1, overlap=0, taper=None, **kwargs):
""" Invert using algorithm specified by context:
* 2d: Two-dimensional transform
* wstack: wstacking with either vis_slices or wstack (spacing between w planes) set
* wprojection: w projection with wstep (spacing between w places) set, also kernel='wprojection'
* timeslice: snapshot imaging with either vis_slices or timeslice set. timeslice='auto' does every time
* facets: Faceted imaging with facets facets on each axis
* facets_wprojection: facets AND wprojection
* facets_wstack: facets AND wstacking
* wprojection_wstack: wprojection and wstacking
:param vis:
:param im:
:param dopsf: Make the psf instead of the dirty image (False)
:param normalize: Normalize by the sum of weights (True)
:param context: Imaging context e.g. '2d', 'timeslice', etc.
:param kwargs:
:return: Image, sum of weights
"""
c = imaging_context(context)
vis_iter = c['vis_iterator']
invert = c['invert']
if not isinstance(vis, Visibility):
svis = convert_blockvisibility_to_visibility(vis)
else:
svis = vis
resultimage = create_empty_image_like(im)
totalwt = None
for rows in vis_iter(svis, vis_slices=vis_slices):
if numpy.sum(rows):
visslice = create_visibility_from_rows(svis, rows)
sumwt = 0.0
workimage = create_empty_image_like(im)
for dpatch in image_scatter_facets(workimage, facets=facets, overlap=overlap, taper=taper):
result, sumwt = invert(visslice, dpatch, dopsf, normalize=False, facets=facets,
vis_slices=vis_slices, **kwargs)
# Ensure that we fill in the elements of dpatch instead of creating a new numpy arrray
dpatch.data[...] = result.data[...]
# Assume that sumwt is the same for all patches
if totalwt is None:
totalwt = sumwt
else:
totalwt += sumwt
resultimage.data += workimage.data
assert totalwt is not None, "No valid data found for imaging"
if normalize:
resultimage = normalize_sumwt(resultimage, totalwt)
return resultimage, totalwt
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.11833094588997, tol=1e-7)
def test_griddata_invert_pswf(self):
self.actualSetUp(zerow=True)
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.fits' % self.dir)
self.check_peaks(im, 97.00435128311616, 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.42031190701735)
def sum_invert_results(image_list, normalize=True):
""" Sum a set of invert results with appropriate weighting
:param image_list: List of [image, sum weights] pairs
:return: image, sum of weights
"""
if len(image_list) == 1:
return image_list[0]
im = create_empty_image_like(image_list[0][0])
sumwt = image_list[0][1].copy()
sumwt *= 0.0
for i, arg in enumerate(image_list):
if arg is not None:
im.data += arg[1][..., numpy.newaxis, numpy.newaxis] * arg[0].data
sumwt += arg[1]
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 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
