PyTransit 2.6.18__tar.gz → 2.7.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.6.18
+Version: 2.7.0
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2
@@ -17,7 +17,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: arviz
-Requires-Dist: numpy
+Requires-Dist: numpy>=2.0.0
 Requires-Dist: scipy
 Requires-Dist: pandas
 Requires-Dist: xarray

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.6.18
+Version: 2.7.0
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2
@@ -17,7 +17,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: arviz
-Requires-Dist: numpy
+Requires-Dist: numpy>=2.0.0
 Requires-Dist: scipy
 Requires-Dist: pandas
 Requires-Dist: xarray

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

@@ -95,7 +95,9 @@ 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_ecspec.py
 pytransit/models/roadrunner/model_full.py
 pytransit/models/roadrunner/model_simple.py
 pytransit/models/roadrunner/model_trspec.py
@@ -136,6 +138,8 @@ pytransit/utils/tess.py
 pytransit/utils/io/__init__.py
 pytransit/utils/io/lightcurvedata.py
 tests/test_contamination.py
+tests/test_jax_uniformdisk.py
+tests/test_limb_darkening.py
 tests/test_ma_quadratic.py
 tests/test_ma_quadratic_nb.py
 tests/test_qpower2_nb.py

{pytransit-2.6.18 → pytransit-2.7.0}/PyTransit.egg-info/requires.txt

@@ -1,5 +1,5 @@
 arviz
-numpy
+numpy>=2.0.0
 scipy
 pandas
 xarray

{pytransit-2.6.18 → pytransit-2.7.0}/pytransit/__init__.py

@@ -41,7 +41,7 @@ Date
 
 """
 
-__version__ = '2.6.18'
+__version__ = '2.7.0'
 
 # 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.18 → pytransit-2.7.0}/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.6.18 → pytransit-2.7.0}/pytransit/models/ldmodel.py

@@ -15,7 +15,7 @@
 #  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from typing import Tuple
-from numpy import linspace, trapz, sqrt, ndarray, zeros, pi
+from numpy import linspace, trapezoid, sqrt, ndarray, zeros, pi
 
 
 class LDModel:
@@ -35,5 +35,5 @@ class LDModel:
         ldi = zeros((npv, npb))
         for ipv in range(npv):
             for ipb in range(npb):
-                ldi[ipv,ipb] = 2. * pi * trapz(self._int_z * self._evaluate(self._int_mu, x), self._int_z)
+                ldi[ipv,ipb] = 2. * pi * trapezoid(self._int_z * self._evaluate(self._int_mu, x), self._int_z)
         return ldi

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

@@ -0,0 +1,88 @@
+#  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) -> 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.
+
+        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 = 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])
+
+    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)

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

@@ -0,0 +1,60 @@
+from math import fabs, floor
+
+from meepmeep.utils import d_from_pkaiews, eclipse_phase
+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,
+            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])
+        te = t0[ipv] + eclipse_shift
+
+        # --------------------------------#
+        # 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.18 → pytransit-2.7.0}/pytransit/models/roadrunner/rrmodel_cl.py

@@ -23,7 +23,7 @@ import warnings
 from pyopencl import CompilerWarning
 
 from numpy import array, uint32, float32, int32, asarray, zeros, ones, unique, atleast_2d, squeeze, ndarray, \
-    concatenate, empty, linspace, diff, trapz
+    concatenate, empty, linspace, diff, trapezoid
 from ..ldmodel import LDModel
 
 from .common import create_z_grid
@@ -344,7 +344,7 @@ class RoadRunnerModelCL(TransitModel):
                 ldpi = evaluate_ld(self.ldmodel, self._ldmu, ldc)
                 for ipv in range(self.npv):
                     for ipb in range(self.npb):
-                        istar[ipv, ipb] = 2 * pi * trapz(self._ldz * ldpi[ipv,ipb], self._ldz)
+                        istar[ipv, ipb] = 2 * pi * trapezoid(self._ldz * ldpi[ipv,ipb], self._ldz)
 
         # Copy the limb darkening profiles and their integrals to the GPU
         cl.enqueue_copy(self.queue, self._b_ldp, ldp.astype('float32'))

{pytransit-2.6.18 → pytransit-2.7.0}/requirements.txt

@@ -1,5 +1,5 @@
 arviz
-numpy
+numpy >= 2.0.0
 scipy
 pandas
 xarray

pytransit-2.7.0/tests/test_jax_uniformdisk.py

@@ -0,0 +1,195 @@
+"""Tests for the JAX uniform-disk transit model.
+
+Verifies:
+1. Analytical correctness (mid-transit depth = k^2 for full containment)
+2. jax.jit compatibility
+3. jax.value_and_grad produces finite gradients
+4. Edge cases: grazing transit, full containment, no transit
+"""
+
+import numpy as np
+import jax
+jax.config.update("jax_enable_x64", True)
+import jax.numpy as jnp
+import pytest
+
+from pytransit.backends.jax.uniformdisk import uniform_model as jax_uniform
+
+# Shared orbital parameters for a typical hot Jupiter transit
+T0 = 0.0
+P = 2.5
+A = 8.0
+I = np.radians(87.0)
+E = 0.0
+W = 0.5 * np.pi
+TIMES = np.linspace(-0.15, 0.15, 300)
+
+
+class TestAnalytical:
+    """Check against known analytical results."""
+
+    def test_mid_transit_depth(self):
+        """At mid-transit with b~0, flux deviation should be -k^2."""
+        k = 0.1
+        # Use near-zero impact parameter (i ~ 90 deg)
+        inc = np.radians(89.99)
+        times = jnp.array([0.0])
+        flux = np.asarray(jax_uniform(times, k, T0, P, A, inc, E, W))
+        np.testing.assert_allclose(flux[0], -k**2, atol=1e-6)
+
+    @pytest.mark.parametrize("k", [0.05, 0.1, 0.15])
+    def test_out_of_transit_is_zero(self, k):
+        """Far from transit, flux deviation should be zero."""
+        times = jnp.array([0.5, 1.0, -0.5])
+        flux = np.asarray(jax_uniform(times, k, T0, P, A, I, E, W))
+        np.testing.assert_allclose(flux, 0.0, atol=1e-12)
+
+    def test_transit_is_symmetric(self):
+        """Transit light curve should be symmetric about t0 for circular orbit."""
+        k = 0.1
+        times = jnp.linspace(-0.1, 0.1, 201)
+        flux = np.asarray(jax_uniform(times, k, T0, P, A, I, E, W))
+        np.testing.assert_allclose(flux, flux[::-1], atol=5e-7)
+
+
+class TestJIT:
+    """Model should work under jax.jit."""
+
+    def test_jit_produces_correct_results(self):
+        k = 0.1
+        times = jnp.array(TIMES)
+        flux_eager = np.asarray(jax_uniform(times, k, T0, P, A, I, E, W))
+        flux_jit = np.asarray(jax.jit(jax_uniform)(times, k, T0, P, A, I, E, W))
+        np.testing.assert_allclose(flux_jit, flux_eager, atol=1e-6)
+
+
+class TestGradients:
+    """jax.value_and_grad should return finite gradients."""
+
+    def test_grad_wrt_k(self):
+        def loss(k):
+            return jnp.sum(jax_uniform(jnp.array(TIMES), k, T0, P, A, I, E, W))
+
+        val, grad = jax.value_and_grad(loss)(0.1)
+        assert jnp.isfinite(val)
+        assert jnp.isfinite(grad)
+        assert grad != 0.0  # k definitely affects the flux
+
+    def test_grad_wrt_all_params(self):
+        def loss(k, t0, p, a, inc, e, w):
+            return jnp.sum(jax_uniform(jnp.array(TIMES), k, t0, p, a, inc, e, w))
+
+        argnums = tuple(range(7))
+        val, grads = jax.value_and_grad(loss, argnums=argnums)(0.1, T0, P, A, I, E, W)
+        assert jnp.isfinite(val)
+        for j, g in enumerate(grads):
+            assert jnp.isfinite(g), f"Non-finite gradient for argnum {j}: {g}"
+
+
+class TestEdgeCases:
+    """Edge cases: grazing transit, full containment, no overlap."""
+
+    def test_no_transit(self):
+        """Large impact parameter — planet never overlaps the star."""
+        inc_no_transit = np.radians(60.0)
+        flux = np.asarray(jax_uniform(jnp.array(TIMES), 0.1, T0, P, A, inc_no_transit, E, W))
+        np.testing.assert_allclose(flux, 0.0, atol=1e-12)
+
+    def test_grazing_transit(self):
+        """Planet barely grazes the stellar disk."""
+        k = 0.1
+        b_grazing = 0.95
+        inc_graze = np.arccos(b_grazing / A)
+        flux = np.asarray(jax_uniform(jnp.array(TIMES), k, T0, P, A, inc_graze, E, W))
+        # Should have some negative flux values (transit dip)
+        assert np.min(flux) < 0.0
+        # But much shallower than full transit
+        full_flux = np.asarray(jax_uniform(jnp.array(TIMES), k, T0, P, A, I, E, W))
+        assert np.min(flux) > np.min(full_flux)
+
+    def test_full_containment(self):
+        """Planet fully inside the stellar disk at mid-transit."""
+        k = 0.1
+        flux = np.asarray(jax_uniform(jnp.array(TIMES), k, T0, P, A, I, E, W))
+        # At mid-transit, flux deviation should be -k^2
+        mid_idx = len(TIMES) // 2
+        np.testing.assert_allclose(flux[mid_idx], -k**2, atol=1e-6)
+
+    def test_eccentric_orbit(self):
+        """Eccentric orbit should still produce valid transit."""
+        k, e = 0.1, 0.3
+        flux = np.asarray(jax_uniform(jnp.array(TIMES), k, T0, P, A, I, e, W))
+        # Should have a transit dip
+        assert np.min(flux) < 0.0
+        # Out-of-transit should be zero
+        assert flux[0] == 0.0 or abs(flux[0]) < 1e-10
+
+
+class TestCustomJVP:
+    """Validate custom JVP derivatives against finite differences."""
+
+    PARAM_NAMES = ["k", "t0", "p", "a", "i", "e", "w"]
+
+    @staticmethod
+    def _finite_diff_grad(times, params, idx, eps=1e-6):
+        """Central finite-difference gradient w.r.t. params[idx]."""
+        p_plus = list(params)
+        p_minus = list(params)
+        p_plus[idx] = params[idx] + eps
+        p_minus[idx] = params[idx] - eps
+        f_plus = jax_uniform(times, *p_plus)
+        f_minus = jax_uniform(times, *p_minus)
+        return (f_plus - f_minus) / (2 * eps)
+
+    @pytest.mark.parametrize("idx", range(7))
+    def test_circular_orbit_jacobian(self, idx):
+        """Custom JVP matches finite differences for circular orbit."""
+        times = jnp.linspace(-0.08, 0.08, 50)
+        params = [0.1, T0, P, A, I, 0.0, W]
+
+        # JAX Jacobian via the custom JVP
+        def model_wrapper(*args):
+            return jax_uniform(times, *args)
+
+        jac_jax = jax.jacobian(model_wrapper, argnums=idx)(*[jnp.float64(v) for v in params])
+        jac_fd = self._finite_diff_grad(times, params, idx)
+
+        np.testing.assert_allclose(
+            np.asarray(jac_jax), np.asarray(jac_fd), atol=1e-4, rtol=1e-3,
+            err_msg=f"Jacobian mismatch for {self.PARAM_NAMES[idx]} (circular)"
+        )
+
+    @pytest.mark.parametrize("idx", range(7))
+    def test_eccentric_orbit_jacobian(self, idx):
+        """Custom JVP matches finite differences for eccentric orbit."""
+        times = jnp.linspace(-0.08, 0.08, 50)
+        params = [0.1, T0, P, A, I, 0.3, W]
+
+        def model_wrapper(*args):
+            return jax_uniform(times, *args)
+
+        jac_jax = jax.jacobian(model_wrapper, argnums=idx)(*[jnp.float64(v) for v in params])
+        jac_fd = self._finite_diff_grad(times, params, idx)
+
+        np.testing.assert_allclose(
+            np.asarray(jac_jax), np.asarray(jac_fd), atol=1e-4, rtol=1e-3,
+            err_msg=f"Jacobian mismatch for {self.PARAM_NAMES[idx]} (eccentric)"
+        )
+
+    def test_all_gradients_finite_and_nonzero(self):
+        """All 7 partial derivatives should be finite; most should be nonzero."""
+        times = jnp.linspace(-0.08, 0.08, 50)
+
+        def loss(*args):
+            return jnp.sum(jax_uniform(times, *args))
+
+        params = [jnp.float64(v) for v in [0.1, T0, P, A, I, 0.0, W]]
+        val, grads = jax.value_and_grad(loss, argnums=tuple(range(7)))(*params)
+
+        assert jnp.isfinite(val)
+        for j, g in enumerate(grads):
+            assert jnp.isfinite(g), f"Non-finite grad for {self.PARAM_NAMES[j]}: {g}"
+
+        # k, a, i definitely affect transit depth
+        for j in [0, 3, 4]:
+            assert grads[j] != 0.0, f"Zero grad for {self.PARAM_NAMES[j]}"