25683986170

Committed 11 May 2026 04:45PM UTC coverage: 86.691% (-0.1%) from 86.801%

Build # 25683986170

Build Type

Pull #361

github

Committed by

web-flow

Commit Message

Merge 5b7acbf72 into 6cb1b083e

Pull Request Pull Request #361: Non-detection interface overhaul + misc

Coverage Stats

251 of 366 new or added lines in 9 files covered. (68.58%)

7 existing lines in 4 files now uncovered.

15229 of 17567 relevant lines covered (86.69%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.2

/redback/plotting.py

from __future__ import annotations

from os.path import join
from typing import Any, Union

import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

import redback
from redback.utils import KwargsAccessorWithDefault, logger

class _FilenameGetter(object):
    def __init__(self, suffix: str) -> None:
        self.suffix = suffix

    def __get__(self, instance: Plotter, owner: object) -> str:
        return instance.get_filename(default=f"{instance.transient.name}_{self.suffix}.png")

    def __set__(self, instance: Plotter, value: object) -> None:
        pass


class _FilePathGetter(object):

    def __init__(self, directory_property: str, filename_property: str) -> None:
        self.directory_property = directory_property
        self.filename_property = filename_property

    def __get__(self, instance: Plotter, owner: object) -> str:
        return join(getattr(instance, self.directory_property), getattr(instance, self.filename_property))


class Plotter(object):
    """
    Base class for all lightcurve plotting classes in redback.
    """

    capsize = KwargsAccessorWithDefault("capsize", 0.)
    legend_location = KwargsAccessorWithDefault("legend_location", "best")
    legend_cols = KwargsAccessorWithDefault("legend_cols", 2)
    band_colors = KwargsAccessorWithDefault("band_colors", None)
    color = KwargsAccessorWithDefault("color", "k")
    band_labels = KwargsAccessorWithDefault("band_labels", None)
    band_scaling = KwargsAccessorWithDefault("band_scaling", {})
    dpi = KwargsAccessorWithDefault("dpi", 300)
    elinewidth = KwargsAccessorWithDefault("elinewidth", 2)
    errorbar_fmt = KwargsAccessorWithDefault("errorbar_fmt", "o")
    model = KwargsAccessorWithDefault("model", None)
    ms = KwargsAccessorWithDefault("ms", 5)
    axis_tick_params_pad = KwargsAccessorWithDefault("axis_tick_params_pad", 10)

    max_likelihood_alpha = KwargsAccessorWithDefault("max_likelihood_alpha", 0.65)
    random_sample_alpha = KwargsAccessorWithDefault("random_sample_alpha", 0.05)
    uncertainty_band_alpha = KwargsAccessorWithDefault("uncertainty_band_alpha", 0.4)
    max_likelihood_color = KwargsAccessorWithDefault("max_likelihood_color", "blue")
    random_sample_color = KwargsAccessorWithDefault("random_sample_color", "red")

    bbox_inches = KwargsAccessorWithDefault("bbox_inches", "tight")
    linewidth = KwargsAccessorWithDefault("linewidth", 2)
    zorder = KwargsAccessorWithDefault("zorder", -1)

    xy = KwargsAccessorWithDefault("xy", (0.95, 0.9))
    xycoords = KwargsAccessorWithDefault("xycoords", "axes fraction")
    horizontalalignment = KwargsAccessorWithDefault("horizontalalignment", "right")
    annotation_size = KwargsAccessorWithDefault("annotation_size", 20)

    fontsize_axes = KwargsAccessorWithDefault("fontsize_axes", 18)
    fontsize_figure = KwargsAccessorWithDefault("fontsize_figure", 30)
    fontsize_legend = KwargsAccessorWithDefault("fontsize_legend", 18)
    fontsize_ticks = KwargsAccessorWithDefault("fontsize_ticks", 16)
    hspace = KwargsAccessorWithDefault("hspace", 0.04)
    wspace = KwargsAccessorWithDefault("wspace", 0.15)

    plot_others = KwargsAccessorWithDefault("plot_others", True)
    random_models = KwargsAccessorWithDefault("random_models", 100)
    uncertainty_mode = KwargsAccessorWithDefault("uncertainty_mode", "random_models")
    credible_interval_level = KwargsAccessorWithDefault("credible_interval_level", 0.9)
    plot_max_likelihood = KwargsAccessorWithDefault("plot_max_likelihood", True)
    set_same_color_per_subplot = KwargsAccessorWithDefault("set_same_color_per_subplot", True)

    xlim_high_multiplier = KwargsAccessorWithDefault("xlim_high_multiplier", 2.0)
    xlim_low_multiplier = KwargsAccessorWithDefault("xlim_low_multiplier", 0.5)
    ylim_high_multiplier = KwargsAccessorWithDefault("ylim_high_multiplier", 2.0)
    ylim_low_multiplier = KwargsAccessorWithDefault("ylim_low_multiplier", 0.5)

    # Upper limit plot options
    upper_limit_marker = KwargsAccessorWithDefault("upper_limit_marker", r"$\downarrow$")
    upper_limit_markersize = KwargsAccessorWithDefault("upper_limit_markersize", 14)
    upper_limit_alpha = KwargsAccessorWithDefault("upper_limit_alpha", 0.7)

    # Grid options
    show_grid = KwargsAccessorWithDefault("show_grid", False)
    grid_alpha = KwargsAccessorWithDefault("grid_alpha", 0.3)
    grid_color = KwargsAccessorWithDefault("grid_color", "gray")
    grid_linestyle = KwargsAccessorWithDefault("grid_linestyle", "--")
    grid_linewidth = KwargsAccessorWithDefault("grid_linewidth", 0.5)

    # Save format and transparency
    save_format = KwargsAccessorWithDefault("save_format", "png")
    transparent = KwargsAccessorWithDefault("transparent", False)

    # Axis scale options
    xscale = KwargsAccessorWithDefault("xscale", None)
    yscale = KwargsAccessorWithDefault("yscale", None)

    # Title options
    title = KwargsAccessorWithDefault("title", None)
    title_fontsize = KwargsAccessorWithDefault("title_fontsize", 20)

    # Line style options
    linestyle = KwargsAccessorWithDefault("linestyle", "-")
    max_likelihood_linestyle = KwargsAccessorWithDefault("max_likelihood_linestyle", "-")
    random_sample_linestyle = KwargsAccessorWithDefault("random_sample_linestyle", "-")

    # Marker options
    markerfillstyle = KwargsAccessorWithDefault("markerfillstyle", "full")
    markeredgecolor = KwargsAccessorWithDefault("markeredgecolor", None)
    markeredgewidth = KwargsAccessorWithDefault("markeredgewidth", 1.0)

    # Legend customization
    legend_frameon = KwargsAccessorWithDefault("legend_frameon", True)
    legend_shadow = KwargsAccessorWithDefault("legend_shadow", False)
    legend_fancybox = KwargsAccessorWithDefault("legend_fancybox", True)
    legend_framealpha = KwargsAccessorWithDefault("legend_framealpha", 0.8)

    # Tick customization
    tick_direction = KwargsAccessorWithDefault("tick_direction", "in")
    tick_length = KwargsAccessorWithDefault("tick_length", None)
    tick_width = KwargsAccessorWithDefault("tick_width", None)

    # Spine options
    show_spines = KwargsAccessorWithDefault("show_spines", True)
    spine_linewidth = KwargsAccessorWithDefault("spine_linewidth", None)

    def __init__(self, transient: Union[redback.transient.Transient, None], **kwargs) -> None:
        """
        :param transient: An instance of `redback.transient.Transient`. Contains the data to be plotted.
        :param kwargs: Additional kwargs the plotter uses. -------
        :keyword capsize: Same as matplotlib capsize.
        :keyword bands_to_plot: List of bands to plot in plot lightcurve and multiband lightcurve. Default is active bands.
        :keyword legend_location: Same as matplotlib legend location.
        :keyword legend_cols: Same as matplotlib legend columns.
        :keyword color: Color of the data points.
        :keyword band_colors: A dictionary with the colors of the bands.
        :keyword band_labels: List with the names of the bands.
        :keyword band_scaling: Dict with the scaling for each band. First entry should be {type: '+' or 'x'} for different types.
        :keyword dpi: Same as matplotlib dpi.
        :keyword elinewidth: same as matplotlib elinewidth
        :keyword errorbar_fmt: 'fmt' argument of `ax.errorbar`.
        :keyword model: str or callable, the model to plot.
        :keyword ms: Same as matplotlib markersize.
        :keyword axis_tick_params_pad: `pad` argument in calls to `ax.tick_params` when setting the axes.
        :keyword max_likelihood_alpha: `alpha` argument, i.e. transparency, when plotting the max likelihood curve.
        :keyword random_sample_alpha: `alpha` argument, i.e. transparency, when plotting random sample curves.
        :keyword uncertainty_band_alpha: `alpha` argument, i.e. transparency, when plotting a credible band.
        :keyword max_likelihood_color: Color of the maximum likelihood curve.
        :keyword random_sample_color: Color of the random sample curves.
        :keyword bbox_inches: Setting for saving plots. Default is 'tight'.
        :keyword linewidth: Same as matplotlib linewidth
        :keyword zorder: Same as matplotlib zorder
        :keyword xy: For `ax.annotate' x and y coordinates of the point to annotate.
        :keyword xycoords: The coordinate system `xy` is given in. Default is 'axes fraction'
        :keyword horizontalalignment: Horizontal alignment of the annotation. Default is 'right'
        :keyword annotation_size: `size` argument of of `ax.annotate`.
        :keyword fontsize_axes: Font size of the x and y labels.
        :keyword fontsize_legend: Font size of the legend.
        :keyword fontsize_figure: Font size of the figure. Relevant for multiband plots.
                                  Used on `supxlabel` and `supylabel`.
        :keyword fontsize_ticks: Font size of the axis ticks.
        :keyword hspace: Argument for `subplots_adjust`, sets horizontal spacing between panels.
        :keyword wspace: Argument for `subplots_adjust`, sets horizontal spacing between panels.
        :keyword plot_others: Whether to plot additional bands in the data plot, all in the same colors
        :keyword random_models: Number of random draws to use to calculate credible bands or to plot.
        :keyword uncertainty_mode: 'random_models': Plot random draws from the available parameter sets.
                                   'credible_intervals': Plot a credible interval that is calculated based
                                   on the available parameter sets.
        :keyword reference_mjd_date: Date to use as reference point for the x axis.
                                    Default is the first date in the data.
        :keyword credible_interval_level: 0.9: Plot the 90% credible interval.
        :keyword plot_max_likelihood: Plots the draw corresponding to the maximum likelihood. Default is 'True'.
        :keyword set_same_color_per_subplot: Sets the lightcurve to be the same color as the data per subplot. Default is 'True'.
        :keyword xlim_high_multiplier: Adjust the maximum xlim based on available x values.
        :keyword xlim_low_multiplier: Adjust the minimum xlim based on available x values.
        :keyword ylim_high_multiplier: Adjust the maximum ylim based on available x values.
        :keyword ylim_low_multiplier: Adjust the minimum ylim based on available x values.
        :keyword show_grid: Whether to show grid lines. Default is False.
        :keyword grid_alpha: Transparency of grid lines. Default is 0.3.
        :keyword grid_color: Color of grid lines. Default is 'gray'.
        :keyword grid_linestyle: Line style of grid lines. Default is '--'.
        :keyword grid_linewidth: Line width of grid lines. Default is 0.5.
        :keyword save_format: Format for saving plots (e.g., 'png', 'pdf', 'svg', 'eps'). Default is 'png'.
        :keyword transparent: Whether to save plots with transparent background. Default is False.
        :keyword xscale: X-axis scale ('linear', 'log', 'symlog', 'logit'). Default is None (auto-determined).
        :keyword yscale: Y-axis scale ('linear', 'log', 'symlog', 'logit'). Default is None (auto-determined).
        :keyword title: Title for the plot. Default is None (no title).
        :keyword title_fontsize: Font size for the title. Default is 20.
        :keyword linestyle: Line style for model curves. Default is '-'.
        :keyword max_likelihood_linestyle: Line style for max likelihood curve. Default is '-'.
        :keyword random_sample_linestyle: Line style for random sample curves. Default is '-'.
        :keyword markerfillstyle: Fill style for markers ('full', 'left', 'right', 'bottom', 'top', 'none'). Default is 'full'.
        :keyword markeredgecolor: Edge color for markers. Default is None (same as face color).
        :keyword markeredgewidth: Edge width for markers. Default is 1.0.
        :keyword legend_frameon: Whether to draw a frame around the legend. Default is True.
        :keyword legend_shadow: Whether to draw a shadow behind the legend. Default is False.
        :keyword legend_fancybox: Whether to use rounded corners for legend frame. Default is True.
        :keyword legend_framealpha: Transparency of legend frame. Default is 0.8.
        :keyword tick_direction: Direction of tick marks ('in', 'out', 'inout'). Default is 'in'.
        :keyword tick_length: Length of tick marks. Default is None (matplotlib default).
        :keyword tick_width: Width of tick marks. Default is None (matplotlib default).
        :keyword show_spines: Whether to show plot spines (borders). Default is True.
        :keyword spine_linewidth: Width of plot spines. Default is None (matplotlib default).
        """
        self.transient = transient
        self.kwargs = kwargs or dict()
        self._posterior_sorted = False

    keyword_docstring = __init__.__doc__.split("-------")[1]

    def _get_times(self, axes: matplotlib.axes.Axes) -> np.ndarray:
        """
        :param axes: The axes used in the plotting procedure.
        :type axes: matplotlib.axes.Axes

        :return: Linearly or logarithmically scaled time values depending on the y scale used in the plot.
        :rtype: np.ndarray
        """
        if isinstance(axes, np.ndarray):
            ax = axes[0]
        else:
            ax = axes

        if ax.get_yscale() == 'linear':
            times = np.linspace(self._xlim_low, self._xlim_high, 200)
        else:
            times = np.exp(np.linspace(np.log(self._xlim_low), np.log(self._xlim_high), 200))

        if self.transient.use_phase_model:
            times = times + self._reference_mjd_date
        return times

    @property
    def _xlim_low(self) -> float:
        default = self.xlim_low_multiplier * self.transient.x[0]
        if default == 0:
            default += 1e-3
        return self.kwargs.get("xlim_low", default)

    @property
    def _xlim_high(self) -> float:
        if self._x_err is None:
            default = self.xlim_high_multiplier * self.transient.x[-1]
        else:
            default = self.xlim_high_multiplier * (self.transient.x[-1] + self._x_err[1][-1])
        return self.kwargs.get("xlim_high", default)

    @property
    def _ylim_low(self) -> float:
        y_valid = self.transient.y[np.isfinite(self.transient.y)]
        if len(y_valid) == 0:
            return 0
        default = self.ylim_low_multiplier * min(y_valid)
        return self.kwargs.get("ylim_low", default)

    @property
    def _ylim_high(self) -> float:
        y_valid = self.transient.y[np.isfinite(self.transient.y)]
        if len(y_valid) == 0:
            return 1
        default = self.ylim_high_multiplier * np.max(y_valid)
        return self.kwargs.get("ylim_high", default)

    @property
    def _x_err(self) -> Union[np.ndarray, None]:
        if self.transient.x_err is not None:
            return np.array([np.abs(self.transient.x_err[1, :]), self.transient.x_err[0, :]])
        else:
            return None

    @property
    def _y_err(self) -> np.ndarray:
        if self.transient.y_err.ndim > 1.:
            return np.array([np.abs(self.transient.y_err[1, :]), self.transient.y_err[0, :]])
        else:
            return np.array([np.abs(self.transient.y_err)])
    @property
    def _lightcurve_plot_outdir(self) -> str:
        return self._get_outdir(join(self.transient.directory_structure.directory_path, self.model.__name__))

    @property
    def _data_plot_outdir(self) -> str:
        return self._get_outdir(self.transient.directory_structure.directory_path)

    def _get_outdir(self, default: str) -> str:
        return self._get_kwarg_with_default(kwarg="outdir", default=default)

    def get_filename(self, default: str) -> str:
        return self._get_kwarg_with_default(kwarg="filename", default=default)

    def _get_kwarg_with_default(self, kwarg: str, default: Any) -> Any:
        return self.kwargs.get(kwarg, default) or default

    @property
    def _model_kwargs(self) -> dict:
        return self._get_kwarg_with_default("model_kwargs", dict())

    @property
    def _posterior(self) -> pd.DataFrame:
        posterior = self.kwargs.get("posterior", pd.DataFrame())
        if not self._posterior_sorted and posterior is not None:
            posterior.sort_values(by='log_likelihood', inplace=True)
            self._posterior_sorted = True
        return posterior

    @property
    def _max_like_params(self) -> pd.core.series.Series:
        return self._posterior.iloc[-1]

    def _get_random_parameters(self) -> list[pd.core.series.Series]:
        integers = np.arange(len(self._posterior))
        indices = np.random.choice(integers, size=self.random_models)
        return [self._posterior.iloc[idx] for idx in indices]

    _data_plot_filename = _FilenameGetter(suffix="data")
    _lightcurve_plot_filename = _FilenameGetter(suffix="lightcurve")
    _residual_plot_filename = _FilenameGetter(suffix="residual")
    _multiband_data_plot_filename = _FilenameGetter(suffix="multiband_data")
    _multiband_lightcurve_plot_filename = _FilenameGetter(suffix="multiband_lightcurve")

    _data_plot_filepath = _FilePathGetter(
        directory_property="_data_plot_outdir", filename_property="_data_plot_filename")
    _lightcurve_plot_filepath = _FilePathGetter(
        directory_property="_lightcurve_plot_outdir", filename_property="_lightcurve_plot_filename")
    _residual_plot_filepath = _FilePathGetter(
        directory_property="_lightcurve_plot_outdir", filename_property="_residual_plot_filename")
    _multiband_data_plot_filepath = _FilePathGetter(
        directory_property="_data_plot_outdir", filename_property="_multiband_data_plot_filename")
    _multiband_lightcurve_plot_filepath = _FilePathGetter(
        directory_property="_lightcurve_plot_outdir", filename_property="_multiband_lightcurve_plot_filename")

    def _save_and_show(self, filepath: str, save: bool, show: bool) -> None:
        plt.tight_layout()
        if save:
            # Update filepath extension if save_format is specified
            if '.' in filepath:
                filepath = filepath.rsplit('.', 1)[0] + f'.{self.save_format}'
            else:
                filepath = f'{filepath}.{self.save_format}'

            facecolor = 'none' if self.transparent else 'white'
            plt.savefig(filepath, dpi=self.dpi, bbox_inches=self.bbox_inches,
                       transparent=self.transparent, facecolor=facecolor)
        if show:
            plt.show()

    def _apply_axis_customizations(self, ax: matplotlib.axes.Axes) -> None:
        """Apply common axis customizations like grid, title, ticks, and spines."""
        # Grid
        if self.show_grid:
            ax.grid(True, alpha=self.grid_alpha, color=self.grid_color,
                   linestyle=self.grid_linestyle, linewidth=self.grid_linewidth)

        # Title
        if self.title is not None:
            ax.set_title(self.title, fontsize=self.title_fontsize)

        # Tick customization
        tick_params = {'axis': 'both', 'which': 'both',
                      'pad': self.axis_tick_params_pad,
                      'labelsize': self.fontsize_ticks,
                      'direction': self.tick_direction}
        if self.tick_length is not None:
            tick_params['length'] = self.tick_length
        if self.tick_width is not None:
            tick_params['width'] = self.tick_width
        ax.tick_params(**tick_params)

        # Spine customization
        if not self.show_spines:
            for spine in ax.spines.values():
                spine.set_visible(False)
        elif self.spine_linewidth is not None:
            for spine in ax.spines.values():
                spine.set_linewidth(self.spine_linewidth)

class SpecPlotter(object):
    """
    Base class for all lightcurve plotting classes in redback.
    """

    capsize = KwargsAccessorWithDefault("capsize", 0.)
    elinewidth = KwargsAccessorWithDefault("elinewidth", 2)
    errorbar_fmt = KwargsAccessorWithDefault("errorbar_fmt", "x")
    legend_location = KwargsAccessorWithDefault("legend_location", "best")
    legend_cols = KwargsAccessorWithDefault("legend_cols", 2)
    color = KwargsAccessorWithDefault("color", "k")
    dpi = KwargsAccessorWithDefault("dpi", 300)
    model = KwargsAccessorWithDefault("model", None)
    ms = KwargsAccessorWithDefault("ms", 1)
    axis_tick_params_pad = KwargsAccessorWithDefault("axis_tick_params_pad", 10)

    max_likelihood_alpha = KwargsAccessorWithDefault("max_likelihood_alpha", 0.65)
    random_sample_alpha = KwargsAccessorWithDefault("random_sample_alpha", 0.05)
    uncertainty_band_alpha = KwargsAccessorWithDefault("uncertainty_band_alpha", 0.4)
    max_likelihood_color = KwargsAccessorWithDefault("max_likelihood_color", "blue")
    random_sample_color = KwargsAccessorWithDefault("random_sample_color", "red")

    bbox_inches = KwargsAccessorWithDefault("bbox_inches", "tight")
    linewidth = KwargsAccessorWithDefault("linewidth", 2)
    zorder = KwargsAccessorWithDefault("zorder", -1)
    yscale = KwargsAccessorWithDefault("yscale", "linear")

    xy = KwargsAccessorWithDefault("xy", (0.95, 0.9))
    xycoords = KwargsAccessorWithDefault("xycoords", "axes fraction")
    horizontalalignment = KwargsAccessorWithDefault("horizontalalignment", "right")
    annotation_size = KwargsAccessorWithDefault("annotation_size", 20)

    fontsize_axes = KwargsAccessorWithDefault("fontsize_axes", 18)
    fontsize_figure = KwargsAccessorWithDefault("fontsize_figure", 30)
    fontsize_legend = KwargsAccessorWithDefault("fontsize_legend", 18)
    fontsize_ticks = KwargsAccessorWithDefault("fontsize_ticks", 16)
    hspace = KwargsAccessorWithDefault("hspace", 0.04)
    wspace = KwargsAccessorWithDefault("wspace", 0.15)

    random_models = KwargsAccessorWithDefault("random_models", 100)
    uncertainty_mode = KwargsAccessorWithDefault("uncertainty_mode", "random_models")
    credible_interval_level = KwargsAccessorWithDefault("credible_interval_level", 0.9)
    plot_max_likelihood = KwargsAccessorWithDefault("plot_max_likelihood", True)
    set_same_color_per_subplot = KwargsAccessorWithDefault("set_same_color_per_subplot", True)

    xlim_high_multiplier = KwargsAccessorWithDefault("xlim_high_multiplier", 1.05)
    xlim_low_multiplier = KwargsAccessorWithDefault("xlim_low_multiplier", 0.9)
    ylim_high_multiplier = KwargsAccessorWithDefault("ylim_high_multiplier", 1.1)
    ylim_low_multiplier = KwargsAccessorWithDefault("ylim_low_multiplier", 0.5)

    # Upper limit plot options
    upper_limit_marker = KwargsAccessorWithDefault("upper_limit_marker", r"$\downarrow$")
    upper_limit_markersize = KwargsAccessorWithDefault("upper_limit_markersize", 14)
    upper_limit_alpha = KwargsAccessorWithDefault("upper_limit_alpha", 0.7)

    # Grid options
    show_grid = KwargsAccessorWithDefault("show_grid", False)
    grid_alpha = KwargsAccessorWithDefault("grid_alpha", 0.3)
    grid_color = KwargsAccessorWithDefault("grid_color", "gray")
    grid_linestyle = KwargsAccessorWithDefault("grid_linestyle", "--")
    grid_linewidth = KwargsAccessorWithDefault("grid_linewidth", 0.5)

    # Save format and transparency
    save_format = KwargsAccessorWithDefault("save_format", "png")
    transparent = KwargsAccessorWithDefault("transparent", False)

    # Axis scale options (xscale can be customized too)
    xscale = KwargsAccessorWithDefault("xscale", None)

    # Title options
    title = KwargsAccessorWithDefault("title", None)
    title_fontsize = KwargsAccessorWithDefault("title_fontsize", 20)

    # Line style options
    linestyle = KwargsAccessorWithDefault("linestyle", "-")
    max_likelihood_linestyle = KwargsAccessorWithDefault("max_likelihood_linestyle", "-")
    random_sample_linestyle = KwargsAccessorWithDefault("random_sample_linestyle", "-")

    # Marker options
    markerfillstyle = KwargsAccessorWithDefault("markerfillstyle", "full")
    markeredgecolor = KwargsAccessorWithDefault("markeredgecolor", None)
    markeredgewidth = KwargsAccessorWithDefault("markeredgewidth", 1.0)

    # Legend customization
    legend_frameon = KwargsAccessorWithDefault("legend_frameon", True)
    legend_shadow = KwargsAccessorWithDefault("legend_shadow", False)
    legend_fancybox = KwargsAccessorWithDefault("legend_fancybox", True)
    legend_framealpha = KwargsAccessorWithDefault("legend_framealpha", 0.8)

    # Tick customization
    tick_direction = KwargsAccessorWithDefault("tick_direction", "in")
    tick_length = KwargsAccessorWithDefault("tick_length", None)
    tick_width = KwargsAccessorWithDefault("tick_width", None)

    # Spine options
    show_spines = KwargsAccessorWithDefault("show_spines", True)
    spine_linewidth = KwargsAccessorWithDefault("spine_linewidth", None)

    def __init__(self, spectrum: Union[redback.transient.Spectrum, None], **kwargs) -> None:
        """
        :param spectrum: An instance of `redback.transient.Spectrum`. Contains the data to be plotted.
        :param kwargs: Additional kwargs the plotter uses. -------
        :keyword capsize: Same as matplotlib capsize.
        :keyword elinewidth: same as matplotlib elinewidth
        :keyword errorbar_fmt: 'fmt' argument of `ax.errorbar`.
        :keyword ms: Same as matplotlib markersize.
        :keyword legend_location: Same as matplotlib legend location.
        :keyword legend_cols: Same as matplotlib legend columns.
        :keyword color: Color of the data points.
        :keyword dpi: Same as matplotlib dpi.
        :keyword model: str or callable, the model to plot.
        :keyword ms: Same as matplotlib markersize.
        :keyword axis_tick_params_pad: `pad` argument in calls to `ax.tick_params` when setting the axes.
        :keyword max_likelihood_alpha: `alpha` argument, i.e. transparency, when plotting the max likelihood curve.
        :keyword random_sample_alpha: `alpha` argument, i.e. transparency, when plotting random sample curves.
        :keyword uncertainty_band_alpha: `alpha` argument, i.e. transparency, when plotting a credible band.
        :keyword max_likelihood_color: Color of the maximum likelihood curve.
        :keyword random_sample_color: Color of the random sample curves.
        :keyword bbox_inches: Setting for saving plots. Default is 'tight'.
        :keyword linewidth: Same as matplotlib linewidth
        :keyword zorder: Same as matplotlib zorder
        :keyword yscale: Same as matplotlib yscale, default is linear
        :keyword xy: For `ax.annotate' x and y coordinates of the point to annotate.
        :keyword xycoords: The coordinate system `xy` is given in. Default is 'axes fraction'
        :keyword horizontalalignment: Horizontal alignment of the annotation. Default is 'right'
        :keyword annotation_size: `size` argument of of `ax.annotate`.
        :keyword fontsize_axes: Font size of the x and y labels.
        :keyword fontsize_legend: Font size of the legend.
        :keyword fontsize_figure: Font size of the figure. Relevant for multiband plots.
                                  Used on `supxlabel` and `supylabel`.
        :keyword fontsize_ticks: Font size of the axis ticks.
        :keyword hspace: Argument for `subplots_adjust`, sets horizontal spacing between panels.
        :keyword wspace: Argument for `subplots_adjust`, sets horizontal spacing between panels.
        :keyword plot_others: Whether to plot additional bands in the data plot, all in the same colors
        :keyword random_models: Number of random draws to use to calculate credible bands or to plot.
        :keyword uncertainty_mode: 'random_models': Plot random draws from the available parameter sets.
                                   'credible_intervals': Plot a credible interval that is calculated based
                                   on the available parameter sets.
        :keyword credible_interval_level: 0.9: Plot the 90% credible interval.
        :keyword plot_max_likelihood: Plots the draw corresponding to the maximum likelihood. Default is 'True'.
        :keyword set_same_color_per_subplot: Sets the lightcurve to be the same color as the data per subplot. Default is 'True'.
        :keyword xlim_high_multiplier: Adjust the maximum xlim based on available x values.
        :keyword xlim_low_multiplier: Adjust the minimum xlim based on available x values.
        :keyword ylim_high_multiplier: Adjust the maximum ylim based on available x values.
        :keyword ylim_low_multiplier: Adjust the minimum ylim based on available x values.
        :keyword show_grid: Whether to show grid lines. Default is False.
        :keyword grid_alpha: Transparency of grid lines. Default is 0.3.
        :keyword grid_color: Color of grid lines. Default is 'gray'.
        :keyword grid_linestyle: Line style of grid lines. Default is '--'.
        :keyword grid_linewidth: Line width of grid lines. Default is 0.5.
        :keyword save_format: Format for saving plots (e.g., 'png', 'pdf', 'svg', 'eps'). Default is 'png'.
        :keyword transparent: Whether to save plots with transparent background. Default is False.
        :keyword xscale: X-axis scale ('linear', 'log', 'symlog', 'logit'). Default is None (auto-determined).
        :keyword title: Title for the plot. Default is None (no title).
        :keyword title_fontsize: Font size for the title. Default is 20.
        :keyword linestyle: Line style for model curves. Default is '-'.
        :keyword max_likelihood_linestyle: Line style for max likelihood curve. Default is '-'.
        :keyword random_sample_linestyle: Line style for random sample curves. Default is '-'.
        :keyword markerfillstyle: Fill style for markers ('full', 'left', 'right', 'bottom', 'top', 'none'). Default is 'full'.
        :keyword markeredgecolor: Edge color for markers. Default is None (same as face color).
        :keyword markeredgewidth: Edge width for markers. Default is 1.0.
        :keyword legend_frameon: Whether to draw a frame around the legend. Default is True.
        :keyword legend_shadow: Whether to draw a shadow behind the legend. Default is False.
        :keyword legend_fancybox: Whether to use rounded corners for legend frame. Default is True.
        :keyword legend_framealpha: Transparency of legend frame. Default is 0.8.
        :keyword tick_direction: Direction of tick marks ('in', 'out', 'inout'). Default is 'in'.
        :keyword tick_length: Length of tick marks. Default is None (matplotlib default).
        :keyword tick_width: Width of tick marks. Default is None (matplotlib default).
        :keyword show_spines: Whether to show plot spines (borders). Default is True.
        :keyword spine_linewidth: Width of plot spines. Default is None (matplotlib default).
        """
        self.transient = spectrum
        self.kwargs = kwargs or dict()
        self._posterior_sorted = False

    keyword_docstring = __init__.__doc__.split("-------")[1]

    def _get_angstroms(self, axes: matplotlib.axes.Axes) -> np.ndarray:
        """
        :param axes: The axes used in the plotting procedure.
        :type axes: matplotlib.axes.Axes

        :return: Linearly or logarithmically scaled angtrom values depending on the y scale used in the plot.
        :rtype: np.ndarray
        """
        if isinstance(axes, np.ndarray):
            ax = axes[0]
        else:
            ax = axes

        if ax.get_yscale() == 'linear':
            angstroms = np.linspace(self._xlim_low, self._xlim_high, 200)
        else:
            angstroms = np.exp(np.linspace(np.log(self._xlim_low), np.log(self._xlim_high), 200))

        return angstroms

    @property
    def _xlim_low(self) -> float:
        default = self.xlim_low_multiplier * self.transient.angstroms[0]
        if default == 0:
            default += 1e-3
        return self.kwargs.get("xlim_low", default)

    @property
    def _xlim_high(self) -> float:
        default = self.xlim_high_multiplier * self.transient.angstroms[-1]
        return self.kwargs.get("xlim_high", default)

    @property
    def _ylim_low(self) -> float:
        default = self.ylim_low_multiplier * min(self.transient.flux_density)
        return self.kwargs.get("ylim_low", default/1e-17)

    @property
    def _ylim_high(self) -> float:
        default = self.ylim_high_multiplier * np.max(self.transient.flux_density)
        return self.kwargs.get("ylim_high", default/1e-17)

    @property
    def _y_err(self) -> np.ndarray:
        return np.array([np.abs(self.transient.flux_density_err)])

    @property
    def _data_plot_outdir(self) -> str:
        return self._get_outdir(self.transient.directory_structure.directory_path)

    def _get_outdir(self, default: str) -> str:
        return self._get_kwarg_with_default(kwarg="outdir", default=default)

    def get_filename(self, default: str) -> str:
        return self._get_kwarg_with_default(kwarg="filename", default=default)

    def _get_kwarg_with_default(self, kwarg: str, default: Any) -> Any:
        return self.kwargs.get(kwarg, default) or default

    @property
    def _model_kwargs(self) -> dict:
        return self._get_kwarg_with_default("model_kwargs", dict())

    @property
    def _posterior(self) -> pd.DataFrame:
        posterior = self.kwargs.get("posterior", pd.DataFrame())
        if not self._posterior_sorted and posterior is not None:
            posterior.sort_values(by='log_likelihood', inplace=True)
            self._posterior_sorted = True
        return posterior

    @property
    def _max_like_params(self) -> pd.core.series.Series:
        return self._posterior.iloc[-1]

    def _get_random_parameters(self) -> list[pd.core.series.Series]:
        integers = np.arange(len(self._posterior))
        indices = np.random.choice(integers, size=self.random_models)
        return [self._posterior.iloc[idx] for idx in indices]

    _data_plot_filename = _FilenameGetter(suffix="data")
    _spectrum_ppd_plot_filename = _FilenameGetter(suffix="spectrum_ppd")
    _residual_plot_filename = _FilenameGetter(suffix="residual")

    _data_plot_filepath = _FilePathGetter(
        directory_property="_data_plot_outdir", filename_property="_data_plot_filename")
    _spectrum_ppd_plot_filepath = _FilePathGetter(
        directory_property="_data_plot_outdir", filename_property="_spectrum_ppd_plot_filename")
    _residual_plot_filepath = _FilePathGetter(
        directory_property="_data_plot_outdir", filename_property="_residual_plot_filename")

    def _save_and_show(self, filepath: str, save: bool, show: bool) -> None:
        plt.tight_layout()
        if save:
            # Update filepath extension if save_format is specified
            if '.' in filepath:
                filepath = filepath.rsplit('.', 1)[0] + f'.{self.save_format}'
            else:
                filepath = f'{filepath}.{self.save_format}'

            facecolor = 'none' if self.transparent else 'white'
            plt.savefig(filepath, dpi=self.dpi, bbox_inches=self.bbox_inches,
                       transparent=self.transparent, facecolor=facecolor)
        if show:
            plt.show()

    def _apply_axis_customizations(self, ax: matplotlib.axes.Axes) -> None:
        """Apply common axis customizations like grid, title, ticks, and spines."""
        # Grid
        if self.show_grid:
            ax.grid(True, alpha=self.grid_alpha, color=self.grid_color,
                   linestyle=self.grid_linestyle, linewidth=self.grid_linewidth)

        # Title
        if self.title is not None:
            ax.set_title(self.title, fontsize=self.title_fontsize)

        # Tick customization
        tick_params = {'axis': 'both', 'which': 'both',
                      'pad': self.axis_tick_params_pad,
                      'labelsize': self.fontsize_ticks,
                      'direction': self.tick_direction}
        if self.tick_length is not None:
            tick_params['length'] = self.tick_length
        if self.tick_width is not None:
            tick_params['width'] = self.tick_width
        ax.tick_params(**tick_params)

        # Spine customization
        if not self.show_spines:
            for spine in ax.spines.values():
                spine.set_visible(False)
        elif self.spine_linewidth is not None:
            for spine in ax.spines.values():
                spine.set_linewidth(self.spine_linewidth)


class IntegratedFluxPlotter(Plotter):

    @property
    def _xlabel(self) -> str:
        return r"Time since burst [s]"

    @property
    def _ylabel(self) -> str:
        return self.transient.ylabel

    def plot_data(
            self, axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
        """Plots the Integrated flux data and returns Axes.

        :param axes: Matplotlib axes to plot the data into. Useful for user specific modifications to the plot.
        :type axes: Union[matplotlib.axes.Axes, None], optional
        :param save: Whether to save the plot. (Default value = True)
        :type save: bool
        :param show: Whether to show the plot. (Default value = True)
        :type show: bool

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        ax = axes or plt.gca()

        ax.errorbar(self.transient.x, self.transient.y, xerr=self._x_err, yerr=self._y_err,
                    fmt=self.errorbar_fmt, c=self.color, ms=self.ms, elinewidth=self.elinewidth, capsize=self.capsize,
                    fillstyle=self.markerfillstyle, markeredgecolor=self.markeredgecolor,
                    markeredgewidth=self.markeredgewidth)

        # Apply custom scales if specified, otherwise use defaults
        ax.set_xscale(self.xscale if self.xscale is not None else 'log')
        ax.set_yscale(self.yscale if self.yscale is not None else 'log')

        ax.set_xlim(self._xlim_low, self._xlim_high)
        ax.set_ylim(self._ylim_low, self._ylim_high)
        ax.set_xlabel(self._xlabel, fontsize=self.fontsize_axes)
        ax.set_ylabel(self._ylabel, fontsize=self.fontsize_axes)

        ax.annotate(
            self.transient.name, xy=self.xy, xycoords=self.xycoords,
            horizontalalignment=self.horizontalalignment, size=self.annotation_size)

        # Apply new customizations
        self._apply_axis_customizations(ax)

        self._save_and_show(filepath=self._data_plot_filepath, save=save, show=show)
        return ax

    def plot_lightcurve(
            self, axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
        """Plots the Integrated flux data and the lightcurve and returns Axes.

        :param axes: Matplotlib axes to plot the lightcurve into. Useful for user specific modifications to the plot.
        :type axes: Union[matplotlib.axes.Axes, None], optional
        :param save: Whether to save the plot. (Default value = True)
        :type save: bool
        :param show: Whether to show the plot. (Default value = True)
        :type show: bool

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        
        axes = axes or plt.gca()

        axes = self.plot_data(axes=axes, save=False, show=False)
        times = self._get_times(axes)

        self._plot_lightcurves(axes, times)

        self._save_and_show(filepath=self._lightcurve_plot_filepath, save=save, show=show)
        return axes

    def _plot_lightcurves(self, axes: matplotlib.axes.Axes, times: np.ndarray) -> None:
        if self.plot_max_likelihood:
            ys = self.model(times, **self._max_like_params, **self._model_kwargs)
            axes.plot(times, ys, color=self.max_likelihood_color, alpha=self.max_likelihood_alpha,
                     lw=self.linewidth, linestyle=self.max_likelihood_linestyle)

        random_ys_list = [self.model(times, **random_params, **self._model_kwargs)
                          for random_params in self._get_random_parameters()]
        if self.uncertainty_mode == "random_models":
            for ys in random_ys_list:
                axes.plot(times, ys, color=self.random_sample_color, alpha=self.random_sample_alpha,
                         lw=self.linewidth, linestyle=self.random_sample_linestyle, zorder=self.zorder)
        elif self.uncertainty_mode == "credible_intervals":
            lower_bound, upper_bound, _ = redback.utils.calc_credible_intervals(samples=random_ys_list, interval=self.credible_interval_level)
            axes.fill_between(
                times, lower_bound, upper_bound, alpha=self.uncertainty_band_alpha, color=self.max_likelihood_color)

    def _plot_single_lightcurve(self, axes: matplotlib.axes.Axes, times: np.ndarray, params: dict) -> None:
        ys = self.model(times, **params, **self._model_kwargs)
        axes.plot(times, ys, color=self.random_sample_color, alpha=self.random_sample_alpha,
                 lw=self.linewidth, linestyle=self.random_sample_linestyle, zorder=self.zorder)

    def plot_residuals(
            self, axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
        """Plots the residual of the Integrated flux data returns Axes.

        :param axes: Matplotlib axes to plot the lightcurve into. Useful for user specific modifications to the plot.
        :param save: Whether to save the plot. (Default value = True)
        :param show: Whether to show the plot. (Default value = True)

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        if axes is None:
            fig, axes = plt.subplots(
                nrows=2, ncols=1, sharex=True, sharey=False, figsize=(10, 8), gridspec_kw=dict(height_ratios=[2, 1]))

        axes[0] = self.plot_lightcurve(axes=axes[0], save=False, show=False)
        axes[1].set_xlabel(axes[0].get_xlabel(), fontsize=self.fontsize_axes)
        axes[0].set_xlabel("")
        ys = self.model(self.transient.x, **self._max_like_params, **self._model_kwargs)
        axes[1].errorbar(
            self.transient.x, self.transient.y - ys, xerr=self._x_err, yerr=self._y_err,
            fmt=self.errorbar_fmt, c=self.color, ms=self.ms, elinewidth=self.elinewidth, capsize=self.capsize,
            fillstyle=self.markerfillstyle, markeredgecolor=self.markeredgecolor,
            markeredgewidth=self.markeredgewidth)
        axes[1].set_yscale("log")
        axes[1].set_ylabel("Residual", fontsize=self.fontsize_axes)

        # Apply new customizations
        self._apply_axis_customizations(axes[1])

        self._save_and_show(filepath=self._residual_plot_filepath, save=save, show=show)
        return axes


class LuminosityOpticalPlotter(IntegratedFluxPlotter):

    @property
    def _xlabel(self) -> str:
        return r"Time since explosion [days]"

    @property
    def _ylabel(self) -> str:
        return r"L$_{\rm bol}$ [$10^{50}$ erg s$^{-1}$]"

class LuminosityPlotter(IntegratedFluxPlotter):
    pass


class MagnitudePlotter(Plotter):

    xlim_low_phase_model_multiplier = KwargsAccessorWithDefault("xlim_low_multiplier", 0.9)
    xlim_high_phase_model_multiplier = KwargsAccessorWithDefault("xlim_high_multiplier", 1.1)
    xlim_high_multiplier = KwargsAccessorWithDefault("xlim_high_multiplier", 1.2)
    ylim_low_magnitude_multiplier = KwargsAccessorWithDefault("ylim_low_multiplier", 0.95)
    ylim_high_magnitude_multiplier = KwargsAccessorWithDefault("ylim_high_multiplier", 1.05)
    ncols = KwargsAccessorWithDefault("ncols", 2)

    @property
    def _colors(self) -> str:
        return self.kwargs.get("colors", self.transient.get_colors(self._filters))

    @property
    def _xlabel(self) -> str:
        if self.transient.use_phase_model:
            default = f"Time since {self._reference_mjd_date} MJD [days]"
        else:
            default = self.transient.xlabel
        return self.kwargs.get("xlabel", default)

    @property
    def _ylabel(self) -> str:
        return self.kwargs.get("ylabel", self.transient.ylabel)

    @property
    def _get_bands_to_plot(self) -> list[str]:
        return self.kwargs.get("bands_to_plot", self.transient.active_bands)

    @property
    def _xlim_low(self) -> float:
        if self.transient.use_phase_model:
            default = (self.transient.x[0] - self._reference_mjd_date) * self.xlim_low_phase_model_multiplier
        else:
            default = self.xlim_low_multiplier * self.transient.x[0]
        if default == 0:
            default += 1e-3
        return self.kwargs.get("xlim_low", default)

    @property
    def _xlim_high(self) -> float:
        if self.transient.use_phase_model:
            default = (self.transient.x[-1] - self._reference_mjd_date) * self.xlim_high_phase_model_multiplier
        else:
            default = self.xlim_high_multiplier * self.transient.x[-1]
        return self.kwargs.get("xlim_high", default)

    @property
    def _ylim_low_magnitude(self) -> float:
        y_valid = self.transient.y[np.isfinite(self.transient.y)]
        if len(y_valid) == 0:
            return 0
        default = self.ylim_low_magnitude_multiplier * min(y_valid)
        return self.kwargs.get("ylim_low", default)

    @property
    def _ylim_high_magnitude(self) -> float:
        y_valid = self.transient.y[np.isfinite(self.transient.y)]
        if len(y_valid) == 0:
            return 1
        default = self.ylim_high_magnitude_multiplier * np.max(y_valid)
        return self.kwargs.get("ylim_high", default)

    def _get_ylim_low_with_indices(self, indices: list) -> float:
        y_valid = self.transient.y[indices][np.isfinite(self.transient.y[indices])]
        if len(y_valid) == 0:
            return 0
        return self.ylim_low_multiplier * min(y_valid)

    def _get_ylim_high_with_indices(self, indices: list) -> float:
        y_valid = self.transient.y[indices][np.isfinite(self.transient.y[indices])]
        if len(y_valid) == 0:
            return 1
        return self.ylim_high_multiplier * np.max(y_valid)

    def _get_x_err(self, indices: list) -> np.ndarray:
        return self.transient.x_err[indices] if self.transient.x_err is not None else self.transient.x_err

    def _set_y_axis_data(self, ax: matplotlib.axes.Axes) -> None:
        if self.transient.magnitude_data:
            ax.set_ylim(self._ylim_low_magnitude, self._ylim_high_magnitude)
            ax.invert_yaxis()
            # Apply custom yscale if specified, otherwise use default
            ax.set_yscale(self.yscale if self.yscale is not None else 'linear')
        else:
            ax.set_ylim(self._ylim_low, self._ylim_high)
            # Apply custom yscale if specified, otherwise use default
            ax.set_yscale(self.yscale if self.yscale is not None else "log")

    def _set_y_axis_multiband_data(self, ax: matplotlib.axes.Axes, indices: list) -> None:
        if self.transient.magnitude_data:
            ax.set_ylim(self._ylim_low_magnitude, self._ylim_high_magnitude)
            ax.invert_yaxis()
            # Apply custom yscale if specified, otherwise use default
            ax.set_yscale(self.yscale if self.yscale is not None else 'linear')
        else:
            ax.set_ylim(self._get_ylim_low_with_indices(indices=indices),
                        self._get_ylim_high_with_indices(indices=indices))
            # Apply custom yscale if specified, otherwise use default
            ax.set_yscale(self.yscale if self.yscale is not None else "log")

    def _set_x_axis(self, axes: matplotlib.axes.Axes) -> None:
        # Apply custom xscale if specified, otherwise use default behavior
        if self.xscale is not None:
            axes.set_xscale(self.xscale)
        elif self.transient.use_phase_model:
            axes.set_xscale("linear")  # Keep master's default for phase model
        axes.set_xlim(self._xlim_low, self._xlim_high)

    @property
    def _nrows(self) -> int:
        default = int(np.ceil(len(self._filters) / 2))
        return self._get_kwarg_with_default("nrows", default=default)

    @property
    def _npanels(self) -> int:
        npanels = self._nrows * self.ncols
        if npanels < len(self._filters):
            raise ValueError(f"Insufficient number of panels. {npanels} panels were given "
                             f"but {len(self._filters)} panels are needed.")
        return npanels

    @property
    def _figsize(self) -> tuple:
        default = (4 + 4 * self.ncols, 2 + 2 * self._nrows)
        return self._get_kwarg_with_default("figsize", default=default)

    @property
    def _reference_mjd_date(self) -> int:
        if self.transient.use_phase_model:
            return self.kwargs.get("reference_mjd_date", int(self.transient.x[0]))
        return 0

    @property
    def band_label_generator(self):
        if self.band_labels is not None:
            return (bl for bl in self.band_labels)

    def _get_data_plot_label(self, band):
        if band in self.band_scaling:
            label = band + ' ' + self.band_scaling.get("type") + ' ' + str(self.band_scaling.get(band))
            if self.band_scaling.get("type") == 'x':
                if self.band_scaling.get(band) == 1:
                    label = band
            elif self.band_scaling.get("type") == '+':
                if self.band_scaling.get(band) == 0:
                    label = band
        else:
            label = band
        if isinstance(label, float):
            label = f"{label:.2e}"
        return label

    def _get_data_plot_labels(self) -> dict:
        band_label_generator = self.band_label_generator
        band_labels = dict()
        for band in self.transient.unique_bands:
            if band in self._filters:
                if band_label_generator is None:
                    band_labels[band] = self._get_data_plot_label(band)
                else:
                    band_labels[band] = next(band_label_generator)
            elif self.plot_others:
                band_labels[band] = None
        return band_labels

    def plot_data(
            self, axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
        """Plots the Magnitude data and returns Axes.

        :param axes: Matplotlib axes to plot the data into. Useful for user specific modifications to the plot.
        :type axes: Union[matplotlib.axes.Axes, None], optional
        :param save: Whether to save the plot. (Default value = True)
        :type save: bool
        :param show: Whether to show the plot. (Default value = True)
        :type show: bool

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        ax = axes or plt.gca()

        band_labels = self._get_data_plot_labels()
        labeled_bands = set()

        for indices, band in zip(self.transient.list_of_band_indices, self.transient.unique_bands):
            if band not in band_labels:
                continue
            # Filter out upper limit indices from detection data
            if self.transient.has_upper_limits is True:
                detection_mask = ~self.transient.upper_limits
                indices = np.asarray(indices)
                indices = indices[detection_mask[indices]]
                if len(indices) == 0:
                    continue
            label = band_labels[band]
            if band in self._filters:
                color = self._colors[list(self._filters).index(band)]
            elif self.plot_others:
                color = "black"
            else:
                continue
            if self.band_colors is not None:
                color = self.band_colors[band]
            if band in self.band_scaling:
                if self.band_scaling.get("type") == 'x':
                    ax.errorbar(
                        self.transient.x[indices] - self._reference_mjd_date, self.transient.y[indices] * self.band_scaling.get(band),
                        xerr=self._get_x_err(indices), yerr=self.transient.y_err[indices] * self.band_scaling.get(band),
                        fmt=self.errorbar_fmt, ms=self.ms, color=color,
                        elinewidth=self.elinewidth, capsize=self.capsize, label=label,
                        fillstyle=self.markerfillstyle, markeredgecolor=self.markeredgecolor,
                        markeredgewidth=self.markeredgewidth)
                elif self.band_scaling.get("type") == '+':
                    ax.errorbar(
                        self.transient.x[indices] - self._reference_mjd_date, self.transient.y[indices] + self.band_scaling.get(band),
                        xerr=self._get_x_err(indices), yerr=self.transient.y_err[indices],
                        fmt=self.errorbar_fmt, ms=self.ms, color=color,
                        elinewidth=self.elinewidth, capsize=self.capsize, label=label,
                        fillstyle=self.markerfillstyle, markeredgecolor=self.markeredgecolor,
                        markeredgewidth=self.markeredgewidth)
            else:
                ax.errorbar(
                    self.transient.x[indices] - self._reference_mjd_date, self.transient.y[indices],
                    xerr=self._get_x_err(indices), yerr=self.transient.y_err[indices],
                    fmt=self.errorbar_fmt, ms=self.ms, color=color,
                    elinewidth=self.elinewidth, capsize=self.capsize, label=label,
                    fillstyle=self.markerfillstyle, markeredgecolor=self.markeredgecolor,
                    markeredgewidth=self.markeredgewidth)
            if label is not None:
                labeled_bands.add(band)

        # Plot upper limits if present
        if self.transient.has_upper_limits is True:
            ul_boolean = self.transient.upper_limits
            ul_marker = self.upper_limit_marker
            for indices, band in zip(self.transient.list_of_band_indices, self.transient.unique_bands):
                if band not in band_labels:
                    continue
                ul_band_indices = np.array([i for i in indices if ul_boolean[i]])
                if len(ul_band_indices) == 0:
                    continue
                # Upper limits must have finite y-values to be plotted at a position
                finite_mask = np.isfinite(self.transient.y[ul_band_indices])
                if not np.all(finite_mask):
                    n_nan = int(np.sum(~finite_mask))
                    logger.warning(
                        f"{n_nan} upper limit(s) in band '{band}' have NaN y-values and "
                        f"will not be plotted. Provide finite upper limit values (e.g. the "
                        f"limiting magnitude or flux) to plot them."
                    )
                    ul_band_indices = ul_band_indices[finite_mask]
                if len(ul_band_indices) == 0:
                    continue
                if self.band_colors is not None and band in self.band_colors:
                    color = self.band_colors[band]
                elif band in self._filters:
                    color = self._colors[list(self._filters).index(band)]
                elif self.plot_others:
                    color = "black"
                else:
                    continue
                ul_y = self.transient.y[ul_band_indices]
                if band in self.band_scaling:
                    if self.band_scaling.get("type") == 'x':
                        ul_y = ul_y * self.band_scaling.get(band)
                    elif self.band_scaling.get("type") == '+':
                        ul_y = ul_y + self.band_scaling.get(band)
                label = band_labels[band] if band not in labeled_bands else None
                ax.plot(self.transient.x[ul_band_indices] - self._reference_mjd_date,
                        ul_y, marker=ul_marker, ms=self.upper_limit_markersize,
                        color=color, linestyle='none', alpha=self.upper_limit_alpha,
                        label=label, zorder=3)

        self._set_x_axis(axes=ax)
        self._set_y_axis_data(ax)

        ax.set_xlabel(self._xlabel, fontsize=self.fontsize_axes)
        ax.set_ylabel(self._ylabel, fontsize=self.fontsize_axes)

        # Apply new customizations
        self._apply_axis_customizations(ax)

        # Legend with new customization options
        ax.legend(ncol=self.legend_cols, loc=self.legend_location, fontsize=self.fontsize_legend,
                 frameon=self.legend_frameon, shadow=self.legend_shadow,
                 fancybox=self.legend_fancybox, framealpha=self.legend_framealpha)

        self._save_and_show(filepath=self._data_plot_filepath, save=save, show=show)
        return ax

    def plot_lightcurve(
            self, axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True)\
            -> matplotlib.axes.Axes:
        """Plots the Magnitude data and returns Axes.

        :param axes: Matplotlib axes to plot the lightcurve into. Useful for user specific modifications to the plot.
        :type axes: Union[matplotlib.axes.Axes, None], optional
        :param save: Whether to save the plot. (Default value = True)
        :type save: bool
        :param show: Whether to show the plot. (Default value = True)
        :type show: bool

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        axes = axes or plt.gca()

        axes = self.plot_data(axes=axes, save=False, show=False)

        times = self._get_times(axes)
        bands_to_plot = self._get_bands_to_plot

        color_max = self.max_likelihood_color
        color_sample = self.random_sample_color
        for band, color in zip(bands_to_plot, self.transient.get_colors(bands_to_plot)):
            if self.set_same_color_per_subplot is True:
                if self.band_colors is not None:
                    color = self.band_colors[band]
                color_max = color
                color_sample = color
            sn_cosmo_band = redback.utils.sncosmo_bandname_from_band([band])
            self._model_kwargs["bands"] = [sn_cosmo_band[0] for _ in range(len(times))]
            if isinstance(band, str):
                frequency = redback.utils.bands_to_frequency([band])
            else:
                frequency = band
            self._model_kwargs['frequency'] = np.ones(len(times)) * frequency
            if self.plot_max_likelihood:
                ys = self.model(times, **self._max_like_params, **self._model_kwargs)
                if band in self.band_scaling:
                    if self.band_scaling.get("type") == 'x':
                        axes.plot(times - self._reference_mjd_date, ys * self.band_scaling.get(band), color=color_max,
                                 alpha=self.max_likelihood_alpha, lw=self.linewidth, linestyle=self.max_likelihood_linestyle)
                    elif self.band_scaling.get("type") == '+':
                        axes.plot(times - self._reference_mjd_date, ys + self.band_scaling.get(band), color=color_max,
                                 alpha=self.max_likelihood_alpha, lw=self.linewidth, linestyle=self.max_likelihood_linestyle)
                else:
                    axes.plot(times - self._reference_mjd_date, ys, color=color_max,
                             alpha=self.max_likelihood_alpha, lw=self.linewidth, linestyle=self.max_likelihood_linestyle)

            random_ys_list = [self.model(times, **random_params, **self._model_kwargs)
                              for random_params in self._get_random_parameters()]
            if self.uncertainty_mode == "random_models":
                for ys in random_ys_list:
                    if band in self.band_scaling:
                        if self.band_scaling.get("type") == 'x':
                            axes.plot(times - self._reference_mjd_date, ys * self.band_scaling.get(band), color=color_sample,
                                     alpha=self.random_sample_alpha, lw=self.linewidth, linestyle=self.random_sample_linestyle, zorder=-1)
                        elif self.band_scaling.get("type") == '+':
                            axes.plot(times - self._reference_mjd_date, ys + self.band_scaling.get(band), color=color_sample,
                                     alpha=self.random_sample_alpha, lw=self.linewidth, linestyle=self.random_sample_linestyle, zorder=-1)
                    else:
                        axes.plot(times - self._reference_mjd_date, ys, color=color_sample,
                                 alpha=self.random_sample_alpha, lw=self.linewidth, linestyle=self.random_sample_linestyle, zorder=-1)
            elif self.uncertainty_mode == "credible_intervals":
                if band in self.band_scaling:
                    if self.band_scaling.get("type") == 'x':
                        lower_bound, upper_bound, _ = redback.utils.calc_credible_intervals(samples=np.array(random_ys_list) * self.band_scaling.get(band), interval=self.credible_interval_level)
                    elif self.band_scaling.get("type") == '+':
                        lower_bound, upper_bound, _ = redback.utils.calc_credible_intervals(samples=np.array(random_ys_list) + self.band_scaling.get(band), interval=self.credible_interval_level)
                else:
                    lower_bound, upper_bound, _ = redback.utils.calc_credible_intervals(samples=np.array(random_ys_list), interval=self.credible_interval_level)
                axes.fill_between(
                    times - self._reference_mjd_date, lower_bound, upper_bound,
                    alpha=self.uncertainty_band_alpha, color=color_sample)

        self._save_and_show(filepath=self._lightcurve_plot_filepath, save=save, show=show)
        return axes

    def _check_valid_multiband_data_mode(self) -> bool:
        if self.transient.luminosity_data:
            redback.utils.logger.warning(
                f"Plotting multiband lightcurve/data not possible for {self.transient.data_mode}. Returning.")
            return False
        return True

    def plot_multiband(
            self, figure: matplotlib.figure.Figure = None, axes: matplotlib.axes.Axes = None, save: bool = True,
            show: bool = True) -> matplotlib.axes.Axes:
        """Plots the Magnitude multiband data and returns Axes.

        :param figure: Matplotlib figure to plot the data into.
        :type figure: matplotlib.figure.Figure
        :param axes: Matplotlib axes to plot the data into. Useful for user specific modifications to the plot.
        :type axes: Union[matplotlib.axes.Axes, None], optional
        :param save: Whether to save the plot. (Default value = True)
        :type save: bool
        :param show: Whether to show the plot. (Default value = True)
        :type show: bool

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        if not self._check_valid_multiband_data_mode():
            return

        if figure is None or axes is None:
            figure, axes = plt.subplots(ncols=self.ncols, nrows=self._nrows, sharex='all', figsize=self._figsize)
        axes = axes.ravel()

        band_label_generator = self.band_label_generator

        ii = 0
        for indices, band, freq in zip(
                self.transient.list_of_band_indices, self.transient.unique_bands, self.transient.unique_frequencies):
            if band not in self._filters:
                continue

            x_err = self._get_x_err(indices)
            color = self._colors[list(self._filters).index(band)]
            if self.band_colors is not None:
                color = self.band_colors[band]
            if band_label_generator is None:
                label = self._get_multiband_plot_label(band, freq)
            else:
                label = next(band_label_generator)

            # Separate detections and upper limits for this band
            if self.transient.has_upper_limits is True:
                det_mask = ~self.transient.upper_limits[indices]
                det_indices = indices[det_mask]
                ul_indices_band = indices[~det_mask]
            else:
                det_indices = indices
                ul_indices_band = np.array([], dtype=int)

            # Plot detections with error bars
            if len(det_indices) > 0:
                axes[ii].errorbar(
                    self.transient.x[det_indices] - self._reference_mjd_date,
                    self.transient.y[det_indices], xerr=self._get_x_err(det_indices),
                    yerr=self.transient.y_err[det_indices], fmt=self.errorbar_fmt, ms=self.ms, color=color,
                    elinewidth=self.elinewidth, capsize=self.capsize, label=label,
                    fillstyle=self.markerfillstyle, markeredgecolor=self.markeredgecolor,
                    markeredgewidth=self.markeredgewidth)

            # Plot upper limits with limit markers
            if len(ul_indices_band) > 0:
                finite_mask = np.isfinite(self.transient.y[ul_indices_band])
                if not np.all(finite_mask):
                    n_nan = int(np.sum(~finite_mask))
                    logger.warning(
                        f"{n_nan} upper limit(s) in band '{band}' have NaN y-values and "
                        f"will not be plotted."
                    )
                    ul_indices_band = ul_indices_band[finite_mask]
                if len(ul_indices_band) > 0:
                    ul_y = self.transient.y[ul_indices_band]
                    if band in self.band_scaling:
                        if self.band_scaling.get("type") == 'x':
                            ul_y = ul_y * self.band_scaling.get(band)
                        elif self.band_scaling.get("type") == '+':
                            ul_y = ul_y + self.band_scaling.get(band)
                    axes[ii].plot(
                        self.transient.x[ul_indices_band] - self._reference_mjd_date,
                        ul_y, marker=self.upper_limit_marker, ms=self.upper_limit_markersize,
                        color=color, linestyle='none', alpha=self.upper_limit_alpha,
                        label=label if len(det_indices) == 0 else None, zorder=3)

            self._set_x_axis(axes[ii])
            self._set_y_axis_multiband_data(axes[ii], indices)

            # Apply new customizations
            self._apply_axis_customizations(axes[ii])

            # Legend with new customization options
            axes[ii].legend(ncol=self.legend_cols, loc=self.legend_location, fontsize=self.fontsize_legend,
                           frameon=self.legend_frameon, shadow=self.legend_shadow,
                           fancybox=self.legend_fancybox, framealpha=self.legend_framealpha)
            ii += 1

        figure.supxlabel(self._xlabel, fontsize=self.fontsize_figure)
        figure.supylabel(self._ylabel, fontsize=self.fontsize_figure)
        plt.subplots_adjust(wspace=self.wspace, hspace=self.hspace)

        self._save_and_show(filepath=self._multiband_data_plot_filepath, save=save, show=show)
        return axes

    @staticmethod
    def _get_multiband_plot_label(band: str, freq: float) -> str:
        if isinstance(band, str):
            if 1e10 < float(freq) < 1e16:
                label = band
            else:
                label = f"{freq:.2e}"
        else:
            label = f"{band:.2e}"
        return label

    @property
    def _filters(self) -> list[str]:
        filters = self.kwargs.get("filters", self.transient.active_bands)
        if 'bands_to_plot' in self.kwargs:
            filters = self.kwargs['bands_to_plot']
        if filters is None:
            return self.transient.active_bands
        elif str(filters) == 'default':
            return self.transient.default_filters
        return filters

    def plot_multiband_lightcurve(
        self, figure: matplotlib.figure.Figure = None, axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
        """Plots the Magnitude multiband lightcurve and returns Axes.

        :param figure: Matplotlib figure to plot the data into.
        :param axes: Matplotlib axes to plot the data into. Useful for user specific modifications to the plot.
        :type axes: Union[matplotlib.axes.Axes, None], optional
        :param save: Whether to save the plot. (Default value = True)
        :type save: bool
        :param show: Whether to show the plot. (Default value = True)
        :type show: bool

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        if not self._check_valid_multiband_data_mode():
            return

        if figure is None or axes is None:
            figure, axes = plt.subplots(ncols=self.ncols, nrows=self._nrows, sharex='all', figsize=self._figsize)

        axes = self.plot_multiband(figure=figure, axes=axes, save=False, show=False)
        times = self._get_times(axes)

        ii = 0
        color_max = self.max_likelihood_color
        color_sample = self.random_sample_color
        for band, freq in zip(self.transient.unique_bands, self.transient.unique_frequencies):
            if band not in self._filters:
                continue
            new_model_kwargs = self._model_kwargs.copy()
            new_model_kwargs['frequency'] = freq
            new_model_kwargs['bands'] = redback.utils.sncosmo_bandname_from_band([band])
            new_model_kwargs['bands'] = [new_model_kwargs['bands'][0] for _ in range(len(times))]
            
            if self.set_same_color_per_subplot is True:
                color = self._colors[list(self._filters).index(band)]
                if self.band_colors is not None:
                    color = self.band_colors[band]
                color_max = color
                color_sample = color

            if self.plot_max_likelihood:
                ys = self.model(times, **self._max_like_params, **new_model_kwargs)
                axes[ii].plot(
                    times - self._reference_mjd_date, ys, color=color_max,
                    alpha=self.max_likelihood_alpha, lw=self.linewidth, linestyle=self.max_likelihood_linestyle)
            random_ys_list = [self.model(times, **random_params, **new_model_kwargs)
                              for random_params in self._get_random_parameters()]
            if self.uncertainty_mode == "random_models":
                for random_ys in random_ys_list:
                    axes[ii].plot(times - self._reference_mjd_date, random_ys, color=color_sample,
                                  alpha=self.random_sample_alpha, lw=self.linewidth,
                                  linestyle=self.random_sample_linestyle, zorder=self.zorder)
            elif self.uncertainty_mode == "credible_intervals":
                lower_bound, upper_bound, _ = redback.utils.calc_credible_intervals(samples=random_ys_list, interval=self.credible_interval_level)
                axes[ii].fill_between(
                    times - self._reference_mjd_date, lower_bound, upper_bound,
                    alpha=self.uncertainty_band_alpha, color=color_sample)
            ii += 1

        self._save_and_show(filepath=self._multiband_lightcurve_plot_filepath, save=save, show=show)
        return axes


class FluxDensityPlotter(MagnitudePlotter):
    pass

class IntegratedFluxOpticalPlotter(MagnitudePlotter):
    pass

class SpectrumPlotter(SpecPlotter):
    @property
    def _xlabel(self) -> str:
        return self.transient.xlabel

    @property
    def _ylabel(self) -> str:
        return self.transient.ylabel

    def plot_data(
            self, plot_format: str = 'standard',
            axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
        """Plots the spectrum data and returns Axes.

        :param plot_format: The format to plot the data in. Options are 'standard' and 'errorbar'. (Default value = 'standard')
        :type plot_format: str
        :param axes: Matplotlib axes to plot the data into. Useful for user specific modifications to the plot.
        :type axes: Union[matplotlib.axes.Axes, None], optional
        :param save: Whether to save the plot. (Default value = True)
        :type save: bool
        :param show: Whether to show the plot. (Default value = True)
        :type show: bool

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        ax = axes or plt.gca()

        if self.transient.plot_with_time_label:
            label = self.transient.time
        else:
            label = self.transient.name
        # Apply custom scales if specified, otherwise use defaults
        ax.set_xscale(self.xscale if self.xscale is not None else 'linear')
        if plot_format == 'standard':
            ax.plot(
                self.transient.angstroms,
                self.transient.flux_density / 1e-17,
                color=self.color,
                lw=self.linewidth,
                linestyle=self.linestyle,
            )
        else:
            ax.errorbar(
                self.transient.angstroms,
                self.transient.flux_density / 1e-17,
                yerr=self.transient.flux_density_err / 1e-17,
                color=self.color,
                fmt=self.errorbar_fmt,
                ms=self.ms,
                elinewidth=self.elinewidth,
                capsize=self.capsize,
            )
        ax.set_yscale(self.yscale)

        ax.set_xlim(self._xlim_low, self._xlim_high)
        ax.set_ylim(self._ylim_low, self._ylim_high)
        ax.set_xlabel(self._xlabel, fontsize=self.fontsize_axes)
        ax.set_ylabel(self._ylabel, fontsize=self.fontsize_axes)

        ax.annotate(
            label, xy=self.xy, xycoords=self.xycoords,
            horizontalalignment=self.horizontalalignment, size=self.annotation_size)

        # Apply new customizations
        self._apply_axis_customizations(ax)

        self._save_and_show(filepath=self._data_plot_filepath, save=save, show=show)
        return ax

    def plot_spectrum(
            self, plot_format: str = 'standard',
            axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
        """Plots the spectrum data and the fit and returns Axes.

        :param plot_format: The format to plot the data in. Options are 'standard' and 'errorbar'. (Default value = 'standard')
        :type plot_format: str
        :param axes: Matplotlib axes to plot the lightcurve into. Useful for user specific modifications to the plot.
        :type axes: Union[matplotlib.axes.Axes, None], optional
        :param save: Whether to save the plot. (Default value = True)
        :type save: bool
        :param show: Whether to show the plot. (Default value = True)
        :type show: bool

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """

        axes = axes or plt.gca()

        axes = self.plot_data(axes=axes, save=False, show=False, plot_format=plot_format)
        angstroms = self._get_angstroms(axes)

        self._plot_spectrums(axes, angstroms)

        self._save_and_show(filepath=self._spectrum_ppd_plot_filepath, save=save, show=show)
        return axes

    def _plot_spectrums(self, axes: matplotlib.axes.Axes, angstroms: np.ndarray) -> None:
        if self.plot_max_likelihood:
            ys = self.model(angstroms, **self._max_like_params, **self._model_kwargs)
            axes.plot(angstroms, ys/1e-17, color=self.max_likelihood_color, alpha=self.max_likelihood_alpha,
                      lw=self.linewidth, linestyle=self.max_likelihood_linestyle)

        random_ys_list = [self.model(angstroms, **random_params, **self._model_kwargs)
                          for random_params in self._get_random_parameters()]
        if self.uncertainty_mode == "random_models":
            for ys in random_ys_list:
                axes.plot(angstroms, ys/1e-17, color=self.random_sample_color, alpha=self.random_sample_alpha,
                          lw=self.linewidth, linestyle=self.random_sample_linestyle, zorder=self.zorder)
        elif self.uncertainty_mode == "credible_intervals":
            lower_bound, upper_bound, _ = redback.utils.calc_credible_intervals(samples=random_ys_list,
                                                                                interval=self.credible_interval_level)
            axes.fill_between(
                angstroms, lower_bound/1e-17, upper_bound/1e-17, alpha=self.uncertainty_band_alpha, color=self.max_likelihood_color)

    def plot_residuals(
            self, axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
        """Plots the residual of the Integrated flux data returns Axes.

        :param axes: Matplotlib axes to plot the lightcurve into. Useful for user specific modifications to the plot.
        :param save: Whether to save the plot. (Default value = True)
        :param show: Whether to show the plot. (Default value = True)

        :return: The axes with the plot.
        :rtype: matplotlib.axes.Axes
        """
        if axes is None:
            fig, axes = plt.subplots(
                nrows=2, ncols=1, sharex=True, sharey=False, figsize=(10, 8), gridspec_kw=dict(height_ratios=[2, 1]))

        axes[0] = self.plot_spectrum(axes=axes[0], save=False, show=False)
        axes[1].set_xlabel(axes[0].get_xlabel(), fontsize=self.fontsize_axes)
        axes[0].set_xlabel("")
        ys = self.model(self.transient.angstroms, **self._max_like_params, **self._model_kwargs)
        axes[1].errorbar(
            self.transient.angstroms, self.transient.flux_density - ys, yerr=self.transient.flux_density_err,
            fmt=self.errorbar_fmt, c=self.color, ms=self.ms, elinewidth=self.elinewidth, capsize=self.capsize,
            fillstyle=self.markerfillstyle, markeredgecolor=self.markeredgecolor,
            markeredgewidth=self.markeredgewidth)
        axes[1].set_yscale('linear')
        axes[1].set_ylabel("Residual", fontsize=self.fontsize_axes)

        # Apply new customizations
        self._apply_axis_customizations(axes[1])

        self._save_and_show(filepath=self._residual_plot_filepath, save=save, show=show)
        return axes


def get_plotter_kwargs_docs(plotter_class=None):
    """Return a formatted string documenting all kwarg options for a Plotter class.

    Introspects the class for KwargsAccessorWithDefault descriptors and prints
    each option with its default value. This is the canonical way to discover
    what can be passed as **kwargs to transient.plot_data(), plot_multiband(),
    plot_lightcurve() etc.

    :param plotter_class: A Plotter subclass to inspect. Defaults to Plotter.
    :type plotter_class: type, optional
    :return: Formatted documentation string.
    :rtype: str

    **Example**::

        import redback.plotting
        print(redback.plotting.get_plotter_kwargs_docs())
        # or for MagnitudePlotter specifically:
        print(redback.plotting.get_plotter_kwargs_docs(redback.plotting.MagnitudePlotter))

    """
    if plotter_class is None:
        plotter_class = Plotter

    lines = [f"Keyword arguments accepted by {plotter_class.__name__} (pass via **kwargs):",
             "=" * 65]

    # Walk the MRO so subclass descriptors appear after base-class ones
    seen = set()
    for cls in reversed(plotter_class.__mro__):
        for name, obj in vars(cls).items():
            if isinstance(obj, KwargsAccessorWithDefault) and name not in seen:
                seen.add(name)
                default = repr(obj.default)
                lines.append(f"  {name} (default: {default})")

    lines.append("")
    lines.append("Pass any of these as keyword arguments, e.g.:")
    lines.append("  transient.plot_data(ms=8, fontsize_axes=16, band_colors={'g': 'green'})")
    return "\n".join(lines)


def plot_binned_count_lightcurve(
        binned=None, time_bins=None, counts=None, background=None, selection=None,
        rate=None, error=None,
        axes: matplotlib.axes.Axes = None, filename: str = None, outdir: str = None,
        save: bool = True, show: bool = True, color: str = "tab:blue", marker: str = "o",
        markersize: float = 4.0, xscale: str = "linear", yscale: str = "linear",
        min_counts: int = None, annotate_min_counts: bool = True) -> matplotlib.axes.Axes:
    """
    Plot count-rate light curve (counts/s vs time).

    Inputs (ThreeML-like):
    - time_bins: bin edges
    - counts: counts per bin
    - background: background counts per bin (optional)
    - selection: boolean mask for bins (optional)
    Or provide a DataFrame via `binned` with columns:
      time_start/time_end or time_center + dt, and counts.
    """
    ax = axes or plt.gca()
    logger.info("Plotting binned lightcurve (min_counts=%s)", str(min_counts))

    rate_err = None
    rate_in = rate
    if binned is not None:
        if "dt" in binned:
            dt = binned["dt"].to_numpy()
        else:
            dt = (binned["time_end"] - binned["time_start"]).to_numpy()
        if "time_center" in binned:
            t = binned["time_center"].to_numpy()
        else:
            t = 0.5 * (binned["time_start"] + binned["time_end"]).to_numpy()
        if "counts" in binned:
            cts = binned["counts"].to_numpy()
        else:
            cts = (binned["count_rate"] * dt).to_numpy()
        if "count_rate_err" in binned:
            rate_err = binned["count_rate_err"].to_numpy()
        elif "rate_err" in binned:
            rate_err = binned["rate_err"].to_numpy()
    else:
        if time_bins is None or counts is None:
            raise ValueError("Provide either `binned` or (`time_bins` and `counts`).")
        t = 0.5 * (time_bins[:-1] + time_bins[1:])
        dt = (time_bins[1:] - time_bins[:-1])
        cts = counts
        if rate_in is not None:
            rate_in = np.asarray(rate_in, dtype=float)
            if error is not None:
                rate_err = np.asarray(error, dtype=float)

    if selection is not None:
        t = t[selection]
        dt = dt[selection]
        cts = cts[selection]
        if background is not None:
            background = background[selection]
        if rate_in is not None:
            rate_in = rate_in[selection]
        if rate_err is not None:
            rate_err = rate_err[selection]

    if min_counts is not None and min_counts > 0:
        grouped_t = []
        grouped_dt = []
        grouped_cts = []
        grouped_bkg = [] if background is not None else None
        grouped_err2 = [] if rate_err is not None else None
        grouped_rate = [] if rate_in is not None else None
        acc_cts = 0.0
        acc_t = 0.0
        acc_dt = 0.0
        acc_bkg = 0.0
        acc_err2 = 0.0
        acc_rate = 0.0
        for i in range(len(cts)):
            acc_cts += float(cts[i])
            acc_t += float(t[i]) * float(dt[i])
            acc_dt += float(dt[i])
            if background is not None:
                acc_bkg += float(background[i])
            if rate_err is not None:
                acc_err2 += float(rate_err[i]) ** 2 * float(dt[i]) ** 2
            if rate_in is not None:
                acc_rate += float(rate_in[i]) * float(dt[i])
            if acc_cts >= min_counts:
                grouped_t.append(acc_t / acc_dt)
                grouped_dt.append(acc_dt)
                grouped_cts.append(acc_cts)
                if background is not None:
                    grouped_bkg.append(acc_bkg)
                if rate_err is not None:
                    grouped_err2.append(acc_err2)
                if rate_in is not None:
                    grouped_rate.append(acc_rate / acc_dt)
                acc_cts = 0.0
                acc_t = 0.0
                acc_dt = 0.0
                acc_bkg = 0.0
                acc_err2 = 0.0
                acc_rate = 0.0
        if acc_dt > 0:
            grouped_t.append(acc_t / acc_dt)
            grouped_dt.append(acc_dt)
            grouped_cts.append(acc_cts)
            if background is not None:
                grouped_bkg.append(acc_bkg)
            if rate_err is not None:
                grouped_err2.append(acc_err2)
            if rate_in is not None:
                grouped_rate.append(acc_rate / acc_dt)

        t = np.asarray(grouped_t, dtype=float)
        dt = np.asarray(grouped_dt, dtype=float)
        cts = np.asarray(grouped_cts, dtype=float)
        if background is not None:
            background = np.asarray(grouped_bkg, dtype=float)
        if rate_err is not None:
            rate_err = np.sqrt(np.asarray(grouped_err2, dtype=float)) / dt
        if rate_in is not None:
            rate_in = np.asarray(grouped_rate, dtype=float)

    if rate_in is None:
        rate = cts / dt
        rate_err = np.sqrt(np.maximum(cts, 0.0)) / dt
    else:
        rate = rate_in
        rate_err = rate_err if rate_err is not None else np.sqrt(np.maximum(cts, 0.0)) / dt

    ax.errorbar(
        t, rate, yerr=rate_err, fmt=marker, markersize=markersize,
        color=color, elinewidth=1.0, capsize=2, label="count rate"
    )

    if background is not None:
        bkg_rate = background / dt
        bkg_err = np.sqrt(np.maximum(background, 0.0)) / dt
        ax.errorbar(
            t, bkg_rate, yerr=bkg_err, fmt=marker, markersize=markersize,
            color="0.5", elinewidth=1.0, capsize=2, label="background"
        )

    ax.set_xscale(xscale)
    ax.set_yscale(yscale)
    ax.set_xlabel("Time (s)")
    ax.set_ylabel("Counts/s")
    ax.legend()

    if annotate_min_counts and min_counts is not None:
        text = f"min counts/bin: {min_counts}"
        ax.text(
            0.02, 0.98, text,
            transform=ax.transAxes,
            ha="left", va="top",
            fontsize=9,
            bbox=dict(boxstyle="round,pad=0.2", facecolor="white", alpha=0.6, edgecolor="none")
        )

    if save and filename is not None:
        path = filename if outdir is None else f"{outdir}/{filename}"
        plt.savefig(path, dpi=150, bbox_inches="tight")
    if show:
        plt.show()
    return ax


def plot_spectrum_data(dataset, **kwargs):
    """
    Wrapper for SpectralDataset.plot_spectrum_data to keep plotting API consistent.
    """
    return dataset.plot_spectrum_data(**kwargs)


def plot_spectrum_fit(dataset, **kwargs):
    """
    Wrapper for SpectralDataset.plot_spectrum_fit to keep plotting API consistent.
    """
    return dataset.plot_spectrum_fit(**kwargs)

nikhil-sarin / redback / 25683986170

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous