channel_bandwidth=channel_bandwidth,
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
zerow=True)
vis = convert_blockvisibility_to_visibility(block_vis)
advice = advise_wide_field(vis, guard_band_image=2.0, delA=0.02)
cellsize = advice['cellsize']
vis_slices = advice['vis_slices']
npixel = advice['npixels2']
small_model = create_image_from_visibility(block_vis,
npixel=512,
frequency=frequency,
nchan=nfreqwin,
cellsize=cellsize,
phasecentre=phasecentre)
vis.data['imaging_weight'][...] = vis.data['weight'][...]
vis = weight_list_serial_workflow([vis], [small_model])[0]
vis = taper_list_serial_workflow([vis], 3 * cellsize)[0]
block_vis = convert_visibility_to_blockvisibility(vis)
#######################################################################################################
### Generate the component model from the GLEAM catalog, including application of the primary beam. Read the
# phase screen and calculate the gaintable for each component.
flux_limit = args.flux_limit
beam = create_image_from_visibility(block_vis,
npixel=npixel,
log.setLevel(logging.DEBUG)
log.addHandler(logging.StreamHandler(sys.stdout))
log.addHandler(logging.StreamHandler(sys.stderr))
if __name__ == '__main__':
results_dir = rascil_path('test_results')
bvt = create_blockvisibility_from_ms(rascil_path('data/vis/sim-2.ms'), start_chan=35, end_chan=39)[0]
bvt.configuration.diameter[...] = 35.0
vt = convert_blockvisibility_to_visibility(bvt)
vt = convert_visibility_to_stokes(vt)
a2r = numpy.pi / (180.0 * 3600.0)
model = create_image_from_visibility(vt, cellsize=20.0 * a2r, npixel=512,
polarisation_frame=PolarisationFrame('stokesIQUV'))
dirty, sumwt = invert_list_serial_workflow([vt], [model], context='2d')[0]
psf, sumwt = invert_list_serial_workflow([vt], [model], context='2d', dopsf=True)[0]
export_image_to_fits(dirty, '%s/rascil_imaging_sim_2_dirty.fits' % (results_dir))
export_image_to_fits(psf, '%s/rascil_imaging_sim_2_psf.fits' % (results_dir))
# Deconvolve using msclean
comp, residual = deconvolve_cube(dirty, psf, niter=10000, threshold=0.001,
fractional_threshold=0.001,
algorithm='msclean',
window_shape='quarter', gain=0.7,
scales=[0, 3, 10, 30])
restored = restore_cube(comp, psf, residual)
print(qa_image(restored))
plt.plot(-vt.data['uvw'][:, 0], -vt.data['uvw'][:, 1], '.', color='b')
# plt.xlim([-400.0, 400.0])
# plt.ylim([-400.0, 400.0])
plt.show()
# To check that we got the prediction right, plot the amplitude of the visibility.
uvdist = numpy.sqrt(vt.data['uvw'][:, 0]**2 + vt.data['uvw'][:, 1]**2)
plt.clf()
plt.plot(uvdist, numpy.abs(vt.data['vis']), '.')
plt.xlabel('uvdist')
plt.ylabel('Amp Visibility')
plt.show()
model = create_image_from_visibility(
vt,
cellsize=cellsize,
npixel=1024,
polarisation_frame=PolarisationFrame('stokesIV'))
dirty, sumwt = invert_2d(vt, model, context='2d')
psf, sumwt = invert_2d(vt, model, context='2d', dopsf=True)
dirty = show_image(dirty)
dirty.show()
show_image(psf)
# 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.fits'%(results_dir))
# export_image_to_fits(psf, '%s/imaging_psf.fits'%(results_dir))
def actualSetup(self, nsources=None, nvoronoi=None):
# Set up the observation: 10 minutes at transit, with 10s integration.
# Skip 5/6 points to avoid outstation redundancy
nfreqwin = 1
ntimes = 3
self.rmax = 2500.0
dec = -40.0 * u.deg
frequency = [1e8]
channel_bandwidth = [0.1e8]
times = numpy.linspace(-10.0, 10.0, ntimes) * numpy.pi / (3600.0 * 12.0)
phasecentre = SkyCoord(ra=+0.0 * u.deg, dec=dec, frame='icrs', equinox='J2000')
low = create_named_configuration('LOWBD2', rmax=self.rmax)
centre = numpy.mean(low.xyz, axis=0)
distance = numpy.hypot(low.xyz[:, 0] - centre[0],
low.xyz[:, 1] - centre[1],
low.xyz[:, 2] - centre[2])
lowouter = low.data[distance > 1000.0][::6]
lowcore = low.data[distance < 1000.0][::3]
low.data = numpy.hstack((lowcore, lowouter))
blockvis = create_blockvisibility(low, times, frequency=frequency, channel_bandwidth=channel_bandwidth,
weight=1.0, phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"), zerow=True)
vis = convert_blockvisibility_to_visibility(blockvis)
advice = advise_wide_field(vis, guard_band_image=2.0, delA=0.02)
cellsize = advice['cellsize']
npixel = 512
small_model = create_image_from_visibility(
blockvis,
npixel=512,
frequency=frequency,
nchan=nfreqwin,
cellsize=cellsize,
phasecentre=phasecentre)
vis.data['imaging_weight'][...] = vis.data['weight'][...]
vis = weight_list_serial_workflow([vis], [small_model])[0]
vis = taper_list_serial_workflow([vis], 3 * cellsize)[0]
blockvis = convert_visibility_to_blockvisibility(vis)
# ### Generate the model from the GLEAM catalog, including application of the primary beam.
beam = create_image_from_visibility(blockvis, npixel=npixel, frequency=frequency,
nchan=nfreqwin, cellsize=cellsize, phasecentre=phasecentre)
beam = create_low_test_beam(beam, use_local=False)
flux_limit = 0.5
original_gleam_components = create_low_test_skycomponents_from_gleam(flux_limit=flux_limit,
phasecentre=phasecentre,
frequency=frequency,
polarisation_frame=PolarisationFrame(
'stokesI'),
radius=0.15)
all_components = apply_beam_to_skycomponent(original_gleam_components, beam)
all_components = filter_skycomponents_by_flux(all_components, flux_min=flux_limit)
voronoi_components = filter_skycomponents_by_flux(all_components, flux_min=1.5)
def max_flux(elem):
return numpy.max(elem.flux)
voronoi_components = sorted(voronoi_components, key=max_flux, reverse=True)
if nsources is not None:
all_components = [all_components[0]]
if nvoronoi is not None:
voronoi_components = [voronoi_components[0]]
self.screen = import_image_from_fits(rascil_data_path('models/test_mpc_screen.fits'))
all_gaintables = create_gaintable_from_screen(blockvis, all_components,
self.screen)
gleam_skymodel_noniso = [SkyModel(components=[all_components[i]], gaintable=all_gaintables[i])
for i, sm in enumerate(all_components)]
# ### Now predict the visibility for each skymodel and apply the gaintable for that skymodel,
# returning a list of visibilities, one for each skymodel. We then sum these to obtain
# the total predicted visibility. All images and skycomponents in the same skymodel
# get the same gaintable applied which means that in this case each skycomponent has a separate gaintable.
self.all_skymodel_noniso_vis = convert_blockvisibility_to_visibility(blockvis)
ngroup = 8
future_vis = rsexecute.scatter(self.all_skymodel_noniso_vis)
chunks = [gleam_skymodel_noniso[i:i + ngroup] for i in range(0, len(gleam_skymodel_noniso), ngroup)]
for chunk in chunks:
result = predict_skymodel_list_rsexecute_workflow(future_vis, chunk, context='2d', docal=True)
work_vis = rsexecute.compute(result, sync=True)
for w in work_vis:
self.all_skymodel_noniso_vis.data['vis'] += w.data['vis']
assert numpy.max(numpy.abs(self.all_skymodel_noniso_vis.data['vis'])) > 0.0
self.all_skymodel_noniso_blockvis = convert_visibility_to_blockvisibility(self.all_skymodel_noniso_vis)
# ### Remove weaker of components that are too close (0.02 rad)
idx, voronoi_components = remove_neighbouring_components(voronoi_components, 0.02)
model = create_image_from_visibility(blockvis, npixel=npixel, frequency=frequency,
nchan=nfreqwin, cellsize=cellsize, phasecentre=phasecentre)
# Use the gaintable for the brightest component as the starting gaintable
all_gaintables[0].gain[...] = numpy.conjugate(all_gaintables[0].gain[...])
all_gaintables[0].gain[...] = 1.0 + 0.0j
self.theta_list = initialize_skymodel_voronoi(model, voronoi_components, all_gaintables[0])
advice = advise_wide_field(vt,
guard_band_image=3.0,
delA=0.1,
oversampling_synthesised_beam=4.0)
cellsize = advice['cellsize']
# Read the venerable test image, constructing a RASCIL Image
m31image = create_test_image(frequency=frequency,
cellsize=cellsize,
phasecentre=vt.phasecentre)
# Predict the visibility for the Image
vt = predict_2d(vt, m31image, context='2d')
# Make the dirty image and point spread function
model = create_image_from_visibility(vt, cellsize=cellsize, npixel=512)
dirty, sumwt = invert_2d(vt, model, context='2d')
psf, sumwt = invert_2d(vt, model, context='2d', dopsf=True)
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.fits' % (results_dir))
export_image_to_fits(psf, '%s/imaging_psf.fits' % (results_dir))
# Deconvolve using clean
comp, residual = deconvolve_cube(dirty,
psf,
niter=10000,