black

Author: Jammy2211

autoarray/inversion/inversion/abstract.py

@@ -150,8 +150,7 @@ def param_range_list_from(self, cls: Type) -> List[List[int]]:
         A list of the index range of the parameters of each linear object in the inversion of the input cls type.
         """
         return inversion_util.param_range_list_from(
-            cls=cls,
-            linear_obj_list=self.linear_obj_list
+            cls=cls, linear_obj_list=self.linear_obj_list
         )
 
     def cls_list_from(self, cls: Type, cls_filtered: Optional[Type] = None) -> List:
@@ -429,20 +428,26 @@ def reconstruction(self) -> np.ndarray:
 
                 # 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][:, ids_to_keep]
+                curvature_reg_matrix = self.curvature_reg_matrix[ids_to_keep][
+                    :, ids_to_keep
+                ]
 
                 # Perform reconstruction via fnnls
-                reconstruction_partial = inversion_util.reconstruction_positive_only_from(
-                    data_vector=data_vector,
-                    curvature_reg_matrix=curvature_reg_matrix,
-                    settings=self.settings,
+                reconstruction_partial = (
+                    inversion_util.reconstruction_positive_only_from(
+                        data_vector=data_vector,
+                        curvature_reg_matrix=curvature_reg_matrix,
+                        settings=self.settings,
+                    )
                 )
 
                 # Allocate full solution array
                 reconstruction = jnp.zeros(self.data_vector.shape[0])
 
                 # Scatter the partial solution back to the full shape
-                reconstruction = reconstruction.at[ids_to_keep].set(reconstruction_partial)
+                reconstruction = reconstruction.at[ids_to_keep].set(
+                    reconstruction_partial
+                )
 
                 return reconstruction
 
@@ -638,7 +643,9 @@ def log_det_curvature_reg_matrix_term(self) -> float:
 
         try:
             return 2.0 * np.sum(
-                jnp.log(jnp.diag(jnp.linalg.cholesky(self.curvature_reg_matrix_reduced)))
+                jnp.log(
+                    jnp.diag(jnp.linalg.cholesky(self.curvature_reg_matrix_reduced))
+                )
             )
         except np.linalg.LinAlgError as e:
             raise exc.InversionException() from e

autoarray/inversion/inversion/factory.py

@@ -22,7 +22,7 @@ def inversion_from(
     dataset: Union[Imaging, Interferometer, DatasetInterface],
     linear_obj_list: List[LinearObj],
     settings: SettingsInversion = SettingsInversion(),
-    preloads :Preloads = None,
+    preloads: Preloads = None,
 ):
     """
     Factory which given an input dataset and list of linear objects, creates an `Inversion`.
@@ -71,7 +71,7 @@ def inversion_imaging_from(
     dataset,
     linear_obj_list: List[LinearObj],
     settings: SettingsInversion = SettingsInversion(),
-    preloads : Preloads = None,
+    preloads: Preloads = None,
 ):
     """
     Factory which given an input `Imaging` dataset and list of linear objects, creates an `InversionImaging`.

autoarray/inversion/inversion/interferometer/inversion_interferometer_util.py

@@ -1871,4 +1871,4 @@ def sub_slim_indexes_for_pix_index(
         sub_slim_indexes_for_pix_index,
         sub_slim_sizes_for_pix_index,
         sub_slim_weights_for_pix_index,
-    )
+    )

autoarray/inversion/inversion/interferometer/w_tilde.py

@@ -130,7 +130,7 @@ def curvature_matrix_diag(self) -> np.ndarray:
             sub_slim_indexes_for_pix_index,
             sub_slim_sizes_for_pix_index,
             sub_slim_weights_for_pix_index,
-        ) =  inversion_interferometer_util.sub_slim_indexes_for_pix_index(
+        ) = inversion_interferometer_util.sub_slim_indexes_for_pix_index(
             pix_indexes_for_sub_slim_index=mapper.pix_indexes_for_sub_slim_index,
             pix_weights_for_sub_slim_index=mapper.pix_weights_for_sub_slim_index,
             pix_pixels=mapper.pixels,

autoarray/inversion/inversion/inversion_util.py

@@ -390,4 +390,4 @@ def param_range_list_from(cls: Type, linear_obj_list) -> List[List[int]]:
 
         pixel_count += linear_obj.params
 
-    return index_list
+    return index_list

autoarray/inversion/pixelization/mappers/mapper_util.py

@@ -499,31 +499,33 @@ def adaptive_pixel_signals_from(
     M_sub, B = pix_indexes_for_sub_slim_index.shape
 
     # 1) Flatten the per‐mapping tables:
-    flat_pixidx  = pix_indexes_for_sub_slim_index.reshape(-1)    # (M_sub*B,)
-    flat_weights = pixel_weights.reshape(-1)   # (M_sub*B,)
+    flat_pixidx = pix_indexes_for_sub_slim_index.reshape(-1)  # (M_sub*B,)
+    flat_weights = pixel_weights.reshape(-1)  # (M_sub*B,)
 
     # 2) Build a matching “parent‐slim” index for each flattened entry:
-    I_sub = jnp.repeat(jnp.arange(M_sub), B)                     # (M_sub*B,)
+    I_sub = jnp.repeat(jnp.arange(M_sub), B)  # (M_sub*B,)
 
     # 3) Mask out any k >= pix_size_for_sub_slim_index[i]
-    valid = (I_sub < 0)  # dummy to get shape
+    valid = I_sub < 0  # dummy to get shape
     # better:
     valid = (jnp.arange(B)[None, :] < pix_size_for_sub_slim_index[:, None]).reshape(-1)
 
     flat_weights = jnp.where(valid, flat_weights, 0.0)
-    flat_pixidx  = jnp.where(valid, flat_pixidx, pixels)  # send invalid indices to an out-of-bounds slot
+    flat_pixidx = jnp.where(
+        valid, flat_pixidx, pixels
+    )  # send invalid indices to an out-of-bounds slot
 
     # 4) Look up data & multiply by mapping weights:
     flat_data_vals = adapt_data[slim_index_for_sub_slim_index][I_sub]  # (M_sub*B,)
-    flat_contrib   = flat_data_vals * flat_weights                     # (M_sub*B,)
+    flat_contrib = flat_data_vals * flat_weights  # (M_sub*B,)
 
     # 5) Scatter‐add into signal sums and counts:
-    pixel_signals = jnp.zeros((pixels+1,)).at[flat_pixidx].add(flat_contrib)
-    pixel_counts  = jnp.zeros((pixels+1,)).at[flat_pixidx].add(valid.astype(float))
+    pixel_signals = jnp.zeros((pixels + 1,)).at[flat_pixidx].add(flat_contrib)
+    pixel_counts = jnp.zeros((pixels + 1,)).at[flat_pixidx].add(valid.astype(float))
 
     # 6) Drop the extra “out-of-bounds” slot:
     pixel_signals = pixel_signals[:pixels]
-    pixel_counts  = pixel_counts[:pixels]
+    pixel_counts = pixel_counts[:pixels]
 
     # 7) Normalize
     pixel_counts = jnp.where(pixel_counts > 0, pixel_counts, 1.0)
@@ -532,7 +534,7 @@ def adaptive_pixel_signals_from(
     pixel_signals = jnp.where(max_sig > 0, pixel_signals / max_sig, pixel_signals)
 
     # 8) Exponentiate
-    return pixel_signals ** signal_scale
+    return pixel_signals**signal_scale
 
 
 def mapping_matrix_from(
@@ -652,27 +654,27 @@ def mapped_to_source_via_mapping_matrix_from(
     mapping_matrix: np.ndarray, array_slim: np.ndarray
 ) -> np.ndarray:
     """
-     Map a masked 2D image (in slim form) into the source plane by summing and averaging
-     each image-pixel's contribution to its mapped source-pixels.
-
-     Each row i of `mapping_matrix` describes how image-pixel i is distributed (with
-     weights) across the source-pixels j.  `array_slim[i]` is then multiplied by those
-     weights and summed over i to give each source-pixel’s total mapped value; finally,
-     we divide by the number of nonzero contributions to form an average.
-
-     Parameters
-     ----------
-     mapping_matrix : ndarray of shape (M, N)
-         mapping_matrix[i, j] ≥ 0 is the weight by which image-pixel i contributes to
-         source-pixel j.  Zero means “no contribution.”
-     array_slim : ndarray of shape (M,)
-         The slimmed image values for each image-pixel i.
-
-     Returns
-     -------
-     mapped_to_source : ndarray of shape (N,)
-         The averaged, mapped values on each of the N source-pixels.
-     """
+    Map a masked 2D image (in slim form) into the source plane by summing and averaging
+    each image-pixel's contribution to its mapped source-pixels.
+
+    Each row i of `mapping_matrix` describes how image-pixel i is distributed (with
+    weights) across the source-pixels j.  `array_slim[i]` is then multiplied by those
+    weights and summed over i to give each source-pixel’s total mapped value; finally,
+    we divide by the number of nonzero contributions to form an average.
+
+    Parameters
+    ----------
+    mapping_matrix : ndarray of shape (M, N)
+        mapping_matrix[i, j] ≥ 0 is the weight by which image-pixel i contributes to
+        source-pixel j.  Zero means “no contribution.”
+    array_slim : ndarray of shape (M,)
+        The slimmed image values for each image-pixel i.
+
+    Returns
+    -------
+    mapped_to_source : ndarray of shape (N,)
+        The averaged, mapped values on each of the N source-pixels.
+    """
     # weighted sums: sum over i of array_slim[i] * mapping_matrix[i, j]
     # ==> vector‐matrix multiply: (1×M) dot (M×N) → (N,)
     mapped_to_source = array_slim @ mapping_matrix
@@ -722,4 +724,3 @@ def data_weight_total_for_pix_from(
 
     # Sum weights by pixel index
     return np.bincount(flat_idxs, weights=flat_weights, minlength=pixels)
-

autoarray/inversion/regularization/regularization_util.py

@@ -309,6 +309,7 @@ def weighted_regularization_matrix_from(
 #
 #     return regularization_matrix
 
+
 def brightness_zeroth_regularization_matrix_from(
     regularization_weights: np.ndarray,
 ) -> np.ndarray:
@@ -330,7 +331,6 @@ def brightness_zeroth_regularization_matrix_from(
     return np.diag(regularization_weight_squared)
 
 
-
 def reg_split_from(
     splitted_mappings: np.ndarray,
     splitted_sizes: np.ndarray,
@@ -447,8 +447,7 @@ def pixel_splitted_regularization_matrix_from(
 
             # Outer product of weights and symmetric updates
             outer = np.outer(weight, weight) * reg_w
-            rows, cols = np.meshgrid(mapping, mapping, indexing='ij')
+            rows, cols = np.meshgrid(mapping, mapping, indexing="ij")
             regularization_matrix[rows, cols] += outer
 
     return regularization_matrix
-

autoarray/preloads.py

@@ -10,7 +10,11 @@
 
 class Preloads:
 
-    def __init__(self, mapper_indices: np.ndarray = None, source_pixel_zeroed_indices: np.ndarray = None):
+    def __init__(
+        self,
+        mapper_indices: np.ndarray = None,
+        source_pixel_zeroed_indices: np.ndarray = None,
+    ):
         """
         Stores preloaded arrays and matrices used during pixelized linear inversions, improving both performance
         and compatibility with JAX.

test_autoarray/inversion/inversion/imaging/test_imaging.py

@@ -163,5 +163,5 @@ def test__w_tilde_checks_noise_map_and_raises_exception_if_preloads_dont_match_n
                     mapping_matrix=np.ones(matrix_shape), source_plane_data_grid=grid
                 )
             ],
-            settings=aa.SettingsInversion(use_w_tilde=True)
+            settings=aa.SettingsInversion(use_w_tilde=True),
         )

test_autoarray/inversion/inversion/test_factory.py

@@ -198,9 +198,8 @@ def test__inversion_imaging__source_pixel_zeroed_indices(
         linear_obj_list=[rectangular_mapper_7x7_3x3],
         settings=aa.SettingsInversion(use_w_tilde=False, use_positive_only_solver=True),
         preloads=aa.Preloads(
-            mapper_indices=range(0, 9),
-            source_pixel_zeroed_indices=np.array([0])
-        )
+            mapper_indices=range(0, 9), source_pixel_zeroed_indices=np.array([0])
+        ),
     )
 
     assert inversion.reconstruction.shape[0] == 9
@@ -576,7 +575,7 @@ def test__inversion_matrices__x2_mappers(
 
     assert inversion.reconstruction_dict[rectangular_mapper_7x7_3x3][
         4
-    ] == pytest.approx( 0.5000029374603968, 1.0e-4)
+    ] == pytest.approx(0.5000029374603968, 1.0e-4)
     assert inversion.reconstruction_dict[delaunay_mapper_9_3x3][4] == pytest.approx(
         0.4999970390886761, 1.0e-4
     )