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)