ExoIris 0.16.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

{ExoIris-0.16.0.dist-info → ExoIris-0.18.0.dist-info}/METADATA

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

ExoIris-0.18.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+exoiris/__init__.py,sha256=gaNfxNKXH41yRK35JghqackXpENyB-NOg-JlciqO1YU,1145
+exoiris/binning.py,sha256=-Y9hdK0jZj8DOS82keaprneid2lZ4rCx-keWlKi0LP8,6455
+exoiris/ephemeris.py,sha256=dthBkJztT5yAP6VnnO7jGvxikboFUQBUGPUfBCFrA3w,1316
+exoiris/exoiris.py,sha256=UgwujRngsk-VNXi8DnDQ2z9-v5_E8_eC2_uaE_pYe0k,47974
+exoiris/ldtkld.py,sha256=u4c5Yh6JlG0Zfec7-nOCQGXxIt1VVp9mniFMM7h-L6s,3489
+exoiris/tsdata.py,sha256=c1HLbVBR_Ib291NPAi4gaD44NLtXHcmlRRwIO_mD7Fw,33254
+exoiris/tslpf.py,sha256=7qrVm_HDeiwgPFdu2GsGdS2f7H13hPc5hrVpVPN9Xc8,28581
+exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
+exoiris/util.py,sha256=5PynwYYHRrzyXJHskBtp2J-pcM59zsA1_VtDxencQm4,4630
+exoiris/wlpf.py,sha256=8VB5ChEbtS8398QctIxbwtDInLoLEkr4yoRkSniEnwA,4537
+ExoIris-0.18.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ExoIris-0.18.0.dist-info/METADATA,sha256=P1UH_KJ4kEvToWhzHRMFhkMUhXikCu1HDF2DWB48rUk,4189
+ExoIris-0.18.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ExoIris-0.18.0.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
+ExoIris-0.18.0.dist-info/RECORD,,

exoiris/exoiris.py

@@ -33,7 +33,8 @@ from celerite2 import GaussianProcess, terms
 from emcee import EnsembleSampler
 from matplotlib.pyplot import subplots, setp, figure, Figure, Axes
 from numpy import (where, sqrt, clip, percentile, median, squeeze, floor, ndarray,
-                   array, inf, newaxis, arange, tile, sort, argsort, concatenate, full, nan, r_, nanpercentile)
+                   array, inf, newaxis, arange, tile, sort, argsort, concatenate, full, nan, r_, nanpercentile, log10,
+                   ceil)
 from numpy.random import normal, permutation
 from pytransit import UniformPrior, NormalPrior
 from pytransit.orbits import epoch
@@ -94,7 +95,7 @@ def load_model(fname: Path | str, name: str | None = None):
             a.period = hdul[0].header['P']
             a.zero_epoch = hdul[0].header['T0']
             a.transit_duration = hdul[0].header['T14']
-            [d.calculate_ootmask(a.zero_epoch, a.period, a.transit_duration) for d in a.data]
+            [d.mask_transit(a.zero_epoch, a.period, a.transit_duration) for d in a.data]
         except KeyError:
             pass
 
@@ -164,13 +165,13 @@ class ExoIris:
         """
         return squeeze(self._tsa.lnposterior(pvp))
 
-    def set_noise_model(self, noise_model: str) -> None:
+    def set_noise_model(self, noise_model: Literal['white', 'fixed_gp', 'free_gp']) -> None:
         """Set the noise model for the analysis.
 
         Parameters
         ----------
         noise_model
-            The noise model to be used. Must be one of the following: white, fixed_gp, free_gp.
+            The noise model to be used.
 
         Raises
         ------
@@ -374,6 +375,26 @@ class ExoIris:
         """Posterior samples from the MCMC sampler."""
         return pd.DataFrame(self._tsa._mc_chains.reshape([-1, self.ndim]), columns=self.ps.names)
 
+    @property
+    def white_times(self) -> list[ndarray]:
+        """White light curve time arrays."""
+        return self._wa.times
+
+    @property
+    def white_fluxes(self) -> list[ndarray]:
+        """White light curve flux arrays."""
+        return self._wa.fluxes
+
+    @property
+    def white_models(self) -> list[ndarray]:
+        fm = self._wa.flux_model(self._wa._local_minimization.x)
+        return [fm[sl] for sl in self._wa.lcslices]
+
+    @property
+    def white_errors(self) -> list[ndarray]:
+        """White light curve flux error arrays."""
+        return self._wa.std_errors
+
     def add_radius_ratio_knots(self, knot_wavelengths: Sequence) -> None:
         """Add radius ratio (k) knots.
 
@@ -535,6 +556,22 @@ class ExoIris:
         """
         return self._wa.plot(axs=axs, figsize=figsize, ncols=ncols or min(self.data.size, 2))
 
+    def plot_white_gp_predictions(self, axs = None, ncol: int = 1, figsize: tuple[float, float] | None = None):
+        ndata = self.data.size
+
+        if axs is None:
+            nrow = int(ceil(ndata / ncol))
+            fig, axs = subplots(nrow, ncol, sharey='all', constrained_layout=True, squeeze=False, figsize=figsize)
+        else:
+            fig = axs[0].axes
+
+        for i in range(ndata):
+            tref = floor(self.white_times[i][0])
+            axs.flat[i].plot(self.white_times[i] - tref, self.white_fluxes[i]-self.white_models[i])
+            axs.flat[i].plot(self.white_times[i] - tref, self.white_gp_models[i], 'k')
+            setp(axs.flat[i], xlabel=f'Time - {tref:.0f} [d]', xlim=self.white_times[i][[0,-1]]-tref)
+        setp(axs[:, 0], ylabel='Residuals')
+
     def normalize_baseline(self, deg: int = 1) -> None:
         """Normalize the baseline flux for each spectroscopic light curve.
 
@@ -915,9 +952,6 @@ class ExoIris:
             pp = nanpercentile(residuals, [pmin, pmax])
             data.plot(ax=ax, data=residuals, vmin=pp[0], vmax=pp[1], cmap=cmap)
 
-            tc = pv[1] + pv[2]*epoch(data.time.mean(), pv[1], pv[2])
-            td = self.transit_duration
-
             if not show_names:
                 ax.set_title("")
 
@@ -1103,87 +1137,15 @@ class ExoIris:
             pvp = self._tsa._mc_chains[:, -1, :] = pvp
 
     def optimize_gp_hyperparameters(self,
-                                    log10_sigma_bounds: float | tuple[float, float] = (-5, -2),
+                                    log10_sigma_bounds: float | tuple[float, float] | None = None,
                                     log10_rho_bounds: float | tuple[float, float] = (-5, 0),
                                     log10_sigma_prior=None, log10_rho_prior=None,
-                                    npop: int = 10, niter: int = 100, subset = None):
-        """Optimize the Matern-3/2 kernel Gaussian Process hyperparameters.
-
-        Parameters
-        ----------
-        log10_sigma_bounds
-            The bounds for the log10 of the sigma hyperparameter. If float is provided, the parameter will be
-            fixed to the given value. Default is (-5, -2).
-        log10_rho_bounds
-            The bounds for the log10 of the rho hyperparameter. If float is provided, the parameter will be fixed
-            to the given value. Default is (-5, 0).
-        log10_sigma_prior
-            The prior distribution for the sigma hyperparameter expressed as an object with a `logpdf` method
-            or as an iterable containing the mean and standard deviation of the prior distribution. Default is None.
-        log10_rho_prior
-            The prior distribution for the rho hyperparameter expressed as an object with a `logpdf` method
-            or as an iterable containing the mean and standard deviation of the prior distribution. Default is None.
-        npop
-            The population size for the differential evolution optimizer. Default is 10.
-        niter
-            The number of iterations for the differential evolution optimization process. Default is 100.
-        subset
-            The subset used for the optimization process. If `subset` is a float, a random subset of size
-            `0.5 * self.npb` is used. If `subset` is an iterable, it must contain the indices of the subset.
-            Default is None.
-
-        Returns
-        -------
-        tuple[float, float]
-            The optimized values for the log10 of the sigma and rho hyperparameters.
-        float
-            The fitness value.
-
-        Raises
-        ------
-        ValueError
-            If `subset` is not an iterable or a float.
-        ValueError
-            If `log10_sigma_prior` is not an object with a `logpdf` method or iterable.
-        ValueError
-            If `log10_rho_prior` is not an object with a `logpdf` method or iterable.
-
-        Notes
-        -----
-        - The Gaussian Process is reconfigured with the optimal hyperparameters. Any previous kernels are overwritten.
-        """
-
+                                    npop: int = 10, niter: int = 100):
         if self._tsa.noise_model != 'fixed_gp':
             raise ValueError("The noise model must be set to 'fixed_gp' before the hyperparameter optimization.")
 
-        sb = log10_sigma_bounds if isinstance(log10_sigma_bounds, Sequence) else [log10_sigma_bounds-1, log10_sigma_bounds+1]
-        rb = log10_rho_bounds if isinstance(log10_rho_bounds, Sequence) else [log10_rho_bounds-1, log10_rho_bounds+1]
-        bounds = array([sb, rb])
-
-        data = self.data[0]
-        if subset is not None:
-            if isinstance(subset, float):
-                ids = sort(permutation(data.nwl)[:int(subset*data.nwl)])
-            elif isinstance(subset, Sequence):
-                ids = array(subset, int)
-            else:
-                raise ValueError("subset must be either an iterable or a float.")
-        else:
-            ids = arange(data.nwl)
-
-        class DummyPrior:
-            def logpdf(self, x):
-                return 0.0
-
-        if log10_sigma_prior is not None:
-            if isinstance(log10_sigma_prior, Sequence):
-                sp = norm(*log10_sigma_prior)
-            elif hasattr(log10_sigma_prior, 'logpdf'):
-                sp = log10_sigma_prior
-            else:
-                raise ValueError('Bad sigma_prior')
-        else:
-            sp = DummyPrior()
+        if self._wa is None:
+            raise ValueError("The white light curves must be fit using 'fit_white()' before the hyperparameter optimization.")
 
         if log10_rho_prior is not None:
             if isinstance(log10_rho_prior, Sequence):
@@ -1193,29 +1155,69 @@ class ExoIris:
             else:
                 raise ValueError('Bad rho_prior')
         else:
-            rp = DummyPrior()
-
-        npb = ids.size
-        time = (tile(data.time[newaxis, data.transit_mask], (npb, 1)) + arange(npb)[:, newaxis]).ravel()
-        flux = (data.fluxes[ids, :][:, data.transit_mask]).ravel() - 1
-        ferr = (data.errors[ids, :][:, data.transit_mask]).ravel()
-        gp = GaussianProcess(terms.Matern32Term(sigma=flux.std(), rho=0.1))
-
-        def nll(log10x):
-            x = 10**log10x
-            if any(log10x < bounds[:,0]) or any(log10x > bounds[:,1]):
-                return inf
-            gp.kernel = terms.Matern32Term(sigma=x[0], rho=x[1])
-            gp.compute(time, yerr=ferr, quiet=True)
-            return -(gp.log_likelihood(flux) + sp.logpdf(log10x[0]) + rp.logpdf(log10x[1]))
-
-        de = DiffEvol(nll, bounds, npop, min_ptp=0.2)
-        if isinstance(log10_sigma_bounds, float):
-            de.population[:, 0] = log10_sigma_bounds
-        if isinstance(log10_rho_bounds, float):
-            de.population[:, 1] = log10_rho_bounds
-
-        de.optimize(niter)
-        x = de.minimum_location
-        self._tsa.set_gp_hyperparameters(10**x[0], 10**x[1])
-        return 10**x, de._fitness.ptp()
+            rp = norm(-2, 1)
+
+        times = self.white_times
+        errors = self.white_errors
+        residuals = [o-m for o,m in zip(self.white_fluxes, self.white_models)]
+        self.white_gp_models = []
+
+        gp_hyperparameters = []
+        for i in range(len(times)):
+            time = times[i]
+            fres = residuals[i]
+            ferr = errors[i]
+
+            log10_sigma_guess = log10(fres.std())
+
+            match log10_sigma_bounds:
+                case None:
+                    sb =  [log10_sigma_guess-1, log10_sigma_guess+1]
+                case _ if isinstance(log10_sigma_bounds, Sequence):
+                    sb = log10_sigma_bounds
+                case _ if isinstance(log10_sigma_bounds, float):
+                    sb = [log10_sigma_bounds-1, log10_sigma_bounds+1]
+
+            match log10_rho_bounds:
+                case None:
+                    rb =  [-5, -2]
+                case _ if isinstance(log10_rho_bounds, Sequence):
+                    rb = log10_rho_bounds
+                case _ if isinstance(log10_rho_bounds, float):
+                    rb = [log10_rho_bounds-1, log10_rho_bounds+1]
+
+            bounds = array([sb, rb])
+
+            if log10_sigma_prior is not None:
+                if isinstance(log10_sigma_prior, Sequence):
+                    sp = norm(*log10_sigma_prior)
+                elif hasattr(log10_sigma_prior, 'logpdf'):
+                    sp = log10_sigma_prior
+                else:
+                    raise ValueError('Bad sigma_prior')
+            else:
+                sp = norm(log10_sigma_guess, 0.1)
+
+            gp = GaussianProcess(terms.Matern32Term(sigma=fres.std(), rho=0.1))
+
+            def nll(log10x):
+                x = 10**log10x
+                if any(log10x < bounds[:,0]) or any(log10x > bounds[:,1]):
+                    return inf
+                gp.kernel = terms.Matern32Term(sigma=x[0], rho=x[1])
+                gp.compute(time, yerr=ferr, quiet=True)
+                return -(gp.log_likelihood(fres) + sp.logpdf(log10x[0]) + rp.logpdf(log10x[1]))
+
+            de = DiffEvol(nll, bounds, npop, min_ptp=0.2)
+            if isinstance(log10_sigma_bounds, float):
+                de.population[:, 0] = log10_sigma_bounds
+            if isinstance(log10_rho_bounds, float):
+                de.population[:, 1] = log10_rho_bounds
+
+            de.optimize(niter)
+            x = de.minimum_location
+            gp_hyperparameters.append(10**x)
+            gp.kernel = terms.Matern32Term(sigma=10**x[0], rho=10**x[1])
+            self.white_gp_models.append(gp.predict(fres))
+            self._tsa.set_gp_hyperparameters(10**x[0], 10**x[1], i)
+        return gp_hyperparameters

exoiris/tsdata.py

@@ -47,7 +47,7 @@ class TSData:
     def __init__(self, time: Sequence, wavelength: Sequence, fluxes: Sequence, errors: Sequence, name: str,
                  noise_group: str = 'a', wl_edges : Sequence | None = None, tm_edges : Sequence | None = None,
                  transit_mask: ndarray | None = None, ephemeris: Ephemeris | None = None, n_baseline: int = 1,
-                 mask: ndarray = None) -> None:
+                 mask: ndarray = None, ephemeris_group: int = 0, offset_group: int = 0) -> None:
         """
         Parameters
         ----------
@@ -81,6 +81,12 @@ class TSData:
         if n_baseline < 1:
             raise ValueError("n_baseline must be greater than zero.")
 
+        if ephemeris_group < 0:
+            raise ValueError("ephemeris_group must be a non-negative integer.")
+
+        if offset_group < 0:
+            raise ValueError("offset_group must be a non-negative integer.")
+
         self.name: str = name
         self.time: ndarray = time.copy()
         self.wavelength: ndarray = wavelength
@@ -92,6 +98,8 @@ class TSData:
         self.ephemeris: Ephemeris | None = ephemeris
         self.n_baseline: int = n_baseline
         self._noise_group: str = noise_group
+        self.ephemeris_group: int = ephemeris_group
+        self.offset_group: int = offset_group
         self._dataset: Optional['TSDataSet'] = None
         self._update()
 
@@ -129,6 +137,8 @@ class TSData:
         mask = pf.ImageHDU(self.mask.astype(int), name=f'mask_{self.name}')
         data.header['ngroup'] = self.noise_group
         data.header['nbasel'] = self.n_baseline
+        data.header['epgroup'] = self.ephemeris_group
+        data.header['offgroup'] = self.offset_group
         #TODO: export ephemeris
         return pf.HDUList([time, wave, data, ootm, mask])
 
@@ -153,6 +163,8 @@ class TSData:
         ootm = hdul[f'OOTM_{name}'].data.astype(bool)
         mask = hdul[f'MASK_{name}'].data.astype(bool)
         noise_group = hdul[f'DATA_{name}'].header['NGROUP']
+        ephemeris_group = hdul[f'DATA_{name}'].header['EPGROUP']
+        offset_group = hdul[f'DATA_{name}'].header['OFFGROUP']
 
         try:
             n_baseline = hdul[f'DATA_{name}'].header['NBASEL']
@@ -161,7 +173,7 @@ class TSData:
 
         #TODO: import ephemeris
         return TSData(time, wave, data[0], data[1], name=name, noise_group=noise_group, transit_mask=ootm,
-                      n_baseline=n_baseline, mask=mask)
+                      n_baseline=n_baseline, mask=mask, ephemeris_group=ephemeris_group, offset_group=offset_group)
 
     def __repr__(self) -> str:
         return f"TSData Name:'{self.name}' [{self.wavelength[0]:.2f} - {self.wavelength[-1]:.2f}] nwl={self.nwl} npt={self.npt}"
@@ -286,13 +298,20 @@ class TSData:
         m = masks[0]
         d = TSData(name=f'{self.name}_1', time=self.time[m], wavelength=self.wavelength,
                    fluxes=self.fluxes[:, m], errors=self.errors[:, m], mask=self.mask[:, m],
-                   noise_group=self.noise_group, transit_mask=self.transit_mask[m],
-                   ephemeris=self.ephemeris, n_baseline=self.n_baseline)
+                   noise_group=self.noise_group,
+                   ephemeris_group=self.ephemeris_group,
+                   offset_group=self.offset_group,
+                   transit_mask=self.transit_mask[m],
+                   ephemeris=self.ephemeris,
+                   n_baseline=self.n_baseline)
         for i, m in enumerate(masks[1:]):
             d = d + TSData(name=f'{self.name}_{i+2}', time=self.time[m], wavelength=self.wavelength,
                            fluxes=self.fluxes[:, m], errors=self.errors[:, m], mask=self.mask[:, m],
                            noise_group=self.noise_group,
-                           transit_mask=self.transit_mask[m], ephemeris=self.ephemeris,
+                           ephemeris_group=self.ephemeris_group,
+                           offset_group=self.offset_group,
+                           transit_mask=self.transit_mask[m],
+                           ephemeris=self.ephemeris,
                            n_baseline=self.n_baseline)
         return d
 
@@ -325,6 +344,8 @@ class TSData:
                           errors=self.errors[m],
                           mask=self.mask[m],
                           noise_group=self.noise_group,
+                          ephemeris_group=self.ephemeris_group,
+                          offset_group=self.offset_group,
                           wl_edges=(self._wl_l_edges[m], self._wl_r_edges[m]),
                           tm_edges=(self._tm_l_edges, self._tm_r_edges),
                           transit_mask=self.transit_mask, ephemeris=self.ephemeris,
@@ -360,6 +381,8 @@ class TSData:
                           errors=self.errors[:, m],
                           mask = self.mask[:, m],
                           noise_group=self.noise_group,
+                          ephemeris_group=self.ephemeris_group,
+                          offset_group=self.offset_group,
                           wl_edges=(self._wl_l_edges, self._wl_r_edges),
                           tm_edges=(self._tm_l_edges[m], self._tm_r_edges[m]),
                           transit_mask=self.transit_mask[m], ephemeris=self.ephemeris,
@@ -574,10 +597,16 @@ class TSData:
                            binning.bins, estimate_errors=estimate_errors)
             if not all(isfinite(be)):
                 warnings.warn('Error estimation failed for some bins, check the error array.')
-            return TSData(self.time, binning.bins.mean(1), bf, be, wl_edges=(binning.bins[:,0], binning.bins[:,1]),
-                          name=self.name, tm_edges=(self._tm_l_edges, self._tm_r_edges), noise_group=self.noise_group,
-                          transit_mask=self.transit_mask, ephemeris=self.ephemeris, n_baseline=self.n_baseline)
-
+            return TSData(self.time, binning.bins.mean(1), bf, be,
+                          wl_edges=(binning.bins[:,0], binning.bins[:,1]),
+                          name=self.name,
+                          tm_edges=(self._tm_l_edges, self._tm_r_edges),
+                          noise_group=self.noise_group,
+                          ephemeris_group=self.ephemeris_group,
+                          offset_group=self.offset_group,
+                          transit_mask=self.transit_mask,
+                          ephemeris=self.ephemeris,
+                          n_baseline=self.n_baseline)
 
     def bin_time(self, binning: Optional[Union[Binning, CompoundBinning]] = None,
                        nb: Optional[int] = None, bw: Optional[float] = None,
@@ -609,10 +638,14 @@ class TSData:
             bf, be = bin2d(self.fluxes.T, self.errors.T, self._tm_l_edges, self._tm_r_edges,
                            binning.bins, estimate_errors=estimate_errors)
             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]),
-                          name=self.name, noise_group=self.noise_group,
-                          ephemeris=self.ephemeris, n_baseline=self.n_baseline)
+                       wl_edges=(self._wl_l_edges, self._wl_r_edges),
+                       tm_edges=(binning.bins[:,0], binning.bins[:,1]),
+                       name=self.name,
+                       noise_group=self.noise_group,
+                       ephemeris=self.ephemeris,
+                       n_baseline=self.n_baseline,
+                       ephemeris_group=self.ephemeris_group,
+                       offset_group=self.offset_group)
             if self.ephemeris is not None:
                 d.mask_transit(ephemeris=self.ephemeris)
             return d
@@ -683,6 +716,11 @@ class TSDataSet:
         """Number of noise groups."""
         return len(set(self.noise_groups))
 
+    @property
+    def offset_groups(self) -> list[int]:
+        """List of offset groups."""
+        return [d.offset_group for d in self.data]
+
     @property
     def n_baselines(self) -> list[int]:
         """Number of baseline coefficients for each data set."""

exoiris/tslpf.py

@@ -207,6 +207,7 @@ class TSLPF(LogPosteriorFunction):
         self._init_p_radius_ratios()
         self._init_p_noise()
         self._init_p_baseline()
+        self._init_p_bias()
         self.ps.freeze()
         self.ndim = len(self.ps)
 
@@ -240,23 +241,26 @@ class TSLPF(LogPosteriorFunction):
         self._gp_ferr = []
         self._gp = []
         for d in self.data:
-            self._gp_time.append((tile(d.time[newaxis, :], (d.nwl, 1)) + arange(d.nwl)[:, newaxis]).ravel())
-            self._gp_flux.append(d.fluxes.ravel())
-            self._gp_ferr.append(d.errors.ravel())
+            self._gp_time.append((tile(d.time[newaxis, :], (d.nwl, 1)) + arange(d.nwl)[:, newaxis])[d.mask])
+            self._gp_flux.append(d.fluxes[d.mask])
+            self._gp_ferr.append(d.errors[d.mask])
             self._gp.append(GP(terms.Matern32Term(sigma=self._gp_flux[-1].std(), rho=0.1)))
             self._gp[-1].compute(self._gp_time[-1], yerr=self._gp_ferr[-1], quiet=True)
 
-    def set_gp_hyperparameters(self, sigma: float, rho: float) -> None:
+    def set_gp_hyperparameters(self, sigma: float, rho: float, idata: int | None = None) -> None:
         """Sets the Gaussian Process hyperparameters assuming a Matern32 kernel.
 
         Parameters
         ----------
-        sigma : float
+        sigma
             The kernel amplitude parameter.
 
-        rho : float
+        rho
             The length scale parameter.
 
+        idata
+            The data set for which to set the hyperparameters. If None, the hyperparameters are set for all data sets.
+
         Raises
         ------
         RuntimeError
@@ -264,9 +268,10 @@ class TSLPF(LogPosteriorFunction):
         """
         if self._gp is None:
             raise RuntimeError('The GP needs to be initialized before setting hyperparameters.')
-        for i, gp in enumerate(self._gp):
-            gp.kernel = terms.Matern32Term(sigma=sigma, rho=rho)
-            gp.compute(self._gp_time[i], yerr=self._gp_ferr[i], quiet=True)
+
+        for i in ([idata] or range(self.data.size)):
+            self._gp[i].kernel = terms.Matern32Term(sigma=sigma, rho=rho)
+            self._gp[i].compute(self._gp_time[i], yerr=self._gp_ferr[i], quiet=True)
 
     def set_gp_kernel(self, kernel: terms.Term) -> None:
         """Sets the kernel for the Gaussian Process (GP) model and recomputes the GP.
@@ -341,6 +346,16 @@ class TSLPF(LogPosteriorFunction):
         self._start_baseline = ps.blocks[-1].start
         self._sl_baseline = ps.blocks[-1].slice
 
+    def _init_p_bias(self):
+        ps = self.ps
+        offset_groups = self.data.offset_groups
+        pp = []
+        for i in range(1, max(offset_groups) + 1):
+            pp.append(GParameter(f'bias_{i:02d}', 'bias offset', '', NP(0.0, 1e-6), (-inf, inf)))
+        ps.add_global_block('bias_offsets', pp)
+        self._start_bias = ps.blocks[-1].start
+        self._sl_bias = ps.blocks[-1].slice
+
     def set_ldtk_prior(self, teff, logg, metal, dataset: str = 'visir-lowres', width: float = 50,
                        uncertainty_multiplier: float = 10):
         hw = 0.5 * width
@@ -569,15 +584,21 @@ class TSLPF(LogPosteriorFunction):
         inc = i_from_ba(pv[:, 3], aor)
         ecc = pv[:, 4] ** 2 + pv[:, 5] ** 2
         w = arctan2(pv[:, 5], pv[:, 4])
+        fluxes = []
         if isinstance(self.ldmodel, LDTkLD):
             ldp, istar = self.ldmodel(self.tms[0].mu, ldp)
             ldpi = dstack([ldp, istar])
-            flux = []
             for i, tm in enumerate(self.tms):
-                flux.append(tm.evaluate(k[i], ldpi[:, self.ldmodel.wlslices[i], :], t0, p, aor, inc, ecc, w, copy))
-            return flux
+                fluxes.append(tm.evaluate(k[i], ldpi[:, self.ldmodel.wlslices[i], :], t0, p, aor, inc, ecc, w, copy))
         else:
-            return [tm.evaluate(k[i], ldp[i], t0, p, aor, inc, ecc, w, copy) for i,tm in enumerate(self.tms)]
+            for i, tm in enumerate(self.tms):
+                fluxes.append(tm.evaluate(k[i], ldp[i], t0, p, aor, inc, ecc, w, copy))
+
+        for i, d in enumerate(self.data):
+            if d.offset_group > 0:
+                biases = pv[:, self._start_bias + d.offset_group - 1][:, None, None]
+                fluxes[i] = biases + (1.0 - biases) * fluxes[i]
+        return fluxes
 
     def baseline_model(self, pv):
         pv = atleast_2d(pv)[:, self._sl_baseline]
@@ -646,7 +667,7 @@ class TSLPF(LogPosteriorFunction):
         elif self._nm == NM_GP_FIXED:
             for j in range(npv):
                 for i in range(self.data.size):
-                    lnl[j] += self._gp[i].log_likelihood(self._gp_flux[i] - fmod[i][j].ravel())
+                    lnl[j] += self._gp[i].log_likelihood(self._gp_flux[i] - fmod[i][j][self.data[i].mask])
         else:
             raise NotImplementedError("The free GP noise model hasn't been implemented yet.")
         return lnl if npv > 1 else lnl[0]

exoiris/wlpf.py

@@ -15,7 +15,7 @@
 #  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 from matplotlib.figure import Figure
 from matplotlib.pyplot import subplots, setp
-from numpy import log10, diff, sqrt, floor, ceil, arange, newaxis, nanmean, isfinite
+from numpy import log10, diff, sqrt, floor, ceil, arange, newaxis, nanmean, isfinite, nan, where, nanstd
 from scipy.optimize import minimize
 
 from pytransit import BaseLPF, LinearModelBaseline
@@ -26,16 +26,18 @@ from .tslpf import TSLPF
 class WhiteLPF(BaseLPF):
     def __init__(self, tsa: TSLPF):
         self.tsa = tsa
-        fluxes, times = [], []
+        fluxes, times, errors = [], [], []
         for t, f in zip(tsa.data.times, tsa.data.fluxes):
-            f = nanmean(f, 0)
-            m = isfinite(f)
+            mf = nanmean(f, 0)
+            m = isfinite(mf)
             times.append(t[m])
-            fluxes.append(f[m])
+            fluxes.append(mf[m])
+            errors.append(nanstd(where(m, f, nan), 0) / sqrt(f.shape[0]))
         covs = [(t-t.mean())[:, newaxis] for t in times]
+        self.std_errors = errors
 
-        super().__init__('white', tsa.data.unique_noise_groups, times, fluxes, covariates=covs, wnids=tsa.data.ngids,
-                         pbids=tsa.data.ngids)
+        super().__init__('white', tsa.data.unique_noise_groups, times, fluxes,
+                         covariates=covs, wnids=tsa.data.ngids, pbids=tsa.data.ngids)
         self.set_prior('tc', tsa.ps[tsa.ps.find_pid('tc')].prior)
         self.set_prior('p', tsa.ps[tsa.ps.find_pid('p')].prior)
         self.set_prior('rho', tsa.ps[tsa.ps.find_pid('rho')].prior)
@@ -77,7 +79,7 @@ class WhiteLPF(BaseLPF):
     def plot(self, axs=None, figsize=None, ncols=2) -> Figure:
         if axs is None:
             nrows = int(ceil(self.nlc / ncols))
-            fig, axs = subplots(nrows, ncols, figsize=figsize, sharey='all', squeeze=False)
+            fig, axs = subplots(nrows, ncols, figsize=figsize, sharey='all', squeeze=False, constrained_layout=True)
         else:
             fig = axs[0].get_figure()
 

ExoIris-0.16.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-exoiris/__init__.py,sha256=gaNfxNKXH41yRK35JghqackXpENyB-NOg-JlciqO1YU,1145
-exoiris/binning.py,sha256=-Y9hdK0jZj8DOS82keaprneid2lZ4rCx-keWlKi0LP8,6455
-exoiris/ephemeris.py,sha256=dthBkJztT5yAP6VnnO7jGvxikboFUQBUGPUfBCFrA3w,1316
-exoiris/exoiris.py,sha256=QR6c-4M_koYm8YA6gZst5jWiSfG57ciOTqR9foX0AgI,48315
-exoiris/ldtkld.py,sha256=u4c5Yh6JlG0Zfec7-nOCQGXxIt1VVp9mniFMM7h-L6s,3489
-exoiris/tsdata.py,sha256=uIHml2RKRS6eAF9O0pkdvVj7xL7RqTHfHXQlCUhgtOc,31506
-exoiris/tslpf.py,sha256=gQJpLoz8WWmS6buAupDxFJnenUjXYQe_ZWcq_UZ2kls,27717
-exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
-exoiris/util.py,sha256=5PynwYYHRrzyXJHskBtp2J-pcM59zsA1_VtDxencQm4,4630
-exoiris/wlpf.py,sha256=un-aEevAhqDfCocnP3I5lTdQDkLdmUBEbtvORRVR5LM,4370
-ExoIris-0.16.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ExoIris-0.16.0.dist-info/METADATA,sha256=9_-HWCcU8GrM0a_k2PS_JD22bkmPf7Mi4BxrG0DBuXg,4189
-ExoIris-0.16.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-ExoIris-0.16.0.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
-ExoIris-0.16.0.dist-info/RECORD,,