ExoIris 0.23.2__tar.gz → 1.0.0__tar.gz

{exoiris-0.23.2 → exoiris-1.0.0}/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to ExoIris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.0] - 2026-01-28
+
+### Added
+- Added support for setting custom interpolation models for limb darkening via `set_limb_darkening_interpolator` method.
+- Added support for setting custom interpolation models for radius ratios via `set_radius_ratio_interpolator` method.
+- Added ability to set priors for offset parameters in the analysis workflow.
+- Added interpolation type tracking in FITS header metadata (`INTERP_LD` for limb darkening interpolation).
+
+### Changed
+- Improved reinitialization logic for MCMC and differential evolution populations with updated limb darkening coefficients and knots.
+- Refactored interpolation handling in `TSLPF` to separately manage radius ratio and limb darkening interpolators.
+- Updated documentation for API methods and workflow.
+
+### Fixed
+- Fixed incorrect FWHM scaling in `spot_model` function. The scaling factor now correctly uses `log(4)^(1/shape)` for 
+  proper full width at half maximum calculations in generalized Gaussian spot models.
+
 ## [0.23.1] - 2025-12-18
 
 ### Fixed

{exoiris-0.23.2 → exoiris-1.0.0}/ExoIris.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ExoIris
-Version: 0.23.2
+Version: 1.0.0
 Summary: Easy and robust exoplanet transmission spectroscopy.
 Author-email: Hannu Parviainen <hannu@iac.es>
 License: GPLv3

{exoiris-0.23.2 → exoiris-1.0.0}/ExoIris.egg-info/SOURCES.txt

@@ -46,6 +46,7 @@ exoiris/ephemeris.py
 exoiris/exoiris.py
 exoiris/ldtkld.py
 exoiris/loglikelihood.py
+exoiris/prtretrieval.py
 exoiris/spotmodel.py
 exoiris/tsdata.py
 exoiris/tslpf.py

{exoiris-0.23.2 → exoiris-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ExoIris
-Version: 0.23.2
+Version: 1.0.0
 Summary: Easy and robust exoplanet transmission spectroscopy.
 Author-email: Hannu Parviainen <hannu@iac.es>
 License: GPLv3

{exoiris-0.23.2 → exoiris-1.0.0}/doc/source/api/exoiris.rst

@@ -64,9 +64,25 @@ transmission spectrum, and even the observational data can be changed to improve
     ExoIris.set_data
     ExoIris.set_radius_ratio_knots
     ExoIris.add_radius_ratio_knots
+    ExoIris.set_limb_darkening_knots
+    ExoIris.free_radius_ratio_knot_locations
     ExoIris.create_dense_radius_ratio_block
     ExoIris.plot_setup
 
+Interpolation configuration
+---------------------------
+
+ExoIris uses interpolation to model the wavelength-dependent radius ratio and limb darkening
+parameters. The interpolation method can be customized to balance smoothness against fidelity to the
+data. Available interpolators include: ``nearest``, ``linear``, ``pchip``, ``makima``, ``bspline``,
+``bspline-quadratic``, and ``bspline-cubic``.
+
+.. autosummary::
+    :toctree: api/
+
+    ExoIris.set_radius_ratio_interpolator
+    ExoIris.set_limb_darkening_interpolator
+
 Parameterization and priors
 ---------------------------
 
@@ -83,10 +99,11 @@ Noise model setup
 -----------------
 
 The noise in the spectroscopic light curves can be modeled as either white noise or time-correlated noise
-(using a Gaussian process, GP). The noise model is chosen with the `ExoIris.noise_model` method, and can be
-set to either "white" or "fixed_gp." Selecting "fixed_gp" models the noise as a time-correlated Gaussian process
-using the `celerite2` package. The corresponding `celerite2.GaussianProcess` object can be accessed directly
-via the `ExoIris.gp` attribute.
+(using a Gaussian process, GP). The noise model is chosen with the `ExoIris.set_noise_model` method, and can be
+set to ``"white"``, ``"fixed_gp"``, or ``"free_gp"``. Selecting ``"fixed_gp"`` models the noise as a time-correlated
+Gaussian process using the `celerite2` package with fixed hyperparameters, while ``"free_gp"`` allows the GP
+hyperparameters to be sampled as free parameters. The corresponding `celerite2.GaussianProcess` object can be
+accessed directly via the `ExoIris.gp` attribute.
 
 .. autosummary::
     :toctree: api/
@@ -98,6 +115,23 @@ via the `ExoIris.gp` attribute.
     ExoIris.gp
     ExoIris.plot_white_gp_predictions
 
+Star spot modeling
+------------------
+
+ExoIris supports modeling of star spot crossings during transit and the Transit Light Source Effect (TLSE).
+Star spots can cause both localized bumps in the light curve (when the planet occults a spot) and
+wavelength-dependent baseline variations (TLSE) due to the inhomogeneous stellar surface.
+
+To use spot modeling, first initialize the spot model with `ExoIris.initialize_spots`, then add spots
+for specific epoch groups using `ExoIris.add_spot`.
+
+.. autosummary::
+    :toctree: api/
+
+    ExoIris.initialize_spots
+    ExoIris.add_spot
+    ExoIris.nspots
+
 
 First steps
 -----------
@@ -155,12 +189,27 @@ Pandas `~pandas.DataFrame`.
     :toctree: api/
 
     ExoIris.transmission_spectrum
+    ExoIris.transmission_spectrum_table
     ExoIris.posterior_samples
     ExoIris.plot_fit
     ExoIris.plot_transmission_spectrum
     ExoIris.plot_residuals
     ExoIris.plot_limb_darkening_parameters
 
+Atmospheric retrieval
+---------------------
+
+ExoIris provides tools for atmospheric retrieval by creating a log-likelihood function that can be
+used with external retrieval codes. The `ExoIris.create_loglikelihood_function` method returns a
+callable that evaluates the log-likelihood for a given transmission spectrum model, accounting for
+the full covariance structure of the data.
+
+.. autosummary::
+    :toctree: api/
+
+    ExoIris.create_loglikelihood_function
+    ExoIris.transmission_spectrum_samples
+
 Utility methods
 ---------------
 
@@ -186,6 +235,7 @@ The following properties expose key internal states and parameters of the analys
     ExoIris.nk
     ExoIris.nldp
     ExoIris.npb
+    ExoIris.nspots
     ExoIris.ldmodel
     ExoIris.sampler
     ExoIris.optimizer

{exoiris-0.23.2 → exoiris-1.0.0}/doc/source/api/tsdata.rst

@@ -28,7 +28,7 @@ Data wrangling
     TSData.bin_time
     TSData.crop_wavelength
     TSData.crop_time
-    TSData.remove_outliers
+    TSData.mask_outliers
     TSData.normalize_to_median
     TSData.normalize_to_poly
     TSData.partition_time

{exoiris-0.23.2 → exoiris-1.0.0}/doc/source/index.rst

@@ -52,6 +52,8 @@ Documentation
    api/exoiris
    api/tsdata
    api/binning
+   api/ldtkld
+   api/utilities
 
 Support
 -------

{exoiris-0.23.2 → exoiris-1.0.0}/exoiris/exoiris.py

@@ -43,7 +43,7 @@ from uncertainties import UFloat
 
 from .ldtkld import LDTkLD
 from .tsdata import TSData, TSDataGroup
-from .tslpf import TSLPF
+from .tslpf import TSLPF, interpolators
 from .wlpf import WhiteLPF
 from .loglikelihood import LogLikelihood
 
@@ -88,7 +88,14 @@ def load_model(fname: Path | str, name: str | None = None):
         try:
             ip = hdr['INTERP']
         except KeyError:
-            ip = 'bspline'
+            ip = 'linear'
+
+        # Read the interpolation model.
+        # =============================
+        try:
+            ip_ld = hdr['INTERP_LD']
+        except KeyError:
+            ip_ld = 'bspline-quadratic'
 
         # Read the noise model.
         # =====================
@@ -100,6 +107,7 @@ def load_model(fname: Path | str, name: str | None = None):
         # Setup the analysis.
         # ===================
         a = ExoIris(name or hdr['NAME'], ldmodel=ldm, data=data, noise_model=noise_model, interpolation=ip)
+        a.set_limb_darkening_interpolator(ip_ld)
         a.set_radius_ratio_knots(hdul['K_KNOTS'].data.astype('d'))
         a.set_limb_darkening_knots(hdul['LD_KNOTS'].data.astype('d'))
 
@@ -263,15 +271,15 @@ class ExoIris:
         data = TSDataGroup([data]) if isinstance(data, TSData) else data
         self._tsa.set_data(data)
 
-    def set_prior(self, parameter: Literal['radius ratios', 'baselines', 'wn multipliers'] | str,
+    def set_prior(self, parameter: Literal['radius ratios', 'offsets', 'wn multipliers'] | str,
                   prior: str | Any, *nargs) -> None:
         """Set a prior on a model parameter.
 
         Parameters
         ----------
         parameter
-            The name of the parameter to set a prior for. Can also be 'radius ratios', 'baselines', or 'wn multipliers'
-            to set identical priors on all the radius ratios, baselines, or white noise multipliers.
+            The name of the parameter to set a prior for. Can also be 'radius ratios', 'offsets', or 'wn multipliers'
+            to set identical priors on all the radius ratios, offsets, or white noise multipliers.
 
         prior
             The prior distribution for the parameter. This can be "NP" for a normal prior, "UP" for a
@@ -287,6 +295,9 @@ class ExoIris:
         elif parameter == 'wn multipliers':
             for par in self.ps[self._tsa._sl_wnm]:
                 self.set_prior(par.name, prior, *nargs)
+        elif parameter == 'offsets':
+            for par in self.ps[self._tsa._sl_bias]:
+                self.set_prior(par.name, prior, *nargs)
         else:
             self._tsa.set_prior(parameter, prior, *nargs)
 
@@ -509,6 +520,12 @@ class ExoIris:
         else:
             return self._wa.std_errors
 
+    def set_radius_ratio_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._tsa.set_k_interpolator(interpolator)
+
     def add_radius_ratio_knots(self, knot_wavelengths: Sequence) -> None:
         """Add radius ratio (k) knots.
 
@@ -558,6 +575,12 @@ class ExoIris:
         nk = nk[(nk >= wlmin) & (nk <= wlmax)]
         self.set_radius_ratio_knots(r_[ck[ck < nk[0]], nk, ck[ck > nk[-1]]])
 
+    def set_limb_darkening_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._tsa.set_ld_interpolator(interpolator)
+
     def add_limb_darkening_knots(self, knot_wavelengths: Sequence) -> None:
         """Add limb darkening knots.
 
@@ -1283,6 +1306,7 @@ class ExoIris:
         pri.header['t14'] = self.transit_duration
         pri.header['ndgroups'] = self.data.size
         pri.header['interp'] = self._tsa.interpolation
+        pri.header['interp_ld'] = self._tsa.ld_interpolation
         pri.header['noise'] = self._tsa.noise_model
 
         if self._tsa.free_k_knot_ids is None:

exoiris-1.0.0/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-0.23.2 → exoiris-1.0.0}/exoiris/spotmodel.py

@@ -41,8 +41,8 @@ from exoiris.util import bin2d
 
 @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

{exoiris-0.23.2 → exoiris-1.0.0}/exoiris/tslpf.py

@@ -191,12 +191,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
@@ -468,6 +469,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 +615,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 +640,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)
-                    pvpn[:, pid_new] = pvpo[:, pid_old]
+                    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)
+                    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.