def invert_serial(vis, im: Image, dopsf=False, normalize=True, context='2d', vis_slices=1, facets=1, overlap=0, taper=None, **kwargs): """ Invert using algorithm specified by context: * 2d: Two-dimensional transform * wstack: wstacking with either vis_slices or wstack (spacing between w planes) set * wprojection: w projection with wstep (spacing between w places) set, also kernel='wprojection' * timeslice: snapshot imaging with either vis_slices or timeslice set. timeslice='auto' does every time * facets: Faceted imaging with facets facets on each axis * facets_wprojection: facets AND wprojection * facets_wstack: facets AND wstacking * wprojection_wstack: wprojection and wstacking :param vis: :param im: :param dopsf: Make the psf instead of the dirty image (False) :param normalize: Normalize by the sum of weights (True) :param context: Imaging context e.g. '2d', 'timeslice', etc. :param kwargs: :return: Image, sum of weights """ c = imaging_context(context) vis_iter = c['vis_iterator'] invert = c['invert'] if not isinstance(vis, Visibility): svis = convert_blockvisibility_to_visibility(vis) else: svis = vis resultimage = create_empty_image_like(im) totalwt = None for rows in vis_iter(svis, vis_slices=vis_slices): if numpy.sum(rows): visslice = create_visibility_from_rows(svis, rows) sumwt = 0.0 workimage = create_empty_image_like(im) for dpatch in image_scatter_facets(workimage, facets=facets, overlap=overlap, taper=taper): result, sumwt = invert(visslice, dpatch, dopsf, normalize=False, facets=facets, vis_slices=vis_slices, **kwargs) # Ensure that we fill in the elements of dpatch instead of creating a new numpy arrray dpatch.data[...] = result.data[...] # Assume that sumwt is the same for all patches if totalwt is None: totalwt = sumwt else: totalwt += sumwt resultimage.data += workimage.data assert totalwt is not None, "No valid data found for imaging" if normalize: resultimage = normalize_sumwt(resultimage, totalwt) return resultimage, totalwt
def predict_serial(vis, model: Image, context='2d', vis_slices=1, facets=1, overlap=0, taper=None, **kwargs) -> Visibility: """Predict visibilities using algorithm specified by context * 2d: Two-dimensional transform * wstack: wstacking with either vis_slices or wstack (spacing between w planes) set * wprojection: w projection with wstep (spacing between w places) set, also kernel='wprojection' * timeslice: snapshot imaging with either vis_slices or timeslice set. timeslice='auto' does every time * facets: Faceted imaging with facets facets on each axis * facets_wprojection: facets AND wprojection * facets_wstack: facets AND wstacking * wprojection_wstack: wprojection and wstacking :param vis: :param model: Model image, used to determine image characteristics :param context: Imaging context e.g. '2d', 'timeslice', etc. :param inner: Inner loop 'vis'|'image' :param kwargs: :return: """ c = imaging_context(context) vis_iter = c['vis_iterator'] predict = c['predict'] if not isinstance(vis, Visibility): svis = convert_blockvisibility_to_visibility(vis) else: svis = vis result = copy_visibility(vis, zero=True) for rows in vis_iter(svis, vis_slices=vis_slices): if numpy.sum(rows): visslice = create_visibility_from_rows(svis, rows) visslice.data['vis'][...] = 0.0 for dpatch in image_scatter_facets(model, facets=facets, overlap=overlap, taper=taper): result.data['vis'][...] = 0.0 result = predict(visslice, dpatch, **kwargs) svis.data['vis'][rows] += result.data['vis'] if not isinstance(vis, Visibility): svis = convert_visibility_to_blockvisibility(svis) return svis
def predict_list_arlexecute_workflow(vis_list, model_imagelist, context, vis_slices=1, facets=1, gcfcf=None, **kwargs): """Predict, iterating over both the scattered vis_list and image The visibility and image are scattered, the visibility is predicted on each part, and then the parts are assembled. :param vis_list: :param model_imagelist: Model used to determine image parameters :param vis_slices: Number of vis slices (w stack or timeslice) :param facets: Number of facets (per axis) :param context: Type of processing e.g. 2d, wstack, timeslice or facets :param gcfcg: tuple containing grid correction and convolution function :param kwargs: Parameters for functions in components :return: List of vis_lists """ if get_parameter(kwargs, "use_serial_predict", False): from workflows.serial.imaging.imaging_serial import predict_list_serial_workflow return [arlexecute.execute(predict_list_serial_workflow, nout=1) \ (vis_list=[vis_list[i]], model_imagelist=[model_imagelist[i]], vis_slices=vis_slices, facets=facets, context=context, gcfcf=gcfcf, **kwargs)[0] for i, _ in enumerate(vis_list)] # Predict_2d does not clear the vis so we have to do it here. vis_list = zero_list_arlexecute_workflow(vis_list) c = imaging_context(context) vis_iter = c['vis_iterator'] predict = c['predict'] if facets % 2 == 0 or facets == 1: actual_number_facets = facets else: actual_number_facets = facets - 1 def predict_ignore_none(vis, model, g): if vis is not None: assert isinstance(vis, Visibility), vis assert isinstance(model, Image), model return predict(vis, model, context=context, gcfcf=g, **kwargs) else: return None if gcfcf is None: gcfcf = [arlexecute.execute(create_pswf_convolutionfunction)(m) for m in model_imagelist] # Loop over all frequency windows if facets == 1: image_results_list = list() for ivis, subvis in enumerate(vis_list): if len(gcfcf) > 1: g = gcfcf[ivis] else: g = gcfcf[0] # Create the graph to divide an image into facets. This is by reference. # Create the graph to divide the visibility into slices. This is by copy. sub_vis_lists = arlexecute.execute(visibility_scatter, nout=vis_slices)(subvis, vis_iter, vis_slices) image_vis_lists = list() # Loop over sub visibility for sub_vis_list in sub_vis_lists: # Predict visibility for this sub-visibility from this image image_vis_list = arlexecute.execute(predict_ignore_none, pure=True, nout=1) \ (sub_vis_list, model_imagelist[ivis], g) # Sum all sub-visibilities image_vis_lists.append(image_vis_list) image_results_list.append(arlexecute.execute(visibility_gather, nout=1) (image_vis_lists, subvis, vis_iter)) result = image_results_list else: image_results_list_list = list() for ivis, subvis in enumerate(vis_list): # Create the graph to divide an image into facets. This is by reference. facet_lists = arlexecute.execute(image_scatter_facets, nout=actual_number_facets ** 2)( model_imagelist[ivis], facets=facets) # Create the graph to divide the visibility into slices. This is by copy. sub_vis_lists = arlexecute.execute(visibility_scatter, nout=vis_slices)\ (subvis, vis_iter, vis_slices) facet_vis_lists = list() # Loop over sub visibility for sub_vis_list in sub_vis_lists: facet_vis_results = list() # Loop over facets for facet_list in facet_lists: # Predict visibility for this subvisibility from this facet facet_vis_list = arlexecute.execute(predict_ignore_none, pure=True, nout=1)\ (sub_vis_list, facet_list, None) facet_vis_results.append(facet_vis_list) # Sum the current sub-visibility over all facets facet_vis_lists.append(arlexecute.execute(sum_predict_results)(facet_vis_results)) # Sum all sub-visibilities image_results_list_list.append( arlexecute.execute(visibility_gather, nout=1)(facet_vis_lists, subvis, vis_iter)) result = image_results_list_list return arlexecute.optimize(result)
def invert_list_arlexecute_workflow(vis_list, template_model_imagelist, context, dopsf=False, normalize=True, facets=1, vis_slices=1, 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 """ # Use serial invert for each element of the visibility list. This means that e.g. iteration # through w-planes or timeslices is done sequentially thus not incurring the memory cost # of doing all at once. if get_parameter(kwargs, "use_serial_invert", False): from workflows.serial.imaging.imaging_serial import invert_list_serial_workflow return [arlexecute.execute(invert_list_serial_workflow, nout=1) \ (vis_list=[vis_list[i]], template_model_imagelist=[template_model_imagelist[i]], context=context, dopsf=dopsf, normalize=normalize, vis_slices=vis_slices, facets=facets, gcfcf=gcfcf, **kwargs)[0] for i, _ in enumerate(vis_list)] 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'] if facets % 2 == 0 or facets == 1: actual_number_facets = facets else: actual_number_facets = max(1, (facets - 1)) 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, gg): if vis is not None: return invert(vis, model, context=context, dopsf=dopsf, normalize=normalize, gcfcf=gg, **kwargs) else: return create_empty_image_like(model), numpy.zeros([model.nchan, model.npol]) # If we are doing facets, we need to create the gcf for each image if gcfcf is None and facets == 1: gcfcf = [arlexecute.execute(create_pswf_convolutionfunction)(template_model_imagelist[0])] # Loop over all vis_lists independently results_vislist = list() if facets == 1: for ivis, sub_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_sub_vis_lists = arlexecute.execute(visibility_scatter, nout=vis_slices)\ (sub_vis_list, vis_iter, vis_slices=vis_slices) # Iterate within each sub_sub_vis_list vis_results = list() for sub_sub_vis_list in sub_sub_vis_lists: vis_results.append(arlexecute.execute(invert_ignore_none, pure=True) (sub_sub_vis_list, template_model_imagelist[ivis], g)) results_vislist.append(sum_invert_results_arlexecute(vis_results)) result = results_vislist else: for ivis, sub_vis_list in enumerate(vis_list): # Create the graph to divide an image into facets. This is by reference. facet_lists = arlexecute.execute(image_scatter_facets, nout=actual_number_facets ** 2)( template_model_imagelist[ ivis], facets=facets) # Create the graph to divide the visibility into slices. This is by copy. sub_sub_vis_lists = arlexecute.execute(visibility_scatter, nout=vis_slices)\ (sub_vis_list, vis_iter, vis_slices=vis_slices) # Iterate within each vis_list vis_results = list() for sub_sub_vis_list in sub_sub_vis_lists: facet_vis_results = list() for facet_list in facet_lists: facet_vis_results.append( arlexecute.execute(invert_ignore_none, pure=True)(sub_sub_vis_list, facet_list, None)) vis_results.append(arlexecute.execute(gather_image_iteration_results, nout=1) (facet_vis_results, template_model_imagelist[ivis])) results_vislist.append(sum_invert_results_arlexecute(vis_results)) result = results_vislist return arlexecute.optimize(result)
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
def predict_list_serial_workflow(vis_list, model_imagelist, vis_slices=1, facets=1, context='2d', gcfcf=None, **kwargs): """Predict, iterating over both the scattered vis_list and image The visibility and image are scattered, the visibility is predicted on each part, and then the parts are assembled. :param vis_list: :param model_imagelist: Model used to determine image parameters :param vis_slices: Number of vis slices (w stack or timeslice) :param facets: Number of facets (per axis) :param context: Type of processing e.g. 2d, wstack, timeslice or facets :param gcfcg: tuple containing grid correction and convolution function :param kwargs: Parameters for functions in components :return: List of vis_lists """ assert len(vis_list) == len( model_imagelist), "Model must be the same length as the vis_list" c = imaging_context(context) vis_iter = c['vis_iterator'] predict = c['predict'] if facets % 2 == 0 or facets == 1: actual_number_facets = facets else: actual_number_facets = facets - 1 def predict_ignore_none(vis, model, g): if vis is not None: return predict(vis, model, context=context, gcfcf=g, **kwargs) else: return None if gcfcf is None: gcfcf = [create_pswf_convolutionfunction(model_imagelist[0])] # Loop over all frequency windows if facets == 1: image_results_list = list() for freqwin, vis_list in enumerate(vis_list): if len(gcfcf) > 1: g = gcfcf[freqwin] else: g = gcfcf[0] # Create the graph to divide an image into facets. This is by reference. # Create the graph to divide the visibility into slices. This is by copy. sub_vis_lists = visibility_scatter(vis_list, vis_iter, vis_slices) image_vis_lists = list() # Loop over sub visibility for rows in vis_iter(vis_list, vis_slices=vis_slices): sub_vis_list = create_visibility_from_rows(vis_list, rows) # Predict visibility for this sub-visibility from this image image_vis_list = predict_ignore_none(sub_vis_list, model_imagelist[freqwin], g) # Sum all sub-visibilities image_vis_lists.append(image_vis_list) image_results_list.append( visibility_gather(image_vis_lists, vis_list, vis_iter)) return image_results_list else: image_results_list_list = list() for freqwin, vis_list in enumerate(vis_list): # Create the graph to divide an image into facets. This is by reference. facet_lists = image_scatter_facets(model_imagelist[freqwin], facets=facets) facet_vis_lists = list() # Loop over sub visibility for rows in vis_iter(vis_list, vis_slices=vis_slices): sub_vis_list = create_visibility_from_rows(vis_list, rows) facet_vis_results = list() # Loop over facets for facet_list in facet_lists: # Predict visibility for this subvisibility from this facet facet_vis_list = predict_ignore_none( sub_vis_list, facet_list, None) facet_vis_results.append(facet_vis_list) # Sum the current sub-visibility over all facets facet_vis_lists.append(sum_predict_results(facet_vis_results)) # Sum all sub-visibilties image_results_list_list.append( visibility_gather(facet_vis_lists, vis_list, vis_iter)) return image_results_list_list
def predict_list_arlexecute_workflow(vis_list, model_imagelist, vis_slices=1, facets=1, context='2d', **kwargs): """Predict, iterating over both the scattered vis_list and image The visibility and image are scattered, the visibility is predicted on each part, and then the parts are assembled. :param vis_list: :param model_imagelist: Model used to determine image parameters :param vis_slices: Number of vis slices (w stack or timeslice) :param facets: Number of facets (per axis) :param context: :param kwargs: Parameters for functions in components :return: List of vis_lists """ assert len(vis_list) == len( model_imagelist), "Model must be the same length as the vis_list" c = imaging_context(context) vis_iter = c['vis_iterator'] predict = c['predict'] if facets % 2 == 0 or facets == 1: actual_number_facets = facets else: actual_number_facets = facets - 1 def predict_ignore_none(vis, model): if vis is not None: return predict(vis, model, context=context, facets=facets, vis_slices=vis_slices, **kwargs) else: return None image_results_list_list = list() # Loop over all frequency windows for freqwin, vis_list in enumerate(vis_list): # Create the graph to divide an image into facets. This is by reference. facet_lists = arlexecute.execute(image_scatter_facets, nout=actual_number_facets**2)( model_imagelist[freqwin], facets=facets) # Create the graph to divide the visibility into slices. This is by copy. sub_vis_lists = arlexecute.execute(visibility_scatter, nout=vis_slices)(vis_list, vis_iter, vis_slices) facet_vis_lists = list() # Loop over sub visibility for sub_vis_list in sub_vis_lists: facet_vis_results = list() # Loop over facets for facet_list in facet_lists: # Predict visibility for this subvisibility from this facet facet_vis_list = arlexecute.execute(predict_ignore_none, pure=True, nout=1)(sub_vis_list, facet_list) facet_vis_results.append(facet_vis_list) # Sum the current sub-visibility over all facets facet_vis_lists.append( arlexecute.execute(sum_predict_results)(facet_vis_results)) # Sum all sub-visibilties image_results_list_list.append( arlexecute.execute(visibility_gather, nout=1)(facet_vis_lists, vis_list, vis_iter)) return image_results_list_list
def invert_list_arlexecute_workflow(vis_list, template_model_imagelist, dopsf=False, normalize=True, facets=1, vis_slices=1, context='2d', **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 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'] if facets % 2 == 0 or facets == 1: actual_number_facets = facets else: actual_number_facets = max(1, (facets - 1)) 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): if vis is not None: return invert(vis, model, context=context, dopsf=dopsf, normalize=normalize, facets=facets, vis_slices=vis_slices, **kwargs) else: return create_empty_image_like(model), 0.0 # Loop over all vis_lists independently results_vislist = list() for freqwin, vis_list in enumerate(vis_list): # Create the graph to divide an image into facets. This is by reference. facet_lists = arlexecute.execute(image_scatter_facets, nout=actual_number_facets**2)( template_model_imagelist[freqwin], facets=facets) # Create the graph to divide the visibility into slices. This is by copy. sub_vis_lists = arlexecute.execute( visibility_scatter, nout=vis_slices)(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( arlexecute.execute(invert_ignore_none, pure=True)(sub_vis_list, facet_list)) vis_results.append( arlexecute.execute(gather_image_iteration_results, nout=1)(facet_vis_results, template_model_imagelist[freqwin])) results_vislist.append( arlexecute.execute(sum_invert_results)(vis_results)) return results_vislist
def predict_list_serial_workflow(vis_list, model_imagelist, context, vis_slices=1, facets=1, gcfcf=None, **kwargs): """Predict, iterating over both the scattered vis_list and image The visibility and image are scattered, the visibility is predicted on each part, and then the parts are assembled. :param vis_list: :param model_imagelist: Model used to determine image parameters :param vis_slices: Number of vis slices (w stack or timeslice) :param facets: Number of facets (per axis) :param context: Type of processing e.g. 2d, wstack, timeslice or facets :param gcfcg: tuple containing grid correction and convolution function :param kwargs: Parameters for functions in components :return: List of vis_lists """ assert len(vis_list) == len( model_imagelist), "Model must be the same length as the vis_list" # Predict_2d does not clear the vis so we have to do it here. vis_list = zero_list_serial_workflow(vis_list) c = imaging_context(context) vis_iter = c['vis_iterator'] predict = c['predict'] def predict_ignore_none(vis, model, g): if vis is not None: assert isinstance(vis, Visibility), vis assert isinstance(model, Image), model return predict(vis, model, context=context, gcfcf=g, **kwargs) else: return None if gcfcf is None: gcfcf = [create_pswf_convolutionfunction(m) for m in model_imagelist] # Loop over all frequency windows if facets == 1: image_results_list = list() for ivis, sub_vis_list in enumerate(vis_list): if len(gcfcf) > 1: g = gcfcf[ivis] else: g = gcfcf[0] # Loop over sub visibility vis_predicted = copy_visibility(sub_vis_list, zero=True) for rows in vis_iter(sub_vis_list, vis_slices): row_vis = create_visibility_from_rows(sub_vis_list, rows) row_vis_predicted = predict_ignore_none( row_vis, model_imagelist[ivis], g) if row_vis_predicted is not None: vis_predicted.data['vis'][ rows, ...] = row_vis_predicted.data['vis'] image_results_list.append(vis_predicted) return image_results_list else: image_results_list = list() for ivis, sub_vis_list in enumerate(vis_list): # Create the graph to divide an image into facets. This is by reference. facet_lists = image_scatter_facets(model_imagelist[ivis], facets=facets) facet_vis_lists = list() sub_vis_lists = visibility_scatter(sub_vis_list, vis_iter, vis_slices) # Loop over sub visibility for sub_vis_list in sub_vis_lists: facet_vis_results = list() # Loop over facets for facet_list in facet_lists: # Predict visibility for this subvisibility from this facet facet_vis_list = predict_ignore_none( sub_vis_list, facet_list, None) facet_vis_results.append(facet_vis_list) # Sum the current sub-visibility over all facets facet_vis_lists.append(sum_predict_results(facet_vis_results)) # Sum all sub-visibilties image_results_list.append( visibility_gather(facet_vis_lists, sub_vis_list, vis_iter)) return image_results_list
vis_slices=vis_slices) else: log.info('About to run predict to get predicted visibility') model_imagelist = gleam_model context = 'wstack' facets = 1 assert len(vis_list) == len( model_imagelist), "Model must be the same length as the vis_list" from workflows.shared.imaging.imaging_shared import imaging_context from processing_components.image.gather_scatter import image_scatter_facets, image_gather_facets from processing_components.visibility.gather_scatter import visibility_scatter, visibility_gather from workflows.shared.imaging.imaging_shared import sum_invert_results, remove_sumwt, sum_predict_results, \ threshold_list c = imaging_context(context) vis_iter = c['vis_iterator'] predict = c['predict'] def predict_ignore_none(vis, model): if vis is not None: print("In predict:") print(vis) print(model) print(facets) print(vis_slices) return predict(vis, model, context=context, facets=facets, vis_slices=vis_slices)