PyTransit 2.7.0__tar.gz → 2.7.1__tar.gz

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

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

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

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

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

@@ -97,6 +97,7 @@ 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
@@ -143,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.7.0 → pytransit-2.7.1}/pytransit/__init__.py

@@ -41,7 +41,7 @@ Date
 
 """
 
-__version__ = '2.7.0'
+__version__ = '2.7.1'
 
 # Generic
 # -------

{pytransit-2.7.0 → 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.7.0 → pytransit-2.7.1}/pytransit/models/roadrunner/esmodel.py

@@ -46,7 +46,7 @@ class EclipseSpectroscopyModel(TransitModel):
 
     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) -> ndarray:
+                 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
@@ -67,6 +67,9 @@ class EclipseSpectroscopyModel(TransitModel):
             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
         -----
@@ -79,10 +82,12 @@ class EclipseSpectroscopyModel(TransitModel):
         ndarray
             Modelled flux either as a 3D ndarray.
         """
-        k, t0, p, a, i, e, w = map(atleast_1d, (k, t0, p, a, i, e, w))
-        return self.model(self.time, k, t0, p, a, i, e, w, f, self.nsamples[0], self.exptimes[0])
+        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) -> ndarray:
-        return self.evaluate(f, k, t0, p, a, i, e, w)
+                 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.0 → pytransit-2.7.1}/pytransit/models/roadrunner/model_ecspec.py

@@ -1,6 +1,7 @@
 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
 
@@ -10,7 +11,7 @@ __all__ = ['esmodel']
 
 
 def esmodel(times: ndarray, k: ndarray, t0: ndarray, p: ndarray, a: ndarray, i: ndarray, e: ndarray, w: ndarray,
-            fratio: ndarray, nsamples: int, exptime: float) -> 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)")
 
@@ -34,7 +35,8 @@ def esmodel(times: ndarray, k: ndarray, t0: ndarray, p: ndarray, a: ndarray, i:
         # -----------------------------------------------------#
         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])
-        te = t0[ipv] + eclipse_shift
+        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 #

{pytransit-2.7.0 → 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()