def test_phase_rotation(self):
self.vis = create_visibility(
self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame("stokesIQUV"))
self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
# Predict visibilities with new phase centre independently
ha_diff = -(self.compabsdirection.ra - self.phasecentre.ra).to(
u.rad).value
vispred = create_visibility(
self.lowcore,
self.times + ha_diff,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.compabsdirection,
weight=1.0,
polarisation_frame=PolarisationFrame("stokesIQUV"))
vismodel2 = predict_skycomponent_visibility(vispred, self.comp)
# Should yield the same results as rotation
rotatedvis = phaserotate_visibility(
self.vismodel, newphasecentre=self.compabsdirection, tangent=False)
assert_allclose(rotatedvis.vis, vismodel2.vis, rtol=1e-7)
assert_allclose(rotatedvis.uvw, vismodel2.uvw, rtol=1e-7)
def test_phase_rotation_stokesi(self):
# Define the component and give it some spectral behaviour
f = numpy.array([100.0])
self.flux = numpy.array([f, 0.8 * f, 0.6 * f])
# The phase centre is absolute and the component is specified relative (for now).
# This means that the component should end up at the position phasecentre+compredirection
self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-35.0 * u.deg, frame='icrs', equinox='J2000')
self.compabsdirection = SkyCoord(ra=+181.0 * u.deg, dec=-35.0 * u.deg, frame='icrs', equinox='J2000')
pcof = self.phasecentre.skyoffset_frame()
self.compreldirection = self.compabsdirection.transform_to(pcof)
self.comp = Skycomponent(direction=self.compreldirection, frequency=self.frequency, flux=self.flux,
polarisation_frame=PolarisationFrame("stokesI"))
self.vis = create_visibility(self.lowcore, self.times, self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre, weight=1.0,
polarisation_frame=PolarisationFrame("stokesI"))
self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
# Predict visibilities with new phase centre independently
ha_diff = -(self.compabsdirection.ra - self.phasecentre.ra).to(u.rad).value
vispred = create_visibility(self.lowcore, self.times + ha_diff, self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.compabsdirection, weight=1.0,
polarisation_frame=PolarisationFrame("stokesI"))
vismodel2 = predict_skycomponent_visibility(vispred, self.comp)
# Should yield the same results as rotation
rotatedvis = phaserotate_visibility(self.vismodel, newphasecentre=self.compabsdirection, tangent=False)
assert_allclose(rotatedvis.vis, vismodel2.vis, rtol=3e-6)
assert_allclose(rotatedvis.uvw, vismodel2.uvw, rtol=3e-6)
def test_readwriteblockvisibility(self):
self.vis = create_blockvisibility(
self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("linear"),
weight=1.0)
self.vis = predict_skycomponent_visibility(self.vis, self.comp)
export_blockvisibility_to_hdf5(
self.vis,
'%s/test_data_model_helpers_blockvisibility.hdf' % self.dir)
newvis = import_blockvisibility_from_hdf5(
'%s/test_data_model_helpers_blockvisibility.hdf' % self.dir)
for key in self.vis.data.dtype.fields:
assert numpy.max(
numpy.abs(newvis.data[key] - self.vis.data[key])) < 1e-15
assert numpy.array_equal(newvis.frequency, self.vis.frequency)
assert newvis.data.shape == self.vis.data.shape
assert numpy.max(numpy.abs(self.vis.vis - newvis.vis)) < 1e-15
assert numpy.max(numpy.abs(self.vis.uvw - newvis.uvw)) < 1e-15
assert numpy.abs(newvis.configuration.location.x.value -
self.vis.configuration.location.x.value) < 1e-15
assert numpy.abs(newvis.configuration.location.y.value -
self.vis.configuration.location.y.value) < 1e-15
assert numpy.abs(newvis.configuration.location.z.value -
self.vis.configuration.location.z.value) < 1e-15
assert numpy.max(
numpy.abs(newvis.configuration.xyz -
self.vis.configuration.xyz)) < 1e-15
def test_phase_rotation_identity(self):
self.vis = create_visibility(
self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame("stokesIQUV"))
self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
newphasecenters = [
SkyCoord(182, -35, unit=u.deg),
SkyCoord(182, -30, unit=u.deg),
SkyCoord(177, -30, unit=u.deg),
SkyCoord(176, -35, unit=u.deg),
SkyCoord(216, -35, unit=u.deg),
SkyCoord(180, -70, unit=u.deg)
]
for newphasecentre in newphasecenters:
# Phase rotating back should not make a difference
original_vis = self.vismodel.vis
original_uvw = self.vismodel.uvw
rotatedvis = phaserotate_visibility(phaserotate_visibility(
self.vismodel, newphasecentre, tangent=False),
self.phasecentre,
tangent=False)
assert_allclose(rotatedvis.uvw, original_uvw, rtol=1e-7)
assert_allclose(rotatedvis.vis, original_vis, rtol=1e-7)
def test_fit_visibility(self):
# Sum the visibilities in the correct_visibility direction. This is limited by numerical precision
methods = [
'CG', 'BFGS', 'Powell', 'trust-ncg', 'trust-exact', 'trust-krylov'
]
for method in methods:
self.actualSetup()
self.vis = create_visibility(
self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame("stokesI"))
self.vismodel = predict_skycomponent_visibility(
self.vis, self.comp)
initial_comp = Skycomponent(
direction=self.comp_start_direction,
frequency=self.frequency,
flux=2.0 * self.flux,
polarisation_frame=PolarisationFrame("stokesI"))
sc, res = fit_visibility(self.vismodel,
initial_comp,
niter=200,
tol=1e-5,
method=method,
verbose=False)
# print(method, res)
assert sc.direction.separation(self.comp_actual_direction).to('rad').value < 1e-6, \
sc.direction.separation(self.comp_actual_direction).to('rad')
def test_readwritevisibility(self):
self.vis = create_visibility(
self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("linear"),
weight=1.0)
self.vis = predict_skycomponent_visibility(self.vis, self.comp)
export_visibility_to_hdf5(self.vis,
'%s/test_visibility.hdf' % self.dir)
newvis = import_visibility_from_hdf5('%s/test_visibility.hdf' %
self.dir)
assert str(newvis) == str(
self.vis), "Original %s, import %s" % (str(newvis), str(self.vis))
assert numpy.array_equal(newvis.frequency, self.vis.frequency)
assert newvis.data.shape == self.vis.data.shape
assert numpy.array_equal(newvis.frequency, self.vis.frequency)
assert numpy.max(numpy.abs(self.vis.vis - newvis.vis)) < 1e-15
assert numpy.max(numpy.abs(self.vis.uvw - newvis.uvw)) < 1e-15
assert numpy.abs(newvis.configuration.location.x.value -
self.vis.configuration.location.x.value) < 1e-15
assert numpy.abs(newvis.configuration.location.y.value -
self.vis.configuration.location.y.value) < 1e-15
assert numpy.abs(newvis.configuration.location.z.value -
self.vis.configuration.location.z.value) < 1e-15
assert numpy.max(
numpy.abs(newvis.configuration.xyz -
self.vis.configuration.xyz)) < 1e-15
def test_sum_visibility(self):
self.vis = create_visibility(self.lowcore, self.times, self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("linear"),
weight=1.0)
self.vis = predict_skycomponent_visibility(self.vis, self.comp)
flux, weight = sum_visibility(self.vis, self.comp.direction)
assert numpy.max(numpy.abs(flux - self.flux)) < 1e-7
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 test_insert_skycomponent_dft(self):
self.sc = create_skycomponent(direction=self.phasecentre, flux=self.sc.flux,
frequency=self.component_frequency,
polarisation_frame=PolarisationFrame('stokesI'))
self.vis.data['vis'][...] = 0.0
self.vis = predict_skycomponent_visibility(self.vis, self.sc)
im, sumwt = invert_2d(self.vis, self.model)
export_image_to_fits(im, '%s/test_skycomponent_dft.fits' % self.dir)
assert numpy.max(numpy.abs(self.vis.vis.imag)) < 1e-3
def test_qa(self):
self.vis = create_visibility(self.lowcore, self.times, self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre, weight=1.0,
polarisation_frame=PolarisationFrame("stokesIQUV"))
self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
qa = qa_visibility(self.vis, context='test_qa')
self.assertAlmostEqual(qa.data['maxabs'], 100.0, 7)
self.assertAlmostEqual(qa.data['medianabs'], 11.0, 7)
assert qa.context == 'test_qa'
def actualSetUp(self, freqwin=1, block=True, dopol=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 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 freqwin > 1:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
freqwin * [self.frequency[1] - self.frequency[0]])
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
self.frequency = numpy.array([1e8])
self.channelwidth = numpy.array([1e6])
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.bvis = ingest_unittest_visibility(self.low,
self.frequency,
self.channelwidth,
self.times,
self.vis_pol,
self.phasecentre,
block=block)
self.vis = convert_blockvisibility_to_visibility(self.bvis)
self.model = create_unittest_model(self.vis,
self.image_pol,
npixel=self.npixel,
nchan=freqwin)
self.components = create_unittest_components(self.model, flux)
self.model = insert_skycomponent(self.model, self.components)
self.bvis = predict_skycomponent_visibility(self.bvis, self.components)
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)
export_image_to_fits(self.model, '%s/test_imaging_model.fits' % self.dir)
export_image_to_fits(self.cmodel, '%s/test_imaging_cmodel.fits' % self.dir)
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)
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)
def test_visibilitysum(self):
self.vis = create_visibility(
self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame("stokesIQUV"))
self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
# Sum the visibilities in the correct_visibility direction. This is limited by numerical precision
summedflux, weight = sum_visibility(self.vismodel,
self.compreldirection)
assert_allclose(self.flux, summedflux, rtol=1e-7)
def solve_image_arlexecute(vis: Visibility, model: Image, components=None, context='2d', **kwargs) -> \
(Visibility, Image, Image):
"""Solve for image using deconvolve_cube and specified predict, invert
This is the same as a majorcycle/minorcycle algorithm. The components are removed prior to deconvolution.
See also arguments for predict, invert, deconvolve_cube functions.2d
:param vis:
:param model: Model image
:param predict: Predict function e.g. predict_2d, predict_wstack
:param invert: Invert function e.g. invert_2d, invert_wstack
:return: Visibility, model
"""
nmajor = get_parameter(kwargs, 'nmajor', 5)
thresh = get_parameter(kwargs, "threshold", 0.0)
log.info("solve_image_arlexecute: Performing %d major cycles" % nmajor)
# The model is added to each major cycle and then the visibilities are
# calculated from the full model
vispred = copy_visibility(vis, zero=True)
visres = copy_visibility(vis, zero=True)
vispred = predict_arlexecute(vispred, model, context=context, **kwargs)
if components is not None:
vispred = predict_skycomponent_visibility(vispred, components)
visres.data['vis'] = vis.data['vis'] - vispred.data['vis']
dirty, sumwt = invert_arlexecute(visres, model, context=context, dopsf=False, **kwargs)
assert sumwt.any() > 0.0, "Sum of weights is zero"
psf, sumwt = invert_arlexecute(visres, model, context=context, dopsf=True, **kwargs)
assert sumwt.any() > 0.0, "Sum of weights is zero"
for i in range(nmajor):
log.info("solve_image_arlexecute: Start of major cycle %d" % i)
cc, res = deconvolve_cube(dirty, psf, **kwargs)
model.data += cc.data
vispred.data['vis'][...]=0.0
vispred = predict_arlexecute(vispred, model, context=context, **kwargs)
visres.data['vis'] = vis.data['vis'] - vispred.data['vis']
dirty, sumwt = invert_arlexecute(visres, model, context=context, dopsf=False, **kwargs)
if numpy.abs(dirty.data).max() < 1.1 * thresh:
log.info("Reached stopping threshold %.6f Jy" % thresh)
break
log.info("solve_image_arlexecute: End of minor cycles")
log.info("solve_image_arlexecute: End of major cycles")
return visres, model, dirty
def test_phase_rotation_inverse(self):
self.vis = create_visibility(self.lowcore, self.times, self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre, weight=1.0,
polarisation_frame=PolarisationFrame("stokesIQUV"))
self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
there = SkyCoord(ra=+250.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000')
# Phase rotating back should not make a difference
original_vis = self.vismodel.vis
original_uvw = self.vismodel.uvw
rotatedvis = phaserotate_visibility(phaserotate_visibility(self.vismodel, there, tangent=False,
inverse=True),
self.phasecentre, tangent=False, inverse=True)
assert_allclose(rotatedvis.uvw, original_uvw, rtol=1e-7)
assert_allclose(rotatedvis.vis, original_vis, rtol=1e-7)
def actualSetup(self,
sky_pol_frame='stokesIQUV',
data_pol_frame='linear',
f=None,
vnchan=1):
self.lowcore = create_named_configuration('LOWBD2-CORE')
self.times = (numpy.pi / 43200.0) * numpy.linspace(0.0, 30.0, 3)
self.frequency = numpy.linspace(1.0e8, 1.1e8, vnchan)
if vnchan > 1:
self.channel_bandwidth = numpy.array(
vnchan * [self.frequency[1] - self.frequency[0]])
else:
self.channel_bandwidth = numpy.array([2e7])
if f is None:
f = [100.0, 50.0, -10.0, 40.0]
if sky_pol_frame == 'stokesI':
f = [100.0]
self.flux = numpy.outer(
numpy.array(
[numpy.power(freq / 1e8, -0.7) for freq in self.frequency]), f)
# The phase centre is absolute and the component is specified relative (for now).
# This means that the component should end up at the position phasecentre+compredirection
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.compabsdirection = SkyCoord(ra=+181.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.comp = Skycomponent(
direction=self.compabsdirection,
frequency=self.frequency,
flux=self.flux,
polarisation_frame=PolarisationFrame(sky_pol_frame))
self.vis = create_blockvisibility(
self.lowcore,
self.times,
self.frequency,
phasecentre=self.phasecentre,
channel_bandwidth=self.channel_bandwidth,
weight=1.0,
polarisation_frame=PolarisationFrame(data_pol_frame))
self.vis = predict_skycomponent_visibility(self.vis, self.comp)
def test_predict_sky_components_coalesce(self):
sc = create_low_test_skycomponents_from_gleam(flux_limit=10.0,
polarisation_frame=PolarisationFrame("stokesI"),
frequency=self.frequency, kind='cubic',
phasecentre=SkyCoord("17h20m31s", "-00d58m45s"),
radius=0.1)
self.config = create_named_configuration('LOWBD2-CORE')
self.phasecentre = SkyCoord("17h20m31s", "-00d58m45s")
sampling_time = 3.76
self.times = numpy.arange(0.0, + 300 * sampling_time, sampling_time)
self.vis = create_blockvisibility(self.config, self.times, self.frequency, phasecentre=self.phasecentre,
weight=1.0, polarisation_frame=PolarisationFrame('stokesI'),
channel_bandwidth=self.channel_bandwidth)
self.vis = predict_skycomponent_visibility(self.vis, sc)
cvt = convert_blockvisibility_to_visibility(self.vis)
assert cvt.cindex is not None
def test_readwriteblockvisibility(self):
self.vis = create_blockvisibility(
self.midcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("linear"),
weight=1.0,
meta={"ARL": 0.0})
self.vis = predict_skycomponent_visibility(self.vis, self.comp)
config = {
"buffer": {
"directory": self.dir
},
"vislist": {
"name": "test_bufferblockvisibility.hdf",
"data_model": "BlockVisibility"
}
}
bdm = BufferBlockVisibility(config["buffer"], config["vislist"],
self.vis)
bdm.sync()
new_bdm = BufferBlockVisibility(config["buffer"], config["vislist"])
new_bdm.sync()
newvis = bdm.memory_data_model
assert isinstance(newvis, BlockVisibility)
assert numpy.array_equal(newvis.frequency, self.vis.frequency)
assert newvis.data.shape == self.vis.data.shape
assert numpy.max(numpy.abs(self.vis.vis - newvis.vis)) < 1e-15
assert numpy.max(numpy.abs(self.vis.uvw - newvis.uvw)) < 1e-15
assert numpy.abs(newvis.configuration.location.x.value -
self.vis.configuration.location.x.value) < 1e-15
assert numpy.abs(newvis.configuration.location.y.value -
self.vis.configuration.location.y.value) < 1e-15
assert numpy.abs(newvis.configuration.location.z.value -
self.vis.configuration.location.z.value) < 1e-15
assert numpy.max(
numpy.abs(newvis.configuration.xyz -
self.vis.configuration.xyz)) < 1e-15
assert newvis.meta == self.vis.meta
def rcal(vis: BlockVisibility, components, **kwargs) -> GainTable:
""" Real-time calibration pipeline.
Reads visibilities through a BlockVisibility iterator, calculates model visibilities according to a
component-based sky model, and performs calibration solution, writing a gaintable for each chunk of
visibilities.
:param vis: Visibility or Union(Visibility, Iterable)
:param components: Component-based sky model
:param kwargs: Parameters
:return: gaintable
"""
if not isinstance(vis, collections.Iterable):
vis = [vis]
for ichunk, vischunk in enumerate(vis):
vispred = copy_visibility(vischunk, zero=True)
vispred = predict_skycomponent_visibility(vispred, components)
gt = solve_gaintable(vischunk, vispred, **kwargs)
yield gt
def actualSetup(self, sky_pol_frame='stokesIQUV', data_pol_frame='linear'):
self.lowcore = create_named_configuration('LOWBD2', rmax=300.0)
self.times = (numpy.pi / 43200.0) * numpy.arange(0.0, 300.0, 30.0)
vnchan = 3
self.frequency = numpy.linspace(1.0e8, 1.1e8, vnchan)
self.channel_bandwidth = numpy.array(
vnchan * [self.frequency[1] - self.frequency[0]])
# Define the component and give it some spectral behaviour
f = numpy.array([100.0, 20.0, -10.0, 1.0])
self.flux = numpy.array([f, 0.8 * f, 0.6 * f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.compabsdirection = SkyCoord(ra=+181.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
if sky_pol_frame == 'stokesI':
self.flux = self.flux[:, 0][:, numpy.newaxis]
self.comp = Skycomponent(
direction=self.compabsdirection,
frequency=self.frequency,
flux=self.flux,
polarisation_frame=PolarisationFrame(sky_pol_frame))
self.vis = create_blockvisibility(
self.lowcore,
self.times,
self.frequency,
phasecentre=self.phasecentre,
channel_bandwidth=self.channel_bandwidth,
weight=1.0,
polarisation_frame=PolarisationFrame(data_pol_frame))
self.vis = predict_skycomponent_visibility(self.vis, self.comp)
def actualSetup(self,
vnchan=1,
doiso=True,
ntimes=5,
flux_limit=2.0,
zerow=True,
fixed=False):
nfreqwin = vnchan
rmax = 300.0
npixel = 512
cellsize = 0.001
frequency = numpy.linspace(0.8e8, 1.2e8, nfreqwin)
if nfreqwin > 1:
channel_bandwidth = numpy.array(nfreqwin *
[frequency[1] - frequency[0]])
else:
channel_bandwidth = [0.4e8]
times = numpy.linspace(-numpy.pi / 3.0, numpy.pi / 3.0, ntimes)
phasecentre = SkyCoord(ra=-60.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
lowcore = create_named_configuration('LOWBD2', rmax=rmax)
block_vis = create_blockvisibility(
lowcore,
times,
frequency=frequency,
channel_bandwidth=channel_bandwidth,
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
zerow=zerow)
block_vis.data['uvw'][..., 2] = 0.0
self.beam = create_image_from_visibility(
block_vis,
npixel=npixel,
frequency=[numpy.average(frequency)],
nchan=nfreqwin,
channel_bandwidth=[numpy.sum(channel_bandwidth)],
cellsize=cellsize,
phasecentre=phasecentre)
self.components = create_low_test_skycomponents_from_gleam(
flux_limit=flux_limit,
phasecentre=phasecentre,
frequency=frequency,
polarisation_frame=PolarisationFrame('stokesI'),
radius=npixel * cellsize)
self.beam = create_low_test_beam(self.beam)
self.components = apply_beam_to_skycomponent(self.components,
self.beam,
flux_limit=flux_limit)
self.vis = copy_visibility(block_vis, zero=True)
gt = create_gaintable_from_blockvisibility(block_vis, timeslice='auto')
for i, sc in enumerate(self.components):
if sc.flux[0, 0] > 10:
sc.flux[...] /= 10.0
component_vis = copy_visibility(block_vis, zero=True)
gt = simulate_gaintable(gt,
amplitude_error=0.0,
phase_error=0.1,
seed=None)
component_vis = predict_skycomponent_visibility(component_vis, sc)
component_vis = apply_gaintable(component_vis, gt)
self.vis.data['vis'][...] += component_vis.data['vis'][...]
# Do an isoplanatic selfcal
self.model_vis = copy_visibility(self.vis, zero=True)
self.model_vis = predict_skycomponent_visibility(
self.model_vis, self.components)
if doiso:
gt = solve_gaintable(self.vis,
self.model_vis,
phase_only=True,
timeslice='auto')
self.vis = apply_gaintable(self.vis, gt, inverse=True)
self.model_vis = convert_blockvisibility_to_visibility(self.model_vis)
self.model_vis, _, _ = weight_visibility(self.model_vis, self.beam)
self.dirty_model, sumwt = invert_function(self.model_vis,
self.beam,
context='2d')
export_image_to_fits(self.dirty_model,
"%s/test_skymodel-model_dirty.fits" % self.dir)
lvis = convert_blockvisibility_to_visibility(self.vis)
lvis, _, _ = weight_visibility(lvis, self.beam)
dirty, sumwt = invert_function(lvis, self.beam, context='2d')
if doiso:
export_image_to_fits(
dirty, "%s/test_skymodel-initial-iso-residual.fits" % self.dir)
else:
export_image_to_fits(
dirty,
"%s/test_skymodel-initial-noiso-residual.fits" % self.dir)
self.skymodels = [
SkyModel(components=[cm], fixed=fixed) for cm in self.components
]
def ical_serial(block_vis: BlockVisibility,
model: Image,
components=None,
context='2d',
controls=None,
**kwargs):
""" Post observation image, deconvolve, and self-calibrate
:param vis:
:param model: Model image
:param components: Initial components
:param context: Imaging context
:param controls: calibration controls dictionary
:return: model, residual, restored
"""
nmajor = get_parameter(kwargs, 'nmajor', 5)
log.info("ical_serial: Performing %d major cycles" % nmajor)
do_selfcal = get_parameter(kwargs, "do_selfcal", False)
if controls is None:
controls = create_calibration_controls(**kwargs)
# The model is added to each major cycle and then the visibilities are
# calculated from the full model
vis = convert_blockvisibility_to_visibility(block_vis)
block_vispred = copy_visibility(block_vis, zero=True)
vispred = convert_blockvisibility_to_visibility(block_vispred)
vispred.data['vis'][...] = 0.0
visres = copy_visibility(vispred)
vispred = predict_serial(vispred, model, context=context, **kwargs)
if components is not None:
vispred = predict_skycomponent_visibility(vispred, components)
if do_selfcal:
vis, gaintables = calibrate_function(vis,
vispred,
'TGB',
controls,
iteration=-1)
visres.data['vis'] = vis.data['vis'] - vispred.data['vis']
dirty, sumwt = invert_serial(visres, model, context=context, **kwargs)
log.info("Maximum in residual image is %.6f" %
(numpy.max(numpy.abs(dirty.data))))
psf, sumwt = invert_serial(visres,
model,
dopsf=True,
context=context,
**kwargs)
thresh = get_parameter(kwargs, "threshold", 0.0)
for i in range(nmajor):
log.info("ical_serial: Start of major cycle %d of %d" % (i, nmajor))
cc, res = deconvolve_cube(dirty, psf, **kwargs)
model.data += cc.data
vispred.data['vis'][...] = 0.0
vispred = predict_serial(vispred, model, context=context, **kwargs)
if do_selfcal:
vis, gaintables = calibrate_function(vis,
vispred,
'TGB',
controls,
iteration=i)
visres.data['vis'] = vis.data['vis'] - vispred.data['vis']
dirty, sumwt = invert_serial(visres, model, context=context, **kwargs)
log.info("Maximum in residual image is %s" %
(numpy.max(numpy.abs(dirty.data))))
if numpy.abs(dirty.data).max() < 1.1 * thresh:
log.info("ical_serial: Reached stopping threshold %.6f Jy" %
thresh)
break
log.info("ical_serial: End of major cycle")
log.info("ical_serial: End of major cycles")
restored = restore_cube(model, psf, dirty, **kwargs)
return model, dirty, restored
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
