def _invert_base(self,
fluxthreshold=1.0,
positionthreshold=1.0,
check_components=True,
name='predict_ng',
**kwargs):
# dirty = invert_ng(self.blockvis, self.model, dopsf=False, normalize=True, **kwargs)
from processing_components.imaging.ng import predict_ng, invert_ng
dirty = invert_ng(self.blockvis,
self.model,
normalize=True,
verbosity=self.verbosity,
**kwargs)
if self.persist:
export_image_to_fits(
dirty[0],
'%s/test_imaging_ng_%s_dirty.fits' % (self.dir, name))
# import matplotlib.pyplot as plt
# from processing_components.image.operations import show_image
# npol = dirty[0].shape[1]
# for pol in range(npol):
# plt.clf()
# show_image(dirty[0], pol=pol)
# plt.show(block=False)
assert numpy.max(numpy.abs(dirty[0].data)), "Image is empty"
if check_components:
self._checkcomponents(dirty[0], fluxthreshold, positionthreshold)
def test_deconvolve_spectral(self):
self.actualSetUp(add_errors=True)
dirty_imagelist = invert_workflow(self.vis_list,
self.model_imagelist,
context='2d',
dopsf=False,
normalize=True)
psf_imagelist = invert_workflow(self.vis_list,
self.model_imagelist,
context='2d',
dopsf=True,
normalize=True)
deconvolved, _ = deconvolve_workflow(dirty_imagelist,
psf_imagelist,
self.model_imagelist,
niter=1000,
fractional_threshold=0.1,
scales=[0, 3, 10],
threshold=0.1,
gain=0.7)
deconvolved = arlexecute.compute(deconvolved, sync=True)
export_image_to_fits(
deconvolved[0], '%s/test_imaging_%s_deconvolve_spectral.fits' %
(self.dir, arlexecute.type()))
def _invert_base(self,
context,
extra='',
fluxthreshold=1.0,
positionthreshold=1.0,
check_components=True,
facets=1,
vis_slices=1,
**kwargs):
dirty = invert_serial(self.vis,
self.model,
context=context,
dopsf=False,
normalize=True,
facets=facets,
vis_slices=vis_slices,
**kwargs)
export_image_to_fits(
dirty[0], '%s/test_imaging_invert_%s%s_dirty.fits' %
(self.dir, context, extra))
assert numpy.max(numpy.abs(dirty[0].data)), "Image is empty"
if check_components:
self._checkcomponents(dirty[0], fluxthreshold, positionthreshold)
def _predict_base(self, fluxthreshold=1.0, name='predict_ng', **kwargs):
from processing_components.imaging.ng import predict_ng, invert_ng
original_vis = copy_visibility(self.blockvis)
vis = predict_ng(self.blockvis,
self.model,
verbosity=self.verbosity,
**kwargs)
vis.data['vis'] = vis.data['vis'] - original_vis.data['vis']
dirty = invert_ng(vis,
self.model,
dopsf=False,
normalize=True,
verbosity=self.verbosity,
**kwargs)
# import matplotlib.pyplot as plt
# from processing_components.image.operations import show_image
# npol = dirty[0].shape[1]
# for pol in range(npol):
# plt.clf()
# show_image(dirty[0], pol=pol)
# plt.show(block=False)
if self.persist:
export_image_to_fits(
dirty[0],
'%s/test_imaging_ng_%s_residual.fits' % (self.dir, name))
# assert numpy.max(numpy.abs(dirty[0].data)), "Residual image is empty"
maxabs = numpy.max(numpy.abs(dirty[0].data))
assert maxabs < fluxthreshold, "Error %.3f greater than fluxthreshold %.3f " % (
maxabs, fluxthreshold)
def test_w_kernel_list(self):
oversampling = 2
kernelwidth = 32
kernel_indices, kernels = w_kernel_list(self.vis,
self.model,
kernelwidth=kernelwidth,
wstep=50,
oversampling=oversampling)
assert numpy.max(numpy.abs(kernels[0].data)) > 0.0
assert len(kernel_indices) > 0
assert max(kernel_indices) == len(kernels) - 1
assert isinstance(kernels[0], numpy.ndarray)
assert len(kernels[0].shape) == 4
assert kernels[0].shape == (oversampling, oversampling, kernelwidth, kernelwidth), \
"Actual shape is %s" % str(kernels[0].shape)
kernel0 = create_image_from_array(
kernels[0],
self.model.wcs,
polarisation_frame=PolarisationFrame('stokesI'))
kernel0.data = kernel0.data.real
export_image_to_fits(kernel0,
"%s/test_w_kernel_list_kernel0.fits" % (self.dir))
with self.assertRaises(AssertionError):
kernel_indices, kernels = w_kernel_list(self.vis,
self.model,
kernelwidth=32,
wstep=50,
oversampling=3,
maxsupport=128)
def _predict_base(self,
context='2d',
extra='',
fluxthreshold=1.0,
facets=1,
vis_slices=1,
**kwargs):
vis = copy_visibility(self.vis)
vis.data['vis'][...] = 0
vis = predict_serial(vis,
self.model,
context=context,
vis_slices=vis_slices,
facets=facets,
**kwargs)
vis.data['vis'][...] -= self.vis.data['vis'][...]
dirty = invert_serial(vis,
self.model,
context='2d',
dopsf=False,
normalize=True)
assert numpy.max(numpy.abs(dirty[0].data)), "Residual image is empty"
export_image_to_fits(
dirty[0], '%s/test_imaging_predict_%s%s_dirty.fits' %
(self.dir, context, extra))
maxabs = numpy.max(numpy.abs(dirty[0].data))
assert maxabs < fluxthreshold, "Error %.3f greater than fluxthreshold %.3f " % (
maxabs, fluxthreshold)
def moments_save_to_disk(moments_im, stokes_type='q', results_dir='./results_dir', outname='mean'):
"""Save the Faraday moments images to disk.
Args:
rmsynth (numpy array): array of complex numbers from RM Synthesis.
cellsize (float): advised cellsize in Faraday space.
maxrm_est (float): maximum observable RM (50 percent sensitivity).
rmtype (str): the component of the complex numbers to process and save.
results_dir (str): directory to save results.
outname (str): outname for saved file.
Returns:
None
"""
# Read in the first channel image, and appropriate it as the new moments image:
im_moments = import_image_from_fits('%s/imaging_clean_WStack-%s.fits' % (results_dir, 0))
# Place the data into the open image:
im_moments.data = moments_im
try:
if stokes_type == 'p':
stokes_val = 0.0
elif stokes_type == 'q':
stokes_val = 2.0
elif stokes_type == 'u':
stokes_val = 3.0
except:
print("Unknown value for stokes_type:", sys.exc_info()[0])
raise
# This line also adjusts the listed Stokes parameter (use 0.0=? for P):
im_moments.wcs.wcs.crval = [im_moments.wcs.wcs.crval[0], im_moments.wcs.wcs.crval[1],
stokes_val, im_moments.wcs.wcs.crval[3]]
# Output the file to disk:
export_image_to_fits(im_moments, '%s/%s_%s.fits' % (results_dir, outname, stokes_type))
return
def test_create_voltage_patterns_zernike(self):
self.createVis(freq=1.4e9)
cellsize = 8 * numpy.pi / 180.0 / 280
model = create_image_from_visibility(self.vis,
npixel=512,
cellsize=cellsize,
override_cellsize=False)
plt.clf()
fig, axs = plt.subplots(7, 7, gridspec_kw={'hspace': 0, 'wspace': 0})
for noll in range(1, 50):
zernikes = [{'coeff': 1.0, 'noll': noll}]
vp = create_vp_generic_numeric(model,
pointingcentre=None,
diameter=15.0,
blockage=0.0,
taper='gaussian',
edge=0.03162278,
zernikes=zernikes,
padding=2,
use_local=True)
vp_data = vp.data
vp.data = numpy.real(vp_data)
export_image_to_fits(
vp, "%s/test_voltage_pattern_real_%s_NOLL%d.fits" %
(self.dir, 'MID_ZERNIKES', noll))
row = (noll - 1) // 7
col = (noll - 1) - 7 * row
ax = axs[row, col]
ax.imshow(vp.data[0, 0], vmax=0.1, vmin=-0.01)
#ax.set_title('Noll %d' % noll)
ax.axis('off')
plt.savefig("zernikes.png")
plt.show()
def test_scatter_gather_facet_overlap_taper(self):
m31original = create_test_image(polarisation_frame=PolarisationFrame('stokesI'))
assert numpy.max(numpy.abs(m31original.data)), "Original is empty"
for taper in ['linear', None]:
for nraster, overlap in [(1, 0), (4, 8), (8, 8), (8, 16)]:
m31model = create_test_image(polarisation_frame=PolarisationFrame('stokesI'))
image_list = image_scatter_facets(m31model, facets=nraster, overlap=overlap, taper=taper)
for patch in image_list:
assert patch.data.shape[3] == (2 * overlap + m31model.data.shape[3] // nraster), \
"Number of pixels in each patch: %d not as expected: %d" % (patch.data.shape[3],
(2 * overlap + m31model.data.shape[3] //
nraster))
assert patch.data.shape[2] == (2 * overlap + m31model.data.shape[2] // nraster), \
"Number of pixels in each patch: %d not as expected: %d" % (patch.data.shape[2],
(2 * overlap + m31model.data.shape[2] //
nraster))
m31reconstructed = create_empty_image_like(m31model)
m31reconstructed = image_gather_facets(image_list, m31reconstructed, facets=nraster, overlap=overlap,
taper=taper)
flat = image_gather_facets(image_list, m31reconstructed, facets=nraster, overlap=overlap,
taper=taper, return_flat=True)
export_image_to_fits(m31reconstructed,
"%s/test_image_gather_scatter_%dnraster_%doverlap_%s_reconstructed.fits" %
(self.dir, nraster, overlap, taper))
export_image_to_fits(flat,
"%s/test_image_gather_scatter_%dnraster_%doverlap_%s_flat.fits" %
(self.dir, nraster, overlap, taper))
assert numpy.max(numpy.abs(flat.data)), "Flat is empty for %d" % nraster
assert numpy.max(numpy.abs(m31reconstructed.data)), "Raster is empty for %d" % nraster
def test_calculate_image_frequency_moments(self):
frequency = numpy.linspace(0.9e8, 1.1e8, 9)
cube = create_low_test_image_from_gleam(npixel=512,
cellsize=0.0001,
frequency=frequency,
flux_limit=1.0)
log.debug(
export_image_to_fits(cube,
fitsfile='%s/test_moments_cube.fits' %
(self.dir)))
original_cube = copy_image(cube)
moment_cube = calculate_image_frequency_moments(cube, nmoment=3)
log.debug(
export_image_to_fits(moment_cube,
fitsfile='%s/test_moments_moment_cube.fits' %
(self.dir)))
reconstructed_cube = calculate_image_from_frequency_moments(
cube, moment_cube)
log.debug(
export_image_to_fits(
reconstructed_cube,
fitsfile='%s/test_moments_reconstructed_cube.fits' %
(self.dir)))
error = numpy.std(reconstructed_cube.data - original_cube.data)
assert error < 0.2
def test_create_convolutionfunction(self):
cf = create_convolutionfunction_from_image(self.image, nz=1)
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_convolutionfunction_cf.fits" % self.dir)
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')
def test_compare_wterm_kernels(self):
_, cf = create_awterm_convolutionfunction(self.image,
nw=110,
wstep=8,
oversampling=8,
support=60,
use_aaf=True)
cf.data = numpy.real(cf.data)
peak_location = numpy.unravel_index(numpy.argmax(numpy.abs(cf.data)),
cf.shape)
assert peak_location == (0, 0, 55, 4, 4, 30, 30), peak_location
assert numpy.abs(cf.data[peak_location] - (0.18704481681878257 - 0j)) < 1e-7, \
cf.data[peak_location]
_, cf_noover = create_awterm_convolutionfunction(self.image,
nw=111,
wstep=8,
oversampling=1,
support=60,
use_aaf=True)
cf_noover.data = numpy.real(cf_noover.data)
cf.data[...] -= cf_noover.data[0, 0, 0, 0, 0]
cf_image = convert_convolutionfunction_to_image(cf)
cf_image.data = numpy.real(cf_image.data)
export_image_to_fits(
cf_image,
"%s/test_convolutionfunction_compare_wterm_kernels.fits" %
self.dir)
assert numpy.abs(cf.data[0, 0, 0, 4, 4, 30, 30]) < 5e-6, cf.data[0, 0,
0, 4,
4, 30,
30]
def test_create_voltage_patterns_illumination(self):
self.createVis(freq=1.4e9)
cellsize = 8 * numpy.pi / 180.0 / 280
model = create_image_from_visibility(self.vis,
npixel=512,
cellsize=cellsize,
override_cellsize=False)
plt.clf()
fig, axs = plt.subplots(5, 5, gridspec_kw={'hspace': 0, 'wspace': 0})
# (r ** 2 + rho * (dx * dy) + diff * (dx ** 2 - dy ** 2))
for irho, rho in enumerate([-0.1, -0.05, 0.0, 0.05, 0.1]):
for idiff, diff in enumerate([-0.2, -0.15, -0.1, -0.05, 0.0]):
vp = create_vp_generic_numeric(model,
pointingcentre=None,
diameter=15.0,
blockage=0.0,
taper='gaussian',
edge=0.03162278,
padding=2,
use_local=True,
rho=rho,
diff=diff)
vp_data = vp.data
vp.data = numpy.real(vp_data)
if self.persist:
export_image_to_fits(
vp,
"%s/test_voltage_pattern_real_%s_rho%.3f_diff%.3f.fits"
% (self.dir, "MID_TAPER", rho, diff))
ax = axs[irho, idiff]
ax.imshow(vp.data[0, 0]) #, vmax=0.1, vmin=-0.01)
ax.axis('off')
plt.show()
def test_skymodel_solve_fixed(self):
self.actualSetup(ntimes=1, doiso=True, fixed=True)
calskymodel, residual_vis = calskymodel_solve(self.vis,
self.skymodels,
niter=30,
gain=0.25)
# Check that the components are unchanged
calskymodel_skycomponents = list()
for sm in [csm[0] for csm in calskymodel]:
for comp in sm.components:
calskymodel_skycomponents.append(comp)
recovered_components = find_skycomponent_matches(
calskymodel_skycomponents, self.components, 1e-5)
for p in recovered_components:
assert numpy.abs(calskymodel_skycomponents[p[0]].flux[0, 0] -
self.components[p[1]].flux[0, 0]) < 1e-15
assert calskymodel_skycomponents[p[0]].direction.separation(
self.components[p[1]].direction).rad < 1e-15
residual_vis = convert_blockvisibility_to_visibility(residual_vis)
residual_vis, _, _ = weight_visibility(residual_vis, self.beam)
dirty, sumwt = invert_function(residual_vis, self.beam, context='2d')
export_image_to_fits(
dirty, "%s/test_skymodel-final-iso-residual.fits" % self.dir)
qa = qa_image(dirty)
assert qa.data['rms'] < 3.4e-3, qa
def test_tapering_Gaussian(self):
self.actualSetUp()
size_required = 0.003542
self.componentvis, _, _ = weight_visibility(self.componentvis,
self.model,
algoritm='uniform')
self.componentvis = taper_visibility_gaussian(self.componentvis,
beam=size_required)
psf, sumwt = invert_2d(self.componentvis, self.model, dopsf=True)
export_image_to_fits(
psf, '%s/test_weighting_gaussian_taper_psf.fits' % self.dir)
xfr = fft_image(psf)
xfr.data = xfr.data.real.astype('float')
export_image_to_fits(
xfr, '%s/test_weighting_gaussian_taper_xfr.fits' % self.dir)
npixel = psf.data.shape[3]
sl = slice(npixel // 2 - 7, npixel // 2 + 8)
fit = fit_2dgaussian(psf.data[0, 0, sl, sl])
if fit.x_stddev <= 0.0 or fit.y_stddev <= 0.0:
raise ValueError('Error in fitting to psf')
# fit_2dgaussian returns sqrt of variance. We need to convert that to FWHM.
# https://en.wikipedia.org/wiki/Full_width_at_half_maximum
scale_factor = numpy.sqrt(8 * numpy.log(2.0))
size = numpy.sqrt(fit.x_stddev * fit.y_stddev) * scale_factor
# Now we need to convert to radians
size *= numpy.pi * self.model.wcs.wcs.cdelt[1] / 180.0
# Very impressive! Desired 0.01 Acheived 0.0100006250829
assert numpy.abs(size - size_required) < 0.001 * size_required, \
"Fit should be %f, actually is %f" % (size_required, size)
def _invert_base(self,
context,
extra='',
fluxthreshold=1.0,
positionthreshold=1.0,
check_components=True,
facets=1,
vis_slices=1,
**kwargs):
dirty = invert_component(self.vis_list,
self.model_graph,
context=context,
dopsf=False,
normalize=True,
facets=facets,
vis_slices=vis_slices,
**kwargs)[0]
dirty = arlexecute.compute(dirty, sync=True)
export_image_to_fits(
dirty[0], '%s/test_imaging_invert_%s%s_%s_dirty.fits' %
(self.dir, context, extra, arlexecute.type()))
assert numpy.max(numpy.abs(dirty[0].data)), "Image is empty"
if check_components:
self._checkcomponents(dirty[0], fluxthreshold, positionthreshold)
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_invert(self):
uvfitsfile = arl_path("data/vis/ASKAP_example.fits")
nchan_ave = 32
nchan = 192
for schan in range(0, nchan, nchan_ave):
max_chan = min(nchan, schan + nchan_ave)
bv = create_blockvisibility_from_uvfits(uvfitsfile,
range(schan, max_chan))[0]
vis = convert_blockvisibility_to_visibility(bv)
from processing_components.visibility.operations import convert_visibility_to_stokesI
vis = convert_visibility_to_stokesI(vis)
model = create_image_from_visibility(
vis,
npixel=256,
polarisation_frame=PolarisationFrame('stokesI'))
dirty, sumwt = invert_2d(vis, model, context='2d')
assert (numpy.max(numpy.abs(dirty.data))) > 0.0
assert dirty.shape == (nchan_ave, 1, 256, 256)
import matplotlib.pyplot as plt
from processing_components.image.operations import show_image
show_image(dirty)
plt.show()
if self.persist:
export_image_to_fits(
dirty, '%s/test_visibility_uvfits_dirty.fits' % self.dir)
def test_create_primary_beams_AZELGEO(self):
self.createVis()
for telescope in ['VLA', 'ASKAP', 'MID', 'MID_GAUSS', 'MID_GRASP', 'LOW']:
model = create_image_from_visibility(self.vis, cellsize=0.001, override_cellsize=False)
beam = create_pb(model, telescope=telescope, use_local=True)
assert numpy.max(beam.data) > 0.0
export_image_to_fits(beam, "%s/test_primary_beam_AZELGEO_%s.fits" % (self.dir, telescope))
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_create_low_test_beam(self):
im = create_test_image(
canonical=True,
cellsize=0.002,
frequency=numpy.array([1e8 - 5e7, 1e8, 1e8 + 5e7]),
channel_bandwidth=numpy.array([5e7, 5e7, 5e7]),
polarisation_frame=PolarisationFrame("stokesIQUV"),
phasecentre=self.phasecentre)
bm = create_low_test_beam(model=im)
export_image_to_fits(bm,
'%s/test_test_support_low_beam.fits' % (self.dir))
assert bm.data.shape[0] == 3
assert bm.data.shape[1] == 4
assert bm.data.shape[2] == im.data.shape[2]
assert bm.data.shape[3] == im.data.shape[3]
# Check to see if the beam scales as expected
for i in [30, 40]:
assert numpy.max(
numpy.abs(bm.data[0, 0, 128, 128 - 2 * i] -
bm.data[1, 0, 128, 128 - i])) < 0.02
assert numpy.max(
numpy.abs(bm.data[0, 0, 128, 128 - 3 * i] -
bm.data[2, 0, 128, 128 - i])) < 0.02
assert numpy.max(
numpy.abs(bm.data[0, 0, 128 - 2 * i, 128] -
bm.data[1, 0, 128 - i, 128])) < 0.02
assert numpy.max(
numpy.abs(bm.data[0, 0, 128 - 3 * i, 128] -
bm.data[2, 0, 128 - i, 128])) < 0.02
def test_deconvolve_hogbom(self):
self.comp, self.residual = deconvolve_cube(self.dirty, self.psf, niter=10000, gain=0.1, algorithm='hogbom',
threshold=0.01)
export_image_to_fits(self.residual, "%s/test_deconvolve_hogbom-residual.fits" % (self.dir))
self.cmodel = restore_cube(self.comp, self.psf, self.residual)
export_image_to_fits(self.cmodel, "%s/test_deconvolve_hogbom-clean.fits" % (self.dir))
assert numpy.max(self.residual.data) < 1.2
def _predict_base(self,
fluxthreshold=1.0,
gcf=None,
cf=None,
name='predict_2d',
gcfcf=None,
**kwargs):
vis = predict_2d(self.vis, self.model, gcfcf=gcfcf, **kwargs)
vis.data['vis'] = self.vis.data['vis'] - vis.data['vis']
dirty = invert_2d(vis,
self.model,
dopsf=False,
normalize=True,
gcfcf=gcfcf)
if self.persist:
export_image_to_fits(
dirty[0],
'%s/test_imaging_%s_residual.fits' % (self.dir, name))
assert numpy.max(numpy.abs(dirty[0].data)), "Residual image is empty"
maxabs = numpy.max(numpy.abs(dirty[0].data))
assert maxabs < fluxthreshold, "Error %.3f greater than fluxthreshold %.3f " % (
maxabs, fluxthreshold)
def test_fill_pswf_to_convolutionfunction_nooversampling(self):
oversampling = 1
support = 6
gcf, cf = create_pswf_convolutionfunction(self.image,
oversampling=oversampling,
support=support)
assert numpy.max(numpy.abs(cf.data)) > 0.0
export_image_to_fits(
gcf, "%s/test_convolutionfunction_pswf_nooversampling_gcf.fits" %
self.dir)
cf_image = convert_convolutionfunction_to_image(cf)
cf_image.data = numpy.real(cf_image.data)
export_image_to_fits(
cf_image,
"%s/test_convolutionfunction_pwsf_nooversampling_cf.fits" %
self.dir)
peak_location = numpy.unravel_index(numpy.argmax(numpy.abs(cf.data)),
cf.shape)
assert numpy.abs(cf.data[peak_location] - 0.18712109669890536 +
0j) < 1e-7, cf.data[peak_location]
assert peak_location == (0, 0, 0, 0, 0, 3, 3), peak_location
u_peak, v_peak = cf.grid_wcs.sub([1, 2]).wcs_pix2world(
peak_location[-2], peak_location[-1], 0)
assert numpy.abs(u_peak) < 1e-7, u_peak
assert numpy.abs(v_peak) < 1e-7, u_peak
def _predict_base(self,
context='2d',
extra='',
fluxthreshold=1.0,
facets=1,
vis_slices=1,
**kwargs):
vis_list = zero_vislist_component(self.vis_list)
vis_list = predict_component(vis_list,
self.model_graph,
context=context,
vis_slices=vis_slices,
facets=facets,
**kwargs)
vis_list = subtract_vislist_component(self.vis_list, vis_list)[0]
vis_list = arlexecute.compute(vis_list, sync=True)
dirty = invert_component([vis_list], [self.model_graph[0]],
context='2d',
dopsf=False,
normalize=True)[0]
dirty = arlexecute.compute(dirty, sync=True)
assert numpy.max(numpy.abs(dirty[0].data)), "Residual image is empty"
export_image_to_fits(
dirty[0], '%s/test_imaging_predict_%s%s_%s_dirty.fits' %
(self.dir, context, extra, arlexecute.type()))
maxabs = numpy.max(numpy.abs(dirty[0].data))
assert maxabs < fluxthreshold, "Error %.3f greater than fluxthreshold %.3f " % (
maxabs, fluxthreshold)
def test_deconvolve_hogbom_subpsf(self):
self.comp, self.residual = deconvolve_cube(self.dirty, psf=self.psf, psf_support=200, window='quarter',
niter=10000, gain=0.1, algorithm='hogbom', threshold=0.01)
export_image_to_fits(self.residual, "%s/test_deconvolve_hogbom_subpsf-residual.fits" % (self.dir))
self.cmodel = restore_cube(self.comp, self.psf, self.residual)
export_image_to_fits(self.cmodel, "%s/test_deconvolve_hogbom_subpsf-clean.fits" % (self.dir))
assert numpy.max(self.residual.data[..., 56:456, 56:456]) < 1.2
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_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)
def test_create_test_image_from_s3_low(self):
im = create_test_image_from_s3(npixel=1024, channel_bandwidth=numpy.array([1e6]),
frequency=numpy.array([1e8]),
phasecentre=self.phasecentre, fov=10)
assert im.data.shape[0] == 1
assert im.data.shape[1] == 1
assert im.data.shape[2] == 1024
assert im.data.shape[3] == 1024
export_image_to_fits(im, '%s/test_test_support_low_s3.fits' % (self.dir))
def main():
"""Run the workflow."""
init_logging()
LOG.info("Starting imaging-pipeline")
# Read parameters
PARFILE = 'parameters.json'
if len(sys.argv) > 1:
PARFILE = sys.argv[1]
LOG.info("JSON parameter file = %s", PARFILE)
try:
with open(PARFILE, "r") as par_file:
jspar = json.load(par_file)
except AssertionError as error:
LOG.critical('ERROR %s', error)
return
# We will use dask
arlexecute.set_client(get_dask_Client())
arlexecute.run(init_logging)
# Import visibility list from HDF5 file
vis_list = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["vis_list"]))
# Now read the BlockVisibilities constructed using a model drawn from GLEAM
predicted_vislist = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["predicted_vis_list"]))
corrupted_vislist = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["corrupted_vis_list"]))
# Reproduce parameters from the visibility data
ntimes = vis_list[0].nvis
phasecentre = vis_list[0].phasecentre
print(phasecentre)
polframe = vis_list[0].polarisation_frame.type
LOG.info("Polarisation Frame of vis_list: %s", polframe)
wprojection_planes = jspar["advice"]["wprojection_planes"]
guard_band_image = jspar["advice"]["guard_band_image"]
delA = jspar["advice"]["delA"]
advice_low = advise_wide_field(vis_list[0], guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
advice_high = advise_wide_field(vis_list[-1], guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
vis_slices = advice_low['vis_slices']
npixel = advice_high['npixels2']
cellsize = min(advice_low['cellsize'], advice_high['cellsize'])
# Recovering frequencies
fstart = vis_list[0].frequency
fend = vis_list[-1].frequency
num_freq_win = len(vis_list)
frequency = numpy.linspace(fstart, fend, num_freq_win)
# Recovering bandwidths
channel_bandwidth = numpy.array(num_freq_win * [vis_list[1].frequency - vis_list[0].frequency])
# Get the LSM. This is currently blank.
model_list = [
arlexecute.execute(create_image_from_visibility)(
vis_list[f],
npixel=npixel,
frequency=[frequency[f]],
channel_bandwidth=[channel_bandwidth[f]],
cellsize=cellsize,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame(polframe))
for f, freq in enumerate(frequency)
]
# future_predicted_vislist = arlexecute.scatter(predicted_vislist)
# Create and execute graphs to make the dirty image and PSF
# LOG.info('About to run invert to get dirty image')
# dirty_list = invert_component(future_predicted_vislist, model_list,
# context='wstack',
# vis_slices=vis_slices, dopsf=False)
# dirty_list = arlexecute.compute(dirty_list, sync=True)
# LOG.info('About to run invert to get PSF')
# psf_list = invert_component(future_predicted_vislist, model_list,
# context='wstack',
# vis_slices=vis_slices, dopsf=True)
# psf_list = arlexecute.compute(psf_list, sync=True)
# Now deconvolve using msclean
# LOG.info('About to run deconvolve')
# deconvolve_list, _ = deconvolve_component(
# dirty_list, psf_list,
# model_imagelist=model_list,
# deconvolve_facets=8,
# deconvolve_overlap=16,
# deconvolve_taper='tukey',
# scales=[0, 3, 10],
# algorithm='msclean',
# niter=1000,
# fractional_threshold=0.1,
# threshold=0.1,
# gain=0.1,
# psf_support=64)
# deconvolved = arlexecute.compute(deconvolve_list, sync=True)
LOG.info('About to run continuum imaging')
continuum_imaging_list = continuum_imaging_arlexecute(
predicted_vislist,
model_imagelist = model_list,
context = jspar["processing"]["continuum_imaging"]["context"] , #'wstack',
vis_slices = vis_slices,
scales = jspar["processing"]["continuum_imaging"]["scales"], #[0, 3, 10],
algorithm = jspar["processing"]["continuum_imaging"]["algorithm"], #'mmclean',
nmoment = jspar["processing"]["continuum_imaging"]["nmoment"], #3,
niter = jspar["processing"]["continuum_imaging"]["niter"], #1000,
fractional_threshold = jspar["processing"]["continuum_imaging"]["fractional_threshold"], #0.1,
threshold = jspar["processing"]["continuum_imaging"]["threshold"], #0.1,
nmajor = jspar["processing"]["continuum_imaging"]["nmajor"], #5,
gain = jspar["processing"]["continuum_imaging"]["gain"], #0.25,
deconvolve_facets = jspar["processing"]["continuum_imaging"]["deconvolve_facets"], #8,
deconvolve_overlap = jspar["processing"]["continuum_imaging"]["deconvolve_overlap"], #16,
deconvolve_taper = jspar["processing"]["continuum_imaging"]["deconvolve_taper"], #'tukey',
psf_support = jspar["processing"]["continuum_imaging"]["psf_support"] ) #64)
result = arlexecute.compute(continuum_imaging_list, sync=True)
deconvolved = result[0][0]
residual = result[1][0]
restored = result[2][0]
print(qa_image(deconvolved, context='Clean image - no selfcal'))
print(qa_image(restored, context='Restored clean image - no selfcal'))
export_image_to_fits(restored,
'%s/%s' % (RESULTS_DIR, jspar["files"]["continuum_imaging_restored"]))
print(qa_image(residual[0], context='Residual clean image - no selfcal'))
export_image_to_fits(residual[0],
'%s/%s' % (RESULTS_DIR, jspar["files"]["continuum_imaging_residual"]))
controls = create_calibration_controls()
controls['T']['first_selfcal'] = jspar["processing"]["controls"]["T"]["first_selfcal"]
controls['G']['first_selfcal'] = jspar["processing"]["controls"]["G"]["first_selfcal"]
controls['B']['first_selfcal'] = jspar["processing"]["controls"]["B"]["first_selfcal"]
controls['T']['timescale'] = jspar["processing"]["controls"]["T"]["timescale"]
controls['G']['timescale'] = jspar["processing"]["controls"]["G"]["timescale"]
controls['B']['timescale'] = jspar["processing"]["controls"]["B"]["timescale"]
PP.pprint(controls)
future_corrupted_vislist = arlexecute.scatter(corrupted_vislist)
ical_list = ical_arlexecute(future_corrupted_vislist,
model_imagelist = model_list,
context = jspar["processing"]["ical"]["context"] , #'wstack',
calibration_context = jspar["processing"]["ical"]["calibration_context"] , #'TG',
controls = controls,
vis_slices = ntimes,
scales = jspar["processing"]["ical"]["scales"], #[0, 3, 10],
timeslice = jspar["processing"]["ical"]["timeslice"], #'auto',
algorithm = jspar["processing"]["ical"]["algorithm"], #'mmclean',
nmoment = jspar["processing"]["ical"]["nmoment"], #3,
niter = jspar["processing"]["ical"]["niter"], #1000,
fractional_threshold = jspar["processing"]["ical"]["fractional_threshold"], #0.1,
threshold = jspar["processing"]["ical"]["threshold"], #0.1,
nmajor = jspar["processing"]["ical"]["nmajor"], #5,
gain = jspar["processing"]["ical"]["gain"], #0.25,
deconvolve_facets = jspar["processing"]["ical"]["deconvolve_facets"], #8,
deconvolve_overlap = jspar["processing"]["ical"]["deconvolve_overlap"], #16,
deconvolve_taper = jspar["processing"]["ical"]["deconvolve_taper"], #'tukey',
global_solution = jspar["processing"]["ical"]["global_solution"], #False,
do_selfcal = jspar["processing"]["ical"]["do_selfcal"], #True,
psf_support = jspar["processing"]["ical"]["psf_support"]) #64
LOG.info('About to run ical')
result = arlexecute.compute(ical_list, sync=True)
deconvolved = result[0][0]
residual = result[1][0]
restored = result[2][0]
print(qa_image(deconvolved, context='Clean image'))
print(qa_image(restored, context='Restored clean image'))
export_image_to_fits(restored, '%s/%s' % (RESULTS_DIR, jspar["files"]["ical_restored"]))
print(qa_image(residual[0], context='Residual clean image'))
export_image_to_fits(residual[0], '%s/%s' % (RESULTS_DIR, jspar["files"]["ical_residual"]))
arlexecute.close()
