lenstronomy.ImSim.Numerics package

Submodules

lenstronomy.ImSim.Numerics.adaptive_numerics module

class AdaptiveConvolution(kernel_super, supersampling_factor, conv_supersample_pixels, supersampling_kernel_size=None, compute_pixels=None, nopython=True, cache=True, parallel=False)

Bases: object

This class performs convolutions of a subset of pixels at higher supersampled resolution Goal: speed up relative to higher resolution FFT when only considering a (small) subset of pixels to be convolved on the higher resolution grid.

strategy: 1. lower resolution convolution over full image with FFT 2. subset of pixels with higher resolution Numba convolution (with smaller kernel) 3. the same subset of pixels with low resolution Numba convolution (with same kernel as step 2) adaptive solution is 1 + 2 - 3

__init__(kernel_super, supersampling_factor, conv_supersample_pixels, supersampling_kernel_size=None, compute_pixels=None, nopython=True, cache=True, parallel=False)

Parameters:

• kernel_super – convolution kernel in units of super sampled pixels provided, odd length per axis

• supersampling_factor – factor of supersampling relative to pixel grid

• conv_supersample_pixels – bool array same size as data, pixels to be convolved and their light to be blurred

• supersampling_kernel_size – number of pixels (in units of the image pixels) that are convolved with the supersampled kernel

• compute_pixels – bool array of size of image, these pixels (if True) will get blurred light from other pixels

• nopython – bool, numba jit setting to use python or compiled.

• cache – bool, numba jit setting to use cache

• parallel – bool, numba jit setting to use parallel mode

re_size_convolve(image_low_res, image_high_res)

Parameters:

• image_low_res – regular sampled image/model

• image_high_res – supersampled image/model to be convolved on a regular pixel grid

Returns:

convolved and re-sized image

convolve2d(image_high_res)

Parameters:

image_high_res – supersampled image/model to be convolved on a regular pixel grid

Returns:

convolved and re-sized image

lenstronomy.ImSim.Numerics.convolution module

class PixelKernelConvolution(kernel, convolution_type='fft_static')

Bases: object

Class to compute convolutions for a given pixelized kernel (fft, grid)

__init__(kernel, convolution_type='fft_static')

Parameters:

• kernel – 2d array, convolution kernel

• convolution_type – string, ‘fft’, ‘grid’, ‘fft_static’ mode of 2d convolution

pixel_kernel(num_pix=None)

Access pixelated kernel.

Parameters:

num_pix – size of returned kernel (odd number per axis). If None, return the original kernel.

Returns:

pixel kernel centered

copy_transpose()

Returns:

copy of the class with kernel set to the transpose of original one

convolution2d(image)

Parameters:

image – 2d array (image) to be convolved

Returns:

fft convolution

re_size_convolve(image_low_res, image_high_res=None)

Parameters:

• image_low_res – regular sampled image/model

• image_high_res – supersampled image/model to be convolved on a regular pixel grid

Returns:

convolved and re-sized image

class SubgridKernelConvolution(kernel_supersampled, supersampling_factor, supersampling_kernel_size=None, convolution_type='fft_static')

Bases: object

Class to compute the convolution on a supersampled grid with partial convolution computed on the regular grid.

__init__(kernel_supersampled, supersampling_factor, supersampling_kernel_size=None, convolution_type='fft_static')

Parameters:

• kernel_supersampled – kernel in supersampled pixels

• supersampling_factor – supersampling factor relative to the image pixel grid

• supersampling_kernel_size – number of pixels (in units of the image pixels) that are convolved with the supersampled kernel

convolution2d(image)

Parameters:

image – 2d array (high resoluton image) to be convolved and re-sized

Returns:

convolved image

re_size_convolve(image_low_res, image_high_res)

Parameters:

image_high_res – supersampled image/model to be convolved on a regular pixel grid

Returns:

convolved and re-sized image

class MultiGaussianConvolution(sigma_list, fraction_list, pixel_scale, supersampling_factor=1, supersampling_convolution=False, truncation=2)

Bases: object

Class to perform a convolution consisting of multiple 2d Gaussians This is aimed to lead to a speed-up without significant loss of accuracy do to the simplified convolution kernel relative to a pixelized kernel.

__init__(sigma_list, fraction_list, pixel_scale, supersampling_factor=1, supersampling_convolution=False, truncation=2)

Parameters:

• sigma_list – list of std value of Gaussian kernel

• fraction_list – fraction of flux to be convoled with each Gaussian kernel

• pixel_scale – scale of pixel width (to convert sigmas into units of pixels)

• truncation – float. Truncate the filter at this many standard deviations. Default is 4.0.

convolution2d(image)

2d convolution.

Parameters:

image – 2d numpy array, image to be convolved

Returns:

convolved image, 2d numpy array

re_size_convolve(image_low_res, image_high_res)

Parameters:

image_high_res – supersampled image/model to be convolved on a regular pixel grid

Returns:

convolved and re-sized image

pixel_kernel(num_pix)

Computes a pixelized kernel from the MGE parameters.

Parameters:

num_pix – int, size of kernel (odd number per axis)

Returns:

pixel kernel centered

class FWHMGaussianConvolution(kernel, truncation=4)

Bases: object

Uses a two-dimensional Gaussian function with same FWHM of given kernel as approximation.

__init__(kernel, truncation=4)

Parameters:

• kernel – 2d kernel

• truncation – sigma scaling of kernel truncation

convolution2d(image)

2d convolution.

Parameters:

image – 2d numpy array, image to be convolved

Returns:

convolved image, 2d numpy array

class MGEConvolution(kernel, pixel_scale, order=1)

Bases: object

Approximates a 2d kernel with an azimuthal Multi-Gaussian expansion.

__init__(kernel, pixel_scale, order=1)

Parameters:

• kernel – 2d convolution kernel (centered, odd axis number)

• order – order of Multi-Gaussian Expansion

convolution2d(image)

Parameters:

image –

Returns:

kernel_difference()

Returns:

difference between true kernel and MGE approximation

lenstronomy.ImSim.Numerics.grid module

class AdaptiveGrid(nx, ny, transform_pix2angle, ra_at_xy_0, dec_at_xy_0, supersampling_indexes, supersampling_factor, flux_evaluate_indexes=None)

Bases: Coordinates1D

Manages a super-sampled grid on the partial image.

__init__(nx, ny, transform_pix2angle, ra_at_xy_0, dec_at_xy_0, supersampling_indexes, supersampling_factor, flux_evaluate_indexes=None)

Parameters:

• nx – number of pixels in x-axis

• ny – number of pixels in y-axis

• transform_pix2angle – 2x2 matrix, mapping of pixel to coordinate

• ra_at_xy_0 – ra coordinate at pixel (0,0)

• dec_at_xy_0 – dec coordinate at pixel (0,0)

• supersampling_indexes – bool array of shape nx x ny, corresponding to pixels being super_sampled

• supersampling_factor – int, factor (per axis) of super-sampling

• flux_evaluate_indexes – bool array of shape nx x ny, corresponding to pixels being evaluated (for both low and high res). Default is None, replaced by setting all pixels to being evaluated.

property coordinates_evaluate

Returns:

1d array of all coordinates being evaluated to perform the image computation

flux_array2image_low_high(flux_array, high_res_return=True)

Parameters:

• flux_array – 1d array of low and high resolution flux values corresponding to the coordinates_evaluate order

• high_res_return – bool, if True also returns the high resolution image (needs more computation and is only needed when convolution is performed on the supersampling level)

Returns:

2d array, 2d array, corresponding to (partial) images in low and high resolution (to be convolved)

class RegularGrid(nx, ny, transform_pix2angle, ra_at_xy_0, dec_at_xy_0, supersampling_factor=1, flux_evaluate_indexes=None)

Bases: Coordinates1D

Manages a super-sampled grid on the partial image.

__init__(nx, ny, transform_pix2angle, ra_at_xy_0, dec_at_xy_0, supersampling_factor=1, flux_evaluate_indexes=None)

Parameters:

• nx – number of pixels in x-axis

• ny – number of pixels in y-axis

• transform_pix2angle – 2x2 matrix, mapping of pixel to coordinate

• ra_at_xy_0 – ra coordinate at pixel (0,0)

• dec_at_xy_0 – dec coordinate at pixel (0,0)

• supersampling_factor – int, factor (per axis) of super-sampling

• flux_evaluate_indexes – bool array of shape nx x ny, corresponding to pixels being evaluated (for both low and high res). Default is None, replaced by setting all pixels to being evaluated.

property coordinates_evaluate

Returns:

1d array of all coordinates being evaluated to perform the image computation

property grid_points_spacing

Effective spacing between coordinate points, after supersampling.

Returns:

sqrt(pixel_area)/supersampling_factor.

property num_grid_points_axes

Effective number of points along each axes, after supersampling.

Returns:

number of pixels per axis, nx*supersampling_factor ny*supersampling_factor

property supersampling_factor

Returns:

factor (per axis) of super-sampling relative to a pixel

flux_array2image_low_high(flux_array, **kwargs)

Parameters:

flux_array – 1d array of low and high resolution flux values corresponding to the coordinates_evaluate order

Returns:

2d array, 2d array, corresponding to (partial) images in low and high resolution (to be convolved)

lenstronomy.ImSim.Numerics.numba_convolution module

class NumbaConvolution(kernel, conv_pixels, compute_pixels=None, nopython=True, cache=True, parallel=False, memory_raise=True)

Bases: object

Class to convolve explicit pixels only.

the convolution is inspired by pyautolens: https://github.com/Jammy2211/PyAutoLens

__init__(kernel, conv_pixels, compute_pixels=None, nopython=True, cache=True, parallel=False, memory_raise=True)

Parameters:

• kernel – convolution kernel in units of the image pixels provided, odd length per axis

• conv_pixels – bool array same size as data, pixels to be convolved and their light to be blurred

• compute_pixels – bool array of size of image, these pixels (if True) will get blurred light from other pixels

• nopython – bool, numba jit setting to use python or compiled.

• cache – bool, numba jit setting to use cache

• parallel – bool, numba jit setting to use parallel mode

• memory_raise – bool, if True, checks whether memory required to store the convolution kernel is within certain bounds

convolve2d(image)

2d convolution.

Parameters:

image – 2d numpy array, image to be convolved

Returns:

convolved image, 2d numpy array

lenstronomy.ImSim.Numerics.numerics module

class Numerics(pixel_grid, psf, supersampling_factor=1, compute_mode='regular', supersampling_convolution=False, supersampling_kernel_size=5, flux_evaluate_indexes=None, supersampled_indexes=None, compute_indexes=None, point_source_supersampling_factor=1, convolution_kernel_size=None, convolution_type='fft_static', truncation=4)

Bases: PointSourceRendering

This classes manages the numerical options and computations of an image.

The class has two main functions, re_size_convolve() and coordinates_evaluate()

__init__(pixel_grid, psf, supersampling_factor=1, compute_mode='regular', supersampling_convolution=False, supersampling_kernel_size=5, flux_evaluate_indexes=None, supersampled_indexes=None, compute_indexes=None, point_source_supersampling_factor=1, convolution_kernel_size=None, convolution_type='fft_static', truncation=4)

Parameters:

• pixel_grid – PixelGrid() class instance

• psf – PSF() class instance

• compute_mode – options are: ‘regular’, ‘adaptive’

• supersampling_factor – int, factor of higher resolution sub-pixel sampling of surface brightness

• supersampling_convolution – bool, if True, performs (part of) the convolution on the super-sampled grid/pixels

• supersampling_kernel_size – int (odd number), size (in regular pixel units) of the super-sampled convolution

• flux_evaluate_indexes – boolean 2d array of size of image (or None, then initiated as gird of True’s). Pixels indicated with True will be used to perform the surface brightness computation (and possible lensing ray-shooting). Pixels marked as False will be assigned a flux value of zero (or ignored in the adaptive convolution)

• supersampled_indexes – 2d boolean array (only used in mode=’adaptive’) of pixels to be supersampled (in surface brightness and if supersampling_convolution=True also in convolution). All other pixels not set to =True will not be super-sampled.

• compute_indexes – 2d boolean array (only used in compute_mode=’adaptive’), marks pixel that the response after convolution is computed (all others =0). This can be set to likelihood_mask in the Likelihood module for consistency.

• point_source_supersampling_factor – super-sampling resolution of the point source placing

• convolution_kernel_size – int, odd number, size of convolution kernel. If None, takes size of point_source_kernel

• convolution_type – string, ‘fft’, ‘grid’, ‘fft_static’ mode of 2d convolution

re_size_convolve(flux_array, unconvolved=False)

Parameters:

• flux_array – 1d array, flux values corresponding to coordinates_evaluate

• unconvolved – boolean, if True, does not apply a convolution

Returns:

convolved image on regular pixel grid, 2d array

property grid_supersampling_factor

Returns:

supersampling factor set for higher resolution sub-pixel sampling of surface brightness

property coordinates_evaluate

Returns:

1d array of all coordinates being evaluated to perform the image computation

property convolution_class

Returns:

convolution class (can be SubgridKernelConvolution, PixelKernelConvolution, MultiGaussianConvolution, …)

property grid_class

Returns:

grid class (can be RegularGrid, AdaptiveGrid)

lenstronomy.ImSim.Numerics.partial_image module

class PartialImage(partial_read_bools)

Bases: object

Class to deal with the use of partial slicing of a 2d data array, to be used for various computations where only a subset of pixels need to be know.

__init__(partial_read_bools)

Parameters:

partial_read_bools – 2d numpy array of bools indicating which indexes to be processed

partial_array(image)

Parameters:

image – 2d array

Returns:

1d array of partial list

property index_array

Returns:

2d array with indexes (integers) corresponding to the 1d array, -1 when masked

array_from_partial(partial_array)

Parameters:

partial_array – 1d array of the partial indexes

Returns:

full 1d array

image_from_partial(partial_array)

Parameters:

partial_array – 1d array corresponding to the indexes of the partial read

Returns:

full image with zeros elsewhere

property num_partial

Returns:

number of indexes handled in the partial section

lenstronomy.ImSim.Numerics.point_source_rendering module

class PointSourceRendering(pixel_grid, supersampling_factor, psf)

Bases: object

Numerics to compute the point source response on an image.

__init__(pixel_grid, supersampling_factor, psf)

Parameters:

• pixel_grid – PixelGrid() instance

• supersampling_factor – int, factor of supersampling of point source

• psf – PSF() instance

point_source_rendering(ra_pos, dec_pos, amp)

Parameters:

• ra_pos – list of RA positions of point source(s)

• dec_pos – list of DEC positions of point source(s)

• amp – list of amplitudes of point source(s)

Returns:

2d numpy array of size of the image with the point source(s) rendered

psf_error_map(ra_pos, dec_pos, amp, data, fix_psf_error_map=False)

Parameters:

• ra_pos – image positions of point sources

• dec_pos – image positions of point sources

• amp – amplitude of modeled point sources

• data – 2d numpy array of the data

• fix_psf_error_map – bool, if True, estimates the error based on the input (modeled) amplitude, else uses the data to do so.

Returns:

2d array of size of the image with error terms (sigma**2) expected from inaccuracies in the PSF modeling

Module contents