mapped_reconstructed_data

Author: Jammy2211

autoarray/inversion/inversion/abstract.py

@@ -542,6 +542,22 @@ def mapped_reconstructed_data(self) -> Union[Array2D, Visibilities]:
         This uses the unique mappings of every source pixel to image pixels, which is a quantity that is already
         computed when using the w-tilde formalism.
 
+        Returns
+        -------
+        Array2D
+            The reconstructed image data which the inversion fits.
+        """
+        return sum(self.mapped_reconstructed_data_dict.values())
+
+    @property
+    def mapped_reconstructed_operated_data(self) -> Union[Array2D, Visibilities]:
+        """
+        Using the reconstructed source pixel fluxes we map each source pixel flux back to the image plane and
+        reconstruct the image data.
+
+        This uses the unique mappings of every source pixel to image pixels, which is a quantity that is already
+        computed when using the w-tilde formalism.
+
         Returns
         -------
         Array2D

autoarray/inversion/inversion/imaging/mapping.py

@@ -101,10 +101,9 @@ def curvature_matrix(self):
             xp=self._xp,
         )
 
-
     def _mapped_reconstructed_data_dict_from(
-            self,
-            mapping_matrix_list,
+        self,
+        mapping_matrix_list,
     ) -> Dict["LinearObj", "Array2D"]:
         """
         Shared implementation for mapping a reconstruction to image-plane arrays
@@ -197,4 +196,3 @@ def mapped_reconstructed_operated_data_dict(self) -> Dict["LinearObj", "Array2D"
         return self._mapped_reconstructed_data_dict_from(
             mapping_matrix_list=self.operated_mapping_matrix_list
         )
-

autoarray/inversion/inversion/imaging/sparse.py

@@ -483,7 +483,6 @@ def _curvature_matrix_func_list_and_mapper(self) -> np.ndarray:
 
         return curvature_matrix
 
-
     def _mapped_reconstructed_data_dict_from(
         self,
         *,
@@ -530,11 +529,12 @@ def _mapped_reconstructed_data_dict_from(
 
                     mapped = Array2D(values=mapped, mask=self.mask)
 
-
             else:
 
                 if use_operated_for_linear_func:
-                    mapping_matrix = self.linear_func_operated_mapping_matrix_dict[linear_obj]
+                    mapping_matrix = self.linear_func_operated_mapping_matrix_dict[
+                        linear_obj
+                    ]
                 else:
                     mapping_matrix = self.linear_func_mapping_matrix_dict[linear_obj]
 
@@ -607,4 +607,4 @@ def mapped_reconstructed_operated_data_dict(self) -> Dict[LinearObj, Array2D]:
         """
         return self._mapped_reconstructed_data_dict_from(
             use_operated_for_linear_func=True
-        )
+        )

autoarray/inversion/inversion/imaging_numba/inversion_imaging_numba_util.py

@@ -790,17 +790,17 @@ def mapped_reconstructed_data_via_image_to_pix_unique_from(
 
     data_pixels = data_to_pix_unique.shape[0]
 
-    mapped_reconstructed_data = np.zeros(data_pixels)
+    mapped_reconstructed_operated_data = np.zeros(data_pixels)
 
     for data_0 in range(data_pixels):
         for pix_0 in range(pix_lengths[data_0]):
             pix_for_data = data_to_pix_unique[data_0, pix_0]
 
-            mapped_reconstructed_data[data_0] += (
+            mapped_reconstructed_operated_data[data_0] += (
                 data_weights[data_0, pix_0] * reconstruction[pix_for_data]
             )
 
-    return mapped_reconstructed_data
+    return mapped_reconstructed_operated_data
 
 
 class SparseLinAlgImagingNumba:

autoarray/inversion/inversion/imaging_numba/sparse.py

@@ -507,9 +507,11 @@ def _mapped_reconstructed_data_dict_from(
                     mapped = Array2D(values=mapped, mask=self.mask)
 
             else:
-                
+
                 if use_operated_for_linear_func:
-                    mapping_matrix = self.linear_func_operated_mapping_matrix_dict[linear_obj]
+                    mapping_matrix = self.linear_func_operated_mapping_matrix_dict[
+                        linear_obj
+                    ]
                 else:
                     mapping_matrix = self.linear_func_mapping_matrix_dict[linear_obj]
 
@@ -583,5 +585,3 @@ def mapped_reconstructed_operated_data_dict(self) -> Dict[LinearObj, Array2D]:
         return self._mapped_reconstructed_data_dict_from(
             use_operated_for_linear_func=True
         )
-
-

autoarray/inversion/mock/mock_inversion.py

@@ -23,6 +23,7 @@ def __init__(
         reconstruction: np.ndarray = None,
         reconstruction_dict: List[np.ndarray] = None,
         mapped_reconstructed_operated_data_dict=None,
+        mapped_reconstructed_data_dict=None,
         mapped_reconstructed_image_dict=None,
         reconstruction_noise_map: np.ndarray = None,
         reconstruction_noise_map_dict: List[np.ndarray] = None,
@@ -56,7 +57,10 @@ def __init__(
         self._reconstruction = reconstruction
         self._reconstruction_dict = reconstruction_dict
 
-        self._mapped_reconstructed_operated_data_dict = mapped_reconstructed_operated_data_dict
+        self._mapped_reconstructed_operated_data_dict = (
+            mapped_reconstructed_operated_data_dict
+        )
+        self._mapped_reconstructed_data_dict = mapped_reconstructed_data_dict
         self._mapped_reconstructed_image_dict = mapped_reconstructed_image_dict
 
         self._reconstruction_noise_map = reconstruction_noise_map
@@ -131,6 +135,26 @@ def reconstruction_dict(self):
             return super().reconstruction_dict
         return self._reconstruction_dict
 
+    @property
+    def mapped_reconstructed_data_dict(self):
+        """
+        Using the reconstructed source pixel fluxes we map each source pixel flux back to the image plane and
+        reconstruct the image data.
+
+        This uses the unique mappings of every source pixel to image pixels, which is a quantity that is already
+        computed when using the w-tilde formalism.
+
+        Returns
+        -------
+        Array2D
+            The reconstructed image data which the inversion fits.
+        """
+
+        if self._mapped_reconstructed_data_dict is None:
+            return super().mapped_reconstructed_data_dict
+
+        return self._mapped_reconstructed_data_dict
+
     @property
     def mapped_reconstructed_operated_data_dict(self):
         """

test_autoarray/inversion/inversion/interferometer/test_interferometer.py

@@ -55,7 +55,7 @@ def test__fast_chi_squared(
 
     residual_map = aa.util.fit.residual_map_from(
         data=interferometer_7_no_fft.data,
-        model_data=inversion.mapped_reconstructed_data,
+        model_data=inversion.mapped_reconstructed_operated_data,
     )
 
     chi_squared_map = aa.util.fit.chi_squared_map_complex_from(

test_autoarray/inversion/inversion/test_abstract.py

@@ -305,7 +305,43 @@ def test__reconstruction_dict():
     assert (inversion.reconstruction_dict[mapper_1] == 2.0 * np.ones(3)).all()
 
 
-def test__mapped_reconstructed_data():
+def test__mapped_reconstructed_data_dict():
+    linear_obj_0 = aa.m.MockLinearObj()
+
+    mapped_reconstructed_data_dict = {linear_obj_0: np.ones(3)}
+
+    # noinspection PyTypeChecker
+    inversion = aa.m.MockInversion(
+        mapped_reconstructed_data_dict=mapped_reconstructed_data_dict,
+        reconstruction=np.ones(3),
+        reconstruction_dict=[None],
+    )
+
+    assert (inversion.mapped_reconstructed_data_dict[linear_obj_0] == np.ones(3)).all()
+    assert (inversion.mapped_reconstructed_data == np.ones(3)).all()
+
+    linear_obj_1 = aa.m.MockLinearObj()
+
+    mapped_reconstructed_data_dict = {
+        linear_obj_0: np.ones(2),
+        linear_obj_1: 2.0 * np.ones(2),
+    }
+
+    # noinspection PyTypeChecker
+    inversion = aa.m.MockInversion(
+        mapped_reconstructed_data_dict=mapped_reconstructed_data_dict,
+        reconstruction=np.array([1.0, 1.0, 2.0, 2.0]),
+        reconstruction_dict=[None, None],
+    )
+
+    assert (inversion.mapped_reconstructed_data_dict[linear_obj_0] == np.ones(2)).all()
+    assert (
+        inversion.mapped_reconstructed_data_dict[linear_obj_1] == 2.0 * np.ones(2)
+    ).all()
+    assert (inversion.mapped_reconstructed_data == 3.0 * np.ones(2)).all()
+
+
+def test__mapped_reconstructed_operated_data_dict():
     linear_obj_0 = aa.m.MockLinearObj()
 
     mapped_reconstructed_operated_data_dict = {linear_obj_0: np.ones(3)}
@@ -317,8 +353,10 @@ def test__mapped_reconstructed_data():
         reconstruction_dict=[None],
     )
 
-    assert (inversion.mapped_reconstructed_operated_data_dict[linear_obj_0] == np.ones(3)).all()
-    assert (inversion.mapped_reconstructed_data == np.ones(3)).all()
+    assert (
+        inversion.mapped_reconstructed_operated_data_dict[linear_obj_0] == np.ones(3)
+    ).all()
+    assert (inversion.mapped_reconstructed_operated_data == np.ones(3)).all()
 
     linear_obj_1 = aa.m.MockLinearObj()
 
@@ -334,11 +372,14 @@ def test__mapped_reconstructed_data():
         reconstruction_dict=[None, None],
     )
 
-    assert (inversion.mapped_reconstructed_operated_data_dict[linear_obj_0] == np.ones(2)).all()
     assert (
-        inversion.mapped_reconstructed_operated_data_dict[linear_obj_1] == 2.0 * np.ones(2)
+        inversion.mapped_reconstructed_operated_data_dict[linear_obj_0] == np.ones(2)
     ).all()
-    assert (inversion.mapped_reconstructed_data == 3.0 * np.ones(2)).all()
+    assert (
+        inversion.mapped_reconstructed_operated_data_dict[linear_obj_1]
+        == 2.0 * np.ones(2)
+    ).all()
+    assert (inversion.mapped_reconstructed_operated_data == 3.0 * np.ones(2)).all()
 
 
 def test__mapped_reconstructed_image():

test_autoarray/inversion/inversion/test_factory.py

@@ -328,9 +328,9 @@ def test__inversion_imaging__linear_obj_func_and_non_func_give_same_terms(
 
     masked_imaging_7x7_no_blur = copy.copy(masked_imaging_7x7_no_blur)
 
-    masked_imaging_7x7_no_blur.data -= inversion.mapped_reconstructed_operated_data_dict[
-        linear_obj
-    ]
+    masked_imaging_7x7_no_blur.data -= (
+        inversion.mapped_reconstructed_operated_data_dict[linear_obj]
+    )
 
     inversion_no_linear_func = aa.Inversion(
         dataset=masked_imaging_7x7_no_blur,
@@ -453,11 +453,11 @@ def test__inversion_interferometer__via_mapper(
 
     assert isinstance(inversion.linear_obj_list[0], aa.MapperRectangularUniform)
     assert isinstance(inversion, aa.InversionInterferometerMapping)
-    assert inversion.mapped_reconstructed_data == pytest.approx(
+    assert inversion.mapped_reconstructed_operated_data == pytest.approx(
         1.0 + 0.0j * np.ones(shape=(7,)), 1.0e-4
     )
-    assert (np.imag(inversion.mapped_reconstructed_data) < 0.0001).all()
-    assert (np.imag(inversion.mapped_reconstructed_data) > 0.0).all()
+    assert (np.imag(inversion.mapped_reconstructed_operated_data) < 0.0001).all()
+    assert (np.imag(inversion.mapped_reconstructed_operated_data) > 0.0).all()
     assert inversion.log_det_curvature_reg_matrix_term == pytest.approx(10.2116, 1.0e-4)
 
     inversion = aa.Inversion(
@@ -468,11 +468,11 @@ def test__inversion_interferometer__via_mapper(
 
     assert isinstance(inversion.linear_obj_list[0], aa.MapperDelaunay)
     assert isinstance(inversion, aa.InversionInterferometerMapping)
-    assert inversion.mapped_reconstructed_data == pytest.approx(
+    assert inversion.mapped_reconstructed_operated_data == pytest.approx(
         1.0 + 0.0j * np.ones(shape=(7,)), 1.0e-4
     )
-    assert (np.imag(inversion.mapped_reconstructed_data) < 0.0001).all()
-    assert (np.imag(inversion.mapped_reconstructed_data) > 0.0).all()
+    assert (np.imag(inversion.mapped_reconstructed_operated_data) < 0.0001).all()
+    assert (np.imag(inversion.mapped_reconstructed_operated_data) > 0.0).all()
     assert inversion.log_det_curvature_reg_matrix_term == pytest.approx(
         14.49772, 1.0e-4
     )
@@ -540,9 +540,9 @@ def test__inversion_matrices__x2_mappers(
     )
     assert inversion.reconstruction[13] == pytest.approx(0.49999703908867, 1.0e-4)
 
-    assert inversion.mapped_reconstructed_operated_data_dict[rectangular_mapper_7x7_3x3][
-        4
-    ] == pytest.approx(0.5000029, 1.0e-4)
+    assert inversion.mapped_reconstructed_operated_data_dict[
+        rectangular_mapper_7x7_3x3
+    ][4] == pytest.approx(0.5000029, 1.0e-4)
     assert inversion.mapped_reconstructed_operated_data_dict[delaunay_mapper_9_3x3][
         3
     ] == pytest.approx(0.49999704, 1.0e-4)

test_autoarray/inversion/inversion/test_inversion_util.py

@@ -93,25 +93,25 @@ def test__mapped_reconstructed_data_via_mapping_matrix_from():
 
     reconstruction = np.array([1.0, 1.0, 2.0])
 
-    mapped_reconstructed_data = (
+    mapped_reconstructed_operated_data = (
         aa.util.inversion.mapped_reconstructed_data_via_mapping_matrix_from(
             mapping_matrix=mapping_matrix, reconstruction=reconstruction
         )
     )
 
-    assert (mapped_reconstructed_data == np.array([1.0, 1.0, 2.0])).all()
+    assert (mapped_reconstructed_operated_data == np.array([1.0, 1.0, 2.0])).all()
 
     mapping_matrix = np.array([[0.25, 0.50, 0.25], [0.0, 1.0, 0.0], [0.0, 0.25, 0.75]])
 
     reconstruction = np.array([1.0, 1.0, 2.0])
 
-    mapped_reconstructed_data = (
+    mapped_reconstructed_operated_data = (
         aa.util.inversion.mapped_reconstructed_data_via_mapping_matrix_from(
             mapping_matrix=mapping_matrix, reconstruction=reconstruction
         )
     )
 
-    assert (mapped_reconstructed_data == np.array([1.25, 1.0, 1.75])).all()
+    assert (mapped_reconstructed_operated_data == np.array([1.25, 1.0, 1.75])).all()
 
 
 def test__mapped_reconstructed_data_via_image_to_pix_unique_from():
@@ -134,14 +134,14 @@ def test__mapped_reconstructed_data_via_image_to_pix_unique_from():
 
     reconstruction = np.array([1.0, 1.0, 2.0])
 
-    mapped_reconstructed_data = aa.util.inversion_imaging_numba.mapped_reconstructed_data_via_image_to_pix_unique_from(
+    mapped_reconstructed_operated_data = aa.util.inversion_imaging_numba.mapped_reconstructed_data_via_image_to_pix_unique_from(
         data_to_pix_unique=data_to_pix_unique.astype("int"),
         data_weights=data_weights,
         pix_lengths=pix_lengths.astype("int"),
         reconstruction=reconstruction,
     )
 
-    assert (mapped_reconstructed_data == np.array([1.0, 1.0, 2.0])).all()
+    assert (mapped_reconstructed_operated_data == np.array([1.0, 1.0, 2.0])).all()
 
     pix_indexes_for_sub_slim_index = np.array(
         [[0], [1], [1], [2], [1], [1], [1], [1], [1], [2], [2], [2]]
@@ -164,14 +164,14 @@ def test__mapped_reconstructed_data_via_image_to_pix_unique_from():
 
     reconstruction = np.array([1.0, 1.0, 2.0])
 
-    mapped_reconstructed_data = aa.util.inversion_imaging_numba.mapped_reconstructed_data_via_image_to_pix_unique_from(
+    mapped_reconstructed_operated_data = aa.util.inversion_imaging_numba.mapped_reconstructed_data_via_image_to_pix_unique_from(
         data_to_pix_unique=data_to_pix_unique.astype("int"),
         data_weights=data_weights,
         pix_lengths=pix_lengths.astype("int"),
         reconstruction=reconstruction,
     )
 
-    assert (mapped_reconstructed_data == np.array([1.25, 1.0, 1.75])).all()
+    assert (mapped_reconstructed_operated_data == np.array([1.25, 1.0, 1.75])).all()
 
 
 def test__preconditioner_matrix_via_mapping_matrix_from():