redback 1.1__py3-none-any.whl → 1.12.1__py3-none-any.whl

redback/__init__.py

@@ -5,5 +5,5 @@ from redback.transient import afterglow, kilonova, prompt, supernova, tde
 from redback.sampler import fit_model
 from redback.utils import setup_logger
 
-__version__ = "1.1.0"
+__version__ = "1.12.1"
 setup_logger(log_level='info')

redback/filters.py

@@ -2,63 +2,73 @@ from astropy.io import ascii
 from astropy import units as u
 from astroquery.svo_fps import SvoFps
 import numpy as np
+from redback.utils import calc_effective_width_hz_from_angstrom
 import redback
 import sncosmo
 
-def add_to_database(LABEL, WAVELENGTH, ZEROFLUX, DATABASE, PLOT_LABEL, EFFECTIVE_WIDTH):
-    
+def add_to_database(label, wavelength, zeroflux, database, plot_label, effective_width):
+
     """
     Add a filter to the Redback filter database.
-    :param LABEL:       name of the filter in the Redback filter database
-    :param WAVELENGTH:  central wavelength of the filter as defined on SVO
+
+    :param label:       name of the filter in the Redback filter database
+    :param wavelength:  central wavelength of the filter as defined on SVO in m
+    :param zeroflux:   zero flux of the filter in erg/cm^2/s/Hz
+    :param database:    filter database
+    :param plot_label:  plot label. If none is provided, it will use LABEL (default: None).
+    :param effective_width: effective width of the filter in Angstrom
     :return: None
     """
 
-    frequency = 3.0e8 / WAVELENGTH
-    effective_width = 3.0e8 / EFFECTIVE_WIDTH
-    print(effective_width)
-    DATABASE.add_row([LABEL, frequency, WAVELENGTH*1e10, 'black', ZEROFLUX, LABEL, PLOT_LABEL, effective_width])
+    frequency = 3.0e8 / wavelength
+    effective_width = calc_effective_width_hz_from_angstrom(effective_width=effective_width,
+                                                            effective_wavelength=wavelength * 1e10)
+    database.add_row([label, frequency, wavelength * 1e10, 'black', zeroflux, label, plot_label, effective_width])
 
-def add_to_sncosmo(LABEL, TRANSMISSION):
+def add_to_sncosmo(label, transmission):
 
     """
     Add a filter to the Redback filter database.
-    :param LABEL:       name of the filter in the Redback filter database
+
+    :param label:       name of the filter in the Redback filter database
     :param WAVELENGTH:  central wavelength of the filter as defined on SVO
     :return: None
     """
 
-    band  = sncosmo.Bandpass(TRANSMISSION['Wavelength'], TRANSMISSION['Transmission'], name=LABEL, wave_unit=u.angstrom)
-    sncosmo.register(band, LABEL, force=True)
+    band  = sncosmo.Bandpass(transmission['Wavelength'], transmission['Transmission'], name=label, wave_unit=u.angstrom)
+    sncosmo.register(band, label, force=True)
 
-def add_filter_svo(FILTER, LABEL, PLOT_LABEL=None, OVERWRITE=False):
+def add_filter_svo(filter, label, plot_label=None, overwrite=False):
 
     """
     Wrapper to add a filter from SVO to SNCosmo and the Redback filter database
-    :param FILTER: record from the SVO query
-    :param LABEL:  name of the filter in SNCosmo
+
+    :param filter: record from the SVO query
+    :param label:  name of the filter in SNCosmo
+    :param plot_label: plot label. If none is provided, it will use LABEL (default: None).
+    :param overwrite:  overwrite any existing entry? (default: False)
     :return: None
     """
 
-    redback_db_fname = path = redback.__path__[0] + '/tables/filters.csv'
+    redback_db_fname = redback.__path__[0] + '/tables/filters.csv'
     database_filters = ascii.read(redback_db_fname)
     
-    mask = np.where((database_filters['bands'] == LABEL) & (database_filters['sncosmo_name'] == LABEL))[0]
+    mask = np.where((database_filters['bands'] == label) & (database_filters['sncosmo_name'] == label))[0]
     
     # Only add filter to filter database if entry does not exist in the Redback database by default
     
     # If no entry exists or you choose to overwrite an entry
-    if (len(mask) == 0) or ( (len(mask) != 0) & OVERWRITE ):
+    if (len(mask) == 0) or ((len(mask) != 0) & overwrite):
 
         if len(mask) > 0:
             database_filters.remove_rows(mask)
 
         # Reference (=pivot) wavelength, unit: AA
-        wavelength_pivot = FILTER['WavelengthRef']
+        wavelength_pivot = filter['WavelengthRef']
 
         # Effective width
         # defined as int( T(lambda), lambda ) / max( T(lambda) ), unit: AA
-        effective_width  = FILTER['WidthEff']
+        effective_width  = filter['WidthEff']
 
         # Zero flux
 
@@ -74,14 +84,14 @@ def add_filter_svo(FILTER, LABEL, PLOT_LABEL=None, OVERWRITE=False):
 
         # Add to Redback
 
-        plot_label = PLOT_LABEL if PLOT_LABEL != None else LABEL
+        plot_label = plot_label if plot_label != None else label
 
-        add_to_database(LABEL, wavelength_pivot * 1.0e-10, zeroflux, database_filters, plot_label, effective_width)
+        add_to_database(label, wavelength_pivot * 1.0e-10, zeroflux, database_filters, plot_label, effective_width)
 
     # Non-standard filters always needs to be re-added to SN Cosmo even if an entry exists in filter.csv
 
-    filter_transmission = SvoFps.get_transmission_data(FILTER['filterID'])
-    add_to_sncosmo(LABEL, filter_transmission)
+    filter_transmission = SvoFps.get_transmission_data(filter['filterID'])
+    add_to_sncosmo(label, filter_transmission)
 
     # Prettify output
 
@@ -92,16 +102,16 @@ def add_filter_svo(FILTER, LABEL, PLOT_LABEL=None, OVERWRITE=False):
 
     database_filters.write(redback_db_fname, overwrite=True, format='csv')
 
-def add_filter_user(FILE, LABEL, PLOT_LABEL=None, OVERWRITE=False):
+def add_filter_user(file, label, plot_label=None, overwrite=False):
 
     """
     Wrapper to add a user filter from SVO to SNCosmo and the Redback filter database
-    :param FILE:       file name that contains the transmission function
+    :param file:       file name that contains the transmission function
                        (Must have two columns, wavelength must be in AA)
-    :param LABEL:      name of the filter
+    :param label:      name of the filter
     :param DATABASE:   location of the Redback filter database
-    :param PLOT_LABEL: plot label. If none is provided, it will use LABEL (default: None).
-    :param OVERWRITE:  overwrite any existing entry? (default: False)
+    :param plot_label: plot label. If none is provided, it will use LABEL (default: None).
+    :param overwrite:  overwrite any existing entry? (default: False)
     :return: None
     """
 
@@ -111,21 +121,21 @@ def add_filter_user(FILE, LABEL, PLOT_LABEL=None, OVERWRITE=False):
     database_filters = ascii.read(redback_db_fname)
 
     # Check whether such an entry already exists
-    mask = np.where((database_filters['bands'] == LABEL) & (database_filters['sncosmo_name'] == LABEL))[0]
+    mask = np.where((database_filters['bands'] == label) & (database_filters['sncosmo_name'] == label))[0]
 
     # Add to SNCosmo
     # Needs to be done even if an entry exists in filters.csv
 
-    filter_transmission = ascii.read(FILE)
+    filter_transmission = ascii.read(file)
     filter_transmission.rename_columns(list(filter_transmission.keys()), ['Wavelength', 'Transmission'])
 
-    add_to_sncosmo(LABEL, filter_transmission)
+    add_to_sncosmo(label, filter_transmission)
 
     # Add to filter.csv
 
     # If no entry exists or you choose to overwrite an entry
 
-    if (len(mask) == 0) or ( (len(mask) != 0) & OVERWRITE ):
+    if (len(mask) == 0) or ((len(mask) != 0) & overwrite):
         
         if len(mask) > 0:
             database_filters.remove_rows(mask)
@@ -156,11 +166,11 @@ def add_filter_user(FILE, LABEL, PLOT_LABEL=None, OVERWRITE=False):
 
         # Add to Redback
         
-        plot_label = PLOT_LABEL if PLOT_LABEL != None else LABEL
+        plot_label = plot_label if plot_label != None else label
 
-        print(LABEL, wavelength_pivot * 1.0e-10, zeroflux, plot_label)
+        print(label, wavelength_pivot * 1.0e-10, zeroflux, plot_label)
 
-        add_to_database(LABEL, wavelength_pivot * 1.0e-10, zeroflux, database_filters, plot_label, effective_width)
+        add_to_database(label, wavelength_pivot * 1.0e-10, zeroflux, database_filters, plot_label, effective_width)
 
         # Prettify output
 
@@ -173,7 +183,7 @@ def add_filter_user(FILE, LABEL, PLOT_LABEL=None, OVERWRITE=False):
     
     else:
         
-        print('Filter {} already exists. Set OVERWRITE to True if you want to overwrite the existing entry'.format(LABEL))
+        print('Filter {} already exists. Set OVERWRITE to True if you want to overwrite the existing entry'.format(label))
 
 def add_common_filters(overwrite=False):
 
@@ -191,7 +201,7 @@ def add_common_filters(overwrite=False):
     filter_label = ['grond::' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
     plot_label   = ['GROND/' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
 
-    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], OVERWRITE=overwrite) for ii in range(len(filter_list))]
+    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], overwrite=overwrite) for ii in range(len(filter_list))]
 
     print('done.\n')
 
@@ -206,7 +216,7 @@ def add_common_filters(overwrite=False):
     filter_label = ['efosc2::' + x for x in filter_list['Band']]
     plot_label   = ['EFOSC/' + x for x in filter_list['Band']]
 
-    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], OVERWRITE=overwrite) for ii in range(len(filter_list))]
+    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], overwrite=overwrite) for ii in range(len(filter_list))]
 
     print('done.\n')
 
@@ -218,7 +228,7 @@ def add_common_filters(overwrite=False):
     filter_label = ['euclid::' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
     plot_label   = ['EUCLID/' + x.split('/')[1].split('.')[1].upper() for x in filter_list['filterID']]
 
-    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], OVERWRITE=overwrite) for ii in range(len(filter_list))]
+    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], overwrite=overwrite) for ii in range(len(filter_list))]
 
 
     filter_list  = SvoFps.get_filter_list(facility='Euclid', instrument='NISP')
@@ -227,7 +237,7 @@ def add_common_filters(overwrite=False):
     filter_label = ['euclid::' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
     plot_label   = ['EUCLID/' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
 
-    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], OVERWRITE=overwrite) for ii in range(len(filter_list))]
+    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], overwrite=overwrite) for ii in range(len(filter_list))]
 
     print('done.\n')
 
@@ -239,7 +249,7 @@ def add_common_filters(overwrite=False):
     filter_label = ['irac::' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
     plot_label   = ['IRAC/' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
 
-    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], OVERWRITE=overwrite) for ii in range(len(filter_list))]
+    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], overwrite=overwrite) for ii in range(len(filter_list))]
 
     print('done.\n')
 
@@ -251,7 +261,7 @@ def add_common_filters(overwrite=False):
     filter_label = ['wise::' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
     plot_label   = ['WISE/' + x.split('/')[1].split('.')[1] for x in filter_list['filterID']]
 
-    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], OVERWRITE=overwrite) for ii in range(len(filter_list))]
+    [add_filter_svo(filter_list[ii], filter_label[ii], plot_label[ii], overwrite=overwrite) for ii in range(len(filter_list))]
 
     print('done.\n')
 
@@ -265,6 +275,7 @@ def show_all_filters():
 def add_effective_widths():
     """
     Adds effective widths to the Redback filter database
+
     :return: None
     """
     import pandas as pd
@@ -280,8 +291,9 @@ def add_effective_widths():
             # Calculate the effective width:
             #   effective_width = ∫T(λ) dλ / max(T(λ))
             effective_width = np.trapz(trans, waves) / np.max(trans)
-            effective_width = effective_width * u.Angstrom
-            eff_width[ii] = effective_width.to(u.Hz, equivalencies=u.spectral()).value
+            effective_width = calc_effective_width_hz_from_angstrom(effective_width=effective_width,
+                                                                    effective_wavelength=band.wave_eff)
+            eff_width[ii] = effective_width
         except Exception:
             redback.utils.logger.warning("Failed for band={} at index={}".format(bb, ii))
             eff_width[ii] = db['wavelength [Hz]'].iloc[ii]

redback/likelihoods.py

@@ -2,7 +2,7 @@ import numpy as np
 from typing import Any, Union
 
 import bilby
-from scipy.special import gammaln
+from scipy.special import gammaln, erf
 from redback.utils import logger
 from bilby.core.prior import DeltaFunction, Constraint
 
@@ -180,9 +180,17 @@ class GaussianLikelihood(_RedbackLikelihood):
         else:
             raise ValueError('Sigma must be either float or array-like x.')
 
+    @property
+    def model_output(self) -> np.ndarray:
+        """
+        :return: The model output for the given x values.
+        :rtype: np.ndarray
+        """
+        return self.function(self.x, **self.parameters, **self.kwargs)
+
     @property
     def residual(self) -> np.ndarray:
-        return self.y - self.function(self.x, **self.parameters, **self.kwargs)
+        return self.y - self.model_output
 
     def noise_log_likelihood(self) -> float:
         """
@@ -204,6 +212,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 GaussianLikelihoodWithUpperLimits(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, detections: Union[np.ndarray, None] = None,
+            upper_limit_sigma: Union[float, np.ndarray] = 3.0,
+            data_mode: str = 'flux') -> None:
+        """A Gaussian likelihood that handles upper limits - extends the base GaussianLikelihood.
+
+        :param x: The x values.
+        :type x: np.ndarray
+        :param y: The y values. For upper limits, these are the reported limit values.
+        :type y: np.ndarray
+        :param sigma: The standard deviation of the noise for detections.
+        :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 priors: The priors for the parameters. Default to None if not provided.
+        Only necessary if using maximum likelihood estimation functionality.
+        :type priors: Union[dict, None]
+        :param fiducial_parameters: The starting guesses for model parameters to
+        use in the optimization for maximum likelihood estimation. Default to None if not provided.
+        :type fiducial_parameters: Union[dict, None]
+        :param detections: Array indicating which data points are detections.
+        Can be boolean (True/False) or integer (1/0). 1 = detection, 0 = upper limit.
+        If None, all data points are treated as detections.
+        :type detections: Union[np.ndarray, None]
+        :param upper_limit_sigma: The sigma level for upper limits. Can be a single value
+        (e.g., 3.0 for all 3-sigma limits) or an array with different sigma levels for each
+        upper limit. Default is 3.0.
+        :type upper_limit_sigma: Union[float, np.ndarray]
+        :param data_mode: Whether data is in 'flux' or 'magnitude' units. This affects
+        how upper limits are interpreted. For flux: upper limit means "true value < limit".
+        For magnitude: upper limit means "true value > limit" (fainter than limit).
+        :type data_mode: str
+        """
+
+        # Initialize the parent class first
+        super().__init__(x=x, y=y, sigma=sigma, function=function, kwargs=kwargs,
+                         priors=priors, fiducial_parameters=fiducial_parameters)
+
+        # Add upper limit functionality
+        self.detections = detections
+        self.upper_limit_sigma = upper_limit_sigma
+        self.data_mode = data_mode
+
+    @property
+    def detections(self) -> np.ndarray:
+        return self._detections
+
+    @detections.setter
+    def detections(self, detections: Union[np.ndarray, None]) -> None:
+        if detections is None:
+            self._detections = np.ones(len(self.x), dtype=bool)  # All detections by default
+        elif len(detections) == len(self.x):
+            # Convert to boolean array, handles both 0/1 and True/False
+            self._detections = np.array(detections, dtype=bool)
+        else:
+            raise ValueError('detections must have the same length as x.')
+
+    @property
+    def upper_limits(self) -> np.ndarray:
+        """Derived property: upper_limits is the inverse of detections"""
+        return ~self._detections
+
+    @property
+    def upper_limit_sigma(self) -> Union[float, np.ndarray]:
+        return self._upper_limit_sigma
+
+    @upper_limit_sigma.setter
+    def upper_limit_sigma(self, upper_limit_sigma: Union[float, np.ndarray]) -> None:
+        if isinstance(upper_limit_sigma, (float, int)):
+            self._upper_limit_sigma = float(upper_limit_sigma)
+        elif isinstance(upper_limit_sigma, np.ndarray):
+            if len(upper_limit_sigma) == len(self.x):
+                self._upper_limit_sigma = upper_limit_sigma
+            elif hasattr(self, '_detections') and len(upper_limit_sigma) == np.sum(~self._detections):
+                # Array length matches number of upper limits
+                self._upper_limit_sigma = upper_limit_sigma
+            else:
+                raise ValueError('upper_limit_sigma array must have length equal to x or to number of upper limits.')
+        else:
+            raise ValueError('upper_limit_sigma must be a float or array.')
+
+    @property
+    def data_mode(self) -> str:
+        return self._data_mode
+
+    @data_mode.setter
+    def data_mode(self, data_mode: str) -> None:
+        if data_mode.lower() not in ['flux', 'magnitude', 'mag']:
+            raise ValueError("data_mode must be 'flux' or 'magnitude' (or 'mag')")
+        self._data_mode = data_mode.lower()
+        if self._data_mode == 'mag':
+            self._data_mode = 'magnitude'
+
+    def get_upper_limit_sigma_values(self) -> np.ndarray:
+        """
+        Get the sigma values for upper limits only.
+
+        :return: Array of sigma values for upper limit data points.
+        :rtype: np.ndarray
+        """
+        if not np.any(self.upper_limits):
+            return np.array([])
+
+        if isinstance(self.upper_limit_sigma, (float, int)):
+            # Same sigma level for all upper limits
+            n_upper_limits = np.sum(self.upper_limits)
+            return np.full(n_upper_limits, self.upper_limit_sigma)
+        elif len(self.upper_limit_sigma) == len(self.x):
+            # Sigma level for each data point, extract upper limits only
+            return self.upper_limit_sigma[self.upper_limits]
+        else:
+            # Array already has length equal to number of upper limits
+            return self.upper_limit_sigma
+
+    @staticmethod
+    def _normal_cdf(x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
+        """
+        Fast computation of normal CDF using erf.
+        CDF(x) = 0.5 * (1 + erf(x / sqrt(2)))
+
+        :param x: Standardized values (z-scores)
+        :return: CDF values
+        """
+        return 0.5 * (1.0 + erf(x / np.sqrt(2)))
+
+    def _upper_limit_log_likelihood(self, observed: np.ndarray, model: np.ndarray) -> float:
+        """
+        Calculate log-likelihood contribution from upper limits only.
+
+        :param observed: Upper limit values
+        :param model: Model predictions at upper limit points
+        :return: Log-likelihood contribution from upper limits
+        """
+        if not np.any(self.upper_limits):
+            return 0.0
+
+        model_ul = model[self.upper_limits]
+        observed_ul = observed[self.upper_limits]
+
+        # Get the sigma levels for each upper limit
+        ul_sigma_levels = self.get_upper_limit_sigma_values()
+
+        # The measurement uncertainty - this calculation depends on data mode
+        if self.data_mode == 'magnitude':
+            # For magnitudes, the uncertainty is typically symmetric in mag space
+            # If we don't have explicit uncertainties for upper limits, we need to estimate them
+            # This is a common issue - often we only have the sigma level, not the actual uncertainty
+            # We'll use a reasonable default or derive from the limit
+
+            # Option 1: Use a typical photometric uncertainty (you may want to adjust this)
+            sigma_measurement = np.full_like(observed_ul, 0.1)  # Assume 0.1 mag uncertainty
+
+            # Option 2: Derive from the sigma level (uncomment if preferred)
+            # sigma_measurement = observed_ul / ul_sigma_levels  # This assumes the limit is sigma_level * uncertainty
+
+        else:  # flux mode
+            sigma_measurement = observed_ul / ul_sigma_levels
+
+        # Calculate the probability based on data mode
+        if self.data_mode == 'magnitude':
+            # For magnitudes: upper limit means "true magnitude > observed_limit" (fainter than limit)
+            # We want: P(true_mag > observed_upper_limit | model_prediction)
+            # This is 1 - CDF(observed_limit) = CDF(-standardized) due to symmetry
+            standardized = (observed_ul - model_ul) / sigma_measurement
+            # P(X > observed) = 1 - P(X <= observed) = 1 - CDF(standardized)
+            survival_prob = 1.0 - self._normal_cdf(standardized)
+            cdf_values = survival_prob
+
+        else:  # flux mode
+            # For flux: upper limit means "true flux < observed_limit"
+            # We want: P(true_flux < observed_upper_limit | model_prediction)
+            standardized = (observed_ul - model_ul) / sigma_measurement
+            cdf_values = self._normal_cdf(standardized)
+
+        # Add small epsilon to avoid log(0) and clip to valid range
+        epsilon = 1e-30
+        cdf_values = np.clip(cdf_values, epsilon, 1.0 - epsilon)
+
+        return np.sum(np.log(cdf_values))
+
+    def noise_log_likelihood(self) -> float:
+        """
+        Override parent method to include upper limits in noise likelihood.
+
+        :return: The noise log-likelihood, i.e. the log-likelihood assuming the signal is just noise.
+        :rtype: float
+        """
+        if self._noise_log_likelihood is None:
+            # Detections part (use parent class method for detected points only)
+            if np.any(self.detections):
+                y_det = self.y[self.detections]
+                sigma_det = self.sigma if np.isscalar(self.sigma) else self.sigma[self.detections]
+                detection_noise_ll = self._gaussian_log_likelihood(res=y_det, sigma=sigma_det)
+            else:
+                detection_noise_ll = 0.0
+
+            # Upper limits part (assume model = 0 for noise in flux, or some reference mag for magnitudes)
+            if self.data_mode == 'magnitude':
+                # For magnitudes, "no signal" might mean very faint (large magnitude)
+                # You might want to adjust this based on your specific case
+                noise_model = np.full_like(self.y, 60.0)  # Assume 30 mag as "no signal"
+            else:
+                noise_model = np.zeros_like(self.y)
+
+            ul_noise_ll = self._upper_limit_log_likelihood(observed=self.y, model=noise_model)
+
+            self._noise_log_likelihood = detection_noise_ll + ul_noise_ll
+
+        return self._noise_log_likelihood
+
+    def log_likelihood(self) -> float:
+        """
+        Override parent method to include upper limits.
+
+        :return: The log-likelihood including upper limits.
+        :rtype: float
+        """
+        # Detections part (use parent class method for detected points only)
+        if np.any(self.detections):
+            residual_det = self.residual[self.detections]
+            sigma_det = self.sigma if np.isscalar(self.sigma) else self.sigma[self.detections]
+            detection_ll = self._gaussian_log_likelihood(res=residual_det, sigma=sigma_det)
+        else:
+            detection_ll = 0.0
+
+        # Upper limits part
+        ul_ll = self._upper_limit_log_likelihood(observed=self.y, model=self.model_output)
+
+        return np.nan_to_num(detection_ll + ul_ll)
+
+    def summary(self) -> dict:
+        """
+        Provide a summary of the likelihood setup.
+
+        :return: Dictionary with summary information
+        """
+        n_detections = np.sum(self.detections)
+        n_upper_limits = np.sum(self.upper_limits)
+
+        summary_dict = {
+            'total_data_points': len(self.x),
+            'detections': n_detections,
+            'upper_limits': n_upper_limits,
+            'data_mode': self.data_mode,
+            'upper_limit_sigma_levels': self.get_upper_limit_sigma_values() if n_upper_limits > 0 else None
+        }
+
+        return summary_dict
+
+
 class MixtureGaussianLikelihood(GaussianLikelihood):
     def __init__(self, x: np.ndarray, y: np.ndarray,
                  sigma: Union[float, None, np.ndarray],
@@ -534,7 +802,6 @@ class GaussianLikelihoodUniformXErrors(GaussianLikelihood):
         """
         return np.nan_to_num(self.log_likelihood_x() + self.log_likelihood_y())
 
-
 class GaussianLikelihoodQuadratureNoise(GaussianLikelihood):
     def __init__(
             self, x: np.ndarray, y: np.ndarray, sigma_i: Union[float, None, np.ndarray],
@@ -628,7 +895,7 @@ class GaussianLikelihoodWithFractionalNoise(GaussianLikelihood):
         :return: The standard deviation of the full noise
         :rtype: Union[float, np.ndarray]
         """
-        model_y = self.function(self.x, **self.parameters, **self.kwargs)
+        model_y = self.model_output
         return np.sqrt(self.sigma_i**2.*model_y**2)
 
     def noise_log_likelihood(self) -> float:
@@ -652,7 +919,8 @@ class GaussianLikelihoodWithSystematicNoise(GaussianLikelihood):
             self, x: np.ndarray, y: np.ndarray, sigma_i: Union[float, None, np.ndarray],
             function: callable, kwargs: dict = None, priors=None, fiducial_parameters=None) -> None:
         """
-        A Gaussian likelihood with a systematic noise term that is proportional to the model + some additive noise.
+        A Gaussian likelihood with a systematic noise term that is proportional to the model +
+        the original data noise added in quadrature.
         The parameters are inferred from the arguments of function
 
         :param x: The x values.
@@ -688,7 +956,7 @@ class GaussianLikelihoodWithSystematicNoise(GaussianLikelihood):
         :return: The standard deviation of the full noise
         :rtype: Union[float, np.ndarray]
         """
-        model_y = self.function(self.x, **self.parameters, **self.kwargs)
+        model_y = self.model_output
         return np.sqrt(self.sigma_i**2. + model_y**2*self.sigma**2.)
 
     def noise_log_likelihood(self) -> float:

redback/model_library.py

@@ -2,7 +2,7 @@ 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, spectral_models
+    general_synchrotron_models, spectral_models, stellar_interaction_models
 
 from redback.utils import get_functions_dict
 
@@ -10,7 +10,7 @@ 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, spectral_models]
+           tde_models, combined_models, general_synchrotron_models, spectral_models, stellar_interaction_models]
 
 base_modules = [extinction_models, phase_models]
 

redback/plotting.py

@@ -672,6 +672,7 @@ class MagnitudePlotter(Plotter):
         if self.transient.magnitude_data:
             ax.set_ylim(self._ylim_low_magnitude, self._ylim_high_magnitude)
             ax.invert_yaxis()
+            ax.set_yscale('linear')
         else:
             ax.set_ylim(self._ylim_low, self._ylim_high)
             ax.set_yscale("log")
@@ -680,6 +681,7 @@ class MagnitudePlotter(Plotter):
         if self.transient.magnitude_data:
             ax.set_ylim(self._ylim_low_magnitude, self._ylim_high_magnitude)
             ax.invert_yaxis()
+            ax.set_yscale('linear')
         else:
             ax.set_ylim(self._get_ylim_low_with_indices(indices=indices),
                         self._get_ylim_high_with_indices(indices=indices))
@@ -742,7 +744,7 @@ class MagnitudePlotter(Plotter):
                 color = self._colors[list(self._filters).index(band)]
                 if band_label_generator is None:
                     if band in self.band_scaling:
-                        label = str(self.band_scaling.get(band))  + ' ' + self.band_scaling.get("type") + ' ' + band 
+                        label = band + ' ' + self.band_scaling.get("type") + ' ' + str(self.band_scaling.get(band))
                     else:
                         label = band   
                 else:
@@ -806,7 +808,6 @@ class MagnitudePlotter(Plotter):
         axes = axes or plt.gca()
 
         axes = self.plot_data(axes=axes, save=False, show=False)
-        axes.set_yscale('log')
 
         times = self._get_times(axes)
         bands_to_plot = self._get_bands_to_plot
@@ -983,7 +984,8 @@ class MagnitudePlotter(Plotter):
                 continue
             new_model_kwargs = self._model_kwargs.copy()
             new_model_kwargs['frequency'] = freq
-            new_model_kwargs['bands'] = band
+            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)]

redback/priors/blackbody_spectrum_at_z.prior

@@ -0,0 +1,3 @@
+redshift = Uniform(0.01, 1.0, 'redshift', latex_label = r'$z$')
+rph = LogUniform(1e13, 1e20, 'rph', latex_label = r'$R_{\mathrm{ph}}~(\mathrm{cm})$')
+temp = Uniform(2000, 15000, 'temp', latex_label = r'$T~(\mathrm{K})$')

redback/priors/bpl_cooling_envelope.prior

@@ -0,0 +1,9 @@
+redshift = Uniform(1e-6, 3, 'redshift', latex_label = r'$z$')
+peak_time = LogUniform(0.1,60, name='peak_time', latex_label = r'$t_{\mathrm{peak}}~(\mathrm{day})$')
+alpha_1 = Uniform(0.5, 3, name='alpha_1', latex_label=r'$\\alpha_{1}$')
+alpha_2 = Uniform(-3, -0.5, name='alpha_2', latex_label=r'$\\alpha_{2}$')
+mbh_6 = LogUniform(0.01, 20, name='mbh_6', latex_label = r'$M_{\mathrm{BH}}~(10^{6}~M_\odot)$')
+stellar_mass = LogUniform(0.1, 10, name='stellar_mass', latex_label = r'$M_{\mathrm{star}}~(M_\odot)$')
+eta = LogUniform(1e-4, 0.1, name='eta', latex_label=r'$\\eta$')
+alpha = LogUniform(0.1, 1, name='alpha', latex_label=r'$\\alpha$')
+beta = Uniform(1, 5, name='beta', latex_label=r'$\\beta$')