PyTransit 2.6.19__tar.gz → 2.7.1__tar.gz

{pytransit-2.6.19 → pytransit-2.7.1}/PKG-INFO

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

{pytransit-2.6.19 → pytransit-2.7.1}/PyTransit.egg-info/PKG-INFO

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

{pytransit-2.6.19 → pytransit-2.7.1}/PyTransit.egg-info/SOURCES.txt

@@ -95,7 +95,10 @@ pytransit/models/opencl/qpower2.cl
 pytransit/models/roadrunner/__init__.py
 pytransit/models/roadrunner/common.py
 pytransit/models/roadrunner/ecintersection.py
+pytransit/models/roadrunner/esmodel.py
 pytransit/models/roadrunner/model.py
+pytransit/models/roadrunner/model_eclipse.py
+pytransit/models/roadrunner/model_ecspec.py
 pytransit/models/roadrunner/model_full.py
 pytransit/models/roadrunner/model_simple.py
 pytransit/models/roadrunner/model_trspec.py
@@ -141,6 +144,7 @@ tests/test_limb_darkening.py
 tests/test_ma_quadratic.py
 tests/test_ma_quadratic_nb.py
 tests/test_qpower2_nb.py
+tests/test_roadrunner_eclipse.py
 tests/test_transitmodel_helpers.py
 tests/test_uniform_model.py
 tests/test_uniform_model_nb.py

{pytransit-2.6.19 → pytransit-2.7.1}/pytransit/__init__.py

@@ -41,7 +41,7 @@ Date
 
 """
 
-__version__ = '2.6.19'
+__version__ = '2.7.1'
 
 # Generic
 # -------
@@ -59,7 +59,7 @@ from .models.general import GeneralModel
 from .models.osmodel import OblateStarModel
 from .models.gdmodel import GravityDarkenedModel
 
-from .models import RoadRunnerModel, OblatePlanetModel, TransmissionSpectroscopyModel
+from .models import RoadRunnerModel, OblatePlanetModel, TransmissionSpectroscopyModel, EclipseSpectroscopyModel, ESModel
 
 TSModel = TransmissionSpectroscopyModel
 OPModel = OblatePlanetModel

{pytransit-2.6.19 → pytransit-2.7.1}/pytransit/lpf/rvlpf.py

@@ -32,8 +32,8 @@ from astropy.table import Column
 from corner import corner
 from matplotlib.pyplot import subplots, setp
 from numba import njit
-from numpy import zeros, log, pi, inf, atleast_2d, arange, arctan2, cos, squeeze, median, linspace, \
-    percentile, argsort, sum, concatenate, full, sqrt, ndarray
+from numpy import zeros, log, pi, inf, atleast_2d, arange, arctan2, cos, squeeze, median, linspace, percentile, argsort, \
+    sum, concatenate, full, sqrt, ndarray, floor
 from numpy.random.mtrand import permutation
 
 from pytransit.lpf.logposteriorfunction import LogPosteriorFunction
@@ -57,7 +57,7 @@ def lnlike_normal(o, m, e):
 
 
 class RVLPF(LogPosteriorFunction):
-    def __init__(self, name: str, nplanets: int, times, rvs, rves, rvis=None, slope_order: int = 1):
+    def __init__(self, name: str, nplanets: int, times, rvs, rves, rvis, is_transiting, slope_order: int = 1):
         super().__init__(name)
 
         def transform_input(a):
@@ -76,8 +76,8 @@ class RVLPF(LogPosteriorFunction):
         else:
             rvis = zeros(len(times), 'int')
 
-        self._tref = concatenate(times).mean()
-        self.rvm: RVModel = RVModel(self, nplanets, times, rvs, rves, rvis, slope_order=slope_order)
+        self._tref = floor(concatenate(times).min())
+        self.rvm: RVModel = RVModel(self, nplanets, times, rvs, rves, rvis, is_transiting=is_transiting, slope_order=slope_order)
 
     def model(self, pv):
         return self.rvm.rv_model(pv)
@@ -102,7 +102,7 @@ class RVModel:
     """
 
     def __init__(self, lpf: LogPosteriorFunction, nplanets: int,
-                 times, rvs: Iterable, rves: Iterable, rvis: Iterable,
+                 times, rvs: Iterable, rves: Iterable, rvis: Iterable, is_transiting,
                  tref: Optional[float] = None, slope_order: int = 1):
         self.lpf = lpf
 
@@ -110,6 +110,10 @@ class RVModel:
             assert lpf.nplanets == nplanets
         self.nplanets = nplanets
 
+        if len(is_transiting) != self.nplanets:
+            raise ValueError("The size of the is_transiting list must equal the number of planets.")
+        self.is_transiting = is_transiting
+
         if hasattr(lpf, '_tref'):
             assert tref is None
             self._tref = lpf._tref
@@ -152,12 +156,15 @@ class RVModel:
         self.ps = ps = ParameterSet([])
         pp = []
         for i in range(1, self.nplanets + 1):
-            pp.extend([
-                GParameter(f'tc_{i}', f'zero epoch {i}', 'd', NP(0.0, 0.1), (-inf, inf)),
-                GParameter(f'p_{i}', f'period {i}', 'd', NP(1.0, 1e-5), (0, inf)),
-                GParameter(f'secw_{i}', f'sqrt(e) cos(w) {i}', '', UP(-1.0, 1.0), (-1, 1)),
-                GParameter(f'sesw_{i}', f'sqrt(e) sin(w) {i}', '', UP(-1.0, 1.0), (-1, 1)),
-            ])
+            if self.is_transiting[i-1]:
+                pp.append(GParameter(f't0_{i}', f'zero epoch {i}', 'd', NP(0.0, 0.1), (-inf, inf)))
+            else:
+                pp.append(GParameter(f'm0_{i}', f'reference mean anomaly {i}', 'd', UP(0.0, 2*pi), (0, 2*pi)))
+
+            pp.extend([GParameter(f'p_{i}', f'period {i}', 'd', NP(1.0, 1e-5), (0, inf)),
+                       GParameter(f'secw_{i}', f'sqrt(e) cos(w) {i}', '', UP(-1.0, 1.0), (-1, 1)),
+                       GParameter(f'sesw_{i}', f'sqrt(e) sin(w) {i}', '', UP(-1.0, 1.0), (-1, 1)),
+                       ])
         ps.add_global_block('planets', pp)
         self._start_pl = ps.blocks[-1].start
         self._sl_pl = ps.blocks[-1].slice
@@ -190,9 +197,11 @@ class RVModel:
         self._sl_rv_slope = ps.blocks[-1].slice
         self.ps.freeze()
 
-        pnames = "rv_k_{} tc_{} p_{} secw_{} sesw_{}".split()
+        pnames_tr = "rv_k_{} t0_{} p_{} secw_{} sesw_{}".split()
+        pnames_nt = "rv_k_{} m0_{} p_{} secw_{} sesw_{}".split()
         self.pids = zeros((self.nplanets, 5), 'int')
         for ipl in range(self.nplanets):
+            pnames = pnames_tr if self.is_transiting[ipl] else pnames_nt
             for ip, p in enumerate(pnames):
                 name = p.format(ipl + 1)
                 self.pids[ipl, ip] = self.ps.names.index(name)
@@ -216,7 +225,10 @@ class RVModel:
         planets = planets if planets is not None else arange(self.nplanets)
         for ipl in planets:
             pv = pvp[:, self.pids[ipl]]
-            tc = pv[:, 1] - self._tref
+            if self.is_transiting[ipl]:
+                tc = pv[:, 1] - self._tref
+            else:
+                tc = pv[:, 1] / (2*pi) * pv[:, 2]
             p = pv[:, 2]
             e = pv[:, 3] ** 2 + pv[:, 4] ** 2
             w = arctan2(pv[:, 4], pv[:, 3])
@@ -345,7 +357,10 @@ class RVModel:
             rv_others = median(self.rv_model(pvp, planets=other_planets, add_sv=False, add_slope=False), 0)
 
         period = pv[self.ps.names.index(f'p_{planet + 1}')]
-        tc = pv[self.ps.names.index(f'tc_{planet + 1}')] - self._tref
+        if self.is_transiting[planet]:
+            tc = pv[self.ps.names.index(f't0_{planet + 1}')] - self._tref
+        else:
+            tc = pv[self.ps.names.index(f'm0_{planet + 1}')] / (2*pi) * period
 
         phase = (fold(self._timea, period, tc, 0.5) - 0.5) * period
         phase_model = (fold(rv_time, period, tc, 0.5) - 0.5) * period

{pytransit-2.6.19 → pytransit-2.7.1}/pytransit/models/__init__.py

@@ -14,11 +14,13 @@
 #  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 .transitmodel import TransitModel
+from .transitmodel import TransitModel  # noqa
 from .roadrunner.rrmodel import RoadRunnerModel
 from .roadrunner.opmodel import OblatePlanetModel
 from .roadrunner.tsmodel import TransmissionSpectroscopyModel
+from .roadrunner.esmodel import EclipseSpectroscopyModel
 
 RRModel = RoadRunnerModel
 OPModel = OblatePlanetModel
 TSModel = TransmissionSpectroscopyModel
+ESModel = EclipseSpectroscopyModel

pytransit-2.7.1/pytransit/models/roadrunner/esmodel.py

@@ -0,0 +1,93 @@
+#  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/>.
+#
+#  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 Union, List, Optional
+
+from numpy import ndarray, atleast_1d
+from numba import njit
+
+from ..transitmodel import TransitModel
+from .model_ecspec import esmodel
+
+__all__ = ['EclipseSpectroscopyModel']
+
+
+class EclipseSpectroscopyModel(TransitModel):
+
+    def __init__(self, parallel: bool = False):
+        self.parallel = parallel
+        self.model = njit(parallel=parallel, fastmath=False)(esmodel)
+        super().__init__()
+
+    def evaluate(self, f: ndarray, k: Union[float, ndarray], t0: Union[float, ndarray], p: Union[float, ndarray],
+                 a: Union[float, ndarray], i: Union[float, ndarray], e: Union[float, ndarray] = 0.0,
+                 w: Union[float, ndarray] = 0.0, rstar: Union[float, ndarray] = 1.0) -> ndarray:
+        """Evaluate the transit model for a set of scalar or vector parameters.
+
+        Parameters
+        ----------
+        f
+            Flux ratios either as a 1D vector or 2D array
+        k
+            Radius ratio either as a single float or a 1D vector.
+        t0
+            Transit center(s) as a float or a 1D vector.
+        p
+            Orbital period(s) as a float or a 1D vector.
+        a
+            Orbital semi-major axis (axes) divided by the stellar radius as a float or a 1D vector.
+        i
+            Orbital inclination(s) as a float or a 1D vector.
+        e : optional
+            Orbital eccentricity as a float or a 1D vector.
+        w : optional
+            Argument of periastron as a float or a 1D vector.
+        rstar : optional
+            Stellar radius in solar radii, used to compute the light travel time
+            correction between transit and secondary eclipse. Defaults to 1.0.
+
+        Notes
+        -----
+        The model can be evaluated either for one set of parameters or for many sets of parameters simultaneously. In
+        the first case, the orbital parameters should all be given as floats. In the second case, the orbital parameters
+        should be given as a 1D array-like.
+
+        Returns
+        -------
+        ndarray
+            Modelled flux either as a 3D ndarray.
+        """
+        k, t0, p, a, i, e, w, rstar = map(atleast_1d, (k, t0, p, a, i, e, w, rstar))
+        if rstar.size == 1 and k.size > 1:
+            rstar = rstar.repeat(k.size)
+        return self.model(self.time, k, t0, p, a, i, e, w, rstar, f, self.nsamples[0], self.exptimes[0])
+
+    def __call__(self, f: ndarray, k: Union[float, ndarray], t0: Union[float, ndarray], p: Union[float, ndarray],
+                 a: Union[float, ndarray], i: Union[float, ndarray], e: Union[float, ndarray] = 0.0,
+                 w: Union[float, ndarray] = 0.0, rstar: Union[float, ndarray] = 1.0) -> ndarray:
+        return self.evaluate(f, k, t0, p, a, i, e, w, rstar)

pytransit-2.7.1/pytransit/models/roadrunner/model_eclipse.py

@@ -0,0 +1,83 @@
+from meepmeep import eclipse_light_travel_time
+from meepmeep.utils import eclipse_phase
+
+from numba import njit, prange
+from numpy import zeros, isnan, nan, full, floor, pi
+from numpy.typing import NDArray
+
+from meepmeep.xy.position import solve_xy_p5s, pd_t15sc, bounding_box
+
+from .common import circle_circle_intersection_area_kite as ccia
+
+
+@njit(parallel=False, fastmath=False)
+def eclipse_model(times: NDArray, k: NDArray, t0: NDArray, p: NDArray, a: NDArray, i: NDArray, e: NDArray, w: NDArray,
+                  rstar: float, nlc: int, lcids: NDArray, epids: NDArray, nsamples: int | NDArray,
+                  exptimes: int | NDArray):
+
+    npv = k.shape[0]
+    npt = times.size
+
+    if k.ndim != 1:
+        raise ValueError(" The radius ratio must be given as an 1D array with shape (npv)")
+
+    _exptimes = zeros(nlc)
+    _exptimes[:] = exptimes
+    _nsamples = zeros(nlc)
+    _nsamples[:] = nsamples
+
+    pv_is_good = full(npv, True)
+    xyc = zeros((npv, 2, 5))  # Taylor series coefficients for the (x, y) position
+    bbs = zeros((npv, nlc, 2))
+    eclipse_shifts = zeros(npv)
+    ltts = zeros(npv)
+
+    for ipv in range(npv):
+        if isnan(a[ipv]) or (a[ipv] <= 1.0) or (e[ipv] < 0.0):
+            pv_is_good[ipv] = False
+            continue
+
+        # ------------------------------------------------------#
+        # Calculate the Taylor series expansions for the orbits #
+        # ------------------------------------------------------#
+        eclipse_shifts[ipv] = eclipse_phase(p[ipv], i[ipv], e[ipv], w[ipv])
+        xyc[ipv, :, :] = solve_xy_p5s(eclipse_shifts[ipv], p[ipv], a[ipv], i[ipv], e[ipv], w[ipv])
+        ltts[ipv] = eclipse_light_travel_time(p[ipv], a[ipv], i[ipv], e[ipv], w[ipv], rstar)
+
+        # -----------------------------#
+        # Calculate the bounding boxes #
+        # -----------------------------#
+        bt4, bt1 = bounding_box(k[ipv], xyc[ipv])
+        bbs[ipv, :, 0] = bt1
+        bbs[ipv, :, 1] = bt4
+        for ilc in range(nlc):
+            bbs[ipv, ilc, 0] -= 0.003 + _exptimes[ilc]
+            bbs[ipv, ilc, 1] += 0.003 + _exptimes[ilc]
+
+    # ---------------------------#
+    # Calculate the light curves #
+    # ---------------------------#
+    flux = zeros((npv, npt))
+    for j in prange(npv * npt):
+        ipv = j // npt
+        ipt = j % npt
+
+        if not pv_is_good[ipv]:
+            flux[ipv, ipt] = nan
+            continue
+
+        ilc = lcids[ipt]
+        iep = epids[ilc]
+
+        te = t0[ipv, iep] + eclipse_shifts[ipv] + ltts[ipv]
+        epoch = floor((times[ipt] - te + 0.5 * p[ipv]) / p[ipv])
+        tc = times[ipt] - (te + epoch * p[ipv])
+        if not (bbs[ipv, ilc, 0] <= tc <= bbs[ipv, ilc, 1]):
+            flux[ipv, ipt] = pi * k[ipv] ** 2
+        else:
+            for isample in range(1, nsamples[ilc] + 1):
+                time_offset = exptimes[ilc] * ((isample - 0.5) / nsamples[ilc] - 0.5)
+                z = pd_t15sc(tc + time_offset, xyc[ipv])
+                flux[ipv, ipt] += pi * k[ipv] ** 2 - ccia(1.0, k[ipv], z)[0]
+            flux[ipv, ipt] /= nsamples[ilc]
+    return flux

pytransit-2.7.1/pytransit/models/roadrunner/model_ecspec.py

@@ -0,0 +1,62 @@
+from math import fabs, floor
+
+from meepmeep.utils import d_from_pkaiews, eclipse_phase
+from meepmeep.newton import eclipse_light_travel_time
+from meepmeep.xy.position import solve_xy_p5s, pd_t15sc
+from numpy import zeros, ndarray, isnan, nan, pi
+
+from .common import circle_circle_intersection_area_kite as ccia
+
+__all__ = ['esmodel']
+
+
+def esmodel(times: ndarray, k: ndarray, t0: ndarray, p: ndarray, a: ndarray, i: ndarray, e: ndarray, w: ndarray,
+            rstar: ndarray, fratio: ndarray, nsamples: int, exptime: float) -> ndarray:
+    if k.ndim != 1:
+        raise ValueError(" The radius ratio must be given as an 1D array with shape (npv)")
+
+    if fratio.ndim != 2:
+        raise ValueError(" The flux ratio must be given as a 2D array with shape (npv, npb)")
+
+    npt = times.size
+    npv = fratio.shape[0]
+    npb = fratio.shape[1]
+
+    flux = zeros((npv, npb, npt))  # Model flux
+    xyc = zeros((2, 5))  # Taylor series coefficients for the (x, y) position
+
+    for ipv in range(npv):
+        if isnan(a[ipv]) or (a[ipv] <= 1.0) or (e[ipv] < 0.0):
+            flux[ipv, :, :] = nan
+            continue
+
+        # -----------------------------------------------------#
+        # Calculate the Taylor series expansions for the orbit #
+        # -----------------------------------------------------#
+        eclipse_shift = eclipse_phase(p[ipv], i[ipv], e[ipv], w[ipv])
+        xyc[:, :] = solve_xy_p5s(eclipse_shift, p[ipv], a[ipv], i[ipv], e[ipv], w[ipv])
+        ltt = eclipse_light_travel_time(p[ipv], a[ipv], i[ipv], e[ipv], w[ipv], rstar[ipv])
+        te = t0[ipv] + eclipse_shift + ltt
+
+        # --------------------------------#
+        # Calculate the half-window width #
+        # --------------------------------#
+        hww = 0.5 * d_from_pkaiews(p[ipv], k[ipv], a[ipv], i[ipv], e[ipv], w[ipv], -1, 14)
+        hww = 0.0015 + exptime + hww
+
+        # --------------------------#
+        # Calculate the light curve #
+        # --------------------------#
+        for ipt in range(npt):
+            epoch = floor((times[ipt] - te + 0.5 * p[ipv]) / p[ipv])
+            tc = times[ipt] - (te + epoch * p[ipv])
+            if fabs(tc) > hww:
+                flux[ipv, :, ipt] = 1.0
+            else:
+                for isample in range(1, nsamples + 1):
+                    time_offset = exptime * ((isample - 0.5) / nsamples - 0.5)
+                    z = pd_t15sc(tc + time_offset, xyc)
+                    flux[ipv, :, ipt] += 1.0 - (fratio[ipv, :] * ccia(1.0, k[ipv], z)[0] / pi) / (
+                                1.0 + fratio[ipv, :] * k[ipv] ** 2)
+                flux[ipv, :, ipt] /= nsamples
+    return flux

{pytransit-2.6.19 → pytransit-2.7.1}/pytransit/models/roadrunner/model_full.py

@@ -1,8 +1,7 @@
-from meepmeep.tsorbit import bounding_box
 from numba import njit, prange
 from numpy import zeros, dot, ndarray, isnan, nan, full, floor
 
-from meepmeep.xy.position import solve_xy_p5s, pd_t15sc
+from meepmeep.xy.position import solve_xy_p5s, pd_t15sc, bounding_box
 from meepmeep.utils import d_from_pkaiews
 
 from .common import calculate_weights_2d, interpolate_mean_limb_darkening_s
@@ -82,7 +81,7 @@ def rr_full_serial(times: ndarray, k: ndarray, t0: ndarray, p: ndarray, a: ndarr
         # -----------------------------#
         # Calculate the bounding boxes #
         # -----------------------------#
-        bt1, bt4 = bounding_box(ks[ipv, 0], xyc)
+        bt1, bt4 = bounding_box(ks[ipv, 0], xyc[ipv])
         bbs[ipv, :, 0] = bt1
         bbs[ipv, :, 1] = bt4
         for ilc in range(nlc):
@@ -178,7 +177,7 @@ def rr_full_parallel(times: ndarray, k: ndarray, t0: ndarray, p: ndarray, a: nda
         # -----------------------------#
         # Calculate the bounding boxes #
         # -----------------------------#
-        bt1, bt4 = bounding_box(ks[ipv, 0], xyc)
+        bt1, bt4 = bounding_box(ks[ipv, 0], xyc[ipv])
         bbs[ipv, :, 0] = bt1
         bbs[ipv, :, 1] = bt4
         for ilc in range(nlc):

pytransit-2.7.1/tests/test_roadrunner_eclipse.py

@@ -0,0 +1,61 @@
+#  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.
+
+import unittest
+from math import pi
+
+import numpy as np
+from numpy import ndarray
+
+
+def make_inputs(k=0.1, a=8.0, inc=np.pi / 2, p=2.0, t0=0.0,
+                e=0.0, w=0.0, rstar=1.0,
+                npt=5000, t_start=-0.5, t_end=3.5, nep=1):
+    """Build a canonical single-pv, single-light-curve input set.
+
+    The defaults give a non-grazing hot-Jupiter-like geometry on a
+    circular orbit, with the primary transit at t=0 and the secondary
+    eclipse near t=p/2=1 d.
+    """
+    times = np.linspace(t_start, t_end, npt)
+    k_arr = np.array([k])
+    t0_arr = np.full((1, nep), t0)
+    p_arr = np.array([p])
+    a_arr = np.array([a])
+    i_arr = np.array([inc])
+    e_arr = np.array([e])
+    w_arr = np.array([w])
+    rstar_arr = np.array([rstar])
+    nlc, npb = 1, 1
+    lcids = np.zeros(npt, dtype=np.int64)
+    pbids = np.zeros(nlc, dtype=np.int64)
+    epids = np.zeros(nlc, dtype=np.int64)
+    nsamples = np.ones(nlc, dtype=np.int64)
+    exptimes = np.zeros(nlc)
+    return (times, k_arr, t0_arr, p_arr, a_arr, i_arr, e_arr, w_arr,
+            rstar_arr, nlc, npb, nep,
+            lcids, pbids, epids, nsamples, exptimes)
+
+
+class TestEclipseKernelImport(unittest.TestCase):
+    """Sanity checks that the kernel imports and runs end-to-end."""
+
+    def test_kernel_imports(self):
+        from pytransit.models.roadrunner.model_eclipse import eclipse_model
+        self.assertTrue(callable(eclipse_model))
+
+    def test_kernel_returns_expected_shape(self):
+        from pytransit.models.roadrunner.model_eclipse import eclipse_model
+        args = make_inputs()
+        flux = eclipse_model(*args)
+        self.assertIsInstance(flux, ndarray)
+        self.assertEqual(flux.shape, (1, args[0].size))
+
+
+if __name__ == "__main__":
+    unittest.main()