def load_invert_and_deconvolve(c):
v1 = create_visibility_from_ms(input_vis[0], channum=[c])[0]
v2 = create_visibility_from_ms(input_vis[1], channum=[c])[0]
vf = append_visibility(v1, v2)
vf = convert_visibility_to_stokes(vf)
vf.configuration.diameter[...] = 35.0
rows = vis_select_uvrange(vf, 0.0, uvmax=uvmax)
v = create_visibility_from_rows(vf, rows)
pol_frame = PolarisationFrame("stokesIQUV")
m = create_image_from_visibility(v,
npixel=npixel,
cellsize=cellsize,
polarisation_frame=pol_frame)
if context == '2d':
d, sumwt = invert_2d(v, m, dopsf=False)
p, sumwt = invert_2d(v, m, dopsf=True)
else:
d, sumwt = invert_list_serial_workflow([v], [m],
context=context,
dopsf=False,
vis_slices=vis_slices)[0]
p, sumwt = invert_list_serial_workflow([v], [m],
context=context,
dopsf=True,
vis_slices=vis_slices)[0]
c, resid = deconvolve_cube(d,
p,
m,
threshold=0.01,
fracthresh=0.01,
window_shape='quarter',
niter=100,
gain=0.1,
algorithm='hogbom-complex')
r = restore_cube(c, p, resid, psfwidth=psfwidth)
return r
def actualSetup(self, nsources=None, nvoronoi=None):
n_workers = 8
# 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 = advice['npixels2']
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(
arl_path('data/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 = n_workers
future_vis = arlexecute.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_arlexecute_workflow(future_vis,
chunk,
context='2d',
docal=True)
work_vis = arlexecute.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])
local_dir=dask_dir)
times = numpy.array([-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0]) * (numpy.pi / 12.0)
frequency = numpy.array([4e8])
channel_bandwidth = numpy.array([25e6])
reffrequency = numpy.max(frequency)
phasecentre = SkyCoord(ra=+5 * u.deg, dec=20 * u.deg, frame='icrs', equinox='J2000')
vt = create_visibility(lowcore, times, frequency, channel_bandwidth=channel_bandwidth,
weight=1.0, phasecentre=phasecentre,
polarisation_frame=PolarisationFrame('stokesI'))
advice = advise_wide_field(vt, wprojection_planes=1)
vt.data['vis'] *= 0.0
npixel=256
model = create_image_from_visibility(vt, npixel=npixel, cellsize=6.8e-5, nchan=1,
polarisation_frame=PolarisationFrame('stokesI'))
centre = model.wcs.wcs.crpix-1
spacing_pixels = npixel // 8
log.info('Spacing in pixels = %s' % spacing_pixels)
spacing = model.wcs.wcs.cdelt * spacing_pixels
locations = [-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]
original_comps = []
# We calculate the source positions in pixels and then calculate the
# world coordinates to put in the skycomponent description
for iy in locations:
for ix in locations:
if ix >= iy:
p = int(round(centre[0] + ix * spacing_pixels * numpy.sign(model.wcs.wcs.cdelt[0]))), \
int(round(centre[1] + iy * spacing_pixels * numpy.sign(model.wcs.wcs.cdelt[1])))
sc = pixel_to_skycoord(p[0], p[1], model.wcs)
## frequency and channel_bandwidth are replicated and they have already
## been split
log.info('%d: predict finished in %f seconds' % (rank, end - start))
print('%d: predict finished in %f seconds' % (rank, end - start),
flush=True)
log.info('%d: About create image from visibility' % (rank))
sub_vis_list = numpy.array_split(vis_list, size)
sub_vis_list = comm.scatter(sub_vis_list, root=0)
sub_model_list = [
create_image_from_visibility(
sub_vis_list[f],
npixel=npixel,
frequency=[sub_frequency[rank][f]],
channel_bandwidth=[sub_channel_bandwidth[rank][f]],
cellsize=cellsize,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"))
for f, freq in enumerate(sub_frequency[rank])
]
def concat_tuples(list_of_tuples):
if len(list_of_tuples) < 2:
result_list = list_of_tuples
else:
result_list = list_of_tuples[0]
for l in list_of_tuples[1:]:
result_list += l
return result_list
for field, vt in enumerate(vis_list):
uvdist = numpy.sqrt(vt.data['uvw'][:, 0]**2 + vt.data['uvw'][:, 1]**2)
plt.clf()
plt.plot(uvdist, numpy.abs(vt.data['weight']), '.')
plt.xlabel('uvdist')
plt.ylabel('Amp Visibility')
plt.title('Field %d' % (field))
plt.show()
cellsize = 0.00001
model = create_image_from_visibility(
vis_list[0],
cellsize=cellsize,
npixel=512,
nchan=1,
frequency=[0.5 * (8435100000.0 + 8.4851e+09)],
channel_bandwidth=[1e8],
imagecentre=vis_list[0].phasecentre,
polarisation_frame=PolarisationFrame('stokesIQUV'))
mosaic = copy_image(model)
mosaicsens = copy_image(model)
work = copy_image(model)
for vt in vis_list:
channel_model = create_image_from_visibility(
vt,
cellsize=cellsize,
npixel=512,
nchan=1,
imagecentre=vis_list[0].phasecentre,
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
advice = advise_wide_field(vt, wprojection_planes=4)
# 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='r')
# plt.xlabel('U (wavelengths)')
# plt.ylabel('V (wavelengths)')
# plt.title("UV coverage")
# plt.savefig(storedir + '/UV_coverage.pdf', format='pdf')
# plt.show()
vt.data['vis'] *= 0.0
# print("*****************", vt.data['vis'])
model = create_image_from_visibility(vt, npixel=npixel, nchan=1, cellsize=cellsize,
polarisation_frame=PolarisationFrame('stokesI'))
centre = model.wcs.wcs.crpix - 1
spacing_pixels = npixel // 8
# For an observation for the Sun, the disk is about 34 arcmin, if total FOV is 60 arcmin, then
# the disk edge would be 34/60*8
log.info('Spacing in pixels = %s' % spacing_pixels)
spacing = model.wcs.wcs.cdelt * spacing_pixels
# locations = [-3.5, -2.5, -2.27, -1.5, -1., -0.5, 0.5, 1.0, 1.5, 2.0, 2.5, 3.5]
locations = [-3.5, -3.0, -2.3, -1.5, -0.5, 0.5, 1.5, 2.3, 3.0, 3.5]
original_comps = []
# We calculate the source positions in pixels and then calculate the
# world coordinates to put in the skycomponent description
for iy in locations:
for ix in locations:
if True: # ix >= iy:
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,
weight=1.0, phasecentre=phasecentre,
polarisation_frame=PolarisationFrame('stokesI'))
advice = advise_wide_field(vt, wprojection_planes=1)
# 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='r')
plt.xlabel('U (wavelengths)')
plt.ylabel('V (wavelengths)')
plt.title("UV coverage")
plt.savefig(results_dir+'/UV_coverage.pdf',format='pdf')
vt.data['vis'] *= 0.0
model = create_image_from_visibility(vt, npixel=npixel, npol=1, cellsize=cellsize)
spacing_pixels = npixel // facets
log.info('Spacing in pixels = %s' % spacing_pixels)
spacing = model.wcs.wcs.cdelt* spacing_pixels #180.0 * cellsize * spacing_pixels / numpy.pi
centers = -3.0, -2.0, -1.0, -0.5, +0.5, +1.0, 2.0, 3.0
comps = list()
for iy in centers:
for ix in centers:
pra = int(round(npixel // 2 + ix * spacing_pixels - 1))
pdec = int(round(npixel // 2 + iy * spacing_pixels - 1))
sc = pixel_to_skycoord(pra, pdec, model.wcs)
log.info("Component at (%f, %f) %s" % (pra, pdec, str(sc)))
comp = create_skycomponent(flux=flux, frequency=frequency, direction=sc,
polarisation_frame=PolarisationFrame("stokesI"))
comps.append(comp)
predict_skycomponent_visibility(vt, comps)