def test_griddata_invert_wterm(self):
        self.actualSetUp(zerow=False)
        gcf, cf = create_awterm_convolutionfunction(self.model,
                                                    nw=100,
                                                    wstep=8.0,
                                                    oversampling=8,
                                                    support=32,
                                                    use_aaf=True)

        cf_image = convert_convolutionfunction_to_image(cf)
        cf_image.data = numpy.real(cf_image.data)
        if self.persist:
            export_image_to_fits(cf_image,
                                 "%s/test_gridding_wterm_cf.fits" % self.dir)

        griddata = create_griddata_from_image(self.model, nw=1)
        griddata, sumwt = grid_visibility_to_griddata(self.vis,
                                                      griddata=griddata,
                                                      cf=cf)
        im = fft_griddata_to_image(griddata, gcf)
        im = normalize_sumwt(im, sumwt)
        if self.persist:
            export_image_to_fits(
                im, '%s/test_gridding_dirty_wterm.fits' % self.dir)
        self.check_peaks(im, 97.13215242859648)
 def test_griddata_invert_aterm_noover(self):
     self.actualSetUp(zerow=True)
     make_pb = functools.partial(create_pb_generic,
                                 diameter=35.0,
                                 blockage=0.0,
                                 use_local=False)
     pb = make_pb(self.model)
     if self.persist:
         export_image_to_fits(pb,
                              "%s/test_gridding_aterm_pb.fits" % self.dir)
     gcf, cf = create_awterm_convolutionfunction(self.model,
                                                 make_pb=make_pb,
                                                 nw=1,
                                                 oversampling=1,
                                                 support=16,
                                                 use_aaf=True)
     griddata = create_griddata_from_image(self.model)
     griddata, sumwt = grid_visibility_to_griddata(self.vis,
                                                   griddata=griddata,
                                                   cf=cf)
     im = fft_griddata_to_image(griddata, gcf)
     im = normalize_sumwt(im, sumwt)
     if self.persist:
         export_image_to_fits(
             im, '%s/test_gridding_dirty_aterm_noover.fits' % self.dir)
     self.check_peaks(im, 97.10594988491549)
    def test_griddata_invert_awterm(self):
        self.actualSetUp(zerow=False)
        make_pb = functools.partial(create_pb_generic,
                                    diameter=35.0,
                                    blockage=0.0,
                                    use_local=False)
        pb = make_pb(self.model)
        if self.persist:
            export_image_to_fits(pb,
                                 "%s/test_gridding_awterm_pb.fits" % self.dir)
        gcf, cf = create_awterm_convolutionfunction(self.model,
                                                    make_pb=make_pb,
                                                    nw=100,
                                                    wstep=8.0,
                                                    oversampling=16,
                                                    support=32,
                                                    use_aaf=True)
        cf_image = convert_convolutionfunction_to_image(cf)
        cf_image.data = numpy.real(cf_image.data)
        if self.persist:
            export_image_to_fits(cf_image,
                                 "%s/test_gridding_awterm_cf.fits" % self.dir)

        griddata = create_griddata_from_image(self.model, nw=100, wstep=8.0)
        griddata, sumwt = grid_visibility_to_griddata(self.vis,
                                                      griddata=griddata,
                                                      cf=cf)
        im = fft_griddata_to_image(griddata, gcf)
        im = normalize_sumwt(im, sumwt)
        if self.persist:
            export_image_to_fits(
                im, '%s/test_gridding_dirty_awterm.fits' % self.dir)
        self.check_peaks(im, 97.13240677427714)
 def test_griddata_predict_awterm(self):
     self.actualSetUp(zerow=False)
     make_pb = functools.partial(create_pb_generic,
                                 diameter=35.0,
                                 blockage=0.0,
                                 use_local=False)
     pb = make_pb(self.model)
     if self.persist:
         export_image_to_fits(pb,
                              "%s/test_gridding_awterm_pb.fits" % self.dir)
     gcf, cf = create_awterm_convolutionfunction(self.model,
                                                 make_pb=make_pb,
                                                 nw=100,
                                                 wstep=8.0,
                                                 oversampling=16,
                                                 support=32,
                                                 use_aaf=True)
     griddata = create_griddata_from_image(self.model, nw=100, wstep=8.0)
     griddata = fft_image_to_griddata(self.model, griddata, gcf)
     newvis = degrid_visibility_from_griddata(self.vis,
                                              griddata=griddata,
                                              cf=cf)
     qa = qa_visibility(newvis)
     assert qa.data['rms'] < 120.0, str(qa)
     self.plot_vis(newvis, 'awterm')
Ejemplo n.º 5
0
 def test_readwritegriddata(self):
     im = create_test_image()
     gd = create_griddata_from_image(im)
     export_griddata_to_hdf5(gd, '%s/test_data_model_helpers_griddata.hdf' % self.dir)
     newgd = import_griddata_from_hdf5('%s/test_data_model_helpers_griddata.hdf' % self.dir)
 
     assert newgd.data.shape == gd.data.shape
     assert numpy.max(numpy.abs(gd.data - newgd.data)) < 1e-15
 def test_griddata_predict_pswf(self):
     self.actualSetUp(zerow=True)
     gcf, cf = create_pswf_convolutionfunction(self.model, support=6, oversampling=256)
     griddata = create_griddata_from_image(self.model)
     griddata = fft_image_to_griddata(self.model, griddata, gcf)
     newvis = degrid_visibility_from_griddata(self.vis, griddata=griddata, cf=cf)
     newvis.data['vis'][...] -= self.vis.data['vis'][...]
     qa = qa_visibility(newvis)
     assert qa.data['rms'] < 0.7, str(qa)
 def test_griddata_invert_fast(self):
     self.actualSetUp(zerow=True)
     gcf, cf = create_box_convolutionfunction(self.model)
     griddata = create_griddata_from_image(self.model)
     griddata, sumwt = grid_visibility_to_griddata(self.vis, griddata=griddata, cf=cf)
     im = fft_griddata_to_image(griddata, gcf)
     im = normalize_sumwt(im, sumwt)
     export_image_to_fits(im, '%s/test_gridding_dirty_fast.fits' % self.dir)
     self.check_peaks(im, 96.74492791536595, tol=1e-7)
 def test_griddata_predict_box(self):
     self.actualSetUp(zerow=True)
     gcf, cf = create_box_convolutionfunction(self.model)
     griddata = create_griddata_from_image(self.model)
     griddata = fft_image_to_griddata(self.model, griddata, gcf)
     newvis = degrid_visibility_from_griddata(self.vis, griddata=griddata, cf=cf)
     newvis.data['vis'][...] -= self.vis.data['vis'][...]
     qa = qa_visibility(newvis)
     assert qa.data['rms'] < 46.0, str(qa)
 def test_griddata_invert_pswf_w(self):
     self.actualSetUp(zerow=False)
     gcf, cf = create_pswf_convolutionfunction(self.model, support=6, oversampling=32)
     griddata = create_griddata_from_image(self.model)
     griddata, sumwt = grid_visibility_to_griddata(self.vis, griddata=griddata, cf=cf)
     im = fft_griddata_to_image(griddata, gcf)
     im = normalize_sumwt(im, sumwt)
     export_image_to_fits(im, '%s/test_gridding_dirty_pswf_w.fits' % self.dir)
     self.check_peaks(im, 96.62754566597258, tol=1e-7)
Ejemplo n.º 10
0
 def test_griddata_invert_pswf(self):
     self.actualSetUp(zerow=True)
     gcf, cf = create_pswf_convolutionfunction(self.model, support=6, oversampling=32)
     griddata = create_griddata_from_image(self.model)
     griddata, sumwt = grid_visibility_to_griddata(self.vis, griddata=griddata, cf=cf)
     im = fft_griddata_to_image(griddata, gcf)
     im = normalize_sumwt(im, sumwt)
     if self.persist:
         export_image_to_fits(im, '%s/test_gridding_dirty_pswf.fits' % self.dir)
     self.check_peaks(im, 97.00435128311616, tol=1e-7)
Ejemplo n.º 11
0
 def test_griddata_invert_box(self):
     self.actualSetUp(zerow=True)
     gcf, cf = create_box_convolutionfunction(self.model)
     griddata = create_griddata_from_image(self.model)
     griddata, sumwt = grid_visibility_to_griddata(self.vis, griddata=griddata, cf=cf)
     im = fft_griddata_to_image(griddata, gcf)
     im = normalize_sumwt(im, sumwt)
     if self.persist:
         export_image_to_fits(im, '%s/test_gridding_dirty_box.fits' % self.dir)
     self.check_peaks(im, 97.11833094588997, tol=1e-7)
 def test_griddata_predict_wterm(self):
     self.actualSetUp(zerow=False)
     gcf, cf = create_awterm_convolutionfunction(self.model, nw=100, wstep=10.0, oversampling=8, support=30,
                                                 use_aaf=True)
     griddata = create_griddata_from_image(self.model, nw=100, wstep=10.0)
     griddata = fft_image_to_griddata(self.model, griddata, gcf)
     newvis = degrid_visibility_from_griddata(self.vis, griddata=griddata, cf=cf)
     newvis.data['vis'][...] -= self.vis.data['vis'][...]
     qa = qa_visibility(newvis)
     self.plot_vis(newvis, 'wterm')
     assert qa.data['rms'] < 11.0, str(qa)
 def test_griddata_predict_aterm(self):
     self.actualSetUp(zerow=True)
     make_pb = functools.partial(create_pb_generic, diameter=35.0, blockage=0.0)
     griddata = create_griddata_from_image(self.model)
     gcf, cf = create_awterm_convolutionfunction(self.model, make_pb=make_pb, nw=1,
                                                 oversampling=16, support=16,
                                                 use_aaf=True)
     griddata = fft_image_to_griddata(self.model, griddata, gcf)
     newvis = degrid_visibility_from_griddata(self.vis, griddata=griddata, cf=cf)
     qa = qa_visibility(newvis)
     assert qa.data['rms'] < 120.0, str(qa)
Ejemplo n.º 14
0
 def test_griddata_weight(self):
     self.actualSetUp(zerow=True)
     gcf, cf = create_box_convolutionfunction(self.model)
     gd = create_griddata_from_image(self.model)
     gd_list = [grid_weight_to_griddata(self.vis, gd, cf) for i in range(10)]
     gd, sumwt = griddata_merge_weights(gd_list, algorithm='uniform')
     self.vis = griddata_reweight(self.vis, gd, cf)
     gd, sumwt = grid_visibility_to_griddata(self.vis, griddata=gd, cf=cf)
     im = fft_griddata_to_image(gd, gcf)
     im = normalize_sumwt(im, sumwt)
     if self.persist:
         export_image_to_fits(im, '%s/test_gridding_dirty_2d_uniform.fits' % self.dir)
     self.check_peaks(im, 99.42031190701735)
    def test_readwritegriddata(self):
        im = create_test_image()
        gd = create_griddata_from_image(im)
        config = {
            "buffer": {
                "directory": self.dir
            },
            "griddata": {
                "name": "test_buffergriddata.hdf",
                "data_model": "GridData"
            }
        }
        bdm = BufferGridData(config["buffer"], config["griddata"], gd)
        bdm.sync()
        new_bdm = BufferGridData(config["buffer"], config["griddata"])
        new_bdm.sync()
        newgd = bdm.memory_data_model

        assert newgd.data.shape == gd.data.shape
        assert numpy.max(numpy.abs(gd.data - newgd.data)) < 1e-15
def weight_visibility(vis, model, gcfcf=None, weighting='uniform', **kwargs):
    """ Weight the visibility data

    This is done collectively so the weights are summed over all vis_lists and then
    corrected

    :param vis_list:
    :param model_imagelist: Model required to determine weighting parameters
    :param weighting: Type of weighting
    :param kwargs: Parameters for functions in graphs
    :return: List of vis_graphs
   """

    assert isinstance(vis, Visibility), vis

    if gcfcf is None:
        gcfcf = create_pswf_convolutionfunction(model)

    griddata = create_griddata_from_image(model)
    griddata, sumwt = grid_weight_to_griddata(vis, griddata, gcfcf[1])
    vis = griddata_reweight(vis, griddata, gcfcf[1])
    return vis
 def test_convert_griddata_to_image(self):
     m31model_by_image = create_griddata_from_image(self.m31image)
     m31_converted = convert_griddata_to_image(m31model_by_image)
 def test_create_griddata_from_image(self):
     m31model_by_image = create_griddata_from_image(self.m31image)
     assert m31model_by_image.shape[0] == self.m31image.shape[0]
     assert m31model_by_image.shape[1] == self.m31image.shape[1]
     assert m31model_by_image.shape[3] == self.m31image.shape[2]
     assert m31model_by_image.shape[4] == self.m31image.shape[3]