Complete plot refactor: remove all *Plotter classes, add standalone subplot functions

- Remove SubhaloPlotter from subhalo.py; replace with subplot_detection_imaging
  and subplot_detection_fits standalone functions in lens/plot/subhalo_plots.py
- Remove SubhaloSensitivityPlotter from sensitivity.py; replace with
  subplot_tracer_images, subplot_sensitivity, subplot_figures_of_merit_grid
  standalone functions in lens/plot/sensitivity_plots.py
- Delete autolens/plot/abstract_plotters.py (no longer needed)
- Update autolens/plot/__init__.py: export only plot_array, plot_grid,
  wrap classes, and all subplot_* functions; remove all *Plotter class exports
- Fix analysis/plotter_interface.py: replace aplt.Array2DPlotter usage in
  image_with_positions with standalone plot_array call
- Add vmin/vmax params to plot_array in plot_utils.py for coordinated colormaps
- Rename test files from test_*_plotters.py to test_*_plots.py
- All 173 tests pass

https://claude.ai/code/session_01CzJBy8KvFXiNchoNdk5i9k

Author: claude

autolens/analysis/plotter_interface.py

@@ -7,14 +7,14 @@
 
 import autoarray as aa
 import autogalaxy as ag
-import autogalaxy.plot as aplt
 
 from autogalaxy.analysis.plotter_interface import plot_setting
 
 from autogalaxy.analysis.plotter_interface import PlotterInterface as AgPlotterInterface
 
 from autolens.lens.tracer import Tracer
 from autolens.lens.plot.tracer_plots import subplot_galaxies_images
+from autolens.plot.plot_utils import plot_array
 
 
 class PlotterInterface(AgPlotterInterface):
@@ -145,20 +145,19 @@ def image_with_positions(self, image: aa.Array2D, positions: aa.Grid2DIrregular)
         def should_plot(name):
             return plot_setting(section=["positions"], name=name)
 
-        output = self.output_from()
-
-        if positions is not None:
+        if positions is not None and should_plot("image_with_positions"):
             pos_arr = np.array(
                 positions.array if hasattr(positions, "array") else positions
             )
 
-            image_plotter = aplt.Array2DPlotter(
+            fmt = self.fmt
+            if isinstance(fmt, (list, tuple)):
+                fmt = fmt[0]
+
+            plot_array(
                 array=image,
-                output=output,
                 positions=[pos_arr],
+                output_path=str(self.image_path),
+                output_filename="image_with_positions",
+                output_format=fmt,
             )
-
-            image_plotter.set_filename("image_with_positions")
-
-            if should_plot("image_with_positions"):
-                image_plotter.figure_2d()

autolens/lens/plot/sensitivity_plots.py

@@ -0,0 +1,185 @@
+"""Standalone subplot functions for subhalo sensitivity mapping visualisation."""
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import Optional
+
+import autoarray as aa
+
+from autolens.plot.plot_utils import plot_array, _save_subplot
+
+
+def subplot_tracer_images(
+    mask,
+    tracer_perturb,
+    tracer_no_perturb,
+    source_image,
+    output_path: Optional[str] = None,
+    output_format: str = "png",
+    colormap: str = "jet",
+    use_log10: bool = False,
+):
+    """6-panel subplot showing lensed images and residuals from a perturbed tracer."""
+    from autolens.lens.tracer_util import critical_curves_from, caustics_from
+    from autolens.plot.plot_utils import _to_lines
+
+    grid = aa.Grid2D.from_mask(mask=mask)
+
+    image = tracer_perturb.image_2d_from(grid=grid)
+    lensed_source_image = tracer_perturb.image_2d_via_input_plane_image_from(
+        grid=grid, plane_image=source_image
+    )
+    lensed_source_image_no_perturb = tracer_no_perturb.image_2d_via_input_plane_image_from(
+        grid=grid, plane_image=source_image
+    )
+
+    unmasked_grid = mask.derive_grid.unmasked
+
+    try:
+        tan_cc_p, rad_cc_p = critical_curves_from(tracer=tracer_perturb, grid=unmasked_grid)
+        perturb_cc_lines = _to_lines(list(tan_cc_p), list(rad_cc_p))
+    except Exception:
+        perturb_cc_lines = None
+
+    try:
+        tan_ca_p, rad_ca_p = caustics_from(tracer=tracer_perturb, grid=unmasked_grid)
+        perturb_ca_lines = _to_lines(list(tan_ca_p), list(rad_ca_p))
+    except Exception:
+        perturb_ca_lines = None
+
+    try:
+        tan_cc_n, rad_cc_n = critical_curves_from(tracer=tracer_no_perturb, grid=unmasked_grid)
+        no_perturb_cc_lines = _to_lines(list(tan_cc_n), list(rad_cc_n))
+    except Exception:
+        no_perturb_cc_lines = None
+
+    residual_map = lensed_source_image - lensed_source_image_no_perturb
+
+    fig, axes = plt.subplots(1, 6, figsize=(42, 7))
+
+    plot_array(array=image, ax=axes[0], title="Image",
+               colormap=colormap, use_log10=use_log10)
+    plot_array(array=lensed_source_image, ax=axes[1], title="Lensed Source Image",
+               colormap=colormap, use_log10=use_log10, lines=perturb_cc_lines)
+    plot_array(array=source_image, ax=axes[2], title="Source Image",
+               colormap=colormap, use_log10=use_log10, lines=perturb_ca_lines)
+    plot_array(array=tracer_perturb.convergence_2d_from(grid=grid), ax=axes[3],
+               title="Convergence", colormap=colormap, use_log10=use_log10)
+    plot_array(array=lensed_source_image, ax=axes[4],
+               title="Lensed Source Image (No Subhalo)",
+               colormap=colormap, use_log10=use_log10, lines=no_perturb_cc_lines)
+    plot_array(array=residual_map, ax=axes[5],
+               title="Residual Map (Subhalo - No Subhalo)",
+               colormap=colormap, use_log10=use_log10, lines=no_perturb_cc_lines)
+
+    plt.tight_layout()
+    _save_subplot(fig, output_path, "subplot_lensed_images", output_format)
+
+
+def subplot_sensitivity(
+    result,
+    data_subtracted,
+    output_path: Optional[str] = None,
+    output_format: str = "png",
+    colormap: str = "jet",
+    use_log10: bool = False,
+):
+    """8-panel sensitivity subplot: log-likelihood/evidence maps and above-threshold map."""
+    log_likelihoods = result.figure_of_merit_array(
+        use_log_evidences=False,
+        remove_zeros=True,
+    )
+
+    try:
+        log_evidences = result.figure_of_merit_array(
+            use_log_evidences=True,
+            remove_zeros=True,
+        )
+    except TypeError:
+        log_evidences = np.zeros_like(log_likelihoods)
+
+    above_threshold = np.where(log_likelihoods > 5.0, 1.0, 0.0)
+    above_threshold = aa.Array2D(values=above_threshold, mask=log_likelihoods.mask)
+
+    fig, axes = plt.subplots(2, 4, figsize=(28, 14))
+    axes_flat = list(axes.flatten())
+
+    plot_array(array=data_subtracted, ax=axes_flat[0], title="Subtracted Image",
+               colormap=colormap, use_log10=use_log10)
+    plot_array(array=log_evidences, ax=axes_flat[1], title="Increase in Log Evidence",
+               colormap=colormap)
+    plot_array(array=log_likelihoods, ax=axes_flat[2], title="Increase in Log Likelihood",
+               colormap=colormap)
+    plot_array(array=above_threshold, ax=axes_flat[3], title="Log Likelihood > 5.0",
+               colormap=colormap)
+
+    ax_idx = 4
+    try:
+        log_evidences_base = result._array_2d_from(result.log_evidences_base)
+        log_evidences_perturbed = result._array_2d_from(result.log_evidences_perturbed)
+
+        base_vals = np.asarray(log_evidences_base)
+        perturb_vals = np.asarray(log_evidences_perturbed)
+        finite_base = base_vals[np.isfinite(base_vals) & (base_vals != 0)]
+        finite_perturb = perturb_vals[np.isfinite(perturb_vals) & (perturb_vals != 0)]
+        if len(finite_base) > 0 and len(finite_perturb) > 0:
+            vmin = float(np.min([np.min(finite_base), np.min(finite_perturb)]))
+            vmax = float(np.max([np.max(finite_base), np.max(finite_perturb)]))
+        else:
+            vmin = vmax = None
+
+        plot_array(array=log_evidences_base, ax=axes_flat[ax_idx],
+                   title="Log Evidence Base", colormap=colormap, vmin=vmin, vmax=vmax)
+        ax_idx += 1
+        plot_array(array=log_evidences_perturbed, ax=axes_flat[ax_idx],
+                   title="Log Evidence Perturb", colormap=colormap, vmin=vmin, vmax=vmax)
+        ax_idx += 1
+    except (TypeError, AttributeError):
+        pass
+
+    try:
+        log_likelihoods_base = result._array_2d_from(result.log_likelihoods_base)
+        log_likelihoods_perturbed = result._array_2d_from(result.log_likelihoods_perturbed)
+
+        base_vals = np.asarray(log_likelihoods_base)
+        perturb_vals = np.asarray(log_likelihoods_perturbed)
+        finite_base = base_vals[np.isfinite(base_vals) & (base_vals != 0)]
+        finite_perturb = perturb_vals[np.isfinite(perturb_vals) & (perturb_vals != 0)]
+        if len(finite_base) > 0 and len(finite_perturb) > 0:
+            vmin = float(np.min([np.min(finite_base), np.min(finite_perturb)]))
+            vmax = float(np.max([np.max(finite_base), np.max(finite_perturb)]))
+        else:
+            vmin = vmax = None
+
+        if ax_idx < len(axes_flat):
+            plot_array(array=log_likelihoods_base, ax=axes_flat[ax_idx],
+                       title="Log Likelihood Base", colormap=colormap, vmin=vmin, vmax=vmax)
+            ax_idx += 1
+        if ax_idx < len(axes_flat):
+            plot_array(array=log_likelihoods_perturbed, ax=axes_flat[ax_idx],
+                       title="Log Likelihood Perturb", colormap=colormap, vmin=vmin, vmax=vmax)
+    except (TypeError, AttributeError):
+        pass
+
+    plt.tight_layout()
+    _save_subplot(fig, output_path, "subplot_sensitivity", output_format)
+
+
+def subplot_figures_of_merit_grid(
+    result,
+    output_path: Optional[str] = None,
+    output_format: str = "png",
+    colormap: str = "jet",
+    use_log_evidences: bool = True,
+    remove_zeros: bool = True,
+):
+    """Single-panel subplot: the figures-of-merit grid for sensitivity mapping."""
+    figures_of_merit = result.figure_of_merit_array(
+        use_log_evidences=use_log_evidences,
+        remove_zeros=remove_zeros,
+    )
+
+    fig, ax = plt.subplots(1, 1, figsize=(7, 7))
+    plot_array(array=figures_of_merit, ax=ax, title="Increase in Log Evidence",
+               colormap=colormap)
+    plt.tight_layout()
+    _save_subplot(fig, output_path, "sensitivity", output_format)

autolens/lens/plot/subhalo_plots.py

@@ -0,0 +1,103 @@
+"""Standalone subplot functions for subhalo detection visualisation."""
+import matplotlib.pyplot as plt
+from typing import Optional
+
+from autolens.plot.plot_utils import plot_array, _save_subplot
+from autolens.imaging.plot.fit_imaging_plots import _plot_source_plane
+
+
+def subplot_detection_imaging(
+    result,
+    fit_imaging_with_subhalo,
+    output_path: Optional[str] = None,
+    output_format: str = "png",
+    colormap: str = "jet",
+    use_log10: bool = False,
+    use_log_evidences: bool = True,
+    relative_to_value: float = 0.0,
+    remove_zeros: bool = False,
+):
+    """4-panel subplot: data, S/N map, log-evidence increase, subhalo mass grid."""
+    fig, axes = plt.subplots(1, 4, figsize=(28, 7))
+
+    plot_array(
+        array=fit_imaging_with_subhalo.data,
+        ax=axes[0],
+        title="Data",
+        colormap=colormap,
+        use_log10=use_log10,
+    )
+    plot_array(
+        array=fit_imaging_with_subhalo.signal_to_noise_map,
+        ax=axes[1],
+        title="Signal-To-Noise Map",
+        colormap=colormap,
+        use_log10=use_log10,
+    )
+
+    fom_array = result.figure_of_merit_array(
+        use_log_evidences=use_log_evidences,
+        relative_to_value=relative_to_value,
+        remove_zeros=remove_zeros,
+    )
+    plot_array(
+        array=fom_array,
+        ax=axes[2],
+        title="Increase in Log Evidence",
+        colormap=colormap,
+    )
+
+    mass_array = result.subhalo_mass_array
+    plot_array(
+        array=mass_array,
+        ax=axes[3],
+        title="Subhalo Mass",
+        colormap=colormap,
+    )
+
+    plt.tight_layout()
+    _save_subplot(fig, output_path, "subplot_detection_imaging", output_format)
+
+
+def subplot_detection_fits(
+    fit_imaging_no_subhalo,
+    fit_imaging_with_subhalo,
+    output_path: Optional[str] = None,
+    output_format: str = "png",
+    colormap: str = "jet",
+):
+    """6-panel subplot comparing fits with and without a subhalo."""
+    fig, axes = plt.subplots(2, 3, figsize=(21, 14))
+
+    plot_array(
+        array=fit_imaging_no_subhalo.normalized_residual_map,
+        ax=axes[0][0],
+        title="Normalized Residual Map (No Subhalo)",
+        colormap=colormap,
+    )
+    plot_array(
+        array=fit_imaging_no_subhalo.chi_squared_map,
+        ax=axes[0][1],
+        title="Chi-Squared Map (No Subhalo)",
+        colormap=colormap,
+    )
+    _plot_source_plane(fit_imaging_no_subhalo, axes[0][2], plane_index=1,
+                       colormap=colormap)
+
+    plot_array(
+        array=fit_imaging_with_subhalo.normalized_residual_map,
+        ax=axes[1][0],
+        title="Normalized Residual Map (With Subhalo)",
+        colormap=colormap,
+    )
+    plot_array(
+        array=fit_imaging_with_subhalo.chi_squared_map,
+        ax=axes[1][1],
+        title="Chi-Squared Map (With Subhalo)",
+        colormap=colormap,
+    )
+    _plot_source_plane(fit_imaging_with_subhalo, axes[1][2], plane_index=1,
+                       colormap=colormap)
+
+    plt.tight_layout()
+    _save_subplot(fig, output_path, "subplot_detection_fits", output_format)