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

redback/__init__.py

@@ -2,3 +2,7 @@ from redback import analysis, constants, get_data, redback_errors, priors, resul
     transient_models, utils, photosphere, sed, interaction_processes, constraints, plotting, model_library, simulate_transients
 from redback.transient import afterglow, kilonova, prompt, supernova, tde
 from redback.sampler import fit_model
+from redback.utils import setup_logger
+
+__version__ = "1.0.2"
+setup_logger(log_level='info')

redback/constraints.py

@@ -2,6 +2,7 @@ import numpy as np
 import redback.eos as eos
 from redback.constants import *
 from redback.utils import calc_tfb
+from scipy.interpolate import interp1d
 
 def slsn_constraint(parameters):
     """
@@ -23,7 +24,7 @@ def slsn_constraint(parameters):
     neutrino_energy = 1e51
     total_energy = kinetic_energy + neutrino_energy
     # ensure rotational energy is greater than total output energy
-    converted_parameters['erot_constraint'] = rotational_energy - total_energy
+    converted_parameters['erot_constraint'] = total_energy/rotational_energy
     # ensure t_nebula is greater than 100 days
     converted_parameters['t_nebula_min'] = tnebula - 100
     return converted_parameters
@@ -43,7 +44,7 @@ def basic_magnetar_powered_sn_constraints(parameters):
     kinetic_energy = 0.5 * mej * vej**2
     rotational_energy = 2.6e52 * (mass_ns/1.4)**(3./2.) * p0**(-2)
     # ensure rotational energy is greater than total output energy
-    converted_parameters['erot_constraint'] = rotational_energy - kinetic_energy
+    converted_parameters['erot_constraint'] = kinetic_energy/rotational_energy
     return converted_parameters
 
 def general_magnetar_powered_sn_constraints(parameters):
@@ -61,7 +62,7 @@ def general_magnetar_powered_sn_constraints(parameters):
     tau = parameters['tsd']
     rotational_energy = 2*l0*tau
     # ensure rotational energy is greater than total output energy
-    converted_parameters['erot_constraint'] = rotational_energy - kinetic_energy
+    converted_parameters['erot_constraint'] = kinetic_energy/rotational_energy
     return converted_parameters
     
 def general_magnetar_powered_supernova_constraints(parameters):
@@ -77,7 +78,7 @@ def general_magnetar_powered_supernova_constraints(parameters):
     nn = parameters['nn']    
     rotational_energy = (nn-1)*l0*tau/2.0
     # ensure rotational energy is less than the maximum spin down energy
-    converted_parameters['erot_constraint'] = 1e53 - rotational_energy
+    converted_parameters['erot_constraint'] = rotational_energy/1e53
     return converted_parameters    
 
 def tde_constraints(parameters):
@@ -91,7 +92,7 @@ def tde_constraints(parameters):
     rp = parameters['pericenter_radius']
     mass_bh = parameters['mass_bh']
     schwarzchild_radius = (2 * graviational_constant * mass_bh * solar_mass /(speed_of_light**2))/au_cgs
-    converted_parameters['disruption_radius'] = rp - schwarzchild_radius
+    converted_parameters['disruption_radius'] = schwarzchild_radius/rp
     return converted_parameters
 
 def gaussianrise_tde_constraints(parameters):
@@ -103,13 +104,11 @@ def gaussianrise_tde_constraints(parameters):
     converted_parameters = parameters.copy()
     ms = parameters['stellar_mass']
     mbh6 = parameters['mbh_6']
-    etamin = 0.01*(ms**(-7./15.))*(mbh6**(2./3.))
     betamax = 12.*(ms**(7./15.))*(mbh6**(-2./3.))
     tfb = calc_tfb(binding_energy_const=0.8, mbh_6=mbh6,stellar_mass=ms)/86400
     tfb_obs = tfb * (1 + parameters['redshift'])
-    converted_parameters['eta_low'] = converted_parameters['eta'] - etamin
-    converted_parameters['beta_high'] = betamax - converted_parameters['beta']
-    converted_parameters['tfb_max'] = tfb_obs - converted_parameters['peak_time']
+    converted_parameters['beta_high'] = converted_parameters['beta']/betamax
+    converted_parameters['tfb_max'] = converted_parameters['peak_time']/tfb_obs
     return converted_parameters
 
 def nuclear_burning_constraints(parameters):
@@ -126,7 +125,7 @@ def nuclear_burning_constraints(parameters):
     kinetic_energy = 0.5 * mej * (vej / 2.0) ** 2
     excess_constant = -(56.0 / 4.0 * 2.4249 - 53.9037) / proton_mass * mev_cgs
     emax = excess_constant * mej * fnickel
-    converted_parameters['emax_constraint'] = emax - kinetic_energy
+    converted_parameters['emax_constraint'] = kinetic_energy/emax
     return converted_parameters
 
 def simple_fallback_constraints(parameters):
@@ -149,7 +148,7 @@ def simple_fallback_constraints(parameters):
     neutrino_energy = 1e51
     total_energy = e_fallback + neutrino_energy
     # ensure total energy is greater than kinetic energy
-    converted_parameters['en_constraint'] = total_energy - kinetic_energy
+    converted_parameters['en_constraint'] = kinetic_energy/total_energy
     # ensure t_nebula is greater than 100 days
     converted_parameters['t_nebula_min'] = tnebula - 100
     return converted_parameters
@@ -162,15 +161,18 @@ def csm_constraints(parameters):
     :param parameters: dictionary of parameters
     :return: converted_parameters dictionary where the violated samples are thrown out
     """
-    from redback.utils import get_csm_properties
     converted_parameters = parameters.copy()
     mej = parameters['mej']
     csm_mass = parameters['csm_mass']
     kappa = parameters['kappa']
     r0 = parameters['r0']
     vej = parameters['vej']
-    nn = parameters.get('nn', np.ones(len(mej)) * 12.)
-    delta = parameters.get('delta', np.ones(len(mej)))
+    if hasattr(parameters['mej'], "__len__"):
+        nn = parameters.get('nn', np.ones(len(mej)) * 8.)
+        delta = parameters.get('delta', np.ones(len(mej)))
+    else:
+        nn = parameters.get('nn', 12.)
+        delta = parameters.get('delta', 0.)
     eta = parameters['eta']
     rho = parameters['rho']
 
@@ -180,12 +182,16 @@ def csm_constraints(parameters):
     vej = vej * km_cgs
     Esn = 3. * vej ** 2 * mej / 10.
 
-    AA = np.zeros(len(mej))
-    Bf = np.zeros(len(mej))
-    for x in range(len(mej)):
-        csm_properties = get_csm_properties(nn[x], eta[x])
-        AA[x] = csm_properties.AA
-        Bf[x] = csm_properties.Bf
+    ns = [6, 7, 8, 9, 10, 12, 14]
+    Bfs = [1.377, 1.299, 1.267, 1.250, 1.239, 1.226, 1.218]
+    As = [0.62, 0.27, 0.15, 0.096, 0.067, 0.038, 0.025]
+
+    Bf_func = interp1d(ns, Bfs)
+    A_func = interp1d(ns, As)
+
+    Bf = Bf_func(nn)
+    AA = A_func(nn)
+
     qq = rho * r0 ** eta
     # outer CSM shell radius
     radius_csm = ((3.0 - eta) / (4.0 * np.pi * qq) * csm_mass + r0 ** (3.0 - eta)) ** (
@@ -203,14 +209,14 @@ def csm_constraints(parameters):
                    (3.0 - delta) * (nn - 3.0) * mej) ** ((nn - 5.0) / 2.0))
 
     tshock = ((radius_csm - r0) / Bf / (AA * g_n / qq) ** (
-                       1. / (nn - eta))) ** ((nn - eta) /(nn - 3))
+                       1. / (nn - eta))) ** ((nn - eta) / (nn - 3))
 
-    diffusion_time = np.sqrt(2. * kappa * mass_csm_threshold /(vej * 13.7 * 3.e10))
+    diffusion_time = np.sqrt(2. * kappa * mass_csm_threshold / (vej * 13.7 * 3.e10))
     # ensure shock crossing time is greater than diffusion time
-    # converted_parameters['shock_time'] = tshock - diffusion_time
+    converted_parameters['shock_time'] = diffusion_time/tshock
     # ensure photospheric radius is within the csm i.e., r_photo < radius_csm and r_photo > r0
-    converted_parameters['photosphere_constraint_1'] = radius_csm - r_photosphere
-    converted_parameters['photosphere_constraint_2'] = r_photosphere - r0
+    converted_parameters['photosphere_constraint_1'] = r_photosphere/radius_csm
+    converted_parameters['photosphere_constraint_2'] = r0/r_photosphere
     return converted_parameters
 
 def piecewise_polytrope_eos_constraints(parameters):

redback/get_data/lasair.py

@@ -58,8 +58,8 @@ class LasairDataGetter(DataGetter):
                 f"Are you sure you are using the right alias?")
         data = pd.read_html(self.url)
         data = data[1]
-        data['diff_magnitude'] = [data['magpsf'].iloc[x].split(" ")[0] for x in range(len(data))]
-        data['diff_magnitude_error'] = [data['magpsf'].iloc[x].split(" ")[-1] for x in range(len(data))]
+        data['diff_magnitude'] = [data['unforced mag'].iloc[x].split(" ")[0] for x in range(len(data))]
+        data['diff_magnitude_error'] = [data['unforced mag'].iloc[x].split(" ")[-1] for x in range(len(data))]
 
         logger.warning('Using the difference magnitude to calculate quantities. '
                        'Reduce the data yourself if you would like to use a reference magnitude')
@@ -67,7 +67,6 @@ class LasairDataGetter(DataGetter):
         # Change the dataframe to the correct raw dataframe format
         del data['UTC']
         del data['images']
-        del data['magpsf']
         data.to_csv(self.raw_file_path, index=False)
         logger.info(f"Retrieved data for {self.transient}.")
 
@@ -83,7 +82,7 @@ class LasairDataGetter(DataGetter):
             return pd.read_csv(self.processed_file_path)
 
         raw_data = pd.read_csv(self.raw_file_path)
-        raw_data = raw_data[raw_data['difference flux status'] != 'limit']
+        raw_data = raw_data[raw_data['unforced mag status'] != 'limit']
         lasair_to_general_bands = {"g": "ztfg", "r": "ztfr", "i":'ztfi'}
         processed_data = pd.DataFrame()
 

redback/get_data/swift.py

@@ -199,9 +199,9 @@ class SwiftDataGetter(GRBDataGetter):
         driver = fetch_driver()
         try:
             driver.get(self.grb_website)
-            driver.find_element_by_xpath("//select[@name='xrtsub']/option[text()='no']").click()
+            driver.find_element("xpath", "//select[@name='xrtsub']/option[text()='no']").click()
             time.sleep(20)
-            driver.find_element_by_id("xrt_DENSITY_makeDownload").click()
+            driver.find_element("id","xrt_DENSITY_makeDownload").click()
             time.sleep(20)
             grb_url = driver.current_url
             # scrape the data
@@ -227,19 +227,19 @@ class SwiftDataGetter(GRBDataGetter):
             # select option for BAT bin_size
             bat_binning = 'batxrtbin'
             if check_element(driver, bat_binning):
-                driver.find_element_by_xpath("//select[@name='batxrtbin']/option[text()='SNR 4']").click()
+                driver.find_element("xpath", "//select[@name='batxrtbin']/option[text()='SNR 4']").click()
             # select option for subplot
             subplot = "batxrtsub"
             if check_element(driver, subplot):
-                driver.find_element_by_xpath("//select[@name='batxrtsub']/option[text()='no']").click()
+                driver.find_element("xpath","//select[@name='batxrtsub']/option[text()='no']").click()
             # Select option for flux density
             flux_density1 = "batxrtband1"
             flux_density0 = "batxrtband0"
             if (check_element(driver, flux_density1)) and (check_element(driver, flux_density0)):
-                driver.find_element_by_xpath(".//*[@id='batxrtband1']").click()
-                driver.find_element_by_xpath(".//*[@id='batxrtband0']").click()
+                driver.find_element("xpath",".//*[@id='batxrtband1']").click()
+                driver.find_element("xpath",".//*[@id='batxrtband0']").click()
             # Generate data file
-            driver.find_element_by_xpath(".//*[@id='batxrt_XRTBAND_makeDownload']").click()
+            driver.find_element("xpath",".//*[@id='batxrt_XRTBAND_makeDownload']").click()
             time.sleep(20)
             grb_url = driver.current_url
             driver.quit()

redback/interaction_processes.py

@@ -165,8 +165,6 @@ class CSMDiffusion(object):
         # photosphere radius
         r_photosphere = self.r_photosphere
 
-        tau_diff = (self.kappa * self.csm_mass) / (13.8 * speed_of_light * r_photosphere) / day_to_s
-
         # mass of the optically thick CSM (tau > 2/3).
         mass_csm_threshold = self.mass_csm_threshold
 
@@ -180,7 +178,7 @@ class CSMDiffusion(object):
         lu = len(uniq_times)
 
         num = int(round(timesteps / 2.0))
-        lsp = np.logspace(np.log10(tau_diff /self.dense_times[-1]) + minimum_log_spacing, 0, num)
+        lsp = np.logspace(np.log10(t0 /self.dense_times[-1]) + minimum_log_spacing, 0, num)
         xm = np.unique(np.concatenate((lsp, 1 - lsp)))
 
         int_times = tb + (uniq_times.reshape(lu, 1) - tb) * xm
@@ -192,7 +190,6 @@ class CSMDiffusion(object):
 
         uniq_lums = np.trapz(int_args, int_times, axis=1)
         uniq_lums *= np.exp(-int_tes/t0)/t0
-
         new_lums = uniq_lums[np.searchsorted(uniq_times, self.time)]
         return new_lums
 

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