PyTransit 2.8.0__tar.gz → 2.8.1__tar.gz

pytransit-2.8.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include pytransit/models/opencl/*.cl
+include pytransit/models/roadrunner/*.cl
+include pytransit/stars/data/*.fits
+include pytransit/contamination/data/*

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.8.0
+Version: 2.8.1
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2
@@ -28,7 +28,6 @@ Requires-Dist: astropy
 Requires-Dist: matplotlib
 Requires-Dist: tqdm
 Requires-Dist: semantic_version
-Requires-Dist: setuptools
 Requires-Dist: deprecated
 Requires-Dist: seaborn
 Requires-Dist: emcee

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.8.0
+Version: 2.8.1
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2
@@ -28,7 +28,6 @@ Requires-Dist: astropy
 Requires-Dist: matplotlib
 Requires-Dist: tqdm
 Requires-Dist: semantic_version
-Requires-Dist: setuptools
 Requires-Dist: deprecated
 Requires-Dist: seaborn
 Requires-Dist: emcee

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

@@ -62,6 +62,7 @@ pytransit/models/ma_quadratic.py
 pytransit/models/ma_quadratic_cl.py
 pytransit/models/ma_uniform.py
 pytransit/models/ma_uniform_cl.py
+pytransit/models/new_eclipse_model.py
 pytransit/models/osmodel.py
 pytransit/models/qpower2.py
 pytransit/models/qpower2_cl.py
@@ -137,13 +138,11 @@ 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
 tests/test_roadrunner_eclipse.py
-tests/test_transitmodel_helpers.py
 tests/test_uniform_model.py
 tests/test_uniform_model_nb.py
 tests/test_z.py

{pytransit-2.8.0 → pytransit-2.8.1}/PyTransit.egg-info/requires.txt

@@ -10,7 +10,6 @@ astropy
 matplotlib
 tqdm
 semantic_version
-setuptools
 deprecated
 seaborn
 emcee

{pytransit-2.8.0 → pytransit-2.8.1}/pyproject.toml

@@ -33,7 +33,7 @@ version = {attr = "pytransit.__version__"}
 include-package-data = true
 
 [tool.setuptools.packages.find]
-include = ["pytransit"]
+include = ["pytransit*"]
 namespaces = true
 
 [tool.pytest.ini_options]

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

@@ -41,7 +41,7 @@ Date
 
 """
 
-__version__ = '2.8.0'
+__version__ = '2.8.1'
 
 # Generic
 # -------

{pytransit-2.8.0 → pytransit-2.8.1}/pytransit/models/limb_darkening/linear.py

@@ -11,7 +11,7 @@ def ld_linear(mu, pv):
 
 @njit(fastmath=True)
 def ldi_linear(pv):
-    return 2 * pi * 1 / 6 * (3 - 2 * pv[0])
+    return 2 * pi * 1 / 6 * (3 - pv[0])
 
 
 @njit(fastmath=True)

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

@@ -0,0 +1,6 @@
+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)

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

@@ -1,4 +1,4 @@
-from math import pi, sqrt, gamma
+from math import pi
 
 from numba import njit
 from numpy import zeros, log
@@ -11,7 +11,7 @@ def ld_power_2(mu, pv):
 
 @njit
 def ldi_power_2(mu, pv):
-    return 2 * pi * sqrt(pi) * pv[0] * gamma(0.5*pv[1] + 1.0) / (2*gamma(0.5*(pv[1]+3.0))) - pv[0] + 1
+    return 2 * pi * (0.5 - 0.5 * pv[0] + pv[0] / (pv[1] + 2.0))
 
 
 @njit(fastmath=True)

pytransit-2.8.1/pytransit/models/new_eclipse_model.py

@@ -0,0 +1,70 @@
+#  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 Union
+
+from numpy import squeeze, zeros, atleast_1d, atleast_2d
+from numpy.typing import NDArray
+from .roadrunner.model_eclipse import eclipse_model
+from .transitmodel import TransitModel
+
+__all__ = ['EclipseModel']
+
+npfloat = Union[float, NDArray]
+
+
+class EclipseModel(TransitModel):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def evaluate(self, k: npfloat, t0: npfloat, p: npfloat, a: npfloat, i: npfloat, e: npfloat = None, w: npfloat = None,
+                 rstar: float = 1.0, copy: bool = True) -> NDArray:
+        """Evaluates a multiplicative secondary eclipse model for a set of scalar or vector parameters.
+
+        Parameters
+        ----------
+        k
+            Radius ratio(s) either as a single float, 1D vector, or 2D array.
+        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
+            Orbital eccentricity as a float or a 1D vector.
+        w
+            Argument of periastron as a float or a 1D vector.
+        rstar
+            Stellar radius in R_sun as a float or a 1D vector.
+
+        Returns
+        -------
+        Multiplicative eclipse model
+        """
+
+        k = atleast_1d(k)
+        t0 = atleast_2d(t0).reshape([k.size, -1])
+        p = atleast_1d(p)
+        a = atleast_1d(a)
+        i = atleast_1d(i)
+        e = zeros(1) if e is None else atleast_1d(e)
+        w = zeros(1) if w is None else atleast_1d(w)
+
+        return squeeze(eclipse_model(self.time, k, t0, p, a, i, e, w, rstar, self.nlc, self.lcids, self.pbids, self.nsamples, self.exptimes))

{pytransit-2.8.0 → pytransit-2.8.1}/pytransit/models/numba/udmodel.py

@@ -1,7 +1,7 @@
 from math import isnan
 
 from numba import njit
-from numpy import zeros, floor, nan, pi, atleast_1d, asarray
+from numpy import zeros, floor, nan, pi, atleast_1d, asarray, sqrt
 
 from meepmeep.backends.numba.point2d import solve2d, sep_c, bounding_box
 

{pytransit-2.8.0 → pytransit-2.8.1}/requirements.txt

@@ -10,7 +10,6 @@ astropy
 matplotlib
 tqdm
 semantic_version
-setuptools
 deprecated
 seaborn
 emcee

{pytransit-2.8.0 → pytransit-2.8.1}/tests/test_limb_darkening.py

@@ -9,16 +9,13 @@ from numpy.testing import assert_allclose
 import pytest
 from scipy.integrate import quad
 
-# Skip the whole module if the numba limb-darkening backend isn't available yet (work in progress).
-pytest.importorskip("pytransit.backends.numba.limb_darkening.uniform")
-
-from pytransit.backends.numba.limb_darkening.uniform import ld_uniform, ldi_uniform
-from pytransit.backends.numba.limb_darkening.linear import ld_linear, ldi_linear, ldd_linear
-from pytransit.backends.numba.limb_darkening.quadratic import ld_quadratic, ldi_quadratic, ldd_quadratic
-from pytransit.backends.numba.limb_darkening.quadratic_tri import ld_quadratic_tri, ldi_quadratic_tri, ldd_quadratic_tri
-from pytransit.backends.numba.limb_darkening.power_2 import ld_power_2, ldi_power_2, ldd_power_2
-from pytransit.backends.numba.limb_darkening.nonlinear import ld_nonlinear, ldi_nonlinear, ldd_nonlinear
-from pytransit.backends.numba.limb_darkening.general import ld_general, ldi_general, ldd_general
+from pytransit.models.limb_darkening.uniform import ld_uniform, ldi_uniform
+from pytransit.models.limb_darkening.linear import ld_linear, ldi_linear, ldd_linear
+from pytransit.models.limb_darkening.quadratic import ld_quadratic, ldi_quadratic, ldd_quadratic
+from pytransit.models.limb_darkening.quadratic_tri import ld_quadratic_tri, ldi_quadratic_tri
+from pytransit.models.limb_darkening.power_2 import ld_power_2, ldi_power_2, ldd_power_2
+from pytransit.models.limb_darkening.nonlinear import ld_nonlinear
+from pytransit.models.limb_darkening.general import ld_general
 
 
 def numerical_ldi(ld_func, pv, n=10000):
@@ -110,38 +107,12 @@ class TestIntegrals:
         np.array([0.0, 1.0]),
     ])
     def test_power_2(self, pv):
-        assert_allclose(ldi_power_2(pv), numerical_ldi(ld_power_2, pv), rtol=1e-10)
+        # ldi_power_2 takes (mu, pv) for registry consistency; mu is unused.
+        assert_allclose(ldi_power_2(np.array([1.0]), pv), numerical_ldi(ld_power_2, pv), rtol=1e-10)
 
     def test_power_2_c0_gives_pi(self):
         """c=0 reduces to uniform disk, integral = π."""
-        assert_allclose(ldi_power_2(np.array([0.0, 1.0])), np.pi, rtol=1e-12)
-
-    @pytest.mark.parametrize("pv", [
-        np.array([0.1, 0.2, 0.1, 0.05]),
-        np.array([0.3, 0.2, 0.15, 0.1]),
-        np.array([0.0, 0.0, 0.0, 0.0]),
-        np.array([0.5, 0.3, 0.1, 0.05]),
-    ])
-    def test_nonlinear(self, pv):
-        assert_allclose(ldi_nonlinear(pv), numerical_ldi(ld_nonlinear, pv), rtol=1e-10)
-
-    def test_nonlinear_zeros_gives_pi(self):
-        """All zeros reduces to uniform disk, integral = π."""
-        assert_allclose(ldi_nonlinear(np.array([0.0, 0.0, 0.0, 0.0])), np.pi, rtol=1e-12)
-
-    @pytest.mark.parametrize("pv", [
-        np.array([0.5, 0.3]),
-        np.array([1.0, 0.0]),
-        np.array([0.0, 1.0]),
-        np.array([0.2, 0.3, 0.1]),
-    ])
-    def test_general(self, pv):
-        assert_allclose(ldi_general(pv), numerical_ldi(ld_general, pv), rtol=1e-10)
-
-    def test_general_single_coeff(self):
-        """Single coeff c₀: I(μ) = c₀(1-μ), integral = 2π·c₀·1/(2·3) = πc₀/3."""
-        pv = np.array([1.0])
-        assert_allclose(ldi_general(pv), np.pi / 3.0, rtol=1e-12)
+        assert_allclose(ldi_power_2(np.array([1.0]), np.array([0.0, 1.0])), np.pi, rtol=1e-12)
 
 
 # ============================================================
@@ -171,15 +142,6 @@ class TestGradients:
         num = numerical_gradient(ld_quadratic, self.mu_test, pv)
         assert_allclose(ana, num, atol=1e-6)
 
-    @pytest.mark.parametrize("pv", [
-        np.array([0.5, 0.3]),
-        np.array([0.8, 0.5]),
-    ])
-    def test_quadratic_tri(self, pv):
-        ana = ldd_quadratic_tri(self.mu_test, pv)
-        num = numerical_gradient(ld_quadratic_tri, self.mu_test, pv)
-        assert_allclose(ana, num, atol=1e-5)
-
     @pytest.mark.parametrize("pv", [
         np.array([0.3, 0.7]),
         np.array([0.8, 0.5]),
@@ -191,26 +153,6 @@ class TestGradients:
         num = numerical_gradient(ld_power_2, mu, pv)
         assert_allclose(ana, num, atol=1e-5)
 
-    @pytest.mark.parametrize("pv", [
-        np.array([0.1, 0.2, 0.1, 0.05]),
-        np.array([0.3, 0.2, 0.15, 0.1]),
-    ])
-    def test_nonlinear(self, pv):
-        # Avoid mu near 0 where c₁/(2√μ) diverges
-        mu = self.mu_test[self.mu_test > 0.05]
-        ana = ldd_nonlinear(mu, pv)
-        num = numerical_gradient(ld_nonlinear, mu, pv)
-        assert_allclose(ana, num, atol=1e-5)
-
-    @pytest.mark.parametrize("pv", [
-        np.array([0.5, 0.3]),
-        np.array([0.2, 0.3, 0.1]),
-    ])
-    def test_general(self, pv):
-        ana = ldd_general(self.mu_test, pv)
-        num = numerical_gradient(ld_general, self.mu_test, pv)
-        assert_allclose(ana, num, atol=1e-5)
-
 
 # ============================================================
 # Edge case tests

{pytransit-2.8.0 → pytransit-2.8.1}/tests/test_ma_quadratic.py

@@ -109,40 +109,6 @@ class TestQuadraticModel:
         assert flux.ndim == 1
         assert flux.size == model_data.time.size
 
-    def test_evaluate_pvi(self, model_data):
-        tm = QuadraticModel(interpolate=True)
-        tm.set_data(model_data.time)
-
-        pvp = array([[0.12, 0.00, 1.0, 3.0, 0.500 * pi, 0.0, 0.0],
-                     [0.11, 0.01, 0.9, 2.9, 0.495 * pi, 0.0, 0.0]])
-
-        ldc = [[0.1, 0.2], [0.3, 0.1]]
-        flux = tm.evaluate_pv(pvp[0], ldc[0])
-        assert flux.ndim == 1
-        assert flux.size == model_data.time.size
-
-        ldc = [[0.1, 0.2], [0.3, 0.1]]
-        flux = tm.evaluate_pv(pvp, ldc)
-        assert flux.ndim == 2
-        assert flux.shape == (2, model_data.time.size)
-
-    def test_evaluate_pvd(self, model_data):
-        tm = QuadraticModel(interpolate=False)
-        tm.set_data(model_data.time)
-
-        pvp = array([[0.12, 0.00, 1.0, 3.0, 0.500 * pi, 0.0, 0.0],
-                     [0.11, 0.01, 0.9, 2.9, 0.495 * pi, 0.0, 0.0]])
-
-        ldc = [[0.1, 0.2], [0.3, 0.1]]
-        flux = tm.evaluate_pv(pvp[0], ldc[0])
-        assert flux.ndim == 1
-        assert flux.size == model_data.time.size
-
-        ldc = [[0.1, 0.2], [0.3, 0.1]]
-        flux = tm.evaluate_pv(pvp, ldc)
-        assert flux.ndim == 2
-        assert flux.shape == (2, model_data.time.size)
-
     # TODO: Set up OpenCL in Travis
     # -----------------------------
     # def test_to_opencl(self):

{pytransit-2.8.0 → pytransit-2.8.1}/tests/test_uniform_model.py

@@ -79,17 +79,19 @@ class TestUniformModel:
         assert flux.ndim == 1
         assert flux.size == model_data.time.size
 
-    def test_evaluate_pv(self, model_data):
+    def test_evaluate_population(self, model_data):
+        # Evaluate a population of parameter sets simultaneously through the
+        # vectorised evaluate() (which replaced the removed evaluate_pv()). The
+        # vector branch is selected because the orbital parameters are arrays.
         tm = UniformModel()
         tm.set_data(model_data.time)
 
-        pvp = array([[0.12, 0.00, 1.0, 3.0, 0.500 * pi, 0.0, 0.0],
-                     [0.11, 0.01, 0.9, 2.9, 0.495 * pi, 0.0, 0.0]])
+        k  = array([0.12, 0.11])
+        t0 = array([0.00, 0.01])
+        p  = array([1.0, 0.9])
+        a  = array([3.0, 2.9])
+        i  = array([0.500 * pi, 0.495 * pi])
 
-        flux = tm.evaluate_pv(pvp[0])
-        assert flux.ndim == 1
-        assert flux.size == model_data.time.size
-
-        flux = tm.evaluate_pv(pvp)
+        flux = tm.evaluate(k, t0, p, a, i)
         assert flux.ndim == 2
         assert flux.shape == (2, model_data.time.size)

pytransit-2.8.0/MANIFEST.in

@@ -1,6 +0,0 @@
-include pytransit/contamination/data/*
-include pytransit/models/opencl/*.cl
-include pytransit/models/roadrunner/*.cl
-include pytransit/models/roadrunner/*.py
-include pytransit/models/numba/*.py
-include pytransit/stars/data/*.fits

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

@@ -1,8 +0,0 @@
-from math import pi, sqrt
-
-from numba import njit
-
-
-@njit(fastmath=True)
-def ld_nonlinear(mu, pv):
-    return 1. - pv[0] * (1. - sqrt(mu)) - pv[1] * (1. - mu) - pv[2] * (1. - mu**1.5) - pv[3] * (1. - mu ** 2)

pytransit-2.8.0/tests/test_jax_uniformdisk.py

@@ -1,196 +0,0 @@
-"""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
-
-# Skip the whole module if the JAX backend isn't available yet (work in progress).
-jax_uniform = pytest.importorskip("pytransit.backends.jax.uniformdisk").uniform_model
-
-# 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]}"