def test_deconvolve_and_restore_cube_mmclean_facets(self):
self.actualSetUp(add_errors=True)
dirty_imagelist = invert_list_serial_workflow(self.vis_list,
self.model_imagelist,
context='2d',
dopsf=False,
normalize=True)
psf_imagelist = invert_list_serial_workflow(self.vis_list,
self.model_imagelist,
context='2d',
dopsf=True,
normalize=True)
dec_imagelist = deconvolve_list_serial_workflow(
dirty_imagelist,
psf_imagelist,
self.model_imagelist,
niter=1000,
fractional_threshold=0.1,
scales=[0, 3, 10],
algorithm='mmclean',
nmoment=3,
nchan=self.freqwin,
threshold=0.01,
gain=0.7,
deconvolve_facets=8,
deconvolve_overlap=8,
deconvolve_taper='tukey')
residual_imagelist = residual_list_serial_workflow(
self.vis_list, model_imagelist=dec_imagelist, context='2d')
restored = restore_list_serial_workflow(
model_imagelist=dec_imagelist,
psf_imagelist=psf_imagelist,
residual_imagelist=residual_imagelist,
empty=self.model_imagelist)[0]
if self.persist:
export_image_to_fits(
restored,
'%s/test_imaging_serial_overlap_mmclean_restored.fits' %
(self.dir))
def test_deconvolve_spectral(self):
self.actualSetUp(add_errors=True)
dirty_imagelist = invert_list_serial_workflow(self.vis_list,
self.model_imagelist,
context='2d',
dopsf=False,
normalize=True)
psf_imagelist = invert_list_serial_workflow(self.vis_list,
self.model_imagelist,
context='2d',
dopsf=True,
normalize=True)
deconvolved = deconvolve_list_serial_workflow(dirty_imagelist,
psf_imagelist,
self.model_imagelist,
niter=1000,
fractional_threshold=0.1,
scales=[0, 3, 10],
threshold=0.1,
gain=0.7)
if self.persist:
export_image_to_fits(
deconvolved[0],
'%s/test_imaging_serial_deconvolve_spectral.fits' % (self.dir))
def _invert_base(self, context, extra='', fluxthreshold=1.0, positionthreshold=1.0, check_components=True,
facets=1, vis_slices=1, gcfcf=None, **kwargs):
centre = self.freqwin // 2
dirty = invert_list_serial_workflow(self.vis_list, self.model_list, context=context,
dopsf=False, normalize=True, facets=facets, vis_slices=vis_slices,
gcfcf=gcfcf, **kwargs)[centre]
if self.persist: export_image_to_fits(dirty[0], '%s/test_imaging_invert_%s%s_serial_dirty.fits' %
(self.dir, context, extra))
assert numpy.max(numpy.abs(dirty[0].data)), "Image is empty"
if check_components:
self._checkcomponents(dirty[0], fluxthreshold, positionthreshold)
def ft_ift_sm(ov, sm, g):
assert isinstance(ov, Visibility), ov
assert isinstance(sm, SkyModel), sm
if g is not None:
assert len(g) == 2, g
assert isinstance(g[0], Image), g[0]
assert isinstance(g[1], ConvolutionFunction), g[1]
v = copy_visibility(ov)
v.data['vis'][...] = 0.0 + 0.0j
if len(sm.components) > 0:
if isinstance(sm.mask, Image):
comps = copy_skycomponent(sm.components)
comps = apply_beam_to_skycomponent(comps, sm.mask)
v = predict_skycomponent_visibility(v, comps)
else:
v = predict_skycomponent_visibility(v, sm.components)
if isinstance(sm.image, Image):
if numpy.max(numpy.abs(sm.image.data)) > 0.0:
if isinstance(sm.mask, Image):
model = copy_image(sm.image)
model.data *= sm.mask.data
else:
model = sm.image
v = predict_list_serial_workflow([v], [model],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=[g],
**kwargs)[0]
assert isinstance(sm.image, Image), sm.image
result = invert_list_serial_workflow([v], [sm.image],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)[0]
if isinstance(sm.mask, Image):
result[0].data *= sm.mask.data
return result
def _predict_base(self, context='2d', extra='', fluxthreshold=1.0, facets=1, vis_slices=1,
gcfcf=None, **kwargs):
centre = self.freqwin // 2
vis_list = zero_list_serial_workflow(self.vis_list)
vis_list = predict_list_serial_workflow(vis_list, self.model_list, context=context,
vis_slices=vis_slices, facets=facets, gcfcf=gcfcf, **kwargs)
vis_list = subtract_list_serial_workflow(self.vis_list, vis_list)
dirty = invert_list_serial_workflow(vis_list, self.model_list, context=context, dopsf=False,
gcfcf=gcfcf, normalize=True, vis_slices=vis_slices)[centre]
assert numpy.max(numpy.abs(dirty[0].data)), "Residual image is empty"
if self.persist: export_image_to_fits(dirty[0], '%s/test_imaging_predict_%s%s_serial_dirty.fits' %
(self.dir, context, extra))
maxabs = numpy.max(numpy.abs(dirty[0].data))
assert maxabs < fluxthreshold, "Error %.3f greater than fluxthreshold %.3f " % (maxabs, fluxthreshold)
def test_restored_list_facet(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
psf_image_list = invert_list_serial_workflow(self.bvis_list,
self.model_list,
context='2d',
dopsf=True)
residual_image_list = residual_list_serial_workflow(self.bvis_list,
self.model_list,
context='2d')
restored_4facets_image_list = restore_list_serial_workflow(
self.model_list,
psf_image_list,
residual_image_list,
restore_facets=4,
psfwidth=1.0)
restored_1facets_image_list = restore_list_serial_workflow(
self.model_list,
psf_image_list,
residual_image_list,
restore_facets=1,
psfwidth=1.0)
if self.persist:
export_image_to_fits(
restored_4facets_image_list[0],
'%s/test_imaging_invert_serial_restored_4facets.fits' %
(self.dir))
qa = qa_image(restored_4facets_image_list[centre])
assert numpy.abs(qa.data['max'] - 100.00291168642293) < 1e-7, str(qa)
assert numpy.abs(qa.data['min'] + 0.1698056648051111) < 1e-7, str(qa)
restored_4facets_image_list[
centre].data -= restored_1facets_image_list[centre].data
if self.persist:
export_image_to_fits(
restored_4facets_image_list[centre],
'%s/test_imaging_invert_serial_restored_4facets_error.fits' %
(self.dir))
qa = qa_image(restored_4facets_image_list[centre])
assert numpy.abs(qa.data['max']) < 1e-10, str(qa)
def test_restored_list_noresidual(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
psf_image_list = invert_list_serial_workflow(self.bvis_list,
self.model_list,
context='2d',
dopsf=True)
restored_image_list = restore_list_serial_workflow(self.model_list,
psf_image_list,
psfwidth=1.0)
if self.persist:
export_image_to_fits(
restored_image_list[centre],
'%s/test_imaging_invert_serial_restored_noresidual.fits' %
(self.dir))
qa = qa_image(restored_image_list[centre])
assert numpy.abs(qa.data['max'] - 100.0) < 1e-7, str(qa)
assert numpy.abs(qa.data['min']) < 1e-7, str(qa)
def ift_ical_sm(v, sm, g):
assert isinstance(v, Visibility), v
assert isinstance(sm, SkyModel), sm
if g is not None:
assert len(g) == 2, g
assert isinstance(g[0], Image), g[0]
assert isinstance(g[1], ConvolutionFunction), g[1]
if docal and isinstance(sm.gaintable, GainTable):
bv = convert_visibility_to_blockvisibility(v)
bv = apply_gaintable(bv, sm.gaintable)
v = convert_blockvisibility_to_visibility(bv)
result = invert_list_serial_workflow([v], [sm.image],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=[g],
**kwargs)[0]
if isinstance(sm.mask, Image):
result[0].data *= sm.mask.data
return result
def ical_list_serial_workflow(vis_list,
model_imagelist,
context,
vis_slices=1,
facets=1,
gcfcf=None,
calibration_context='TG',
do_selfcal=True,
**kwargs):
"""Run ICAL pipeline
:param vis_list:
:param model_imagelist:
:param context: imaging context e.g. '2d'
:param calibration_context: Sequence of calibration steps e.g. TGB
:param do_selfcal: Do the selfcalibration?
:param kwargs: Parameters for functions in components
:return:
"""
gt_list = list()
if gcfcf is None:
gcfcf = [create_pswf_convolutionfunction(model_imagelist[0])]
psf_imagelist = invert_list_serial_workflow(vis_list,
model_imagelist,
dopsf=True,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
model_vislist = [copy_visibility(v, zero=True) for v in vis_list]
if do_selfcal:
cal_vis_list = [copy_visibility(v) for v in vis_list]
else:
cal_vis_list = vis_list
if do_selfcal:
# Make the predicted visibilities, selfcalibrate against it correcting the gains, then
# form the residual visibility, then make the residual image
model_vislist = predict_list_serial_workflow(model_vislist,
model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
cal_vis_list, gt_list = calibrate_list_serial_workflow(
cal_vis_list,
model_vislist,
calibration_context=calibration_context,
**kwargs)
residual_vislist = subtract_list_serial_workflow(
cal_vis_list, model_vislist)
residual_imagelist = invert_list_serial_workflow(residual_vislist,
model_imagelist,
context=context,
dopsf=False,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
iteration=0,
**kwargs)
else:
# If we are not selfcalibrating it's much easier and we can avoid an unnecessary round of gather/scatter
# for visibility partitioning such as timeslices and wstack.
residual_imagelist = residual_list_serial_workflow(
cal_vis_list,
model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
deconvolve_model_imagelist = deconvolve_list_serial_workflow(
residual_imagelist,
psf_imagelist,
model_imagelist,
prefix='cycle 0',
**kwargs)
nmajor = get_parameter(kwargs, "nmajor", 5)
if nmajor > 1:
for cycle in range(nmajor):
if do_selfcal:
model_vislist = predict_list_serial_workflow(
model_vislist,
deconvolve_model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
cal_vis_list = [copy_visibility(v) for v in vis_list]
cal_vis_list, gt_list = calibrate_list_serial_workflow(
cal_vis_list,
model_vislist,
calibration_context=calibration_context,
iteration=cycle,
**kwargs)
residual_vislist = subtract_list_serial_workflow(
cal_vis_list, model_vislist)
residual_imagelist = invert_list_serial_workflow(
residual_vislist,
model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
else:
residual_imagelist = residual_list_serial_workflow(
cal_vis_list,
deconvolve_model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
prefix = "cycle %d" % (cycle + 1)
deconvolve_model_imagelist = deconvolve_list_serial_workflow(
residual_imagelist,
psf_imagelist,
deconvolve_model_imagelist,
prefix=prefix,
**kwargs)
residual_imagelist = residual_list_serial_workflow(
cal_vis_list,
deconvolve_model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
restore_imagelist = restore_list_serial_workflow(
deconvolve_model_imagelist, psf_imagelist, residual_imagelist)
return deconvolve_model_imagelist, residual_imagelist, restore_imagelist, gt_list
def continuum_imaging_list_serial_workflow(vis_list,
model_imagelist,
context,
gcfcf=None,
vis_slices=1,
facets=1,
**kwargs):
""" Create graph for the continuum imaging pipeline.
Same as ICAL but with no selfcal.
:param vis_list:
:param model_imagelist:
:param context: Imaging context
:param kwargs: Parameters for functions in components
:return:
"""
if gcfcf is None:
gcfcf = [create_pswf_convolutionfunction(model_imagelist[0])]
psf_imagelist = invert_list_serial_workflow(vis_list,
model_imagelist,
context=context,
dopsf=True,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
residual_imagelist = residual_list_serial_workflow(vis_list,
model_imagelist,
context=context,
gcfcf=gcfcf,
vis_slices=vis_slices,
facets=facets,
**kwargs)
deconvolve_model_imagelist = deconvolve_list_serial_workflow(
residual_imagelist,
psf_imagelist,
model_imagelist,
prefix='cycle 0',
**kwargs)
nmajor = get_parameter(kwargs, "nmajor", 5)
if nmajor > 1:
for cycle in range(nmajor):
prefix = "cycle %d" % (cycle + 1)
residual_imagelist = residual_list_serial_workflow(
vis_list,
deconvolve_model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
deconvolve_model_imagelist = deconvolve_list_serial_workflow(
residual_imagelist,
psf_imagelist,
deconvolve_model_imagelist,
prefix=prefix,
**kwargs)
residual_imagelist = residual_list_serial_workflow(
vis_list,
deconvolve_model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
restore_imagelist = restore_list_serial_workflow(
deconvolve_model_imagelist, psf_imagelist, residual_imagelist)
return (deconvolve_model_imagelist, residual_imagelist, restore_imagelist)
try:
bvt = create_blockvisibility_from_ms(rascil_data_path('vis/sim-2.ms'),
channum=[35, 36, 37, 38, 39])[0]
bvt.configuration.diameter[...] = 35.0
vt = convert_blockvisibility_to_visibility(bvt)
vt = convert_visibility_to_stokes(vt)
cellsize = 20.0 * numpy.pi / (180.0 * 3600.0)
npixel = 512
model = create_image_from_visibility(
vt,
cellsize=cellsize,
npixel=npixel,
polarisation_frame=PolarisationFrame('stokesIQUV'))
dirty, sumwt = invert_list_serial_workflow([vt], [model],
context='2d')[0]
psf, sumwt = invert_list_serial_workflow([vt], [model],
context='2d',
dopsf=True)[0]
export_image_to_fits(
dirty, '%s/compare_imaging_sim2_dirty.fits' % (results_dir))
export_image_to_fits(
psf, '%s/compare_imaging_sim2_psf.fits' % (results_dir))
# Deconvolve using clean
comp, residual = deconvolve_cube(dirty,
psf,
niter=10000,
threshold=0.001,
fractional_threshold=0.001,
window_shape='quarter',
