lowouter = low.data[distance > 1000.0][::6]
lowcore = low.data[distance < 1000.0][::3]
low.data = numpy.hstack((lowcore, lowouter))
block_vis = 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(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]
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])
baseline.append([29, i])
baseline.append([[32, 29], [33, 29], [34, 29], [35, 29], [36, 29],
[37, 29], [38, 29], [39, 29]])
for i in range(29):
baseline.append([30, i])
baseline.append([[32, 30], [33, 30], [34, 30], [35, 30], [36, 30],
[37, 30], [38, 30], [39, 30]])
bvis = flagging_blockvisibility_with_bl(bvis, baseline)
return bvis
# %%
bvis_list = [rsexecute.execute(flag)(bv) for bv in bvis_list]
bvis_list = rsexecute.compute(bvis_list, sync=True)
print(bvis_list[0])
advice = advise_wide_field(bvis_list[-1], guard_band_image=0.5)
cellsize = advice["cellsize"]
npixel = advice["npixels2"]
def read_sun_disk_data():
sundisk_file_path = "quietsundisk400_2000MHz.txt"
sundisk_file = open(sundisk_file_path, "r")
sundisk_dict = {}
try:
while True:
linekey = sundisk_file.readline()
linevalue = sundisk_file.readline()
if linekey and linevalue:
linekey = str(int(float(linekey.strip())))
value = list(map(eval, linevalue.strip().split(',')[1:]))
# baseline = [ [4,0],[4,1],[5,4],[21,4],[24,4],[25,4],[26,4],[27,4],[28,4],[29,4],[30,4],[31,4],[32,4],[36,4],[38,4],[39,4]]
# baseline.append([[17,4],[17,13],[19,17],[26,17],[27,17],[28,17],[29,17],[30,17],[31,17],[39,17]])
# bvis = flagging_blockvisibility_with_bl(vis[0],baseline)
#
# vis_list = []
# vis_list.append(bvis)
# # Output results
# export_file_name = muser_output_path('ms_flag_test') + '.ms'
#
# export_blockvisibility_to_ms(export_file_name, vis_list, source_name='SUN')
# Flagging
vt = convert_blockvisibility_to_visibility(bvis)
advice = advise_wide_field(vt,
guard_band_image=3.0,
delA=0.1,
oversampling_synthesised_beam=4.0)
cellsize = advice['cellsize']
plt.clf()
plt.plot(vt.data['uvw'][:, 0], vt.data['uvw'][:, 1], '.', color='b')
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')
results_dir = rascil_path('test_results')
# Construct LOW core configuration
lowr3 = create_named_configuration('LOWBD2', rmax=750.0)
# We create the visibility. This just makes the uvw, time, antenna1, antenna2, weight columns in a table
times = numpy.zeros([1])
frequency = numpy.array([1e8])
channel_bandwidth = numpy.array([1e6])
phasecentre = SkyCoord(ra=+15.0 * u.deg, dec=-45.0 * u.deg, frame='icrs', equinox='J2000')
vt = create_visibility(lowr3, times, frequency, channel_bandwidth=channel_bandwidth,
weight=1.0, phasecentre=phasecentre, polarisation_frame=PolarisationFrame('stokesI'))
# Find the recommended imaging parameters
advice = advise_wide_field(vt, guard_band_image=3.0, delA=0.1, facets=1, wprojection_planes=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))