extend preload making function

Author: Jammy2211

autoarray/dataset/imaging/simulator.py

@@ -179,8 +179,7 @@ def via_image_from(
         if over_sample_size is not None:
 
             dataset = dataset.apply_over_sampling(
-                over_sample_size_lp=over_sample_size.native,
-                disable_fft_pad=True
+                over_sample_size_lp=over_sample_size.native, disable_fft_pad=True
             )
 
         return dataset

autoarray/inversion/inversion/abstract.py

@@ -11,6 +11,7 @@
 from autoarray.dataset.interferometer.dataset import Interferometer
 from autoarray.inversion.inversion.dataset_interface import DatasetInterface
 from autoarray.inversion.linear_obj.linear_obj import LinearObj
+from autoarray.inversion.linear_obj.func_list import AbstractLinearObjFuncList
 from autoarray.inversion.pixelization.mappers.abstract import AbstractMapper
 from autoarray.inversion.regularization.abstract import AbstractRegularization
 from autoarray.inversion.inversion.settings import SettingsInversion
@@ -416,11 +417,18 @@ def reconstruction(self) -> np.ndarray:
         """
         if self.settings.use_positive_only_solver:
 
-            if self.preloads.source_pixel_zeroed_indices is not None:
+            if (
+                self.preloads.source_pixel_zeroed_indices is not None
+                and self.settings.force_edge_pixels_to_zeros
+            ):
 
                 # ids of values which are not zeroed and therefore kept in soluiton, which is computed in preloads.
                 ids_to_keep = self.preloads.source_pixel_zeroed_indices_to_keep
 
+                total_linear_light_profiles = self.cls_list_from(
+                    cls=AbstractLinearObjFuncList
+                )
+
                 # Use advanced indexing to select rows/columns
                 data_vector = self.data_vector[ids_to_keep]
                 curvature_reg_matrix = self.curvature_reg_matrix[ids_to_keep][

autoarray/inversion/inversion/imaging/mapping.py

@@ -62,7 +62,7 @@ def _data_vector_mapper(self) -> np.ndarray:
         """
 
         if not self.has(cls=AbstractMapper):
-            return None
+            return
 
         data_vector = np.zeros(self.total_params)
 

autoarray/inversion/pixelization/mesh/mesh_util.py

@@ -352,7 +352,9 @@ def rectangular_edges_from(shape_native, pixel_scales):
     return jnp.stack(edges_list, axis=0)
 
 
-def rectangular_edge_pixel_list_from(shape_native: Tuple[int, int]) -> List[int]:
+def rectangular_edge_pixel_list_from(
+    shape_native: Tuple[int, int], total_linear_light_profiles: int = 0
+) -> List[int]:
     """
     Returns a list of the 1D indices of all pixels on the edge of a rectangular pixelization,
     based on its 2D shape.
@@ -381,7 +383,9 @@ def rectangular_edge_pixel_list_from(shape_native: Tuple[int, int]) -> List[int]
     right = (np.arange(1, rows - 1) + 1) * cols - 1
 
     # Concatenate all edge indices
-    edge_pixel_indices = np.concatenate([top, left, right, bottom])
+    edge_pixel_indices = total_linear_light_profiles + np.concatenate(
+        [top, left, right, bottom]
+    )
 
     # Sort and return
     return np.sort(edge_pixel_indices).tolist()

autoarray/operators/over_sampling/over_sample_util.py

@@ -167,190 +167,60 @@ def sub_size_radial_bins_from(
     return sub_size_list[bin_indices]
 
 
-from autoarray.geometry import geometry_util
-
-
 def grid_2d_slim_over_sampled_via_mask_from(
     mask_2d: np.ndarray,
     pixel_scales: ty.PixelScales,
     sub_size: np.ndarray,
     origin: Tuple[float, float] = (0.0, 0.0),
 ) -> np.ndarray:
     """
-    For a sub-grid, every unmasked pixel of its 2D mask with shape (total_y_pixels, total_x_pixels) is divided into
-    a finer uniform grid of shape (total_y_pixels*sub_size, total_x_pixels*sub_size). This routine computes the (y,x)
-    scaled coordinates at the centre of every sub-pixel defined by this 2D mask array.
+    Compute a sub-sampled 2D grid of coordinates for every unmasked pixel,
+    skipping pixels where sub_size == 0 (to avoid divide-by-zero).
+    """
 
-    The sub-grid is returned on an array of shape (total_unmasked_pixels*sub_size**2, 2). y coordinates are
-    stored in the 0 index of the second dimension, x coordinates in the 1 index. Masked coordinates are therefore
-    removed and not included in the slimmed grid.
+    H, W = mask_2d.shape
+    sy, sx = pixel_scales
+    oy, ox = origin
 
-    Grid2D are defined from the top-left corner, where the first unmasked sub-pixel corresponds to index 0.
-    Sub-pixels that are part of the same mask array pixel are indexed next to one another, such that the second
-    sub-pixel in the first pixel has index 1, its next sub-pixel has index 2, and so forth.
+    # 1) Find unmasked pixel indices in row-major order
+    rows, cols = np.nonzero(~mask_2d)
+    Npix = rows.size
 
-    Parameters
-    ----------
-    mask_2d
-        A 2D array of bools, where `False` values are unmasked and therefore included as part of the calculated
-        sub-grid.
-    pixel_scales
-        The (y,x) scaled units to pixel units conversion factor of the 2D mask array.
-    sub_size
-        The size of the sub-grid that each pixel of the 2D mask array is divided into.
-    origin
-        The (y,x) origin of the 2D array, which the sub-grid is shifted around.
+    if Npix == 0:
+        return np.empty((0, 2), dtype=float)
 
-    Returns
-    -------
-    ndarray
-        A slimmed sub grid of (y,x) scaled coordinates at the centre of every pixel unmasked pixel on the 2D mask
-        array. The sub grid array has dimensions (total_unmasked_pixels*sub_size**2, 2).
+    # 2) Broadcast or validate sub_size array
+    sub_arr = np.asarray(sub_size)
+    sub_arr = np.full(Npix, sub_arr, dtype=int) if sub_arr.size == 1 else sub_arr
 
-    Examples
-    --------
-    mask = np.array([[True, False, True],
-                     [False, False, False]
-                     [True, False, True]])
-    grid_slim = grid_2d_slim_over_sampled_via_mask_from(mask=mask, pixel_scales=(0.5, 0.5), sub_size=1, origin=(0.0, 0.0))
-    """
+    # 3) Mask out any pixels with invalid sub_size <= 0
+    valid_mask = sub_arr > 0
+    rows, cols, sub_arr = rows[valid_mask], cols[valid_mask], sub_arr[valid_mask]
 
-    pixels_in_mask = (np.size(mask_2d) - np.sum(mask_2d)).astype(int)
+    if sub_arr.size == 0:
+        return np.empty((0, 2), dtype=float)
 
-    if isinstance(sub_size, int):
-        sub_size = np.full(fill_value=sub_size, shape=pixels_in_mask)
+    # 4) Compute pixel centers
+    cy = (H - 1) / 2.0
+    cx = (W - 1) / 2.0
+    y_pix = (cy - rows) * sy + oy
+    x_pix = (cols - cx) * sx + ox
 
-    total_sub_pixels = np.sum(sub_size**2)
+    # 5) For each valid pixel, generate its sub-pixel coords
+    coords_list = []
+    for i, s in enumerate(sub_arr):
+        dy = sy / s
+        dx = sx / s
 
-    grid_slim = np.zeros(shape=(total_sub_pixels, 2))
+        y_off = np.linspace(+sy / 2 - dy / 2, -sy / 2 + dy / 2, s)
+        x_off = np.linspace(-sx / 2 + dx / 2, +sx / 2 - dx / 2, s)
 
-    centres_scaled = geometry_util.central_scaled_coordinate_2d_from(
-        shape_native=mask_2d.shape, pixel_scales=pixel_scales, origin=origin
-    )
+        y_sub, x_sub = np.meshgrid(y_off, x_off, indexing="ij")
+
+        coords = np.stack([y_pix[i] + y_sub.ravel(), x_pix[i] + x_sub.ravel()], axis=1)
+        coords_list.append(coords)
 
-    index = 0
-    sub_index = 0
-
-    for y in range(mask_2d.shape[0]):
-        for x in range(mask_2d.shape[1]):
-            if not mask_2d[y, x]:
-                sub = sub_size[index]
-
-                y_sub_half = pixel_scales[0] / 2
-                y_sub_step = pixel_scales[0] / (sub)
-
-                x_sub_half = pixel_scales[1] / 2
-                x_sub_step = pixel_scales[1] / (sub)
-
-                y_scaled = (y - centres_scaled[0]) * pixel_scales[0]
-                x_scaled = (x - centres_scaled[1]) * pixel_scales[1]
-
-                for y1 in range(sub):
-                    for x1 in range(sub):
-                        grid_slim[sub_index, 0] = -(
-                            y_scaled - y_sub_half + y1 * y_sub_step + (y_sub_step / 2.0)
-                        )
-                        grid_slim[sub_index, 1] = (
-                            x_scaled - x_sub_half + x1 * x_sub_step + (x_sub_step / 2.0)
-                        )
-                        sub_index += 1
-
-                index += 1
-
-    return grid_slim
-
-
-#
-
-# def grid_2d_slim_over_sampled_via_mask_from(
-#     mask_2d: np.ndarray,
-#     pixel_scales: ty.PixelScales,
-#     sub_size: np.ndarray,
-#     origin: Tuple[float, float] = (0.0, 0.0),
-# ) -> np.ndarray:
-#     """
-#     For a sub-grid, every unmasked pixel of its 2D mask with shape (total_y_pixels, total_x_pixels) is divided into
-#     a finer uniform grid of shape (total_y_pixels*sub_size, total_x_pixels*sub_size). This routine computes the (y,x)
-#     scaled coordinates at the centre of every sub-pixel defined by this 2D mask array.
-#
-#     The sub-grid is returned on an array of shape (total_unmasked_pixels*sub_size**2, 2). y coordinates are
-#     stored in the 0 index of the second dimension, x coordinates in the 1 index. Masked coordinates are therefore
-#     removed and not included in the slimmed grid.
-#
-#     Grid2D are defined from the top-left corner, where the first unmasked sub-pixel corresponds to index 0.
-#     Sub-pixels that are part of the same mask array pixel are indexed next to one another, such that the second
-#     sub-pixel in the first pixel has index 1, its next sub-pixel has index 2, and so forth.
-#
-#     Parameters
-#     ----------
-#     mask_2d
-#         A 2D array of bools, where `False` values are unmasked and therefore included as part of the calculated
-#         sub-grid.
-#     pixel_scales
-#         The (y,x) scaled units to pixel units conversion factor of the 2D mask array.
-#     sub_size
-#         The size of the sub-grid that each pixel of the 2D mask array is divided into.
-#     origin
-#         The (y,x) origin of the 2D array, which the sub-grid is shifted around.
-#
-#     Returns
-#     -------
-#     ndarray
-#         A slimmed sub grid of (y,x) scaled coordinates at the centre of every pixel unmasked pixel on the 2D mask
-#         array. The sub grid array has dimensions (total_unmasked_pixels*sub_size**2, 2).
-#
-#     Examples
-#     --------
-#     mask = np.array([[True, False, True],
-#                      [False, False, False]
-#                      [True, False, True]])
-#     grid_slim = grid_2d_slim_over_sampled_via_mask_from(mask=mask, pixel_scales=(0.5, 0.5), sub_size=1, origin=(0.0, 0.0))
-#     """
-#
-#     H, W = mask_2d.shape
-#     sy, sx = pixel_scales
-#     oy, ox = origin
-#
-#     # 1) Find unmasked pixel indices in row-major order
-#     rows, cols = np.nonzero(~mask_2d)
-#     Npix = rows.size
-#
-#     # 2) Broadcast or validate sub_size array
-#     sub_arr = np.asarray(sub_size)
-#     sub_arr = np.full(Npix, sub_arr, dtype=int) if sub_arr.size == 1 else sub_arr
-#
-#     # 3) Compute pixel centers (y ↑ up, x → right)
-#     cy = (H - 1) / 2.0
-#     cx = (W - 1) / 2.0
-#     y_pix = (cy - rows) * sy + oy
-#     x_pix = (cols - cx) * sx + ox
-#
-#     # 4) For each pixel, generate its sub-pixel coords and collect
-#     coords_list = []
-#     for i in range(Npix):
-#         s = sub_arr[i]
-#         dy = sy / s
-#         dx = sx / s
-#
-#         # y offsets: from top (+sy/2 - dy/2) down to bottom (-sy/2 + dy/2)
-#         y_off = np.linspace(+sy/2 - dy/2, -sy/2 + dy/2, s)
-#         # x offsets: left to right
-#         x_off = np.linspace(-sx/2 + dx/2, +sx/2 - dx/2, s)
-#
-#         # build subgrid
-#         y_sub, x_sub = np.meshgrid(y_off, x_off, indexing="ij")
-#         y_sub = y_sub.ravel()
-#         x_sub = x_sub.ravel()
-#
-#         # center + offsets
-#         y_center = y_pix[i]
-#         x_center = x_pix[i]
-#         coords = np.stack([y_center + y_sub, x_center + x_sub], axis=1)
-#
-#         coords_list.append(coords)
-#
-#     # 5) Concatenate all sub-pixel blocks in row-major pixel order
-#     return np.vstack(coords_list)
+    return np.vstack(coords_list)
 
 
 def over_sample_size_via_radial_bins_from(

autoarray/plot/mat_plot/two_d.py

@@ -65,6 +65,7 @@ def __init__(
         serial_overscan_plot: Optional[w2d.SerialOverscanPlot] = None,
         use_log10: bool = False,
         plot_mask: bool = True,
+        quick_update: bool = False,
     ):
         """
         Visualizes 2D data structures (e.g an `Array2D`, `Grid2D`, `VectorField`, etc.) using Matplotlib.
@@ -227,6 +228,7 @@ def __init__(
         self.plot_mask = plot_mask
 
         self.is_for_subplot = False
+        self.quick_update = quick_update
 
     def plot_array(
         self,

autoarray/plot/wrap/base/output.py

@@ -157,7 +157,9 @@ def to_figure(
                             overwrite=True,
                         )
 
-    def subplot_to_figure(self, auto_filename: Optional[str] = None):
+    def subplot_to_figure(
+        self, auto_filename: Optional[str] = None, also_show: bool = False
+    ):
         """
         Output a subplot figure, either as an image on the screen or to the hard-disk as a png or fits file.
 
@@ -184,6 +186,9 @@ def subplot_to_figure(self, auto_filename: Optional[str] = None):
             elif format == "png" or format == "pdf":
                 self.savefig(filename, output_path, format)
 
+        if also_show:
+            plt.show()
+
     def to_figure_output_mode(self, filename: str):
         global COUNT
 

test_autoarray/config/general.yaml

@@ -19,15 +19,6 @@ numba:
   nopython: true
   parallel: false
   use_numba: true
-output:
-  backup_every_update: 10
-  grid_results_interval: 100
-  log_every_update: 50
-  log_file: output.log
-  log_level: INFO
-  model_results_decimal_places: 3
-  model_results_every_update: 100
-  remove_files: false
 pixelization:
   voronoi_nn_max_interpolation_neighbors: 300
 profiling:

test_autoarray/dataset/imaging/test_dataset.py

@@ -33,7 +33,6 @@ def make_test_data_path():
     return test_data_path
 
 
-
 def test__noise_covariance_input__noise_map_uses_diag():
     image = aa.Array2D.ones(shape_native=(3, 3), pixel_scales=1.0)
     noise_covariance_matrix = np.ones(shape=(9, 9))

test_autoarray/structures/arrays/test_kernel_2d.py

@@ -527,6 +527,4 @@ def test__convolve_imaged_from__via_fft__sizes_not_precomputed__compare_numerica
         image=masked_image, blurring_image=blurring_image
     )
 
-    assert blurred_fft.native.array[13, 13] == pytest.approx(
-        228.5, rel=1e-6, abs=1e-6
-    )
+    assert blurred_fft.native.array[13, 13] == pytest.approx(228.5, rel=1e-6, abs=1e-6)