Feature/mock refactor

autolens/__init__.py

@@ -84,6 +84,7 @@
 from .point.point_solver import PointSolver
 from .quantity.fit_quantity import FitQuantity
 from .quantity.model.analysis import AnalysisQuantity
+from . import mock as m
 from . import util
 
 from autoconf import conf

autolens/mock/fixtures.py → autolens/fixtures.py

@@ -1,8 +1,6 @@
 import autolens as al
 
-from autogalaxy.mock.fixtures import *
-from autofit.mock.mock import MockSearch
-from autolens.mock.mock import MockPointSolver
+from autogalaxy.fixtures import *
 
 
 def make_positions_x2():
@@ -154,5 +152,5 @@ def make_analysis_interferometer_7():
 def make_analysis_point_x2():
     return al.AnalysisPoint(
         point_dict=make_point_dict(),
-        solver=MockPointSolver(model_positions=make_positions_x2()),
+        solver=al.m.MockPointSolver(model_positions=make_positions_x2()),
     )

autolens/imaging/fit_imaging.py

@@ -15,7 +15,7 @@ def __init__(
         tracer,
         hyper_image_sky=None,
         hyper_background_noise=None,
-        use_hyper_scaling=True,
+        use_hyper_scalings=True,
         settings_pixelization=aa.SettingsPixelization(),
         settings_inversion=aa.SettingsInversion(),
         preloads=Preloads(),
@@ -31,11 +31,13 @@ def __init__(
             The tracer, which describes the ray-tracing and strong lens configuration.
         """
 
+        super().__init__(dataset=dataset, profiling_dict=profiling_dict)
+
         self.tracer = tracer
 
         self.hyper_image_sky = hyper_image_sky
         self.hyper_background_noise = hyper_background_noise
-        self.use_hyper_scaling = use_hyper_scaling
+        self.use_hyper_scalings = use_hyper_scalings
 
         self.settings_pixelization = settings_pixelization
         self.settings_inversion = settings_inversion
@@ -44,68 +46,97 @@ def __init__(
 
         self.profiling_dict = profiling_dict
 
-        if use_hyper_scaling:
+    @property
+    def data(self):
+        """
+        Returns the imaging data, which may have a hyper scaling performed which rescales the background sky level
+        in order to account for uncertainty in the background sky subtraction.
+        """
+        if self.use_hyper_scalings:
 
-            image = hyper_image_from(
-                image=dataset.image, hyper_image_sky=hyper_image_sky
+            return hyper_image_from(
+                image=self.dataset.image, hyper_image_sky=self.hyper_image_sky
             )
 
-            noise_map = hyper_noise_map_from(
-                noise_map=dataset.noise_map,
-                tracer=tracer,
-                hyper_background_noise=hyper_background_noise,
-            )
+        return self.dataset.data
 
-        else:
+    @property
+    def noise_map(self):
+        """
+        Returns the imaging noise-map, which may have a hyper scaling performed which increase the noise in regions of
+        the data that are poorly fitted in order to avoid overfitting.
+        """
+        if self.use_hyper_scalings:
 
-            image = dataset.image
-            noise_map = dataset.noise_map
+            return hyper_noise_map_from(
+                noise_map=self.dataset.noise_map,
+                tracer=self.tracer,
+                hyper_background_noise=self.hyper_background_noise,
+            )
 
-        if preloads.blurred_image is None:
+        return self.dataset.noise_map
 
-            self.blurred_image = self.tracer.blurred_image_2d_via_convolver_from(
-                grid=dataset.grid,
-                convolver=dataset.convolver,
-                blurring_grid=dataset.blurring_grid,
-            )
+    @property
+    def blurred_image(self):
+        """
+        Returns the image of all light profiles in the fit's tracer convolved with the imaging dataset's PSF.
 
-        else:
+        For certain lens models the blurred image does not change (for example when all light profiles in the tracer
+        are fixed in the lens model). For faster run-times the blurred image can be preloaded.
+        """
 
-            self.blurred_image = preloads.blurred_image
+        if self.preloads.blurred_image is None:
 
-        self.profile_subtracted_image = image - self.blurred_image
+            return self.tracer.blurred_image_2d_via_convolver_from(
+                grid=self.dataset.grid,
+                convolver=self.dataset.convolver,
+                blurring_grid=self.dataset.blurring_grid,
+            )
+        return self.preloads.blurred_image
 
-        if not tracer.has_pixelization:
+    @property
+    def profile_subtracted_image(self):
+        """
+        Returns the dataset's image with all blurred light profile images in the fit's tracer subtracted.
+        """
+        return self.image - self.blurred_image
 
-            inversion = None
-            model_image = self.blurred_image
+    @property
+    def inversion(self):
+        """
+        If the tracer has linear objects which are used to fit the data (e.g. a pixelization) this function returns
+        the linear inversion.
 
-        else:
+        The image passed to this function is the dataset's image with all light profile images of the tracer subtracted.
+        """
+        if self.tracer.has_pixelization:
 
-            inversion = tracer.inversion_imaging_from(
-                grid=dataset.grid_inversion,
+            return self.tracer.inversion_imaging_from(
+                grid=self.dataset.grid_inversion,
                 image=self.profile_subtracted_image,
-                noise_map=noise_map,
-                convolver=dataset.convolver,
-                w_tilde=dataset.w_tilde,
-                settings_pixelization=settings_pixelization,
-                settings_inversion=settings_inversion,
-                preloads=preloads,
+                noise_map=self.noise_map,
+                convolver=self.dataset.convolver,
+                w_tilde=self.dataset.w_tilde,
+                settings_pixelization=self.settings_pixelization,
+                settings_inversion=self.settings_inversion,
             )
 
-            model_image = self.blurred_image + inversion.mapped_reconstructed_image
+    @property
+    def model_data(self):
+        """
+        Returns the model-image that is used to fit the data.
+
+        If the tracer does not have any linear objects and therefore omits an inversion, the model image is the
+        sum of all light profile images.
 
-        fit = aa.FitData(
-            data=image,
-            noise_map=noise_map,
-            model_data=model_image,
-            mask=dataset.mask,
-            inversion=inversion,
-            use_mask_in_fit=False,
-            profiling_dict=profiling_dict,
-        )
+        If a inversion is included it is the sum of this sum and the inversion's reconstruction of the image.
+        """
 
-        super().__init__(dataset=dataset, fit=fit, profiling_dict=profiling_dict)
+        if self.tracer.has_pixelization:
+
+            return self.blurred_image + self.inversion.mapped_reconstructed_data
+
+        return self.blurred_image
 
     @property
     def grid(self):
@@ -192,20 +223,18 @@ def total_mappers(self):
 
     def refit_with_new_preloads(self, preloads, settings_inversion=None):
 
-        if self.profiling_dict is not None:
-            profiling_dict = {}
-        else:
-            profiling_dict = None
+        profiling_dict = {} if self.profiling_dict is not None else None
 
-        if settings_inversion is None:
-            settings_inversion = self.settings_inversion
+        settings_inversion = (
+            self.settings_inversion if settings_inversion is None else None
+        )
 
         return FitImaging(
             dataset=self.imaging,
             tracer=self.tracer,
             hyper_image_sky=self.hyper_image_sky,
             hyper_background_noise=self.hyper_background_noise,
-            use_hyper_scaling=self.use_hyper_scaling,
+            use_hyper_scalings=self.use_hyper_scalings,
             settings_pixelization=self.settings_pixelization,
             settings_inversion=settings_inversion,
             preloads=preloads,

autolens/imaging/mock/mock_fit_imaging.py

@@ -0,0 +1,23 @@
+import autoarray as aa
+
+
+class MockFitImaging(aa.m.MockFitImaging):
+    def __init__(
+        self,
+        tracer=None,
+        dataset=aa.m.MockDataset(),
+        inversion=None,
+        noise_map=None,
+        grid=None,
+        blurred_image=None,
+    ):
+
+        super().__init__(
+            dataset=dataset,
+            inversion=inversion,
+            noise_map=noise_map,
+            blurred_image=blurred_image,
+        )
+
+        self.tracer = tracer
+        self.grid = grid

autolens/imaging/model/analysis.py

@@ -226,7 +226,7 @@ def fit_imaging_for_tracer(
             tracer=tracer,
             hyper_image_sky=hyper_image_sky,
             hyper_background_noise=hyper_background_noise,
-            use_hyper_scaling=use_hyper_scalings,
+            use_hyper_scalings=use_hyper_scalings,
             settings_pixelization=self.settings_pixelization,
             settings_inversion=self.settings_inversion,
             preloads=preloads,
@@ -490,7 +490,7 @@ def save_results_for_aggregator(
 
     def make_result(
         self, samples: af.PDFSamples, model: af.Collection, search: af.NonLinearSearch
-    ):
+    ) -> ResultImaging:
         """
         After the non-linear search is complete create its `Result`, which includes: