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

exoiris/bin1d.py

@@ -0,0 +1,97 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2026 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 numba import njit
+from numpy import zeros, isfinite, where, nan, sqrt, ndarray, sum
+
+@njit
+def bin1d(v, e, el, er, bins, estimate_errors: bool = False) -> tuple[ndarray, ndarray]:
+    """Bin 2D spectrophotometry data with its uncertainties into predefined bins along the first axis.
+
+        Parameters
+        ----------
+        v : ndarray
+            A 2D spectrophotometry array.
+        e : ndarray
+            A 2D array of uncertainties associated with the spectrophotometry in `v`, matching the shape of `v`.
+        el : ndarray
+            A 1D array containing the left edges of the integration ranges for each spectral data point.
+        er : ndarray
+            A 1D array containing the right edges of the integration ranges for each spectral data point.
+        bins : ndarray
+            A 2D array containing the edges of the 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]))
+    nonfin_weights = isfinite(v).astype('d')
+    v = where(nonfin_weights, v, 0.0)
+    e2 = where(nonfin_weights, e**2, 0.0)
+    weights = zeros(v.shape)
+    npt = zeros(v.shape[1])
+
+    i = 0
+    for ibin in range(nbins):
+        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] - max(el[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
+
+        weights[il:ir+1, :] *= nonfin_weights[il:ir+1, :]
+        weights[il:ir+1, :] /= weights[il:ir+1, :].sum(0)
+        npt += (nonfin_weights[il:ir+1, :]-1.0).sum(0)
+        ws = sum(weights[il:ir+1, :], 0)
+        ws2 = sum(weights[il:ir+1, :]**2, 0)
+        ws = where(ws > 0, ws, nan)
+        bv[ibin] = vmean = sum(weights[il:ir+1, :] * v[il:ir+1,:], 0) / ws
+
+        if estimate_errors:
+            var_sum = sum(weights[il:ir+1, :] * (v[il:ir+1, :] - vmean)**2, 0)
+            denominator = ws - ws2 / ws
+            sample_variance = var_sum / denominator
+            be[ibin, :] = where((npt > 1) & (ws**2 > ws2),
+                                sqrt(sample_variance * ws2 / (ws * ws)), nan)
+        else:
+            be[ibin] = sqrt(sum(weights[il:ir+1, :]**2 * e2[il:ir+1,:], 0)) / ws
+    return bv, be

exoiris/bin2d.py

@@ -0,0 +1,218 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2026 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 numba import njit
+from numpy import zeros, isfinite, where, nan, sqrt, ndarray, int32, float64
+
+@njit
+def bin2d(v: ndarray, e: ndarray,
+             wl_l: ndarray, wl_r: ndarray,
+             tm_l: ndarray, tm_r: ndarray,
+             wl_bins: ndarray, tm_bins: ndarray,
+             estimate_errors: bool = False) -> tuple[ndarray, ndarray, ndarray]:
+    """Bin 2D spectrophotometry data in both wavelength and time dimensions.
+
+    Parameters
+    ----------
+    v : ndarray
+        A 2D spectrophotometry array with shape (n_wavelength, n_exposure).
+    e : ndarray
+        A 2D array of uncertainties matching the shape of `v`.
+    wl_l : ndarray
+        A 1D array of left wavelength edges for each spectral data point.
+    wl_r : ndarray
+        A 1D array of right wavelength edges for each spectral data point.
+    tm_l : ndarray
+        A 1D array of left time edges for each exposure.
+    tm_r : ndarray
+        A 1D array of right time edges for each exposure.
+    wl_bins : ndarray
+        A 2D array (n_wl_bins, 2) of wavelength bin edges [left, right].
+    tm_bins : ndarray
+        A 2D array (n_tm_bins, 2) of time bin edges [left, right].
+    estimate_errors : bool, optional
+        If True, estimate uncertainties from data scatter. Default is False.
+
+    Returns
+    -------
+    tuple of ndarrays
+        - bv: Binned values with shape (n_wl_bins, n_tm_bins).
+        - be: Binned uncertainties with shape (n_wl_bins, n_tm_bins).
+        - bn: Number of original finite pixels in each bin with shape (n_wl_bins, n_tm_bins).
+    """
+    n_wl_bins = len(wl_bins)
+    n_tm_bins = len(tm_bins)
+    n_wl = v.shape[0]
+    n_tm = v.shape[1]
+
+    bv = zeros((n_wl_bins, n_tm_bins))
+    be = zeros((n_wl_bins, n_tm_bins))
+    bn = zeros((n_wl_bins, n_tm_bins), dtype=int32)
+
+    # Pre-compute masks and cleaned data
+    nonfin_mask = isfinite(v)
+    v_clean = where(nonfin_mask, v, 0.0)
+    e2_clean = where(nonfin_mask, e**2, 0.0)
+    nonfin_weights = nonfin_mask.astype(float64)
+
+    # Pre-compute time bin indices and weights
+    tm_il_arr = zeros(n_tm_bins, dtype=int32)
+    tm_ir_arr = zeros(n_tm_bins, dtype=int32)
+    tm_weights_all = zeros((n_tm_bins, n_tm))
+
+    for itm_bin in range(n_tm_bins):
+        tm_bel, tm_ber = tm_bins[itm_bin]
+
+        # Find first time index
+        tm_il = 0
+        for j in range(n_tm - 1):
+            if tm_l[j + 1] > tm_bel:
+                tm_il = j
+                break
+        else:
+            tm_il = n_tm - 1
+
+        tm_il_arr[itm_bin] = tm_il
+
+        # Calculate time weights with ROBUST overlap logic
+        # Overlap = max(0, min(pixel_right, bin_right) - max(pixel_left, bin_left))
+        # We perform the loop starting from the found index until pixels no longer overlap
+
+        tm_idx = tm_il
+        # Iterate until pixel starts after bin ends or we run out of pixels
+        while tm_idx < n_tm:
+            # Optimization: If pixel starts after bin ends, stop.
+            if tm_l[tm_idx] >= tm_ber:
+                # But careful: tm_il search might land us on a pixel that starts after bin
+                # if the bin is in a gap. If so, we just want to record the index and break.
+                break
+
+            # Calculate overlap
+            # min(pixel_r, bin_r)
+            r_bound = tm_r[tm_idx] if tm_r[tm_idx] < tm_ber else tm_ber
+            # max(pixel_l, bin_l)
+            l_bound = tm_l[tm_idx] if tm_l[tm_idx] > tm_bel else tm_bel
+
+            if r_bound > l_bound:
+                tm_weights_all[itm_bin, tm_idx] = r_bound - l_bound
+
+            # If this pixel goes past the bin, we are done with this bin
+            if tm_r[tm_idx] >= tm_ber:
+                break
+
+            tm_idx += 1
+
+        tm_ir_arr[itm_bin] = min(tm_idx, n_tm - 1)
+
+    # Allocation moved outside loop
+    wl_weights = zeros(n_wl)
+
+    # Process wavelength bins
+    wl_start = 0
+    for iwl_bin in range(n_wl_bins):
+        wl_bel, wl_ber = wl_bins[iwl_bin]
+
+        # Reset weights for this iteration (faster than re-allocating)
+        # We only need to zero out the range we are about to use or used previously?
+        # Actually, since we calculate specific indices [wl_il, wl_ir],
+        # we can just zero them out at the end of the loop, or re-zero the whole array.
+        # Given n_wl is usually small (spectroscopy), zeroing whole array is fine.
+        wl_weights[:] = 0.0
+
+        # Find first wavelength index
+        wl_il = wl_start
+        for wl_il in range(wl_start, n_wl - 1):
+            if wl_l[wl_il + 1] > wl_bel:
+                break
+
+        # Calculate wavelength weights (Same robust logic as time)
+        wl_idx = wl_il
+        while wl_idx < n_wl:
+            if wl_l[wl_idx] >= wl_ber:
+                break
+
+            r_bound = wl_r[wl_idx] if wl_r[wl_idx] < wl_ber else wl_ber
+            l_bound = wl_l[wl_idx] if wl_l[wl_idx] > wl_bel else wl_bel
+
+            if r_bound > l_bound:
+                wl_weights[wl_idx] = r_bound - l_bound
+
+            if wl_r[wl_idx] >= wl_ber:
+                break
+            wl_idx += 1
+
+        wl_ir = min(wl_idx, n_wl - 1)
+
+        # Optimization for next bin search
+        wl_start = wl_il
+
+        # Process all time bins for this wavelength bin
+        for itm_bin in range(n_tm_bins):
+            tm_il = tm_il_arr[itm_bin]
+            tm_ir = tm_ir_arr[itm_bin]
+
+            total_weight = 0.0
+            sum_w2 = 0.0
+            weighted_sum = 0.0
+            weighted_e2_sum = 0.0
+            npt = 0
+
+            for i in range(wl_il, wl_ir + 1):
+                w_wl = wl_weights[i]
+                if w_wl <= 0: continue # Skip if no overlap
+
+                for j in range(tm_il, tm_ir + 1):
+                    # Combine weights
+                    w = w_wl * tm_weights_all[itm_bin, j] * nonfin_weights[i, j]
+
+                    if w > 0:
+                        total_weight += w
+                        sum_w2 += w * w
+                        weighted_sum += w * v_clean[i, j]
+                        weighted_e2_sum += w * w * e2_clean[i, j]
+                        npt += 1
+
+            bn[iwl_bin, itm_bin] = npt
+
+            if total_weight > 0:
+                bv[iwl_bin, itm_bin] = vmean = weighted_sum / total_weight
+
+                if estimate_errors:
+                    # Need at least 2 points (or effective degrees of freedom) to estimate variance
+                    if npt > 1 and total_weight**2 > sum_w2:
+                        var_sum = 0.0
+                        for i in range(wl_il, wl_ir + 1):
+                            w_wl = wl_weights[i]
+                            if w_wl <= 0: continue
+
+                            for j in range(tm_il, tm_ir + 1):
+                                w = w_wl * tm_weights_all[itm_bin, j] * nonfin_weights[i, j]
+                                if w > 0:
+                                    var_sum += w * (v_clean[i, j] - vmean) ** 2
+
+                        denominator = total_weight - (sum_w2 / total_weight)
+                        sample_variance = var_sum / denominator
+                        be[iwl_bin, itm_bin] = sqrt(sample_variance * (sum_w2 / (total_weight * total_weight)))
+                    else:
+                        be[iwl_bin, itm_bin] = nan
+                else:
+                    # Propagate input errors: SE = sqrt(sum(w² * σ²)) / sum(w)
+                    be[iwl_bin, itm_bin] = sqrt(weighted_e2_sum) / total_weight
+            else:
+                bv[iwl_bin, itm_bin] = nan
+                be[iwl_bin, itm_bin] = nan
+
+    return bv, be, bn

exoiris/exoiris.py

@@ -170,7 +170,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',
+                 tmpars: dict | None = 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'):
         """
         Parameters
@@ -1450,42 +1450,6 @@ class ExoIris:
         """
         return self._tsa.create_initial_population(n, source, add_noise)
 
-    def add_noise_to_solution(self, result: str = 'fit') -> None:
-        """Add noise to the global optimization result or MCMC parameter posteriors.
-
-        Add noise to the global optimization result or MCMC parameter posteriors. You may want to do this if you
-        create a new analysis from another one, for example, by adding radius ratio knots or changing the intrinsic
-        data resolution.
-
-        Parameters
-        ----------
-        result
-            Determines which result to add noise to. Default is 'fit'.
-
-        Raises
-        ------
-        ValueError
-            If the 'result' argument is not 'fit' or 'mcmc'.
-        """
-        if result == 'fit':
-            pvp = self._tsa._de_population[:, :].copy()
-        elif result == 'mcmc':
-            pvp = self._tsa._mc_chains[:, -1, :].copy()
-        else:
-            raise ValueError("The 'result' argument must be either 'fit' or 'mcmc'")
-
-        npv = pvp.shape[0]
-        pvp[:, 0] += normal(0, 0.005, size=npv)
-        pvp[:, 1] += normal(0, 0.001, size=npv)
-        pvp[:, 3] += normal(0, 0.005, size=npv)
-        pvp[:, self._tsa._sl_rratios] += normal(0, 1, pvp[:, self._tsa._sl_rratios].shape) * 0.002 * pvp[:, self._tsa._sl_rratios]
-        pvp[:, self._tsa._sl_ld] += normal(0, 1, pvp[:, self._tsa._sl_ld].shape) * 0.002 * pvp[:, self._tsa._sl_ld]
-
-        if result == 'fit':
-            self._tsa._de_population[:, :] = pvp
-        else:
-            pvp = self._tsa._mc_chains[:, -1, :] = pvp
-
     def optimize_gp_hyperparameters(self,
                                     log10_sigma_bounds: float | tuple[float, float] | None = None,
                                     log10_rho_bounds: float | tuple[float, float] = (-5, 0),

exoiris/lmlikelihood.py

@@ -0,0 +1,172 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2026 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 numpy as np
+from numba import njit
+
+@njit
+def _chol_solve(l: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """Solve L L^T x = b given lower-triangular L."""
+    y = np.linalg.solve(l, b)
+    return np.linalg.solve(l.T, y)
+
+
+@njit
+def marginalized_loglike_mbl1d(
+        obs: np.ndarray,
+        mod: np.ndarray,
+        covs: np.ndarray,
+        sigma: np.ndarray,
+        tau: float = 1e6,
+        drop_constant: bool = False,
+) -> float:
+    """Compute the analytically marginalized log-likelihood for a multiplicative baseline model.
+
+    JIT-compiled implementation of the collapsed (marginalized) log-likelihood for a
+    model where systematic trends multiply the physical signal:
+
+        obs = mod(θ) · covs·a + ε
+
+    where ε ~ N(0, diag(σ²)) and a ~ N(0, Λ). The baseline coefficients a are
+    integrated out analytically, yielding a likelihood that depends only on the
+    physical model mod(θ).
+
+    This formulation is appropriate when the out-of-transit baseline level must be
+    estimated from the data. The design matrix `covs` should include a constant
+    column (ones) to capture the baseline flux level, with additional columns for
+    systematic trends.
+
+    The computation avoids explicit matrix inversion by exploiting the Woodbury
+    identity and matrix determinant lemma, working with k×k matrices rather than
+    n×n matrices. This makes the function efficient when k ≪ n.
+
+    Parameters
+    ----------
+    obs : ndarray of shape (n,), dtype float64
+        Observed flux values. Must be contiguous float64 array.
+    mod : ndarray of shape (n,), dtype float64
+        Physical transit model evaluated at the current parameters θ, normalized
+        such that the out-of-transit level is unity. Must be contiguous float64.
+    covs : ndarray of shape (n, k), dtype float64
+        Design matrix for the multiplicative baseline. Should include a constant
+        column (ones) as the first column to capture the baseline flux level.
+        Additional columns represent systematic trends (e.g., airmass, detector
+        position, PSF width). Trend columns should typically be mean-centered.
+        Must be contiguous float64 with C ordering.
+    sigma : ndarray of shape (n,), dtype float64
+        Per-observation measurement uncertainties (standard deviations). All
+        values must be strictly positive. Must be contiguous float64.
+    tau : float, default 1e6
+        Prior standard deviation for all baseline coefficients (Λ = τ²I).
+    drop_constant : bool, default False
+        If True, omit terms constant in θ (log|Σ| and n·log(2π)). Use this for
+        MCMC sampling over θ when σ is fixed, as these terms only shift the
+        log-posterior by a constant without affecting sampling.
+
+    Returns
+    -------
+    float
+        The marginalized log-likelihood value. If drop_constant is True, this
+        omits θ-independent normalization terms.
+
+    Raises
+    ------
+    numpy.linalg.LinAlgError
+        If Lambda or the internal matrix K is not positive definite (Cholesky
+        decomposition fails). No other validation is performed.
+
+    Notes
+    -----
+    The marginalized likelihood is obtained by integrating over the baseline
+    coefficients:
+
+        L(θ) = ∫ p(obs | θ, a) p(a) da
+
+    Defining Φ = diag(mod)·covs, the marginal distribution of obs is:
+
+        obs ~ N(0, C)  where  C = Σ + τ²ΦΦᵀ
+
+    Rather than inverting the n×n matrix C directly, the implementation uses:
+
+        C⁻¹ = W − τ²W·Φ·K⁻¹·Φᵀ·W     (Woodbury identity)
+        |C| = |Σ|·|K|                 (matrix determinant lemma)
+
+    where W = Σ⁻¹ = diag(1/σ²) and K = I + τ²ΦᵀWΦ is a k×k matrix.
+
+    The log-likelihood is:
+
+        log L = −½ [obsᵀC⁻¹obs + log|C| + n·log(2π)]
+              = −½ [(obsᵀWobs − τ²cᵀK⁻¹c) + log|Σ| + log|K| + n·log(2π)]
+
+    where c = ΦᵀW·obs.
+
+    With the isotropic prior Λ = τ²I, the Cholesky factorization of Λ is trivially
+    L_Λ = τI, eliminating one matrix decomposition compared to the general case.
+    All operations involve only k×k matrices, giving O(nk² + k³) complexity
+    rather than O(n³).
+
+    In the limit τ → ∞, the marginalized likelihood approaches the profile
+    likelihood with a at its maximum likelihood estimate (ordinary least squares).
+    Numerical stability requires finite τ; values around 10⁶ are effectively
+    uninformative for normalized flux data while maintaining well-conditioned K.
+    """
+    n = obs.shape[0]
+    ncov = covs.shape[1]
+    tau2 = tau * tau
+    phi = mod[:, None] * covs
+    w = 1.0 / (sigma * sigma)
+    wphi = w[:, None] * phi
+    k = np.eye(ncov) + tau2 * (phi.T @ wphi)
+    c = phi.T @ (w * obs)
+    lk = np.linalg.cholesky(k)
+    obswobs = np.dot(w * obs, obs)
+    kinvc = _chol_solve(lk, c)
+    quad = obswobs - tau2 * np.dot(c, kinvc)
+    logdetk = 2.0 * np.sum(np.log(np.diag(lk)))
+    if drop_constant:
+        return -0.5 * (quad + logdetk)
+    logdetsigma = np.sum(np.log(sigma * sigma))
+    return -0.5 * (quad + logdetsigma + logdetk + n * np.log(2.0 * np.pi))
+
+@njit
+def marginalized_loglike_mbl2d(
+        obs: np.ndarray,
+        mod: np.ndarray,
+        err: np.ndarray,
+        covs: np.ndarray,
+        mask: np.ndarray,
+        tau: float = 1e6,
+) -> float:
+    nwl = obs.shape[0]
+    ncov = covs.shape[1]
+    tau2 = tau * tau
+    w = 1.0 / (err * err)
+
+    lnlike = 0.0
+    for i in range(nwl):
+        m = mask[i]
+        phi = mod[i, m, None] * covs[m]
+        wphi = w[i, m, None] * phi
+        k = np.eye(ncov) + tau2 * (phi.T @ wphi)
+        c = phi.T @ (w[i, m] * obs[i, m])
+        lk = np.linalg.cholesky(k)
+        obswobs = np.dot(w[i, m] * obs[i, m], obs[i, m])
+        kinvc = _chol_solve(lk, c)
+        quad = obswobs - tau2 * np.dot(c, kinvc)
+        logdetk = 2.0 * np.sum(np.log(np.diag(lk)))
+        logdetsigma = np.sum(np.log(err[i, m] * err[i, m]))
+        lnlike += -0.5 * (quad + logdetsigma + logdetk + mask[i].sum() * np.log(2.0 * np.pi))
+    return lnlike

exoiris/spotmodel.py

@@ -36,7 +36,7 @@ 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
@@ -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
@@ -296,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
         ------
@@ -304,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):
@@ -822,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:
@@ -867,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])
@@ -881,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
@@ -891,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
         -------
@@ -921,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):
     """

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

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

exoiris-1.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+exoiris/__init__.py,sha256=LU5jAE7_OVPLHFO0UAOGS0e0wuWV6rdSD0Qveet11K8,1147
+exoiris/bin1d.py,sha256=6X7Wzf-l2TohruJRcrzHtGdy0tWIO4cyeu2YMbKy_Fs,3857
+exoiris/bin2d.py,sha256=SE-MllYRFKf4rvy-z9Z7xDSkKB7f0feaMzVDDWoO6xU,8287
+exoiris/binning.py,sha256=-Y9hdK0jZj8DOS82keaprneid2lZ4rCx-keWlKi0LP8,6455
+exoiris/ephemeris.py,sha256=dthBkJztT5yAP6VnnO7jGvxikboFUQBUGPUfBCFrA3w,1316
+exoiris/exoiris.py,sha256=h188V6SqkIju2Z505JMSMz1X5l05kDn5Xqar7D2O_QI,61006
+exoiris/ldtkld.py,sha256=7H1r1xail3vSKdsNKorMTqivnRKU9WrOVH-uE4Ky2jM,3495
+exoiris/lmlikelihood.py,sha256=ukMW-VV7t_7HosBNCxMQVrGYhgrGd_a8coeN-3nAM8g,6823
+exoiris/loglikelihood.py,sha256=lVm7kMyzy-xxP5VvZMV7kJY3KovbhlEz3u_6O7R6zgI,6309
+exoiris/prtretrieval.py,sha256=PBUk-61kRgRGaJtUWLYWYpTpOj4FMDRSdYwI89U_fyw,7060
+exoiris/spotmodel.py,sha256=jB_J9_5_Gb1ymEd2SfyYuXKDkNCp7ivf5ZAbfGV2s_g,7157
+exoiris/tsdata.py,sha256=vvJi3_v1QzNKSbWRmEfiNualxrXQx-U7I8BpvaG5xu8,40375
+exoiris/tslpf.py,sha256=kvAmeB6YZw2MpL7N8yLWCek2AMGlEj1RbAIZcRL8YuQ,36951
+exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
+exoiris/util.py,sha256=eEDK1rRXKE1mszNyELtakF_TnAT3Wrf2_wMdidoYKvQ,3337
+exoiris/wlpf.py,sha256=ixEsDXLHSglYOWhJKA87NJPrLWqhEk4DYhn1IaShN8U,6294
+exoiris-1.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+exoiris-1.1.0.dist-info/METADATA,sha256=FthAETbYQCboYaTrf0cVlxJK2Umys_YHv1qbzSE-04M,5083
+exoiris-1.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+exoiris-1.1.0.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
+exoiris-1.1.0.dist-info/RECORD,,

exoiris-1.0.0.dist-info/RECORD

@@ -1,18 +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=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,,