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 _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_continuum_imaging_pipeline(self): self.actualSetUp(add_errors=False, block=True) continuum_imaging_list = \ continuum_imaging_component(self.vis_list, model_imagelist=self.model_imagelist, context='2d', algorithm='mmclean', facets=1, scales=[0, 3, 10], niter=1000, fractional_threshold=0.1, nmoments=2, nchan=self.freqwin, threshold=2.0, nmajor=5, gain=0.1, deconvolve_facets=8, deconvolve_overlap=16, deconvolve_taper='tukey') clean, residual, restored = arlexecute.compute(continuum_imaging_list, sync=True) export_image_to_fits( clean[0], '%s/test_pipelines_continuum_imaging_pipeline_clean.fits' % self.dir) export_image_to_fits( residual[0][0], '%s/test_pipelines_continuum_imaging_pipeline_residual.fits' % self.dir) export_image_to_fits( restored[0], '%s/test_pipelines_continuum_imaging_pipeline_restored.fits' % self.dir) qa = qa_image(restored[0]) assert numpy.abs(qa.data['max'] - 116.9) < 1.0, str(qa) assert numpy.abs(qa.data['min'] + 0.118) < 1.0, str(qa)
def test_useFunction(self): def square(x): return x**2 arlexecute.set_client(use_dask=False) graph = arlexecute.execute(square)(numpy.arange(10)) assert (arlexecute.compute(graph) == numpy.array( [0, 1, 4, 9, 16, 25, 36, 49, 64, 81])).all() arlexecute.close()
def test_useDaskSync(self): def square(x): return x**2 arlexecute.set_client(use_dask=True) graph = arlexecute.execute(square)(numpy.arange(10)) result = arlexecute.compute(graph, sync=True) assert (result == numpy.array([0, 1, 4, 9, 16, 25, 36, 49, 64, 81])).all() arlexecute.close()
def test_create_generic_image_graph(self): def imagerooter(im): im.data = numpy.sqrt(numpy.abs(im.data)) return im root = generic_image_component(imagerooter, self.image, facets=4) root = arlexecute.compute(root, sync=True) arlexecute.close() numpy.testing.assert_array_almost_equal_nulp( root.data**2, numpy.abs(self.image.data), 7)
def test_deconvolve_spectral(self): self.actualSetUp(add_errors=True) dirty_imagelist = invert_component(self.vis_list, self.model_imagelist, context='2d', dopsf=False, normalize=True) psf_imagelist = invert_component(self.vis_list, self.model_imagelist, context='2d', dopsf=True, normalize=True) deconvolved, _ = deconvolve_component(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 test_weighting(self): self.actualSetUp() context = 'wstack' vis_slices = 41 facets = 1 dirty_graph = invert_component(self.vis_list, self.model_graph, context=context, dopsf=False, normalize=True, facets=facets, vis_slices=vis_slices) dirty = arlexecute.compute(dirty_graph[0], sync=True) export_image_to_fits( dirty[0], '%s/test_imaging_noweighting_%s_dirty.fits' % (self.dir, arlexecute.type()))
def test_deconvolve_and_restore_cube_mmclean(self): self.actualSetUp(add_errors=True) dirty_imagelist = invert_component(self.vis_list, self.model_imagelist, context='2d', dopsf=False, normalize=True) psf_imagelist = invert_component(self.vis_list, self.model_imagelist, context='2d', dopsf=True, normalize=True) dec_imagelist, _ = deconvolve_component(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_component(self.vis_list, model_imagelist=dec_imagelist, context='wstack', vis_slices=51) restored = restore_component(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_ical_pipeline(self): amp_errors = {'T': 0.0, 'G': 0.00, 'B': 0.0} phase_errors = {'T': 0.1, 'G': 0.0, 'B': 0.0} self.actualSetUp(add_errors=True, block=True, amp_errors=amp_errors, phase_errors=phase_errors) controls = create_calibration_controls() controls['T']['first_selfcal'] = 1 controls['G']['first_selfcal'] = 3 controls['B']['first_selfcal'] = 4 controls['T']['timescale'] = 'auto' controls['G']['timescale'] = 'auto' controls['B']['timescale'] = 1e5 ical_list = \ ical_component(self.vis_list, model_imagelist=self.model_imagelist, context='2d', calibration_context='T', controls=controls, do_selfcal=True, global_solution=False, algorithm='mmclean', facets=1, scales=[0, 3, 10], niter=1000, fractional_threshold=0.1, nmoments=2, nchan=self.freqwin, threshold=2.0, nmajor=5, gain=0.1, deconvolve_facets=8, deconvolve_overlap=16, deconvolve_taper='tukey') clean, residual, restored = arlexecute.compute(ical_list, sync=True) export_image_to_fits( clean[0], '%s/test_pipelines_ical_pipeline_clean.fits' % self.dir) export_image_to_fits( residual[0][0], '%s/test_pipelines_ical_pipeline_residual.fits' % self.dir) export_image_to_fits( restored[0], '%s/test_pipelines_ical_pipeline_restored.fits' % self.dir) qa = qa_image(restored[0]) assert numpy.abs(qa.data['max'] - 116.9) < 1.0, str(qa) assert numpy.abs(qa.data['min'] + 0.118) < 1.0, str(qa)
def test_create_generic_blockvisibility_graph(self): self.blockvis = [ create_blockvisibility( self.lowcore, self.times, self.frequency, phasecentre=self.phasecentre, channel_bandwidth=self.channel_bandwidth, weight=1.0, polarisation_frame=PolarisationFrame('stokesI')) ] self.blockvis = generic_blockvisibility_component( predict_skycomponent_visibility, vis_list=self.blockvis, sc=self.comp)[0] self.blockvis = arlexecute.compute(self.blockvis, sync=True) arlexecute.close() assert numpy.max(numpy.abs(self.blockvis[0].vis)) > 0.0
def test_calskymodel_solve_component(self): self.actualSetup(doiso=True) self.skymodel_list = [ arlexecute.execute(SkyModel, nout=1)(components=[cm]) for cm in self.components ] calskymodel_list = calskymodel_solve_component( self.vis, skymodel_list=self.skymodel_list, niter=30, gain=0.25) skymodel, residual_vis = arlexecute.compute(calskymodel_list, sync=True) 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_calskymodel-%s-final-iso-residual.fits" % (self.dir, arlexecute.type())) qa = qa_image(dirty) assert qa.data['rms'] < 3.2e-3, qa
threshold=0.1, nmajor=5, gain=0.25, deconvolve_facets=8, deconvolve_overlap=32, deconvolve_taper='tukey', vis_slices=ntimes, timeslice='auto', global_solution=False, psf_support=64, do_selfcal=True) # In[ ]: 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] arlexecute.close() show_image(deconvolved, title='Clean image', cm='Greys', vmax=0.1, vmin=-0.01) print(qa_image(deconvolved, context='Clean image')) plt.show() export_image_to_fits(deconvolved, '%s/gleam_ical_deconvolved.fits' % (results_dir))
def actualSetUp(self, add_errors=False, freqwin=1, block=False, dospectral=True, dopol=False, zerow=False): arlexecute.set_client(use_dask=True) self.npixel = 256 self.low = create_named_configuration('LOWBD2', rmax=750.0) self.freqwin = freqwin self.vis_list = list() self.ntimes = 5 self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0 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([0.8e8]) 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.vis_list = [ arlexecute.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.model_graph = [ arlexecute.execute(create_unittest_model, nout=freqwin)(self.vis_list[freqwin], self.image_pol, npixel=self.npixel) for freqwin, _ in enumerate(self.frequency) ] self.components_graph = [ arlexecute.execute(create_unittest_components)( self.model_graph[freqwin], flux[freqwin, :][numpy.newaxis, :]) for freqwin, _ in enumerate(self.frequency) ] self.model_graph = [ arlexecute.execute(insert_skycomponent, nout=1)(self.model_graph[freqwin], self.components_graph[freqwin]) for freqwin, _ in enumerate(self.frequency) ] self.vis_list = [ arlexecute.execute(predict_skycomponent_visibility)( self.vis_list[freqwin], self.components_graph[freqwin]) for freqwin, _ in enumerate(self.frequency) ] # Calculate the model convolved with a Gaussian. self.model = arlexecute.compute(self.model_graph[0], sync=True) self.cmodel = smooth_image(self.model) export_image_to_fits(self.model, '%s/test_imaging_model.fits' % self.dir) export_image_to_fits(self.cmodel, '%s/test_imaging_cmodel.fits' % self.dir) if add_errors and block: self.vis_list = [ arlexecute.execute(insert_unittest_errors)(self.vis_list[i]) for i, _ in enumerate(self.frequency) ] self.vis = arlexecute.compute(self.vis_list[0], sync=True) self.components = arlexecute.compute(self.components_graph[0], sync=True)
def actualSetUp(self, add_errors=False, freqwin=5, block=False, dospectral=True, dopol=False, amp_errors=None, phase_errors=None, zerow=True): if amp_errors is None: amp_errors = {'T': 0.0, 'G': 0.01, 'B': 0.01} if phase_errors is None: phase_errors = {'T': 1.0, 'G': 0.1, 'B': 0.01} self.npixel = 512 self.low = create_named_configuration('LOWBD2', rmax=750.0) self.freqwin = freqwin self.vis_list = list() self.ntimes = 5 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 freqwin > 1: self.channelwidth = numpy.array( 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.vis_list = [ arlexecute.execute(ingest_unittest_visibility)( self.low, [self.frequency[i]], [self.channelwidth[i]], self.times, self.vis_pol, self.phasecentre, block=block, zerow=zerow) for i, _ in enumerate(self.frequency) ] self.model_imagelist = [ arlexecute.execute(create_unittest_model, nout=freqwin)(self.vis_list[0], self.image_pol, npixel=self.npixel) for i, _ in enumerate(self.frequency) ] self.components_list = [ arlexecute.execute(create_unittest_components)( self.model_imagelist[i], flux[i, :][numpy.newaxis, :]) for i, _ in enumerate(self.frequency) ] # Apply the LOW primary beam and insert into model self.model_imagelist = [ arlexecute.execute(insert_skycomponent, nout=1)(self.model_imagelist[freqwin], self.components_list[freqwin]) for freqwin, _ in enumerate(self.frequency) ] self.vis_list = [ arlexecute.execute(predict_skycomponent_visibility)( self.vis_list[freqwin], self.components_list[freqwin]) for freqwin, _ in enumerate(self.frequency) ] # Calculate the model convolved with a Gaussian. self.model_imagelist = arlexecute.compute(self.model_imagelist, sync=True) model = self.model_imagelist[0] self.cmodel = smooth_image(model) export_image_to_fits(model, '%s/test_imaging_delayed_model.fits' % self.dir) export_image_to_fits(self.cmodel, '%s/test_imaging_delayed_cmodel.fits' % self.dir) if add_errors and block: self.vis_list = [ arlexecute.execute(insert_unittest_errors)( self.vis_list[i], amp_errors=amp_errors, phase_errors=phase_errors) for i, _ in enumerate(self.frequency) ] self.vis_list = arlexecute.compute(self.vis_list, sync=True) self.vis_list = arlexecute.scatter(self.vis_list) self.model_imagelist = arlexecute.scatter(self.model_imagelist)
rmax = 300.0 frequency = numpy.linspace(0.9e8, 1.1e8, nfreqwin) channel_bandwidth = numpy.array(nfreqwin * [frequency[1] - frequency[0]]) times = numpy.linspace(-numpy.pi / 3.0, numpy.pi / 3.0, ntimes) phasecentre = SkyCoord(ra=+30.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000') vis_list = simulate_component('LOWBD2', rmax=rmax, frequency=frequency, channel_bandwidth=channel_bandwidth, times=times, phasecentre=phasecentre, order='frequency') print('%d elements in vis_list' % len(vis_list)) log.info('About to make visibility') vis_list = arlexecute.compute(vis_list, sync=True) print(vis_list[0]) # In[ ]: wprojection_planes = 1 advice_low = advise_wide_field(vis_list[0], guard_band_image=8.0, delA=0.02, wprojection_planes=wprojection_planes) advice_high = advise_wide_field(vis_list[-1], guard_band_image=8.0, delA=0.02, wprojection_planes=wprojection_planes) vis_slices = advice_low['vis_slices'] npixel = advice_high['npixels2'] cellsize = min(advice_low['cellsize'], advice_high['cellsize'])