PyTransit 2.8.1__tar.gz → 2.9.0__tar.gz

{pytransit-2.8.1 → pytransit-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.8.1
+Version: 2.9.0
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2

{pytransit-2.8.1 → pytransit-2.9.0}/PyTransit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.8.1
+Version: 2.9.0
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2

{pytransit-2.8.1 → pytransit-2.9.0}/PyTransit.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ pytransit/lpf/ttvlpf.py
 pytransit/lpf/baselines/__init__.py
 pytransit/lpf/baselines/legendrebaseline.py
 pytransit/lpf/baselines/linearbaseline.py
+pytransit/lpf/baselines/lstsqbaseline.py
 pytransit/lpf/loglikelihood/__init__.py
 pytransit/lpf/loglikelihood/celeriteloglikelihood.py
 pytransit/lpf/loglikelihood/clloglikelihood.py
@@ -69,12 +70,16 @@ pytransit/models/qpower2_cl.py
 pytransit/models/transitmodel.py
 pytransit/models/uniform.py
 pytransit/models/limb_darkening/__init__.py
+pytransit/models/limb_darkening/evaluation.py
+pytransit/models/limb_darkening/exponential.py
 pytransit/models/limb_darkening/general.py
 pytransit/models/limb_darkening/linear.py
+pytransit/models/limb_darkening/logarithmic.py
 pytransit/models/limb_darkening/nonlinear.py
 pytransit/models/limb_darkening/power_2.py
 pytransit/models/limb_darkening/quadratic.py
 pytransit/models/limb_darkening/quadratic_tri.py
+pytransit/models/limb_darkening/square_root.py
 pytransit/models/limb_darkening/uniform.py
 pytransit/models/numba/__init__.py
 pytransit/models/numba/gdmodel.py
@@ -138,11 +143,15 @@ pytransit/utils/tess.py
 pytransit/utils/io/__init__.py
 pytransit/utils/io/lightcurvedata.py
 tests/test_contamination.py
+tests/test_ecintersection.py
 tests/test_limb_darkening.py
+tests/test_lstsqbaseline.py
 tests/test_ma_quadratic.py
 tests/test_ma_quadratic_nb.py
+tests/test_opmodel.py
 tests/test_qpower2_nb.py
 tests/test_roadrunner_eclipse.py
+tests/test_rrmodel.py
 tests/test_uniform_model.py
 tests/test_uniform_model_nb.py
 tests/test_z.py

{pytransit-2.8.1 → pytransit-2.9.0}/pytransit/__init__.py

@@ -41,7 +41,7 @@ Date
 
 """
 
-__version__ = '2.8.1'
+__version__ = '2.9.0'
 
 # Generic
 # -------
@@ -86,6 +86,7 @@ from .lpf.transitlpf import TransitLPF
 from .lpf.cntlpf import PhysContLPF
 from .lpf.baselines.legendrebaseline import LegendreBaseline
 from .lpf.baselines.linearbaseline import LinearModelBaseline
+from .lpf.baselines.lstsqbaseline import LSTSQBaseline
 from .lpf.transitanalysis import TransitAnalysis
 
 # Utilities

pytransit-2.9.0/pytransit/lpf/baselines/lstsqbaseline.py

@@ -0,0 +1,236 @@
+#  PyTransit: fast and easy exoplanet transit modelling in Python.
+#  Copyright (C) 2010-2019  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 typing import Optional
+
+from numpy import (asarray, atleast_2d, ones, zeros, hstack, unique, isfinite, nan, ndarray,
+                   errstate, where)
+from numpy.linalg import pinv, LinAlgError, cond
+
+
+class LSTSQBaseline:
+    """A parameterless multiplicative baseline fitted by linear least squares.
+
+    ``LSTSQBaseline`` models the same linear-in-covariates baseline as
+    :class:`~pytransit.lpf.baselines.linearbaseline.LinearModelBaseline`, but adds *no*
+    free parameters to the LPF's parameter set. Instead, the baseline coefficients are
+    solved for directly at every evaluation by least-squares fitting the relative
+    residuals ``flux_obs / flux_model``.
+
+    This works because the baseline is linear in its coefficients, so conditional on the
+    transit model they have a closed-form maximum-likelihood solution. The coefficients
+    are *profiled out* rather than sampled.
+
+    .. note::
+       Profiling is not marginalisation. The posterior conditions on the best-fit
+       baseline rather than integrating over it, so parameter uncertainties are somewhat
+       underestimated relative to a fully marginalised treatment.
+
+    The design matrix is fixed (it depends only on the covariates, never on the parameter
+    vector), so its pseudoinverse is computed once in :meth:`init_data`. Each call is then
+    two small matrix products, fully vectorised over the parameter vector population.
+
+    Usage
+    -----
+    ``LSTSQBaseline`` does not join the ``BaseLPF._baseline_models`` chain: those models
+    are called as ``blm(pv, bl)`` and are evaluated *before* the transit model, an ordering
+    a least-squares baseline cannot satisfy. An LPF opts in by overriding ``flux_model``::
+
+        class MyLPF(BaseLPF):
+            def _init_baseline(self):
+                self.lstsq_baseline = LSTSQBaseline(self)
+
+            def flux_model(self, pv):
+                fmod = self.transit_model(pv)
+                return fmod * self.lstsq_baseline(fmod) + self.trends(pv)
+
+    Because the model is not registered with ``_add_baseline_model``, ``lpf.baseline(pv)``
+    will *not* return this baseline. Plotting helpers that rely on ``lpf.baseline(pv)``
+    should call ``lpf.lstsq_baseline(lpf.transit_model(pv))`` instead.
+
+    Parameters
+    ----------
+    lpf
+        The log posterior function the baseline belongs to. Its data must already be
+        initialised, and it must have been given covariates.
+    name
+        Name of the baseline model.
+    lcids
+        Indices of the light curves the baseline is applied to. Defaults to all of them.
+        Points belonging to light curves not covered keep a baseline of exactly 1.0.
+    """
+
+    def __init__(self, lpf, name: str = 'lstsq', lcids=None):
+        self.name = name
+        self.lpf = lpf
+
+        if lpf.lcids is None:
+            raise ValueError('The LPF data needs to be initialised before initialising LSTSQBaseline.')
+
+        if lpf.covariates is None:
+            raise ValueError('LSTSQBaseline requires the LPF to be initialised with covariates.')
+
+        self._bl: Optional[ndarray] = None
+        self.init_data(lcids)
+
+    @staticmethod
+    def normalize_covariates(covariates: ndarray) -> ndarray:
+        """Normalise a light curve's covariate matrix before the intercept column is added.
+
+        Each column is standardised to zero mean and unit standard deviation. Mixing a
+        column on an arbitrary scale (raw BJD ~2.46e6, pixel positions ~1e3) with an
+        intercept column of ones makes the design matrix badly conditioned, and ``pinv``
+        returns a numerically poor solution rather than raising.
+
+        ``BaseLPF._init_data`` already standardises the covariates it stores, so this is
+        normally a no-op. It is applied anyway because standardisation is idempotent and
+        this class may be handed covariates that did not come through that path.
+
+        Constant columns are only centred: they carry no information, and scaling them
+        would divide by zero. A design matrix left rank deficient by such a column is
+        caught by :meth:`_check_conditioning`.
+
+        Parameters
+        ----------
+        covariates
+            Covariate matrix of shape ``(npt, ncov)``.
+
+        Returns
+        -------
+        The standardised covariate matrix, same shape as the input.
+        """
+        cs = covariates.std(0)
+        return (covariates - covariates.mean(0)) / where(cs > 0.0, cs, 1.0)
+
+    def init_data(self, lcids=None):
+        """Build the per-light-curve design matrices and their pseudoinverses."""
+        self.lcids = lcids if lcids is not None else unique(self.lpf.lcids)
+        self.nlc = self.lcids.size
+        self.slices = [self.lpf.lcslices[lcid] for lcid in self.lcids]
+
+        self.covs = []
+        self.pinvs = []
+        for i, lcid in enumerate(self.lcids):
+            cv = self.normalize_covariates(asarray(self.lpf.covariates[lcid], 'd'))
+            if cv.ndim == 1:
+                cv = cv[:, None]
+            x = hstack([ones((cv.shape[0], 1)), cv])
+            self._check_conditioning(x, lcid)
+            try:
+                self.pinvs.append(pinv(x))
+            except LinAlgError as e:
+                raise LinAlgError(f'Failed to invert the {self.name} design matrix for light curve {lcid}: {e}')
+            self.covs.append(x)
+
+        self.ncoef = [x.shape[1] for x in self.covs]
+
+        # Flat mask of the points this baseline covers. Points outside it stay at 1.0.
+        self.mask = zeros(self.lpf.lcids.size, bool)
+        for sl in self.slices:
+            self.mask[sl] = 1
+
+    @staticmethod
+    def _check_conditioning(x: ndarray, lcid: int, limit: float = 1e10) -> None:
+        with errstate(all='ignore'):
+            c = cond(x)
+        if not isfinite(c) or c > limit:
+            raise ValueError(
+                f'The design matrix for light curve {lcid} is singular or badly conditioned '
+                f'(condition number {c:.3e}). The covariates are standardised automatically, so '
+                f'this points to duplicate, constant, or linearly dependent covariate columns.')
+
+    def _baseline_array(self, npv: int) -> ndarray:
+        """Return the cached output buffer, reallocating it only when `npv` changes."""
+        if self._bl is None or self._bl.shape[0] != npv:
+            self._bl = ones((npv, self.lpf.timea.size))
+        return self._bl
+
+    def _observed_flux(self, oflux) -> ndarray:
+        """Validate the observed flux and return it as a 2D array broadcastable over `npv`."""
+        of = atleast_2d(self.lpf.ofluxa if oflux is None else asarray(oflux, 'd'))
+        if of.shape[-1] != self.lpf.timea.size:
+            raise ValueError(f'The observed flux has {of.shape[-1]} points, but the LPF data has '
+                             f'{self.lpf.timea.size}.')
+        return of
+
+    def _fit(self, fmod: ndarray, oflux: ndarray, i: int) -> ndarray:
+        """Least-squares coefficients for light curve `i`, for all parameter vectors."""
+        sl = self.slices[i]
+        with errstate(divide='ignore', invalid='ignore'):
+            res = oflux[:, sl] / fmod[:, sl]            # (npv, npt_lc)
+        return res @ self.pinvs[i].T                    # (npv, ncoef)
+
+    def coefficients(self, fmod, oflux=None):
+        """Fit the baseline and return its coefficients rather than its evaluation.
+
+        Parameters
+        ----------
+        fmod
+            Model fluxes, either a 1D ``(npt,)`` array or a 2D ``(npv, npt)`` array.
+        oflux
+            Observed fluxes to fit against, either a 1D ``(npt,)`` array or a 2D
+            ``(npv, npt)`` array. Defaults to the LPF's own ``ofluxa``.
+
+        Returns
+        -------
+        A list with one entry per covered light curve. Each entry has shape
+        ``(npv, ncoef)`` for a 2D `fmod` and ``(ncoef,)`` for a 1D one, where the first
+        coefficient is the intercept. The coefficient count may differ between light
+        curves, which is why this is a list rather than an array.
+        """
+        fmod = asarray(fmod, 'd')
+        fm = atleast_2d(fmod)
+        of = self._observed_flux(oflux)
+        cs = [self._fit(fm, of, i) for i in range(self.nlc)]
+        return cs if fmod.ndim > 1 else [c[0] for c in cs]
+
+    def __call__(self, fmod, oflux=None):
+        """Fit and evaluate the baseline for a set of model fluxes.
+
+        Parameters
+        ----------
+        fmod
+            Model fluxes, either a 1D ``(npt,)`` array or a 2D ``(npv, npt)`` array,
+            where `npt` is the total number of datapoints in the LPF.
+        oflux
+            Observed fluxes to fit against, either a 1D ``(npt,)`` array or a 2D
+            ``(npv, npt)`` array. Defaults to the LPF's own ``ofluxa``, which is what a
+            likelihood evaluation wants; pass it explicitly to fit the baseline against
+            simulated or otherwise modified data.
+
+        Returns
+        -------
+        The multiplicative baseline, shaped like `fmod`. A parameter vector whose fit
+        fails, or whose residuals are not finite, gets an all-NaN baseline, which
+        propagates to a non-finite log likelihood and is rejected by the sampler.
+
+        .. warning::
+           The returned array is a reused internal buffer that the next call overwrites.
+           Copy it if you need to keep it.
+        """
+        fmod = asarray(fmod, 'd')
+        fm = atleast_2d(fmod)
+        of = self._observed_flux(oflux)
+        bl = self._baseline_array(fm.shape[0])
+
+        for i, sl in enumerate(self.slices):
+            b = self._fit(fm, of, i) @ self.covs[i].T   # (npv, npt_lc)
+            bad = ~isfinite(b).all(axis=1)
+            if bad.any():
+                b[bad] = nan
+            bl[:, sl] = b
+
+        return bl if fmod.ndim > 1 else bl[0]

{pytransit-2.8.1 → pytransit-2.9.0}/pytransit/lpf/lpf.py

@@ -303,9 +303,15 @@ class BaseLPF(LogPosteriorFunction):
         # Initialise the covariate arrays, if given
         # -----------------------------------------
         if covariates is not None:
-            self.covariates = covariates
-            for cv in self.covariates:
-                cv = (cv - cv.mean(0)) / cv.std(0)
+            # Standardise the covariates to zero mean and unit standard deviation. This keeps
+            # the baseline design matrices well conditioned and makes the covariate coefficient
+            # priors comparable across covariates. Constant columns are only centred, since
+            # they cannot be scaled.
+            self.covariates = []
+            for cv in covariates:
+                cv = asarray(cv, 'd')
+                cs = cv.std(0)
+                self.covariates.append((cv - cv.mean(0)) / where(cs > 0.0, cs, 1.0))
             #self.ncovs = self.covariates[0].shape[1]
             #self.covsize = array([c.size for c in self.covariates])
             #self.covstart = concatenate([[0], self.covsize.cumsum()[:-1]])
@@ -561,7 +567,7 @@ class BaseLPF(LogPosteriorFunction):
             if self.errors is not None:
                 errors.append(self.errors[i][mask])
 
-        self._init_data(times=times, fluxes=fluxes, covariates=self.covariates, pbids=self.pbids,
+        self._init_data(times=times, fluxes=fluxes, covariates=covariates, pbids=self.pbids,
                         errors=(errors if self.errors is not None else None), wnids=self.noise_ids,
                         nsamples=self.nsamples, exptimes=self.exptimes)
 

pytransit-2.9.0/pytransit/models/limb_darkening/__init__.py

@@ -0,0 +1,31 @@
+"""Numba-accelerated limb darkening models.
+
+Each model is defined by an intensity profile function ``ld_<model>(mu, pv)``
+and, where an analytic solution exists, a disk-integrated stellar intensity
+function ``ldi_<model>(pv)`` returning 2*pi * int_0^1 I(mu) mu dmu, and a
+derivative function ``ldd_<model>(mu, pv)``.
+"""
+from .evaluation import evaluate_ld, evaluate_ldi
+from .exponential import ld_exponential, ldi_exponential
+from .general import ld_general, ldi_general
+from .linear import ld_linear, ldi_linear, ldd_linear
+from .logarithmic import ld_logarithmic, ldi_logarithmic
+from .nonlinear import ld_nonlinear, ldi_nonlinear
+from .power_2 import ld_power_2, ldi_power_2, ldd_power_2, ld_power_2_pm, ldi_power_2_pm
+from .quadratic import ld_quadratic, ldi_quadratic, ldd_quadratic
+from .quadratic_tri import ld_quadratic_tri, ldi_quadratic_tri
+from .square_root import ld_square_root, ldi_square_root
+from .uniform import ld_uniform, ldi_uniform
+
+__all__ = ['ld_uniform', 'ldi_uniform',
+           'ld_linear', 'ldi_linear', 'ldd_linear',
+           'ld_quadratic', 'ldi_quadratic', 'ldd_quadratic',
+           'ld_quadratic_tri', 'ldi_quadratic_tri',
+           'ld_nonlinear', 'ldi_nonlinear',
+           'ld_general', 'ldi_general',
+           'ld_power_2', 'ldi_power_2', 'ldd_power_2',
+           'ld_power_2_pm', 'ldi_power_2_pm',
+           'ld_square_root', 'ldi_square_root',
+           'ld_logarithmic', 'ldi_logarithmic',
+           'ld_exponential', 'ldi_exponential',
+           'evaluate_ld', 'evaluate_ldi']

pytransit-2.9.0/pytransit/models/limb_darkening/evaluation.py

@@ -0,0 +1,55 @@
+from numba import njit
+from numpy import zeros
+
+
+@njit
+def evaluate_ld(ldm, mu, pvo):
+    """Evaluate a limb darkening model for 1D, 2D, or 3D parameter arrays.
+
+    The parameters can be given as a 1D array with a shape (nldc), a 2D array
+    with a shape (npb, nldc), or a 3D array with a shape (npv, npb, nldc),
+    where nldc is the number of limb darkening coefficients, npb is the number
+    of passbands, and npv is the number of parameter vectors.
+
+    Returns the limb darkening profiles as a 3D array with a shape
+    (npv, npb, nmu).
+    """
+    if pvo.ndim == 1:
+        pv = pvo.reshape((1, 1, -1))
+    elif pvo.ndim == 2:
+        pv = pvo.reshape((1, pvo.shape[0], -1))
+    else:
+        pv = pvo
+
+    npv = pv.shape[0]
+    npb = pv.shape[1]
+    ldp = zeros((npv, npb, mu.size))
+    for ipv in range(npv):
+        for ipb in range(npb):
+            ldp[ipv, ipb, :] = ldm(mu, pv[ipv, ipb])
+    return ldp
+
+
+@njit
+def evaluate_ldi(ldi, pvo):
+    """Evaluate a disk-integrated stellar intensity for 1D, 2D, or 3D parameter arrays.
+
+    The parameters follow the same conventions as in ``evaluate_ld``.
+
+    Returns the disk-integrated stellar intensities as a 2D array with a
+    shape (npv, npb).
+    """
+    if pvo.ndim == 1:
+        pv = pvo.reshape((1, 1, -1))
+    elif pvo.ndim == 2:
+        pv = pvo.reshape((1, pvo.shape[0], -1))
+    else:
+        pv = pvo
+
+    npv = pv.shape[0]
+    npb = pv.shape[1]
+    istar = zeros((npv, npb))
+    for ipv in range(npv):
+        for ipb in range(npb):
+            istar[ipv, ipb] = ldi(pv[ipv, ipb])
+    return istar

pytransit-2.9.0/pytransit/models/limb_darkening/exponential.py

@@ -0,0 +1,15 @@
+from math import pi
+
+from numba import njit
+from numpy import exp
+
+
+@njit(fastmath=True)
+def ld_exponential(mu, pv):
+    return 1. - pv[0] * (1. - mu) - pv[1] / (1. - exp(mu))
+
+
+@njit(fastmath=True)
+def ldi_exponential(pv):
+    # -int_0^1 mu/(1-exp(mu)) dmu = pi^2/6 + ln(1-1/e) - Li2(1/e)
+    return 2 * pi * (0.5 - pv[0] / 6 + 0.7775046341122480 * pv[1])

pytransit-2.9.0/pytransit/models/limb_darkening/general.py

@@ -0,0 +1,21 @@
+from math import pi
+
+from numba import njit
+from numpy import ones
+
+
+@njit(fastmath=True)
+def ld_general(mu, pv):
+    """Giménez (2006) general limb darkening model: I(mu) = 1 - sum c_i (1 - mu^(i+1))."""
+    ldp = ones(mu.size)
+    for i in range(pv.size):
+        ldp -= pv[i] * (1.0 - mu ** (i + 1))
+    return ldp
+
+
+@njit(fastmath=True)
+def ldi_general(pv):
+    istar = 0.5
+    for i in range(pv.size):
+        istar -= pv[i] * (0.5 - 1.0 / (i + 3))
+    return 2 * pi * istar

pytransit-2.9.0/pytransit/models/limb_darkening/logarithmic.py

@@ -0,0 +1,14 @@
+from math import pi
+
+from numba import njit
+from numpy import log
+
+
+@njit(fastmath=True)
+def ld_logarithmic(mu, pv):
+    return 1. - pv[0] * (1. - mu) - pv[1] * mu * log(mu)
+
+
+@njit(fastmath=True)
+def ldi_logarithmic(pv):
+    return 2 * pi * (0.5 - pv[0] / 6 + pv[1] / 9)

pytransit-2.9.0/pytransit/models/limb_darkening/nonlinear.py

@@ -0,0 +1,13 @@
+from math import pi
+
+from numba import njit
+
+
+@njit(fastmath=True)
+def ld_nonlinear(mu, pv):
+    return 1. - pv[0] * (1. - mu**0.5) - pv[1] * (1. - mu) - pv[2] * (1. - mu**1.5) - pv[3] * (1. - mu ** 2)
+
+
+@njit(fastmath=True)
+def ldi_nonlinear(pv):
+    return 2 * pi * (0.5 - pv[0] / 10 - pv[1] / 6 - 3 * pv[2] / 14 - pv[3] / 4)

{pytransit-2.8.1 → pytransit-2.9.0}/pytransit/models/limb_darkening/power_2.py

@@ -1,7 +1,7 @@
 from math import pi
 
 from numba import njit
-from numpy import zeros, log
+from numpy import zeros, log, log2
 
 
 @njit(fastmath=True)
@@ -10,7 +10,7 @@ def ld_power_2(mu, pv):
 
 
 @njit
-def ldi_power_2(mu, pv):
+def ldi_power_2(pv):
     return 2 * pi * (0.5 - 0.5 * pv[0] + pv[0] / (pv[1] + 2.0))
 
 
@@ -20,4 +20,18 @@ def ldd_power_2(mu, pv):
     ldd[0] = pv[0]*pv[1]*mu**(pv[1]-1.0)
     ldd[1] = mu**pv[1] - 1.0
     ldd[2] = pv[0]*mu**pv[1] * log(mu)
-    return ldd
+    return ldd
+
+
+@njit(fastmath=True)
+def ld_power_2_pm(mu, pv):
+    c = 1 - pv[0] + pv[1]
+    a = log2(c/pv[1])
+    return 1. - c * (1. - mu**a)
+
+
+@njit
+def ldi_power_2_pm(pv):
+    c = 1 - pv[0] + pv[1]
+    a = log2(c/pv[1])
+    return 2 * pi * (0.5 - 0.5 * c + c / (a + 2.0))

pytransit-2.9.0/pytransit/models/limb_darkening/square_root.py

@@ -0,0 +1,14 @@
+from math import pi
+
+from numba import njit
+from numpy import sqrt
+
+
+@njit(fastmath=True)
+def ld_square_root(mu, pv):
+    return 1. - pv[0] * (1. - mu) - pv[1] * (1. - sqrt(mu))
+
+
+@njit(fastmath=True)
+def ldi_square_root(pv):
+    return 2 * pi * (0.5 - pv[0] / 6 - pv[1] / 10)

pytransit-2.9.0/pytransit/models/numba/ldmodels.py

@@ -0,0 +1,21 @@
+#  PyTransit: fast and easy exoplanet transit modelling in Python.
+#  Copyright (C) 2010-2020  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/>.
+"""Deprecated: the limb darkening models live in ``pytransit.models.limb_darkening``.
+
+This module re-exports them for backwards compatibility.
+"""
+from ..limb_darkening import *
+from ..limb_darkening import __all__

{pytransit-2.8.1 → pytransit-2.9.0}/pytransit/models/roadrunner/common.py

@@ -237,4 +237,27 @@ def interpolate_mean_limb_darkening_v(gs, dg, lda):
     r = zeros(gs.size)
     for i in range(gs.size):
         r[i] = interpolate_mean_limb_darkening_s(gs[i], dg, lda)
-    return r
+    return r
+
+@njit(fastmath=True)
+def interpolate_limb_darkening_s(z, zm, ldp):
+    """Interpolate a tabulated limb darkening profile at a normalized distance z.
+
+    Linear interpolation of the limb darkening profile over the (non-uniform) profile node
+    grid `zm`, clamped to the last node beyond the edge of the grid. Used by the small-planet
+    approximation, where the mean intensity blocked by the planet is approximated by the
+    stellar intensity at the planet's center.
+    """
+    if z < 0.0:
+        return nan
+    if z >= zm[-1]:
+        return ldp[-1]
+    i = zm.size // 2
+    if z > zm[i]:
+        while z > zm[i + 1]:
+            i += 1
+    else:
+        while z < zm[i]:
+            i -= 1
+    a = (z - zm[i]) / (zm[i + 1] - zm[i])
+    return (1.0 - a) * ldp[i] + a * ldp[i + 1]