def test_calibrate_rsexecute_repeat(self):
amp_errors = {'T': 0.0, 'G': 0.0}
phase_errors = {'T': 1.0, 'G': 0.0}
self.actualSetUp(amp_errors=amp_errors, phase_errors=phase_errors)
controls = create_calibration_controls()
controls['T']['first_selfcal'] = 0
controls['T']['timeslice'] = 'auto'
calibrate_list = \
calibrate_list_rsexecute_workflow(self.error_blockvis_list, self.blockvis_list,
calibration_context='T', controls=controls, do_selfcal=True,
global_solution=False)
calibrate_list = rsexecute.compute(calibrate_list, sync=True)
assert len(calibrate_list) == 2
assert numpy.max(calibrate_list[1][0]['T'].residual) < 7e-6, numpy.max(calibrate_list[1][0]['T'].residual)
err = numpy.max(numpy.abs(calibrate_list[0][0].flagged_vis - self.blockvis_list[0].flagged_vis))
assert err < 2e-6, err
calibrate_list = \
calibrate_list_rsexecute_workflow(self.error_blockvis_list, self.blockvis_list,
gt_list=calibrate_list[1],
calibration_context='T', controls=controls, do_selfcal=True,
global_solution=False)
calibrate_list = rsexecute.compute(calibrate_list, sync=True)
assert len(calibrate_list) == 2
assert numpy.max(calibrate_list[1][0]['T'].residual) < 7e-6, numpy.max(calibrate_list[1][0]['T'].residual)
err = numpy.max(numpy.abs(calibrate_list[0][0].flagged_vis - self.blockvis_list[0].flagged_vis))
assert err < 2e-6, err
def test_calibrate_rsexecute_empty(self):
amp_errors = {'T': 0.0, 'G': 0.0}
phase_errors = {'T': 1.0, 'G': 0.0}
self.actualSetUp(amp_errors=amp_errors, phase_errors=phase_errors)
for v in self.blockvis_list:
v.data['vis'][...] = 0.0 + 0.0j
controls = create_calibration_controls()
controls['T']['first_selfcal'] = 0
controls['T']['timeslice'] = 'auto'
calibrate_list = \
calibrate_list_rsexecute_workflow(self.error_blockvis_list, self.blockvis_list,
calibration_context='T', controls=controls, do_selfcal=True,
global_solution=False)
calibrate_list = rsexecute.compute(calibrate_list, sync=True)
assert len(calibrate_list[1][0]) > 0
def mpccal_skymodel_list_rsexecute_workflow(visobs, model, theta_list, nmajor=10, context='2d',
mpccal_progress=None, **kwargs):
"""Run MPC pipeline
This runs the Model Partition Calibration algorithm. See SDP Memo 97 for more details,
and see workflows/scripts/pipelines/mpccal_rsexecute_pipeline.py for an example of the application
:param visobs: Visibility (not a list!)
:param model: Model image
:param theta_list: List of SkyModels i.e. theta in memo 97.
:param nmajor: Number of major cycles
:param context: Imaging context
:param mpccal_progress: Function to display progress
:return: Delayed tuple (theta_list, residual)
"""
psf_obs = invert_list_rsexecute_workflow([visobs], [model], context=context, dopsf=True)
result = rsexecute.execute((theta_list, model))
for iteration in range(nmajor):
# The E step of decoupling the data models
vdatamodel_list = predict_skymodel_list_rsexecute_workflow(visobs, theta_list, context=context,
docal=True, **kwargs)
vdatamodel_list = crosssubtract_datamodels_skymodel_list_rsexecute_workflow(visobs, vdatamodel_list)
# The M step: 1 - Update the models by deconvolving the residual image. The residual image must be calculated
# from a difference of the dirty images from the data model, and the dirty images
dirty_all_conv = convolve_skymodel_list_rsexecute_workflow(visobs, theta_list, context=context,
docal=True, **kwargs)
dirty_all_cal = invert_skymodel_list_rsexecute_workflow(vdatamodel_list, theta_list, context=context,
docal=True, **kwargs)
def diff_dirty(dcal, dconv):
assert numpy.max(numpy.abs(dcal[0].data)) > 0.0, "before: dcal subimage is zero"
dcal[0].data -= dconv[0].data
assert numpy.max(numpy.abs(dcal[0].data)) > 0.0, "after: dcal subimage is zero"
return dcal
dirty_all_cal = [rsexecute.execute(diff_dirty, nout=1)(dirty_all_cal[i], dirty_all_conv[i])
for i in range(len(dirty_all_cal))]
def make_residual(dcal, tl, it):
res = create_empty_image_like(dcal[0][0])
for i, d in enumerate(dcal):
assert numpy.max(numpy.abs(d[0].data)) > 0.0, "Residual subimage is zero"
if tl[i].mask is None:
res.data += d[0].data
else:
assert numpy.max(numpy.abs(tl[i].mask.data)) > 0.0, "Mask image is zero"
res.data += d[0].data * tl[i].mask.data
assert numpy.max(numpy.abs(res.data)) > 0.0, "Residual image is zero"
# import matplotlib.pyplot as plt
# from rascil.processing_components.image import show_image
# show_image(res, title='MPCCAL residual image, iteration %d' % it)
# plt.show()
return res
residual = rsexecute.execute(make_residual, nout=1)(dirty_all_cal, theta_list, iteration)
deconvolved = deconvolve_list_rsexecute_workflow([(residual, 1.0)], [psf_obs[0]],
[model], **kwargs)
# The M step: 2 - Update the gaintables
vpredicted_list = predict_skymodel_list_rsexecute_workflow(visobs, theta_list, context=context,
docal=True, **kwargs)
vcalibrated_list, gaintable_list = calibrate_list_rsexecute_workflow(vdatamodel_list, vpredicted_list,
calibration_context='T',
iteration=iteration, global_solution=False,
**kwargs)
if mpccal_progress is not None:
theta_list = rsexecute.execute(mpccal_progress, nout=len(theta_list))(residual, theta_list,
gaintable_list, iteration)
theta_list = \
rsexecute.execute(update_skymodel_from_image, nout=len(theta_list))(theta_list, deconvolved[0])
theta_list = rsexecute.execute(update_skymodel_from_gaintables, nout=len(theta_list))(theta_list,
gaintable_list,
calibration_context='T')
result = rsexecute.execute((theta_list, residual))
return result
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)
