def create_blockvisibility_iterator(config: Configuration, times: numpy.array, frequency: numpy.array,
channel_bandwidth, phasecentre: SkyCoord, weight: float = 1,
polarisation_frame=PolarisationFrame('stokesI'), integration_time=1.0,
number_integrations=1, predict=predict_2d, model=None, components=None,
phase_error=0.0, amplitude_error=0.0, sleep=0.0, **kwargs):
""" Create a sequence of Visibilities and optionally predicting and coalescing
This is useful mainly for performing large simulations. Do something like::
vis_iter = create_blockvisibility_iterator(config, times, frequency, channel_bandwidth, phasecentre=phasecentre,
weight=1.0, integration_time=30.0, number_integrations=3)
for i, vis in enumerate(vis_iter):
if i == 0:
fullvis = vis
else:
fullvis = append_visibility(fullvis, vis)
:param config: Configuration of antennas
:param times: hour angles in radians
:param frequency: frequencies (Hz] Shape [nchan]
:param weight: weight of a single sample
:param phasecentre: phasecentre of observation
:param npol: Number of polarizations
:param integration_time: Integration time ('auto' or value in s)
:param number_integrations: Number of integrations to be created at each time.
:param model: Model image to be inserted
:param components: Components to be inserted
:param sleep_time: Time to sleep between yields
:return: Visibility
"""
for time in times:
actualtimes = time + numpy.arange(0, number_integrations) * integration_time * numpy.pi / 43200.0
bvis = create_blockvisibility(config, actualtimes, frequency=frequency, phasecentre=phasecentre, weight=weight,
polarisation_frame=polarisation_frame, integration_time=integration_time,
channel_bandwidth=channel_bandwidth)
if model is not None:
vis = predict(bvis, model, **kwargs)
bvis = convert_visibility_to_blockvisibility(vis)
if components is not None:
bvis = predict_skycomponent_visibility(bvis, components)
# Add phase errors
if phase_error > 0.0 or amplitude_error > 0.0:
gt = create_gaintable_from_blockvisibility(bvis)
gt = simulate_gaintable(gt=gt, phase_error=phase_error, amplitude_error=amplitude_error)
bvis = apply_gaintable(bvis, gt)
import time
time.sleep(sleep)
yield bvis
def predict_serial(vis, model: Image, context='2d', vis_slices=1, facets=1, overlap=0, taper=None,
**kwargs) -> Visibility:
"""Predict visibilities using algorithm specified by context
* 2d: Two-dimensional transform
* wstack: wstacking with either vis_slices or wstack (spacing between w planes) set
* wprojection: w projection with wstep (spacing between w places) set, also kernel='wprojection'
* timeslice: snapshot imaging with either vis_slices or timeslice set. timeslice='auto' does every time
* facets: Faceted imaging with facets facets on each axis
* facets_wprojection: facets AND wprojection
* facets_wstack: facets AND wstacking
* wprojection_wstack: wprojection and wstacking
:param vis:
:param model: Model image, used to determine image characteristics
:param context: Imaging context e.g. '2d', 'timeslice', etc.
:param inner: Inner loop 'vis'|'image'
:param kwargs:
:return:
"""
c = imaging_context(context)
vis_iter = c['vis_iterator']
predict = c['predict']
if not isinstance(vis, Visibility):
svis = convert_blockvisibility_to_visibility(vis)
else:
svis = vis
result = copy_visibility(vis, zero=True)
for rows in vis_iter(svis, vis_slices=vis_slices):
if numpy.sum(rows):
visslice = create_visibility_from_rows(svis, rows)
visslice.data['vis'][...] = 0.0
for dpatch in image_scatter_facets(model, facets=facets, overlap=overlap, taper=taper):
result.data['vis'][...] = 0.0
result = predict(visslice, dpatch, **kwargs)
svis.data['vis'][rows] += result.data['vis']
if not isinstance(vis, Visibility):
svis = convert_visibility_to_blockvisibility(svis)
return svis
gleam_model = create_low_test_image_from_gleam(
npixel=npixel,
frequency=frequency,
channel_bandwidth=channel_bandwidth,
cellsize=cellsize,
phasecentre=phasecentre,
flux_limit=1.0,
applybeam=True)
predicted_vis = predict_function(block_vis,
gleam_model,
vis_slices=51,
context='wstack')
#print("np.sum(predicted_vis.data): ", numpy.sum(predicted_vis.data['vis']))
block_vis = convert_visibility_to_blockvisibility(predicted_vis)
#print("np.sum(block_vis.data): ", numpy.sum(block_vis.data['vis']))
#print("nchan npol nants ", block_vis.nchan, block_vis.npol, block_vis.nants)
#print("uvw", block_vis.uvw, numpy.sum(block_vis.uvw))
#print("vis", block_vis.vis, numpy.sum(block_vis.vis))
#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)
def to_bvis(v, ov):
if isinstance(ov, BlockVisibility):
av = convert_visibility_to_blockvisibility(v)
return av
else:
return v
def test_export_ms(self):
if run_ms_tests == False:
return
msoutfile = arl_path("data/vis/Test_output.ms")
from astropy.coordinates import SkyCoord
from astropy import units as u
from wrappers.serial.image.operations import show_image, export_image_to_fits
from wrappers.serial.simulation.configurations import create_named_configuration
from wrappers.serial.simulation.testing_support import create_test_image
from wrappers.serial.imaging.base import create_image_from_visibility
from wrappers.serial.imaging.base import advise_wide_field
from workflows.serial.imaging.imaging_serial import invert_list_serial_workflow, predict_list_serial_workflow
from data_models.polarisation import PolarisationFrame
lowr3 = create_named_configuration('LOWBD2', rmax=750.0)
times = numpy.zeros([1])
frequency = numpy.array([1e8])
channelbandwidth = numpy.array([1e6])
phasecentre = SkyCoord(ra=+15.0 * u.deg, dec=-45.0 * u.deg, frame='icrs', equinox='J2000')
bvis = create_blockvisibility(lowr3, times, frequency, phasecentre=phasecentre,
weight=1.0, polarisation_frame=PolarisationFrame('stokesI'),
channel_bandwidth=channelbandwidth)
vt = convert_blockvisibility_to_visibility(bvis)
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']
m31image = create_test_image(frequency=frequency, cellsize=cellsize)
nchan, npol, ny, nx = m31image.data.shape
m31image.wcs.wcs.crval[0] = vt.phasecentre.ra.deg
m31image.wcs.wcs.crval[1] = vt.phasecentre.dec.deg
m31image.wcs.wcs.crpix[0] = float(nx // 2)
m31image.wcs.wcs.crpix[1] = float(ny // 2)
vt = predict_list_serial_workflow([vt], [m31image], context='2d')[0]
# uvdist = numpy.sqrt(vt.data['uvw'][:, 0] ** 2 + vt.data['uvw'][:, 1] ** 2)
#
# model = create_image_from_visibility(vt, cellsize=cellsize, npixel=512)
# dirty, sumwt = invert_list_serial_workflow([vt], [model], context='2d')[0]
# psf, sumwt = invert_list_serial_workflow([vt], [model], context='2d', dopsf=True)[0]
#
# 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))
# results_dir="/Users/f.wang"
# export_image_to_fits(dirty, '%s/imaging_dirty.fits' % (results_dir))
# export_image_to_fits(psf, '%s/imaging_psf.fits' % (results_dir))
v = convert_visibility_to_blockvisibility(vt)
vis_list=[]
vis_list.append(v)
export_blockvisility_to_ms(msoutfile, vis_list,source_name='M31')
