def test_restored_list_facet(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
psf_image_list = invert_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d', dopsf=True)
residual_image_list = residual_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d')
restored_4facets_image_list = restore_list_rsexecute_workflow(self.model_list, psf_image_list,
residual_image_list,
restore_facets=4, psfwidth=1.0)
restored_4facets_image_list = rsexecute.compute(restored_4facets_image_list, sync=True)
restored_1facets_image_list = restore_list_rsexecute_workflow(self.model_list, psf_image_list,
residual_image_list,
restore_facets=1, psfwidth=1.0)
restored_1facets_image_list = rsexecute.compute(restored_1facets_image_list, sync=True)
if self.persist: export_image_to_fits(restored_4facets_image_list[0],
'%s/test_imaging_invert_%s_restored_4facets.fits' %
(self.dir, rsexecute.type()))
qa = qa_image(restored_4facets_image_list[centre])
assert numpy.abs(qa.data['max'] - 99.43438263927833) < 1e-7, str(qa)
assert numpy.abs(qa.data['min'] + 0.6328915148563354) < 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_%s_restored_4facets_error.fits' %
(self.dir, rsexecute.type()))
qa = qa_image(restored_4facets_image_list[centre])
assert numpy.abs(qa.data['max']) < 1e-10, str(qa)
def test_deconvolve_and_restore_cube_mmclean_facets(self):
self.actualSetUp(add_errors=True)
dirty_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d',
dopsf=False, normalize=True)
psf_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d',
dopsf=True, normalize=True)
dirty_imagelist = rsexecute.persist(dirty_imagelist)
psf_imagelist = rsexecute.persist(psf_imagelist)
dec_imagelist = deconvolve_list_rsexecute_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')
dec_imagelist = rsexecute.persist(dec_imagelist)
residual_imagelist = residual_list_rsexecute_workflow(self.vis_list, model_imagelist=dec_imagelist,
context='2d')
residual_imagelist = rsexecute.persist(residual_imagelist)
restored_list = restore_list_rsexecute_workflow(model_imagelist=dec_imagelist, psf_imagelist=psf_imagelist,
residual_imagelist=residual_imagelist,
empty=self.model_imagelist)
restored = rsexecute.compute(restored_list, sync=True)[0]
if self.persist: export_image_to_fits(restored, '%s/test_imaging_%s_overlap_mmclean_restored.fits'
% (self.dir, rsexecute.type()))
def test_residual_list(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
residual_image_list = residual_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d')
residual_image_list = rsexecute.compute(residual_image_list, sync=True)
qa = qa_image(residual_image_list[centre][0])
assert numpy.abs(qa.data['max'] - 0.35139716991480785) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.7681701460717593) < 1.0, str(qa)
def continuum_imaging_list_rsexecute_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 = [rsexecute.execute(create_pswf_convolutionfunction)(model_imagelist[0])]
psf_imagelist = invert_list_rsexecute_workflow(vis_list, model_imagelist, context=context, dopsf=True,
vis_slices=vis_slices, facets=facets, gcfcf=gcfcf, **kwargs)
residual_imagelist = residual_list_rsexecute_workflow(vis_list, model_imagelist, context=context, gcfcf=gcfcf,
vis_slices=vis_slices, facets=facets, **kwargs)
deconvolve_model_imagelist = deconvolve_list_rsexecute_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_rsexecute_workflow(vis_list, deconvolve_model_imagelist,
context=context, vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf, **kwargs)
deconvolve_model_imagelist = deconvolve_list_rsexecute_workflow(residual_imagelist, psf_imagelist,
deconvolve_model_imagelist,
prefix=prefix,
**kwargs)
residual_imagelist = residual_list_rsexecute_workflow(vis_list, deconvolve_model_imagelist, context=context,
vis_slices=vis_slices, facets=facets, gcfcf=gcfcf, **kwargs)
restore_imagelist = restore_list_rsexecute_workflow(deconvolve_model_imagelist, psf_imagelist, residual_imagelist)
return (deconvolve_model_imagelist, residual_imagelist, restore_imagelist)
def test_residual_list(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
residual_image_list = residual_list_rsexecute_workflow(self.bvis_list,
self.model_list,
context='2d')
residual_image_list = rsexecute.compute(residual_image_list, sync=True)
qa = qa_image(residual_image_list[centre][0])
assert numpy.abs(qa.data['max'] - 0.32584463456508744) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.4559162232699305) < 1.0, str(qa)
def test_sum_invert_list(self):
self.actualSetUp(zerow=True)
residual_image_list = residual_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d')
residual_image_list = rsexecute.compute(residual_image_list, sync=True)
route2 = sum_invert_results(residual_image_list)
route1 = sum_invert_results_rsexecute(residual_image_list)
route1 = rsexecute.compute(route1, sync=True)
for r in route1, route2:
assert len(r) == 2
qa = qa_image(r[0])
assert numpy.abs(qa.data['max'] - 0.35139716991480785) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.7681701460717593) < 1.0, str(qa)
assert numpy.abs(r[1]-415950.0) < 1e-7, str(qa)
def test_sum_invert_list(self):
self.actualSetUp(zerow=True)
residual_image_list = residual_list_rsexecute_workflow(self.bvis_list,
self.model_list,
context='2d')
residual_image_list = rsexecute.compute(residual_image_list, sync=True)
route2 = sum_invert_results(residual_image_list)
route1 = sum_invert_results_rsexecute(residual_image_list)
route1 = rsexecute.compute(route1, sync=True)
for r in route1, route2:
assert len(r) == 2
qa = qa_image(r[0])
assert numpy.abs(qa.data['max'] -
0.15513038832438183) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] +
0.4607090445091728) < 1.0, str(qa)
assert numpy.abs(r[1] - 831900.) < 1e-7, r
def test_restored_list(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
psf_image_list = invert_list_rsexecute_workflow(self.bvis_list,
self.model_list,
context='2d',
dopsf=True)
residual_image_list = residual_list_rsexecute_workflow(self.bvis_list,
self.model_list,
context='2d')
restored_image_list = restore_list_rsexecute_workflow(
self.model_list, psf_image_list, residual_image_list, psfwidth=1.0)
restored_image_list = rsexecute.compute(restored_image_list, sync=True)
self.persist = True
if self.persist:
export_image_to_fits(
restored_image_list[centre],
'%s/test_imaging_invert_%s_restored.fits' %
(self.dir, rsexecute.type()))
qa = qa_image(restored_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)
def ical_list_rsexecute_workflow(vis_list, model_imagelist, context, vis_slices=1, facets=1,
gcfcf=None, calibration_context='TG', do_selfcal=True, **kwargs):
"""Create graph for 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 = [rsexecute.execute(create_pswf_convolutionfunction)(model_imagelist[0])]
psf_imagelist = invert_list_rsexecute_workflow(vis_list, model_imagelist, dopsf=True, context=context,
vis_slices=vis_slices, facets=facets, gcfcf=gcfcf, **kwargs)
model_vislist = [rsexecute.execute(copy_visibility, nout=1)(v, zero=True) for v in vis_list]
if do_selfcal:
cal_vis_list = [rsexecute.execute(copy_visibility, nout=1)(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
predicted_model_vislist = predict_list_rsexecute_workflow(model_vislist, model_imagelist,
context=context, vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf, **kwargs)
recal_vis_list, gt_list = calibrate_list_rsexecute_workflow(cal_vis_list, predicted_model_vislist,
calibration_context=calibration_context, **kwargs)
def zero_model_image(im):
log.info("ical_list_rsexecute_workflow: setting initial mode to zero after initial selfcal")
im.data[...]=0.0
return im
model_imagelist = [rsexecute.execute(zero_model_image, nout=1)(model) for model in model_imagelist]
residual_imagelist = invert_list_rsexecute_workflow(recal_vis_list, model_imagelist, context=context,
vis_slices=vis_slices, facets=facets, gcfcf=gcfcf,
**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_rsexecute_workflow(cal_vis_list, model_imagelist, context=context,
vis_slices=vis_slices, facets=facets, gcfcf=gcfcf,
**kwargs)
deconvolve_model_imagelist = deconvolve_list_rsexecute_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:
predicted_model_vislist = predict_list_rsexecute_workflow(model_vislist, deconvolve_model_imagelist,
context=context, vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf, **kwargs)
recal_vis_list, gt_list = calibrate_list_rsexecute_workflow(cal_vis_list,
predicted_model_vislist,
calibration_context=calibration_context,
iteration=cycle, **kwargs)
residual_vislist = subtract_list_rsexecute_workflow(recal_vis_list, model_vislist)
residual_imagelist = invert_list_rsexecute_workflow(residual_vislist, model_imagelist,
context=context,
vis_slices=vis_slices, facets=facets,
gcfcf=gcfcf, **kwargs)
else:
residual_imagelist = residual_list_rsexecute_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_rsexecute_workflow(residual_imagelist, psf_imagelist,
deconvolve_model_imagelist,
prefix=prefix,
**kwargs)
residual_imagelist = residual_list_rsexecute_workflow(cal_vis_list, deconvolve_model_imagelist, context=context,
vis_slices=vis_slices, facets=facets, gcfcf=gcfcf, **kwargs)
restore_imagelist = restore_list_rsexecute_workflow(deconvolve_model_imagelist, psf_imagelist, residual_imagelist)
return (deconvolve_model_imagelist, residual_imagelist, restore_imagelist, gt_list)
