Imaging

ska_sdp_func_python.imaging.base Module

Base Imaging functions.

Functions

`advise_wide_field`(vis[, delA, ...])	Advise on parameters for wide field imaging.
`create_image_from_visibility`(vis, **kwargs)	Make an empty Image from params and Visibility.
`fill_vis_for_psf`(svis)	Fill the visibility for calculation of PSF.
`invert_awprojection`(vis, im[, dopsf, ...])	Invert using convolutional degridding and an AW kernel.
`normalise_sumwt`(im, sumwt[, min_weight, ...])	Normalise out the sum of weights.
`predict_awprojection`(vis, model[, gcfcf])	Predict using convolutional degridding and an AW kernel.
`shift_vis_to_image`(vis, im[, tangent, inverse])	Shift visibility in place to the phase centre of the Image.
`visibility_recentre`(uvw, dl, dm)	Compensate for kernel re-centering - see w_kernel_function.

ska_sdp_func_python.imaging.dft Module

Functions that aid Fourier transform processing.

Functions

`dft_cpu_looped`(direction_cosines, ...)	CPU computational kernel for DFT, using explicit loop over components.
`dft_gpu_raw_kernel`(direction_cosines, ...)	CPU computational kernel for DFT, using CUDA raw code via cupy.
`dft_kernel`(direction_cosines, vfluxes, ...)	CPU computational kernel for DFT, choice dependent on dft_compute_kernel.
`dft_skycomponent_visibility`(vis, sc[, ...])	DFT to get the visibility from a SkyComponent, for Visibility.
`dft_skycomponent`(uvw, skycomponent, phase_centre)	Calculate the Direct Fourier Transform (DFT) for a single sky component.
`gaussian_tapers`(u, v, params)	Calculate visibility amplitude tapers for Gaussian components.
`extract_direction_and_flux`(sc, vis)	Extract SkyComponent direction and flux to be consumed by DFT.
`idft_visibility_skycomponent`(vis, sc)	Inverse DFT a SkyComponent from Visibility.

ska_sdp_func_python.imaging.imaging Module

Functions for predicting visibility from a model image, and invert a visibility to make an (Image, sumweights) tuple. These redirect to specific versions.

Functions

`invert_visibility`(vis, im[, dopsf, ...])	Invert Visibility to make an (Image, sum weights) tuple.
`predict_visibility`(vis, model[, context, gcfcf])	Predict Visibility from an Image.

ska_sdp_func_python.imaging.imaging_helpers Module

Functions to aid operations on imaging results.

Functions

`remove_sumwt`(results)	Remove sumwt term in list of (image, sumwt) tuples.
`sum_invert_results`(image_list)	Sum a set of invert results with appropriate weighting.
`sum_predict_results`(results)	Sum a set of predict results of the same shape.
`threshold_list`(imagelist, threshold, ...[, ...])	Find actual threshold for list of results, optionally using moment 0.

ska_sdp_func_python.imaging.ng Module

Functions that implement prediction of and imaging from visibilities using the nifty gridder (DUCC version).

https://gitlab.mpcdf.mpg.de/mtr/ducc.git

This performs all necessary w term corrections, to high precision.

Note that nifty gridder doesn’t like some null data such as all w = 0 and do_wstacking=True. Also true of the visibilities.

Functions

`invert_ng`(bvis, model[, dopsf, normalise])	Invert using nifty-gridder module.
`predict_ng`(bvis, model, **kwargs)	Predict using convolutional degridding.

ska_sdp_func_python.imaging.weighting Module

Functions that aid weighting the visibility data prior to imaging.

There are two classes of functions:

Changing the weight dependent on noise level or sample density or a combination
Tapering the weight spatially to avoid effects of sharp edges or to emphasize a given scale size in the image

Functions

`taper_visibility_gaussian`(vis[, beam])	Taper the visibility weights.
`taper_visibility_tukey`(vis[, tukey])	Taper the visibility weights.
`weight_visibility`(vis, model[, weighting, ...])	Weight the visibility data.

ska_sdp_func_python.imaging.wg Module

Functions that implement prediction of and imaging from visibilities using the GPU-based w-stacking gridder from ska-sdp-func (which is compatible with the DUCC/nifty gridder).

Functions

`invert_wg`(bvis, model[, dopsf, normalise])	Invert using GPU-based w-stacking gridder module.
`predict_wg`(bvis, model, **kwargs)	Predict using GPU-based w-stacking degridder module.

ska_sdp_func_python.imaging.adaptive_optics Module

Functions that implement creating Zernike polynomials to be applied as phase across the dish.

Note that we copied the implementation of zernike_noll and its related functions from package aotools (Ver 1.0.5) to simplify the installation. Copyright of function zernIndex and zernike_noll belongs to its respectful owner

AOTools: https://github.com/AOtools/aotools version 1.0.5 Releases 22

Functions

zernike_noll(j, N)

Creates the Zernike polynomial with mode index j, where j = 1 corresponds to piston.

ska_sdp_func_python.imaging.primary_beams Module

Functions to create primary beam and voltage pattern models

Functions

`set_pb_header`(pb[, use_local])	Fill in PB header correctly for local coordinates.
`create_pb`(model[, telescope, ...])	Create an image containing the primary beam for a number of cases
`create_pb_generic`(model[, pointingcentre, ...])	Create a generic analytical model of the primary beam
`create_vp`([model, telescope, ...])	Create an image containing the dish voltage pattern for a number of cases
`create_vp_generic`(model[, pointingcentre, ...])	Create a generic analytical model of the voltage pattern
`create_vp_generic_numeric`(model[, ...])	Make an image like model and fill it with an analytical model of the primary beam
`create_low_test_beam`(model[, use_local, azel])	Create a test power beam for LOW
`create_low_test_vp`(model[, use_local, azel])	Create a test voltage beam for LOW
`create_mid_allsky`([frequency, npixel, cellsize])	Approximate all sky MID beam
`convert_azelvp_to_radec`(vp, im, pa)	Convert AZELGEO image to image coords at specific parallactic angle
`normalise_vp`(vp)	Normalise the vp in place so that the peak gain on axis for parallel pols is equal