autoarray 2026.9.27.2__tar.gz → 2026.10.2.1__tar.gz

{autoarray-2026.9.27.2 → autoarray-2026.10.2.1}/.claude/hooks/session-start.sh

@@ -130,14 +130,14 @@ marked_root() {
 # A directory counts as a workspace root if it holds an organ checkout. Any
 # organ: a remote session may hold exactly one, and it is still a root.
 holds_an_organ() {
-    [ -d "$1/PyAutoMind" ] || [ -d "$1/PyAutoBrain" ] || [ -d "$1/PyAutoHeart" ] \
-        || [ -d "$1/PyAutoHands" ] || [ -d "$1/PyAutoMemory" ] || [ -d "$1/PyAutoGut" ] \
-        || [ -d "$1/PyAutoNerves" ] || [ -d "$1/PyAutoCortex" ] || [ -d "$1/PyAutoEyes" ] \
-        || [ -d "$1/organs/PyAutoMind" ] \
-        || [ -d "$1/organs/PyAutoBrain" ] || [ -d "$1/organs/PyAutoHeart" ] \
-        || [ -d "$1/organs/PyAutoHands" ] || [ -d "$1/organs/PyAutoMemory" ] \
-        || [ -d "$1/organs/PyAutoGut" ] || [ -d "$1/organs/PyAutoNerves" ] \
-        || [ -d "$1/organs/PyAutoCortex" ] || [ -d "$1/organs/PyAutoEyes" ]
+    [ -d "$1/PyAutoBrain" ] || [ -d "$1/PyAutoMind" ] || [ -d "$1/PyAutoCortex" ] \
+        || [ -d "$1/PyAutoMemory" ] || [ -d "$1/PyAutoEyes" ] || [ -d "$1/PyAutoHeart" ] \
+        || [ -d "$1/PyAutoHands" ] || [ -d "$1/PyAutoNerves" ] || [ -d "$1/PyAutoGut" ] \
+        || [ -d "$1/organs/PyAutoBrain" ] || [ -d "$1/organs/PyAutoMind" ] \
+        || [ -d "$1/organs/PyAutoCortex" ] || [ -d "$1/organs/PyAutoMemory" ] \
+        || [ -d "$1/organs/PyAutoEyes" ] || [ -d "$1/organs/PyAutoHeart" ] \
+        || [ -d "$1/organs/PyAutoHands" ] || [ -d "$1/organs/PyAutoNerves" ] \
+        || [ -d "$1/organs/PyAutoGut" ]
 }
 
 # Assigns WORKSPACE_ROOT and WORKSPACE_ROOT_REASON rather than printing: one

{autoarray-2026.9.27.2 → autoarray-2026.10.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autoarray
-Version: 2026.9.27.2
+Version: 2026.10.2.1
 Summary: PyAuto Data Structures
 Author-email: James Nightingale <James.Nightingale@newcastle.ac.uk>, Richard Hayes <richard@rghsoftware.co.uk>
 License: MIT

{autoarray-2026.9.27.2 → autoarray-2026.10.2.1}/autoarray/__init__.py

@@ -53,6 +53,7 @@ from .inversion.inversion.interferometer.sparse import (
 from .inversion.inversion.interferometer.mapping import InversionInterferometerMapping
 from .inversion.inversion.interferometer.inversion_interferometer_util import (
     InterferometerSparseOperator,
+    SparseTerms,
 )
 from .inversion.linear_obj.linear_obj import LinearObj
 from .inversion.linear_obj.func_list import AbstractLinearObjFuncList
@@ -111,7 +112,7 @@ conf.instance.register(__file__)
 # Last manual sync of the source stamp. Release wheels are stamped at build
 # time and the git tag is the release truth — deliberately never bumped per
 # release (PyAutoBuild#118/#120).
-__version__ = "2026.9.27.2"
+__version__ = "2026.10.2.1"
 
 # ---------------------------------------------------------------------------
 # Public re-export of the autonerves configuration / serialization surface.

{autoarray-2026.9.27.2 → autoarray-2026.10.2.1}/autoarray/config/general.yaml

@@ -8,7 +8,7 @@ inversion:
   use_border_relocator: false          # If True, by default a pixelization's border is used to relocate all pixels outside its border to the border.
   nnls_jacobi_preconditioning: true   # If True (default), the curvature matrix passed to jaxnnls.solve_nnls_primal is Jacobi-preconditioned (D Q D y = D q, x = D y). Fixes NaN backward-pass gradients on ill-conditioned Q and roughly halves forward solve time. Set False to restore the raw unpreconditioned solve.
   nnls_target_kappa: 1.0e-11          # Central-path relaxation parameter passed to jaxnnls.solve_nnls_primal. Larger values smooth the relaxed-KKT backward pass and prevent NaN gradients on ill-conditioned Q; smaller values tighten the primal solve. Verified finite gradients across all MGE/rectangular/delaunay pipelines (imaging + interferometer) with scale invariance over 5 orders of magnitude in noise. jaxnnls's own default (1e-3) is too aggressive for the backward pass. The relaxed solve must start from an iterate whose complementarity s*z is not far above this value; the "raw" no-mapper mode polishes its forward iterate to ensure that (PyAutoArray#573).
-  nnls_preconditioning_no_mapper: raw # How the JAX positive-only PDIP solve scales inversions with NO mapper (linear light profiles / MGE only). "raw" (default) runs the forward solve on the un-preconditioned system with a data-scaled KKT tolerance (1e-2 * n * eps * max(1, max|data_vector|)) and keeps the Jacobi-space relaxed-KKT gradient, whose relaxed solve starts from the forward iterate polished by <= 10 tight warm-started PDIP iterations on the Jacobi system (without the polish the loose forward tolerance leaves s*z far above nnls_target_kappa and the relaxed solve diverged to NaN gradients on 4/16 jax_grad/mge.py points, PyAutoArray#573); "jacobi" uses the Jacobi-preconditioned solve. Jacobi scaling of signal-free MGE columns (diagonal = the no-regularization floor) made the PDIP dual diverge on 14/48 SLaM source_lp[1] points (PyAutoArray#571). Inversions with a mapper always use jacobi; the NumPy path is unaffected.
+  nnls_preconditioning_no_mapper: raw # How the JAX positive-only PDIP solve scales inversions with NO mapper (linear light profiles / MGE only). "raw" (default) runs the forward solve on the un-preconditioned system with a data-scaled KKT tolerance (1e-2 * n * eps * max(1, max|data_vector|)), polishes that iterate with <= 10 tight warm-started PDIP iterations on the Jacobi system and returns the polished iterate (the loose tolerance also judges complementarity, so unpolished it left 11.5 % of the fnnls flux on inactive columns of the euclid vis_lp system; polished <= 3.3e-4 over 81 corpus systems, ~5 extra iterations, PyAutoArray#594), and keeps the Jacobi-space relaxed-KKT gradient started from the same polished point (without the polish the relaxed solve diverged to NaN gradients on 4/16 jax_grad/mge.py points, PyAutoArray#573); "jacobi" uses the Jacobi-preconditioned solve. Jacobi scaling of signal-free MGE columns (diagonal = the no-regularization floor) made the PDIP dual diverge on 14/48 SLaM source_lp[1] points (PyAutoArray#571). Inversions with a mapper always use jacobi; the NumPy path is unaffected.
   nnls_warm_start_memo: true         # If True (default), the NumPy/numba positive-only (fnnls) solve warm-starts its active set from the previous likelihood evaluation's passive set, cutting active-set iterations on successive sampler evaluations. The NNLS optimum is unique so the reconstruction is unchanged. On by default as of PyAutoArray#498, measured on the euclid+hst Delaunay-1250 fiducial (9.9x / 4.0x fewer active-set iterations on successive evaluations, reconstruction unchanged). Set false, or AUTOARRAY_NNLS_WARM_START=0, to disable. JAX path unaffected.
   nnls_warm_start_error_tolerance: 1.5 # Relative quality guard on a warm-start memo seed. Each memo entry remembers the error fraction of the most recent dense-sign-started solve for that key; a seeded solve whose own error fraction exceeds this multiple of that reference is dropped, so the next solve restarts from the dense-sign start and refreshes the reference. Default 1.5 sits above the worst seed/dense error-fraction ratio seen in the PyAutoArray#498 32-cell robustness matrix (1.42), so it is protective against unmeasured regimes rather than flapping. Any non-finite or non-positive value (e.g. .inf) disables the guard. NumPy/numba fnnls path only.
   positive_only_solver: pdip          # Which solver the JAX (xp=jnp) positive-only reconstruction uses. "pdip" (default) is the jaxnnls interior-point solve; "certified" is the certified active-set solve (budgeted masked-Cholesky passes that stop once the KKT conditions certify, exact implicit gradient, PDIP fallback), measured 1.2-2.6x faster on source-only inversions (PyAutoArray#566). Applied only to mapper-only JAX inversions (MGE / linear light profiles keep PDIP); the NumPy path always uses fnnls. Opt-in until the batched (vmap) policy is measured.

{autoarray-2026.9.27.2 → autoarray-2026.10.2.1}/autoarray/dataset/abstract/dataset.py

@@ -94,7 +94,12 @@ class AbstractDataset:
 
         self.noise_covariance_matrix = noise_covariance_matrix
 
-        if noise_map is None:
+        # An array-free dataset (e.g. `Interferometer.from_stream`) carries neither data nor a
+        # noise-map: everything its likelihood needs was reduced into a sparse operator
+        # upstream, so there is no diagonal to take and nothing to check.
+        if noise_map is None and data is None and noise_covariance_matrix is None:
+            pass
+        elif noise_map is None:
             try:
                 noise_map = Array2D.no_mask(
                     values=np.diag(noise_covariance_matrix),
@@ -174,6 +179,10 @@ class AbstractDataset:
         """
         The 1D size of the dataset data array after masking, i.e. the number of unmasked pixels.
         """
+        # An array-free dataset has no data array; the mask's slim size is not a substitute
+        # (for an interferometer the data is visibilities, not image pixels).
+        if self.data is None:
+            return None
         return self.data.shape_slim
 
     @property

{autoarray-2026.9.27.2 → autoarray-2026.10.2.1}/autoarray/dataset/imaging/dataset.py

@@ -61,6 +61,36 @@ def _validate_convolve_over_sample_size(
         )
 
 
+_SPARSE_OPERATOR_CONVOLVE_OVER_SAMPLE_SIZE_ERROR = (
+    "The sparse linear algebra formalism precomputes PSF products at "
+    "image resolution and is incompatible with an oversampled PSF "
+    "(convolve_over_sample_size > 1)."
+)
+
+
+def _warn_sparse_operator_discarded(sparse_operator, method_name: str) -> None:
+    """
+    Log a warning when a dataset rebuild discards an attached sparse operator.
+
+    The sparse operator precomputes PSF products of every pair of masked noise-map
+    values, so it is invalidated by any change to the mask or noise-map. Rebuilds
+    which make such changes (e.g. `apply_mask`, `apply_noise_scaling`) therefore do
+    not carry it, and the returned dataset falls back to the (slower) mapping matrix
+    formalism unless the operator is re-applied. This warning stops that fallback
+    from happening silently.
+    """
+    if sparse_operator is None:
+        return
+
+    logger.warning(
+        f"IMAGING - {method_name} changes the mask or noise-map, which invalidates the "
+        f"sparse operator attached to this dataset, so it has been discarded. Pixelized "
+        f"reconstructions will use the slower mapping matrix formalism unless the sparse "
+        f"operator is re-applied (via apply_sparse_operator() or "
+        f"apply_sparse_operator_cpu()) as the last dataset operation."
+    )
+
+
 class Imaging(AbstractDataset):
     def __init__(
         self,
@@ -439,6 +469,10 @@ class Imaging(AbstractDataset):
             values=self.over_sample_size_pixelization.native, mask=mask
         )
 
+        _warn_sparse_operator_discarded(
+            sparse_operator=self.sparse_operator, method_name="apply_mask"
+        )
+
         dataset = Imaging(
             data=data,
             noise_map=noise_map,
@@ -520,6 +554,10 @@ class Imaging(AbstractDataset):
 
         noise_map = Array2D(values=noise_map, mask=self.data.mask)
 
+        _warn_sparse_operator_discarded(
+            sparse_operator=self.sparse_operator, method_name="apply_noise_scaling"
+        )
+
         dataset = Imaging(
             data=data,
             noise_map=noise_map,
@@ -527,6 +565,8 @@ class Imaging(AbstractDataset):
             noise_covariance_matrix=self.noise_covariance_matrix,
             over_sample_size_lp=self.over_sample_size_lp,
             over_sample_size_pixelization=self.over_sample_size_pixelization,
+            convolve_over_sample_size_lp=self.convolve_over_sample_size_lp,
+            convolve_over_sample_size_pixelization=self.convolve_over_sample_size_pixelization,
             check_noise_map=False,
         )
 
@@ -551,6 +591,10 @@ class Imaging(AbstractDataset):
         This function resets the cached properties so that the new over sampling is used in the grid and grid
         pixelization.
 
+        The `noise_covariance_matrix` and any attached `sparse_operator` are carried over, as neither depends on
+        the over sampling (the sparse operator depends only on the noise-map, PSF kernel and mask). This means
+        `apply_sparse_operator()` / `apply_sparse_operator_cpu()` may be called before or after this method.
+
         Parameters
         ----------
         over_sample_size_lp
@@ -566,12 +610,14 @@ class Imaging(AbstractDataset):
             data=self.data,
             noise_map=self.noise_map,
             psf=self.psf,
+            noise_covariance_matrix=self.noise_covariance_matrix,
             over_sample_size_lp=over_sample_size_lp or self.over_sample_size_lp,
             over_sample_size_pixelization=over_sample_size_pixelization
             or self.over_sample_size_pixelization,
             convolve_over_sample_size_lp=self.convolve_over_sample_size_lp,
             convolve_over_sample_size_pixelization=self.convolve_over_sample_size_pixelization,
             check_noise_map=False,
+            sparse_operator=self.sparse_operator,
         )
 
         return dataset
@@ -620,9 +666,7 @@ class Imaging(AbstractDataset):
 
         if self.psf is not None and self.psf.convolve_over_sample_size > 1:
             raise exc.DatasetException(
-                "The sparse linear algebra formalism precomputes PSF products at "
-                "image resolution and is incompatible with an oversampled PSF "
-                "(convolve_over_sample_size > 1)."
+                _SPARSE_OPERATOR_CONVOLVE_OVER_SAMPLE_SIZE_ERROR
             )
 
         logger.info(
@@ -645,6 +689,8 @@ class Imaging(AbstractDataset):
             noise_covariance_matrix=self.noise_covariance_matrix,
             over_sample_size_lp=self.over_sample_size_lp,
             over_sample_size_pixelization=self.over_sample_size_pixelization,
+            convolve_over_sample_size_lp=self.convolve_over_sample_size_lp,
+            convolve_over_sample_size_pixelization=self.convolve_over_sample_size_pixelization,
             check_noise_map=False,
             sparse_operator=sparse_operator,
         )
@@ -668,6 +714,11 @@ class Imaging(AbstractDataset):
             A new `Imaging` dataset with a precomputed Numba-based sparse operator attached,
             enabling efficient pixelized source reconstruction on CPU hardware.
         """
+        if self.psf is not None and self.psf.convolve_over_sample_size > 1:
+            raise exc.DatasetException(
+                _SPARSE_OPERATOR_CONVOLVE_OVER_SAMPLE_SIZE_ERROR
+            )
+
         try:
             import numba
         except ModuleNotFoundError:
@@ -711,6 +762,8 @@ class Imaging(AbstractDataset):
             noise_covariance_matrix=self.noise_covariance_matrix,
             over_sample_size_lp=self.over_sample_size_lp,
             over_sample_size_pixelization=self.over_sample_size_pixelization,
+            convolve_over_sample_size_lp=self.convolve_over_sample_size_lp,
+            convolve_over_sample_size_pixelization=self.convolve_over_sample_size_pixelization,
             check_noise_map=False,
             sparse_operator=sparse_operator,
         )