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