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_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_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_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.10594988491546, tol=1e-7)
def test_griddata_invert_pswf_w(self): self.actualSetUp(zerow=False) gcf, cf = create_pswf_convolutionfunction(self.model) griddata = create_griddata_from_image(self.model, self.vis) griddata, sumwt = grid_visibility_to_griddata(self.vis, griddata=griddata, cf=cf) cim = fft_griddata_to_image(griddata, gcf) cim = normalize_sumwt(cim, sumwt) im = convert_polimage_to_stokes(cim) if self.persist: export_image_to_fits( im, '%s/test_gridding_dirty_pswf_w.fits' % self.dir) self.check_peaks(im, 97.13240718331633, tol=1e-7)
def test_griddata_invert_pswf_stokesIQ(self): self.actualSetUp(zerow=True, image_pol=PolarisationFrame("stokesIQ")) gcf, cf = create_pswf_convolutionfunction(self.model) griddata = create_griddata_from_image(self.model, self.vis) griddata, sumwt = grid_visibility_to_griddata(self.vis, griddata=griddata, cf=cf) cim = fft_griddata_to_image(griddata, gcf) cim = normalize_sumwt(cim, sumwt) im = convert_polimage_to_stokes(cim) if self.persist: export_image_to_fits(im, '%s/test_gridding_dirty_pswf.fits' % self.dir) self.check_peaks(im, 97.10594988491545, tol=1e-7)
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) if self.persist: export_image_to_fits( im, '%s/test_gridding_dirty_pswf_w.fits' % self.dir) self.check_peaks(im, 97.01838776845877, tol=1e-7)
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.40822097133994)
def test_griddata_visibility_weight_IQ(self): self.actualSetUp(zerow=True, image_pol=PolarisationFrame("stokesIQUV")) gcf, cf = create_pswf_convolutionfunction(self.model) gd = create_griddata_from_image(self.model, self.vis) gd_list = [ grid_visibility_weight_to_griddata(self.vis, gd, cf) for i in range(10) ] gd, sumwt = griddata_merge_weights(gd_list, algorithm='uniform') self.vis = griddata_visibility_reweight(self.vis, gd, cf) gd, sumwt = grid_visibility_to_griddata(self.vis, griddata=gd, cf=cf) cim = fft_griddata_to_image(gd, gcf) cim = normalize_sumwt(cim, sumwt) im = convert_polimage_to_stokes(cim) if self.persist: export_image_to_fits( im, '%s/test_gridding_dirty_2d_IQ_uniform.fits' % self.dir) self.check_peaks(im, 99.40822097133994)
def test_griddata_blockvisibility_weight(self): self.actualSetUp(zerow=True, block=True, image_pol=PolarisationFrame("stokesIQUV")) gcf, cf = create_pswf_convolutionfunction(self.model) gd = create_griddata_from_image(self.model, self.vis) gd_list = [ grid_blockvisibility_weight_to_griddata(self.vis, gd, cf) for i in range(10) ] assert numpy.max(numpy.abs(gd_list[0][0].data)) > 10.0 gd, sumwt = griddata_merge_weights(gd_list, algorithm='uniform') self.vis = griddata_blockvisibility_reweight(self.vis, gd, cf) gd, sumwt = grid_blockvisibility_to_griddata(self.vis, griddata=gd, cf=cf) cim = fft_griddata_to_image(gd, gcf) cim = normalize_sumwt(cim, sumwt) im = convert_polimage_to_stokes(cim) if self.persist: export_image_to_fits( im, '%s/test_gridding_dirty_2d_uniform_block.fits' % self.dir) self.check_peaks(im, 100.13540418821904)
def invert_ng(bvis: BlockVisibility, model: Image, dopsf: bool = False, normalize: bool = True, **kwargs) -> (Image, numpy.ndarray): """ Invert using nifty-gridder module https://gitlab.mpcdf.mpg.de/ift/nifty_gridder Use the image im as a template. Do PSF in a separate call. In the imaging and pipeline workflows, this may be invoked using context='ng'. :param dopsf: Make the PSF instead of the dirty image :param bvis: BlockVisibility to be inverted :param im: image template (not changed) :param normalize: Normalize by the sum of weights (True) :return: (resulting image, sum of the weights for each frequency and polarization) """ assert image_is_canonical(model) assert isinstance(bvis, BlockVisibility), bvis im = copy_image(model) nthreads = get_parameter(kwargs, "threads", 4) epsilon = get_parameter(kwargs, "epsilon", 1e-12) do_wstacking = get_parameter(kwargs, "do_wstacking", True) verbosity = get_parameter(kwargs, "verbosity", 0) sbvis = copy_visibility(bvis) sbvis = shift_vis_to_image(sbvis, im, tangent=True, inverse=False) freq = sbvis.frequency # frequency, Hz nrows, nants, _, vnchan, vnpol = sbvis.vis.shape # if dopsf: # sbvis = fill_vis_for_psf(sbvis) ms = sbvis.vis.reshape([nrows * nants * nants, vnchan, vnpol]) ms = convert_pol_frame(ms, bvis.polarisation_frame, im.polarisation_frame, polaxis=2) uvw = sbvis.uvw.reshape([nrows * nants * nants, 3]) wgt = sbvis.flagged_imaging_weight.reshape( [nrows * nants * nants, vnchan, vnpol]) if epsilon > 5.0e-6: ms = ms.astype("c8") wgt = wgt.astype("f4") # Find out the image size/resolution npixdirty = im.nwidth pixsize = numpy.abs(numpy.radians(im.wcs.wcs.cdelt[0])) fuvw = uvw.copy() # We need to flip the u and w axes. fuvw[:, 0] *= -1.0 fuvw[:, 2] *= -1.0 nchan, npol, ny, nx = im.shape im.data[...] = 0.0 sumwt = numpy.zeros([nchan, npol]) # There's a latent problem here with the weights. # wgt = numpy.real(convert_pol_frame(wgt, bvis.polarisation_frame, im.polarisation_frame, polaxis=2)) # Set up the conversion from visibility channels to image channels vis_to_im = numpy.round(model.wcs.sub([4]).wcs_world2pix( freq, 0)[0]).astype('int') # Nifty gridder likes to receive contiguous arrays so we transpose # at the beginning mfs = nchan == 1 if dopsf: mst = ms.T mst[...] = 0.0 mst[0, ...] = 1.0 wgtt = wgt.T if mfs: dirty = ng.ms2dirty(fuvw.astype(numpy.float64), bvis.frequency.astype(numpy.float64), numpy.ascontiguousarray(mst[0, :, :].T), numpy.ascontiguousarray(wgtt[0, :, :].T), npixdirty, npixdirty, pixsize, pixsize, epsilon, do_wstacking=do_wstacking, nthreads=nthreads, verbosity=verbosity) sumwt[0, :] += numpy.sum(wgtt[0, 0, :].T, axis=0) im.data[0, :] += dirty.T else: for vchan in range(vnchan): ichan = vis_to_im[vchan] frequency = numpy.array(freq[vchan:vchan + 1]).astype( numpy.float64) dirty = ng.ms2dirty( fuvw.astype(numpy.float64), frequency.astype(numpy.float64), numpy.ascontiguousarray(mst[0, vchan, :][..., numpy.newaxis]), numpy.ascontiguousarray(wgtt[0, vchan, :][..., numpy.newaxis]), npixdirty, npixdirty, pixsize, pixsize, epsilon, do_wstacking=do_wstacking, nthreads=nthreads, verbosity=verbosity) sumwt[ichan, :] += numpy.sum(wgtt[0, ichan, :].T, axis=0) im.data[ichan, :] += dirty.T else: mst = ms.T wgtt = wgt.T for pol in range(npol): if mfs: dirty = ng.ms2dirty( fuvw.astype(numpy.float64), bvis.frequency.astype(numpy.float64), numpy.ascontiguousarray(mst[pol, :, :].T), numpy.ascontiguousarray(wgtt[pol, :, :].T), npixdirty, npixdirty, pixsize, pixsize, epsilon, do_wstacking=do_wstacking, nthreads=nthreads, verbosity=verbosity) sumwt[0, pol] += numpy.sum(wgtt[pol, 0, :].T, axis=0) im.data[0, pol] += dirty.T else: for vchan in range(vnchan): ichan = vis_to_im[vchan] frequency = numpy.array(freq[vchan:vchan + 1]).astype( numpy.float64) dirty = ng.ms2dirty(fuvw.astype(numpy.float64), frequency.astype(numpy.float64), numpy.ascontiguousarray( mst[pol, vchan, :][..., numpy.newaxis]), numpy.ascontiguousarray( wgtt[pol, vchan, :][..., numpy.newaxis]), npixdirty, npixdirty, pixsize, pixsize, epsilon, do_wstacking=do_wstacking, nthreads=nthreads, verbosity=verbosity) sumwt[ichan, pol] += numpy.sum(wgtt[pol, ichan, :].T, axis=0) im.data[ichan, pol] += dirty.T if normalize: im = normalize_sumwt(im, sumwt) return im, sumwt
def invert_ng(bvis: BlockVisibility, model: Image, dopsf: bool = False, normalize: bool = True, **kwargs) -> (Image, numpy.ndarray): """ Invert using nifty-gridder module https://gitlab.mpcdf.mpg.de/ift/nifty_gridder Use the image im as a template. Do PSF in a separate call. This is at the bottom of the layering i.e. all transforms are eventually expressed in terms of this function. . Any shifting needed is performed here. :param bvis: BlockVisibility to be inverted :param im: image template (not changed) :param normalize: Normalize by the sum of weights (True) :return: (resulting image, sum of the weights for each frequency and polarization) """ assert image_is_canonical(model) assert isinstance(bvis, BlockVisibility), bvis im = copy_image(model) nthreads = get_parameter(kwargs, "threads", 4) epsilon = get_parameter(kwargs, "epsilon", 1e-12) do_wstacking = get_parameter(kwargs, "do_wstacking", True) verbosity = get_parameter(kwargs, "verbosity", 0) sbvis = copy_visibility(bvis) sbvis = shift_vis_to_image(sbvis, im, tangent=True, inverse=False) vis = bvis.vis freq = sbvis.frequency # frequency, Hz nrows, nants, _, vnchan, vnpol = vis.shape uvw = sbvis.uvw.reshape([nrows * nants * nants, 3]) ms = vis.reshape([nrows * nants * nants, vnchan, vnpol]) wgt = sbvis.imaging_weight.reshape( [nrows * nants * nants, vnchan, vnpol]) if dopsf: ms[...] = 1.0 + 0.0j if epsilon > 5.0e-6: ms = ms.astype("c8") wgt = wgt.astype("f4") # Find out the image size/resolution npixdirty = im.nwidth pixsize = numpy.abs(numpy.radians(im.wcs.wcs.cdelt[0])) fuvw = uvw.copy() # We need to flip the u and w axes. fuvw[:, 0] *= -1.0 fuvw[:, 2] *= -1.0 nchan, npol, ny, nx = im.shape im.data[...] = 0.0 sumwt = numpy.zeros([nchan, npol]) ms = convert_pol_frame(ms, bvis.polarisation_frame, im.polarisation_frame, polaxis=2) # There's a latent problem here with the weights. # wgt = numpy.real(convert_pol_frame(wgt, bvis.polarisation_frame, im.polarisation_frame, polaxis=2)) # Set up the conversion from visibility channels to image channels vis_to_im = numpy.round(model.wcs.sub([4]).wcs_world2pix( freq, 0)[0]).astype('int') for vchan in range(vnchan): ichan = vis_to_im[vchan] for pol in range(npol): # Nifty gridder likes to receive contiguous arrays ms_1d = numpy.array([ ms[row, vchan:vchan + 1, pol] for row in range(nrows * nants * nants) ], dtype='complex') ms_1d.reshape([ms_1d.shape[0], 1]) wgt_1d = numpy.array([ wgt[row, vchan:vchan + 1, pol] for row in range(nrows * nants * nants) ]) wgt_1d.reshape([wgt_1d.shape[0], 1]) dirty = ng.ms2dirty(fuvw, freq[vchan:vchan + 1], ms_1d, wgt_1d, npixdirty, npixdirty, pixsize, pixsize, epsilon, do_wstacking=do_wstacking, nthreads=nthreads, verbosity=verbosity) sumwt[ichan, pol] += numpy.sum(wgt[:, vchan, pol]) im.data[ichan, pol] += dirty.T if normalize: im = normalize_sumwt(im, sumwt) return im, sumwt