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)