maapping matrix convolve works

Author: Jammy2211

autoarray/dataset/imaging/dataset.py

@@ -166,6 +166,9 @@ def __init__(
 
         self.psf = psf
 
+        if psf.mask.shape[0] % 2 == 0 or psf.mask.shape[1] % 2 == 0:
+            raise exc.KernelException("Kernel2D Kernel2D must be odd")
+
     @cached_property
     def grids(self):
         return GridsDataset(

autoarray/inversion/inversion/imaging/w_tilde.py

@@ -526,7 +526,8 @@ def mapped_reconstructed_data_dict(self) -> Dict[LinearObj, Array2D]:
                 )
 
                 mapped_reconstructed_image = self.convolver.convolve_image_no_blurring(
-                    image=mapped_reconstructed_image
+                    image=mapped_reconstructed_image,
+                    mask=self.mask
                 )
 
             else:

autoarray/structures/arrays/kernel_2d.py

@@ -54,9 +54,6 @@ def __init__(
             store_native=store_native,
         )
 
-        if self.mask.shape[0] % 2 == 0 or self.mask.shape[1] % 2 == 0:
-            raise exc.KernelException("Kernel2D Kernel2D must be odd")
-
         if normalize:
             self._array = np.divide(self._array, np.sum(self._array))
 
@@ -529,7 +526,7 @@ def convolve_image(self, image, blurring_image, jax_method="fft"):
 
         return Array2D(values=convolved_array_1d, mask=image.mask)
 
-    def convolve_image_no_blurring(self, image, jax_method="fft"):
+    def convolve_image_no_blurring(self, image, mask, jax_method="fft"):
         """
         For a given 1D array and blurring array, convolve the two using this convolver.
 
@@ -547,13 +544,13 @@ def convolve_image_no_blurring(self, image, jax_method="fft"):
         """
 
         slim_to_native = jnp.nonzero(
-            jnp.logical_not(image.mask.array), size=image.shape[0]
+            jnp.logical_not(mask.array), size=image.shape[0]
         )
 
-        expanded_array_native = jnp.zeros(image.mask.shape)
+        expanded_array_native = jnp.zeros(mask.shape)
 
         expanded_array_native = expanded_array_native.at[slim_to_native].set(
-            image.array
+            image
         )
 
         kernel = np.array(self.native.array)
@@ -564,4 +561,14 @@ def convolve_image_no_blurring(self, image, jax_method="fft"):
 
         convolved_array_1d = convolve_native[slim_to_native]
 
-        return Array2D(values=convolved_array_1d, mask=image.mask)
+        return Array2D(values=convolved_array_1d, mask=mask)
+
+    def convolve_mapping_matrix(self, mapping_matrix, mask):
+        """For a given 1D array and blurring array, convolve the two using this convolver.
+
+        Parameters
+        ----------
+        image
+            1D array of the values which are to be blurred with the convolver's PSF.
+        """
+        return jax.vmap(self.convolve_image_no_blurring, in_axes=(1, None))(mapping_matrix, mask).T

test_autoarray/dataset/imaging/test_dataset.py

@@ -8,6 +8,8 @@
 
 import autoarray as aa
 
+from autoarray import exc
+
 test_data_path = path.join(
     "{}".format(path.dirname(path.realpath(__file__))),
     "files",
@@ -241,3 +243,8 @@ def test__noise_map_unmasked_has_zeros_or_negative__raises_exception():
 
     with pytest.raises(aa.exc.DatasetException):
         aa.Imaging(data=array, noise_map=noise_map)
+
+def test__psf_not_odd_x_odd_kernel__raises_error():
+
+    with pytest.raises(exc.KernelException):
+        aa.Kernel2D.no_mask(values=[[0.0, 1.0], [1.0, 2.0]], pixel_scales=1.0)

test_autoarray/structures/arrays/test_kernel_2d.py

@@ -292,12 +292,6 @@ def test__from_as_gaussian_via_alma_fits_header_parameters__identical_to_astropy
     assert kernel_astropy == pytest.approx(kernel_2d.native._array, abs=1e-4)
 
 
-def test__not_odd_x_odd_kernel__raises_error():
-
-    with pytest.raises(exc.KernelException):
-        aa.Kernel2D.no_mask(values=[[0.0, 1.0], [1.0, 2.0]], pixel_scales=1.0)
-
-
 def test__convolved_array_from():
 
     array_2d = aa.Array2D.no_mask(
@@ -430,13 +424,13 @@ def test__convolve_image_no_blurring():
 
     masked_image = aa.Array2D(values=image.native, mask=mask)
 
-    blurred_masked_im_1 = kernel.convolve_image_no_blurring(image=masked_image)
+    blurred_masked_im_1 = kernel.convolve_image_no_blurring(image=masked_image, mask=mask)
 
     assert blurred_masked_image_via_scipy == pytest.approx(blurred_masked_im_1.array, 1e-4)
 
 
 def test__convolve_mapping_matrix():
-    mask = np.array(
+    mask = aa.Mask2D(mask=np.array(
         [
             [True, True, True, True, True, True],
             [True, False, False, False, False, True],
@@ -445,7 +439,7 @@ def test__convolve_mapping_matrix():
             [True, False, False, False, False, True],
             [True, True, True, True, True, True],
         ]
-    )
+    ), pixel_scales=1.0)
 
     kernel = aa.Kernel2D.no_mask(
         values=[[0, 0.0, 0], [0.4, 0.2, 0.3], [0, 0.1, 0]], pixel_scales=1.0
@@ -476,11 +470,11 @@ def test__convolve_mapping_matrix():
         ]
     )
 
-    blurred_mapping = kernel.convolve_mapping_matrix(mapping)
+    blurred_mapping = kernel.convolve_mapping_matrix(mapping, mask)
 
     assert (
         blurred_mapping
-        == np.array(
+        == pytest.approx(np.array(
             [
                 [0, 0, 0],
                 [0, 0, 0],
@@ -500,7 +494,7 @@ def test__convolve_mapping_matrix():
                 [0, 0, 0],
             ]
         )
-    ).all()
+    ), 1.0e-4)
 
     kernel = aa.Kernel2D.no_mask(
         values=[[0, 0.0, 0], [0.4, 0.2, 0.3], [0, 0.1, 0]], pixel_scales=1.0
@@ -531,7 +525,9 @@ def test__convolve_mapping_matrix():
         ]
     )
 
-    blurred_mapping = kernel.convolve_mapping_matrix(mapping)
+    blurred_mapping = kernel.convolve_mapping_matrix(mapping, mask)
+
+    print(blurred_mapping)
 
     assert blurred_mapping == pytest.approx(
         np.array(
@@ -554,5 +550,5 @@ def test__convolve_mapping_matrix():
                 [0, 0, 0],
             ]
         ),
-        1e-4,
+        abs=1e-4,
     )