pizzetti 0.1.0__py3-none-any.whl

pizzetti/__init__.py

@@ -0,0 +1,12 @@
+"""pizzetti: fast limb-darkened transit light curves.
+
+A drop-in replacement for batman's ``TransitModel`` / ``TransitParams``. While
+the planet is entirely inside the stellar disk, the flux is evaluated with an
+elementary series that has a rigorous error bound; near and across the limb
+an exact (quadratic family) or quadrature (other power laws) solution is used.
+"""
+from .occult import SERIES_TOL, occult, series_cut
+from .transitmodel import TransitModel, TransitParams
+
+__version__ = "0.1.0"
+__all__ = ["TransitModel", "TransitParams", "occult", "series_cut", "SERIES_TOL", "__version__"]

pizzetti/_exact.py

@@ -0,0 +1,231 @@
+"""Exact Mandel & Agol (2002) flux for quadratic limb darkening, used for the
+samples that the interior series does not cover (near and across the stellar
+limb).
+
+Vectorised, branch-free evaluation with Bulirsch's general complete elliptic
+integral (Bulirsch 1969) at a fixed number of steps, and elliptic operands in
+closed form from (z, p) as in Agol, Luger & Foreman-Mackey (2020, eq. 41).
+Lanes that are not converged after the fixed steps are recomputed with a
+scalar early-exit iteration. Adapted from the Pandora code (Hippke & Heller
+2022, GPL-3).
+
+Conventions: z = projected centre distance, k = radius ratio (both in stellar
+radii); quadratic law I(mu) = 1 - u1 (1 - mu) - u2 (1 - mu)^2. The flux is
+    F = 1 - (c1 lex + c2 ldx + u2 edx) omega,
+    c1 = 1 - u1 - 2 u2, c2 = u1 + 2 u2, omega = 1 / (1 - u1/3 - u2/6),
+with the LD-independent terms lex (blocked area / pi), ldx (lambda_d of
+Mandel & Agol plus 2/3 Theta(k - z)) and edx (eta_d).
+"""
+from math import pi
+
+import numpy as np
+from numba import njit
+
+# fixed Bulirsch steps of the vectorised pass; non-converged lanes fall back
+ELL_BATCH_ITERATIONS = 5
+# floor of the complementary modulus (kc = 0 only at internal tangency)
+KC_MIN = 1e-150
+# smallest |z - k| (z == k exactly is moved by one ulp)
+Z_K_MIN = 1e-150
+
+# fdlibm e_asin / e_acos rational kernel
+_PS0 = 1.66666666666666657415e-01
+_PS1 = -3.25565818622400915405e-01
+_PS2 = 2.01212532134862925881e-01
+_PS3 = -4.00555345006794114027e-02
+_PS4 = 7.91534994289814532176e-04
+_PS5 = 3.47933107596021167570e-05
+_QS1 = -2.40339491173441421878e+00
+_QS2 = 2.02094576023350569471e+00
+_QS3 = -6.88283971605453293030e-01
+_QS4 = 7.70381505559019352791e-02
+_HALF_PI = 1.5707963267948966
+
+
+@njit(cache=True, fastmath=True, error_model="numpy", inline="always")
+def acos_poly(x):
+    """arccos(x) for -1 <= x <= 1, branch-free (fdlibm with selects), so that
+    loops calling it vectorise; <= 1 ulp from libm."""
+    ax = abs(x)
+    small = ax <= 0.5
+    z = x * x if small else 0.5 * (1.0 - ax)
+    s = np.sqrt(z)
+    p = z * (_PS0 + z * (_PS1 + z * (_PS2 + z * (_PS3 + z * (_PS4 + z * _PS5)))))
+    q = 1.0 + z * (_QS1 + z * (_QS2 + z * (_QS3 + z * _QS4)))
+    r = p / q
+    a_small = _HALF_PI - (x + x * r)
+    t = 2.0 * (s + s * r)
+    a_big = t if x > 0 else pi - t
+    return a_small if small else a_big
+
+
+@njit(cache=True, fastmath=True, error_model="numpy", inline="always")
+def acos_acc(x, om, op):
+    """arccos(x) from x and accurately computed om = 1 - x, op = 1 + x
+    (both >= 0), branch-free: no loss of accuracy near x = +-1, where
+    arccos(x) = 2 asin(sqrt((1 - |x|) / 2)) is evaluated from the given
+    (1 - |x|). Arguments are clamped to [-1, 1]."""
+    x = max(min(x, 1.0), -1.0)
+    om = max(om, 0.0)
+    op = max(op, 0.0)
+    ax = abs(x)
+    small = ax <= 0.5
+    zz = x * x if small else 0.5 * min(om if x > 0 else op, 1.0)
+    s = np.sqrt(zz)
+    p = zz * (_PS0 + zz * (_PS1 + zz * (_PS2 + zz * (_PS3 + zz * (_PS4 + zz * _PS5)))))
+    q = 1.0 + zz * (_QS1 + zz * (_QS2 + zz * (_QS3 + zz * _QS4)))
+    r = p / q
+    a_small = _HALF_PI - (x + x * r)
+    t = 2.0 * (s + s * r)
+    a_big = t if x > 0 else pi - t
+    return a_small if small else a_big
+
+
+@njit(cache=True, fastmath=True, error_model="numpy", inline="always")
+def limb_terms(z, k):
+    """lex, edx on the limb (Case III) with the arccos arguments and the
+    kite area in factored form (accurate at the contact points)."""
+    INV_PI = 1 / pi
+    k2 = k * k
+    z2 = z * z
+    zs = max(z, 1e-300)
+    zk = max(z * k, 1e-300)
+    # factors ordered so that cancelling sums are exact (Sterbenz)
+    f1 = (z - 1.0) + k  # z + k - 1 >= 0 on the limb
+    f2 = (1.0 - z) + k  # 1 + k - z
+    f3 = (1.0 - k) + z  # 1 + z - k
+    f4 = 1.0 + z + k
+    f5 = f2
+    f6 = f1
+    # kap1 = acos((1 - k^2 + z^2) / (2 z)), 1 - x = f1 f2 / (2z), 1 + x = f3 f4 / (2z)
+    kap1 = acos_acc((1 - k2 + z2) / (2 * zs), f1 * f2 / (2 * zs), f3 * f4 / (2 * zs))
+    # kap0 = acos((k^2 + z^2 - 1) / (2 k z)), 1 - x = f5 f3 / (2kz), 1 + x = f6 f4 / (2kz)
+    kap0 = acos_acc((k2 + z2 - 1) / (2 * zk), f5 * f3 / (2 * zk), f6 * f4 / (2 * zk))
+    kite = np.sqrt(max(f1 * f2 * f3 * f4, 0.0))
+    lex = (k2 * kap0 + kap1 - 0.5 * kite) * INV_PI
+    edx = 0.5 * INV_PI * (kap1 + k2 * (k2 + 2 * z2) * kap0 - (1 + 5 * k2 + z2) / 4 * kite)
+    return lex, edx
+
+
+@njit(cache=True, fastmath=True)
+def ell_combo_kc(kc, p, A, B, C, Cp):
+    """A K + B E + C Pi from one Bulirsch iteration with early exit.
+    kc: complementary modulus, p = sqrt(n + 1), Cp = C / p."""
+    a1 = A + B
+    b1 = A + B * kc * kc
+    a2 = C
+    b2 = Cp
+    e = kc
+    m0 = 1.0
+    for _ in range(1000):
+        f1 = a1
+        a1 = a1 + b1 / m0
+        b1 = 2 * (b1 + f1 * kc)
+        inv_p = 1 / p
+        f2 = a2
+        a2 = a2 + b2 * inv_p
+        g = e * inv_p
+        b2 = 2 * (b2 + f2 * g)
+        p = g + p
+        g = m0
+        m0 = kc + m0
+        if abs(g - kc) > 1e-8 * g:
+            kc = 2 * np.sqrt(e)
+            e = kc * m0
+        else:
+            return 0.5 * pi * ((b1 + a1 * m0) / (2 * m0 * m0) + (b2 + a2 * m0) / (m0 * (m0 + p)))
+    return np.nan
+
+
+@njit(cache=True, fastmath=True)
+def exact_point(z, k, c1, c2, u2, omega):
+    """Exact flux at one on-star z (0 <= z < 1 + k, z != k, not fully
+    occulted), scalar."""
+    INV_PI = 1 / pi
+    k2 = k * k
+    z2 = z * z
+    s = z + k
+    d = z - k
+    x1 = d * d
+    x2 = s * s
+    x3 = k2 - z2
+    sg = 1.0 if d > 0 else -1.0
+    if z < 1 - k:
+        lex = k2
+        edx = k2 / 2 * (k2 + 2 * z2)
+        num = ((1.0 - z) - k) * (1 + s)
+        den = 1 - x1
+        A = 1 - 5 * z2 + k2 + x3 * x3
+        p = s / abs(d)
+        Cp = 3 * sg
+    else:
+        lex, edx = limb_terms(z, k)
+        num = ((z - 1.0) + k) * (s + 1)
+        den = 4 * z * k
+        A = (1 - x2) * (2 * x2 + x1 - 3) - 3 * x3 * (x2 - 2)
+        p = 1 / abs(d)
+        Cp = 3 * s * sg
+    sden = np.sqrt(den)
+    kc = max(np.sqrt(max(num, 0.0)) / sden, KC_MIN)
+    ldx = 2 / 9 * INV_PI / sden * ell_combo_kc(kc, p, A, den * (z2 + 7 * k2 - 4), 3 * s / d, Cp)
+    if z < k:
+        ldx = ldx + 2 / 3
+    return 1 - (c1 * lex + c2 * ldx + u2 * edx) * omega
+
+
+@njit(cache=True, fastmath=True, error_model="numpy")
+def exact_batch(zb, m, k, c1, c2, u2, omega, flux, dev):
+    """Exact flux for zb[:m] (on-star, z != k, not fully occulted), branch-free
+    so that LLVM vectorises the loop. dev[j] > 0 marks lanes that need the
+    scalar exact_point()."""
+    INV_PI = 1 / pi
+    k2 = k * k
+    for j in range(m):
+        z = zb[j]
+        z2 = z * z
+        s = z + k
+        d = z - k
+        x1 = d * d
+        x2 = s * s
+        x3 = k2 - z2
+        inner = z < 1 - k
+        num = ((1.0 - z) - k) * (1 + s) if inner else ((z - 1.0) + k) * (s + 1)
+        den = 1 - x1 if inner else 4 * z * k
+        inv_sden = 1 / np.sqrt(den)
+        kc = max(np.sqrt(max(num, 0.0)) * inv_sden, KC_MIN)
+        sg = 1.0 if d > 0 else -1.0
+        inv_ad = 1 / abs(d)
+        p = s * inv_ad if inner else inv_ad
+        a2 = 3 * s * sg * inv_ad
+        b2 = 3 * sg if inner else 3 * s * sg
+        A = (1 - 5 * z2 + k2 + x3 * x3) if inner else ((1 - x2) * (2 * x2 + x1 - 3) - 3 * x3 * (x2 - 2))
+        B = den * (z2 + 7 * k2 - 4)
+        a1 = A + B
+        b1 = A + B * kc * kc
+        e = kc
+        m0 = 1.0
+        dd = 0.0
+        for _ in range(ELL_BATCH_ITERATIONS):
+            r = 1 / (m0 * p)
+            f1 = a1
+            a1 = a1 + b1 * (p * r)
+            b1 = 2 * (b1 + f1 * kc)
+            inv_p = m0 * r
+            f2 = a2
+            a2 = a2 + b2 * inv_p
+            g = e * inv_p
+            b2 = 2 * (b2 + f2 * g)
+            p = g + p
+            g = m0
+            m0 = kc + m0
+            dd = abs(g - kc) - 1e-8 * g
+            kc = 2 * np.sqrt(e)
+            e = kc * m0
+        mp = m0 + p
+        ell = 0.25 * pi * ((b1 + a1 * m0) * mp + 2 * m0 * (b2 + a2 * m0)) / (m0 * m0 * mp)
+        ldx = (2 / 9 * INV_PI) * inv_sden * ell + (2 / 3 if z < k else 0.0)
+        lex_l, edx_l = limb_terms(z, k)
+        lex = k2 if inner else lex_l
+        edx = k2 / 2 * (k2 + 2 * z2) if inner else edx_l
+        flux[j] = 1 - (c1 * lex + c2 * ldx + u2 * edx) * omega
+        dev[j] = dd

pizzetti/_general.py

@@ -0,0 +1,161 @@
+"""Flux for intensity laws I(mu) = sum_i c_i mu^(alpha_i) where the occultor
+touches or crosses the stellar limb, by Green's theorem.
+
+With the radial primitive F_i(r) = int_0^r (1 - s^2)^g s ds
+= (1 - (1 - r^2)^(g+1)) / (2 (g + 1)), g = alpha_i / 2, the field
+(F(r)/r^2) (x, y) has divergence (1 - r^2)^g and is smooth at r = 0. The
+blocked flux is the outward flux through the boundary of the occulted part
+of the stellar disk:
+  * stellar-limb arc inside the occultor (r = 1): F(1) * 2 theta_s,
+    cos theta_s = (1 + z^2 - p^2) / (2 z);
+  * occultor arc inside the star, points (z + p cos t, p sin t),
+    cos t < c = (1 - z^2 - p^2) / (2 z p):
+    2 p int_{t0}^{pi} (F(r)/r^2) (p + z cos t) dt,  t0 = arccos(c).
+The arc integral uses composite Gauss-Legendre quadrature on segments that
+grow geometrically away from the nearest singularity of (1 - r^2)^(g+1)
+(at t = -t0, or at +-i sqrt(y_min/(z p)) for an interior disk); the first
+segment uses t = t0 + L u^2 to remove the (t - t0)^(g+1) endpoint behaviour.
+"""
+from math import pi
+
+import numpy as np
+from numba import njit
+
+#: Gauss-Legendre nodes per segment of the limb arc integral (geometric
+#: segments towards the nearest singularity).
+N_NODES = 12
+_X, _W = np.polynomial.legendre.leggauss(N_NODES)
+GL_U = 0.5 * (_X + 1.0)
+GL_W = 0.5 * _W
+
+
+@njit(cache=True, fastmath=False)
+def _h(x, y, g):
+    """(1 - y^(g+1)) / (2 (g+1) x) with x = r^2 and y = 1 - r^2 (both given
+    accurately), stable for x -> 0 and y -> 0."""
+    if x < 1e-8:
+        return 0.5 * (1.0 - 0.5 * g * x)
+    if y <= 0.0:
+        return 0.5 / ((g + 1.0) * x)
+    if x < 0.5:
+        return -np.expm1((g + 1.0) * np.log1p(-x)) / (2.0 * (g + 1.0) * x)
+    return (1.0 - np.exp((g + 1.0) * np.log(y))) / (2.0 * (g + 1.0) * x)
+
+
+@njit(cache=True, fastmath=False)
+def _acos_acc(x, om, op):
+    """arccos(x) from accurate 1 - x (om) and 1 + x (op)."""
+    if x > 0.5:
+        return 2.0 * np.arcsin(np.sqrt(max(om, 0.0) / 2.0))
+    if x < -0.5:
+        return pi - 2.0 * np.arcsin(np.sqrt(max(op, 0.0) / 2.0))
+    return np.arccos(x)
+
+
+@njit(cache=True, fastmath=False)
+def blocked_limb(z, p, gams, cs, gu, gw):
+    """sum_i c_i * (blocked flux of (1 - r^2)^{g_i}) for an occultor that
+    touches or crosses the limb (or covers the star)."""
+    nt = gams.shape[0]
+    tot = 0.0
+    need_log = False
+    for i in range(nt):
+        gi = gams[i]
+        if not (gi == 0.0 or gi == 1.0 or gi == 0.5 or gi == 0.25 or gi == 0.75):
+            need_log = True
+    # stellar-limb arc inside the occultor. cos(theta_s) = (1 + z^2 - p^2)/(2z),
+    # 1 - cos = (z-1+p)(1-z+p)/(2z), 1 + cos = (1-p+z)(1+z+p)/(2z); the
+    # cancelling sums are ordered so that they are exact (Sterbenz), and the
+    # case decisions use them (not the rounded cosine).
+    if z > 0.0:
+        om = ((z - 1.0) + p) * ((1.0 - z) + p) / (2.0 * z)
+        op = ((1.0 - p) + z) * (1.0 + z + p) / (2.0 * z)
+        if om <= 0.0:
+            th = 0.0
+        elif op <= 0.0:
+            th = pi
+        else:
+            th = _acos_acc(1.0 - om if om < op else op - 1.0, om, op)
+    else:
+        th = pi if p >= 1.0 else 0.0
+    if th > 0.0:
+        for i in range(nt):
+            tot += cs[i] * 2.0 * th * 0.5 / (gams[i] + 1.0)
+    # occultor arc inside the star: cos t < c = (1 - z^2 - p^2) / (2 z p),
+    # 1 - c = (z-1+p)(z+p+1)/(2zp), 1 + c = (1-z+p)(1-p+z)/(2zp)
+    if z > 0.0 and p > 0.0:
+        omc = ((z - 1.0) + p) * (z + p + 1.0) / (2.0 * z * p)
+        opc = ((1.0 - z) + p) * ((1.0 - p) + z) / (2.0 * z * p)
+        arc = opc > 0.0
+    else:
+        omc = 0.0 if p < 1.0 else 2.0
+        opc = 2.0 if p < 1.0 else 0.0
+        arc = p < 1.0
+    if arc:
+        if omc <= 0.0:
+            t0 = 0.0
+        else:
+            t0 = _acos_acc(1.0 - omc if omc < opc else opc - 1.0, omc, opc)
+        zp = z * p
+        omz2p2 = ((1.0 - z) - p) * (1.0 + z + p) + 2.0 * zp   # 1 - z^2 - p^2
+        # length scale of the nearest singularity of (1 - r^2)^(g+1) in t:
+        # the second zero at -t0 (limb), or +-i sqrt(y_min / (z p)) (interior)
+        if t0 > 0.0:
+            scale = t0
+        else:
+            ymin = ((1.0 - z) - p) * (1.0 + z + p)
+            scale = np.sqrt(max(ymin, 0.0) / max(zp, 1e-300)) if zp > 0.0 else pi
+        scale = min(max(scale, 1e-12), pi - t0)
+        a = t0
+        b = t0 + scale
+        first = True
+        for _ in range(64):
+            L = b - a
+            for n in range(gu.shape[0]):
+                u = gu[n]
+                if first:      # t = t0 + L u^2: removes the (t - t0)^(g+1) endpoint
+                    t = a + L * u * u
+                    jac = 2.0 * L * u * gw[n]
+                else:
+                    t = a + L * u
+                    jac = L * gw[n]
+                ct = np.cos(t)
+                # 1 - r^2 = 2 z p (cos t0 - cos t); cos t0 = 1 - omc from its accurate form
+                if t0 > 0.0:
+                    y = 2.0 * zp * ((1.0 - ct) - omc)
+                else:
+                    y = omz2p2 - 2.0 * zp * ct
+                y = min(max(y, 0.0), 1.0)
+                r2 = max(1.0 - y, 0.0) if y > 0.5 else min(max(z * z + p * p + 2.0 * zp * ct, 0.0), 1.0)
+                geo = 2.0 * p * (p + z * ct) * jac
+                sy = np.sqrt(y)
+                qy = np.sqrt(sy)
+                ly = np.log(y) if (y > 0.0 and need_log) else -745.0
+                l1x = np.log1p(-r2) if r2 < 0.05 else 0.0
+                for i in range(nt):
+                    gi = gams[i]
+                    if gi == 0.0:
+                        hv = 0.5
+                    elif gi == 1.0:
+                        hv = 0.25 * (1.0 + y)
+                    elif r2 < 1e-8:
+                        hv = 0.5 * (1.0 - 0.5 * gi * r2)
+                    elif r2 < 0.05:
+                        hv = -np.expm1((gi + 1.0) * l1x) / (2.0 * (gi + 1.0) * r2)
+                    elif gi == 0.5:
+                        hv = (1.0 - y * sy) / (3.0 * r2)
+                    elif gi == 0.25:
+                        hv = (1.0 - y * qy) / (2.5 * r2)
+                    elif gi == 0.75:
+                        hv = (1.0 - y * sy * qy) / (3.5 * r2)
+                    else:
+                        hv = (1.0 - np.exp((gi + 1.0) * ly)) / (2.0 * (gi + 1.0) * r2)
+                    tot += cs[i] * hv * geo
+            if b >= pi:
+                break
+            first = False
+            a = b
+            b = min(t0 + 3.0 * (b - t0), pi)
+            if pi - b < 0.25 * (b - a):
+                b = pi
+    return tot

pizzetti/_orbit.py

@@ -0,0 +1,140 @@
+"""Sky-projected separation and true anomaly (same conventions as batman's _rsky)."""
+from math import pi
+
+import numpy as np
+from numba import njit
+
+#: separation returned when the planet is behind the star (primary) or in
+#: front of it (secondary), as in batman
+BIGD = 100.0
+
+
+# fdlibm __kernel_sin / __kernel_cos coefficients on [-pi/4, pi/4]
+_S1 = -1.66666666666666324348e-01
+_S2 = 8.33333333332248946124e-03
+_S3 = -1.98412698298579493134e-04
+_S4 = 2.75573137070700676789e-06
+_S5 = -2.50507602534068634195e-08
+_S6 = 1.58969099521155010221e-10
+_C1 = 4.16666666666666019037e-02
+_C2 = -1.38888888888741095749e-03
+_C3 = 2.48015872894767294178e-05
+_C4 = -2.75573143513906633035e-07
+_C5 = 2.08757232129817482790e-09
+_C6 = -1.13596475577881948265e-11
+
+
+@njit(cache=True, fastmath=True, inline="always")
+def sin_turns(u):
+    """sin(2 pi u) for a phase u in turns, branch-free polynomial (vectorises);
+    error ~1e-16 independent of |u| (the phase is reduced in turns)."""
+    f = u - np.floor(u + 0.5)
+    q = np.floor(4.0 * f + 0.5)
+    r = 2.0 * pi * (f - 0.25 * q)
+    z = r * r
+    s = r + r * z * (_S1 + z * (_S2 + z * (_S3 + z * (_S4 + z * (_S5 + z * _S6)))))
+    c = 1.0 - 0.5 * z + z * z * (_C1 + z * (_C2 + z * (_C3 + z * (_C4 + z * (_C5 + z * _C6)))))
+    k = np.int64(q) & 3
+    v = c if (k & 1) == 1 else s
+    return -v if k >= 2 else v
+
+
+@njit(cache=True, fastmath=True)
+def _rsky_circular(t, tp, per, a, si, w_turns, transittype, d):
+    """Circular orbit: d = a sqrt(1 - sin^2(f + w) sin^2 i), f = 2 pi (t - tp) / per."""
+    inv_per = 1.0 / per
+    for i in range(t.shape[0]):
+        s = sin_turns((t[i] - tp) * inv_per + w_turns)
+        ss = s * si
+        dd = a * np.sqrt(max(1.0 - ss * ss, 0.0))
+        bad = (ss <= 0.0) if transittype == 1 else (ss >= 0.0)
+        d[i] = BIGD if bad else dd
+
+
+@njit(cache=True)
+def eccentric_anomaly(M, e):
+    """Solve Kepler's equation E - e sin E = M (Newton, robust start)."""
+    Mr = M - 2.0 * pi * np.floor(M / (2.0 * pi))
+    E = Mr + e * np.sin(Mr) if e < 0.8 else pi
+    for _ in range(100):
+        f = E - e * np.sin(E) - Mr
+        dE = f / (1.0 - e * np.cos(E))
+        E -= dE
+        if abs(dE) < 1e-15 * max(1.0, abs(E)):
+            break
+    return E + (M - Mr)
+
+
+@njit(cache=True)
+def _true_anomaly(t, tc, per, ecc, omega):
+    f0 = pi / 2.0 - omega
+    if ecc < 1.0e-5:
+        E = f0
+        M = f0
+    else:
+        E = 2.0 * np.arctan(np.sqrt((1.0 - ecc) / (1.0 + ecc)) * np.tan(f0 / 2.0))
+        M = E - ecc * np.sin(E)
+    tp = tc - per * M / 2.0 / pi
+    n = t.shape[0]
+    f = np.empty(n)
+    if ecc < 1.0e-5:
+        for i in range(n):
+            x = (t[i] - tp) / per
+            f[i] = (x - np.trunc(x)) * 2.0 * pi
+    else:
+        sq = np.sqrt((1.0 + ecc) / (1.0 - ecc))
+        nm = 2.0 * pi / per
+        for i in range(n):
+            E = eccentric_anomaly(nm * (t[i] - tp), ecc)
+            f[i] = 2.0 * np.arctan(sq * np.tan(E / 2.0))
+    return f
+
+
+@njit(cache=True)
+def rsky(t, tc, per, a, inc, ecc, omega, transittype):
+    """Separation of centres in stellar radii; inc and omega in radians;
+    transittype 1 (primary) or 2 (secondary)."""
+    n = t.shape[0]
+    d = np.empty(n)
+    si = np.sin(inc)
+    if ecc < 1.0e-5:
+        # time of periastron as in batman (true = mean anomaly for e = 0)
+        tp = tc - per * (pi / 2.0 - omega) / 2.0 / pi
+        _rsky_circular(t, tp, per, a, si, omega / (2.0 * pi), transittype, d)
+        return d
+    f = _true_anomaly(t, tc, per, ecc, omega)
+    for i in range(n):
+        s = np.sin(f[i] + omega)
+        if transittype == 1 and s * si <= 0.0:
+            d[i] = BIGD
+        elif transittype == 2 and s * si >= 0.0:
+            d[i] = BIGD
+        else:
+            d[i] = a * (1.0 - ecc * ecc) / (1.0 + ecc * np.cos(f[i])) * np.sqrt(1.0 - s * s * si * si)
+    return d
+
+
+@njit(cache=True)
+def true_anomaly(t, tc, per, ecc, omega):
+    return _true_anomaly(t, tc, per, ecc, omega)
+
+
+@njit(cache=True)
+def eclipse(d, p, fp):
+    """Secondary eclipse with a uniform planet disk (batman's _eclipse)."""
+    if abs(p - 0.5) < 1.0e-3:
+        p = 0.5
+    n = d.shape[0]
+    out = np.empty(n)
+    for i in range(n):
+        x = d[i]
+        if x >= 1.0 + p:
+            out[i] = 1.0 + fp
+        elif x < 1.0 - p:
+            out[i] = 1.0
+        else:
+            kap1 = np.arccos(min((1.0 - p * p + x * x) / 2.0 / x, 1.0))
+            kap0 = np.arccos(min((p * p + x * x - 1.0) / 2.0 / p / x, 1.0))
+            at = (p * p * kap0 + kap1 - 0.5 * np.sqrt(max(4.0 * x * x - (1.0 + x * x - p * p) ** 2, 0.0))) / pi
+            out[i] = 1.0 + fp * (1.0 - at / p / p)
+    return out