autolens.Grid2DIterate#

class autolens.Grid2DIterate(shape, dtype=float, buffer=None, offset=0, strides=None, order=None)[source]#
__init__(*args, **kwargs)#

Initialize self. See help(type(self)) for accurate signature.

Methods

__init__(*args, **kwargs)

Initialize self.

all([axis, out, keepdims])

Returns True if all elements evaluate to True.

any([axis, out, keepdims])

Returns True if any of the elements of a evaluate to True.

argmax([axis, out])

Return indices of the maximum values along the given axis.

argmin([axis, out])

Return indices of the minimum values along the given axis of a.

argpartition(kth[, axis, kind, order])

Returns the indices that would partition this array.

argsort([axis, kind, order])

Returns the indices that would sort this array.

array_at_sub_size_from(func, cls, mask, sub_size)

astype(dtype[, order, casting, subok, copy])

Copy of the array, cast to a specified type.

blurring_grid_from(mask, kernel_shape_native)

Setup a blurring-grid from a mask, where a blurring grid consists of all pixels that are masked (and therefore have their values set to (0.0, 0.0)), but are close enough to the unmasked pixels that their values will be convolved into the unmasked those pixels.

blurring_grid_via_kernel_shape_from(…)

Returns the blurring grid from a grid and create it as a Grid2DIterate, via an input 2D kernel shape.

bounding_box(bounding_box, shape_native[, …])

Create a Grid2D (see Grid2D.__new__) from an input bounding box with coordinates [y_min, y_max, x_min, x_max], where the shape_native is used to compute the (y,x) grid values within this bounding box.

byteswap([inplace])

Swap the bytes of the array elements

choose(choices[, out, mode])

Use an index array to construct a new array from a set of choices.

clip([min, max, out])

Return an array whose values are limited to [min, max].

compress(condition[, axis, out])

Return selected slices of this array along given axis.

conj()

Complex-conjugate all elements.

conjugate()

Return the complex conjugate, element-wise.

copy([order])

Return a copy of the array.

cumprod([axis, dtype, out])

Return the cumulative product of the elements along the given axis.

cumsum([axis, dtype, out])

Return the cumulative sum of the elements along the given axis.

diagonal([offset, axis1, axis2])

Return specified diagonals.

distances_to_coordinate_from([coordinate])

Returns the distance of every coordinate on the grid from an input (y,x) coordinate.

dot(b[, out])

Dot product of two arrays.

dump(file)

Dump a pickle of the array to the specified file.

dumps()

Returns the pickle of the array as a string.

extent_with_buffer_from([buffer])

The extent of the grid in scaled units returned as a list [x_min, x_max, y_min, y_max], where all values are buffed such that their extent is further than the grid’s extent..

fill(value)

Fill the array with a scalar value.

flatten([order])

Return a copy of the array collapsed into one dimension.

from_fits(file_path, pixel_scales[, …])

Create a Grid2D (see Grid2D.__new__) from a mask, where only unmasked pixels are included in the grid (if the grid is represented in its native 2D masked values are (0.0, 0.0)).

from_mask(mask[, fractional_accuracy, …])

Create a Grid2DIterate (see Grid2DIterate.__new__) from a mask, where only unmasked pixels are included in the grid (if the grid is represented in 2D masked values are (0.0, 0.0)).

getfield(dtype[, offset])

Returns a field of the given array as a certain type.

grid_2d_radial_projected_from([centre, …])

Determine a projected radial grid of points from a 2D region of coordinates defined by an extent [xmin, xmax, ymin, ymax] and with a (y,x) centre.

grid_2d_radial_projected_shape_slim_from([…])

The function grid_scaled_2d_slim_radial_projected_from() determines a projected radial grid of points from a 2D region of coordinates defined by an extent [xmin, xmax, ymin, ymax] and with a (y,x) centre.

grid_2d_via_deflection_grid_from(deflection_grid)

Returns a new Grid2DIterate from this grid, where the (y,x) coordinates of this grid have a grid of (y,x) values, termed the deflection grid, subtracted from them to determine the new grid of (y,x) values.

grid_at_sub_size_from(func, cls, mask, sub_size)

grid_with_coordinates_within_distance_removed_from(…)

Remove all coordinates from this Grid2D which are within a certain distance of an input list of coordinates.

item(*args)

Copy an element of an array to a standard Python scalar and return it.

itemset(*args)

Insert scalar into an array (scalar is cast to array’s dtype, if possible)

iterated_array_from(func, cls, …)

Iterate over a function that returns an array of values until the it meets a specified fractional accuracy.

iterated_array_jit_from(iterated_array, …)

Create the iterated array from a result array that is computed at a higher sub size leel than the previous grid.

iterated_grid_from(func, cls, grid_lower_sub_2d)

Iterate over a function that returns a grid of values until the it meets a specified fractional accuracy.

iterated_grid_jit_from(iterated_grid, …)

Create the iterated grid from a result grid that is computed at a higher sub size level than the previous grid.

iterated_result_from(func, cls)

Iterate over a function that returns an array or grid of values until the it meets a specified fractional accuracy.

manual(grid, pixel_scales[, shape_native, …])

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in 1D or 2D, automatically determining whether to use the ‘manual_slim’ or ‘manual_native’ methods.

manual_extent(extent, shape_native[, sub_size])

Create a Grid2D (see Grid2D.__new__) by inputting the extent of the (y,x) grid coordinates as an input (x0, x1, y0, y1) tuple.

manual_mask(grid, mask)

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in their native or slimmed format with their corresponding mask, automatically determining whether to use the ‘manual_slim’ or ‘manual_native’ methods.

manual_native(grid, pixel_scales[, …])

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in 2D, for example:

manual_slim(grid, shape_native, pixel_scales)

Create a Grid2DIterate (see Grid2DIterate.__new__) by inputting the grid coordinates in 1D, for example:

manual_yx_1d(y, x, shape_native, pixel_scales)

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates as 1D y and x values, for example:

manual_yx_2d(y, x, pixel_scales[, sub_size, …])

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates as 2D y and x values, for example:

max([axis, out, keepdims, initial, where])

Return the maximum along a given axis.

mean([axis, dtype, out, keepdims])

Returns the average of the array elements along given axis.

min([axis, out, keepdims, initial, where])

Return the minimum along a given axis.

newbyteorder([new_order])

Return the array with the same data viewed with a different byte order.

nonzero()

Return the indices of the elements that are non-zero.

output_to_fits(file_path[, overwrite])

Output the grid to a .fits file.

padded_grid_from(kernel_shape_native)

When the edge pixels of a mask are unmasked and a convolution is to occur, the signal of edge pixels will be ‘missing’ if the grid is used to evaluate the signal via an analytic function.

partition(kth[, axis, kind, order])

Rearranges the elements in the array in such a way that the value of the element in kth position is in the position it would be in a sorted array.

prod([axis, dtype, out, keepdims, initial, …])

Return the product of the array elements over the given axis

ptp([axis, out, keepdims])

Peak to peak (maximum - minimum) value along a given axis.

put(indices, values[, mode])

Set a.flat[n] = values[n] for all n in indices.

ravel([order])

Return a flattened array.

relocated_grid_from(grid)

Relocate the coordinates of a grid to the border of this grid if they are outside the border, where the border is defined as all pixels at the edge of the grid’s mask (see mask._border_1d_indexes).

relocated_pixelization_grid_from(…)

Relocate the coordinates of a pixelization grid to the border of this grid. See the method `relocated_grid_from()`for a full description of how this grid relocation works.

repeat(repeats[, axis])

Repeat elements of an array.

reshape(shape[, order])

Returns an array containing the same data with a new shape.

resize(new_shape[, refcheck])

Change shape and size of array in-place.

return_iterated_array_result(iterated_array)

Returns the resulting iterated array, by mapping it to 1D and then passing it back as an Array2D structure.

round([decimals, out])

Return a with each element rounded to the given number of decimals.

searchsorted(v[, side, sorter])

Find indices where elements of v should be inserted in a to maintain order.

setfield(val, dtype[, offset])

Put a value into a specified place in a field defined by a data-type.

setflags([write, align, uic])

Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY), respectively.

sort([axis, kind, order])

Sort an array in-place.

squared_distances_to_coordinate_from([…])

Returns the squared distance of every coordinate on the grid from an input coordinate.

squeeze([axis])

Remove single-dimensional entries from the shape of a.

std([axis, dtype, out, ddof, keepdims])

Returns the standard deviation of the array elements along given axis.

structure_2d_from(result)

Convert a result from an ndarray to an aa.Array2D or aa.Grid2D structure, where the conversion depends on type(result) as follows:

structure_2d_list_from(result_list)

Convert a result from a list of ndarrays to a list of aa.Array2D or aa.Grid2D structure, where the conversion depends on type(result) as follows:

sum([axis, dtype, out, keepdims, initial, where])

Return the sum of the array elements over the given axis.

swapaxes(axis1, axis2)

Return a view of the array with axis1 and axis2 interchanged.

take(indices[, axis, out, mode])

Return an array formed from the elements of a at the given indices.

threshold_mask_via_arrays_from(…)

Returns a fractional mask from a result array, where the fractional mask describes whether the evaluated value in the result array is within the Grid2DIterate’s specified fractional accuracy.

threshold_mask_via_arrays_jit_from(…)

Jitted functioon to determine the fractional mask, which is a mask where:

threshold_mask_via_grids_from(…)

Returns a fractional mask from a result array, where the fractional mask describes whether the evaluated value in the result array is within the Grid2DIterate’s specified fractional accuracy.

threshold_mask_via_grids_jit_from(…)

Jitted function to determine the fractional mask, which is a mask where:

tobytes([order])

Construct Python bytes containing the raw data bytes in the array.

tofile(fid[, sep, format])

Write array to a file as text or binary (default).

tolist()

Return the array as an a.ndim-levels deep nested list of Python scalars.

tostring([order])

A compatibility alias for tobytes, with exactly the same behavior.

trace([offset, axis1, axis2, dtype, out])

Return the sum along diagonals of the array.

transpose(*axes)

Returns a view of the array with axes transposed.

uniform(shape_native, pixel_scales[, …])

Create a Grid2DIterate (see Grid2DIterate.__new__) as a uniform grid of (y,x) values given an input shape_native and pixel scale of the grid:

values_from(array_slim)

Create a ValuesIrregular object from a 1D NumPy array of values of shape [total_coordinates].

var([axis, dtype, out, ddof, keepdims])

Returns the variance of the array elements, along given axis.

view([dtype][, type])

New view of array with the same data.

Attributes

T

The transposed array.

base

Base object if memory is from some other object.

binned

Return a Grid2D of the binned-up grid in its 1D representation, which is stored with shape [total_unmasked_pixels, 2].

ctypes

An object to simplify the interaction of the array with the ctypes module.

data

Python buffer object pointing to the start of the array’s data.

dtype

Data-type of the array’s elements.

extent

The extent of the grid in scaled units returned as an ndarray of the form [x_min, x_max, y_min, y_max].

flags

Information about the memory layout of the array.

flat

A 1-D iterator over the array.

flipped

Return the grid as an ndarray of shape [total_unmasked_pixels, 2] with flipped values such that coordinates are given as (x,y) values.

imag

The imaginary part of the array.

in_radians

Return the grid as an ndarray where all (y,x) values are converted to Radians.

itemsize

Length of one array element in bytes.

native

Return a Grid2D where the data is stored in its native representation, which has shape [sub_size*total_y_pixels, sub_size*total_x_pixels, 2].

nbytes

Total bytes consumed by the elements of the array.

ndim

Number of array dimensions.

origin

pixel_area

pixel_scale

pixel_scales

real

The real part of the array.

scaled_maxima

The maximum values of the grid in scaled coordinates returned as a tuple (y_max, x_max).

scaled_minima

The minium values of the grid in scaled coordinates returned as a tuple (y_min, x_min).

shape

Tuple of array dimensions.

shape_native

shape_native_scaled

The (y,x) 2D shape of the grid in scaled units, computed from the minimum and maximum y and x values of the grid.

shape_slim

size

Number of elements in the array.

slim

Return a Grid2D where the data is stored its slim representation, which is an ndarray of shape [total_unmasked_pixels * sub_size**2, 2].

strides

Tuple of bytes to step in each dimension when traversing an array.

sub_border_grid

A property that is only computed once per instance and then replaces itself with an ordinary attribute.

sub_shape_native

sub_shape_slim

sub_size

total_area

total_pixels

unmasked_grid