redback 1.0.31__py3-none-any.whl → 1.12.0__py3-none-any.whl

redback/likelihoods.py

@@ -204,6 +204,266 @@ class GaussianLikelihood(_RedbackLikelihood):
     def _gaussian_log_likelihood(res: np.ndarray, sigma: Union[float, np.ndarray]) -> Any:
         return np.sum(- (res / sigma) ** 2 / 2 - np.log(2 * np.pi * sigma ** 2) / 2)
 
+class MixtureGaussianLikelihood(GaussianLikelihood):
+    def __init__(self, x: np.ndarray, y: np.ndarray,
+                 sigma: Union[float, None, np.ndarray],
+                 function: callable, kwargs: dict = None,
+                 priors=None, fiducial_parameters=None) -> None:
+        """
+        Mixture Gaussian likelihood that handles outliers by modeling each data point’s likelihood
+        as a weighted sum of two Gaussians. The likelihood for each datum is given by
+
+            L_i = α * N(y_i | f(x_i), σ²) + (1 - α) * N(y_i | f(x_i), σ_out²)
+
+        where:
+          - N(y_i | f(x_i), σ²) is the Gaussian probability density evaluated at y_i with mean f(x_i)
+            and variance σ².
+          - α is the inlier fraction (between 0 and 1).
+          - σ_out is the standard deviation for the outlier component.
+
+        In addition, the posterior probability that a data point is an outlier is computed via
+
+            P(outlier | r) = [(1 - α) * p_out(r)] / [α * p_in(r) + (1 - α) * p_out(r)]
+
+        where r is the residual (y - f(x)).
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Independent variable data.
+        y : np.ndarray
+            Observed dependent variable data.
+        sigma : float, None, or np.ndarray
+            Standard deviation for the inlier component.
+        function : callable
+            Model function. It should accept x as the first argument.
+        kwargs : dict, optional
+            Additional keyword arguments for the model function.
+            sigma_out: Standard deviation of outlier data, is set to 10 times the inlier sigma if not provided.
+            alpha: Inlier fraction, i.e., fraction of data points from the underlying model. Default is 0.9.
+        priors : dict, optional
+            Priors for the parameters (not used in this implementation).
+        fiducial_parameters : dict, optional
+            Starting guesses for the model parameters.
+        """
+        super().__init__(x=x, y=y, sigma=sigma, function=function, kwargs=kwargs, priors=priors,
+                        fiducial_parameters=fiducial_parameters)
+
+        # Set default mixture parameters if not provided.
+        if 'alpha' not in self.parameters:
+            self.parameters['alpha'] = 0.9
+        if 'sigma_out' not in self.parameters:
+            if sigma is not None and isinstance(sigma, (int, float)):
+                self.parameters['sigma_out'] = sigma * 10
+            else:
+                self.parameters['sigma_out'] = 10.0
+
+        self._noise_log_likelihood = None
+    def _mixture_gaussian_log_likelihood(self, res: np.ndarray,
+                                         sigma: Union[float, np.ndarray],
+                                         sigma_out: Union[float, np.ndarray],
+                                         alpha: float) -> np.ndarray:
+        """
+        Compute the log-likelihood of the residuals under a mixture of two Gaussians in a stable
+        manner using the log-sum-exp trick.
+
+        Parameters
+        ----------
+        res : np.ndarray
+            Array of residuals.
+        sigma : float or np.ndarray
+            Standard deviation for the inlier Gaussian.
+        sigma_out : float or np.ndarray
+            Standard deviation for the outlier Gaussian.
+        alpha : float
+            Inlier fraction (between 0 and 1).
+
+        Returns
+        -------
+        np.ndarray
+            Log-likelihood for each residual under the mixture model.
+        """
+        # Compute log densities directly for inlier and outlier components:
+        logp_in = -0.5 * np.log(2 * np.pi) - np.log(sigma) - 0.5 * (res / sigma) ** 2
+        logp_out = -0.5 * np.log(2 * np.pi) - np.log(sigma_out) - 0.5 * (res / sigma_out) ** 2
+
+        # Combine contributions using log-sum-exp:
+        # log(sum_i exp(log_a_i)) can be computed as np.logaddexp(log_a, log_b) for two terms.
+        term_in = np.log(alpha) + logp_in
+        term_out = np.log(1 - alpha) + logp_out
+
+        # np.logaddexp is applied element-wise:
+        log_likelihood = np.logaddexp(term_in, term_out)
+        return log_likelihood
+
+    def p_in(self, r: np.ndarray) -> np.ndarray:
+        """
+        Compute the inlier probability density for residuals.
+
+        Parameters
+        ----------
+        r : np.ndarray
+            Residuals.
+
+        Returns
+        -------
+        np.ndarray
+            Inlier probability density evaluated at each residual.
+        """
+        sigma = self.sigma
+        return (1 / (np.sqrt(2 * np.pi) * sigma)) * np.exp(-0.5 * (r / sigma) ** 2)
+
+    def p_out(self, r: np.ndarray) -> np.ndarray:
+        """
+        Compute the outlier probability density for residuals.
+
+        Parameters
+        ----------
+        r : np.ndarray
+            Residuals.
+
+        Returns
+        -------
+        np.ndarray
+            Outlier probability density evaluated at each residual.
+        """
+        sigma_out = self.parameters.get('sigma_out')
+        return (1 / (np.sqrt(2 * np.pi) * sigma_out)) * np.exp(-0.5 * (r / sigma_out) ** 2)
+
+    def log_likelihood(self) -> float:
+        """
+        Compute the total log-likelihood for the mixture model.
+
+        For each data point, the log-likelihood is given by
+
+            log(L_i) = log(α * N(0, σ²) + (1 - α) * N(0, σ_out²)).
+
+        Returns
+        -------
+        float
+            The overall log-likelihood (summed over all data points).
+        """
+        res = self.residual
+        alpha = self.parameters.get('alpha')
+        sigma_out = self.parameters.get('sigma_out')
+        ll = np.sum(self._mixture_gaussian_log_likelihood(res, self.sigma, sigma_out, alpha))
+        return ll
+
+    def calculate_outlier_posteriors(self, model_prediction: np.ndarray) -> np.ndarray:
+        """
+        Calculate the posterior probability that each data point is an outlier.
+
+        Given a model prediction, the residual for each point is computed as:
+            r = y - model_prediction.
+        Then the posterior is given by
+
+            P(outlier | r) = [(1 - α) * p_out(r)] / [α * p_in(r) + (1 - α) * p_out(r)].
+
+        Parameters
+        ----------
+        model_prediction : np.ndarray
+            Model predictions for each data point.
+
+        Returns
+        -------
+        np.ndarray
+            An array of posterior probabilities (between 0 and 1) for each data point being an outlier.
+        """
+        r = self.y - model_prediction
+        pin = self.p_in(r)
+        pout = self.p_out(r)
+        alpha = self.parameters.get('alpha')
+        numerator = (1 - alpha) * pout
+        denominator = alpha * pin + (1 - alpha) * pout
+        posteriors = np.where(denominator > 0, numerator / denominator, 0.0)
+        return posteriors
+
+class StudentTLikelihood(GaussianLikelihood):
+    def __init__(
+            self, x: np.ndarray, y: np.ndarray, sigma: Union[float, None, np.ndarray],
+            function: callable, kwargs: dict = None, priors=None, fiducial_parameters=None) -> None:
+        """
+        A Student-t likelihood that handles outliers by assuming that the data are distributed
+        according to a Student-t distribution. The probability density function for each residual is
+        given by:
+
+            p(r | ν, σ) = Γ((ν+1)/2) / [√(νπ) σ Γ(ν/2)] · [1 + (r/σ)²/ν]^(–(ν+1)/2)
+
+        where ν (nu) is the degrees of freedom and σ is the scale (standard deviation).
+
+        :param x: The x values.
+        :type x: np.ndarray
+        :param y: The y values.
+        :type y: np.ndarray
+        :param sigma: The scale (standard deviation) for the model residuals.
+        :type sigma: Union[float, None, np.ndarray]
+        :param function:
+            The python function to fit to the data. Note, this must take the
+            dependent variable as its first argument. The other arguments will require a prior
+            and will be sampled over (unless a fixed value is given).
+        :type function: callable
+        :param kwargs: Any additional keywords for 'function'.
+        :type kwargs: dict
+        :param nu: The degrees of freedom for the Student-t distribution. Default to 3.0.
+        :param priors: The priors for the parameters. Default to None if not provided.
+        :type priors: Union[dict, None]
+        :param fiducial_parameters: The starting guesses for model parameters to use in the optimization.
+        :type fiducial_parameters: Union[dict, None]
+        """
+        self._noise_log_likelihood = None
+        super().__init__(x=x, y=y, sigma=sigma, function=function, kwargs=kwargs, priors=priors,
+                         fiducial_parameters=fiducial_parameters)
+
+        # Set default degrees of freedom for the Student-t distribution if not provided.
+        if 'nu' not in self.parameters:
+            self.parameters['nu'] = 3.0  # You can change this default as needed.
+
+    def noise_log_likelihood(self) -> float:
+        """
+        Compute the log-likelihood assuming the signal is pure noise (i.e. the residuals are just y).
+        """
+        if self._noise_log_likelihood is None:
+            nu = self.parameters.get('nu')
+            self._noise_log_likelihood = self._student_t_log_likelihood(res=self.y, sigma=self.sigma, nu=nu)
+        return self._noise_log_likelihood
+
+    def log_likelihood(self) -> float:
+        """
+        Compute the total log-likelihood for the Student-t likelihood model.
+
+        :return: The log-likelihood.
+        :rtype: float
+        """
+        nu = self.parameters.get('nu')
+        return np.nan_to_num(self._student_t_log_likelihood(res=self.residual, sigma=self.sigma, nu=nu))
+
+    @staticmethod
+    def _student_t_log_likelihood(res: np.ndarray, sigma: Union[float, np.ndarray], nu: float) -> Any:
+        """
+        Computes the log likelihood of the Student-t distribution for the residuals.
+
+        For each data point, the log probability is given by:
+
+          log[p(r|ν,σ)] = gammaln((ν+1)/2) - gammaln(ν/2)
+                           - 0.5*log(νπ) - log(σ)
+                           - ((ν+1)/2)*log[1 + (r/σ)²/ν]
+
+        :param res: The residuals.
+        :type res: np.ndarray
+        :param sigma: The scale parameter.
+        :type sigma: Union[float, np.ndarray]
+        :param nu: Degrees of freedom.
+        :type nu: float
+        :return: The total log-likelihood.
+        :rtype: float
+        """
+        term1 = gammaln((nu + 1) / 2) - gammaln(nu / 2)
+        term2 = - 0.5 * np.log(nu * np.pi)
+        term3 = - np.log(sigma)
+        term4 = - ((nu + 1) / 2) * np.log(1 + (res / sigma) ** 2 / nu)
+        log_pdf = term1 + term2 + term3 + term4
+        return np.sum(log_pdf)
+
 
 class GaussianLikelihoodUniformXErrors(GaussianLikelihood):
     def __init__(

redback/model_library.py

@@ -1,18 +1,28 @@
 from redback.transient_models import afterglow_models, \
     extinction_models, kilonova_models, fireball_models, \
     gaussianprocess_models, magnetar_models, magnetar_driven_ejecta_models, phase_models, phenomenological_models, \
-    prompt_models, shock_powered_models, supernova_models, tde_models, integrated_flux_afterglow_models, combined_models, general_synchrotron_models
+    prompt_models, shock_powered_models, supernova_models, tde_models, integrated_flux_afterglow_models, combined_models, \
+    general_synchrotron_models, spectral_models
+
 from redback.utils import get_functions_dict
 
 modules = [afterglow_models, extinction_models, fireball_models,
            gaussianprocess_models,  integrated_flux_afterglow_models, kilonova_models,
            magnetar_models, magnetar_driven_ejecta_models,
-           phase_models, phenomenological_models, prompt_models, shock_powered_models, supernova_models, tde_models, combined_models, general_synchrotron_models]
+           phase_models, phenomenological_models, prompt_models, shock_powered_models, supernova_models,
+           tde_models, combined_models, general_synchrotron_models, spectral_models]
+
+base_modules = [extinction_models, phase_models]
 
 all_models_dict = dict()
+base_models_dict = dict()
 modules_dict = dict()
 for module in modules:
     models_dict = get_functions_dict(module)
     modules_dict.update(models_dict)
     for k, v in models_dict[module.__name__.split('.')[-1]].items():
         all_models_dict[k] = v
+for mod in base_modules:
+    models_dict = get_functions_dict(mod)
+    for k, v in models_dict[mod.__name__.split('.')[-1]].items():
+        base_models_dict[k] = v

redback/plotting.py

@@ -33,6 +33,9 @@ class _FilePathGetter(object):
 
 
 class Plotter(object):
+    """
+    Base class for all lightcurve plotting classes in redback.
+    """
 
     capsize = KwargsAccessorWithDefault("capsize", 0.)
     legend_location = KwargsAccessorWithDefault("legend_location", "best")
@@ -43,9 +46,9 @@ class Plotter(object):
     band_scaling = KwargsAccessorWithDefault("band_scaling", {})
     dpi = KwargsAccessorWithDefault("dpi", 300)
     elinewidth = KwargsAccessorWithDefault("elinewidth", 2)
-    errorbar_fmt = KwargsAccessorWithDefault("errorbar_fmt", "x")
+    errorbar_fmt = KwargsAccessorWithDefault("errorbar_fmt", "o")
     model = KwargsAccessorWithDefault("model", None)
-    ms = KwargsAccessorWithDefault("ms", 1)
+    ms = KwargsAccessorWithDefault("ms", 5)
     axis_tick_params_pad = KwargsAccessorWithDefault("axis_tick_params_pad", 10)
 
     max_likelihood_alpha = KwargsAccessorWithDefault("max_likelihood_alpha", 0.65)
@@ -262,6 +265,208 @@ class Plotter(object):
         if show:
             plt.show()
 
+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)
+
+    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.
+        """
+        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:
+            plt.savefig(filepath, dpi=self.dpi, bbox_inches=self.bbox_inches, transparent=False, facecolor='white')
+        if show:
+            plt.show()
+
 
 class IntegratedFluxPlotter(Plotter):
 
@@ -385,6 +590,16 @@ class IntegratedFluxPlotter(Plotter):
         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
 
@@ -805,6 +1020,122 @@ class FluxDensityPlotter(MagnitudePlotter):
 class IntegratedFluxOpticalPlotter(MagnitudePlotter):
     pass
 
-class SpectraPlotter(Plotter):
-    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, axes: matplotlib.axes.Axes = None, save: bool = True, show: bool = True) -> matplotlib.axes.Axes:
+        """Plots the spectrum 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()
+
+        if self.transient.plot_with_time_label:
+            label = self.transient.time
+        else:
+            label = self.transient.name
+        ax.plot(self.transient.angstroms, self.transient.flux_density/1e-17, color=self.color,
+                lw=self.linewidth)
+        ax.set_xscale('linear')
+        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)
+
+        ax.tick_params(axis='both', which='both', pad=self.axis_tick_params_pad, labelsize=self.fontsize_ticks)
+
+        self._save_and_show(filepath=self._data_plot_filepath, save=save, show=show)
+        return ax
+
+    def plot_spectrum(
+            self, 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 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)
+        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)
+
+        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, 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)
+        axes[1].set_yscale('linear')
+        axes[1].set_ylabel("Residual", fontsize=self.fontsize_axes)
+        axes[1].tick_params(axis='both', which='both', pad=self.axis_tick_params_pad, labelsize=self.fontsize_ticks)
+
+        self._save_and_show(filepath=self._residual_plot_filepath, save=save, show=show)
+        return axes

redback/priors/blackbody_spectrum_with_absorption_and_emission_lines.prior

@@ -0,0 +1,9 @@
+redshift = Uniform(minimum=0.01, maximum=2.0, name='redshift', latex_label=r'$z$')
+rph = LogUniform(minimum=1e13, maximum=1e16, name='rph', latex_label=r'$R_{\mathrm{ph}}~(\mathrm{cm})$')
+temp = Uniform(minimum=1e3, maximum=1e5, name='temp', latex_label=r'$T~(\mathrm{K})$')
+lc1 = Uniform(2000, 7000, name='lc1', latex_label=r'$\Lambda_{\mathrm{emission}}$')
+lc2 = Uniform(2000,7000, name='lc2', latex_label=r'$\Lambda_{\mathrm{absorption}}$')
+ls1 = LogUniform(1e-34, 1e-31, name='ls1', latex_label=r'line_stength$_{\mathrm{emission}}$')
+ls2 = LogUniform(1e-34, 1e-31, name='ls2', latex_label=r'line_stength$_{\mathrm{absorption}}$')
+v1 = Uniform(1e3, 1e4, name='v1', latex_label=r'$v_{\mathrm{emission}}$')
+v2 = Uniform(1e3, 1e4, name='v2', latex_label=r'$v_{\mathrm{absorption}}$')