merge main

Author: rhayes777

autolens/__init__.py

@@ -123,4 +123,4 @@
 
 conf.instance.register(__file__)
 
-__version__ = "2024.9.21.2"
+__version__ = "2024.11.6.1"

autolens/aggregator/tracer.py

@@ -41,13 +41,15 @@ def _tracer_from(
         galaxies = instance.galaxies
 
         if hasattr(instance, "extra_galaxies"):
-            galaxies = galaxies + fit.instance.extra_galaxies
+            if fit.instance.extra_galaxies is not None:
+                galaxies = galaxies + fit.instance.extra_galaxies
 
     else:
         galaxies = fit.instance.galaxies
 
         if hasattr(fit.instance, "extra_galaxies"):
-            galaxies = galaxies + fit.instance.extra_galaxies
+            if fit.instance.extra_galaxies is not None:
+                galaxies = galaxies + fit.instance.extra_galaxies
 
     try:
         cosmology = instance.cosmology

autolens/analysis/result.py

@@ -169,6 +169,36 @@ def positions_likelihood_from(
         use_resample=False,
         positions: Optional[aa.Grid2DIrregular] = None,
     ) -> Union[PositionsLHPenalty, PositionsLHResample]:
+        """
+        Returns a `PositionsLH` object from the result of a lens model-fit, where the maximum log likelihood mass
+        and source models are used to determine the multiple image positions in the image-plane and source-plane
+        and ray-trace them to the source-plane to determine the threshold.
+
+        In chained fits, for example the SLaM pipelines, this means that a simple initial fit (e.g. SIE mass model,
+        parametric source) can be used to determine the multiple image positions and threshold for a more complex
+        subsequent fit (e.g. power-law mass model, pixelized source).
+
+        Parameters
+        ----------
+        factor
+            The value the computed threshold is multiplied by to make the position threshold larger or smaller than the
+            maximum log likelihood model's threshold.
+        minimum_threshold
+            The output threshold is rounded up to this value if it is below it, to avoid extremely small threshold
+            values.
+        use_resample
+            If `False` the `PositionsLH` object is created using the `PositionsLHPenalty` class, which uses the
+            threshold to apply a penalty term to the likelihood. If `True` the `PositionsLH` object is created using
+            the `PositionsLHResample` class, which resamples the positions to the threshold.
+        positions
+            If input, these positions are used instead of the computed multiple image positions from the lens mass
+            model.
+
+        Returns
+        -------
+        The `PositionsLH` object used to apply a likelihood penalty or resample the positions.
+        """
+
         if os.environ.get("PYAUTOFIT_TEST_MODE") == "1":
             return None
 

autolens/config/visualize/plots.yaml

@@ -7,6 +7,10 @@
     psf: false
   positions:                                 # Settings for plots with resampling image-positions on (e.g. the image).
     image_with_positions: true
+  point_dataset:                             # Settings for plots of point source datasets (e.g. PointDatasetPlotter).
+    subplot_dataset: true                    # Plot subplot containing all dataset quantities (e.g. the data, noise-map, etc.)?
+    positions: false                         # Plot the positions of th multiple images of the point source in the image plane?
+    fluxes: false                            # Plot the fluxes of the multiple images of the point source in the image plane?
   fit:                                       # Settings for plots of all fits (e.g. FitImagingPlotter, FitInterferometerPlotter).
     subplot_fit: true                        # Plot subplot of all fit quantities for any dataset (e.g. the model data, residual-map, etc.)?
     all_at_end_png: true                     # Plot all individual plots listed below as .png (even if False)?
@@ -25,6 +29,9 @@
     subtracted_images_of_planes: false       # Plot individual plots of each plane's subtracted image?
     plane_images_of_planes: false            # Plot individual plots of each plane's image (e.g. in the source plane)?
   fit_imaging: {}                            # Settings for plots of fits to imaging datasets (e.g. FitImagingPlotter).
+  fit_point_dataset:                         # Settings for plots of fits to point source datasets (e.g. FitPointDatasetPlotter).
+    positions: false                         # Plot the positions of th multiple images of the point source in the image plane?
+    fluxes: false                            # Plot the fluxes of the multiple images of the point source in the image plane?
   tracer:                               # Settings for plots of tracers (e.g. TracerPlotter).
     subplot_tracer: true                # Plot subplot of all quantities in each tracer (e.g. images, convergence)?
     all_at_end_png: true                     # Plot all individual plots listed below as .png (even if False)?

autolens/imaging/plot/fit_imaging_plotters.py

@@ -148,6 +148,8 @@ def figures_2d_of_planes(
         subtracted_image: bool = False,
         model_image: bool = False,
         plane_image: bool = False,
+        plane_errors: bool = False,
+        plane_signal_to_noise_map: bool = False,
         use_source_vmax: bool = False,
         zoom_to_brightest: bool = True,
         interpolate_to_uniform: bool = False,
@@ -178,6 +180,14 @@ def figures_2d_of_planes(
             Whether to make a 2D plot (via `imshow`) of the image of a plane in its source-plane (e.g. unlensed).
             Depending on how the fit is performed, this could either be an image of light profiles of the reconstruction
             of an `Inversion`.
+        plane_errors
+            Whether to make a 2D plot (via `imshow`) of the errors of a plane in its source-plane, where the
+            errors can only be computed when a pixelized source reconstruction is performed and they correspond to
+            the errors in each reconstructed pixel as given by the inverse curvature matrix.
+        plane_signal_to_noise_map
+            Whether to make a 2D plot (via `imshow`) of the signal-to-noise map of a plane in its source-plane,
+            where the signal-to-noise map values can only be computed when a pixelized source reconstruction and they
+            are the ratio of reconstructed flux to error in each pixel.
         use_source_vmax
             If `True`, the maximum value of the lensed source (e.g. in the image-plane) is used to set the `vmax` of
             certain plots (e.g. the `data`) in order to ensure the lensed source is visible compared to the lens.
@@ -283,6 +293,14 @@ def figures_2d_of_planes(
 
                 elif self.tracer.planes[plane_index].has(cls=aa.Pixelization):
 
+                    pix = self.tracer.planes[plane_index].cls_list_from(cls=aa.Pixelization)[0]
+
+                    if isinstance(pix.mesh, aa.mesh.Delaunay):
+                        try:
+                            self.mat_plot_2d.cmap.kwargs.pop("vmax")
+                        except KeyError:
+                            pass
+
                     inversion_plotter = self.inversion_plotter_of_plane(
                         plane_index=plane_index
                     )
@@ -294,8 +312,41 @@ def figures_2d_of_planes(
                         interpolate_to_uniform=interpolate_to_uniform
                     )
 
-        if use_source_vmax:
-            self.mat_plot_2d.cmap.kwargs.pop("vmax")
+            if use_source_vmax:
+                try:
+                    self.mat_plot_2d.cmap.kwargs.pop("vmax")
+                except KeyError:
+                    pass
+
+            if plane_errors:
+
+                if self.tracer.planes[plane_index].has(cls=aa.Pixelization):
+
+                    inversion_plotter = self.inversion_plotter_of_plane(
+                        plane_index=plane_index
+                    )
+
+                    inversion_plotter.figures_2d_of_pixelization(
+                        pixelization_index=0,
+                        errors=True,
+                        zoom_to_brightest=zoom_to_brightest,
+                        interpolate_to_uniform=interpolate_to_uniform
+                    )
+
+            if plane_signal_to_noise_map:
+
+                if self.tracer.planes[plane_index].has(cls=aa.Pixelization):
+
+                    inversion_plotter = self.inversion_plotter_of_plane(
+                        plane_index=plane_index
+                    )
+
+                    inversion_plotter.figures_2d_of_pixelization(
+                        pixelization_index=0,
+                        signal_to_noise_map=True,
+                        zoom_to_brightest=zoom_to_brightest,
+                        interpolate_to_uniform=interpolate_to_uniform
+                    )
 
     def subplot_of_planes(self, plane_index: Optional[int] = None):
         """
@@ -614,7 +665,12 @@ def subplot_mappings_of_plane(self, plane_index: Optional[int] = None, auto_file
                     "total_mappings_pixels"
                 ]
 
-                pix_indexes = inversion_plotter.inversion.brightest_pixel_list_from(
+                mapper = inversion_plotter.inversion.cls_list_from(cls=aa.AbstractMapper)[0]
+                mapper_valued = aa.MapperValued(
+                    values=inversion_plotter.inversion.reconstruction_dict[mapper],
+                    mapper=mapper,
+                )
+                pix_indexes = mapper_valued.max_pixel_list_from(
                     total_pixels=total_pixels, filter_neighbors=True
                 )
 

autolens/interferometer/plot/fit_interferometer_plotters.py

@@ -229,7 +229,12 @@ def subplot_mappings_of_plane(
                 "total_mappings_pixels"
             ]
 
-            pix_indexes = inversion_plotter.inversion.brightest_pixel_list_from(
+            mapper = inversion_plotter.inversion.cls_list_from(cls=aa.AbstractMapper)[0]
+            mapper_valued = aa.MapperValued(
+                values=inversion_plotter.inversion.reconstruction_dict[mapper],
+                mapper=mapper,
+            )
+            pix_indexes = mapper_valued.max_pixel_list_from(
                 total_pixels=total_pixels, filter_neighbors=True
             )
 
@@ -370,7 +375,10 @@ def figures_2d_of_planes(
         self,
         plane_index: Optional[int] = None,
         plane_image: bool = False,
+        plane_errors: bool = False,
+        plane_signal_to_noise_map: bool = False,
         zoom_to_brightest: bool = True,
+        interpolate_to_uniform: bool = False,
     ):
         """
         Plots images representing each individual `Plane` in the fit's `Tracer` in 2D, which are computed via the
@@ -390,9 +398,20 @@ def figures_2d_of_planes(
             Whether to make a 2D plot (via `imshow`) of the image of a plane in its source-plane (e.g. unlensed).
             Depending on how the fit is performed, this could either be an image of light profiles of the reconstruction
             of an `Inversion`.
+        plane_errors
+            Whether to make a 2D plot (via `imshow`) of the errors of a plane in its source-plane, where the
+            errors can only be computed when a pixelized source reconstruction is performed and they correspond to
+            the errors in each reconstructed pixel as given by the inverse curvature matrix.
+        plane_signal_to_noise_map
+            Whether to make a 2D plot (via `imshow`) of the signal-to-noise map of a plane in its source-plane,
+            where the signal-to-noise map values can only be computed when a pixelized source reconstruction and they
+            are the ratio of reconstructed flux to error in each pixel.
         zoom_to_brightest
             For images not in the image-plane (e.g. the `plane_image`), whether to automatically zoom the plot to
             the brightest regions of the galaxies being plotted as opposed to the full extent of the grid.
+        interpolate_to_uniform
+            If `True`, the mapper's reconstruction is interpolated to a uniform grid before plotting, for example
+            meaning that an irregular Delaunay grid can be plotted as a uniform grid.
         """
         if plane_image:
             if not self.tracer.planes[plane_index].has(cls=aa.Pixelization):
@@ -408,6 +427,33 @@ def figures_2d_of_planes(
                     pixelization_index=0,
                     reconstruction=True,
                     zoom_to_brightest=zoom_to_brightest,
+                    interpolate_to_uniform=interpolate_to_uniform,
+                )
+
+        if plane_errors:
+            if self.tracer.planes[plane_index].has(cls=aa.Pixelization):
+                inversion_plotter = self.inversion_plotter_of_plane(
+                    plane_index=plane_index
+                )
+
+                inversion_plotter.figures_2d_of_pixelization(
+                    pixelization_index=0,
+                    errors=True,
+                    zoom_to_brightest=zoom_to_brightest,
+                    interpolate_to_uniform=interpolate_to_uniform,
+                )
+
+        if plane_signal_to_noise_map:
+            if self.tracer.planes[plane_index].has(cls=aa.Pixelization):
+                inversion_plotter = self.inversion_plotter_of_plane(
+                    plane_index=plane_index
+                )
+
+                inversion_plotter.figures_2d_of_pixelization(
+                    pixelization_index=0,
+                    signal_to_noise_map=True,
+                    zoom_to_brightest=zoom_to_brightest,
+                    interpolate_to_uniform=interpolate_to_uniform,
                 )
 
     def subplot_fit_real_space(self):

autolens/lens/sensitivity.py

@@ -360,6 +360,109 @@ def set_auto_filename(
 
         return False
 
+    def subplot_sensitivity(self):
+
+        log_likelihoods = self.result.figure_of_merit_array(
+            use_log_evidences=False,
+            remove_zeros=True,
+        )
+
+        try:
+            log_evidences = self.result.figure_of_merit_array(
+                use_log_evidences=True,
+                remove_zeros=True,
+            )
+        except TypeError:
+            log_evidences = np.zeros_like(log_likelihoods)
+
+        self.open_subplot_figure(number_subplots=8, subplot_shape=(2,4))
+
+        plotter = aplt.Array2DPlotter(
+            array=self.data_subtracted,
+            mat_plot_2d=self.mat_plot_2d,
+        )
+
+        plotter.figure_2d()
+
+        self.mat_plot_2d.plot_array(
+            array=log_evidences,
+            visuals_2d=self.visuals_2d,
+            auto_labels=AutoLabels(title="Increase in Log Evidence"),
+        )
+
+        self.mat_plot_2d.plot_array(
+            array=log_likelihoods,
+            visuals_2d=self.visuals_2d,
+            auto_labels=AutoLabels(title="Increase in Log Likelihood"),
+        )
+
+        above_threshold = np.where(log_likelihoods > 5.0, 1.0, 0.0)
+
+        above_threshold = aa.Array2D(
+            values=above_threshold,
+            mask=log_likelihoods.mask
+        )
+
+        self.mat_plot_2d.plot_array(
+            array=above_threshold,
+            visuals_2d=self.visuals_2d,
+            auto_labels=AutoLabels(title="Log Likelihood > 5.0"),
+        )
+
+        try:
+            log_evidences_base = self.result._array_2d_from(self.result.log_evidences_base)
+            log_evidences_perturbed = self.result._array_2d_from(self.result.log_evidences_perturbed)
+
+            log_evidences_base_min = np.nanmin(np.where(log_evidences_base == 0, np.nan, log_evidences_base))
+            log_evidences_base_max = np.nanmax(np.where(log_evidences_base == 0, np.nan, log_evidences_base))
+            log_evidences_perturbed_min = np.nanmin(np.where(log_evidences_perturbed == 0, np.nan, log_evidences_perturbed))
+            log_evidences_perturbed_max = np.nanmax(np.where(log_evidences_perturbed == 0, np.nan, log_evidences_perturbed))
+
+            self.mat_plot_2d.cmap.kwargs["vmin"] = np.min([log_evidences_base_min, log_evidences_perturbed_min])
+            self.mat_plot_2d.cmap.kwargs["vmax"] = np.max([log_evidences_base_max, log_evidences_perturbed_max])
+
+            self.mat_plot_2d.plot_array(
+                array=log_evidences_base,
+                visuals_2d=self.visuals_2d,
+                auto_labels=AutoLabels(title="Log Evidence Base"),
+            )
+
+            self.mat_plot_2d.plot_array(
+                array=log_evidences_perturbed,
+                visuals_2d=self.visuals_2d,
+                auto_labels=AutoLabels(title="Log Evidence Perturb"),
+
+            )
+        except TypeError:
+            pass
+        
+        log_likelihoods_base = self.result._array_2d_from(self.result.log_likelihoods_base)
+        log_likelihoods_perturbed = self.result._array_2d_from(self.result.log_likelihoods_perturbed)
+
+        log_likelihoods_base_min = np.nanmin(np.where(log_likelihoods_base == 0, np.nan, log_likelihoods_base))
+        log_likelihoods_base_max = np.nanmax(np.where(log_likelihoods_base == 0, np.nan, log_likelihoods_base))
+        log_likelihoods_perturbed_min = np.nanmin(np.where(log_likelihoods_perturbed == 0, np.nan, log_likelihoods_perturbed))
+        log_likelihoods_perturbed_max = np.nanmax(np.where(log_likelihoods_perturbed == 0, np.nan, log_likelihoods_perturbed))
+
+        self.mat_plot_2d.cmap.kwargs["vmin"] = np.min([log_likelihoods_base_min, log_likelihoods_perturbed_min])
+        self.mat_plot_2d.cmap.kwargs["vmax"] = np.max([log_likelihoods_base_max, log_likelihoods_perturbed_max])
+
+        self.mat_plot_2d.plot_array(
+            array=log_likelihoods_base,
+            visuals_2d=self.visuals_2d,
+            auto_labels=AutoLabels(title="Log Likelihood Base"),
+        )
+
+        self.mat_plot_2d.plot_array(
+            array=log_likelihoods_perturbed,
+            visuals_2d=self.visuals_2d,
+            auto_labels=AutoLabels(title="Log Likelihood Perturb"),
+        )
+
+        self.mat_plot_2d.output.subplot_to_figure(auto_filename="subplot_sensitivity")
+
+        self.close_subplot_figure()
+
     def subplot_figures_of_merit_grid(
         self,
         use_log_evidences: bool = True,