def test_restored_list_facet(self): self.actualSetUp(zerow=True) centre = self.freqwin // 2 psf_image_list = invert_list_arlexecute_workflow(self.vis_list, self.model_list, context='2d', dopsf=True) residual_image_list = residual_list_arlexecute_workflow(self.vis_list, self.model_list, context='2d') restored_4facets_image_list = restore_list_arlexecute_workflow(self.model_list, psf_image_list, residual_image_list, restore_facets=4, psfwidth=1.0) restored_4facets_image_list = arlexecute.compute(restored_4facets_image_list, sync=True) restored_1facets_image_list = restore_list_arlexecute_workflow(self.model_list, psf_image_list, residual_image_list, restore_facets=1, psfwidth=1.0) restored_1facets_image_list = arlexecute.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, arlexecute.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, arlexecute.type())) qa = qa_image(restored_4facets_image_list[centre]) assert numpy.abs(qa.data['max']) < 1e-10, str(qa)
def test_restored_list_noresidual(self): self.actualSetUp(zerow=True) centre = self.freqwin // 2 psf_image_list = invert_list_arlexecute_workflow(self.vis_list, self.model_list, context='2d', dopsf=True) restored_image_list = restore_list_arlexecute_workflow(self.model_list, psf_image_list, psfwidth=1.0) restored_image_list = arlexecute.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, arlexecute.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_deconvolve_and_restore_cube_mmclean_facets(self): self.actualSetUp(add_errors=True) dirty_imagelist = invert_list_arlexecute_workflow(self.vis_list, self.model_imagelist, context='2d', dopsf=False, normalize=True) psf_imagelist = invert_list_arlexecute_workflow(self.vis_list, self.model_imagelist, context='2d', dopsf=True, normalize=True) dirty_imagelist = arlexecute.persist(dirty_imagelist) psf_imagelist = arlexecute.persist(psf_imagelist) dec_imagelist = deconvolve_list_arlexecute_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 = arlexecute.persist(dec_imagelist) residual_imagelist = residual_list_arlexecute_workflow( self.vis_list, model_imagelist=dec_imagelist, context='2d') residual_imagelist = arlexecute.persist(residual_imagelist) restored_list = restore_list_arlexecute_workflow( model_imagelist=dec_imagelist, psf_imagelist=psf_imagelist, residual_imagelist=residual_imagelist, empty=self.model_imagelist) restored = arlexecute.compute(restored_list, sync=True)[0] if self.persist: export_image_to_fits( restored, '%s/test_imaging_%s_overlap_mmclean_restored.fits' % (self.dir, arlexecute.type()))
def test_deconvolve_and_restore_cube_mmclean(self): self.actualSetUp(add_errors=True) dirty_imagelist = invert_list_arlexecute_workflow(self.vis_list, self.model_imagelist, context='2d', dopsf=False, normalize=True) psf_imagelist = invert_list_arlexecute_workflow(self.vis_list, self.model_imagelist, context='2d', dopsf=True, normalize=True) dec_imagelist, _ = deconvolve_list_arlexecute_workflow(dirty_imagelist, psf_imagelist, self.model_imagelist, niter=1000, fractional_threshold=0.01, scales=[0, 3, 10], algorithm='mmclean', nmoments=3, nchan=self.freqwin, threshold=0.1, gain=0.7) residual_imagelist = residual_list_arlexecute_workflow(self.vis_list, model_imagelist=dec_imagelist, context='wstack', vis_slices=51) restored = restore_list_arlexecute_workflow(model_imagelist=dec_imagelist, psf_imagelist=psf_imagelist, residual_imagelist=residual_imagelist, empty=self.model_imagelist)[0] restored = arlexecute.compute(restored, sync=True) export_image_to_fits(restored, '%s/test_imaging_%s_mmclean_restored.fits' % (self.dir, arlexecute.type()))
def test_mpccal_MPCCAL_manysources_subimages(self): self.actualSetup() model = create_empty_image_like(self.theta_list[0].image) if arlexecute.using_dask: progress = None else: progress = self.progress future_vis = arlexecute.scatter(self.all_skymodel_noniso_vis) future_model = arlexecute.scatter(model) future_theta_list = arlexecute.scatter(self.theta_list) result = mpccal_skymodel_list_arlexecute_workflow( future_vis, future_model, future_theta_list, mpccal_progress=progress, nmajor=5, context='2d', algorithm='hogbom', scales=[0, 3, 10], fractional_threshold=0.3, threshold=0.2, gain=0.1, niter=1000, psf_support=256, deconvolve_facets=8, deconvolve_overlap=8, deconvolve_taper='tukey') (self.theta_list, residual) = arlexecute.compute(result, sync=True) combined_model = calculate_skymodel_equivalent_image(self.theta_list) psf_obs = invert_list_arlexecute_workflow( [self.all_skymodel_noniso_vis], [model], context='2d', dopsf=True) result = restore_list_arlexecute_workflow([combined_model], psf_obs, [(residual, 0.0)]) result = arlexecute.compute(result, sync=True) if self.persist: export_image_to_fits( residual, arl_path('test_results/test_mpccal_no_edge_residual.fits')) if self.persist: export_image_to_fits( result[0], arl_path('test_results/test_mpccal_no_edge_restored.fits')) if self.persist: export_image_to_fits( combined_model, arl_path('test_results/test_mpccal_no_edge_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 8', recovered_mpccal_components[0].name assert numpy.abs(recovered_mpccal_components[0].flux[0, 0] - 7.773751416364857) < 1e-7, \ 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, arl_path('test_results/test_mpccal_no_edge_screen.fits')) if self.persist: export_image_to_fits( weights, arl_path( 'test_results/test_mpccal_no_edge_screenweights.fits')) arlexecute.close()
psf_support=512, deconvolve_facets=8, deconvolve_overlap=16, deconvolve_taper='tukey') (ical_skymodel, residual) = arlexecute.compute(result, sync=True) print(qa_image(residual, context='ICAL residual image')) print('ical finished') combined_model = calculate_skymodel_equivalent_image(ical_skymodel) print(qa_image(combined_model, context='ICAL combined model')) psf_obs = invert_list_arlexecute_workflow([future_vis], [future_model], context='2d', dopsf=True) result = restore_list_arlexecute_workflow([combined_model], psf_obs, [(residual, 0.0)]) result = arlexecute.compute(result, sync=True) ical_restored = result[0] export_image_to_fits( ical_restored, arl_path('test_results/low-sims-mpc-ical-restored_%.1frmax.fits' % rmax)) ####################################################################################################### # Now set up the skymodels for MPCCAL. We find the brightest components in the ICAL image, remove # sources that are too close to another stronger source, and then use these to set up # a Voronoi tesselation to define the skymodel masks ical_components = find_skycomponents(ical_restored, fwhm=2,
residual_imagelist = residual_list_arlexecute_workflow(vt_list, model_imagelist=dec_imagelist, context=context) # residual_imagelist = arlexecute.persist(residual_imagelist) residual_imagelist = arlexecute.compute(residual_imagelist, sync=True) residualed = residual_imagelist[0][0] show_image(residualed) plt.title(context) plt.savefig('%s/test_imaging_%s_residual.pdf' % (storedir, context)) # export_image_to_fits(residualed, # '%s/test_imaging_%s_residualed.fits' % (storedir, context)) restored_list = restore_list_arlexecute_workflow(model_imagelist=dec_imagelist, psf_imagelist=psf_imagelist, gcfcf=gcfcf, residual_imagelist=residual_imagelist, empty=targetimage_list) restored_list = arlexecute.compute(restored_list, sync=True) restored = restored_list[0] show_image(restored) plt.title(context) plt.savefig('%s/test_imaging_%s_restored.pdf' % (storedir, context)) # export_image_to_fits(restored, # '%s/test_imaging_%s_restored.fits' % (storedir, context)) comps = find_skycomponents(targetimage, fwhm=1.0, threshold=10.0, npixels=5) plt.clf() for comp in comps: