def test_create_image_from_visibility(self): self.actualSetUp() im = create_image_from_visibility(self.vis, nchan=1, npixel=128) assert im.data.shape == (1, 1, 128, 128) im = create_image_from_visibility(self.vis, frequency=self.frequency, npixel=128) assert im.data.shape == (len(self.frequency), 1, 128, 128) im = create_image_from_visibility(self.vis, frequency=self.frequency, npixel=128, nchan=1) assert im.data.shape == (1, 1, 128, 128)
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 setUp(self): from data_models.parameters import arl_path self.dir = arl_path('test_results') self.lowcore = create_named_configuration('LOWBD2-CORE') self.times = (numpy.pi / (12.0)) * numpy.linspace(-3.0, 3.0, 7) self.frequency = numpy.array([1e8]) self.channel_bandwidth = numpy.array([1e6]) self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000') self.vis = create_visibility( self.lowcore, self.times, self.frequency, channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre, weight=1.0, polarisation_frame=PolarisationFrame('stokesI'), zerow=True) self.vis.data['vis'] *= 0.0 # Create model self.test_model = create_test_image(cellsize=0.001, phasecentre=self.vis.phasecentre, frequency=self.frequency) self.vis = predict_2d(self.vis, self.test_model) assert numpy.max(numpy.abs(self.vis.vis)) > 0.0 self.model = create_image_from_visibility( self.vis, npixel=512, cellsize=0.001, polarisation_frame=PolarisationFrame('stokesI')) self.dirty, sumwt = invert_2d(self.vis, self.model) self.psf, sumwt = invert_2d(self.vis, self.model, dopsf=True)
def test_create_voltage_patterns(self): self.createVis() for telescope in ['VLA', 'ASKAP', 'LOW']: model = create_image_from_visibility(self.vis, cellsize=0.001, override_cellsize=False) beam=create_vp(model, telescope=telescope) assert numpy.max(numpy.abs(beam.data.real)) > 0.0 assert numpy.max(numpy.abs(beam.data.imag)) < 1e-15, numpy.max(numpy.abs(beam.data.imag))
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_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_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 setUp(self): from data_models.parameters import arl_path self.dir = arl_path('test_results') self.vnchan = 7 self.lowcore = create_named_configuration('LOWBD2', rmax=300.0) self.times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 7) self.frequency = numpy.linspace(8e7, 1.2e8, self.vnchan) self.startfrequency = numpy.array([8e7]) self.channel_bandwidth = numpy.array( self.vnchan * [(1.0 - 1.0e-7) * (self.frequency[1] - self.frequency[0])]) self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000') self.vis = create_visibility( self.lowcore, times=self.times, frequency=self.frequency, phasecentre=self.phasecentre, weight=1.0, polarisation_frame=PolarisationFrame('stokesI'), channel_bandwidth=self.channel_bandwidth) self.model = create_image_from_visibility( self.vis, npixel=128, cellsize=0.001, nchan=self.vnchan, frequency=self.startfrequency)
def setUp(self): from data_models.parameters import arl_path self.dir = arl_path('test_results') self.niter = 1000 self.lowcore = create_named_configuration('LOWBD2-CORE') self.nchan = 5 self.times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 7) self.frequency = numpy.linspace(0.9e8, 1.1e8, self.nchan) self.channel_bandwidth = numpy.array( self.nchan * [self.frequency[1] - self.frequency[0]]) self.phasecentre = SkyCoord(ra=+0.0 * u.deg, dec=-45.0 * u.deg, frame='icrs', equinox='J2000') self.vis = create_visibility( self.lowcore, self.times, self.frequency, self.channel_bandwidth, phasecentre=self.phasecentre, weight=1.0, polarisation_frame=PolarisationFrame('stokesI'), zerow=True) self.vis.data['vis'] *= 0.0 # Create model self.test_model = create_low_test_image_from_gleam( npixel=512, cellsize=0.001, phasecentre=self.vis.phasecentre, frequency=self.frequency, channel_bandwidth=self.channel_bandwidth, flux_limit=1.0) beam = create_low_test_beam(self.test_model) export_image_to_fits(beam, "%s/test_deconvolve_mmclean_beam.fits" % self.dir) self.test_model.data *= beam.data export_image_to_fits( self.test_model, "%s/test_deconvolve_mmclean_model.fits" % self.dir) self.vis = predict_2d(self.vis, self.test_model) assert numpy.max(numpy.abs(self.vis.vis)) > 0.0 self.model = create_image_from_visibility( self.vis, npixel=512, cellsize=0.001, polarisation_frame=PolarisationFrame('stokesI')) self.dirty, sumwt = invert_2d(self.vis, self.model) self.psf, sumwt = invert_2d(self.vis, self.model, dopsf=True) export_image_to_fits( self.dirty, "%s/test_deconvolve_mmclean-dirty.fits" % self.dir) export_image_to_fits(self.psf, "%s/test_deconvolve_mmclean-psf.fits" % self.dir) window = numpy.ones(shape=self.model.shape, dtype=numpy.bool) window[..., 129:384, 129:384] = True self.innerquarter = create_image_from_array( window, self.model.wcs, polarisation_frame=PolarisationFrame('stokesI'))
def actualSetUp(self, time=None, frequency=None, dospectral=False, dopol=False): self.lowcore = create_named_configuration('LOWBD2', rmax=600) self.times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 5) if time is not None: self.times = time log.info("Times are %s" % (self.times)) if dospectral: self.nchan = 3 self.frequency = numpy.array([0.9e8, 1e8, 1.1e8]) self.channel_bandwidth = numpy.array([1e7, 1e7, 1e7]) else: self.frequency = numpy.array([1e8]) self.channel_bandwidth = numpy.array([1e7]) if dopol: self.vis_pol = PolarisationFrame('linear') self.image_pol = PolarisationFrame('stokesIQUV') else: self.vis_pol = PolarisationFrame('stokesI') self.image_pol = PolarisationFrame('stokesI') if dopol: f = numpy.array([100.0, 20.0, -10.0, 1.0]) else: f = numpy.array([100.0]) if dospectral: numpy.array([f, 0.8 * f, 0.6 * f]) else: numpy.array([f]) self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000') self.componentvis = create_visibility( self.lowcore, self.times, self.frequency, channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre, weight=1.0, polarisation_frame=self.vis_pol) self.uvw = self.componentvis.data['uvw'] self.componentvis.data['vis'] *= 0.0 # Create model self.model = create_image_from_visibility( self.componentvis, npixel=self.npixel, cellsize=0.001, nchan=len(self.frequency), polarisation_frame=self.image_pol)
def test_get_frequency_map_mfs(self): self.model = create_image_from_visibility( self.vis, npixel=128, cellsize=0.001, nchan=1, frequency=self.startfrequency) spectral_mode, vfrequency_map = get_frequency_map(self.vis, self.model) assert numpy.max(vfrequency_map) == 0 assert spectral_mode == 'mfs'
def create_unittest_model(vis, model_pol, npixel=None, cellsize=None, nchan=1): advice = advise_wide_field(vis, guard_band_image=2.0, delA=0.02, facets=1, wprojection_planes=1, oversampling_synthesised_beam=4.0) if cellsize is None: cellsize = advice['cellsize'] if npixel is None: npixel = advice['npixels2'] model = create_image_from_visibility(vis, npixel=npixel, cellsize=cellsize, nchan=nchan, polarisation_frame=model_pol) return model
def test_create_primary_beams(self): self.createVis(config='LOWBD2', rmax=1000.0) for telescope in ['VLA', 'ASKAP', 'MID', 'LOW']: model = create_image_from_visibility(self.vis, cellsize=0.001, override_cellsize=False) beam = create_pb(model, telescope=telescope) assert numpy.max(beam.data) > 0.0 export_image_to_fits( beam, "%s/test_primary_beam_%s.fits" % (self.dir, telescope))
def test_get_frequency_map_different_channel(self): self.model = create_image_from_visibility( self.vis, npixel=128, cellsize=0.001, frequency=self.startfrequency, nchan=3, channel_bandwidth=2e7) spectral_mode, vfrequency_map = get_frequency_map(self.vis, self.model) assert numpy.max(vfrequency_map) == self.model.nchan - 1 assert spectral_mode == 'channel'
def test_create_voltage_patterns_MID(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) for telescope in ['MID']: beam=create_vp(model, telescope=telescope, padding=4) beam_data = beam.data beam.data = numpy.real(beam_data) beam.wcs.wcs.crval[0]=0.0 beam.wcs.wcs.crval[1]=90.0 export_image_to_fits(beam, "%s/test_voltage_pattern_real_zenith_%s.fits" % (self.dir, telescope))
def test_convert_weight(self): cvis = convert_blockvisibility_to_visibility(self.blockvis) model = create_image_from_visibility(vis=cvis, npixel=256, cellsize=0.001, phasecentre=self.phasecentre, polarisation_frame=PolarisationFrame('stokesI')) cvis = weight_visibility(cvis, model) assert numpy.mean(cvis.data['imaging_weight']) < 1.0 assert numpy.std(cvis.data['imaging_weight']) > 0.0 dvis = decoalesce_visibility(cvis) assert numpy.mean(dvis.data['imaging_weight']) < 1.0 assert numpy.std(dvis.data['imaging_weight']) > 0.0 assert dvis.nvis == self.blockvis.nvis
def main(): dlg_string = os.environ['DLG_UID'] dlg_string = dlg_string[(dlg_string.rindex('_') + 1):len(dlg_string)] dlg_uid = dlg_string.split('/') Freq_Iteration = int(dlg_uid[1]) # derived from ID Facet_Iteration = int(dlg_uid[2]) # derived from ID vt = load(1) phasecentre_array = [[+15, -45], [+15.2, -45], [+15, -44], [+14.8, -45], [+15, -46]] phasecentre = SkyCoord(ra=phasecentre_array[Facet_Iteration][0] * u.deg, dec=phasecentre_array[Facet_Iteration][1] * u.deg, frame='icrs', equinox='J2000') model = create_image_from_visibility(vt, phasecentre=phasecentre, cellsize=0.001, npixel=256) dirty, sumwt = invert_function(vt, model) psf, sumwt = invert_function(vt, model, dopsf=True) #show_image(dirty) print("Max, min in dirty image = %.6f, %.6f, sumwt = %f" % (dirty.data.max(), dirty.data.min(), sumwt)) print("Max, min in PSF = %.6f, %.6f, sumwt = %f" % (psf.data.max(), psf.data.min(), sumwt)) export_image_to_fits( dirty, '%s/imaging_dirty_%02d_%02d.fits' % (results_dir, Freq_Iteration, Facet_Iteration)) export_image_to_fits( psf, '%s/imaging_psf_%02d_%02d.fits' % (results_dir, Freq_Iteration, Facet_Iteration)) # Deconvolve using clean comp, residual = deconvolve_cube(dirty, psf, niter=1000, threshold=0.001, fracthresh=0.01, window_shape='quarter', gain=0.7, scales=[0, 3, 10, 30]) restored = restore_cube(comp, psf, residual) export_image_to_fits( restored, '%s/imaging_clean%02d_%02d.fits' % (results_dir, Freq_Iteration, Facet_Iteration)) dump(2, restored)
def test_create_primary_beams_RADEC(self): self.createVis() for telescope in ['VLA', 'ASKAP', 'MID', 'LOW']: model = create_image_from_visibility(self.vis, cellsize=self.cellsize, npixel=self.npixel, override_cellsize=False) beam = create_pb(model, telescope=telescope, use_local=False) assert numpy.max(beam.data) > 0.0 export_image_to_fits( beam, "%s/test_primary_beam_RADEC_%s.fits" % (self.dir, telescope))
def test_convert_weight(self): cvis = convert_blockvisibility_to_visibility(self.blockvis) cvis.data['imaging_weight'] = 10.0 model = create_image_from_visibility( vis=cvis, npixel=256, cellsize=0.001, phasecentre=self.phasecentre, polarisation_frame=PolarisationFrame('stokesI')) cvis = weight_visibility(cvis, model) dvis = decoalesce_visibility(cvis, overwrite=True) assert numpy.max(dvis.data['imaging_weight'] - 10.0) < 1e-7 assert dvis.nvis == self.blockvis.nvis
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_arlexecute_map_workflow(model, create_pb, facets=4, pointingcentre=self.phasecentre, telescope='MID') beam = arlexecute.compute(beam, sync=True) assert numpy.max(beam.data) > 0.0 export_image_to_fits( beam, "%s/test_image_arlexecute_scatter_gather.fits" % (self.dir))
def test_create_voltage_patterns_MID_GAUSS(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) pointingcentre = SkyCoord(ra=+17.0 * u.deg, dec=-37.0 * u.deg, frame='icrs', equinox='J2000') for telescope in ['MID_GAUSS']: beam=create_vp(model, telescope=telescope, padding=4, pointingcentre=pointingcentre) beam_data = beam.data beam.data = numpy.real(beam_data) export_image_to_fits(beam, "%s/test_voltage_pattern_real_%s.fits" % (self.dir, telescope)) beam.data = numpy.imag(beam_data) export_image_to_fits(beam, "%s/test_voltage_pattern_imag_%s.fits" % (self.dir, telescope)) beam=create_vp(model, telescope=telescope, pointingcentre=pointingcentre) beam.data = numpy.real(beam.data) export_image_to_fits(beam, "%s/test_voltage_pattern_offset_%s.fits" % (self.dir, telescope))
def test_create_voltage_patterns_MID(self): self.createVis(freq=1.4e9) model = create_image_from_visibility(self.vis, npixel=self.npixel, cellsize=self.cellsize, override_cellsize=False) for telescope in ['MID', 'MID_FEKO_B1', 'MID_FEKO_B2', 'MID_FEKO_Ku']: beam = create_vp(model, telescope=telescope, padding=4) beam_data = beam.data beam.data = numpy.real(beam_data) beam.wcs.wcs.crval[0] = 0.0 beam.wcs.wcs.crval[1] = 90.0 if self.persist: export_image_to_fits( beam, "%s/test_voltage_pattern_real_zenith_%s.fits" % (self.dir, telescope))
def test_create_voltage_patterns_MID_GAUSS(self): self.createVis() model = create_image_from_visibility(self.vis, npixel=self.npixel, cellsize=self.cellsize, override_cellsize=False) for telescope in ['MID_GAUSS']: beam = create_vp(model, telescope=telescope, padding=4) beam_data = beam.data beam.data = numpy.real(beam_data) export_image_to_fits( beam, "%s/test_voltage_pattern_real_%s.fits" % (self.dir, telescope)) beam.data = numpy.imag(beam_data) export_image_to_fits( beam, "%s/test_voltage_pattern_imag_%s.fits" % (self.dir, telescope))
def image_2d(vis, npixel_advice, cell_advice, channel, results_dir): """Do 2D imaging of visibility data. Args: vis (obj): ARL visibility data. npixel_advice (float): number of pixels in output image. cell_advice (float): cellsize in output image. channel (int): channel number to be imaged (affects output filename). results_dir (str): directory to save results. Returns: dirty: dirty image. psf: image of psf. """ try: vis_slices = len(np.unique(vis.time)) print("There are %d timeslices" % vis_slices) # Obtain advice on w-proj parameters: advice = advise_wide_field(vis) # Create a model image: model = create_image_from_visibility(vis, cellsize=cell_advice, npixel=npixel_advice, phasecentre=vis.phasecentre, polarisation_frame=PolarisationFrame('stokesIQUV')) # Weight the visibilities: vis, _, _ = weight_visibility(vis, model) # Create a dirty image: dirty, sumwt = invert_serial(vis, model, context='2d', vis_slices=1, padding=2) # Create the psf: psf, sumwt = invert_serial(vis, model, dopsf=True, context='2d', vis_slices=1, padding=2) # Save to disk: export_image_to_fits(dirty, '%s/imaging_dirty_WStack-%s.fits' % (results_dir, channel)) export_image_to_fits(psf, '%s/imaging_psf_WStack-%s.fits' % (results_dir, channel)) except: print("Unexpected error:", sys.exc_info()[0]) raise return dirty, psf
def setUp(self): from data_models.parameters import arl_path self.dir = arl_path('test_results') self.lowcore = create_named_configuration('LOWBD2-CORE') self.times = (numpy.pi / (12.0)) * numpy.linspace(-3.0, 3.0, 7) self.frequency = numpy.array([1e8]) self.channel_bandwidth = numpy.array([1e6]) self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000') self.vis = create_visibility( self.lowcore, self.times, self.frequency, channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre, weight=1.0, polarisation_frame=PolarisationFrame('stokesI')) self.vis.data['vis'] *= 0.0 self.vis.data['uvw'][:, 2] = 0.0 # Create model self.model = create_test_image(cellsize=0.0015, phasecentre=self.vis.phasecentre, frequency=self.frequency) self.model.data[self.model.data > 1.0] = 1.0 self.vis = predict_2d(self.vis, self.model) assert numpy.max(numpy.abs(self.vis.vis)) > 0.0 export_image_to_fits( self.model, '%s/test_solve_skycomponent_model.fits' % (self.dir)) self.bigmodel = create_image_from_visibility(self.vis, cellsize=0.0015, npixel=512) residual, sumwt = invert_2d(self.vis, self.bigmodel) export_image_to_fits( residual, '%s/test_solve_skycomponent_msclean_dirty.fits' % (self.dir))
def actualSetup(self, vnchan=1, doiso=True, ntimes=5, flux_limit=2.0, zerow=True, fixed=False): nfreqwin = vnchan rmax = 300.0 npixel = 512 cellsize = 0.001 frequency = numpy.linspace(0.8e8, 1.2e8, nfreqwin) if nfreqwin > 1: channel_bandwidth = numpy.array(nfreqwin * [frequency[1] - frequency[0]]) else: channel_bandwidth = [0.4e8] times = numpy.linspace(-numpy.pi / 3.0, numpy.pi / 3.0, ntimes) phasecentre = SkyCoord(ra=-60.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000') lowcore = create_named_configuration('LOWBD2', rmax=rmax) block_vis = create_blockvisibility( lowcore, times, frequency=frequency, channel_bandwidth=channel_bandwidth, weight=1.0, phasecentre=phasecentre, polarisation_frame=PolarisationFrame("stokesI"), zerow=zerow) block_vis.data['uvw'][..., 2] = 0.0 self.beam = create_image_from_visibility( block_vis, npixel=npixel, frequency=[numpy.average(frequency)], nchan=nfreqwin, channel_bandwidth=[numpy.sum(channel_bandwidth)], cellsize=cellsize, phasecentre=phasecentre) self.components = create_low_test_skycomponents_from_gleam( flux_limit=flux_limit, phasecentre=phasecentre, frequency=frequency, polarisation_frame=PolarisationFrame('stokesI'), radius=npixel * cellsize) self.beam = create_low_test_beam(self.beam) self.components = apply_beam_to_skycomponent(self.components, self.beam, flux_limit=flux_limit) self.vis = copy_visibility(block_vis, zero=True) gt = create_gaintable_from_blockvisibility(block_vis, timeslice='auto') for i, sc in enumerate(self.components): if sc.flux[0, 0] > 10: sc.flux[...] /= 10.0 component_vis = copy_visibility(block_vis, zero=True) gt = simulate_gaintable(gt, amplitude_error=0.0, phase_error=0.1, seed=None) component_vis = predict_skycomponent_visibility(component_vis, sc) component_vis = apply_gaintable(component_vis, gt) self.vis.data['vis'][...] += component_vis.data['vis'][...] # Do an isoplanatic selfcal self.model_vis = copy_visibility(self.vis, zero=True) self.model_vis = predict_skycomponent_visibility( self.model_vis, self.components) if doiso: gt = solve_gaintable(self.vis, self.model_vis, phase_only=True, timeslice='auto') self.vis = apply_gaintable(self.vis, gt, inverse=True) self.model_vis = convert_blockvisibility_to_visibility(self.model_vis) self.model_vis, _, _ = weight_visibility(self.model_vis, self.beam) self.dirty_model, sumwt = invert_function(self.model_vis, self.beam, context='2d') export_image_to_fits(self.dirty_model, "%s/test_skymodel-model_dirty.fits" % self.dir) lvis = convert_blockvisibility_to_visibility(self.vis) lvis, _, _ = weight_visibility(lvis, self.beam) dirty, sumwt = invert_function(lvis, self.beam, context='2d') if doiso: export_image_to_fits( dirty, "%s/test_skymodel-initial-iso-residual.fits" % self.dir) else: export_image_to_fits( dirty, "%s/test_skymodel-initial-noiso-residual.fits" % self.dir) self.skymodels = [ SkyModel(components=[cm], fixed=fixed) for cm in self.components ]
def ingest_visibility(self, freq=None, chan_width=None, times=None, add_errors=False, block=True, bandpass=False): if freq is None: freq = [1e8] if chan_width is None: chan_width = [1e6] if times is None: times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 5) lowcore = create_named_configuration('LOWBD2', rmax=750.0) frequency = numpy.array(freq) channel_bandwidth = numpy.array(chan_width) phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000') if block: vt = create_blockvisibility( lowcore, times, frequency, channel_bandwidth=channel_bandwidth, weight=1.0, phasecentre=phasecentre, polarisation_frame=PolarisationFrame("stokesI")) else: vt = create_visibility( lowcore, times, frequency, channel_bandwidth=channel_bandwidth, weight=1.0, phasecentre=phasecentre, polarisation_frame=PolarisationFrame("stokesI")) cellsize = 0.001 model = create_image_from_visibility( vt, npixel=self.npixel, cellsize=cellsize, npol=1, frequency=frequency, phasecentre=phasecentre, polarisation_frame=PolarisationFrame("stokesI")) nchan = len(self.frequency) flux = numpy.array(nchan * [[100.0]]) facets = 4 rpix = model.wcs.wcs.crpix - 1.0 spacing_pixels = self.npixel // facets centers = [-1.5, -0.5, 0.5, 1.5] comps = list() for iy in centers: for ix in centers: p = int(round(rpix[0] + ix * spacing_pixels * numpy.sign(model.wcs.wcs.cdelt[0]))), \ int(round(rpix[1] + iy * spacing_pixels * numpy.sign(model.wcs.wcs.cdelt[1]))) sc = pixel_to_skycoord(p[0], p[1], model.wcs, origin=1) comp = create_skycomponent( direction=sc, flux=flux, frequency=frequency, polarisation_frame=PolarisationFrame("stokesI")) comps.append(comp) if block: predict_skycomponent_visibility(vt, comps) else: predict_skycomponent_visibility(vt, comps) insert_skycomponent(model, comps) self.comps = comps self.model = copy_image(model) self.empty_model = create_empty_image_like(model) export_image_to_fits( model, '%s/test_pipeline_functions_model.fits' % (self.dir)) if add_errors: # These will be the same for all calls numpy.random.seed(180555) gt = create_gaintable_from_blockvisibility(vt) gt = simulate_gaintable(gt, phase_error=1.0, amplitude_error=0.0) vt = apply_gaintable(vt, gt) if bandpass: bgt = create_gaintable_from_blockvisibility(vt, timeslice=1e5) bgt = simulate_gaintable(bgt, phase_error=0.01, amplitude_error=0.01, smooth_channels=4) vt = apply_gaintable(vt, bgt) return vt
#print("weight", block_vis.weight, numpy.sum(block_vis.weight)) #print("time", block_vis.time, numpy.sum(block_vis.time)) #print("integration_time", block_vis.integration_time, numpy.sum(block_vis.integration_time)) #print("nvis, size", block_vis.nvis, block_vis.size()) gt = create_gaintable_from_blockvisibility(block_vis) #print("np.sum(gt.data): ", numpy.sum(gt.data['gain'])) gt = simulate_gaintable(gt, phase_error=1.0) #print("np.sum(gt.data): ", numpy.sum(gt.data['gain'])) blockvis = apply_gaintable(block_vis, gt) #print("np.sum(blockvis.data): ", numpy.sum(blockvis.data['vis'])) model = create_image_from_visibility( block_vis, npixel=npixel, frequency=[numpy.average(frequency)], nchan=1, channel_bandwidth=[numpy.sum(channel_bandwidth)], cellsize=cellsize, phasecentre=phasecentre) #print("model sum, min, max, shape: ", numpy.sum(model.data), numpy.amin(model.data), numpy.amax(model.data), model.shape) print(qa_image(model, context='Blockvis model image')) export_image_to_fits(model, '%s/imaging-blockvis_model.fits' % (results_dir)) dirty, sumwt = invert_function(predicted_vis, model, vis_slices=vis_slices, dopsf=False, context='wstack')