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

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/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

@@ -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/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.

{exoiris-0.23.2.dist-info → exoiris-1.0.0.dist-info}/METADATA

@@ -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-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+exoiris/__init__.py,sha256=LU5jAE7_OVPLHFO0UAOGS0e0wuWV6rdSD0Qveet11K8,1147
+exoiris/binning.py,sha256=-Y9hdK0jZj8DOS82keaprneid2lZ4rCx-keWlKi0LP8,6455
+exoiris/ephemeris.py,sha256=dthBkJztT5yAP6VnnO7jGvxikboFUQBUGPUfBCFrA3w,1316
+exoiris/exoiris.py,sha256=bPbHp0YRJEhVogCD206kuQlKh4ZOdx3M47LT3T55RfQ,62457
+exoiris/ldtkld.py,sha256=7H1r1xail3vSKdsNKorMTqivnRKU9WrOVH-uE4Ky2jM,3495
+exoiris/loglikelihood.py,sha256=lVm7kMyzy-xxP5VvZMV7kJY3KovbhlEz3u_6O7R6zgI,6309
+exoiris/prtretrieval.py,sha256=PBUk-61kRgRGaJtUWLYWYpTpOj4FMDRSdYwI89U_fyw,7060
+exoiris/spotmodel.py,sha256=p7csTJs6Yicmaz93KHdnFsenvLvC9MDvx89oljnzDTM,7156
+exoiris/tsdata.py,sha256=s3R6sByy7Ud26F3TdaRaXNQi-rYeJHnm7XHk2FLd1Go,36622
+exoiris/tslpf.py,sha256=UqTmYqnqwdiStIX7My2W-VBfadFD4QQ-bYJYk0kIBEs,36214
+exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
+exoiris/util.py,sha256=uNv_c3Kuv1lml8MuDAuyElO4s3f1tRIQ1QMlLaI7Yak,5921
+exoiris/wlpf.py,sha256=ixEsDXLHSglYOWhJKA87NJPrLWqhEk4DYhn1IaShN8U,6294
+exoiris-1.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+exoiris-1.0.0.dist-info/METADATA,sha256=RsDlI-uyi4NgcBNX0Uqlsresgc_Pl0wgbMKjiF8niYQ,5083
+exoiris-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+exoiris-1.0.0.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
+exoiris-1.0.0.dist-info/RECORD,,

{exoiris-0.23.2.dist-info → exoiris-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

exoiris-0.23.2.dist-info/RECORD

@@ -1,17 +0,0 @@
-exoiris/__init__.py,sha256=LU5jAE7_OVPLHFO0UAOGS0e0wuWV6rdSD0Qveet11K8,1147
-exoiris/binning.py,sha256=-Y9hdK0jZj8DOS82keaprneid2lZ4rCx-keWlKi0LP8,6455
-exoiris/ephemeris.py,sha256=dthBkJztT5yAP6VnnO7jGvxikboFUQBUGPUfBCFrA3w,1316
-exoiris/exoiris.py,sha256=zu-_RP1DvHUjvNNT81PBpsVd8aMrAZ134vBveJ4Z6HA,61355
-exoiris/ldtkld.py,sha256=7H1r1xail3vSKdsNKorMTqivnRKU9WrOVH-uE4Ky2jM,3495
-exoiris/loglikelihood.py,sha256=lVm7kMyzy-xxP5VvZMV7kJY3KovbhlEz3u_6O7R6zgI,6309
-exoiris/spotmodel.py,sha256=9-DxvVzGzxf6AjQfrzZreyJB4Htw0gsIAD3nWl0tQMc,7160
-exoiris/tsdata.py,sha256=s3R6sByy7Ud26F3TdaRaXNQi-rYeJHnm7XHk2FLd1Go,36622
-exoiris/tslpf.py,sha256=DcnwuqFNL0ZW9RLWmppJxN6UOlrtdQAzd21ZedfA6Es,33830
-exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
-exoiris/util.py,sha256=uNv_c3Kuv1lml8MuDAuyElO4s3f1tRIQ1QMlLaI7Yak,5921
-exoiris/wlpf.py,sha256=ixEsDXLHSglYOWhJKA87NJPrLWqhEk4DYhn1IaShN8U,6294
-exoiris-0.23.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-exoiris-0.23.2.dist-info/METADATA,sha256=j_sUV7HhzWwtgZpN9PPItE3M4fdJufnsRO1YIRav_U8,5084
-exoiris-0.23.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-exoiris-0.23.2.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
-exoiris-0.23.2.dist-info/RECORD,,