def _predict_base(self,
context='2d',
extra='',
fluxthreshold=1.0,
facets=1,
vis_slices=1,
gcfcf=None,
**kwargs):
centre = self.freqwin // 2
vis_list = zero_list_serial_workflow(self.vis_list)
vis_list = predict_list_serial_workflow(vis_list,
self.model_list,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
vis_list = subtract_list_serial_workflow(self.vis_list, vis_list)
dirty = invert_list_serial_workflow(vis_list,
self.model_list,
context='2d',
dopsf=False,
gcfcf=gcfcf,
normalize=True)[centre]
assert numpy.max(numpy.abs(dirty[0].data)), "Residual image is empty"
export_image_to_fits(
dirty[0], '%s/test_imaging_predict_%s%s_serial_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_deconvolve_and_restore_cube_mmclean(self):
self.actualSetUp(add_errors=True)
dirty_imagelist = invert_list_serial_workflow(self.vis_list,
self.model_imagelist,
context='2d',
dopsf=False,
normalize=True)
psf_imagelist = invert_list_serial_workflow(self.vis_list,
self.model_imagelist,
context='2d',
dopsf=True,
normalize=True)
dec_imagelist = deconvolve_list_serial_workflow(
dirty_imagelist,
psf_imagelist,
self.model_imagelist,
niter=1000,
fractional_threshold=0.01,
scales=[0, 3, 10],
algorithm='mmclean',
nmoment=3,
nchan=self.freqwin,
threshold=0.1,
gain=0.7)
residual_imagelist = residual_list_serial_workflow(
self.vis_list, model_imagelist=dec_imagelist, context='2d')
restored = restore_list_serial_workflow(
model_imagelist=dec_imagelist,
psf_imagelist=psf_imagelist,
residual_imagelist=residual_imagelist,
empty=self.model_imagelist)[0]
export_image_to_fits(
restored,
'%s/test_imaging_serial_mmclean_restored.fits' % (self.dir))
def _invert_base(self,
context,
extra='',
fluxthreshold=1.0,
positionthreshold=1.0,
check_components=True,
facets=1,
vis_slices=1,
gcfcf=None,
**kwargs):
centre = self.freqwin // 2
dirty = invert_list_serial_workflow(self.vis_list,
self.model_list,
context=context,
dopsf=False,
normalize=True,
facets=facets,
vis_slices=vis_slices,
gcfcf=gcfcf,
**kwargs)[centre]
export_image_to_fits(
dirty[0], '%s/test_imaging_invert_%s%s_serial_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 test_deconvolve_spectral(self):
self.actualSetUp(add_errors=True)
dirty_imagelist = invert_list_serial_workflow(self.vis_list, self.model_imagelist,
context='2d',
dopsf=False, normalize=True)
psf_imagelist = invert_list_serial_workflow(self.vis_list, self.model_imagelist,
context='2d',
dopsf=True, normalize=True)
deconvolved, _ = deconvolve_list_serial_workflow(dirty_imagelist, psf_imagelist, self.model_imagelist, niter=1000,
fractional_threshold=0.1, scales=[0, 3, 10],
threshold=0.1, gain=0.7)
export_image_to_fits(deconvolved[0], '%s/test_imaging_serial_deconvolve_spectral.fits' %
(self.dir))
def test_continuum_imaging_pipeline(self):
self.actualSetUp(add_errors=False, zerow=True)
clean, residual, restored = \
continuum_imaging_list_serial_workflow(self.vis_list,
model_imagelist=self.model_imagelist,
context='2d',
algorithm='mmclean', facets=1,
scales=[0, 3, 10],
niter=1000, fractional_threshold=0.1, threshold=0.1,
nmoment=3,
nmajor=5, gain=0.1,
deconvolve_facets=4, deconvolve_overlap=32,
deconvolve_taper='tukey', psf_support=64)
centre = len(clean) // 2
if self.persist:
export_image_to_fits(
clean[centre],
'%s/test_pipelines_continuum_imaging_pipeline_serial_clean.fits'
% self.dir)
export_image_to_fits(
residual[centre][0],
'%s/test_pipelines_continuum_imaging_pipeline_serial_residual.fits'
% self.dir)
export_image_to_fits(
restored[centre],
'%s/test_pipelines_continuum_imaging_pipeline_serial_restored.fits'
% self.dir)
qa = qa_image(restored[centre])
assert numpy.abs(qa.data['max'] - 100.13762476849081) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.03627273884170454) < 1.0, str(qa)
def test_ical_pipeline_global(self):
self.actualSetUp(add_errors=True)
controls = create_calibration_controls()
controls['T']['first_selfcal'] = 1
controls['T']['timescale'] = 'auto'
clean, residual, restored, gt_list = \
ical_list_serial_workflow(self.vis_list,
model_imagelist=self.model_imagelist,
context='2d',
algorithm='mmclean', facets=1,
scales=[0, 3, 10],
niter=1000, fractional_threshold=0.1, threshold=0.1,
nmoment=3,
nmajor=5, gain=0.1,
deconvolve_facets=4, deconvolve_overlap=32,
deconvolve_taper='tukey', psf_support=64,
calibration_context='T', controls=controls, do_selfcal=True,
global_solution=True)
centre = len(clean) // 2
if self.persist:
export_image_to_fits(clean[centre], '%s/test_pipelines_ical_global_pipeline_serial_clean.fits' % self.dir)
export_image_to_fits(residual[centre][0], '%s/test_pipelines_ical_global_pipeline_serial_residual.fits' % self.dir)
export_image_to_fits(restored[centre], '%s/test_pipelines_ical_global_pipeline_serial_restored.fits' % self.dir)
export_gaintable_to_hdf5(gt_list[0]['T'],
'%s/test_pipelines_ical_global_pipeline_serial_gaintable.hdf5' %
self.dir)
qa = qa_image(restored[centre])
assert numpy.abs(qa.data['max'] - 98.92656340122159) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.7024492707920869) < 1.0, str(qa)
def _predict_base(self,
context='2d',
extra='',
fluxthreshold=1.0,
facets=1,
vis_slices=1,
**kwargs):
vis_list = zero_list_mpi_workflow(self.vis_list)
vis_list = predict_list_mpi_workflow(vis_list,
self.model_list,
context=context,
vis_slices=vis_slices,
facets=facets,
**kwargs)
vis_list = subtract_list_mpi_workflow(self.vis_list, vis_list)
if self.rank == 0:
vis_list = vis_list[0]
model_list = self.model_list[0]
else:
vis_list = list()
model_list = list()
dirty = invert_list_mpi_workflow([vis_list], [model_list],
context='2d',
dopsf=False,
normalize=True)
if self.rank == 0:
dirty = dirty[0]
if self.rank == 0:
assert numpy.max(numpy.abs(
dirty[0].data)), "Residual image is empty"
export_image_to_fits(
dirty[0], '%s/test_imaging_predict_%s%s_serial_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_ical_pipeline(self):
amp_errors = {'T': 0.0, 'G': 0.00, 'B': 0.0}
phase_errors = {'T': 0.1, 'G': 0.0, 'B': 0.0}
self.actualSetUp(add_errors=True,
block=True,
amp_errors=amp_errors,
phase_errors=phase_errors)
controls = create_calibration_controls()
controls['T']['first_selfcal'] = 1
controls['G']['first_selfcal'] = 3
controls['B']['first_selfcal'] = 4
controls['T']['timescale'] = 'auto'
controls['G']['timescale'] = 'auto'
controls['B']['timescale'] = 1e5
clean, residual, restored = \
ical_list_serial_workflow(self.vis_list, model_imagelist=self.model_imagelist, context='2d',
calibration_context='T', controls=controls, do_selfcal=True,
global_solution=False,
algorithm='mmclean',
facets=1,
scales=[0, 3, 10],
niter=1000, fractional_threshold=0.1,
nmoments=2, nchan=self.freqwin,
threshold=2.0, nmajor=5, gain=0.1,
deconvolve_facets=8, deconvolve_overlap=16, deconvolve_taper='tukey')
centre = len(clean) // 2
export_image_to_fits(
clean[centre],
'%s/test_pipelines_ical_pipeline_clean.fits' % self.dir)
export_image_to_fits(
residual[centre][0],
'%s/test_pipelines_ical_pipeline_residual.fits' % self.dir)
export_image_to_fits(
restored[centre],
'%s/test_pipelines_ical_pipeline_restored.fits' % self.dir)
qa = qa_image(restored[centre])
assert numpy.abs(qa.data['max'] - 100.13739440876233) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.03644435471804354) < 1.0, str(qa)
def actualSetUp(self,
add_errors=False,
freqwin=3,
block=False,
dospectral=True,
dopol=False,
zerow=False,
makegcfcf=False):
self.npixel = 256
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.vis_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.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_list = [
create_unittest_model(self.vis_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=True)
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.vis_list = [
predict_skycomponent_visibility(self.vis_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)
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)
if add_errors and block:
self.vis_list = [
insert_unittest_errors(self.vis_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
else:
future = invert_list_arlexecute_workflow(vt_list, targetimage_list, context=context)
result = arlexecute.compute(future, sync=True)
targetimage = result[0][0]
show_image(targetimage)
plt.title(context)
plt.savefig('2_'+context+'.jpg')
#plt.show()
print("Dirty Image %s" % qa_image(targetimage, context="imaging-fits notebook, using processor %s" % context))
export_image_to_fits(targetimage, '%s/imaging-fits_dirty_%s.fits' % (results_dir, context))
comps = find_skycomponents(targetimage, fwhm=1.0, threshold=10.0, npixels=5)
plt.clf()
for comp in comps:
distance = comp.direction.separation(model.phasecentre)
dft_flux = sum_visibility(vt, comp.direction)[0]
err = (comp.flux[0, 0] - dft_flux) / dft_flux
plt.plot(distance, err, '.', color='r')
plt.ylabel('Fractional error of image vs DFT')
plt.xlabel('Distance from phasecentre (deg)')
plt.title(
"Fractional error in %s recovered flux vs distance from phasecentre" %
context)
plt.savefig('3_'+context+'.jpg')
# plt.show()
# In[ ]:
end = time.time()
log.info('%d: invert finished' % (rank))
print('%d: invert finished in %f seconds' % (rank, end - start), flush=True)
if rank == 0:
#print("sumwts",flush=True)
#print(dirty_list[0][1])
log.info('After invert to get dirty image')
dirty = dirty_list[0][0]
#show_image(dirty, cm='Greys', vmax=1.0, vmin=-0.1)
#plt.show()
print(qa_image(dirty))
export_image_to_fits(dirty, '%s/imaging-dirty.fits' % (results_dir))
log.info('After invert to get PSF')
psf = psf_list[0][0]
#show_image(psf, cm='Greys', vmax=0.1, vmin=-0.01)
#plt.show()
print(qa_image(psf))
export_image_to_fits(psf, '%s/imaging-psf.fits' % (results_dir))
# Now deconvolve using msclean
# In[ ]:
log.info('%d: About to run deconvolve' % (rank))
print('%d: About to run deconvolve' % (rank), flush=True)
start = time.time()
dirty = create_image_from_visibility(vt, npixel=npixel, cellsize=cellsize,
polarisation_frame=PolarisationFrame("stokesI"))
vt = weight_visibility(vt, dirty)
future = invert_list_arlexecute_workflow([vt], [dirty], context='2d')
dirty, sumwt = arlexecute.compute(future, sync=True)[0]
if doplot:
show_image(dirty,cm='hot')
plt.title("Dirty image")
plt.savefig('%s/%s_dirty.pdf' % (results_dir, str(freq)))
print("Max, min in dirty image = %.6f, %.6f, sumwt = %f" % (dirty.data.max(), dirty.data.min(), sumwt))
export_image_to_fits(dirty, '%s/imaging-wterm_dirty.fits' % (results_dir))
dirtyFacet = create_image_from_visibility(vt, npixel=npixel, npol=1, cellsize=cellsize)
future = invert_list_arlexecute_workflow([vt], [dirtyFacet], facets=4, context='facets')
dirtyFacet, sumwt = arlexecute.compute(future, sync=True)[0]
dirtyFacet = smooth_image(dirtyFacet)
if doplot:
show_image(dirtyFacet,cm='hot')
plt.title("Smoothed model image")
plt.savefig('%s/%s_smooth.pdf' % (results_dir, str(freq)))
print(
"Max, min in dirty image = %.6f, %.6f, sumwt = %f" % (dirtyFacet.data.max(), dirtyFacet.data.min(), sumwt))
export_image_to_fits(dirtyFacet, '%s/imaging-wterm_dirtyFacet.fits' % (results_dir))
dirtyFacet2 = create_image_from_visibility(vt, npixel=npixel, npol=1, cellsize=cellsize)
context='wstack',
vis_slices=vis_slices,
dopsf=False)
psf_list = invert_list_mpi_workflow(predicted_vislist,
model_list,
context='wstack',
vis_slices=vis_slices,
dopsf=True)
# Create and execute graphs to make the dirty image and PSF
# In[ ]:
if rank == 0:
print("sumwts", flush=True)
print(dirty_list[0][1])
log.info('About to run invert to get dirty image')
dirty = dirty_list[0][0]
#show_image(dirty, cm='Greys', vmax=1.0, vmin=-0.1)
#plt.show()
print(qa_image(dirty))
export_image_to_fits(dirty, '%s/imaging-dirty.fits' % (results_dir))
log.info('About to run invert to get PSF')
psf = psf_list[0][0]
#show_image(psf, cm='Greys', vmax=0.1, vmin=-0.01)
#plt.show()
print(qa_image(psf))
export_image_to_fits(psf, '%s/imaging-psf.fits' % (results_dir))
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 = [predict_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)
export_image_to_fits(model, '%s/test_imaging_serial_deconvolved_model.fits' % self.dir)
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 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
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
print('About assemble cubes and deconvolve each frequency')
restored_list = [load_invert_and_deconvolve(c) for c in range(nchan)]
restored_cube = image_gather_channels(restored_list)
print("Processing took %.3f s" % (time.time() - start))
print(qa_image(restored_cube, context='CLEAN restored cube'))
export_image_to_fits(
restored_cube, '%s/dprepb_serial_%s_clean_restored_cube.fits' %
(results_dir, context))
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, -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.blockvis_list = [ingest_unittest_visibility(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.vis_list = [convert_blockvisibility_to_visibility(bv) for bv in self.blockvis_list]
self.model_imagelist = [
create_unittest_model(self.vis_list[i], self.image_pol, npixel=self.npixel, cellsize=0.0005)
for i in range(nfreqwin)]
self.components_list = [create_unittest_components(self.model_imagelist[freqwin],
flux[freqwin, :][numpy.newaxis, :])
for freqwin, m in enumerate(self.model_imagelist)]
self.blockvis_list = [
predict_skycomponent_visibility(self.blockvis_list[freqwin], self.components_list[freqwin])
for freqwin, _ in enumerate(self.blockvis_list)]
self.model_imagelist = [insert_skycomponent(self.model_imagelist[freqwin], self.components_list[freqwin])
for freqwin in range(nfreqwin)]
model = self.model_imagelist[0]
self.cmodel = smooth_image(model)
if self.persist:
export_image_to_fits(model, '%s/test_imaging_serial_model.fits' % self.dir)
export_image_to_fits(self.cmodel, '%s/test_imaging_serial_cmodel.fits' % self.dir)
if add_errors:
gt = create_gaintable_from_blockvisibility(self.blockvis_list[0])
gt = simulate_gaintable(gt, phase_error=0.1, amplitude_error=0.0, smooth_channels=1,
leakage=0.0, seed=180555)
self.blockvis_list = [apply_gaintable(self.blockvis_list[i], gt)
for i in range(self.freqwin)]
self.vis_list = [convert_blockvisibility_to_visibility(bv) for bv in self.blockvis_list]
self.model_imagelist = [
create_unittest_model(self.vis_list[i], self.image_pol, npixel=self.npixel, cellsize=0.0005)
for i in range(nfreqwin)]
# Test requires that casa be installed
try:
bvt = create_blockvisibility_from_ms(arl_path('data/vis/sim-2.ms'), channum=[35, 36, 37, 38, 39])[0]
bvt.configuration.diameter[...] = 35.0
vt = convert_blockvisibility_to_visibility(bvt)
vt = convert_visibility_to_stokes(vt)
cellsize = 20.0 * numpy.pi / (180.0 * 3600.0)
npixel = 512
model = create_image_from_visibility(vt, cellsize=cellsize, npixel=npixel,
polarisation_frame=PolarisationFrame('stokesIQUV'))
dirty, sumwt = invert_list_serial_workflow([vt], [model], context='2d')[0]
psf, sumwt = invert_list_serial_workflow([vt], [model], context='2d', dopsf=True)[0]
export_image_to_fits(dirty, '%s/compare_imaging_sim2_dirty.fits' % (results_dir))
export_image_to_fits(psf, '%s/compare_imaging_sim2_psf.fits' % (results_dir))
# Deconvolve using clean
comp, residual = deconvolve_cube(dirty, psf, niter=10000, threshold=0.001, fractional_threshold=0.001,
window_shape='quarter', gain=0.7, scales=[0, 3, 10, 30])
restored = restore_cube(comp, psf, residual)
export_image_to_fits(restored, '%s/compare_imaging_sim2_restored.fits' % (results_dir))
export_image_to_fits(residual, '%s/compare_imaging_sim2_residual.fits' % (results_dir))
qa = qa_image(restored)
assert numpy.abs(qa.data['max'] - 1.006140596404203) < 1e-7, qa
assert numpy.abs(qa.data['maxabs'] - 1.006140596404203) < 1e-7, qa
assert numpy.abs(qa.data['min'] + 0.23890808520954754) < 1e-7, qa
channel_model = create_image_from_visibility(
vt,
cellsize=cellsize,
npixel=512,
nchan=1,
imagecentre=vis_list[0].phasecentre,
polarisation_frame=PolarisationFrame('stokesIQUV'))
beam = create_pb(channel_model,
telescope='VLA',
pointingcentre=vt.phasecentre,
use_local=False)
beam.data /= numpy.max(beam.data)
dirty, sumwt = invert_list_serial_workflow([vt], [channel_model])[0]
print(sumwt)
mosaic.data += dirty.data * beam.data
mosaicsens.data += beam.data**2
show_image(dirty)
plt.show()
show_image(mosaic, cm='Greys', title='Linear mosaic')
plt.show()
show_image(mosaicsens, cm='Greys', title='Linear mosaic sensitivity')
plt.show()
from wrappers.serial.image.operations import export_image_to_fits
export_image_to_fits(mosaic, "mosaics.fits")
export_image_to_fits(mosaicsens, "mosaicsens.fits")
# %%
