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)
