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 test_griddata_predict_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)
griddata = create_griddata_from_image(self.model, nw=100, wstep=8.0)
griddata = fft_image_to_griddata(self.model, griddata, gcf)
newvis = degrid_visibility_from_griddata(self.vis,
griddata=griddata,
cf=cf)
qa = qa_visibility(newvis)
assert qa.data['rms'] < 120.0, str(qa)
self.plot_vis(newvis, 'awterm')
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 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 test_readwritegriddata(self):
im = create_test_image()
gd = create_griddata_from_image(im)
export_griddata_to_hdf5(gd, '%s/test_data_model_helpers_griddata.hdf' % self.dir)
newgd = import_griddata_from_hdf5('%s/test_data_model_helpers_griddata.hdf' % self.dir)
assert newgd.data.shape == gd.data.shape
assert numpy.max(numpy.abs(gd.data - newgd.data)) < 1e-15
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_box(self):
self.actualSetUp(zerow=True)
gcf, cf = create_box_convolutionfunction(self.model)
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'] < 46.0, str(qa)
def test_griddata_predict_box(self):
self.actualSetUp(zerow=True, image_pol=PolarisationFrame("stokesIQUV"))
gcf, cf = create_box_convolutionfunction(self.model)
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'] < 58.0, str(qa)
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_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_predict_wterm(self):
self.actualSetUp(zerow=False)
gcf, cf = create_awterm_convolutionfunction(self.model,
nw=100,
wstep=10.0,
oversampling=16,
support=32,
use_aaf=True)
griddata = create_griddata_from_image(self.model, nw=100, wstep=10.0)
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)
self.plot_vis(newvis, 'wterm')
assert qa.data['rms'] < 11.0, 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_predict_aterm(self):
self.actualSetUp(zerow=True)
make_pb = functools.partial(create_pb_generic,
diameter=35.0,
blockage=0.0,
use_local=False)
griddata = create_griddata_from_image(self.model)
gcf, cf = create_awterm_convolutionfunction(self.model,
make_pb=make_pb,
nw=1,
oversampling=16,
support=32,
use_aaf=True)
griddata = fft_image_to_griddata(self.model, griddata, gcf)
newvis = degrid_visibility_from_griddata(self.vis,
griddata=griddata,
cf=cf)
qa = qa_visibility(newvis)
assert qa.data['rms'] < 120.0, str(qa)
def test_readwritegriddata(self):
im = create_test_image()
gd = create_griddata_from_image(im)
config = {
"buffer": {
"directory": self.dir
},
"griddata": {
"name": "test_buffergriddata.hdf",
"data_model": "GridData"
}
}
bdm = BufferGridData(config["buffer"], config["griddata"], gd)
bdm.sync()
new_bdm = BufferGridData(config["buffer"], config["griddata"])
new_bdm.sync()
newgd = bdm.memory_data_model
assert newgd.data.shape == gd.data.shape
assert numpy.max(numpy.abs(gd.data - newgd.data)) < 1e-15
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 test_create_griddata_from_image(self):
m31model_by_image = create_griddata_from_image(self.m31image, None)
assert m31model_by_image.shape[0] == self.m31image.shape[0]
assert m31model_by_image.shape[1] == self.m31image.shape[1]
assert m31model_by_image.shape[3] == self.m31image.shape[2]
assert m31model_by_image.shape[4] == self.m31image.shape[3]
def test_convert_griddata_to_image(self):
m31model_by_image = create_griddata_from_image(self.m31image, None)
m31_converted = convert_griddata_to_image(m31model_by_image)
