feat: linear light profiles under an oversampled PSF (#480)

User-directed scope addition at sign-off: LightProfileLinearObjFuncList.
operated_mapping_matrix_override evaluates each profile on the grids'
over-sampled coordinates and convolves at the fine resolution (same
Grid2DIrregular pass-through as the operate/image consumer switch), so
linear light profiles work at convolve_over_sample_size > 1 instead of
raising the binned-input guard. Operated linear profiles keep returning
the unblurred mapping matrix (no convolution by definition). s=1 path
unchanged. Column-level test vs the direct oversampled Convolver (1e-14).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: 2 people

autogalaxy/profiles/light/linear/abstract.py

@@ -340,19 +340,33 @@ def operated_mapping_matrix_override(self) -> Optional[np.ndarray]:
         if isinstance(self.light_profile_list[0], LightProfileOperated):
             return self.mapping_matrix
 
+        if self.psf.convolve_over_sample_size > 1:
+            # Evaluate each profile on the over-sampled coordinates (per-pixel
+            # sub-block order, unbinned — the oversampled Convolver's input format)
+            # so convolution runs at the fine resolution, mirroring
+            # OperateImage.blurred_image_2d_from.
+            evaluation_grid = self.grid.over_sampled
+            evaluation_blurring_grid = self.blurring_grid.over_sampled
+            convolution_mask = self.grid.mask
+        else:
+            evaluation_grid = self.grid
+            evaluation_blurring_grid = self.blurring_grid
+            convolution_mask = None
+
         blurred_image_2d_list = []
 
         for pixel, light_profile in enumerate(self.light_profile_list):
-            image_2d = light_profile.image_2d_from(grid=self.grid, xp=self._xp)
+            image_2d = light_profile.image_2d_from(grid=evaluation_grid, xp=self._xp)
 
             blurring_image_2d = light_profile.image_2d_from(
-                grid=self.blurring_grid, xp=self._xp
+                grid=evaluation_blurring_grid, xp=self._xp
             )
 
             blurred_image_2d = self.psf.convolved_image_from(
                 image=image_2d,
                 blurring_image=blurring_image_2d,
                 use_mixed_precision=self.settings.use_mixed_precision,
+                mask=convolution_mask,
                 xp=self._xp,
             )
 

test_autogalaxy/profiles/light/linear/test_abstract.py

@@ -151,3 +151,55 @@ def test__setstate__preserves_pytree_token_when_present():
     restored.__setstate__(state_with_token)
 
     assert restored.pytree_token == lp.pytree_token
+
+
+def test__operated_mapping_matrix_override__oversampled_psf__matches_direct_convolver():
+    # With an oversampled PSF each linear light profile is evaluated on the
+    # over-sampled coordinates and convolved at the fine resolution — the column
+    # must equal calling the (phase-2a tested) oversampled Convolver directly.
+    import numpy as np
+    import autoarray as aa
+    from autogalaxy.profiles.light.linear.abstract import (
+        LightProfileLinearObjFuncList,
+    )
+
+    mask = aa.Mask2D.circular(shape_native=(11, 11), pixel_scales=1.0, radius=3.5)
+
+    s = 2
+    n = 9
+    c = (np.arange(n) - (n - 1) / 2.0) * (1.0 / s)
+    yy, xx = np.meshgrid(-c, c, indexing="ij")
+    kernel = np.exp(-0.5 * (yy**2 + xx**2) / 0.8**2)
+    kernel = aa.Array2D.no_mask(values=kernel / kernel.sum(), pixel_scales=1.0 / s)
+    psf = aa.Convolver(kernel=kernel, convolve_over_sample_size=s)
+
+    grid = aa.Grid2D.from_mask(mask=mask, over_sample_size=s)
+    blurring_mask = mask.derive_mask.blurring_from(
+        kernel_shape_native=psf.kernel_shape_image_resolution, allow_padding=True
+    )
+    blurring_grid = aa.Grid2D.from_mask(mask=blurring_mask, over_sample_size=s)
+
+    lp_0 = ag.lp_linear.Sersic(
+        centre=(0.3, -0.4), effective_radius=1.0, sersic_index=2.0
+    )
+    lp_1 = ag.lp_linear.Gaussian(centre=(-0.5, 0.2), sigma=0.7)
+
+    func_list = LightProfileLinearObjFuncList(
+        grid=grid,
+        blurring_grid=blurring_grid,
+        psf=psf,
+        light_profile_list=[lp_0, lp_1],
+        regularization=None,
+    )
+
+    override = np.array(func_list.operated_mapping_matrix_override)
+
+    assert override.shape == (mask.pixels_in_mask, 2)
+
+    for i, lp in enumerate([lp_0, lp_1]):
+        image_sub = lp.image_2d_from(grid=grid.over_sampled)
+        blurring_sub = lp.image_2d_from(grid=blurring_grid.over_sampled)
+        direct = psf.convolved_image_from(
+            image=image_sub, blurring_image=blurring_sub, mask=mask
+        )
+        assert override[:, i] == pytest.approx(np.array(direct), abs=1.0e-14)