def vsum(ov, mv):
# Observed vis minus the sum of all predictions
verr = copy_visibility(ov)
for m in mv:
verr.data['vis'] -= m.data['vis']
# Now add back each model in turn
result = list()
for m in mv:
vr = copy_visibility(verr)
vr.data['vis'] += m.data['vis']
result.append(vr)
assert len(result) == len(mv)
return result
def zero(vis):
if vis is not None:
zerovis = copy_visibility(vis)
zerovis.data['vis'][...] = 0.0
return zerovis
else:
return None
def ft_cal_sm(ov, sm):
assert isinstance(ov, Visibility), ov
assert isinstance(sm, SkyModel), sm
v = copy_visibility(ov)
v.data['vis'][...] = 0.0 + 0.0j
if len(sm.components) > 0:
if isinstance(sm.mask, Image):
comps = copy_skycomponent(sm.components)
comps = apply_beam_to_skycomponent(comps, sm.mask)
v = predict_skycomponent_visibility(v, comps)
else:
v = predict_skycomponent_visibility(v, sm.components)
if isinstance(sm.image, Image):
if numpy.max(numpy.abs(sm.image.data)) > 0.0:
if isinstance(sm.mask, Image):
model = copy_image(sm.image)
model.data *= sm.mask.data
else:
model = sm.image
v = predict_list_serial_workflow([v], [model],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)[0]
if docal and isinstance(sm.gaintable, GainTable):
bv = convert_visibility_to_blockvisibility(v)
bv = apply_gaintable(bv, sm.gaintable, inverse=True)
v = convert_blockvisibility_to_visibility(bv)
return v
def subtract_vis(vis, model_vis):
if vis is not None and model_vis is not None:
assert vis.vis.shape == model_vis.vis.shape
subvis = copy_visibility(vis)
subvis.data['vis'][...] -= model_vis.data['vis'][...]
return subvis
else:
return None
def actualSetUp(self, freqwin=1, block=True, dopol=False, zerow=False):
self.npixel = 1024
self.low = create_named_configuration('LOWBD2', rmax=550.0)
self.freqwin = freqwin
self.blockvis_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])
self.phasecentre = SkyCoord(ra=+0.0 * u.deg, dec=-40.0 * u.deg, frame='icrs', equinox='J2000')
self.blockvis_list = [arlexecute.execute(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.blockvis_list = arlexecute.compute(self.blockvis_list, sync=True)
self.vis_list = [arlexecute.execute(convert_blockvisibility_to_visibility)(bv) for bv in self.blockvis_list]
self.vis_list = arlexecute.compute(self.vis_list, sync=True)
self.skymodel_list = [arlexecute.execute(create_low_test_skymodel_from_gleam)
(npixel=self.npixel, cellsize=self.cellsize, frequency=[self.frequency[f]],
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
flux_limit=0.6,
flux_threshold=1.0,
flux_max=5.0) for f, freq in enumerate(self.frequency)]
self.skymodel_list = arlexecute.compute(self.skymodel_list, sync=True)
assert isinstance(self.skymodel_list[0].image, Image), self.skymodel_list[0].image
assert isinstance(self.skymodel_list[0].components[0], Skycomponent), self.skymodel_list[0].components[0]
assert len(self.skymodel_list[0].components) == 19, len(self.skymodel_list[0].components)
self.skymodel_list = expand_skymodel_by_skycomponents(self.skymodel_list[0])
assert len(self.skymodel_list) == 20, len(self.skymodel_list)
assert numpy.max(numpy.abs(self.skymodel_list[-1].image.data)) > 0.0, "Image is empty"
self.vis_list = [copy_visibility(self.vis_list[0], zero=True) for i, _ in enumerate(self.skymodel_list)]
def ft_ift_sm(ov, sm, g):
assert isinstance(ov, Visibility) or isinstance(ov,
BlockVisibility), ov
assert isinstance(sm, SkyModel), sm
if g is not None:
assert len(g) == 2, g
assert isinstance(g[0], Image), g[0]
assert isinstance(g[1], ConvolutionFunction), g[1]
v = copy_visibility(ov)
v.data['vis'][...] = 0.0 + 0.0j
if len(sm.components) > 0:
if isinstance(sm.mask, Image):
comps = copy_skycomponent(sm.components)
comps = apply_beam_to_skycomponent(comps, sm.mask)
v = predict_skycomponent_visibility(v, comps)
else:
v = predict_skycomponent_visibility(v, sm.components)
if isinstance(sm.image, Image):
if numpy.max(numpy.abs(sm.image.data)) > 0.0:
if isinstance(sm.mask, Image):
model = copy_image(sm.image)
model.data *= sm.mask.data
else:
model = sm.image
v = predict_list_serial_workflow([v], [model],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=[g],
**kwargs)[0]
assert isinstance(sm.image, Image), sm.image
result = invert_list_serial_workflow([v], [sm.image],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=[g],
**kwargs)[0]
if isinstance(sm.mask, Image):
result[0].data *= sm.mask.data
return result
def ft_cal_sm(obv, sm):
assert isinstance(obv, BlockVisibility), obv
bv = copy_visibility(obv)
bv.data['vis'][...] = 0.0 + 0.0j
assert len(sm.components) > 0
if isinstance(sm.mask, Image):
comps = copy_skycomponent(sm.components)
comps = apply_beam_to_skycomponent(comps, sm.mask)
bv = predict_skycomponent_visibility(bv, comps)
else:
bv = predict_skycomponent_visibility(bv, sm.components)
if docal and isinstance(sm.gaintable, GainTable):
bv = apply_gaintable(bv, sm.gaintable, inverse=True)
return bv
def ft_ift_sm(ov, sm):
assert isinstance(ov, Visibility), ov
v = copy_visibility(ov)
v.data['vis'][...] = 0.0 + 0.0j
if len(sm.components) > 0:
if isinstance(sm.mask, Image):
comps = copy_skycomponent(sm.components)
comps = apply_beam_to_skycomponent(comps, sm.mask)
v = predict_skycomponent_visibility(v, comps)
else:
v = predict_skycomponent_visibility(v, sm.components)
if isinstance(sm.image, Image):
if numpy.max(numpy.abs(sm.image.data)) > 0.0:
if isinstance(sm.mask, Image):
model = copy_image(sm.image)
model.data *= sm.mask.data
else:
model = sm.image
v = predict_list_serial_workflow([v], [model],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)[0]
assert isinstance(sm.image, Image), sm.image
result = invert_list_serial_workflow([v], [sm.image],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)[0]
if isinstance(sm.mask, Image):
result[0].data *= sm.mask.data
return result
def actualSetUp(self,
nfreqwin=3,
dospectral=True,
dopol=False,
amp_errors=None,
phase_errors=None,
zerow=True):
if amp_errors is None:
amp_errors = {'T': 0.0, 'G': 0.1}
if phase_errors is None:
phase_errors = {'T': 1.0, 'G': 0.0}
self.npixel = 512
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = nfreqwin
self.vis_list = list()
self.ntimes = 1
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 = [
arlexecute.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 = arlexecute.compute(self.blockvis_list, sync=True)
for v in self.blockvis_list:
v.data['vis'][...] = 1.0 + 0.0j
self.error_blockvis_list = [
arlexecute.execute(copy_visibility(v)) for v in self.blockvis_list
]
gt = arlexecute.execute(create_gaintable_from_blockvisibility)(
self.blockvis_list[0])
gt = arlexecute.execute(simulate_gaintable)(gt,
phase_error=0.1,
amplitude_error=0.0,
smooth_channels=1,
leakage=0.0,
seed=180555)
self.error_blockvis_list = [
arlexecute.execute(apply_gaintable)(self.error_blockvis_list[i],
gt)
for i in range(self.freqwin)
]
self.error_blockvis_list = arlexecute.compute(self.error_blockvis_list,
sync=True)
assert numpy.max(
numpy.abs(self.error_blockvis_list[0].vis -
self.blockvis_list[0].vis)) > 0.0
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_list_arlexecute_workflow(
self.model_vis, self.beam, context='2d')
export_image_to_fits(
self.dirty_model,
"%s/test_modelpartition-model_dirty.fits" % self.dir)
lvis = convert_blockvisibility_to_visibility(self.vis)
lvis, _, _ = weight_visibility(lvis, self.beam)
dirty, sumwt = invert_list_arlexecute_workflow(lvis,
self.beam,
context='2d')
if doiso:
export_image_to_fits(
dirty,
"%s/test_modelpartition-initial-iso-residual.fits" % self.dir)
else:
export_image_to_fits(
dirty, "%s/test_modelpartition-initial-noiso-residual.fits" %
self.dir)
self.skymodels = [
SkyModel(components=[cm], fixed=fixed) for cm in self.components
]
def vis_add(v1, v2):
vout = copy_visibility(v1)
vout.data['vis'] += v2.data['vis']
return vout
def ical_list_mpi_workflow(vis_list,
model_imagelist,
context,
vis_slices=1,
facets=1,
gcfcf=None,
calibration_context='TG',
do_selfcal=True,
comm=MPI.COMM_WORLD,
**kwargs):
"""Create graph for ICAL pipeline
:param vis_list:
:param model_imagelist:
:param context: imaging context e.g. '2d'
:param calibration_context: Sequence of calibration steps e.g. TGB
:param do_selfcal: Do the selfcalibration?
:param kwargs: Parameters for functions in components
:return:
"""
rank = comm.Get_rank()
size = comm.Get_size()
assert isinstance(model_imagelist, list), model_imagelist
log.info(
'%d: ical_list_mpi_workflow: vis_list len %d model_imagelist len %d' %
(rank, len(vis_list), len(model_imagelist)))
gt_list = list()
if gcfcf is None:
if rank == 0:
gcfcf = [create_pswf_convolutionfunction(model_imagelist[0])]
gcfcf = comm.bcast(gcfcf, root=0)
psf_imagelist = invert_list_mpi_workflow(vis_list,
model_imagelist,
dopsf=True,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
model_vislist = [copy_visibility(v, zero=True) for v in vis_list]
if do_selfcal:
cal_vis_list = [copy_visibility(v) for v in vis_list]
else:
cal_vis_list = vis_list
if do_selfcal:
# Make the predicted visibilities, selfcalibrate against it correcting the gains, then
# form the residual visibility, then make the residual image
predicted_model_vislist = predict_list_mpi_workflow(
model_vislist,
model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
recal_vis_list, gt_list = calibrate_list_mpi_workflow(
cal_vis_list,
predicted_model_vislist,
calibration_context=calibration_context,
**kwargs)
residual_vislist = subtract_list_mpi_workflow(recal_vis_list,
predicted_model_vislist)
residual_imagelist = invert_list_mpi_workflow(residual_vislist,
model_imagelist,
dopsf=True,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
iteration=0,
**kwargs)
else:
# If we are not selfcalibrating it's much easier and we can avoid an unnecessary round of gather/scatter
# for visibility partitioning such as timeslices and wstack.
residual_imagelist = residual_list_mpi_workflow(cal_vis_list,
model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
assert isinstance(model_imagelist, list), model_imagelist
deconvolve_model_imagelist = deconvolve_list_mpi_workflow(
residual_imagelist,
psf_imagelist,
model_imagelist,
prefix='cycle 0',
**kwargs)
nmajor = get_parameter(kwargs, "nmajor", 5)
if nmajor > 1:
for cycle in range(nmajor):
if do_selfcal:
predicted_model_vislist = predict_list_mpi_workflow(
model_vislist,
deconvolve_model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
recal_vis_list, gt_list = calibrate_list_mpi_workflow(
cal_vis_list,
predicted_model_vislist,
calibration_context=calibration_context,
iteration=cycle,
**kwargs)
residual_vislist = subtract_list_mpi_workflow(
recal_vis_list, model_vislist)
residual_imagelist = invert_list_mpi_workflow(
residual_vislist,
model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
else:
residual_imagelist = residual_list_mpi_workflow(
cal_vis_list,
deconvolve_model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
prefix = "cycle %d" % (cycle + 1)
deconvolve_model_imagelist = deconvolve_list_mpi_workflow(
residual_imagelist,
psf_imagelist,
deconvolve_model_imagelist,
prefix=prefix,
**kwargs)
residual_imagelist = residual_list_mpi_workflow(cal_vis_list,
deconvolve_model_imagelist,
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf,
**kwargs)
restore_imagelist = restore_list_mpi_workflow(deconvolve_model_imagelist,
psf_imagelist,
residual_imagelist)
return (deconvolve_model_imagelist, residual_imagelist, restore_imagelist,
gt_list)
