def test_fill_pswf_to_convolutionfunction(self):
oversampling = 8
support = 6
gcf, cf = create_pswf_convolutionfunction(self.image,
oversampling=oversampling,
support=support)
assert numpy.max(numpy.abs(cf.data)) > 0.0
if self.persist:
export_image_to_fits(
gcf, "%s/test_convolutionfunction_pswf_gcf.fits" % self.dir)
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_convolutionfunction_pwsf_cf.fits" % self.dir)
peak_location = numpy.unravel_index(numpy.argmax(numpy.abs(cf.data)),
cf.shape)
assert numpy.abs(cf.data[peak_location] - 0.1871722034219655 +
0j) < 1e-7, cf.data[peak_location]
assert peak_location == (0, 0, 0, 4, 4, 3, 3), peak_location
u_peak, v_peak = cf.grid_wcs.sub([1, 2]).wcs_pix2world(
peak_location[-2], peak_location[-1], 0)
assert numpy.abs(u_peak) < 1e-7, u_peak
assert numpy.abs(v_peak) < 1e-7, u_peak
def weight_blockvisibility(vis,
model,
gcfcf=None,
weighting="uniform",
robustness=0.0,
**kwargs):
""" Weight the visibility data
This is done collectively so the weights are summed over all vis_lists and then
corrected
:param vis_list:
:param model_imagelist: Model required to determine weighting parameters
:param weighting: Type of weighting
:param kwargs: Parameters for functions in graphs
:return: List of vis_graphs
"""
assert isinstance(vis, BlockVisibility), vis
assert image_is_canonical(model)
if gcfcf is None:
gcfcf = create_pswf_convolutionfunction(model)
griddata = create_griddata_from_image(model, vis)
griddata, sumwt = grid_blockvisibility_weight_to_griddata(
vis, griddata, gcfcf[1])
vis = griddata_blockvisibility_reweight(vis,
griddata,
gcfcf[1],
weighting=weighting,
robustness=robustness)
return vis
def invert_2d(vis: Visibility,
im: Image,
dopsf: bool = False,
normalize: bool = True,
gcfcf=None,
**kwargs) -> (Image, numpy.ndarray):
""" Invert using 2D convolution function, using the specified convolution function
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 vis: Visibility to be inverted
:param im: image template (not changed)
:param dopsf: Make the psf instead of the dirty image
:param normalize: Normalize by the sum of weights (True)
:param gcfcf: (Grid correction function i.e. in image space, Convolution function i.e. in uv space)
:return: resulting image
"""
assert isinstance(vis, Visibility), vis
svis = copy_visibility(vis)
if dopsf:
svis.data['vis'][...] = 1.0 + 0.0j
svis = shift_vis_to_image(svis, im, tangent=True, inverse=False)
if gcfcf is None:
gcf, cf = create_pswf_convolutionfunction(
im,
support=get_parameter(kwargs, "support", 6),
oversampling=get_parameter(kwargs, "oversampling", 128))
else:
gcf, cf = gcfcf
griddata = create_griddata_from_image(im)
griddata, sumwt = grid_visibility_to_griddata(svis,
griddata=griddata,
cf=cf)
imaginary = get_parameter(kwargs, "imaginary", False)
if imaginary:
result0, result1 = fft_griddata_to_image(griddata,
gcf,
imaginary=imaginary)
log.debug("invert_2d: retaining imaginary part of dirty image")
if normalize:
result0 = normalize_sumwt(result0, sumwt)
result1 = normalize_sumwt(result1, sumwt)
return result0, sumwt, result1
else:
result = fft_griddata_to_image(griddata, gcf)
if normalize:
result = normalize_sumwt(result, sumwt)
return result, sumwt
def test_griddata_predict_pswf(self):
self.actualSetUp(zerow=True)
gcf, cf = create_pswf_convolutionfunction(self.model,
support=6,
oversampling=256)
griddata = create_griddata_from_image(self.model)
griddata = fft_image_to_griddata(self.model, griddata, gcf)
newvis = degrid_visibility_from_griddata(self.vis,
griddata=griddata,
cf=cf)
newvis.data['vis'][...] -= self.vis.data['vis'][...]
qa = qa_visibility(newvis)
assert qa.data['rms'] < 0.7, str(qa)
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_predict_pswf(self):
self.actualSetUp(zerow=True, image_pol=PolarisationFrame("stokesIQUV"))
gcf, cf = create_pswf_convolutionfunction(self.model,
support=8,
oversampling=255)
modelIQUV = convert_stokes_to_polimage(self.model,
self.vis.polarisation_frame)
griddata = create_griddata_from_image(modelIQUV, self.vis)
griddata = fft_image_to_griddata(modelIQUV, griddata, gcf)
newvis = degrid_visibility_from_griddata(self.vis,
griddata=griddata,
cf=cf)
newvis.data['vis'][...] -= self.vis.data['vis'][...]
qa = qa_visibility(newvis)
assert qa.data['rms'] < 1.06, str(qa)
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 predict_2d(vis: Union[BlockVisibility, Visibility],
model: Image,
gcfcf=None,
**kwargs) -> Union[BlockVisibility, Visibility]:
""" Predict using convolutional degridding.
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 vis: Visibility to be predicted
:param model: model image
:param gcfcf: (Grid correction function i.e. in image space, Convolution function i.e. in uv space)
:return: resulting visibility (in place works)
"""
if model is None:
return vis
assert isinstance(vis, Visibility) or isinstance(vis, BlockVisibility), vis
_, _, ny, nx = model.data.shape
if gcfcf is None:
gcf, cf = create_pswf_convolutionfunction(
model,
support=get_parameter(kwargs, "support", 8),
oversampling=get_parameter(kwargs, "oversampling", 127))
else:
gcf, cf = gcfcf
griddata = create_griddata_from_image(model, vis)
polmodel = convert_stokes_to_polimage(model, vis.polarisation_frame)
griddata = fft_image_to_griddata(polmodel, griddata, gcf)
if isinstance(vis, Visibility):
vis = degrid_visibility_from_griddata(vis, griddata=griddata, cf=cf)
else:
vis = degrid_blockvisibility_from_griddata(vis,
griddata=griddata,
cf=cf)
# Now we can shift the visibility from the image frame to the original visibility frame
svis = shift_vis_to_image(vis, model, tangent=True, inverse=True)
return svis
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)
