def show_skymodel(sms, psf_width=1.75, cm='Greys', vmax=None, vmin=None):
""" Show a list of SkyModels
:param sms: List of SkyModels
:param psf_width: Width of PSF in pixels
:param cm: matplotlib colormap
:param vmax: Maximum in image display
:param vmin: Minimum in image display
:return:
"""
sp = 1
for ism, sm in enumerate(sms):
plt.clf()
plt.subplot(121, projection=sms[ism].image.wcs.sub([1, 2]))
sp += 1
smodel = copy_image(sms[ism].image)
smodel = insert_skycomponent(smodel, sms[ism].components)
smodel = smooth_image(smodel, psf_width)
if vmax is None:
vmax = numpy.max(smodel.data[0, 0, ...])
if vmin is None:
vmin = numpy.min(smodel.data[0, 0, ...])
plt.imshow(smodel.data[0, 0, ...],
origin='lower',
cmap=cm,
vmax=vmax,
vmin=vmin)
plt.xlabel(sms[ism].image.wcs.wcs.ctype[0])
plt.ylabel(sms[ism].image.wcs.wcs.ctype[1])
plt.title('SkyModel%d' % ism)
components = sms[ism].components
if components is not None:
for sc in components:
x, y = skycoord_to_pixel(sc.direction, sms[ism].image.wcs, 0,
'wcs')
plt.plot(x, y, marker='+', color='red')
gaintable = sms[ism].gaintable
if gaintable is not None:
plt.subplot(122)
sp += 1
phase = numpy.angle(sm.gaintable.gain[:, :, 0, 0, 0])
phase -= phase[:, 0][:, numpy.newaxis]
plt.imshow(phase, origin='lower')
plt.xlabel('Dish/Station')
plt.ylabel('Integration')
plt.show()
def actualSetUp(self,
add_errors=False,
freqwin=3,
block=True,
dospectral=True,
dopol=False,
zerow=False,
makegcfcf=False):
self.npixel = 256
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.bvis_list = list()
self.ntimes = 5
self.cellsize = 0.0005
# Choose the interval so that the maximum change in w is smallish
integration_time = numpy.pi * (24 / (12 * 60))
self.times = numpy.linspace(-integration_time * (self.ntimes // 2),
integration_time * (self.ntimes // 2),
self.ntimes)
if freqwin > 1:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.frequency = numpy.array([1.0e8])
self.channelwidth = numpy.array([4e7])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.bvis_list = [
ingest_unittest_visibility(
self.low,
numpy.array([self.frequency[freqwin]]),
numpy.array([self.channelwidth[freqwin]]),
self.times,
self.vis_pol,
self.phasecentre,
block=block,
zerow=zerow) for freqwin, _ in enumerate(self.frequency)
]
self.model_list = [
create_unittest_model(self.bvis_list[freqwin],
self.image_pol,
cellsize=self.cellsize,
npixel=self.npixel)
for freqwin, _ in enumerate(self.frequency)
]
self.components_list = [
create_unittest_components(self.model_list[freqwin],
flux[freqwin, :][numpy.newaxis, :],
single=False)
for freqwin, _ in enumerate(self.frequency)
]
self.model_list = [
insert_skycomponent(self.model_list[freqwin],
self.components_list[freqwin])
for freqwin, _ in enumerate(self.frequency)
]
self.bvis_list = [
dft_skycomponent_visibility(self.bvis_list[freqwin],
self.components_list[freqwin])
for freqwin, _ in enumerate(self.frequency)
]
centre = self.freqwin // 2
# Calculate the model convolved with a Gaussian.
self.model = self.model_list[centre]
self.cmodel = smooth_image(self.model)
if self.persist:
export_image_to_fits(self.model,
'%s/test_imaging_model.fits' % self.dir)
if self.persist:
export_image_to_fits(self.cmodel,
'%s/test_imaging_cmodel.fits' % self.dir)
if add_errors and block:
self.bvis_list = [
insert_unittest_errors(self.bvis_list[i])
for i, _ in enumerate(self.frequency)
]
self.components = self.components_list[centre]
if makegcfcf:
self.gcfcf = [
create_awterm_convolutionfunction(self.model,
nw=61,
wstep=16.0,
oversampling=8,
support=64,
use_aaf=True)
]
self.gcfcf_clipped = [
(self.gcfcf[0][0],
apply_bounding_box_convolutionfunction(self.gcfcf[0][1],
fractional_level=1e-3))
]
self.gcfcf_joint = [
create_awterm_convolutionfunction(self.model,
nw=11,
wstep=16.0,
oversampling=8,
support=64,
use_aaf=True)
]
else:
self.gcfcf = None
self.gcfcf_clipped = None
self.gcfcf_joint = None
def actualSetUp(self,
add_errors=False,
freqwin=7,
block=False,
dospectral=True,
dopol=False,
zerow=True):
self.npixel = 256
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.vis_list = list()
self.ntimes = 5
cellsize = 0.001
self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
if freqwin > 1:
self.channelwidth = numpy.array(
freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.channelwidth = numpy.array([1e6])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis_list = [
ingest_unittest_visibility(self.low, [self.frequency[freqwin]],
[self.channelwidth[freqwin]],
self.times,
self.vis_pol,
self.phasecentre,
block=block,
zerow=zerow)
for freqwin, _ in enumerate(self.frequency)
]
self.model_imagelist = [
create_unittest_model(self.vis_list[freqwin],
self.image_pol,
cellsize=cellsize,
npixel=self.npixel)
for freqwin, _ in enumerate(self.frequency)
]
self.componentlist = [
create_unittest_components(self.model_imagelist[freqwin],
flux[freqwin, :][numpy.newaxis, :])
for freqwin, _ in enumerate(self.frequency)
]
self.model_imagelist = [
insert_skycomponent(self.model_imagelist[freqwin],
self.componentlist[freqwin])
for freqwin, _ in enumerate(self.frequency)
]
self.vis_list = [
dft_skycomponent_visibility(self.vis_list[freqwin],
self.componentlist[freqwin])
for freqwin, _ in enumerate(self.frequency)
]
# Calculate the model convolved with a Gaussian.
model = self.model_imagelist[0]
self.cmodel = smooth_image(model)
if self.persist:
export_image_to_fits(
model,
'%s/test_imaging_serial_deconvolved_model.fits' % self.dir)
if self.persist:
export_image_to_fits(
self.cmodel,
'%s/test_imaging_serial_deconvolved_cmodel.fits' % self.dir)
if add_errors and block:
self.vis_list = [
insert_unittest_errors(self.vis_list[i])
for i, _ in enumerate(self.frequency)
]
def actualSetUp(self, zerow=True):
self.doplot = False
self.npixel = 256
self.cellsize = 0.0009
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = 1
self.vis_list = list()
self.ntimes = 3
self.times = numpy.linspace(-2.0, +2.0, self.ntimes) * numpy.pi / 12.0
if self.freqwin == 1:
self.frequency = numpy.array([1e8])
self.channelwidth = numpy.array([4e7])
else:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
self.freqwin * [self.frequency[1] - self.frequency[0]])
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis = ingest_unittest_visibility(self.low,
self.frequency,
self.channelwidth,
self.times,
self.vis_pol,
self.phasecentre,
block=False,
zerow=zerow)
self.model = create_unittest_model(self.vis,
self.image_pol,
cellsize=self.cellsize,
npixel=self.npixel,
nchan=self.freqwin)
self.components = create_unittest_components(self.model,
flux,
applypb=False,
scale=0.5,
single=False,
symmetric=True)
self.model = insert_skycomponent(self.model, self.components)
self.vis = predict_skycomponent_visibility(self.vis, self.components)
# Calculate the model convolved with a Gaussian.
self.cmodel = smooth_image(self.model)
if self.persist:
export_image_to_fits(self.model,
'%s/test_gridding_model.fits' % self.dir)
export_image_to_fits(self.cmodel,
'%s/test_gridding_cmodel.fits' % self.dir)
pb = create_pb_generic(self.model,
diameter=35.0,
blockage=0.0,
use_local=False)
self.cmodel.data *= pb.data
if self.persist:
export_image_to_fits(self.cmodel,
'%s/test_gridding_cmodel_pb.fits' % self.dir)
self.peak = numpy.unravel_index(
numpy.argmax(numpy.abs(self.cmodel.data)), self.cmodel.shape)
vis = convert_blockvisibility_to_visibility(blockvis)
model = create_unittest_model(vis, image_pol, npixel=npixel, nchan=freqwin)
components = create_unittest_components(model, flux)
model = insert_skycomponent(model, components)
blockvis = predict_skycomponent_visibility(blockvis, components)
#blockvis = dft_skycomponent_visibility(blockvis, components)
blockvis1 = copy_visibility(blockvis)
vis1 = convert_blockvisibility_to_visibility(blockvis1)
# Calculate the model convolved with a Gaussian.
cmodel = smooth_image(model)
if persist: export_image_to_fits(model, '%s/test_imaging_2d_model.fits' % rdir)
if persist:
export_image_to_fits(cmodel, '%s/test_imaging_2d_cmodel.fits' % rdir)
# In[4]:
print(qa_image(model))
# In[5]:
plt.rcParams['figure.figsize'] = 10, 10
show_image(cmodel)
plt.savefig("cmodel.png")
# In[6]:
def actualSetUp(self,
add_errors=False,
nfreqwin=7,
dospectral=True,
dopol=False,
zerow=True):
self.npixel = 512
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = nfreqwin
self.vis_list = list()
self.ntimes = 5
self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
if self.freqwin > 1:
self.channelwidth = numpy.array(
self.freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.channelwidth = numpy.array([1e6])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, 0.0, 0.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.blockvis_list = \
[rsexecute.execute(ingest_unittest_visibility, nout=1)(self.low,
[self.frequency[i]],
[self.channelwidth[i]],
self.times,
self.vis_pol,
self.phasecentre, block=True,
zerow=zerow)
for i in range(nfreqwin)]
self.blockvis_list = rsexecute.compute(self.blockvis_list, sync=True)
self.blockvis_list = rsexecute.scatter(self.blockvis_list)
self.vis_list = [
rsexecute.execute(convert_blockvisibility_to_visibility,
nout=1)(bv) for bv in self.blockvis_list
]
self.vis_list = rsexecute.compute(self.vis_list, sync=True)
self.vis_list = rsexecute.scatter(self.vis_list)
self.model_imagelist = [
rsexecute.execute(create_unittest_model,
nout=1)(self.vis_list[i],
self.image_pol,
npixel=self.npixel,
cellsize=0.0005) for i in range(nfreqwin)
]
self.model_imagelist = rsexecute.compute(self.model_imagelist,
sync=True)
self.model_imagelist = rsexecute.scatter(self.model_imagelist)
self.components_list = [
rsexecute.execute(create_unittest_components)(
self.model_imagelist[freqwin],
flux[freqwin, :][numpy.newaxis, :])
for freqwin, m in enumerate(self.model_imagelist)
]
self.components_list = rsexecute.compute(self.components_list,
sync=True)
self.components_list = rsexecute.scatter(self.components_list)
self.blockvis_list = [
rsexecute.execute(dft_skycomponent_visibility)(
self.blockvis_list[freqwin], self.components_list[freqwin])
for freqwin, _ in enumerate(self.blockvis_list)
]
self.blockvis_list = rsexecute.compute(self.blockvis_list, sync=True)
self.vis = self.blockvis_list[0]
self.blockvis_list = rsexecute.scatter(self.blockvis_list)
self.model_imagelist = [
rsexecute.execute(insert_skycomponent,
nout=1)(self.model_imagelist[freqwin],
self.components_list[freqwin])
for freqwin in range(nfreqwin)
]
self.model_imagelist = rsexecute.compute(self.model_imagelist,
sync=True)
model = self.model_imagelist[0]
self.cmodel = smooth_image(model)
if self.persist:
export_image_to_fits(
model, '%s/test_pipelines_rsexecute_model.fits' % self.dir)
export_image_to_fits(
self.cmodel,
'%s/test_pipelines_rsexecute_cmodel.fits' % self.dir)
if add_errors:
gt = create_gaintable_from_blockvisibility(self.vis)
gt = simulate_gaintable(gt,
phase_error=0.1,
amplitude_error=0.0,
smooth_channels=1,
leakage=0.0)
self.blockvis_list = [
rsexecute.execute(apply_gaintable,
nout=1)(self.blockvis_list[i], gt)
for i in range(self.freqwin)
]
self.blockvis_list = rsexecute.compute(self.blockvis_list,
sync=True)
self.blockvis_list = rsexecute.scatter(self.blockvis_list)
self.vis_list = [
rsexecute.execute(convert_blockvisibility_to_visibility)(bv)
for bv in self.blockvis_list
]
self.vis_list = rsexecute.compute(self.vis_list, sync=True)
self.vis_list = rsexecute.scatter(self.vis_list)
self.model_imagelist = [
rsexecute.execute(create_unittest_model,
nout=1)(self.vis_list[i],
self.image_pol,
npixel=self.npixel,
cellsize=0.0005) for i in range(nfreqwin)
]
self.model_imagelist = rsexecute.compute(self.model_imagelist,
sync=True)
self.model_imagelist = rsexecute.scatter(self.model_imagelist)
def actualSetUp(self,
freqwin=1,
block=False,
dospectral=True,
dopol=False,
zerow=False):
self.npixel = 512
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.vis = list()
self.ntimes = 5
self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0
if freqwin > 1:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.frequency = numpy.array([1e8])
self.channelwidth = numpy.array([1e6])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis = ingest_unittest_visibility(self.low, [self.frequency],
[self.channelwidth],
self.times,
self.vis_pol,
self.phasecentre,
block=block,
zerow=zerow)
self.model = create_unittest_model(self.vis,
self.image_pol,
npixel=self.npixel)
self.components = create_unittest_components(self.model, flux)
self.model = insert_skycomponent(self.model, self.components)
self.vis = predict_skycomponent_visibility(self.vis, self.components)
# Calculate the model convolved with a Gaussian.
self.cmodel = smooth_image(self.model)
if self.persist:
export_image_to_fits(self.model,
'%s/test_imaging_model.fits' % self.dir)
if self.persist:
export_image_to_fits(self.cmodel,
'%s/test_imaging_cmodel.fits' % self.dir)
def test_smooth_image(self):
smooth = smooth_image(self.m31image)
assert numpy.max(smooth.data) > numpy.max(self.m31image.data)