def actualSetUp(self, nfreqwin=3, dospectral=True, dopol=False,
amp_errors=None, phase_errors=None, zerow=True):
if amp_errors is None:
amp_errors = {'T': 0.0, 'G': 0.1}
if phase_errors is None:
phase_errors = {'T': 1.0, 'G': 0.0}
self.npixel = 512
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = nfreqwin
self.vis_list = list()
self.ntimes = 1
self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
if self.freqwin > 1:
self.channelwidth = numpy.array(self.freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.channelwidth = numpy.array([1e6])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array([f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000')
self.blockvis_list = \
[rsexecute.execute(ingest_unittest_visibility, nout=1)(self.low,
[self.frequency[i]],
[self.channelwidth[i]],
self.times,
self.vis_pol,
self.phasecentre, block=True,
zerow=zerow)
for i in range(nfreqwin)]
self.blockvis_list = rsexecute.compute(self.blockvis_list, sync=True)
for v in self.blockvis_list:
v.data['vis'][...] = 1.0 + 0.0j
self.error_blockvis_list = [rsexecute.execute(copy_visibility(v)) for v in self.blockvis_list]
gt = rsexecute.execute(create_gaintable_from_blockvisibility)(self.blockvis_list[0])
gt = rsexecute.execute(simulate_gaintable)\
(gt, phase_error=0.1, amplitude_error=0.0, smooth_channels=1, leakage=0.0, seed=180555)
self.error_blockvis_list = [rsexecute.execute(apply_gaintable)(self.error_blockvis_list[i], gt)
for i in range(self.freqwin)]
self.error_blockvis_list = rsexecute.compute(self.error_blockvis_list, sync=True)
assert numpy.max(numpy.abs(self.error_blockvis_list[0].vis - self.blockvis_list[0].vis)) > 0.0
def test_zero_list(self):
self.actualSetUp()
centre = self.freqwin // 2
vis_list = zero_list_rsexecute_workflow(self.bvis_list)
vis_list = rsexecute.compute(vis_list, sync=True)
assert numpy.max(numpy.abs(vis_list[centre].vis)) < 1e-15, numpy.max(
numpy.abs(vis_list[centre].vis))
predicted_vis_list = [
rsexecute.execute(dft_skycomponent_visibility)(
vis_list[freqwin], self.components_list[freqwin])
for freqwin, _ in enumerate(self.frequency)
]
predicted_vis_list = rsexecute.compute(predicted_vis_list, sync=True)
assert numpy.max(numpy.abs(predicted_vis_list[centre].vis)) > 0.0, \
numpy.max(numpy.abs(predicted_vis_list[centre].vis))
diff_vis_list = subtract_list_rsexecute_workflow(
self.bvis_list, predicted_vis_list)
diff_vis_list = rsexecute.compute(diff_vis_list, sync=True)
assert numpy.max(numpy.abs(
diff_vis_list[centre].vis)) < 1e-15, numpy.max(
numpy.abs(diff_vis_list[centre].vis))
def test_restored_list_facet(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
psf_image_list = invert_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d', dopsf=True)
residual_image_list = residual_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d')
restored_4facets_image_list = restore_list_rsexecute_workflow(self.model_list, psf_image_list,
residual_image_list,
restore_facets=4, psfwidth=1.0)
restored_4facets_image_list = rsexecute.compute(restored_4facets_image_list, sync=True)
restored_1facets_image_list = restore_list_rsexecute_workflow(self.model_list, psf_image_list,
residual_image_list,
restore_facets=1, psfwidth=1.0)
restored_1facets_image_list = rsexecute.compute(restored_1facets_image_list, sync=True)
if self.persist: export_image_to_fits(restored_4facets_image_list[0],
'%s/test_imaging_invert_%s_restored_4facets.fits' %
(self.dir, rsexecute.type()))
qa = qa_image(restored_4facets_image_list[centre])
assert numpy.abs(qa.data['max'] - 99.43438263927833) < 1e-7, str(qa)
assert numpy.abs(qa.data['min'] + 0.6328915148563354) < 1e-7, str(qa)
restored_4facets_image_list[centre].data -= restored_1facets_image_list[centre].data
if self.persist: export_image_to_fits(restored_4facets_image_list[centre],
'%s/test_imaging_invert_%s_restored_4facets_error.fits' %
(self.dir, rsexecute.type()))
qa = qa_image(restored_4facets_image_list[centre])
assert numpy.abs(qa.data['max']) < 1e-10, str(qa)
def test_predict(self):
self.actualSetUp(zerow=True)
self.skymodel_list = [
rsexecute.execute(create_low_test_skymodel_from_gleam)(
npixel=self.npixel,
cellsize=self.cellsize,
frequency=[self.frequency[f]],
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
flux_limit=0.3,
flux_threshold=1.0,
flux_max=5.0) for f, freq in enumerate(self.frequency)
]
self.skymodel_list = rsexecute.compute(self.skymodel_list, sync=True)
assert isinstance(self.skymodel_list[0].image,
Image), self.skymodel_list[0].image
assert isinstance(self.skymodel_list[0].components[0],
Skycomponent), self.skymodel_list[0].components[0]
assert len(self.skymodel_list[0].components) == 25, len(
self.skymodel_list[0].components)
assert numpy.max(numpy.abs(
self.skymodel_list[0].image.data)) > 0.0, "Image is empty"
self.skymodel_list = rsexecute.scatter(self.skymodel_list)
skymodel_vislist = predict_skymodel_list_rsexecute_workflow(
self.vis_list[0], self.skymodel_list, context='2d')
skymodel_vislist = rsexecute.compute(skymodel_vislist, sync=True)
assert numpy.max(numpy.abs(skymodel_vislist[0].vis)) > 0.0
def test_mpccal_ICAL_onesource(self):
self.actualSetup(nsources=1, nvoronoi=1)
model = create_empty_image_like(self.theta_list[0].image)
if rsexecute.using_dask:
progress = None
else:
progress = self.progress
future_vis = rsexecute.scatter(self.all_skymodel_noniso_vis)
future_model = rsexecute.scatter(model)
future_theta_list = rsexecute.scatter(self.theta_list)
result = mpccal_skymodel_list_rsexecute_workflow(future_vis, future_model, future_theta_list,
mpccal_progress=progress,
nmajor=5,
context='2d',
algorithm='hogbom',
scales=[0, 3, 10],
fractional_threshold=0.15, threshold=0.05,
gain=0.1, niter=1000, psf_support=256,
deconvolve_facets=8, deconvolve_overlap=16,
deconvolve_taper='tukey')
(self.theta_list, residual) = rsexecute.compute(result, sync=True)
combined_model = calculate_skymodel_equivalent_image(self.theta_list)
psf_obs = invert_list_rsexecute_workflow([self.all_skymodel_noniso_vis], [model], context='2d', dopsf=True)
result = restore_list_rsexecute_workflow([combined_model], psf_obs, [(residual, 0.0)])
result = rsexecute.compute(result, sync=True)
if self.persist: export_image_to_fits(residual,
rascil_path('test_results/test_mpccal_ical_onesource_residual.fits'))
if self.persist: export_image_to_fits(result[0],
rascil_path('test_results/test_mpccal_ical_onesource_restored.fits'))
if self.persist: export_image_to_fits(combined_model,
rascil_path('test_results/test_mpccal_ical_onesource_deconvolved.fits'))
recovered_mpccal_components = find_skycomponents(result[0], fwhm=2, threshold=0.32, npixels=12)
def max_flux(elem):
return numpy.max(elem.flux)
recovered_mpccal_components = sorted(recovered_mpccal_components, key=max_flux, reverse=True)
assert recovered_mpccal_components[0].name == 'Segment 0', recovered_mpccal_components[0].name
assert numpy.abs(recovered_mpccal_components[0].flux[0, 0] - 1.138095494391862) < 1e-6, \
recovered_mpccal_components[0].flux[0, 0]
newscreen = create_empty_image_like(self.screen)
gaintables = [th.gaintable for th in self.theta_list]
newscreen, weights = grid_gaintable_to_screen(self.all_skymodel_noniso_blockvis, gaintables, newscreen)
if self.persist: export_image_to_fits(newscreen,
rascil_path('test_results/test_mpccal_ical_onesource_screen.fits'))
if self.persist: export_image_to_fits(weights,
rascil_path('test_results/test_mpccal_ical_onesource_screenweights.fits'))
rsexecute.close()
def test_crosssubtract_datamodel(self):
self.actualSetUp(zerow=True)
future_vis = rsexecute.scatter(self.vis_list[0])
future_skymodel_list = rsexecute.scatter(self.skymodel_list)
skymodel_vislist = predict_skymodel_list_rsexecute_workflow(future_vis, future_skymodel_list,
context='2d', docal=True)
skymodel_vislist = rsexecute.compute(skymodel_vislist, sync=True)
vobs = sum_predict_results(skymodel_vislist)
future_vobs = rsexecute.scatter(vobs)
skymodel_vislist = crosssubtract_datamodels_skymodel_list_rsexecute_workflow(future_vobs, skymodel_vislist)
skymodel_vislist = rsexecute.compute(skymodel_vislist, sync=True)
result_skymodel = [SkyModel(components=None, image=self.skymodel_list[-1].image)
for v in skymodel_vislist]
self.vis_list = rsexecute.scatter(self.vis_list)
result_skymodel = invert_skymodel_list_rsexecute_workflow(skymodel_vislist, result_skymodel,
context='2d', docal=True)
results = rsexecute.compute(result_skymodel, sync=True)
assert numpy.max(numpy.abs(results[0][0].data)) > 0.0
assert numpy.max(numpy.abs(results[0][1])) > 0.0
if self.plot:
import matplotlib.pyplot as plt
from rascil.processing_components.image.operations import show_image
show_image(results[0][0], title='Dirty image after cross-subtraction', vmax=0.1, vmin=-0.01)
plt.show()
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 actualSetUp(self, freqwin=1, block=True, dopol=False, zerow=False):
self.npixel = 1024
self.low = create_named_configuration('LOWBD2', rmax=550.0)
self.freqwin = freqwin
self.blockvis_list = list()
self.ntimes = 5
self.cellsize = 0.0005
# Choose the interval so that the maximum change in w is smallish
integration_time = numpy.pi * (24 / (12 * 60))
self.times = numpy.linspace(-integration_time * (self.ntimes // 2), integration_time * (self.ntimes // 2),
self.ntimes)
if freqwin > 1:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.frequency = numpy.array([1.0e8])
self.channelwidth = numpy.array([4e7])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
self.phasecentre = SkyCoord(ra=+0.0 * u.deg, dec=-40.0 * u.deg, frame='icrs', equinox='J2000')
self.blockvis_list = [rsexecute.execute(ingest_unittest_visibility)(self.low,
[self.frequency[freqwin]],
[self.channelwidth[freqwin]],
self.times,
self.vis_pol,
self.phasecentre, block=block,
zerow=zerow)
for freqwin, _ in enumerate(self.frequency)]
self.blockvis_list = rsexecute.compute(self.blockvis_list, sync=True)
self.vis_list = [rsexecute.execute(convert_blockvisibility_to_visibility)(bv) for bv in self.blockvis_list]
self.vis_list = rsexecute.compute(self.vis_list, sync=True)
self.skymodel_list = [rsexecute.execute(create_low_test_skymodel_from_gleam)
(npixel=self.npixel, cellsize=self.cellsize, frequency=[self.frequency[f]],
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
flux_limit=0.6,
flux_threshold=1.0,
flux_max=5.0) for f, freq in enumerate(self.frequency)]
self.skymodel_list = rsexecute.compute(self.skymodel_list, sync=True)
assert isinstance(self.skymodel_list[0].image, Image), self.skymodel_list[0].image
assert isinstance(self.skymodel_list[0].components[0], Skycomponent), self.skymodel_list[0].components[0]
assert len(self.skymodel_list[0].components) == 35, len(self.skymodel_list[0].components)
self.skymodel_list = expand_skymodel_by_skycomponents(self.skymodel_list[0])
assert len(self.skymodel_list) == 36, len(self.skymodel_list)
assert numpy.max(numpy.abs(self.skymodel_list[-1].image.data)) > 0.0, "Image is empty"
self.vis_list = [copy_visibility(self.vis_list[0], zero=True) for i, _ in enumerate(self.skymodel_list)]
def test_sum_invert_list(self):
self.actualSetUp(zerow=True)
residual_image_list = residual_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d')
residual_image_list = rsexecute.compute(residual_image_list, sync=True)
route2 = sum_invert_results(residual_image_list)
route1 = sum_invert_results_rsexecute(residual_image_list)
route1 = rsexecute.compute(route1, sync=True)
for r in route1, route2:
assert len(r) == 2
qa = qa_image(r[0])
assert numpy.abs(qa.data['max'] - 0.35139716991480785) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.7681701460717593) < 1.0, str(qa)
assert numpy.abs(r[1]-415950.0) < 1e-7, str(qa)
def test_deconvolve_and_restore_cube_mmclean_facets(self):
self.actualSetUp(add_errors=True)
dirty_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d',
dopsf=False, normalize=True)
psf_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d',
dopsf=True, normalize=True)
dirty_imagelist = rsexecute.persist(dirty_imagelist)
psf_imagelist = rsexecute.persist(psf_imagelist)
dec_imagelist = deconvolve_list_rsexecute_workflow(dirty_imagelist, psf_imagelist, self.model_imagelist,
niter=1000,
fractional_threshold=0.1, scales=[0, 3, 10],
algorithm='mmclean', nmoment=3, nchan=self.freqwin,
threshold=0.01, gain=0.7, deconvolve_facets=8,
deconvolve_overlap=8, deconvolve_taper='tukey')
dec_imagelist = rsexecute.persist(dec_imagelist)
residual_imagelist = residual_list_rsexecute_workflow(self.vis_list, model_imagelist=dec_imagelist,
context='2d')
residual_imagelist = rsexecute.persist(residual_imagelist)
restored_list = restore_list_rsexecute_workflow(model_imagelist=dec_imagelist, psf_imagelist=psf_imagelist,
residual_imagelist=residual_imagelist,
empty=self.model_imagelist)
restored = rsexecute.compute(restored_list, sync=True)[0]
if self.persist: export_image_to_fits(restored, '%s/test_imaging_%s_overlap_mmclean_restored.fits'
% (self.dir, rsexecute.type()))
def test_continuum_imaging_pipeline_pol(self):
self.actualSetUp(add_errors=False, zerow=True, dopol=True)
continuum_imaging_list = \
continuum_imaging_list_rsexecute_workflow(self.vis_list,
model_imagelist=self.model_imagelist,
context='2d',
algorithm='mmclean', facets=1,
scales=[0, 3, 10],
niter=1000, fractional_threshold=0.1, threshold=0.1,
nmoment=3,
nmajor=5, gain=0.1,
deconvolve_facets=4, deconvolve_overlap=32,
deconvolve_taper='tukey', psf_support=64,
restore_facets=4, psfwidth=1.0)
clean, residual, restored = rsexecute.compute(continuum_imaging_list,
sync=True)
centre = len(clean) // 2
if self.persist:
export_image_to_fits(
clean[centre],
'%s/test_pipelines_continuum_imaging_pol_pipeline_rsexecute_clean.fits'
% self.dir)
export_image_to_fits(
residual[centre][0],
'%s/test_pipelines_continuum_imaging_pipeline_pol_rsexecute_residual.fits'
% self.dir)
export_image_to_fits(
restored[centre],
'%s/test_pipelines_continuum_imaging_pipeline_pol_rsexecute_restored.fits'
% self.dir)
qa = qa_image(restored[centre])
assert numpy.abs(qa.data['max'] - 100.00806411666247) < 1.0e-7, str(qa)
assert numpy.abs(qa.data['min'] +
0.03519472493724841) < 1.0e-7, str(qa)
def test_create_simulate_vis_list(self):
vis_list = simulate_list_rsexecute_workflow(
frequency=self.frequency, channel_bandwidth=self.channel_bandwidth)
assert len(vis_list) == len(self.frequency)
vt = rsexecute.compute(vis_list[0], sync=True)
assert isinstance(vt, BlockVisibility)
assert vt.nvis > 0
def test_invert_2d_robust_block(self):
self.actualSetUp(zerow=True, makegcfcf=True, block=True)
self.bvis_list = weight_list_rsexecute_workflow(self.bvis_list,
self.model_list,
weighting="robust",
robustness=0.0)
self.bvis_list = rsexecute.compute(self.bvis_list, sync=True)
assert isinstance(self.bvis_list[0], BlockVisibility)
def test_invert_2d_uniform_block(self):
self.actualSetUp(zerow=True, makegcfcf=True, block=True)
self.bvis_list = weight_list_rsexecute_workflow(self.bvis_list,
self.model_list,
gcfcf=self.gcfcf,
weighting='uniform')
self.bvis_list = rsexecute.compute(self.bvis_list, sync=True)
assert isinstance(self.bvis_list[0], BlockVisibility)
def test_useDaskSync(self):
def square(x):
return x**2
graph = rsexecute.execute(square)(numpy.arange(10))
result = rsexecute.compute(graph, sync=True)
assert (result == numpy.array([0, 1, 4, 9, 16, 25, 36, 49, 64,
81])).all()
def test_residual_list(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
residual_image_list = residual_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d')
residual_image_list = rsexecute.compute(residual_image_list, sync=True)
qa = qa_image(residual_image_list[centre][0])
assert numpy.abs(qa.data['max'] - 0.35139716991480785) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.7681701460717593) < 1.0, str(qa)
def test_sum_invert_list(self):
self.actualSetUp(zerow=True)
residual_image_list = residual_list_rsexecute_workflow(self.bvis_list,
self.model_list,
context='2d')
residual_image_list = rsexecute.compute(residual_image_list, sync=True)
route2 = sum_invert_results(residual_image_list)
route1 = sum_invert_results_rsexecute(residual_image_list)
route1 = rsexecute.compute(route1, sync=True)
for r in route1, route2:
assert len(r) == 2
qa = qa_image(r[0])
assert numpy.abs(qa.data['max'] -
0.15513038832438183) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] +
0.4607090445091728) < 1.0, str(qa)
assert numpy.abs(r[1] - 831900.) < 1e-7, r
def test_residual_list(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
residual_image_list = residual_list_rsexecute_workflow(self.bvis_list,
self.model_list,
context='2d')
residual_image_list = rsexecute.compute(residual_image_list, sync=True)
qa = qa_image(residual_image_list[centre][0])
assert numpy.abs(qa.data['max'] - 0.32584463456508744) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.4559162232699305) < 1.0, str(qa)
def create_atmospheric_errors_gaintable_rsexecute_workflow(
sub_bvis_list,
sub_components,
r0=5e3,
screen=None,
height=3e5,
type_atmosphere='iono',
show=False,
basename='',
**kwargs):
""" Create gaintable for atmospheric errors
:param sub_bvis_list: List of vis (or graph)
:param sub_components: List of components (or graph)
:param r0: r0 in m
:param screen:
:param height: Height (in m) of screen above telescope e.g. 3e5
:param type_atmosphere: 'ionosphere' or 'troposhere'
:param show: Plot the results
:param basename: Base name for the plots
:return: (list of error-free gaintables, list of error gaintables) or graph
"""
# One pointing table per visibility
error_gt_list = [
rsexecute.execute(create_gaintable_from_screen)(
vis,
sub_components,
r0=r0,
screen=screen,
height=height,
type_atmosphere=type_atmosphere)
for ivis, vis in enumerate(sub_bvis_list)
]
# Create the gain tables, one per Visibility and per component
no_error_gt_list = [[
rsexecute.execute(create_gaintable_from_blockvisibility)(bvis,
**kwargs)
for cmp in sub_components
] for ibv, bvis in enumerate(sub_bvis_list)]
if show:
tmp_gt_list = rsexecute.compute(error_gt_list, sync=True)
plot_file = 'gaintable_%s.png' % r0
plot_gaintable(tmp_gt_list,
title="%s: dish 0 gain phase, %s" % (basename, r0),
value='phase',
plot_file=plot_file)
return no_error_gt_list, error_gt_list
def _predict_base(self, context='2d', extra='', fluxthreshold=1.0, facets=1, vis_slices=1,
gcfcf=None, **kwargs):
centre = self.freqwin // 2
vis_list = zero_list_rsexecute_workflow(self.vis_list)
vis_list = predict_list_rsexecute_workflow(vis_list, self.model_list, context=context,
vis_slices=vis_slices, facets=facets,
gcfcf=gcfcf, **kwargs)
vis_list = subtract_list_rsexecute_workflow(self.vis_list, vis_list)
vis_list = rsexecute.compute(vis_list, sync=True)
dirty = invert_list_rsexecute_workflow(vis_list, self.model_list, context=context, dopsf=False,
gcfcf=gcfcf, normalize=True, vis_slices=vis_slices)
dirty = rsexecute.compute(dirty, sync=True)[centre]
assert numpy.max(numpy.abs(dirty[0].data)), "Residual image is empty"
if self.persist: export_image_to_fits(dirty[0], '%s/test_imaging_predict_%s%s_%s_dirty.fits' %
(self.dir, context, extra, rsexecute.type()))
maxabs = numpy.max(numpy.abs(dirty[0].data))
assert maxabs < fluxthreshold, "Error %.3f greater than fluxthreshold %.3f " % (maxabs, fluxthreshold)
def test_restored_list_noresidual(self):
self.actualSetUp(zerow=True)
centre = self.freqwin // 2
psf_image_list = invert_list_rsexecute_workflow(self.vis_list, self.model_list, context='2d', dopsf=True)
restored_image_list = restore_list_rsexecute_workflow(self.model_list, psf_image_list, psfwidth=1.0)
restored_image_list = rsexecute.compute(restored_image_list, sync=True)
if self.persist: export_image_to_fits(restored_image_list[centre],
'%s/test_imaging_invert_%s_restored_noresidual.fits' %
(self.dir, rsexecute.type()))
qa = qa_image(restored_image_list[centre])
assert numpy.abs(qa.data['max'] - 100.0) < 1e-7, str(qa)
assert numpy.abs(qa.data['min']) < 1e-7, str(qa)
def test_map_create_pb(self):
self.createVis(config='LOWBD2', rmax=1000.0)
model = create_image_from_visibility(self.vis,
cellsize=0.001,
override_cellsize=False)
beam = image_rsexecute_map_workflow(model,
create_pb,
facets=4,
pointingcentre=self.phasecentre,
telescope='MID')
beam = rsexecute.compute(beam, sync=True)
assert numpy.max(beam.data) > 0.0
if self.persist:
export_image_to_fits(
beam,
"%s/test_image_rsexecute_scatter_gather.fits" % (self.dir))
def _invert_base(self, context, extra='', fluxthreshold=1.0, positionthreshold=1.0, check_components=True,
facets=1, vis_slices=1, gcfcf=None, **kwargs):
centre = self.freqwin // 2
dirty = invert_list_rsexecute_workflow(self.vis_list, self.model_list, context=context,
dopsf=False, normalize=True, facets=facets, vis_slices=vis_slices,
gcfcf=gcfcf, **kwargs)
dirty = rsexecute.compute(dirty, sync=True)[centre]
if self.persist: export_image_to_fits(dirty[0], '%s/test_imaging_invert_%s%s_%s_dirty.fits' %
(self.dir, context, extra, rsexecute.type()))
assert numpy.max(numpy.abs(dirty[0].data)), "Image is empty"
if check_components:
self._checkcomponents(dirty[0], fluxthreshold, positionthreshold)
def actualSetUp(self, freqwin=1, block=False, dopol=False, zerow=False):
self.npixel = 1024
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.vis_list = list()
self.ntimes = 5
self.cellsize = 0.0005
# Choose the interval so that the maximum change in w is smallish
integration_time = numpy.pi * (24 / (12 * 60))
self.times = numpy.linspace(-integration_time * (self.ntimes // 2),
integration_time * (self.ntimes // 2),
self.ntimes)
if freqwin > 1:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.frequency = numpy.array([1.0e8])
self.channelwidth = numpy.array([4e7])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
self.phasecentre = SkyCoord(ra=+30.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis_list = [
rsexecute.execute(ingest_unittest_visibility)(
self.low, [self.frequency[freqwin]],
[self.channelwidth[freqwin]],
self.times,
self.vis_pol,
self.phasecentre,
block=block,
zerow=zerow) for freqwin, _ in enumerate(self.frequency)
]
self.vis_list = rsexecute.compute(self.vis_list)
def test_ical_pipeline_global(self):
self.actualSetUp(add_errors=True)
controls = create_calibration_controls()
controls['T']['first_selfcal'] = 1
controls['T']['timeslice'] = 'auto'
ical_list = \
ical_list_rsexecute_workflow(self.vis_list,
model_imagelist=self.model_imagelist,
context='2d',
algorithm='mmclean', facets=1,
scales=[0, 3, 10],
niter=1000, fractional_threshold=0.1, threshold=0.1,
nmoment=3,
nmajor=5, gain=0.1,
deconvolve_facets=4, deconvolve_overlap=32,
deconvolve_taper='tukey', psf_support=64,
restore_facets=4, psfwidth=1.0,
calibration_context='T', controls=controls, do_selfcal=True,
global_solution=True)
clean, residual, restored, gt_list = rsexecute.compute(ical_list,
sync=True)
centre = len(clean) // 2
if self.persist:
export_image_to_fits(
clean[centre],
'%s/test_pipelines_ical_global_pipeline_rsexecute_clean.fits' %
self.dir)
export_image_to_fits(
residual[centre][0],
'%s/test_pipelines_ical_global_pipeline_rsexecute_residual.fits'
% self.dir)
export_image_to_fits(
restored[centre],
'%s/test_pipelines_ical_global_pipeline_rsexecute_restored.fits'
% self.dir)
export_gaintable_to_hdf5(
gt_list[0]['T'],
'%s/test_pipelines_ical_global_pipeline_rsexecute_gaintable.hdf5'
% self.dir)
qa = qa_image(restored[centre])
assert numpy.abs(qa.data['max'] - 100.00790047266979) < 1.0e-7, str(qa)
assert numpy.abs(qa.data['min'] +
0.033804341730225826) < 1.0e-7, str(qa)
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 test_deconvolve_spectral(self):
self.actualSetUp(add_errors=True)
dirty_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d',
dopsf=False, normalize=True)
psf_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist,
context='2d',
dopsf=True, normalize=True)
dirty_imagelist = rsexecute.persist(dirty_imagelist)
psf_imagelist = rsexecute.persist(psf_imagelist)
deconvolved = deconvolve_list_rsexecute_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 = rsexecute.persist(deconvolved)
deconvolved = rsexecute.compute(deconvolved, sync=True)
if self.persist: export_image_to_fits(deconvolved[0], '%s/test_imaging_%s_deconvolve_spectral.fits' %
(self.dir, rsexecute.type()))
def test_predictcal(self):
self.actualSetUp(zerow=True)
future_vis = rsexecute.scatter(self.vis_list[0])
future_skymodel = rsexecute.scatter(self.skymodel_list)
skymodel_vislist = predict_skymodel_list_rsexecute_workflow(future_vis, future_skymodel,
context='2d', docal=True)
skymodel_vislist = rsexecute.compute(skymodel_vislist, sync=True)
vobs = sum_predict_results(skymodel_vislist)
if self.plot:
def plotvis(i, v):
import matplotlib.pyplot as plt
uvr = numpy.hypot(v.u, v.v)
amp = numpy.abs(v.vis[:, 0])
plt.plot(uvr, amp, '.')
plt.title(str(i))
plt.show()
plotvis(0, vobs)
m,
threshold=0.01,
fracthresh=0.01,
window_shape='quarter',
niter=100,
gain=0.1,
algorithm='hogbom-complex')
r = restore_cube(c, p[0], resid)
return r
restored_list = [
rsexecute.execute(deconvolve)(dirty_list[c], psf_list[c],
model_list[c]) for c in range(nchan)
]
restored_cube = rsexecute.execute(image_gather_channels,
nout=1)(restored_list)
# Up to this point all we have is a graph. Now we compute it and get the
# final restored cleaned cube. During the compute, Dask shows diagnostic pages
# at http://127.0.0.1:8787
restored_cube = rsexecute.compute(restored_cube, sync=True)
# Save the cube
print("Processing took %.3f s" % (time.time() - start))
print(qa_image(restored_cube, context='CLEAN restored cube'))
export_image_to_fits(
restored_cube, '%s/dprepb_rsexecute_%s_clean_restored_cube.fits' %
(results_dir, context))
rsexecute.close()
frequency = numpy.linspace(1e8, 1.5e8, 3)
channel_bandwidth = numpy.array([2.5e7, 2.5e7, 2.5e7])
flux = numpy.array([[100.0], [100.0], [100.0]])
config = create_named_configuration('LOWBD2-CORE')
times = numpy.linspace(-300.0, 300.0, 3) * numpy.pi / 43200.0
nants = config.xyz.shape[0]
assert nants > 1
assert len(config.names) == nants
assert len(config.mount) == nants
config = create_named_configuration('LOWBD2', rmax=1000.0)
phasecentre = SkyCoord(ra=+15 * u.deg, dec=-45.0 * u.deg, frame='icrs', equinox='J2000')
bvis_graph = rsexecute.execute(create_blockvisibility)(config, times, frequency,
channel_bandwidth=channel_bandwidth,
phasecentre=phasecentre, weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'))
vis_graph = rsexecute.execute(convert_blockvisibility_to_visibility)(bvis_graph)
model_graph = rsexecute.execute(create_image_from_visibility)(vis_graph, npixel=4096, cellsize=0.001,
override_cellsize=False)
beam = image_rsexecute_map_workflow(model_graph, create_pb, facets=16, pointingcentre=phasecentre,
telescope='MID')
beam = rsexecute.compute(beam, sync=True)
assert numpy.max(beam.data) > 0.0
print("Successfully finished test_image")
exit(0)
