def main():
dlg_string = os.environ['DLG_UID']
dlg_string = dlg_string[(dlg_string.rindex('_') + 1):len(dlg_string)]
dlg_uid = dlg_string.split('/')
Freq_Iteration = int(dlg_uid[1]) # derived from ID
Facet_Iteration = int(dlg_uid[2]) # derived from ID
vt = load(1)
phasecentre_array = [[+15, -45], [+15.2, -45], [+15, -44], [+14.8, -45],
[+15, -46]]
phasecentre = SkyCoord(ra=phasecentre_array[Facet_Iteration][0] * u.deg,
dec=phasecentre_array[Facet_Iteration][1] * u.deg,
frame='icrs',
equinox='J2000')
model = create_image_from_visibility(vt,
phasecentre=phasecentre,
cellsize=0.001,
npixel=256)
dirty, sumwt = invert_function(vt, model)
psf, sumwt = invert_function(vt, model, dopsf=True)
#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))
export_image_to_fits(
dirty, '%s/imaging_dirty_%02d_%02d.fits' %
(results_dir, Freq_Iteration, Facet_Iteration))
export_image_to_fits(
psf, '%s/imaging_psf_%02d_%02d.fits' %
(results_dir, Freq_Iteration, Facet_Iteration))
# Deconvolve using clean
comp, residual = deconvolve_cube(dirty,
psf,
niter=1000,
threshold=0.001,
fracthresh=0.01,
window_shape='quarter',
gain=0.7,
scales=[0, 3, 10, 30])
restored = restore_cube(comp, psf, residual)
export_image_to_fits(
restored, '%s/imaging_clean%02d_%02d.fits' %
(results_dir, Freq_Iteration, Facet_Iteration))
dump(2, restored)
def test_skymodel_solve_fixed(self):
self.actualSetup(ntimes=1, doiso=True, fixed=True)
calskymodel, residual_vis = calskymodel_solve(self.vis,
self.skymodels,
niter=30,
gain=0.25)
# Check that the components are unchanged
calskymodel_skycomponents = list()
for sm in [csm[0] for csm in calskymodel]:
for comp in sm.components:
calskymodel_skycomponents.append(comp)
recovered_components = find_skycomponent_matches(
calskymodel_skycomponents, self.components, 1e-5)
for p in recovered_components:
assert numpy.abs(calskymodel_skycomponents[p[0]].flux[0, 0] -
self.components[p[1]].flux[0, 0]) < 1e-15
assert calskymodel_skycomponents[p[0]].direction.separation(
self.components[p[1]].direction).rad < 1e-15
residual_vis = convert_blockvisibility_to_visibility(residual_vis)
residual_vis, _, _ = weight_visibility(residual_vis, self.beam)
dirty, sumwt = invert_function(residual_vis, self.beam, context='2d')
export_image_to_fits(
dirty, "%s/test_skymodel-final-iso-residual.fits" % self.dir)
qa = qa_image(dirty)
assert qa.data['rms'] < 3.4e-3, qa
def _invert_base(self,
context,
extra='',
fluxthreshold=1.0,
positionthreshold=1.0,
check_components=True,
facets=1,
vis_slices=1,
**kwargs):
dirty = invert_function(self.vis,
self.model,
context=context,
dopsf=False,
normalize=True,
facets=facets,
vis_slices=vis_slices,
**kwargs)
export_image_to_fits(
dirty[0], '%s/test_imaging_invert_%s%s_dirty.fits' %
(self.dir, context, extra))
assert numpy.max(numpy.abs(dirty[0].data)), "Image is empty"
if check_components:
self._checkcomponents(dirty[0], fluxthreshold, positionthreshold)
def _predict_base(self,
context='2d',
extra='',
fluxthreshold=1.0,
facets=1,
vis_slices=1,
**kwargs):
vis = copy_visibility(self.vis)
vis.data['vis'][...] = 0
vis = predict_function(vis,
self.model,
context=context,
vis_slices=vis_slices,
facets=facets,
**kwargs)
vis.data['vis'][...] -= self.vis.data['vis'][...]
dirty = invert_function(vis,
self.model,
context='2d',
dopsf=False,
normalize=True)
assert numpy.max(numpy.abs(dirty[0].data)), "Residual image is empty"
export_image_to_fits(
dirty[0], '%s/test_imaging_predict_%s%s_dirty.fits' %
(self.dir, context, extra))
maxabs = numpy.max(numpy.abs(dirty[0].data))
assert maxabs < fluxthreshold, "Error %.3f greater than fluxthreshold %.3f " % (
maxabs, fluxthreshold)
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_function(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_skymodel_solve_noiso(self):
self.actualSetup(ntimes=1, doiso=False)
calskymodel, residual_vis = calskymodel_solve(self.vis,
self.skymodels,
niter=30,
gain=0.25)
residual_vis = convert_blockvisibility_to_visibility(residual_vis)
residual_vis, _, _ = weight_visibility(residual_vis, self.beam)
dirty, sumwt = invert_function(residual_vis, self.beam, context='2d')
export_image_to_fits(
dirty, "%s/test_skymodel-final-noiso-residual.fits" % self.dir)
qa = qa_image(dirty)
assert qa.data['rms'] < 3.8e-3, qa
def test_calskymodel_solve_workflow(self):
self.actualSetup(doiso=True)
self.skymodel_list = [
arlexecute.execute(SkyModel, nout=1)(components=[cm])
for cm in self.components
]
calskymodel_list = calskymodel_solve_workflow(
self.vis, skymodel_list=self.skymodel_list, niter=30, gain=0.25)
skymodel, residual_vis = arlexecute.compute(calskymodel_list,
sync=True)
residual_vis = convert_blockvisibility_to_visibility(residual_vis)
residual_vis, _, _ = weight_visibility(residual_vis, self.beam)
dirty, sumwt = invert_function(residual_vis, self.beam, context='2d')
export_image_to_fits(
dirty, "%s/test_calskymodel-%s-final-iso-residual.fits" %
(self.dir, arlexecute.type()))
qa = qa_image(dirty)
assert qa.data['rms'] < 3.2e-3, qa
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
]
block_vis,
npixel=npixel,
frequency=[numpy.average(frequency)],
nchan=1,
channel_bandwidth=[numpy.sum(channel_bandwidth)],
cellsize=cellsize,
phasecentre=phasecentre)
#print("model sum, min, max, shape: ", numpy.sum(model.data), numpy.amin(model.data), numpy.amax(model.data), model.shape)
print(qa_image(model, context='Blockvis model image'))
export_image_to_fits(model, '%s/imaging-blockvis_model.fits' % (results_dir))
dirty, sumwt = invert_function(predicted_vis,
model,
vis_slices=vis_slices,
dopsf=False,
context='wstack')
print(qa_image(dirty, context='Dirty image'))
export_image_to_fits(dirty, '%s/imaging-dirty.fits' % (results_dir))
deconvolved, residual, restored = ical(block_vis=blockvis,
model=model,
vis_slices=vis_slices,
timeslice='auto',
algorithm='hogbom',
niter=1000,
fractional_threshold=0.1,
threshold=0.1,
context='wstack',
