ExoIris 0.19.2__py3-none-any.whl → 0.20.0__py3-none-any.whl

exoiris/exoiris.py

@@ -71,28 +71,38 @@ def load_model(fname: Path | str, name: str | None = None):
     """
     with pf.open(fname) as hdul:
         data = TSDataGroup.import_fits(hdul)
+        hdr = hdul[0].header
 
-        if hdul[0].header['LDMODEL'] == 'ldtk':
-            filters, teff, logg, metal, dataset = pickle.loads(codecs.decode(json.loads(hdul[0].header['LDTKLD']).encode(), "base64"))
+        # Read the limb darkening model.
+        # ==============================
+        if hdr['LDMODEL'] == 'ldtk':
+            filters, teff, logg, metal, dataset = pickle.loads(codecs.decode(json.loads(hdr['LDTKLD']).encode(), "base64"))
             ldm = LDTkLD(filters, teff, logg, metal, dataset=dataset)
         else:
-            ldm =  hdul[0].header['LDMODEL']
+            ldm =  hdr['LDMODEL']
 
+        # Read the interpolation model.
+        # =============================
         try:
-            ip = hdul[0].header['INTERP']
+            ip = hdr['INTERP']
         except KeyError:
             ip = 'bspline'
 
+        # Read the noise model.
+        # =====================
         try:
-            noise_model = hdul[0].header['NOISE']
+            noise_model = hdr['NOISE']
         except KeyError:
             noise_model = "white"
 
-        a = ExoIris(name or hdul[0].header['NAME'], ldmodel=ldm, data=data, noise_model=noise_model, interpolation=ip)
+        # Setup the analysis.
+        # ===================
+        a = ExoIris(name or hdr['NAME'], ldmodel=ldm, data=data, noise_model=noise_model, interpolation=ip)
         a.set_radius_ratio_knots(hdul['K_KNOTS'].data.astype('d'))
         a.set_limb_darkening_knots(hdul['LD_KNOTS'].data.astype('d'))
 
         # Read the white light curve models if they exist.
+        # ================================================
         try:
             tb = Table.read(hdul['WHITE_DATA'])
             white_ids = tb['id'].data
@@ -101,18 +111,28 @@ def load_model(fname: Path | str, name: str | None = None):
             a._white_fluxes = [tb['flux_obs'].data[white_ids == i] for i in uids]
             a._white_errors = [tb['flux_obs_err'].data[white_ids == i] for i in uids]
             a._white_models = [tb['flux_mod'].data[white_ids == i] for i in uids]
-
         except KeyError:
             pass
 
+        # Read the ephemeris if it exists.
+        # ================================
         try:
-            a.period = hdul[0].header['P']
-            a.zero_epoch = hdul[0].header['T0']
-            a.transit_duration = hdul[0].header['T14']
+            a.period = hdr['P']
+            a.zero_epoch = hdr['T0']
+            a.transit_duration = hdr['T14']
             [d.mask_transit(a.zero_epoch, a.period, a.transit_duration) for d in a.data]
-        except KeyError:
+        except (KeyError, ValueError):
             pass
 
+        # Read the spots if they exist.
+        # =============================
+        if 'SPOTS' in hdr and hdr['SPOTS'] is True:
+            a.initialize_spots(hdr["SP_TSTAR"], hdr["SP_REFWL"], hdr["SP_TLSE"])
+            for i in range(hdr['NSPOTS']):
+                a.add_spot(hdr[f'SP{i+1:02d}_EG'])
+
+        # Read the priors.
+        # ================
         priors = pickle.loads(codecs.decode(json.loads(hdul['PRIORS'].header['PRIORS']).encode(), "base64"))
         a._tsa.ps = ParameterSet([pickle.loads(p) for p in priors])
         a._tsa.ps.freeze()
@@ -132,7 +152,7 @@ class ExoIris:
 
     def __init__(self, name: str, ldmodel, data: TSDataGroup | TSData, nk: int = 50, nldc: int = 10, nthreads: int = 1,
                  tmpars: dict | None = None, noise_model: Literal["white", "fixed_gp", "free_gp"] = 'white',
-                 interpolation: Literal['bspline', 'pchip', 'makima'] = 'bspline'):
+                 interpolation: Literal['bspline', 'pchip', 'makima', 'nearest', 'linear'] = 'makima'):
         """
         Parameters
         ----------
@@ -343,6 +363,36 @@ class ExoIris:
         """
         self._tsa.set_gp_kernel(kernel)
 
+    def initialize_spots(self, tstar: float, wlref: float, include_tlse: bool = True):
+        """Initialize star spot model using given stellar and wavelength reference values.
+
+        Parameters
+        ----------
+        tstar
+            Effective stellar temperature [K].
+        wlref
+            Reference wavelength where spot amplitude matches the amplitude parameter.
+        """
+        self._tsa.initialize_spots(tstar, wlref, include_tlse)
+
+    def add_spot(self, epoch_group: int) -> None:
+        """Add a new star spot and associate it with an epoch group.
+
+        Parameters
+        ----------
+        epoch_group
+            Identifier for the epoch group to which the spot will be added.
+        """
+        self._tsa.add_spot(epoch_group)
+
+    @property
+    def nspots(self) -> int:
+        """Number of star spots."""
+        if self._tsa.spot_model is None:
+            return 0
+        else:
+            return self._tsa.spot_model.nspots
+
     @property
     def name(self) -> str:
         """Analysis name."""
@@ -1095,10 +1145,14 @@ class ExoIris:
         pri.header['interp'] = self._tsa.interpolation
         pri.header['noise'] = self._tsa.noise_model
 
+        # Priors
+        # ======
         pr = pf.ImageHDU(name='priors')
         priors = [pickle.dumps(p) for p in self.ps]
         pr.header['priors'] = json.dumps(codecs.encode(pickle.dumps(priors), "base64").decode())
 
+        # Limb darkening
+        # ==============
         if isinstance(self._tsa.ldmodel, LDTkLD):
             ldm = self._tsa.ldmodel
             pri.header['ldmodel'] = 'ldtk'
@@ -1107,11 +1161,15 @@ class ExoIris:
         else:
             pri.header['ldmodel'] = self._tsa.ldmodel
 
+        # Knots
+        # =====
         k_knots = pf.ImageHDU(self._tsa.k_knots, name='k_knots')
         ld_knots = pf.ImageHDU(self._tsa.ld_knots, name='ld_knots')
         hdul = pf.HDUList([pri, k_knots, ld_knots, pr])
         hdul += self.data.export_fits()
 
+        # White light curve analysis
+        # ==========================
         if self._wa is not None and self._wa._local_minimization is not None:
             wa_data = pf.BinTableHDU(
                 Table(
@@ -1140,6 +1198,19 @@ class ExoIris:
             wa_params = pf.BinTableHDU(Table(self._wa._local_minimization.x, names=names), name='white_params')
             hdul.append(wa_params)
 
+        # Spots
+        # =====
+        if self._tsa.spot_model is not None:
+            pri.header['spots'] = True
+            pri.header["sp_tstar"] = self._tsa.spot_model.tphot
+            pri.header["sp_refwl"] = self._tsa.spot_model.wlref
+            pri.header["sp_tlse"] = self._tsa.spot_model.include_tlse
+            pri.header["nspots"] = self.nspots
+            for i in range(self.nspots):
+                pri.header[f"sp{i+1:02d}_eg"] = self._tsa.spot_model.spot_epoch_groups[i]
+
+        # Global optimization results
+        # ===========================
         if self._tsa.de is not None:
             de = pf.BinTableHDU(Table(self._tsa._de_population, names=self.ps.names), name='DE')
             de.header['npop'] = self._tsa.de.n_pop
@@ -1147,6 +1218,8 @@ class ExoIris:
             de.header['imin'] = self._tsa.de.minimum_index
             hdul.append(de)
 
+        # MCMC results
+        # ============
         if self._tsa.sampler is not None:
             mc = pf.BinTableHDU(Table(self._tsa.sampler.flatchain, names=self.ps.names), name='MCMC')
             mc.header['npop'] = self._tsa.sampler.nwalkers

exoiris/spotmodel.py

@@ -0,0 +1,176 @@
+#  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/>.
+
+from copy import deepcopy
+
+from numpy import (
+    exp,
+    fabs,
+    log,
+    inf,
+    array,
+    vstack,
+    atleast_2d,
+    nan,
+    unique,
+    linspace,
+    floor,
+)
+from scipy.interpolate import RegularGridInterpolator
+from numba import njit
+
+from pytransit.stars import create_bt_settl_interpolator, create_husser2013_interpolator
+from pytransit.param import GParameter, UniformPrior as U
+
+from exoiris.tsdata import TSData
+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)
+
+
+@njit
+def interpolate_spectrum(teff, values, tgrid):
+    t0 = tgrid[0]
+    dt = tgrid[1] - tgrid[0]
+    k = (teff - t0) / dt
+    i = int(floor(k))
+    a = k - floor(k)
+    return (1.0-a)*values[i] + a*values[i+1]
+
+
+@njit
+def tlse(tphot, tspot, tfac, aspot, afac, spectra, tgrid):
+    fphot = interpolate_spectrum(tphot, spectra, tgrid)
+    fspot = interpolate_spectrum(tspot, spectra, tgrid)
+    ffac  = interpolate_spectrum(tfac, spectra, tgrid)
+    return 1.0 / (1.0 - aspot*(1.0 - fspot/fphot) - afac*(1.0 - ffac/fphot))
+
+
+def spot_contrast(tphot, tspot, spectra, spnorm):
+    fphot = interpolate_spectrum(tphot, spectra.values, spectra.grid[0])
+    fspot = interpolate_spectrum(tspot, spectra.values, spectra.grid[0])
+    norm = interpolate_spectrum(tspot, spnorm, spectra.grid[0])
+    return (fphot / fspot) / norm
+
+
+def bin_stellar_spectrum_model(sp: RegularGridInterpolator, data: TSData):
+    lrange = array(data.bbox_wl) * 1e3
+    ml = (sp.grid[1] >= lrange[0]) & (sp.grid[1] <= lrange[1])
+
+    teff = sp.grid[0]
+    wave = sp.grid[1][ml]
+    flux = sp.values[:, ml]
+
+    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
+    return RegularGridInterpolator((teff, data.wavelength), bflux, bounds_error=False, fill_value=nan)
+
+
+class SpotModel:
+    def __init__(self, tsa, tphot: float, wlref: float, include_tlse: bool = True):
+        self.tsa = tsa
+        self.tphot = tphot
+        self.wlref = wlref
+        self.include_tlse = include_tlse
+
+        ms = create_bt_settl_interpolator()
+        new_teff_grid = linspace(*ms.grid[0][[0, -1]], 117)
+        new_spectrum = array([ms((t, ms.grid[1])) for t in new_teff_grid])
+        self.full_spectrum = ms = RegularGridInterpolator((new_teff_grid, ms.grid[1]), new_spectrum, bounds_error=False, fill_value=nan)
+
+        wave = ms.grid[1] / 1e3
+        m = (wave > wlref - 0.025) & (wave < wlref + 0.025)
+        spot_norm = ms.values[:, m].mean(1)
+        self.spot_norm = interpolate_spectrum(tphot, spot_norm, ms.grid[0]) / spot_norm
+
+        self.binned_spectra = []
+        for d in tsa.data:
+            self.binned_spectra.append(bin_stellar_spectrum_model(self.full_spectrum, d))
+
+        if self.include_tlse:
+            self._init_tlse_parameters()
+
+        self.nspots = 0
+        self.spot_epoch_groups = []
+        self.spot_data_ids = []
+        self.spot_pv_slices = []
+
+    def use_tlse(self):
+        if self.include_tlse is False:
+            self.include_tlse = True
+            self._init_tlse_parameters()
+
+    def _init_tlse_parameters(self):
+        ps = [GParameter('tlse_tspot', 'Effective temperature of unocculted spots', 'K', U(1200, 7000), (1200, 7000))]
+        ps.append(GParameter('tlse_tfac', 'Effective temperature of unocculted faculae', 'K', U(1200, 7000), (1200, 7000)))
+        for e in unique(self.tsa.data.epoch_groups):
+            ps.append(GParameter(f"tlse_aspot_e{e:02d}", "Area fraction covered by unocculted spots", "", U(0,1), (0,1)))
+            ps.append(GParameter(f"tlse_afac_e{e:02d}", "Area fraction covered by unocculted faculae", "", U(0,1), (0,1)))
+        self.tsa.ps.thaw()
+        self.tsa.ps.add_global_block(f'tlse', ps)
+        setattr(self.tsa, "_start_tlse", self.tsa.ps.blocks[-1].start)
+        setattr(self.tsa, "_sl_tlse", self.tsa.ps.blocks[-1].slice)
+        self.tlse_pv_slice = self.tsa.ps.blocks[-1].slice
+        self.tsa.ps.freeze()
+
+    def add_spot(self, epoch_group: int):
+        self.nspots += 1
+        self.spot_epoch_groups.append(epoch_group)
+        self.spot_data_ids.append([i for i, d in enumerate(self.tsa.data) if d.epoch_group == epoch_group])
+
+        i = self.nspots
+        pspot = [GParameter(f"spc_{i:02d}", 'spot {i:02d} center', "d", U(0, 1), (0, inf)),
+                 GParameter(f"spa_{i:02d}", 'spot {i:02d} amplitude', "", U(0, 1), (0, inf)),
+                 GParameter(f"spw_{i:02d}", 'spot {i:02d} FWHM', "d", U(0, 1), (0, inf)),
+                 GParameter(f"sps_{i:02d}", 'spot {i:02d} shape', "d", U(1, 5), (0, inf)),
+                 GParameter(f"spt_{i:02d}", 'spot {i:02d} temperature', "K", U(3000, 6000), (0, inf))]
+        ps = self.tsa.ps
+        ps.thaw()
+        ps.add_global_block(f'spot_{i:02d}', pspot)
+        setattr(self.tsa, f"_start_spot_{i:02d}", ps.blocks[-1].start)
+        setattr(self.tsa, f"_sl_spot_{i:02d}", ps.blocks[-1].slice)
+        self.spot_pv_slices.append(ps.blocks[-1].slice)
+        ps.freeze()
+
+    def apply_tlse(self, pvp, models):
+        pvp = atleast_2d(pvp)[:, self.tlse_pv_slice]
+        npv = pvp.shape[0]
+        for d, m, sp in zip(self.tsa.data, models, self.binned_spectra):
+            for i in range(npv):
+                tspot = pvp[i, 0]
+                tfac = pvp[i, 1]
+                fspot = pvp[i, 2+d.epoch_group*2]
+                ffac = pvp[i, 3+d.epoch_group*2]
+                m[i, :, :] = (m[i, :, :] - 1.0) * tlse(self.tphot, tspot, tfac, fspot, ffac, sp.values, sp.grid[0])[:, None] + 1
+
+    def apply_spots(self, pvp, models):
+        pvp = atleast_2d(pvp)
+        npv = pvp.shape[0]
+        if models[0].shape[0] != npv:
+            raise ValueError('The _spot_models array has a wrong shape, it has not been initialized properly.')
+
+        for isp in range(self.nspots):
+            for ipv in range(npv):
+                center, amplitude, fwhm, shape, tspot = pvp[ipv, self.spot_pv_slices[isp]]
+                for idata in self.spot_data_ids[isp]:
+                    models[idata][ipv, :, :] += (spot_model(self.tsa.data[idata].time, center, amplitude, fwhm, shape) *
+                                                 spot_contrast(self.tphot, tspot, self.binned_spectra[idata], self.spot_norm)[:, None])

exoiris/tsdata.py

@@ -274,7 +274,7 @@ class TSData:
             self.transit_mask = ones(self.fluxes.shape, bool)
             self.transit_mask[:, elims[0]:elims[1]] = False
         else:
-            raise ValueError("Transit masking requires either t0, pp, and t14, ephemeris, or transit limits in exposure indices.")
+            raise ValueError("Transit masking requires either t0, p, and t14, ephemeris, or transit limits in exposure indices.")
         return self
 
     def estimate_average_uncertainties(self):
@@ -568,8 +568,8 @@ class TSData:
         axx2.set_xlabel('Exposure index')
         axx2.xaxis.set_major_locator(LinearLocator())
         axx2.xaxis.set_major_formatter('{x:.0f}')
-        fig.axx2 = axx2
-        fig.axy2 = axy2
+        ax.axx2 = axx2
+        ax.axy2 = axy2
         return fig
 
     def plot_white(self, ax: Axes | None = None, figsize: tuple[float, float] | None = None) -> Figure:

exoiris/tslpf.py

@@ -28,11 +28,20 @@ from pytransit.lpf.logposteriorfunction import LogPosteriorFunction
 
 from pytransit.orbits import as_from_rhop, i_from_ba, fold, i_from_baew, d_from_pkaiews, epoch
 from pytransit.param import ParameterSet, UniformPrior as UP, NormalPrior as NP, GParameter
-from scipy.interpolate import pchip_interpolate, splrep, splev, Akima1DInterpolator
+from pytransit.stars import create_bt_settl_interpolator
+from scipy.interpolate import (
+    pchip_interpolate,
+    splrep,
+    splev,
+    Akima1DInterpolator,
+    interp1d,
+    FloaterHormannInterpolator,
+)
 
 from .tsmodel import TransmissionSpectroscopyModel as TSModel
 from .tsdata import TSDataGroup
 from .ldtkld import LDTkLD
+from .spotmodel import SpotModel
 
 NM_WHITE = 0
 NM_GP_FIXED = 1
@@ -81,6 +90,14 @@ def ip_makima(x, xk, yk):
     return Akima1DInterpolator(xk, yk, method='makima', extrapolate=True)(x)
 
 
+def ip_nearest(x, xk, yk):
+    return interp1d(xk, yk, kind='nearest', bounds_error=False, fill_value='extrapolate', assume_sorted=True)(x)
+
+
+def ip_linear(x, xk, yk):
+    return interp1d(xk, yk, kind='linear', bounds_error=False, fill_value='extrapolate', assume_sorted=True)(x)
+
+
 def add_knots(x_new, x_old):
     return sort(concatenate([x_new, x_old]))
 
@@ -126,7 +143,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',
-                 interpolation: Literal['bspline', 'pchip', 'makima'] = 'bspline'):
+                 interpolation: Literal['bspline', 'pchip', 'makima', 'nearest', 'linear'] = 'makima'):
         super().__init__(name)
         self._runner = runner
         self._original_data: TSDataGroup | None = None
@@ -137,7 +154,8 @@ class TSLPF(LogPosteriorFunction):
         self._baseline_models: list[ndarray] | None = None
         self.interpolation: str = interpolation
 
-        self._ip = {'bspline': ip_bspline, 'pchip': ip_pchip, 'makima': ip_makima}[interpolation]
+        self._ip = {'bspline': ip_bspline, 'pchip': ip_pchip, 'makima': ip_makima,
+                    'nearest': ip_nearest, 'linear': ip_linear}[interpolation]
 
         self._gp: Optional[list[GP]] = None
         self._gp_time: Optional[list[ndarray]] = None
@@ -147,6 +165,9 @@ class TSLPF(LogPosteriorFunction):
         self.set_data(data)
         self.set_noise_model(noise_model)
 
+        self.spot_model: SpotModel | None = None
+        self.spot_model_fluxes = []
+
         self.ldmodel = ldmodel
         if isinstance(ldmodel, LDTkLD):
             for tm in self.tms:
@@ -211,6 +232,19 @@ class TSLPF(LogPosteriorFunction):
         self.ps.freeze()
         self.ndim = len(self.ps)
 
+    def initialize_spots(self, tstar: float, wlref: float, include_tlse: bool = True) -> None:
+        self.spot_model = SpotModel(self, tstar, wlref, include_tlse)
+
+    def add_spot(self, epoch_group: int) -> None:
+        """Adds a new star spot.
+
+        Parameters
+        ----------
+        epoch_group : int
+            The identifier of the epoch group to which the spot belongs.
+        """
+        self.spot_model.add_spot(epoch_group)
+
     def set_noise_model(self, noise_model: str) -> None:
         """Sets the noise model for the analysis.
 
@@ -434,6 +468,14 @@ class TSLPF(LogPosteriorFunction):
         sln = self._sl_rratios
         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:
@@ -566,8 +608,8 @@ class TSLPF(LogPosteriorFunction):
             ldp = [zeros((pvp.shape[0], npb, 2)) for npb in self.npb]
             for ids in range(self.data.size):
                 for ipv in range(pvp.shape[0]):
-                    ldp[ids][ipv, :, 0] = self._ip(self.wavelengths[ids], self.ld_knots, ldk[ipv, :, 0])
-                    ldp[ids][ipv, :, 1] = self._ip(self.wavelengths[ids], self.ld_knots, ldk[ipv, :, 1])
+                    ldp[ids][ipv, :, 0] = ip_bspline(self.wavelengths[ids], self.ld_knots, ldk[ipv, :, 0])
+                    ldp[ids][ipv, :, 1] = ip_bspline(self.wavelengths[ids], self.ld_knots, ldk[ipv, :, 1])
             return ldp
 
     def transit_model(self, pv, copy=True):
@@ -642,6 +684,10 @@ class TSLPF(LogPosteriorFunction):
     def flux_model(self, pv):
         transit_models = self.transit_model(pv)
         baseline_models = self.baseline_model(pv)
+        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][:, :, newaxis]
         return transit_models

exoiris-0.20.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: ExoIris
+Version: 0.20.0
+Summary: Easy and robust exoplanet transmission spectroscopy.
+Author-email: Hannu Parviainen <hannu@iac.es>
+License: GPLv3
+Project-URL: homepage, https://github.com/hpparvi/ExoIris
+Keywords: astronomy,astrophysics,exoplanets
+Classifier: Topic :: Scientific/Engineering
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytransit>=2.6.15
+Requires-Dist: ldtk>=1.8.5
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: numba
+Requires-Dist: emcee
+Requires-Dist: matplotlib
+Requires-Dist: celerite2
+Requires-Dist: pandas
+Requires-Dist: xarray
+Requires-Dist: seaborn
+Requires-Dist: astropy
+Requires-Dist: uncertainties
+Dynamic: license-file
+
+# ExoIris: Fast and Flexible Transmission Spectroscopy in Python
+
+[![Docs](https://readthedocs.org/projects/exoiris/badge/)](https://exoiris.readthedocs.io)
+![Python package](https://github.com/hpparvi/ExoIris/actions/workflows/python-package.yml/badge.svg)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](CODE_OF_CONDUCT.md)
+[![Licence](http://img.shields.io/badge/license-GPLv3-blue.svg?style=flat)](http://www.gnu.org/licenses/gpl-3.0.html)
+[![PyPI version](https://badge.fury.io/py/exoiris.svg)](https://pypi.org/project/ExoIris/)
+
+**ExoIris** is a Python package for modeling exoplanet transmission spectroscopy. ExoIris removes the typical 
+limitations of the two-step workflow by modeling the full two-dimensional spectroscopic transit time series *directly*.
+It supports combining transmission spectroscopy datasets from multiple instruments observed in different epochs, yielding 
+self-consistent wavelength-independent and wavelength-dependent parameters, simplifying joint analyses, and delivering 
+results quickly.
+
+![](doc/source/examples/e01/example1.png)
+
+## Why ExoIris?
+
+Transmission spectroscopy is often done following a **two-step workflow**: (1) fit a white light curve to infer 
+wavelength-independent parameters; (2) fit each spectroscopic light curve independently, constrained by the white-light 
+solution. This split can introduce approximations and inconsistencies.
+
+**ExoIris takes a different approach.** It models spectrophotometric time series *end-to-end*, enabling:
+
+- Self-consistent inference of shared (wavelength-independent) and spectral (wavelength-dependent) parameters.
+- **Joint** modeling of multiple datasets from different instruments and epochs.
+- Accounting for **transit timing variations** and dataset-dependent offsets within a unified framework.
+
+This design is a natural fit for **JWST-class** data, where correlated noise, multi-epoch observations, and 
+cross-instrument combinations are the norm.
+
+## Documentation
+
+Full documentation and tutorials: <https://exoiris.readthedocs.io>
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install exoiris
+```
+
+Latest development version:
+
+```bash
+git clone https://github.com/hpparvi/ExoIris.git
+cd ExoIris
+pip install -e .
+```
+
+ExoIris supports Python 3.9+. See the docs for dependency details and optional extras.
+
+## Key Features
+
+- **Direct modelling of spectroscopic transit time series**  
+  Built on PyTransit’s `TSModel`, optimised for transmission spectroscopy; scales to hundreds–thousands of light curves simultaneously.
+
+- **Flexible limb darkening**  
+  Use standard analytical laws (quadratic, power-2, non-linear), numerical intensity profiles from stellar atmosphere models, or user-defined radially symmetric functions.
+
+- **Robust noise treatment**  
+  Choose white noise or **time-correlated** noise via a Gaussian Process likelihood, without changing the overall workflow.
+
+- **Full control of spectral resolution**  
+  The transmission spectrum is represented as a cubic spline with user-defined knots, allowing variable resolution across wavelength.
+
+- **Reproducible, incremental workflows**  
+  Save and reload models to refine a low-resolution run into a high-resolution analysis seamlessly.
+
+- **Joint multi-dataset analyses**  
+  Combine instruments and epochs in one fit, with support for transit timing variations and dataset-specific systematics and offsets.
+
+## Performance
+
+ExoIris is designed for speed and stability:
+
+- A transmission spectroscopy analysis of a single JWST/NIRISS dataset at **R ≈ 100** typically runs in **3–5 minutes** 
+  assuming white noise, or **5–15 minutes** with a GP noise model, on a standard desktop CPU.
+- A high-resolution analysis of the JWST/NIRISS **WASP-39 b** dataset (~3800 spectroscopic light curves; see Feinstein 
+  et al. 2023) can be optimised and sampled in about **1.5 hours** on an AMD Ryzen 7 5800X (8 cores, ~3-year-old desktop).
+
+---
+
+© 2025 Hannu Parviainen

exoiris-0.20.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+exoiris/__init__.py,sha256=LU5jAE7_OVPLHFO0UAOGS0e0wuWV6rdSD0Qveet11K8,1147
+exoiris/binning.py,sha256=-Y9hdK0jZj8DOS82keaprneid2lZ4rCx-keWlKi0LP8,6455
+exoiris/ephemeris.py,sha256=dthBkJztT5yAP6VnnO7jGvxikboFUQBUGPUfBCFrA3w,1316
+exoiris/exoiris.py,sha256=POqkyc9hM5YmARDRtVN6k0l6N63hk6g_ecOR8Y4Z_2o,53838
+exoiris/ldtkld.py,sha256=7H1r1xail3vSKdsNKorMTqivnRKU9WrOVH-uE4Ky2jM,3495
+exoiris/spotmodel.py,sha256=9-DxvVzGzxf6AjQfrzZreyJB4Htw0gsIAD3nWl0tQMc,7160
+exoiris/tsdata.py,sha256=WqId5rfZR08pFZ83UZiyO39-QjX6WcB1GrUYolZsM-4,35323
+exoiris/tslpf.py,sha256=yFyMjvx8P9t55wYGGfoEZ8u3Yw1H7T4Ot-dsnT2oQEw,31316
+exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
+exoiris/util.py,sha256=5PynwYYHRrzyXJHskBtp2J-pcM59zsA1_VtDxencQm4,4630
+exoiris/wlpf.py,sha256=g6h1cLk2-nKD8u_FzwXNVVGFK4dry8fBr0A70LA5gJw,6281
+exoiris-0.20.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+exoiris-0.20.0.dist-info/METADATA,sha256=LfJuP-1bFOckme0rDdzOcohvnUeuvspSNQ_m9_yNrbc,5056
+exoiris-0.20.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+exoiris-0.20.0.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
+exoiris-0.20.0.dist-info/RECORD,,

exoiris-0.19.2.dist-info/METADATA

@@ -1,81 +0,0 @@
-Metadata-Version: 2.4
-Name: ExoIris
-Version: 0.19.2
-Summary: Easy and robust exoplanet transmission spectroscopy.
-Author-email: Hannu Parviainen <hannu@iac.es>
-License: GPLv3
-Project-URL: homepage, https://github.com/hpparvi/ExoIris
-Keywords: astronomy,astrophysics,exoplanets
-Classifier: Topic :: Scientific/Engineering
-Classifier: Intended Audience :: Science/Research
-Classifier: Intended Audience :: Developers
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pytransit>=2.6.15
-Requires-Dist: ldtk>=1.8.5
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: numba
-Requires-Dist: emcee
-Requires-Dist: matplotlib
-Requires-Dist: celerite2
-Requires-Dist: pandas
-Requires-Dist: xarray
-Requires-Dist: seaborn
-Requires-Dist: astropy
-Requires-Dist: uncertainties
-Dynamic: license-file
-
-# ExoIris: Transmission Spectroscopy Made Easy
-
-[![Docs](https://readthedocs.org/projects/exoiris/badge/)](https://exoiris.readthedocs.io)
-![Python package](https://github.com/hpparvi/ExoIris/actions/workflows/python-package.yml/badge.svg)
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](CODE_OF_CONDUCT.md)
-[![Licence](http://img.shields.io/badge/license-GPLv3-blue.svg?style=flat)](http://www.gnu.org/licenses/gpl-3.0.html)
-[![PyPI version](https://badge.fury.io/py/exoiris.svg)](https://pypi.org/project/ExoIris/)
-
-**ExoIris** is a user-friendly Python package designed to simplify and accelerate the analysis of transmission 
-spectroscopy data for exoplanets. The package can estimate a self-consistent medium-resolution transmission spectrum 
-with uncertainties from JWST NIRISS data in minutes, even when using a Gaussian Process-based noise model.
-
-![](doc/source/examples/e01/example1.png)
-
-## Documentation
-
-Read the docs at [exoiris.readthedocs.io](https://exoiris.readthedocs.io).
-
-## Key Features
-
-- **Fast modelling of spectroscopic transit time series**: ExoIris uses PyTransit's advanced `TSModel` transit 
-  model that is specially tailored for fast and efficient modelling of spectroscopic transit (or eclipse) time series.
-- **Flexible handling of limb darkening**: The stellar limb darkening can be modelled freely either by any of the standard 
-  limb darkening laws (quadratic, power-2, non-linear, etc.), by numerical stellar intensity profiles obtained
-  directly from stellar atmosphere models, or by an arbitrary ser-defined radially symmetric function.
-- **Handling of Correlated noise**: The noise model can be chosen between white or time-correlated noise, where the
-  time-correlated noise is modelled as a Gaussian process.
-- **Model saving and loading**: Seamless model saving and loading allows one to create a high-resolution analysis starting
-  from a saved low-resolution analysis.
-- **Full control of resolution**: ExoIris represents the transmission spectrum as a cubic spline, with complete 
-  flexibility to set and modify the number and placement of spline knots, allowing variable resolution throughout the 
-  analysis.
-
-## Details
-
-ExoIris uses PyTransit's `TSModel`, a transit model that is specially optimised for transmission spectroscopy and allows
-for simultaneous modelling of hundreds to thousands of spectroscopic light curves 20-30 times faster than when using 
-standard transit models not explicitly designed for transmission spectroscopy. 
-
-A complete posterior solution for a low-resolution transmission spectrum with a data resolution of R=100 
-takes 3-5 minutes to estimate assuming white noise, or 5-15 minutes if using a Gaussian process-based likelihood
-model powered by the celerite2 package. A high-resolution spectrum of the JWST NIRISS WASP-39 b observations 
-by [Feinstein et al. (2023)](https://ui.adsabs.harvard.edu/abs/2023Natur.614..670F/abstract) with ~3800
-spectroscopic light curves (as shown above) takes about 1.5 hours to optimise and sample on a three-year-old 
-AMD Ryzen 7 5800X with eight cores.
-
----
-&copy; 2024 Hannu Parviainen

exoiris-0.19.2.dist-info/RECORD

@@ -1,15 +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=s-q5QoV2Vj4qDHfocXrdZZo0C99E3iTr3g8OjTTgaug,51312
-exoiris/ldtkld.py,sha256=7H1r1xail3vSKdsNKorMTqivnRKU9WrOVH-uE4Ky2jM,3495
-exoiris/tsdata.py,sha256=jEaoz9EvUtbZ3GS-W9ymp07NR952gfiBPlhs4Olll6I,35326
-exoiris/tslpf.py,sha256=mpzYdubNXkeLAaQdUKKBuKJ6iDN_KEl4cOh4wcBB-g0,29734
-exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
-exoiris/util.py,sha256=5PynwYYHRrzyXJHskBtp2J-pcM59zsA1_VtDxencQm4,4630
-exoiris/wlpf.py,sha256=g6h1cLk2-nKD8u_FzwXNVVGFK4dry8fBr0A70LA5gJw,6281
-exoiris-0.19.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-exoiris-0.19.2.dist-info/METADATA,sha256=rmLHmfpXXera-ZGV_S3CHVi5oakrP317i-oeLrEaoYM,4214
-exoiris-0.19.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-exoiris-0.19.2.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
-exoiris-0.19.2.dist-info/RECORD,,