ExoIris 0.23.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

exoiris/prtretrieval.py

@@ -0,0 +1,164 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2025 Hannu Parviainen
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import io
+import warnings
+from contextlib import redirect_stdout
+import numpy as np
+
+from petitRADTRANS.radtrans import Radtrans
+from petitRADTRANS import physical_constants as cst
+from petitRADTRANS.spectral_model import SpectralModel
+from petitRADTRANS.retrieval.data import Data
+
+with warnings.catch_warnings():
+    warnings.simplefilter('ignore')
+    from exoiris.exoiris import ExoIris
+    from pytransit.lpf.logposteriorfunction import LogPosteriorFunction
+    from pytransit.param import ParameterSet, GParameter, UniformPrior as UP, NormalPrior as NP
+
+class PRTRetrieval(LogPosteriorFunction):
+    def __init__(self, name: str, line_species, ei: ExoIris, rstar: float, mplanet: float, temperature_profile='isothermal',
+                 pres: int = 100, r: int | None = None, quiet: bool = False):
+        super().__init__(name)
+        self._line_names = line_species
+        if r is None:
+            self.line_species = line_species
+        else:
+            self.line_species = [ls + f'.R{r}' for ls in line_species]
+
+        self.rstar = rstar
+        self.mplanet = mplanet
+        self.temperature_profile = temperature_profile
+        self.pres = pres
+        self.ei = ei
+        self.r = r
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            if quiet:
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    self._create_model()
+            else:
+                self._create_model()
+
+        self._init_parameters()
+
+        self.wavelengths = self.model()[0]
+        self._loglike = ei.create_loglikelihood_function(self.wavelengths, 'radius_ratio', method='svd')
+
+    def _init_parameters(self):
+        self.ps = ParameterSet([])
+        self._init_p_planet()
+        self._init_p_temperature()
+        self._init_p_clouds()
+        self._init_p_species()
+
+    def _init_p_planet(self):
+        self.ps.thaw()
+        ps = [GParameter('radius', 'Planet radius', 'R_Jup', NP(1.3, 0.05), (0.0, 2.5)),
+              GParameter('logg', 'Planet log g', '', UP(2, 4), (2, 4))]
+        self.ps.add_global_block('planet', ps)
+        self.ps.freeze()
+        self._sl_planet = self.ps.blocks[-1].slice
+        self._st_planet = self.ps.blocks[-1].start
+
+    def _init_p_clouds(self):
+        self.ps.thaw()
+        ps = [GParameter('pc', 'Cloud top pressure', '', UP(-6, 2), (-6, 2))]
+        self.ps.add_global_block('clouds', ps)
+        self.ps.freeze()
+        self._sl_clouds = self.ps.blocks[-1].slice
+        self._st_clouds = self.ps.blocks[-1].start
+
+    def _init_p_temperature(self):
+        self.ps.thaw()
+        if self.temperature_profile == 'isothermal':
+            ps = [GParameter('tp_teq', 'equilibrium temperature', 'K', UP(800, 1200), (500, 3500))]
+        elif self.temperature_profile == 'guillot':
+            ps = [GParameter('tp_teq', 'equilibrium temperature', 'K', UP(800, 1200), (500, 3500)),
+                  GParameter('tp_tin', 'intrinsinc temperature', 'K', UP(800, 1200), (500, 3500)),
+                  GParameter('tp_mo', 'guillot profile mean opacity', 'K', UP(0, 1), (0, 1)),
+                  GParameter('tp_g', 'guillot profile gamma', 'K', UP(0, 1), (0, 1))]
+        self.ps.add_global_block('temperature_profile', ps)
+        self._sl_tprof = self.ps.blocks[-1].slice
+        self._st_tprof = self.ps.blocks[-1].start
+
+    def _init_p_species(self):
+        self.ps.thaw()
+        ps = [GParameter(n, n, '', UP(-12, -0.2), [-12, 0]) for n in self.line_species]
+        self.ps.add_global_block('line_species', ps)
+        self.ps.freeze()
+        self._sl_species = self.ps.blocks[-1].slice
+        self._st_species = self.ps.blocks[-1].start
+
+    def _c_temperature_profile(self, pv) -> dict:
+        pv = pv[self._sl_tprof]
+        pars = {}
+        pars['temperature'] = pv[0]
+        if self.temperature_profile == 'isothermal':
+            pass
+        elif self.temperature_profile == 'guillot':
+            pars['intrinsic_temperature'] = pv[1]
+            pars['guillot_temperature_profile_infrared_mean_opacity_solar_metallicity'] = pv[2]
+            pars['guillot_temperature_profile_gamma'] = pv[3]
+        return pars
+
+    def _create_model(self):
+        self.sm = SpectralModel(
+            pressures=np.logspace(-6, 2, self.pres),
+            line_species=self.line_species,
+            rayleigh_species=['H2', 'He'],
+            gas_continuum_contributors=['H2--H2', 'H2--He'],
+            wavelength_boundaries=[self.ei.data.wlmin, self.ei.data.wlmax],
+            star_radius=self.rstar * cst.r_sun,
+            planet_radius=1.0 * cst.r_jup_mean,
+            planet_mass=self.mplanet * cst.m_jup,
+            reference_gravity=391,
+            reference_pressure=1e-2,
+            temperature_profile=self.temperature_profile,
+            temperature=1000,
+            # cloud_mode='power_law',
+            # power_law_opacity_350nm = 0.01,
+            # power_law_opacity_coefficient = -4.0,
+            # opaque_cloud_top_pressure=1e-3,
+            # cloud_fraction=1.0,
+            haze_factor=100.0,
+            # co_ratio=1,
+            use_equilibrium_chemistry=False,
+            imposed_mass_fractions={s: 1e-4 for s in self.line_species},
+            filling_species={'H2': 37, 'He': 12}
+        )
+
+    def model(self, pv=None):
+        if pv is not None:
+
+            self.sm.model_parameters.update(self._c_temperature_profile(pv))
+            self.sm.model_parameters['planet_radius'] = pv[self._st_planet] * cst.r_jup_mean
+            self.sm.model_parameters['reference_gravity'] = 10 ** pv[self._st_planet + 1]
+            self.sm.model_parameters['opaque_cloud_top_pressure'] = 10 ** pv[self._st_clouds]
+            for i, ls in enumerate(self.line_species):
+                self.sm.model_parameters['imposed_mass_fractions'][ls] = 10 ** pv[self._st_species + i]
+            self.sm.update_spectral_calculation_parameters(**self.sm.model_parameters)
+        wavelengths, radii = self.sm.calculate_spectrum(mode='transmission')
+        return wavelengths[0] * 1e4, radii[0]
+
+    def lnlikelihood(self, pv):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            model_spectrum = self.model(pv)[1]
+        return self._loglike(model_spectrum / (self.rstar * cst.r_sun))

exoiris/spotmodel.py

@@ -36,13 +36,13 @@ from pytransit.stars import create_bt_settl_interpolator, create_husser2013_inte
 from pytransit.param import GParameter, UniformPrior as U
 
 from exoiris.tsdata import TSData
-from exoiris.util import bin2d
+from exoiris.bin1d import bin1d
 
 
 @njit
 def spot_model(x, center, amplitude, fwhm, shape):
-    c = fwhm / 2*(2*log(2))**(1/shape)
-    return amplitude*exp(-(fabs(x-center) / c)**shape)
+    c = log(4)**(1/shape) * fwhm
+    return amplitude*exp(-(2*fabs(x-center) / c)**shape)
 
 
 @njit
@@ -81,7 +81,7 @@ def bin_stellar_spectrum_model(sp: RegularGridInterpolator, data: TSData):
     wl_l_edges = wave - 0.5
     wl_r_edges = wave + 0.5
 
-    bflux = bin2d(flux.T, flux.T, wl_l_edges*1e-3, wl_r_edges*1e-3, vstack([data._wl_l_edges, data._wl_r_edges]).T)[0].T
+    bflux = bin1d(flux.T, flux.T, wl_l_edges*1e-3, wl_r_edges*1e-3, vstack([data._wl_l_edges, data._wl_r_edges]).T)[0].T
     return RegularGridInterpolator((teff, data.wavelength), bflux, bounds_error=False, fill_value=nan)
 
 

exoiris/tsdata.py

@@ -56,12 +56,14 @@ from numpy import (
     ascontiguousarray,
     vstack,
     ones_like,
+    average,
 )
 from pytransit.orbits import fold
 
 from .binning import Binning, CompoundBinning
 from .ephemeris import Ephemeris
-from .util import bin2d
+from .bin1d import bin1d
+from .bin2d import bin2d
 
 
 class TSData:
@@ -603,6 +605,14 @@ class TSData:
         ax.axy2 = axy2
         return fig
 
+    def create_white_light_curve(self, data=None) -> ndarray:
+        """Create a white light curve."""
+        if data is not None and data.shape != self.fluxes.shape:
+            raise ValueError("The data must have the same shape as the 2D flux array.")
+        data = data if data is not None else self.fluxes
+        weights = where(isfinite(data) & isfinite(self.errors), 1/self.errors**2, 0.0)
+        return average(where(isfinite(data), data, 0), axis=0, weights=weights)
+
     def plot_white(self, ax: Axes | None = None, figsize: tuple[float, float] | None = None) -> Figure:
         """Plot a white light curve.
 
@@ -623,7 +633,7 @@ class TSData:
             fig = ax.figure
         tref = floor(self.time.min())
 
-        ax.plot(self.time, nanmean(self.fluxes, 0))
+        ax.plot(self.time, self.create_white_light_curve())
         if self.ephemeris is not None:
             [ax.axvline(tl, ls='--', c='k') for tl in self.ephemeris.transit_limits(self.time.mean())]
 
@@ -677,6 +687,76 @@ class TSData:
         else:
             return TSDataGroup([self]) + other
 
+    def bin(self,
+            wave_binning: Optional[Union[Binning, CompoundBinning]] = None,
+            time_binning: Optional[Union[Binning, CompoundBinning]] = None,
+            wave_nb: Optional[int] = None, wave_bw: Optional[float] = None, wave_r: Optional[float] = None,
+            time_nb: Optional[int] = None, time_bw: Optional[float] = None,
+            estimate_errors: bool = False) -> 'TSData':
+        """Bin the data along the wavelength axis.
+
+        Bin the data along the wavelength and/or time axes. If binning is not specified, a Binning object is created using the
+        minimum and maximum time and wavelength values.
+
+        Parameters
+        ----------
+        binning
+            The binning method to use.
+        nb
+            Number of bins.
+        bw
+            Bin width.
+        r
+            Bin resolution.
+        estimate_errors
+            Should the uncertainties be estimated from the data.
+
+        Returns
+        -------
+        TSData
+        """
+
+        if wave_binning is None and wave_nb is None and wave_bw is None and wave_r is None:
+            return self.bin_time(time_binning, time_nb, time_bw, estimate_errors=estimate_errors)
+        if time_binning is None and time_nb is None and time_bw is None:
+            return self.bin_wavelength(wave_binning, wave_nb, wave_bw, wave_r, estimate_errors=estimate_errors)
+
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', numba.NumbaPerformanceWarning)
+            if wave_binning is None:
+                wave_binning = Binning(self.bbox_wl[0], self.bbox_wl[1], nb=wave_nb, bw=wave_bw, r=wave_r)
+            if time_binning is None:
+                time_binning = Binning(self.time.min(), self.time.max(), nb=time_nb, bw=time_bw/(24*60*60) if time_bw is not None else None)
+
+            bf, be, bn = bin2d(self.fluxes, self.errors,
+                               self._wl_l_edges, self._wl_r_edges,
+                               self._tm_l_edges, self._tm_r_edges,
+                               wave_binning.bins, time_binning.bins,
+                               estimate_errors=estimate_errors)
+
+            bc, _ = bin1d(self.covs, ones_like(self.covs),
+                          self._tm_l_edges, self._tm_r_edges,
+                          time_binning.bins,
+                          estimate_errors=False)
+
+            if not all(isfinite(be)):
+                warnings.warn('Error estimation failed for some bins, check the error array.')
+
+            d = TSData(time_binning.bins.mean(1), wave_binning.bins.mean(1), bf, be,
+                          name=self.name,
+                          wl_edges=(wave_binning.bins[:, 0], wave_binning.bins[:, 1]),
+                          tm_edges=(time_binning.bins[:, 0], time_binning.bins[:, 1]),
+                          noise_group=self.noise_group,
+                          epoch_group=self.epoch_group,
+                          offset_group=self.offset_group,
+                          ephemeris=self.ephemeris,
+                          n_baseline=self.n_baseline,
+                          covs=bc)
+            if self.ephemeris is not None:
+                d.mask_transit(ephemeris=self.ephemeris)
+            return d
+
+
     def bin_wavelength(self, binning: Optional[Union[Binning, CompoundBinning]] = None,
                        nb: Optional[int] = None, bw: Optional[float] = None, r: Optional[float] = None,
                        estimate_errors: bool = False) -> 'TSData':
@@ -706,7 +786,7 @@ class TSData:
             warnings.simplefilter('ignore', numba.NumbaPerformanceWarning)
             if binning is None:
                 binning = Binning(self.bbox_wl[0], self.bbox_wl[1], nb=nb, bw=bw, r=r)
-            bf, be = bin2d(self.fluxes, self.errors, self._wl_l_edges, self._wl_r_edges,
+            bf, be = bin1d(self.fluxes, self.errors, self._wl_l_edges, self._wl_r_edges,
                            binning.bins, estimate_errors=estimate_errors)
             if not all(isfinite(be)):
                 warnings.warn('Error estimation failed for some bins, check the error array.')
@@ -749,9 +829,9 @@ class TSData:
             warnings.simplefilter('ignore', numba.NumbaPerformanceWarning)
             if binning is None:
                 binning = Binning(self.time.min(), self.time.max(), nb=nb, bw=bw/(24*60*60) if bw is not None else None)
-            bf, be = bin2d(self.fluxes.T, self.errors.T, self._tm_l_edges, self._tm_r_edges,
+            bf, be = bin1d(self.fluxes.T, self.errors.T, self._tm_l_edges, self._tm_r_edges,
                            binning.bins, estimate_errors=estimate_errors)
-            bc, _ = bin2d(self.covs, ones_like(self.covs), self._tm_l_edges, self._tm_r_edges, binning.bins, False)
+            bc, _ = bin1d(self.covs, ones_like(self.covs), self._tm_l_edges, self._tm_r_edges, binning.bins, False)
             d = TSData(binning.bins.mean(1), self.wavelength, bf.T, be.T,
                        wl_edges=(self._wl_l_edges, self._wl_r_edges),
                        tm_edges=(binning.bins[:,0], binning.bins[:,1]),

exoiris/tslpf.py

@@ -55,17 +55,19 @@ from scipy.interpolate import (
     interp1d,
 )
 
+from .lmlikelihood import marginalized_loglike_mbl2d
 from .ldtkld import LDTkLD
 from .spotmodel import SpotModel
 from .tsdata import TSDataGroup
 from .tsmodel import TransmissionSpectroscopyModel as TSModel
 
-NM_WHITE = 0
+NM_WHITE_MARGINALIZED = 0
 NM_GP_FIXED = 1
 NM_GP_FREE = 2
+NM_WHITE_PROFILED = 3
 
-noise_models = dict(white=NM_WHITE, fixed_gp=NM_GP_FIXED, free_gp=NM_GP_FREE)
-
+noise_models = dict(white=NM_WHITE_PROFILED, white_profiled=NM_WHITE_PROFILED, white_marginalized=NM_WHITE_MARGINALIZED,
+                    fixed_gp=NM_GP_FIXED, free_gp=NM_GP_FREE)
 
 @njit
 def nlstsq(covs, res, mask, wlmask, with_nans):
@@ -74,7 +76,10 @@ def nlstsq(covs, res, mask, wlmask, with_nans):
     x = zeros((nc, nwl))
     x[:, wlmask] = lstsq(covs, ascontiguousarray(res[wlmask].T))[0]
     for i in with_nans:
-        x[:, i] =  lstsq(covs[mask[i]], res[i, mask[i]])[0]
+        try:
+            x[:, i] =  lstsq(covs[mask[i]], res[i, mask[i]])[0]
+        except:
+            x[:, i] = nan
     return x
 
 
@@ -181,7 +186,7 @@ def clean_knots(knots, min_distance, lmin=0, lmax=inf):
 
 class TSLPF(LogPosteriorFunction):
     def __init__(self, runner, name: str, ldmodel, data: TSDataGroup, nk: int = 50, nldc: int = 10, nthreads: int = 1,
-                 tmpars = None, noise_model: Literal["white", "fixed_gp", "free_gp"] = 'white',
+                 tmpars = None, noise_model: Literal["white_profiled", "white_marginalized", "fixed_gp", "free_gp"] = 'white_profiled',
                  interpolation: Literal['nearest', 'linear', 'pchip', 'makima', 'bspline', 'bspline-quadratic', 'bspline-cubic'] = 'linear'):
         super().__init__(name)
         self._runner = runner
@@ -191,12 +196,13 @@ class TSLPF(LogPosteriorFunction):
         self.npt: list[int] | None = None
         self._baseline_models: list[ndarray] | None = None
         self.interpolation: str = interpolation
+        self.ld_interpolation: str = 'bspline-quadratic'
 
         if interpolation not in interpolator_choices:
             raise ValueError(f'interpolation must be one of {interpolator_choices}')
 
         self._ip = interpolators[interpolation]
-        self._ip_ld = interpolators['bspline']
+        self._ip_ld = interpolators[self.ld_interpolation]
 
         self._gp: Optional[list[GP]] = None
         self._gp_time: Optional[list[ndarray]] = None
@@ -295,7 +301,7 @@ class TSLPF(LogPosteriorFunction):
         Parameters
         ----------
         noise_model : str
-            The noise model to be used. Must be one of the following: white, fixed_gp, free_gp.
+            The noise model to be used. Must be one of the following: white_profiled, white_marginalized, fixed_gp, free_gp.
 
         Raises
         ------
@@ -303,7 +309,7 @@ class TSLPF(LogPosteriorFunction):
             If noise_model is not one of the specified options.
         """
         if noise_model not in noise_models.keys():
-            raise ValueError('noise_model must be one of: white, fixed_gp, free_gp')
+            raise ValueError('noise_model must be one of: white_profiled, white_marginalized, fixed_gp, free_gp')
         self.noise_model = noise_model
         self._nm = noise_models[noise_model]
         if self._nm in (NM_GP_FIXED, NM_GP_FREE):
@@ -468,6 +474,13 @@ class TSLPF(LogPosteriorFunction):
         """
         self.set_k_knots(concatenate([self.k_knots, knot_wavelengths]))
 
+    def set_k_interpolator(self, interpolator: str) -> None:
+        """Set the interpolator for the radius ratio (k) model."""
+        if interpolator not in interpolators.keys():
+            raise ValueError(f"Interpolator {interpolator} not recognized.")
+        self.interpolation = interpolator
+        self._ip = interpolators[interpolator]
+
     def set_k_knots(self, knot_wavelengths) -> None:
         """Set the radius ratio (k) knot wavelengths for the model.
 
@@ -607,6 +620,12 @@ class TSLPF(LogPosteriorFunction):
             return logp
         self._additional_log_priors.append(k_knot_order_prior)
 
+    def set_ld_interpolator(self, interpolator: str) -> None:
+        """Set the interpolator for the limb darkening model."""
+        if interpolator not in interpolators.keys():
+            raise ValueError(f"Interpolator {interpolator} not recognized.")
+        self.ld_interpolation = interpolator
+        self._ip_ld = interpolators[interpolator]
 
     def add_ld_knots(self, knot_wavelengths) -> None:
         """Add limb darkening knots to the model.
@@ -626,36 +645,80 @@ class TSLPF(LogPosteriorFunction):
         knot_wavelengths : array-like
             Array of knot wavelengths.
         """
+
+        # Save the old variables
+        # ----------------------
         xo = self.ld_knots
+        pso = self.ps
+        deo = self._de_population
+        mco = self._mc_chains
+        slo = self._sl_ld
+        ndo = self.ndim
+
         xn = self.ld_knots = sort(knot_wavelengths)
         self.nldc = self.ld_knots.size
 
-        pvpo = self.de.population.copy() if self.de is not None else None
-        pso = self.ps
-        sldo = self._sl_ld
         self._init_parameters()
         psn = self.ps
-        sldn = self._sl_ld
+        sln = self._sl_ld
+        ndn = self.ndim
+
+        # Check if we have spots
+        # ----------------------
+        if self.spot_model is not None:
+            spots = self.spot_model
+            self.initialize_spots(spots.tphot, spots.wlref, spots.include_tlse)
+            for eg in spots.spot_epoch_groups:
+                self.spot_model.add_spot(eg)
+
+        # Set the priors back as they were
+        # --------------------------------
         for po in pso:
             if po.name in psn.names:
                 self.set_prior(po.name, po.prior)
 
-        if self.de is not None:
-            pvpn = self.create_pv_population(pvpo.shape[0])
+        # Resample the DE parameter population
+        # ------------------------------------
+        if self._de_population is not None:
+            den = zeros((deo.shape[0], ndn))
+
             # Copy the old parameter values
             # -----------------------------
             for pid_old, p in enumerate(pso):
-                if p.name in psn:
+                if p.name in psn.names:
+                    pid_new = psn.find_pid(p.name)
+                    den[:, pid_new] = deo[:, pid_old]
+
+            # Resample the limb darkening coefficients
+            # ----------------------------------------
+            for i in range(den.shape[0]):
+                den[i, sln][0::2] = self._ip_ld(xn, xo, deo[i, slo][0::2])
+                den[i, sln][1::2] = self._ip_ld(xn, xo, deo[i, slo][1::2])
+
+            self._de_population = den
+            self.de = None
+
+        # Resample the MCMC parameter population
+        # --------------------------------------
+        if self._mc_chains is not None:
+            fmco = mco.reshape([-1, ndo])
+            fmcn = zeros((fmco.shape[0], ndn))
+
+            # Copy the old parameter values
+            # -----------------------------
+            for pid_old, p in enumerate(pso):
+                if p.name in psn.names:
                     pid_new = psn.find_pid(p.name)
-                    pvpn[:, pid_new] = pvpo[:, pid_old]
+                    fmcn[:, pid_new] = fmco[:, pid_old]
 
             # Resample the radius ratios
             # --------------------------
-            for i in range(pvpn.shape[0]):
-                pvpn[i, sldn] = self._ip(xn, xo, pvpo[i, sldo])
+            for i in range(fmcn.shape[0]):
+                fmcn[i, sln][0::2] = self._ip_ld(xn, xo, fmco[i, slo][0::2])
+                fmcn[i, sln][1::2] = self._ip_ld(xn, xo, fmco[i, slo][1::2])
 
-            self.de = None
-            self._de_population = pvpn
+            self._mc_chains = fmcn.reshape([mco.shape[0], mco.shape[1], ndn])
+            self.sampler = None
 
     def _eval_k(self, pvp) -> list[ndarray]:
         """Evaluate the radius ratio model.
@@ -764,15 +827,16 @@ class TSLPF(LogPosteriorFunction):
                     self._baseline_models[i][ipv, :, :] = nan
         return self._baseline_models
 
-    def flux_model(self, pv):
+    def flux_model(self, pv, include_baseline: bool = True):
         transit_models = self.transit_model(pv)
-        baseline_models = self.baseline_model(transit_models)
         if self.spot_model is not None:
             self.spot_model.apply_spots(pv, transit_models)
             if self.spot_model.include_tlse:
                 self.spot_model.apply_tlse(pv, transit_models)
-        for i in range(self.data.size):
-            transit_models[i][:, :, :] *= baseline_models[i][:, :, :]
+        if include_baseline:
+            baseline_models = self.baseline_model(transit_models)
+            for i in range(self.data.size):
+                transit_models[i][:, :, :] *= baseline_models[i][:, :, :]
         return transit_models
 
     def create_pv_population(self, npop: int = 50) -> ndarray:
@@ -809,13 +873,22 @@ class TSLPF(LogPosteriorFunction):
         """
         pv = atleast_2d(pv)
         npv = pv.shape[0]
-        fmod = self.flux_model(pv)
         wn_multipliers = pv[:, self._sl_wnm]
         lnl = zeros(npv)
-        if self._nm == NM_WHITE:
+        if self._nm == NM_WHITE_MARGINALIZED:
+            fmod = self.flux_model(pv, include_baseline=False)
+            for ipv in range(npv):
+                try:
+                    for i, d in enumerate(self.data):
+                        lnl[ipv] += marginalized_loglike_mbl2d(d.fluxes, fmod[i][ipv], d.errors*wn_multipliers[ipv, d.noise_group], d.covs, d.mask)
+                except LinAlgError:
+                    lnl[ipv] = -inf
+        elif self._nm == NM_WHITE_PROFILED:
+            fmod = self.flux_model(pv, include_baseline=True)
             for i, d in enumerate(self.data):
                 lnl += lnlike_normal(d.fluxes, fmod[i], d.errors, wn_multipliers[:, d.noise_group], d.mask)
         else:
+            fmod = self.flux_model(pv)
             for j in range(npv):
                 if self._nm == NM_GP_FREE:
                     self.set_gp_hyperparameters(*pv[j, self._sl_gp])
@@ -823,7 +896,7 @@ class TSLPF(LogPosteriorFunction):
                     lnl[j] += self._gp[i].log_likelihood(self._gp_flux[i] - fmod[i][j][self.data[i].mask])
         return lnl if npv > 1 else lnl[0]
 
-    def create_initial_population(self, n: int, source: str, add_noise: bool = True) -> ndarray:
+    def create_initial_population(self, n: int, source: str, add_noise: bool = False) -> ndarray:
         """Create an initial parameter vector population for DE.
 
         Parameters
@@ -833,7 +906,7 @@ class TSLPF(LogPosteriorFunction):
         source : str
             Source of the initial population. Must be either 'fit' or 'mcmc'.
         add_noise : bool, optional
-            Flag indicating whether to add noise to the initial population. Default is True.
+            Flag indicating whether to add noise to the initial population. Default is False.
 
         Returns
         -------
@@ -863,12 +936,9 @@ class TSLPF(LogPosteriorFunction):
             else:
                 pvp = rng.choice(pvs.reshape([-1, self.ndim]), size=n)
 
-        if pvp[0, self._sl_baseline][0] < 0.5:
-            pvp[:, self._sl_baseline] = rng.normal(1.0, 1e-6, size=(n, sum(self.n_baselines)))
-
         if add_noise:
-            pvp[:, self._sl_rratios] += rng.normal(0, 1, pvp[:, self._sl_rratios].shape) * 0.002 * pvp[:, self._sl_rratios]
-            pvp[:, self._sl_ld] += rng.normal(0, 1, pvp[:, self._sl_ld].shape) * 0.002 * pvp[:, self._sl_ld]
+            pvp[:, self._sl_rratios] += rng.normal(0, 1e-4, pvp[:, self._sl_rratios].shape)
+            pvp[:, self._sl_ld] += rng.normal(0, 1e-3, pvp[:, self._sl_ld].shape)
         return pvp
 
     def optimize_global(self, niter=200, npop=50, population=None, pool=None, lnpost=None, vectorize=True,

exoiris/util.py

@@ -14,79 +14,11 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-from numba import njit
-from numpy import (zeros, sum, sqrt, linspace, vstack, concatenate, floor, dot, ndarray, nan, asarray, tile)
+from numpy import (linspace, vstack, concatenate, floor, ndarray, asarray, tile)
 from numpy._typing import ArrayLike
 from pytransit import TSModel
 from pytransit.orbits import i_from_ba
 
-@njit
-def bin2d(v, e, el, er, bins, estimate_errors: bool = False) -> tuple[ndarray, ndarray]:
-    """Bin 2D exoplanet transmission spectrum data with its uncertainties into predefined bins in wavelength.
-
-        Parameters
-        ----------
-        v : ndarray
-            A 2D array of the exoplanet transmission spectrum data with a shape (n_wavelength, n_exposure).
-        e : ndarray
-            A 2D array of uncertainties associated with the spectrum data in `v`, matching the shape of `v`.
-        el : ndarray
-            A 1D array containing the left wavelength edges of the integration ranges for each spectral data point.
-        er : ndarray
-            A 1D array containing the right wavelength edges of the integration ranges for each spectral data point.
-        bins : ndarray
-            A 2D array containing the edges of the wavelength bins. These should be sorted in ascending order.
-        estimate_errors: bool, optional.
-            Should the uncertainties be estimated from the data. Default value is False.
-
-        Returns
-        -------
-        tuple of ndarrays
-            A tuple containing two 2D arrays:
-            - The first array (`bv`) contains the binned values of the transmission spectrum.
-            - The second array (`be`) contains the binned uncertainties.
-    """
-    nbins = len(bins)
-    ndata = v.shape[0]
-    bv = zeros((nbins, v.shape[1]))
-    be = zeros((nbins, v.shape[1]))
-    e2 = e**2
-    weights = zeros(ndata)
-    i = 0
-    for ibin in range(nbins):
-        weights[:] = 0.0
-        npt = 0
-        bel, ber = bins[ibin]
-        for i in range(i, ndata - 1):
-            if el[i + 1] > bel:
-                break
-        il = i
-        if er[i] > ber:
-            weights[i] = ber - bel
-            npt += 1
-        else:
-            weights[i] = er[i] - bel
-            npt += 1
-            for i in range(i + 1, ndata):
-                if er[i] < ber:
-                    weights[i] = er[i] - el[i]
-                    npt += 1
-                else:
-                    weights[i] = ber - el[i]
-                    npt += 1
-                    break
-        ir = i
-        ws = sum(weights)
-        bv[ibin] = vmean = dot(weights[il:ir+1], v[il:ir+1,:]) / ws
-        if estimate_errors:
-            if npt > 1:
-                be[ibin] = sqrt(dot(weights[il:ir+1], (v[il:ir+1,:] - vmean)**2) / ws) / sqrt(npt)
-            else:
-                be[ibin] = nan
-        else:
-            be[ibin] = sqrt(dot(weights[il:ir+1], e2[il:ir+1,:])) / ws
-    return bv, be
-
 
 def create_binning(ranges, bwidths):
     """