Esempio n. 1
0
 def test_predict_wprojection_graph(self):
     flux_model_graph = delayed(self.get_LSM)(self.vis_graph_list[self.nvis // 2], flux=100.0)
     zero_vis_graph_list = create_zero_vis_graph_list(self.vis_graph_list)
     predicted_vis_graph_list = create_predict_graph(zero_vis_graph_list, flux_model_graph, wstep=4.0,
                                                     kernel='wprojection')
     residual_vis_graph_list = create_subtract_vis_graph_list(self.vis_graph_list, predicted_vis_graph_list)
     if self.compute:
         qa = qa_visibility(self.vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1600.0, 0)
         qa = qa_visibility(predicted_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 111.8, 0)
         qa = qa_visibility(residual_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1644.3, 0)
Esempio n. 2
0
 def test_predict_wstack_graph_wprojection(self):
     flux_model_graph = delayed(self.get_LSM)(self.vis_graph_list[self.nvis // 2], flux=100.0)
     zero_vis_graph_list = create_zero_vis_graph_list(self.vis_graph_list)
     predicted_vis_graph_list = create_predict_wstack_graph(zero_vis_graph_list, flux_model_graph,
                                                            vis_slices=11, wstep=10.0, kernel='wprojection')
     residual_vis_graph_list = create_subtract_vis_graph_list(self.vis_graph_list, predicted_vis_graph_list)
     if self.compute:
         qa = qa_visibility(self.vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1600.0, 0)
         qa = qa_visibility(predicted_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 100.064844507, 0)
         qa = qa_visibility(residual_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1668.3018405354974, 0)
Esempio n. 3
0
 def test_predict_facet_wstack_graph(self):
     flux_model_graph = delayed(self.get_LSM)(self.vis_graph_list[self.nvis // 2], flux=100.0)
     zero_vis_graph_list = create_zero_vis_graph_list(self.vis_graph_list)
     predicted_vis_graph_list = create_predict_facet_wstack_graph(zero_vis_graph_list, flux_model_graph,
                                                                  facets=2, vis_slices=self.vis_slices)
     residual_vis_graph_list = create_subtract_vis_graph_list(self.vis_graph_list, predicted_vis_graph_list)
     if self.compute:
         qa = qa_visibility(self.vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1600.0, 0)
         qa = qa_visibility(predicted_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 100.064844507, 0)
         qa = qa_visibility(residual_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1643.1, 0)
Esempio n. 4
0
 def test_predict_timeslice_graph(self):
     flux_model_graph = delayed(self.get_LSM)(self.vis_graph_list[self.nvis // 2], flux=100.0)
     zero_vis_graph_list = create_zero_vis_graph_list(self.vis_graph_list)
     predicted_vis_graph_list = create_predict_timeslice_graph(zero_vis_graph_list, flux_model_graph,
                                                            vis_slices=3)
     residual_vis_graph_list = create_subtract_vis_graph_list(self.vis_graph_list, predicted_vis_graph_list)
     if self.compute:
         qa = qa_visibility(self.vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1600.0, 0)
         qa = qa_visibility(predicted_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 152.1, 0)
         qa = qa_visibility(residual_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1749.2, 0)
Esempio n. 5
0
 def test_predict_facet_timeslice_graph_wprojection(self):
     flux_model_graph = delayed(self.get_LSM)(self.vis_graph_list[self.nvis // 2], flux=100.0)
     zero_vis_graph_list = create_zero_vis_graph_list(self.vis_graph_list)
     predicted_vis_graph_list = create_predict_facet_timeslice_graph(zero_vis_graph_list, flux_model_graph,
                                                            vis_slices=3, facets=2,
                                                                     wstep=4.0, kernel='wprojection')
     simple_vis(predicted_vis_graph_list[0], filename='predict_facet_timeslice_graph_wprojection', format='png')
     residual_vis_graph_list = create_subtract_vis_graph_list(self.vis_graph_list, predicted_vis_graph_list)
     if self.compute:
         qa = qa_visibility(self.vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1600.0, 0)
         qa = qa_visibility(predicted_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 94.2, 0)
         qa = qa_visibility(residual_vis_graph_list[0].compute())
         numpy.testing.assert_almost_equal(qa.data['maxabs'], 1656.6, 0)
Esempio n. 6
0
def create_ical_pipeline_graph(vis_graph_list,
                               model_graph: delayed,
                               c_deconvolve_graph=create_deconvolve_graph,
                               c_invert_graph=create_invert_graph,
                               c_residual_graph=create_residual_graph,
                               c_predict_graph=create_predict_graph,
                               c_calibrate_graph=create_calibrate_graph_list,
                               first_selfcal=None,
                               **kwargs) -> delayed:
    """Create graph for ICAL pipeline
    
    :param vis_graph_list:
    :param model_graph:
    :param c_deconvolve_graph: Default: create_deconvolve_graph
    :param c_invert_graph: Default: create_invert_graph,
    :param c_residual_graph: Default: Default: create_residual_graph
    :param kwargs: Parameters for functions in graphs
    :return:
    """
    psf_graph = c_invert_graph(vis_graph_list,
                               model_graph,
                               dopsf=True,
                               **kwargs)

    if first_selfcal is not None and first_selfcal == 0:
        # Make the predicted visibilities, selfcalibrate against it correcting the gains, then
        # form the residual visibility, then make the residual image
        model_vis_graph_list = create_zero_vis_graph_list(vis_graph_list)
        model_vis_graph_list = c_predict_graph(model_vis_graph_list,
                                               model_graph, **kwargs)
        vis_graph_list = c_calibrate_graph(vis_graph_list,
                                           model_vis_graph_list, **kwargs)
        residual_vis_graph_list = create_subtract_vis_graph_list(
            vis_graph_list, model_vis_graph_list)
        residual_graph = c_invert_graph(residual_vis_graph_list,
                                        model_graph,
                                        dopsf=True,
                                        **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_graph = c_residual_graph(vis_graph_list, model_graph,
                                          **kwargs)

    deconvolve_model_graph = c_deconvolve_graph(residual_graph, psf_graph,
                                                model_graph, **kwargs)

    nmajor = get_parameter(kwargs, "nmajor", 5)
    if nmajor > 1:
        for cycle in range(nmajor):
            if first_selfcal is not None and cycle >= first_selfcal:
                model_vis_graph_list = create_zero_vis_graph_list(
                    vis_graph_list)
                model_vis_graph_list = c_predict_graph(model_vis_graph_list,
                                                       deconvolve_model_graph,
                                                       **kwargs)
                vis_graph_list = c_calibrate_graph(vis_graph_list,
                                                   model_vis_graph_list,
                                                   **kwargs)
                residual_vis_graph_list = create_subtract_vis_graph_list(
                    vis_graph_list, model_vis_graph_list)
                residual_graph = c_invert_graph(residual_vis_graph_list,
                                                model_graph,
                                                dopsf=False,
                                                **kwargs)
            else:
                residual_graph = c_residual_graph(vis_graph_list,
                                                  deconvolve_model_graph,
                                                  **kwargs)

            deconvolve_model_graph = c_deconvolve_graph(
                residual_graph, psf_graph, deconvolve_model_graph, **kwargs)
    residual_graph = c_residual_graph(vis_graph_list, deconvolve_model_graph,
                                      **kwargs)

    restore_graph = delayed(restore_cube, pure=True,
                            nout=1)(deconvolve_model_graph, psf_graph[0],
                                    residual_graph[0], **kwargs)
    return delayed((deconvolve_model_graph, residual_graph, restore_graph))