redback 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

redback/likelihoods.py

@@ -3,11 +3,13 @@ from typing import Any, Union
 
 import bilby
 from scipy.special import gammaln
-
+from redback.utils import logger
+from bilby.core.prior import DeltaFunction, Constraint
 
 class _RedbackLikelihood(bilby.Likelihood):
 
-    def __init__(self, x: np.ndarray, y: np.ndarray, function: callable, kwargs: dict = None) -> None:
+    def __init__(self, x: np.ndarray, y: np.ndarray, function: callable, kwargs: dict = None, priors=None,
+                 fiducial_parameters=None) -> None:
         """
 
         :param x: The x values.
@@ -18,11 +20,19 @@ class _RedbackLikelihood(bilby.Likelihood):
         :type function: callable
         :param kwargs: Any additional keywords for 'function'.
         :type kwargs: Union[dict, None]
+        :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]
         """
         self.x = x
         self.y = y
         self.function = function
         self.kwargs = kwargs
+        self.priors = priors
+        self.fiducial_parameters = fiducial_parameters
 
         parameters = bilby.core.utils.introspection.infer_parameters_from_function(func=function)
         super().__init__(parameters=dict.fromkeys(parameters))
@@ -46,11 +56,81 @@ class _RedbackLikelihood(bilby.Likelihood):
         """
         return len(self.x)
 
+    @property
+    def parameters_to_be_updated(self):
+        if self.priors is None:
+            return None
+        else:
+            parameters_to_be_updated = [key for key in self.priors if not isinstance(
+                self.priors[key], (DeltaFunction, Constraint, float, int))]
+            return parameters_to_be_updated
+
+    def get_parameter_dictionary_from_list(self, parameter_list):
+        parameter_dictionary = dict(zip(self.parameters_to_be_updated, parameter_list))
+        excluded_parameter_keys = set(self.fiducial_parameters) - set(self.parameters_to_be_updated)
+        for key in excluded_parameter_keys:
+            parameter_dictionary[key] = self.fiducial_parameters[key]
+        return parameter_dictionary
+
+    def get_parameter_list_from_dictionary(self, parameter_dict):
+        return [parameter_dict[k] for k in self.parameters_to_be_updated]
+
+    def get_bounds_from_priors(self, priors):
+        bounds = []
+        for key in self.parameters_to_be_updated:
+            bounds.append([priors[key].minimum, priors[key].maximum])
+        return bounds
+
+    def lnlike_scipy_maximize(self, parameter_list):
+        self.parameters.update(self.get_parameter_dictionary_from_list(parameter_list))
+        return -self.log_likelihood()
+
+    def find_maximum_likelihood_parameters(self, iterations=5, maximization_kwargs=None, method='Nelder-Mead',
+                                           break_threshold=1e-3):
+        """
+        Estimate the maximum likelihood
+
+        :param iterations: Iterations to run the minimizer for before stopping. Default is 5.
+        :param maximization_kwargs: Any extra keyword arguments passed to the scipy minimize function
+        :param method: Minimize method to use. Default is 'Nelder-Mead'
+        :param break_threshold: The threshold for the difference in log likelihood to break the loop. Default is 1e-3.
+        :return: Dictionary of maximum likelihood parameters
+        """
+        from scipy.optimize import minimize
+        parameter_bounds = self.get_bounds_from_priors(self.priors)
+        if self.priors is None:
+            raise ValueError("Priors must be provided to use this functionality")
+        if maximization_kwargs is None:
+            maximization_kwargs = dict()
+        self.parameters.update(self.fiducial_parameters)
+        self.parameters["fiducial"] = 0
+        updated_parameters_list = self.get_parameter_list_from_dictionary(self.fiducial_parameters)
+        old_fiducial_ln_likelihood = self.log_likelihood()
+        for it in range(iterations):
+            logger.info(f"Optimizing fiducial parameters. Iteration : {it + 1}")
+            output = minimize(
+                self.lnlike_scipy_maximize,
+                x0=updated_parameters_list,
+                bounds=parameter_bounds,
+                method=method,
+                **maximization_kwargs,)
+            updated_parameters_list = output['x']
+            updated_parameters = self.get_parameter_dictionary_from_list(updated_parameters_list)
+            self.parameters.update(updated_parameters)
+            new_fiducial_ln_likelihood = self.log_likelihood_ratio()
+            logger.info(f"Current lnlikelihood: {new_fiducial_ln_likelihood:.2f}")
+            logger.info(f"Updated parameters: {updated_parameters}")
+            if new_fiducial_ln_likelihood - old_fiducial_ln_likelihood < break_threshold:
+                break
+            old_fiducial_ln_likelihood = new_fiducial_ln_likelihood
+        return updated_parameters
+
 
 class GaussianLikelihood(_RedbackLikelihood):
     def __init__(
             self, x: np.ndarray, y: np.ndarray, sigma: Union[float, None, np.ndarray],
-            function: callable, kwargs: dict = None) -> None:
+            function: callable, kwargs: dict = None, priors=None,
+                 fiducial_parameters=None) -> None:
         """A general Gaussian likelihood - the parameters are inferred from the arguments of function.
 
         :param x: The x values.
@@ -67,10 +147,17 @@ class GaussianLikelihood(_RedbackLikelihood):
         :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]
         """
 
         self._noise_log_likelihood = None
-        super().__init__(x=x, y=y, function=function, kwargs=kwargs)
+        super().__init__(x=x, y=y, function=function, kwargs=kwargs, priors=priors,
+                         fiducial_parameters=fiducial_parameters)
         self.sigma = sigma
         if self.sigma is None:
             self.parameters['sigma'] = None
@@ -121,7 +208,8 @@ class GaussianLikelihood(_RedbackLikelihood):
 class GaussianLikelihoodUniformXErrors(GaussianLikelihood):
     def __init__(
             self, x: np.ndarray, y: np.ndarray, sigma: Union[float, None, np.ndarray],
-            bin_size: Union[float, None, np.ndarray], function: callable, kwargs: dict = None) -> None:
+            bin_size: Union[float, None, np.ndarray], function: callable, kwargs: dict = None, priors=None,
+                 fiducial_parameters=None) -> None:
         """A general Gaussian likelihood with uniform errors in x- the parameters are inferred from the
         arguments of function. Takes into account the X errors with a Uniform likelihood between the
         bin high and bin low values. Note that the prior for the true x values must be uniform in this range!
@@ -142,9 +230,16 @@ class GaussianLikelihoodUniformXErrors(GaussianLikelihood):
         :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]
         """
 
-        super().__init__(x=x, y=y, sigma=sigma, function=function, kwargs=kwargs)
+        super().__init__(x=x, y=y, sigma=sigma, function=function, kwargs=kwargs, priors=priors,
+                         fiducial_parameters=fiducial_parameters)
         self.xerr = bin_size * np.ones(self.n)
 
     def noise_log_likelihood(self) -> float:
@@ -183,7 +278,7 @@ class GaussianLikelihoodUniformXErrors(GaussianLikelihood):
 class GaussianLikelihoodQuadratureNoise(GaussianLikelihood):
     def __init__(
             self, x: np.ndarray, y: np.ndarray, sigma_i: Union[float, None, np.ndarray],
-            function: callable, kwargs: dict = None) -> None:
+            function: callable, kwargs: dict = None, priors=None, fiducial_parameters=None) -> None:
         """
         A general Gaussian likelihood - the parameters are inferred from the
         arguments of function
@@ -205,7 +300,8 @@ class GaussianLikelihoodQuadratureNoise(GaussianLikelihood):
         """
         self.sigma_i = sigma_i
         # These lines of code infer the parameters from the provided function
-        super().__init__(x=x, y=y, sigma=sigma_i, function=function, kwargs=kwargs)
+        super().__init__(x=x, y=y, sigma=sigma_i, function=function, kwargs=kwargs, priors=priors,
+                         fiducial_parameters=fiducial_parameters)
 
     @property
     def full_sigma(self) -> Union[float, np.ndarray]:
@@ -231,19 +327,80 @@ class GaussianLikelihoodQuadratureNoise(GaussianLikelihood):
         """
         return np.nan_to_num(self._gaussian_log_likelihood(res=self.residual, sigma=self.full_sigma))
 
+class GaussianLikelihoodWithFractionalNoise(GaussianLikelihood):
+    def __init__(
+            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 noise that is proportional to the model.
+        The parameters are inferred from the arguments of function
+
+        :param x: The x values.
+        :type x: np.ndarray
+        :param y: The y values.
+        :type y: np.ndarray
+        :param sigma_i: The standard deviation of the noise. This is part of the full noise.
+                        The sigma used in the likelihood is sigma = sqrt(sigma_i^2*model_y**2)
+        :type sigma_i: 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]
+        """
+        self.sigma_i = sigma_i
+        # These lines of code infer the parameters from the provided function
+        super().__init__(x=x, y=y, sigma=sigma_i, function=function, kwargs=kwargs, priors=priors,
+                         fiducial_parameters=fiducial_parameters)
+
+    @property
+    def full_sigma(self) -> Union[float, np.ndarray]:
+        """
+        :return: The standard deviation of the full noise
+        :rtype: Union[float, np.ndarray]
+        """
+        model_y = self.function(self.x, **self.parameters, **self.kwargs)
+        return np.sqrt(self.sigma_i**2.*model_y**2)
+
+    def noise_log_likelihood(self) -> float:
+        """
+        :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:
+            self._noise_log_likelihood = self._gaussian_log_likelihood(res=self.y, sigma=self.sigma_i)
+        return self._noise_log_likelihood
+
+    def log_likelihood(self) -> float:
+        """
+        :return: The log-likelihood.
+        :rtype: float
+        """
+        return np.nan_to_num(self._gaussian_log_likelihood(res=self.residual, sigma=self.full_sigma))
+
 class GaussianLikelihoodWithSystematicNoise(GaussianLikelihood):
     def __init__(
             self, x: np.ndarray, y: np.ndarray, sigma_i: Union[float, None, np.ndarray],
-            function: callable, kwargs: dict = None) -> None:
+            function: callable, kwargs: dict = None, priors=None, fiducial_parameters=None) -> None:
         """
-        A general Gaussian likelihood - the parameters are inferred from the
-        arguments of function
+        A Gaussian likelihood with a systematic noise term that is proportional to the model + some additive noise.
+        The parameters are inferred from the arguments of function
 
+        :param x: The x values.
         :type x: np.ndarray
         :param y: The y values.
         :type y: np.ndarray
         :param sigma_i: The standard deviation of the noise. This is part of the full noise.
-                        The sigma used in the likelihood is sigma = sqrt(sigma_i^2 + sigma^2)
+                        The sigma used in the likelihood is sigma = sqrt(sigma_i^2 + model_y**2*sigma^2)
         :type sigma_i: Union[float, None, np.ndarray]
         :param function:
             The python function to fit to the data. Note, this must take the
@@ -253,10 +410,17 @@ class GaussianLikelihoodWithSystematicNoise(GaussianLikelihood):
         :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]
         """
         self.sigma_i = sigma_i
         # These lines of code infer the parameters from the provided function
-        super().__init__(x=x, y=y, sigma=sigma_i, function=function, kwargs=kwargs)
+        super().__init__(x=x, y=y, sigma=sigma_i, function=function, kwargs=kwargs, priors=priors,
+                         fiducial_parameters=fiducial_parameters)
 
     @property
     def full_sigma(self) -> Union[float, np.ndarray]:
@@ -286,10 +450,11 @@ class GaussianLikelihoodWithSystematicNoise(GaussianLikelihood):
 class GaussianLikelihoodQuadratureNoiseNonDetections(GaussianLikelihoodQuadratureNoise):
     def __init__(
             self, x: np.ndarray, y: np.ndarray, sigma_i: Union[float, np.ndarray], function: callable,
-            kwargs: dict = None, upperlimit_kwargs: dict = None) -> None:
+            kwargs: dict = None, upperlimit_kwargs: dict = None, priors=None, fiducial_parameters=None) -> None:
         """A general Gaussian likelihood - the parameters are inferred from the
         arguments of function. Takes into account non-detections with a Uniform likelihood for those points
 
+        :param x: The x values.
         :type x: np.ndarray
         :param y: The y values.
         :type y: np.ndarray
@@ -304,8 +469,15 @@ class GaussianLikelihoodQuadratureNoiseNonDetections(GaussianLikelihoodQuadratur
         :type function: callable
         :param kwargs: Any additional keywords for 'function'.
         :type kwargs: dict
-        """
-        super().__init__(x=x, y=y, sigma_i=sigma_i, function=function, kwargs=kwargs)
+        :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]
+        """
+        super().__init__(x=x, y=y, sigma_i=sigma_i, function=function, kwargs=kwargs, priors=priors,
+                         fiducial_parameters=fiducial_parameters)
         self.upperlimit_kwargs = upperlimit_kwargs
 
     @property
@@ -345,7 +517,7 @@ class GRBGaussianLikelihood(GaussianLikelihood):
 
     def __init__(
             self, x: np.ndarray, y: np.ndarray, sigma: Union[float, np.ndarray],
-            function: callable, kwargs: dict = None) -> None:
+            function: callable, kwargs: dict = None, priors=None, fiducial_parameters=None) -> None:
         """A general Gaussian likelihood - the parameters are inferred from the
         arguments of function.
 
@@ -363,14 +535,21 @@ class GRBGaussianLikelihood(GaussianLikelihood):
         :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]
         """
-        super().__init__(x=x, y=y, sigma=sigma, function=function, kwargs=kwargs)
+        super().__init__(x=x, y=y, sigma=sigma, function=function, kwargs=kwargs, priors=priors,
+                         fiducial_parameters=fiducial_parameters)
 
 
 class PoissonLikelihood(_RedbackLikelihood):
     def __init__(
             self, time: np.ndarray, counts: np.ndarray, function: callable, integrated_rate_function: bool = True,
-            dt: Union[float, np.ndarray] = None, kwargs: dict = None) -> None:
+            dt: Union[float, np.ndarray] = None, kwargs: dict = None, priors=None, fiducial_parameters=None) -> None:
         """
         :param time: The time values.
         :type time: np.ndarray
@@ -389,8 +568,15 @@ class PoissonLikelihood(_RedbackLikelihood):
         :type dt: Union[float, None, np.ndarray]
         :param kwargs: Any additional keywords for 'function'.
         :type kwargs: dict
-        """
-        super(PoissonLikelihood, self).__init__(x=time, y=counts, function=function, kwargs=kwargs)
+        :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]
+        """
+        super(PoissonLikelihood, self).__init__(x=time, y=counts, function=function, kwargs=kwargs, priors=priors,
+                                               fiducial_parameters=fiducial_parameters)
         self.integrated_rate_function = integrated_rate_function
         self.dt = dt
         self.parameters['background_rate'] = 0

redback/plotting.py

@@ -346,7 +346,7 @@ class IntegratedFluxPlotter(Plotter):
                 axes.plot(times, ys, 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)
+            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)
 
@@ -391,11 +391,11 @@ class LuminosityPlotter(IntegratedFluxPlotter):
 
 class MagnitudePlotter(Plotter):
 
-    xlim_low_phase_model_multiplier = 0.9
-    xlim_high_phase_model_multiplier = 1.1
-    xlim_high_multiplier = 1.2
-    ylim_low_magnitude_multiplier = 0.8
-    ylim_high_magnitude_multiplier = 1.2
+    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.8)
+    ylim_high_magnitude_multiplier = KwargsAccessorWithDefault("ylim_high_multiplier", 1.2)
     ncols = KwargsAccessorWithDefault("ncols", 2)
 
     @property
@@ -551,7 +551,7 @@ class MagnitudePlotter(Plotter):
                 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] + 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)
             else:
@@ -635,11 +635,11 @@ class MagnitudePlotter(Plotter):
             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))
+                        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))
+                        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))
+                    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)
@@ -789,7 +789,7 @@ class MagnitudePlotter(Plotter):
                     axes[ii].plot(times - self._reference_mjd_date, random_ys, color=color_sample,
                                   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)
+                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)

redback/priors/csm_interaction.prior

@@ -1,10 +1,9 @@
 redshift = Uniform(1e-3,3,name='redshift', latex_label = r'$z$')
-mej = LogUniform(1e-4, 100, 'mej', latex_label = r'$M_{\mathrm{ej} }~(M_\odot)$')
-csm_mass = LogUniform(1e-4, 100, 'csm_mass', latex_label = r'$M_{\mathrm{csm}}~(M_\odot)$')
+mej = LogUniform(1, 100, 'mej', latex_label = r'$M_{\mathrm{ej} }~(M_\odot)$')
+csm_mass = LogUniform(1, 100, 'csm_mass', latex_label = r'$M_{\mathrm{csm}}~(M_\odot)$')
 vej = LogUniform(1e3, 1e5, 'vej', latex_label = r'$v_{\mathrm{ej}}~(\mathrm{km}/\mathrm{s})$')
-eta = Uniform(0, 1, '\\eta', latex_label = r'$\\eta$')
-rho = Uniform(8, 12, 'rho', latex_label = r'$\\rho$')
-r0 = Uniform(4, 8, 'r0', latex_label=r'$r_0~({\mathrm{AU}})$')
+eta = Uniform(0, 2, '\\eta', latex_label = r'$\\eta$')
+rho = LogUniform(1e-14, 1e-12, 'rho', latex_label = r'$\\rho$')
+r0 = Uniform(50, 700, 'r0', latex_label=r'$r_0~({\mathrm{AU}})$')
 kappa = Uniform(0.05, 2, 'kappa', latex_label = r'$\\kappa~(\mathrm{cm}^{2}/\mathrm{g})$')
-kappa_gamma = LogUniform(1e-4, 1e4, 'kappa_gamma', latex_label = r'$\\kappa_{\\gamma}~(\mathrm{cm}^{2}/\mathrm{g})$')
-temperature_floor = LogUniform(1e3,1e5,name = 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')
+temperature_floor = LogUniform(100,1e4,name = 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')

redback/priors/csm_nickel.prior

@@ -3,9 +3,9 @@ mej = LogUniform(1e-4, 100, 'mej', latex_label = r'$M_{\mathrm{ej} }~(M_\odot)$'
 f_nickel = LogUniform(1e-3,1,name='f_nickel', latex_label = r'$f_{\mathrm{Ni}}$')
 csm_mass = LogUniform(1e-4, 100, 'csm_mass', latex_label = r'$M_{\mathrm{csm}}~(M_\odot)$')
 ek = LogUniform(1e48, 1e52, 'ek', latex_label = r'$E_{\mathrm{kin}}~(\mathrm{ erg})$')
-eta = Uniform(0, 1, '\\eta', latex_label = r'$\\eta$')
-rho = Uniform(8, 12, 'rho', latex_label = r'$\\rho$')
+eta = Uniform(0, 2, '\\eta', latex_label = r'$\\eta$')
+rho = LogUniform(1e-15, 1e-12, 'rho', latex_label = r'$\\rho$')
 r0 = Uniform(4, 8, 'r0', latex_label=r'$r_0~({\mathrm{AU}})$')
 kappa = Uniform(0.05, 2, 'kappa', latex_label = r'$\\kappa~(\mathrm{cm}^{2}/\mathrm{g})$')
 kappa_gamma = LogUniform(1e-4, 1e4, 'kappa_gamma', latex_label = r'$\\kappa_{\\gamma}~(\mathrm{cm}^{2}/\mathrm{g})$')
-temperature_floor = LogUniform(1e3,1e5,name = 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')
+temperature_floor = LogUniform(100,1e4,name = 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')

redback/priors/one_comp_kne_rosswog_heatingrate.prior

@@ -0,0 +1,5 @@
+redshift = Uniform(1e-6, 0.1, 'redshift', latex_label = r'$z$')
+mej = Uniform(1e-2, 0.05, 'mej', latex_label = r'$M_{\mathrm{ej} }~(M_\odot)$')
+vej = Uniform(0.05, 0.3, 'vej', latex_label = r'$v_{\mathrm{ej}}~(c)$')
+ye = Uniform(0.05, 0.4, 'ye', latex_label = r'$Y_{e}$')
+temperature_floor = LogUniform(100, 6000, 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')

redback/priors/one_component_nsbh_ejecta_relation.prior

@@ -1,7 +1,7 @@
 redshift = Uniform(1e-3, 0.1, 'redshift', latex_label = r'$z$')
 mass_bh = Uniform(2.5, 35, 'mass_bh', latex_label = r'$M_1~(M_\odot)$')
 mass_ns = Uniform(1.1, 2.1, 'mass_ns', latex_label = r'$M_2~(M_\odot)$')
-chi_eff = Uniform(0, 1, 'chi_eff', latex_label = r'$\chi_{\mathrm{eff}}$')
+chi_bh = Uniform(0, 0.99, 'chi_bh', latex_label = r'$\chi_{\mathrm{bh}}$')
 lambda_ns = Uniform(0, 5000, 'lambda_2', latex_label = r'$\Lambda_{\mathrm{NS}}$')
 kappa = Uniform(1, 30, 'kappa', latex_label = r'$\\kappa~(\mathrm{cm}^{2}/\mathrm{g})$')
 temperature_floor = LogUniform(100, 6000, 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')

redback/priors/tde_analytical.prior

@@ -1,8 +1,8 @@
 redshift = Uniform(0.01, 3, 'redshift', latex_label=r'$z$')
-mej = LogUniform(1e-4, 100, 'mej', latex_label = r'$M_{\mathrm{ej} }~(M_\odot)$')
+mej = LogUniform(0.1, 100, 'mej', latex_label = r'$M_{\mathrm{ej} }~(M_\odot)$')
 vej = LogUniform(1e3, 1e5, 'vej', latex_label = r'$v_{\mathrm{ej}}~(\mathrm{km}/\mathrm{s})$')
-kappa = Uniform(0.05, 2, 'kappa', latex_label = r'$\\kappa~(\mathrm{cm}^{2}/\mathrm{g})$')
+kappa = Uniform(0.05, 1e2, 'kappa', latex_label = r'$\\kappa~(\mathrm{cm}^{2}/\mathrm{g})$')
 kappa_gamma = LogUniform(1e-4, 1e4, 'kappa_gamma', latex_label = r'$\\kappa_{\\gamma}~(\mathrm{cm}^{2}/\mathrm{g})$')
-temperature_floor = LogUniform(1e3,1e5,name = 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')
-l0 = LogUniform(1e51, 1e58, "l0", latex_label="$l_0$")
-t_0_turn = LogUniform(1e-4, 1e2, "t_0_turn", latex_label="$t_{0 t}$")
+temperature_floor = LogUniform(1e3,1e4,name = 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')
+l0 = LogUniform(1e51, 1e60, "l0", latex_label="$l_0$")
+t_0_turn = LogUniform(1e-4, 5e2, "t_0_turn", latex_label="$t_{0 t}$")

redback/priors/tde_analytical_bolometric.prior

@@ -1,6 +1,8 @@
-mej = LogUniform(1e-4, 100, 'mej', latex_label = r'$M_{\mathrm{ej} }~(M_\odot)$')
+redshift = Uniform(0.01, 3, 'redshift', latex_label=r'$z$')
+mej = LogUniform(0.1, 100, 'mej', latex_label = r'$M_{\mathrm{ej} }~(M_\odot)$')
 vej = LogUniform(1e3, 1e5, 'vej', latex_label = r'$v_{\mathrm{ej}}~(\mathrm{km}/\mathrm{s})$')
-kappa = Uniform(0.05, 2, 'kappa', latex_label = r'$\\kappa~(\mathrm{cm}^{2}/\mathrm{g})$')
+kappa = Uniform(0.05, 1e2, 'kappa', latex_label = r'$\\kappa~(\mathrm{cm}^{2}/\mathrm{g})$')
 kappa_gamma = LogUniform(1e-4, 1e4, 'kappa_gamma', latex_label = r'$\\kappa_{\\gamma}~(\mathrm{cm}^{2}/\mathrm{g})$')
-l0 = LogUniform(1e51, 1e58, "l0", latex_label="$l_0$")
-t_0_turn = LogUniform(1e-4, 1e2, "t_0_turn", latex_label="$t_{0 t}$")
+temperature_floor = LogUniform(1e3,1e4,name = 'temperature_floor', latex_label = r'$T_{\mathrm{floor}}~(\mathrm{K})$')
+l0 = LogUniform(1e51, 1e60, "l0", latex_label="$l_0$")
+t_0_turn = LogUniform(1e-4, 5e2, "t_0_turn", latex_label="$t_{0 t}$")

redback/priors/tophat_from_emulator.prior

@@ -0,0 +1,9 @@
+redshift = Uniform(0.01, 3, 'redshift', latex_label=r'$z$')
+thv = Sine(name='thv', maximum=np.pi/2, latex_label=r'$\\theta_{\mathrm{observer}}~(\mathrm{rad})$')
+loge0 = Uniform(44, 54, 'loge0', latex_label=r'$\log_{10}~E_{0} / {\mathrm{erg}}$')
+thc = Uniform(0.01, 0.1, 'thc', latex_label=r'$\\theta_{\mathrm{core}}~({\mathrm{rad}})$')
+logn0 = Uniform(-5, 2, 'logn0', latex_label=r'$\log_{10}~n_{\mathrm{ism}} / {\mathrm{cm}}^{-3}$')
+p = Uniform(2, 3, 'p', latex_label=r'$p$')
+logepse = Uniform(-5, 0, 'logepse', latex_label=r'$\log_{10}~\\epsilon_{e}$')
+logepsb = Uniform(-5, 0, 'logepsb', latex_label=r'$\log_{10}~\\epsilon_{B}$')
+g0 = Uniform(100,2000, 'g0', latex_label=r'$\\Gamma_{0}$')

redback/priors/two_comp_kne_rosswog_heatingrate.prior

@@ -0,0 +1,9 @@
+redshift = Uniform(1e-6, 0.1, 'redshift', latex_label = r'$z$')
+mej_1 = Uniform(1e-2, 0.05, 'mej', latex_label = r'$M_{\mathrm{ej}~1}~(M_\odot)$')
+vej_1 = Uniform(0.05, 0.3, 'vej', latex_label = r'$v_{\mathrm{ej}~1}~(c)$')
+ye_1 = Uniform(0.05, 0.4, 'ye', latex_label = r'$Y_{e}~1$')
+temperature_floor_1 = LogUniform(100, 6000, 'temperature_floor', latex_label = r'$T_{\mathrm{floor}~1}~(\mathrm{K})$')
+mej_2 = Uniform(1e-2, 0.05, 'mej', latex_label = r'$M_{\mathrm{ej}~2}~(M_\odot)$')
+vej_2 = Uniform(0.05, 0.3, 'vej', latex_label = r'$v_{\mathrm{ej}~2}~(c)$')
+ye_2 = Uniform(0.05, 0.4, 'ye', latex_label = r'$Y_{e}~2$')
+temperature_floor_2 = LogUniform(100, 6000, 'temperature_floor', latex_label = r'$T_{\mathrm{floor}~2}~(\mathrm{K})$')

redback/priors/two_component_nsbh_ejecta_relation.prior

@@ -1,7 +1,7 @@
 redshift = Uniform(1e-3, 0.1, 'redshift', latex_label = r'$z$')
 mass_bh = Uniform(2.5, 35, 'mass_bh', latex_label = r'$M(\mathrm{BH})~(M_\odot)$')
 mass_ns = Uniform(1.1, 2.1, 'mass_ns', latex_label = r'$M(\mathrm{NS})~(M_\odot)$')
-chi_eff = Uniform(0, 1, 'chi_eff', latex_label = r'$\\chi_{\mathrm{eff}}$')
+chi_bh = Uniform(0, 0.99, 'chi_eff', latex_label = r'$\\chi_{\mathrm{bh}}$')
 lambda_ns = Uniform(0, 5000, 'lambda_2', latex_label = r'$\\Lambda_{\mathrm{NS}}$')
 zeta = Uniform(0.05, 0.6, 'zeta', latex_label = r'$\\zeta$')
 vej_2 = Uniform(0.01, 0.3, 'vej', latex_label = r'$v_{\mathrm{ej}~2}~(c)$')

redback/priors/two_layer_stratified_kilonova.prior

@@ -3,4 +3,4 @@ mej = Uniform(1e-2, 0.05, 'mej', latex_label = r'$M_{\mathrm{ej}}~(M_\odot)$')
 vej_1 = Uniform(0.05, 0.2, 'vej_1', latex_label = r'$v_{\mathrm{ej}~1}~(c)$')
 vej_2 = Uniform(0.3, 0.5, 'vej_2', latex_label = r'$v_{\mathrm{ej}~2}~(c)$')
 kappa = Uniform(1, 30, 'kappa', latex_label = r'$\\kappa~(\mathrm{cm}^{2}/\mathrm{g})$')
-beta = Uniform(1.5, 8, 'beta', latex_label = r'$\\beta$')
+beta = Uniform(3.1, 8, 'beta', latex_label = r'$\\beta$')

redback/priors.py

@@ -9,6 +9,17 @@ from redback.utils import logger
 
 
 def get_priors(model, times=None, y=None, yerr=None, dt=None, **kwargs):
+    """
+    Get the prior for the given model. If the model is a prompt model, the times, y, and yerr must be provided.
+
+    :param model: String referring to a name of a model implemented in Redback.
+    :param times: Time array
+    :param y: Y values, arbitrary units
+    :param yerr: Error on y values, arbitrary units
+    :param dt: time interval
+    :param kwargs: Extra arguments to be passed to the prior function
+    :return: priors: PriorDict object
+    """
     prompt_prior_functions = dict(gaussian=get_gaussian_priors, skew_gaussian=get_skew_gaussian_priors,
                                   skew_exponential=get_skew_exponential_priors, fred=get_fred_priors,
                                   fred_extended=get_fred_extended_priors)