def test_sum_invert_list(self):
self.actualSetUp(zerow=True)
residual_image_list = residual_list_arlexecute_workflow(self.vis_list, self.model_list, context='2d')
residual_image_list = arlexecute.compute(residual_image_list, sync=True)
route2 = sum_invert_results(residual_image_list)
route1 = sum_invert_results_arlexecute(residual_image_list)
route1 = arlexecute.compute(route1, sync=True)
for r in route1, route2:
assert len(r) == 2
qa = qa_image(r[0])
assert numpy.abs(qa.data['max'] - 0.35139716991480785) < 1.0, str(qa)
assert numpy.abs(qa.data['min'] + 0.7681701460717593) < 1.0, str(qa)
assert numpy.abs(r[1]-415950.0) < 1e-7, str(qa)
def invert_list_serial_workflow(vis_list, template_model_imagelist, dopsf=False, normalize=True,
facets=1, vis_slices=1, context='2d', gcfcf=None, **kwargs):
""" Sum results from invert, iterating over the scattered image and vis_list
:param vis_list:
:param template_model_imagelist: Model used to determine image parameters
:param dopsf: Make the PSF instead of the dirty image
:param facets: Number of facets
:param normalize: Normalize by sumwt
:param vis_slices: Number of slices
:param context: Imaging context
:param gcfcg: tuple containing grid correction and convolution function
:param kwargs: Parameters for functions in components
:return: List of (image, sumwt) tuple
"""
if not isinstance(template_model_imagelist, collections.Iterable):
template_model_imagelist = [template_model_imagelist]
c = imaging_context(context)
vis_iter = c['vis_iterator']
invert = c['invert']
def gather_image_iteration_results(results, template_model):
result = create_empty_image_like(template_model)
i = 0
sumwt = numpy.zeros([template_model.nchan, template_model.npol])
for dpatch in image_scatter_facets(result, facets=facets):
assert i < len(results), "Too few results in gather_image_iteration_results"
if results[i] is not None:
assert len(results[i]) == 2, results[i]
dpatch.data[...] = results[i][0].data[...]
sumwt += results[i][1]
i += 1
return result, sumwt
def invert_ignore_none(vis, model, g):
if vis is not None:
return invert(vis, model, context=context, dopsf=dopsf, normalize=normalize,
gcfcf=g, **kwargs)
else:
return create_empty_image_like(model), 0.0
# If we are doing facets, we need to create the gcf for each image
if gcfcf is None and facets == 1:
gcfcf = [create_pswf_convolutionfunction(template_model_imagelist[0])]
# Loop over all vis_lists independently
results_vislist = list()
if facets == 1:
for ivis, vis_list in enumerate(vis_list):
if len(gcfcf) > 1:
g = gcfcf[ivis]
else:
g = gcfcf[0]
# Create the graph to divide the visibility into slices. This is by copy.
sub_vis_lists = visibility_scatter(vis_list, vis_iter, vis_slices=vis_slices)
# Iterate within each vis_list
vis_results = list()
for sub_vis_list in sub_vis_lists:
vis_results.append(invert_ignore_none(sub_vis_list, template_model_imagelist[ivis],
g))
results_vislist.append(sum_invert_results(vis_results))
return results_vislist
else:
for ivis, vis_list in enumerate(vis_list):
# Create the graph to divide an image into facets. This is by reference.
facet_lists = image_scatter_facets(template_model_imagelist[
ivis],
facets=facets)
# Create the graph to divide the visibility into slices. This is by copy.
sub_vis_lists = visibility_scatter(vis_list, vis_iter, vis_slices=vis_slices)
# Iterate within each vis_list
vis_results = list()
for sub_vis_list in sub_vis_lists:
facet_vis_results = list()
for facet_list in facet_lists:
facet_vis_results.append(invert_ignore_none(sub_vis_list, facet_list,
None))
vis_results.append(gather_image_iteration_results(facet_vis_results,
template_model_imagelist[ivis]))
results_vislist.append(sum_invert_results(vis_results))
return results_vislist
