workflows/serial/imaging/imaging_serial.py
def deconvolve_list_serial_workflow(dirty_list, psf_list, model_imagelist, prefix='', mask=None, **kwargs):
    """Create a graph for deconvolution, adding to the model

    :param dirty_list:
    :param psf_list:
    :param model_imagelist:
    :param prefix: Informative prefix to log messages
    :param mask: Mask for deconvolution
    :param kwargs: Parameters for functions in components
    :return: (graph for the deconvolution, graph for the flat)
    """
    nchan = len(dirty_list)
    nmoment = get_parameter(kwargs, "nmoment", 0)
    
    assert isinstance(dirty_list, list), dirty_list
    assert isinstance(psf_list, list), psf_list
    assert isinstance(model_imagelist, list), model_imagelist
    
    def deconvolve(dirty, psf, model, facet, gthreshold, msk=None):
        if prefix == '':
            lprefix = "facet %d" % facet
        else:
            lprefix = "%s, facet %d" % (prefix, facet)
        
        if nmoment > 0:
            moment0 = calculate_image_frequency_moments(dirty)
            this_peak = numpy.max(numpy.abs(moment0.data[0, ...])) / dirty.data.shape[0]
        else:
            ref_chan = dirty.data.shape[0] // 2
            this_peak = numpy.max(numpy.abs(dirty.data[ref_chan, ...]))
        
        if this_peak > 1.1 * gthreshold:
            kwargs['threshold'] = gthreshold
            result, _ = deconvolve_cube(dirty, psf, prefix=lprefix, mask=msk, **kwargs)
            
            if result.data.shape[0] == model.data.shape[0]:
                result.data += model.data
            return result
        else:
            
            return copy_image(model)
    
    deconvolve_facets = get_parameter(kwargs, 'deconvolve_facets', 1)
    deconvolve_overlap = get_parameter(kwargs, 'deconvolve_overlap', 0)
    deconvolve_taper = get_parameter(kwargs, 'deconvolve_taper', None)
    if deconvolve_facets > 1 and deconvolve_overlap > 0:
        deconvolve_number_facets = (deconvolve_facets - 2) ** 2
    else:
        deconvolve_number_facets = deconvolve_facets ** 2
    
    model_imagelist = image_gather_channels(model_imagelist)
    
    # Scatter the separate channel images into deconvolve facets and then gather channels for each facet.
    # This avoids constructing the entire spectral cube.
    dirty_list_trimmed = remove_sumwt(dirty_list)
    scattered_channels_facets_dirty_list = \
        [image_scatter_facets(d, facets=deconvolve_facets,
                              overlap=deconvolve_overlap,
                              taper=deconvolve_taper)
         for d in dirty_list_trimmed]
    
    # Now we do a transpose and gather
    scattered_facets_list = [
        image_gather_channels([scattered_channels_facets_dirty_list[chan][facet]
                               for chan in range(nchan)])
        for facet in range(deconvolve_number_facets)]
    
    psf_list_trimmed = remove_sumwt(psf_list)
    psf_list_trimmed = image_gather_channels(psf_list_trimmed)
    
    scattered_model_imagelist = \
        image_scatter_facets(model_imagelist,
                             facets=deconvolve_facets,
                             overlap=deconvolve_overlap)
    
    # Work out the threshold. Need to find global peak over all dirty_list images
    threshold = get_parameter(kwargs, "threshold", 0.0)
    fractional_threshold = get_parameter(kwargs, "fractional_threshold", 0.1)
    nmoment = get_parameter(kwargs, "nmoment", 0)
    use_moment0 = nmoment > 0
    
    # Find the global threshold. This uses the peak in the average on the frequency axis since we
    # want to use it in a stopping criterion in a moment clean
    global_threshold = threshold_list(scattered_facets_list, threshold, fractional_threshold, use_moment0=use_moment0,
                                      prefix=prefix)
    
    facet_list = numpy.arange(deconvolve_number_facets).astype('int')
    if mask is None:
        scattered_results_list = [
            deconvolve(d, psf_list_trimmed, m, facet, global_threshold)
            for d, m, facet in zip(scattered_facets_list, scattered_model_imagelist, facet_list)]
    else:
        mask_list = \
            image_scatter_facets(mask,
                                 facets=deconvolve_facets,
                                 overlap=deconvolve_overlap)
        scattered_results_list = [
            deconvolve(d, psf_list_trimmed, m, facet, global_threshold, msk)
            for d, m, facet, msk in zip(scattered_facets_list, scattered_model_imagelist, facet_list, mask_list)]
    
    # Gather the results back into one image, correcting for overlaps as necessary. The taper function is is used to
    # feather the facets together
    gathered_results_list = image_gather_facets(scattered_results_list, model_imagelist,
                                                facets=deconvolve_facets,
                                                overlap=deconvolve_overlap,
                                                taper=deconvolve_taper)
    
    return image_scatter_channels(gathered_results_list, subimages=nchan)
Create a graph for deconvolution, adding to the model

    :param dirty_list:
    :param psf_list:
    :param model_imagelist:
    :param prefix: Informative prefix to log messages
    :param mask: Mask for deconvolution
    :param kwargs: Parameters for functions in components
    :return: (graph for the deconvolution, graph for the flat)
    
Create a graph for deconvolution, adding to the model
Create a graph for deconvolution adding to the model
def deconvolve_list_serial_workflow(dirty_list, psf_list, model_imagelist, prefix='', mask=None, **kwargs):
    nchan = len(dirty_list)
    nmoment = get_parameter(kwargs, "nmoment", 0)
    assert isinstance(dirty_list, list), dirty_list
    assert isinstance(psf_list, list), psf_list
    assert isinstance(model_imagelist, list), model_imagelist
    def deconvolve(dirty, psf, model, facet, gthreshold, msk=None):
        if prefix == '':
            lprefix = "facet %d" % facet
        else:
            lprefix = "%s, facet %d" % (prefix, facet)
        if nmoment > 0:
            moment0 = calculate_image_frequency_moments(dirty)
            this_peak = numpy.max(numpy.abs(moment0.data[0, ...])) / dirty.data.shape[0]
        else:
            ref_chan = dirty.data.shape[0] // 2
            this_peak = numpy.max(numpy.abs(dirty.data[ref_chan, ...]))
        if this_peak > 1.1 * gthreshold:
            kwargs['threshold'] = gthreshold
            result, _ = deconvolve_cube(dirty, psf, prefix=lprefix, mask=msk, **kwargs)
            if result.data.shape[0] == model.data.shape[0]:
                result.data += model.data
            return result
        else:
            return copy_image(model)
    deconvolve_facets = get_parameter(kwargs, 'deconvolve_facets', 1)
    deconvolve_overlap = get_parameter(kwargs, 'deconvolve_overlap', 0)
    deconvolve_taper = get_parameter(kwargs, 'deconvolve_taper', None)
    if deconvolve_facets > 1 and deconvolve_overlap > 0:
        deconvolve_number_facets = (deconvolve_facets - 2) ** 2
    else:
        deconvolve_number_facets = deconvolve_facets ** 2
    model_imagelist = image_gather_channels(model_imagelist)
    dirty_list_trimmed = remove_sumwt(dirty_list)
    scattered_channels_facets_dirty_list = \
        [image_scatter_facets(d, facets=deconvolve_facets,
                              overlap=deconvolve_overlap,
                              taper=deconvolve_taper)
         for d in dirty_list_trimmed]
    scattered_facets_list = [
        image_gather_channels([scattered_channels_facets_dirty_list[chan][facet]
                               for chan in range(nchan)])
        for facet in range(deconvolve_number_facets)]
    psf_list_trimmed = remove_sumwt(psf_list)
    psf_list_trimmed = image_gather_channels(psf_list_trimmed)
    scattered_model_imagelist = \
        image_scatter_facets(model_imagelist,
                             facets=deconvolve_facets,
                             overlap=deconvolve_overlap)
    threshold = get_parameter(kwargs, "threshold", 0.0)
    fractional_threshold = get_parameter(kwargs, "fractional_threshold", 0.1)
    nmoment = get_parameter(kwargs, "nmoment", 0)
    use_moment0 = nmoment > 0
    global_threshold = threshold_list(scattered_facets_list, threshold, fractional_threshold, use_moment0=use_moment0,
                                      prefix=prefix)
    facet_list = numpy.arange(deconvolve_number_facets).astype('int')
    if mask is None:
        scattered_results_list = [
            deconvolve(d, psf_list_trimmed, m, facet, global_threshold)
            for d, m, facet in zip(scattered_facets_list, scattered_model_imagelist, facet_list)]
    else:
        mask_list = \
            image_scatter_facets(mask,
                                 facets=deconvolve_facets,
                                 overlap=deconvolve_overlap)
        scattered_results_list = [
            deconvolve(d, psf_list_trimmed, m, facet, global_threshold, msk)
            for d, m, facet, msk in zip(scattered_facets_list, scattered_model_imagelist, facet_list, mask_list)]
    gathered_results_list = image_gather_facets(scattered_results_list, model_imagelist,
                                                facets=deconvolve_facets,
                                                overlap=deconvolve_overlap,
                                                taper=deconvolve_taper)
    return image_scatter_channels(gathered_results_list, subimages=nchan)
def deconvolve_list_serial_workflow ( dirty_list , psf_list , model_imagelist , prefix = '' , mask = None , ** kwargs ) : nchan = len ( dirty_list ) nmoment = get_parameter ( kwargs , "nmoment" , 0 ) assert isinstance ( dirty_list , list ) , dirty_list assert isinstance ( psf_list , list ) , psf_list assert isinstance ( model_imagelist , list ) , model_imagelist def deconvolve ( dirty , psf , model , facet , gthreshold , msk = None ) : if prefix == '' : lprefix = "facet %d" % facet else : lprefix = "%s, facet %d" % ( prefix , facet ) if nmoment > 0 : moment0 = calculate_image_frequency_moments ( dirty ) this_peak = numpy . max ( numpy . abs ( moment0 . data [ 0 , ... ] ) ) / dirty . data . shape [ 0 ] else : ref_chan = dirty . data . shape [ 0 ] // 2 this_peak = numpy . max ( numpy . abs ( dirty . data [ ref_chan , ... ] ) ) if this_peak > 1.1 * gthreshold : kwargs [ 'threshold' ] = gthreshold result , _ = deconvolve_cube ( dirty , psf , prefix = lprefix , mask = msk , ** kwargs ) if result . data . shape [ 0 ] == model . data . shape [ 0 ] : result . data += model . data return result else : return copy_image ( model ) deconvolve_facets = get_parameter ( kwargs , 'deconvolve_facets' , 1 ) deconvolve_overlap = get_parameter ( kwargs , 'deconvolve_overlap' , 0 ) deconvolve_taper = get_parameter ( kwargs , 'deconvolve_taper' , None ) if deconvolve_facets > 1 and deconvolve_overlap > 0 : deconvolve_number_facets = ( deconvolve_facets - 2 ) ** 2 else : deconvolve_number_facets = deconvolve_facets ** 2 model_imagelist = image_gather_channels ( model_imagelist ) dirty_list_trimmed = remove_sumwt ( dirty_list ) scattered_channels_facets_dirty_list = [ image_scatter_facets ( d , facets = deconvolve_facets , overlap = deconvolve_overlap , taper = deconvolve_taper ) for d in dirty_list_trimmed ] scattered_facets_list = [ image_gather_channels ( [ scattered_channels_facets_dirty_list [ chan ] [ facet ] for chan in range ( nchan ) ] ) for facet in range ( deconvolve_number_facets ) ] psf_list_trimmed = remove_sumwt ( psf_list ) psf_list_trimmed = image_gather_channels ( psf_list_trimmed ) scattered_model_imagelist = image_scatter_facets ( model_imagelist , facets = deconvolve_facets , overlap = deconvolve_overlap ) threshold = get_parameter ( kwargs , "threshold" , 0.0 ) fractional_threshold = get_parameter ( kwargs , "fractional_threshold" , 0.1 ) nmoment = get_parameter ( kwargs , "nmoment" , 0 ) use_moment0 = nmoment > 0 global_threshold = threshold_list ( scattered_facets_list , threshold , fractional_threshold , use_moment0 = use_moment0 , prefix = prefix ) facet_list = numpy . arange ( deconvolve_number_facets ) . astype ( 'int' ) if mask is None : scattered_results_list = [ deconvolve ( d , psf_list_trimmed , m , facet , global_threshold ) for d , m , facet in zip ( scattered_facets_list , scattered_model_imagelist , facet_list ) ] else : mask_list = image_scatter_facets ( mask , facets = deconvolve_facets , overlap = deconvolve_overlap ) scattered_results_list = [ deconvolve ( d , psf_list_trimmed , m , facet , global_threshold , msk ) for d , m , facet , msk in zip ( scattered_facets_list , scattered_model_imagelist , facet_list , mask_list ) ] gathered_results_list = image_gather_facets ( scattered_results_list , model_imagelist , facets = deconvolve_facets , overlap = deconvolve_overlap , taper = deconvolve_taper ) return image_scatter_channels ( gathered_results_list , subimages = nchan )
Create a graph for deconvolution, adding to the model
Create a graph for deconvolution adding to the model
"""Create a graph for deconvolution, adding to the model

    :param dirty_list:
    :param psf_list:
    :param model_imagelist:
    :param prefix: Informative prefix to log messages
    :param mask: Mask for deconvolution
    :param kwargs: Parameters for functions in components
    :return: (graph for the deconvolution, graph for the flat)
    """ # Scatter the separate channel images into deconvolve facets and then gather channels for each facet. # This avoids constructing the entire spectral cube. # Now we do a transpose and gather # Work out the threshold. Need to find global peak over all dirty_list images # Find the global threshold. This uses the peak in the average on the frequency axis since we # want to use it in a stopping criterion in a moment clean # Gather the results back into one image, correcting for overlaps as necessary. The taper function is is used to # feather the facets together
(graph for the deconvolution, graph for the flat)
( graph for the deconvolution graph for the flat )
dirty_list
None
psf_list
None
model_imagelist
None
prefix
Informative prefix to log messages
Informative prefix to log messages
mask
Mask for deconvolution
Mask for deconvolution
kwargs
Parameters for functions in components
Parameters for functions in components