squishyplanet 0.2.0__tar.gz → 0.2.2__tar.gz

{squishyplanet-0.2.0/squishyplanet.egg-info → squishyplanet-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: squishyplanet
-Version: 0.2.0
+Version: 0.2.2
 Summary: A package for dealing with non-spherical exoplanets
 Author-email: Ben Cassese <b.c.cassese@columbia.edu>
 License: MIT
@@ -26,11 +26,12 @@ Requires-Dist: ipykernel
 
 # squishyplanet
 
-[![status](https://joss.theoj.org/papers/2b62acea4e4d6c0de73309184861d1e9/status.svg)](https://joss.theoj.org/papers/2b62acea4e4d6c0de73309184861d1e9)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.06972/status.svg)](https://doi.org/10.21105/joss.06972)
 [![Documentation Status](https://readthedocs.org/projects/squishyplanet/badge/?version=latest)](https://squishyplanet.readthedocs.io/en/latest/?badge=latest)
 ![Build Status](https://github.com/ben-cassese/squishyplanet/actions/workflows/tests.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/ben-cassese/squishyplanet/badge.svg?branch=main&service=github)](https://coveralls.io/github/ben-cassese/squishyplanet?branch=main)
 ![PyPI - Version](https://img.shields.io/pypi/v/squishyplanet)
+ [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 A package for modeling non-spherical exoplanets.
 
@@ -52,23 +53,20 @@ See the [installation instructions](https://squishyplanet.readthedocs.io/en/late
 
 ## Attribution and License
 
- [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[hopefully joss badge]
 
-``squishyplanet`` is made freely available under the MIT License. If you use this code in your research, please cite the accompanying JOSS paper. The citation information will be updated once the paper is submitted/accepted.
+``squishyplanet`` is made freely available under the MIT License. If you use this code in your research, please cite the accompanying JOSS paper:
 
 ```
-@article{
-    squishyplanet,
-    doi = {},
-    url = {},
-    year = 2024,
-    month = {},
-    publisher = {},
-    volume = {},
-    number = {},
-    author = {},
-    title = {squishyplanet: modeling transits of non-spherical exoplanets in JAX},
-    journal = {}
+@article{squishyplanet,
+   author = {{Cassese}, Ben and {Vega}, Justin and {Lu}, Tiger and {Rice}, Malena and {Poddar}, Avishi and {Kipping}, David},
+   doi = {10.21105/joss.06972},
+   journal = {Journal of Open Source Software},
+   month = aug,
+   number = {100},
+   pages = {6972},
+   title = {{squishyplanet: modeling transits of non-spherical exoplanets in JAX}},
+   url = {https://joss.theoj.org/papers/10.21105/joss.06972},
+   volume = {9},
+   year = {2024}
 }
 ```

{squishyplanet-0.2.0 → squishyplanet-0.2.2}/README.md

@@ -1,10 +1,11 @@
 # squishyplanet
 
-[![status](https://joss.theoj.org/papers/2b62acea4e4d6c0de73309184861d1e9/status.svg)](https://joss.theoj.org/papers/2b62acea4e4d6c0de73309184861d1e9)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.06972/status.svg)](https://doi.org/10.21105/joss.06972)
 [![Documentation Status](https://readthedocs.org/projects/squishyplanet/badge/?version=latest)](https://squishyplanet.readthedocs.io/en/latest/?badge=latest)
 ![Build Status](https://github.com/ben-cassese/squishyplanet/actions/workflows/tests.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/ben-cassese/squishyplanet/badge.svg?branch=main&service=github)](https://coveralls.io/github/ben-cassese/squishyplanet?branch=main)
 ![PyPI - Version](https://img.shields.io/pypi/v/squishyplanet)
+ [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 A package for modeling non-spherical exoplanets.
 
@@ -26,23 +27,20 @@ See the [installation instructions](https://squishyplanet.readthedocs.io/en/late
 
 ## Attribution and License
 
- [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[hopefully joss badge]
 
-``squishyplanet`` is made freely available under the MIT License. If you use this code in your research, please cite the accompanying JOSS paper. The citation information will be updated once the paper is submitted/accepted.
+``squishyplanet`` is made freely available under the MIT License. If you use this code in your research, please cite the accompanying JOSS paper:
 
 ```
-@article{
-    squishyplanet,
-    doi = {},
-    url = {},
-    year = 2024,
-    month = {},
-    publisher = {},
-    volume = {},
-    number = {},
-    author = {},
-    title = {squishyplanet: modeling transits of non-spherical exoplanets in JAX},
-    journal = {}
+@article{squishyplanet,
+   author = {{Cassese}, Ben and {Vega}, Justin and {Lu}, Tiger and {Rice}, Malena and {Poddar}, Avishi and {Kipping}, David},
+   doi = {10.21105/joss.06972},
+   journal = {Journal of Open Source Software},
+   month = aug,
+   number = {100},
+   pages = {6972},
+   title = {{squishyplanet: modeling transits of non-spherical exoplanets in JAX}},
+   url = {https://joss.theoj.org/papers/10.21105/joss.06972},
+   volume = {9},
+   year = {2024}
 }
 ```

{squishyplanet-0.2.0 → squishyplanet-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "squishyplanet"
-version = "0.2.0"
+version = "0.2.2"
 requires-python = ">=3.9"
 dependencies = [
     "requests",

{squishyplanet-0.2.0 → squishyplanet-0.2.2}/squishyplanet/__init__.py

@@ -4,4 +4,4 @@ __all__ = ["OblateSystem"]
 __url__ = "https://github.com/ben-cassese/squishyplanet"
 __license__ = "MIT"
 __description__ = "Modeling transits of non-spherical exoplanets"
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{squishyplanet-0.2.0 → squishyplanet-0.2.2}/squishyplanet/engine/kepler.py

@@ -177,3 +177,72 @@ def skypos(a, e, f, Omega, i, omega, **kwargs):
             _z(a, e, f, Omega, i, omega),
         ]
     )
+
+
+def true_anomaly_at_transit_center(e, i, omega):
+    """
+    Computes the true anomaly at the instant of minimum star/planet separation.
+
+    Uses equations 4.12-4.18 of
+    `Kipping 2011 <https://ui.adsabs.harvard.edu/abs/2011PhDT.......294K/abstract>`_
+    to compute the true anomaly at the instant of minimum star/planet separation.
+
+    Args:
+        e (Array [Dimensionless]): Eccentricity of the orbit
+        i (Array [Radian]): Orbital inclination
+        omega (Array [Radian]): Argument of periapsis
+
+    Returns:
+        Array: True anomaly at the instant of minimum star/planet separation in radians.
+    """
+
+    hp = e * jnp.sin(omega)
+    kp = e * jnp.cos(omega)
+
+    eta_1 = (kp / (1 + hp)) * (jnp.cos(i) ** 2)
+    eta_2 = (kp / (1 + hp)) * (1 / (1 + hp)) * (jnp.cos(i) ** 2) ** 2
+    eta_3 = (
+        -(kp / (1 + hp))
+        * ((-6 * (1 + hp) + kp**2 * (-1 + 2 * hp)) / (6 * (1 + hp) ** 3))
+        * (jnp.cos(i) ** 2) ** 3
+    )
+    eta_4 = (
+        -(kp / (1 + hp))
+        * ((-2 * (1 + hp) + kp**2 * (-1 + 3 * hp)) / (2 * (1 + hp) ** 4))
+        * (jnp.cos(i) ** 2) ** 4
+    )
+    eta_5 = (
+        (kp / (1 + hp))
+        * (
+            (
+                40 * (1 + hp) ** 2
+                - 40 * kp**2 * (-1 + 3 * hp + 4 * hp**2)
+                + kp**4 * (3 - 19 * hp + 8 * hp**2)
+            )
+            / (40 * (1 + hp) ** 6)
+        )
+        * (jnp.cos(i) ** 2) ** 5
+    )
+    eta_6 = (
+        (kp / (1 + hp))
+        * (
+            (
+                24 * (1 + hp) ** 2
+                - 40 * kp**2 * (-1 + 4 * hp + 5 * hp**2)
+                + 9 * kp**4 * (1 - 8 * hp + 5 * hp**2)
+            )
+            / (24 * (1 + hp) ** 7)
+        )
+        * (jnp.cos(i) ** 2) ** 6
+    )
+
+    return jnp.pi / 2 - omega - eta_1 - eta_2 - eta_3 - eta_4 - eta_5 - eta_6
+
+
+def t0_to_t_peri(e, i, omega, period, t0, **kwargs):
+    f = true_anomaly_at_transit_center(e, i, omega)
+
+    eccentric_anomaly = jnp.arctan2(jnp.sqrt(1 - e**2) * jnp.sin(f), e + jnp.cos(f))
+    mean_anomaly = eccentric_anomaly - e * jnp.sin(eccentric_anomaly)
+
+    return t0 - period / (2 * jnp.pi) * mean_anomaly

{squishyplanet-0.2.0 → squishyplanet-0.2.2}/squishyplanet/engine/parametric_ellipse.py

@@ -4,12 +4,8 @@ jax.config.update("jax_enable_x64", True)
 import jax.numpy as jnp
 
 
-# running into some numerical issues for very narrow ellipses-
-# e.g., the terminator for a spherical planet at f=1e-6. the rhos are ~1e14 there,
-# and the final value for c_y1 is off. everything is fine at f=1e-5 though, so leaving
-# for now
 @jax.jit
-def poly_to_parametric_helper(rho_xx, rho_xy, rho_x0, rho_yy, rho_y0, rho_00, **kwargs):
+def poly_to_parametric_helper(rho_xx, rho_xy, rho_x0, rho_yy, rho_y0, rho_00):
     """
     A helper function for :func:`poly_to_parametric`.
 
@@ -30,37 +26,101 @@ def poly_to_parametric_helper(rho_xx, rho_xy, rho_x0, rho_yy, rho_y0, rho_00, **
             - cosa (Array [Dimensionless]): Cosine of the rotation angle
             - sina (Array [Dimensionless]): Sine of the rotation angle
     """
-    rho_00 -= 1
+    # (* base eq *)
+    # pxx  x^2 + pxy  x  y + px0 x + pyy y^2 + py0 y + p00 == 1
+    # (* normalize to get rid of p0 *)
+    # pxx/(1 - p00)  x^2 + pxy /(1 - p00) x  y + px0/(1 - p00) x +
+    # pyy/(1 - p00) y^2 + py0 /(1 - p00) y == 1
+    # (* solve for the ellipse center *)
+    # CoefficientRules[
+    # pxx/(1 - p00)  x^2 + pxy /(1 - p00) x  y + px0/(1 - p00) x +
+    # pyy/(1 - p00) y^2 + py0 /(1 - p00) y /. {x -> x - xc,
+    # y -> y - yc}, {x, y}]
+    # Solve[{px0/(1 - p00) - (2 pxx xc)/(1 - p00) - (pxy yc)/(1 - p00) == 0,
+    # py0/(1 - p00) - (pxy xc)/(1 - p00) - (2 pyy yc)/(1 - p00) ==
+    # 0 }, {xc, yc}]
+    # (* plug back in *)
+    # Simplify[
+    # CoefficientRules[
+    # pxx/(1 - p00)  x^2 + pxy /(1 - p00) x  y + px0/(1 - p00) x +
+    #     pyy/(1 - p00) y^2 + py0 /(1 - p00) y /. {x -> x - xc,
+    #     y -> y - yc} /. {xc -> -((-pxy py0 + 2 px0 pyy)/(
+    #     pxy^2 - 4 pxx pyy)),
+    #     yc -> -((-px0 pxy + 2 pxx py0)/(pxy^2 - 4 pxx pyy))}, {x, y}]]
+    # (* normalize again to get the final coeffs *)
+    # pxxShift =
+    # Simplify[(pxx/(
+    #     1 - p00)) /(1 - (
+    #     px0 pxy py0 - pxx py0^2 -
+    #     px0^2 pyy)/((-1 + p00) (pxy^2 - 4 pxx pyy)))]
+    # pxyShift =
+    # Simplify[(pxy/(
+    #     1 - p00))/(1 - (
+    #     px0 pxy py0 - pxx py0^2 -
+    #     px0^2 pyy)/((-1 + p00) (pxy^2 - 4 pxx pyy)))]
+    # pyyShift =
+    # Simplify[(pyy/(
+    #     1 - p00)) /(1 - (
+    #     px0 pxy py0 - pxx py0^2 -
+    #     px0^2 pyy)/((-1 + p00) (pxy^2 - 4 pxx pyy)))]
 
     # the center of the ellipse
     xc = (rho_xy * rho_y0 - 2 * rho_yy * rho_x0) / (4 * rho_xx * rho_yy - rho_xy**2)
     yc = (rho_xy * rho_x0 - 2 * rho_xx * rho_y0) / (4 * rho_xx * rho_yy - rho_xy**2)
 
-    # the rotation angle
-    if rho_xx.shape == ():
-        a = jnp.ones((1, 2, 2))
-    else:
-        a = jnp.ones((rho_xx.shape[0], 2, 2))
-    a = a.at[:, 0, 0].set(rho_xx)
-    a = a.at[:, 0, 1].set(rho_xy / 2)
-    a = a.at[:, 1, 0].set(rho_xy / 2)
-    a = a.at[:, 1, 1].set(rho_yy)
-    l, b = jax.vmap(jnp.linalg.eigh, in_axes=(0))(a)
-    lambda_1 = l[:, 0]
-    lambda_2 = l[:, 1]
-    cosa = b[:, 0, 0]
-    sina = b[:, 0, 1]
-
-    # the radii
-    k = -(
-        rho_yy * rho_x0**2
-        - rho_xy * rho_x0 * rho_y0
-        + rho_xx * rho_y0**2
-        + rho_xy**2 * rho_00
-        - 4 * rho_xx * rho_yy * rho_00
-    ) / (rho_xy**2 - 4 * rho_xx * rho_yy)
-    r1 = 1 / jnp.sqrt(lambda_1 / k)
-    r2 = 1 / jnp.sqrt(lambda_2 / k)
+    # get new coefficients for the centered ellipse: all others are zero now,
+    # explicitly got rid of rho_00 so there's a lot more divison
+    rho_xx_shift = -(
+        (rho_xx * (rho_xy**2 - 4 * rho_xx * rho_yy))
+        / (
+            (-1 + rho_00) * rho_xy**2
+            - rho_x0 * rho_xy * rho_y0
+            + rho_x0**2 * rho_yy
+            + rho_xx * (rho_y0**2 + 4 * rho_yy - 4 * rho_00 * rho_yy)
+        )
+    )
+    rho_xy_shift = (-(rho_xy**3) + 4 * rho_xx * rho_xy * rho_yy) / (
+        (-1 + rho_00) * rho_xy**2
+        - rho_x0 * rho_xy * rho_y0
+        + rho_x0**2 * rho_yy
+        + rho_xx * (rho_y0**2 + 4 * rho_yy - 4 * rho_00 * rho_yy)
+    )
+    rho_yy_shift = -(
+        (rho_yy * (rho_xy**2 - 4 * rho_xx * rho_yy))
+        / (
+            (-1 + rho_00) * rho_xy**2
+            - rho_x0 * rho_xy * rho_y0
+            + rho_x0**2 * rho_yy
+            + rho_xx * (rho_y0**2 + 4 * rho_yy - 4 * rho_00 * rho_yy)
+        )
+    )
+
+    # get the rotation angle (edge case gives you nans if there's no rotation)
+    theta = jnp.where(
+        rho_xx_shift - rho_yy_shift != 0.0,
+        0.5 * jnp.arctan2(rho_xy_shift, (rho_xx_shift - rho_yy_shift)) + jnp.pi / 2,
+        0.0,
+    )
+    theta = jnp.where(theta < 0.0, theta + jnp.pi, theta)
+    # jax.debug.print("{x}", x=theta)
+    cosa = jnp.cos(theta)
+    sina = jnp.sin(theta)
+
+    # get the semi-major and semi-minor axes
+    a = (
+        rho_xx_shift * jnp.cos(theta) ** 2
+        + rho_xy_shift * jnp.cos(theta) * jnp.sin(theta)
+        + rho_yy_shift * jnp.sin(theta) ** 2
+    )
+    b = (
+        rho_xx_shift * jnp.sin(theta) ** 2
+        - rho_xy_shift * jnp.cos(theta) * jnp.sin(theta)
+        + rho_yy_shift * jnp.cos(theta) ** 2
+    )
+
+    r1 = 1 / jnp.sqrt(a)
+    r2 = 1 / jnp.sqrt(b)
+
     return r1, r2, xc, yc, cosa, sina
 
 
@@ -141,41 +201,17 @@ def cartesian_intersection_to_parametric_angle(
 
     """
 
-    def inner(x, y):
-        def loss(alpha):
-            x_alpha = c_x1 * jnp.cos(alpha) + c_x2 * jnp.sin(alpha) + c_x3
-            y_alpha = c_y1 * jnp.cos(alpha) + c_y2 * jnp.sin(alpha) + c_y3
-
-            return (x - x_alpha) ** 2 + (y - y_alpha) ** 2
-
-        # could have just used autograd, but it's simple enough to do by hand
-        def grad_loss(alpha):
-            return 2 * (c_x2 * jnp.cos(alpha) - c_x1 * jnp.sin(alpha)) * (
-                c_x3 - x + c_x1 * jnp.cos(alpha) + c_x2 * jnp.sin(alpha)
-            ) + 2 * (c_y2 * jnp.cos(alpha) - c_y1 * jnp.sin(alpha)) * (
-                c_y3 - y + c_y1 * jnp.cos(alpha) + c_y2 * jnp.sin(alpha)
-            )
-
-        def scan_func(alpha, _):
-            # rarely, but sometimes, it actually reaches loss=0 and grad=0
-            # in that case, it throws nans when it tries to divide and everything
-            # following that is wrong
-            l = loss(alpha)
-            g = grad_loss(alpha)
-
-            def not_converged(alpha):
-                return alpha - l / g, None
-
-            def converged(alpha):
-                return alpha, None
-
-            return jax.lax.cond(jnp.abs(g) > 1e-16, not_converged, converged, alpha)
+    # center the ellipse
+    xs -= c_x3
+    ys -= c_y3
 
-        # if it starts on the actual value, will get nans
-        # previously had it start at 0, but in idealized cases used for testing it really is 0
-        return jax.lax.scan(scan_func, 0.123, None, length=50)[0]
+    # the x, y positions are now linear combinations of just cosa, sina
+    # linear solve for those
+    inv = jnp.linalg.inv(jnp.array([[c_x1, c_x2], [c_y1, c_y2]]))
+    matrix = jax.vmap(lambda x, y: jnp.matmul(inv, jnp.array([x, y])))(xs, ys)
+    cosa = matrix[:, 0]
+    sina = matrix[:, 1]
 
-    alphas = jax.vmap(inner)(xs, ys)
-    alphas = jnp.mod(alphas, 2 * jnp.pi)
-    alphas = jnp.where(alphas < 0, alphas + 2 * jnp.pi, alphas)
-    return alphas
+    # convert to alpha
+    alpha = jnp.arctan2(sina, cosa)
+    return alpha

{squishyplanet-0.2.0 → squishyplanet-0.2.2}/squishyplanet/engine/polynomial_limb_darkened_transit.py

@@ -12,7 +12,7 @@ from squishyplanet.engine.parametric_ellipse import (
     poly_to_parametric,
     cartesian_intersection_to_parametric_angle,
 )
-from squishyplanet.engine.kepler import kepler, skypos
+from squishyplanet.engine.kepler import kepler, skypos, t0_to_t_peri
 
 epsabs = epsrel = 1e-12
 
@@ -438,6 +438,9 @@ def lightcurve(state, parameterize_with_projected_ellipse):
     # array we'll modify if the planet is in transit
     fluxes = jnp.ones_like(state["times"])
 
+    if state["t0"] is not None:
+        state["t_peri"] = t0_to_t_peri(**state)
+
     time_deltas = state["times"] - state["t_peri"]
     mean_anomalies = 2 * jnp.pi * time_deltas / state["period"]
     true_anomalies = kepler(mean_anomalies, state["e"])

{squishyplanet-0.2.0 → squishyplanet-0.2.2}/squishyplanet/oblate_system.py

@@ -19,7 +19,7 @@ from squishyplanet.engine.parametric_ellipse import (
     poly_to_parametric,
 )
 from squishyplanet.engine.greens_basis_transform import generate_change_of_basis_matrix
-from squishyplanet.engine.kepler import kepler, skypos
+from squishyplanet.engine.kepler import kepler, skypos, t0_to_t_peri
 from squishyplanet.engine.polynomial_limb_darkened_transit import (
     lightcurve,
     parameterize_2d_helper,
@@ -70,8 +70,10 @@ class OblateSystem:
             (e.g. BJD) will work. A required parameter, will raise an error if not
             provided.
         t_peri (float, [Days], default=None):
-            The time of periastron passage. A required parameter, will raise an error
-            if not provided.
+            The time of periastron passage. One of ``t_peri`` or ``t0`` must be
+            provided.
+        t0 (float, [Days], default=None):
+            The time of transit center. One of ``t_peri`` or ``t0`` must be provided.
         period (float, [Days], default=None):
             The period of the orbit. A required parameter, will raise an error if not
             provided.
@@ -241,6 +243,7 @@ class OblateSystem:
         self,
         times=None,
         t_peri=None,
+        t0=None,
         period=None,
         a=None,
         tidally_locked=None,
@@ -363,7 +366,11 @@ class OblateSystem:
 
         # everything below here is just an instantaneous snapshot mostly for plotting,
         # these will all vary with different parameter inputs
-        time_deltas = self._state["times"] - self._state["t_peri"]
+        if self._state["t_peri"] is None:
+            tp = t0_to_t_peri(**self._state)
+        else:
+            tp = self._state["t_peri"]
+        time_deltas = self._state["times"] - tp
         mean_anomalies = 2 * jnp.pi * time_deltas / state["period"]
         true_anomalies = kepler(mean_anomalies, state["e"])
         self._state["f"] = true_anomalies
@@ -449,8 +456,16 @@ class OblateSystem:
                     if self._state["parameterize_with_projected_ellipse"]:
                         self._state["r"] = 0.0
                         continue
+                if key == "t_peri":
+                    continue
+                if key == "t0":
+                    continue
                 raise ValueError(f"'{key}' is a required parameter")
 
+        assert (self._state["t_peri"] is None) != (
+            self._state["t0"] is None
+        ), "Exactly one of 't_peri' or 't0' must be specified"
+
         self._state["ld_u_coeffs"] = jnp.array(self._state["ld_u_coeffs"])
         assert (
             self._state["ld_u_coeffs"].shape[0] >= 2
@@ -486,6 +501,8 @@ class OblateSystem:
                 self._state[key] = jnp.array([self._state[key]])
                 shapes.append(1)
             else:
+                if self._state[key] is None:
+                    continue  # still one None hanging around, either t0 or t_peri
                 if len(self._state[key].shape) > 1:
                     raise ValueError(
                         "All parameters must be scalars or 1D arrays of the same shape."

{squishyplanet-0.2.0 → squishyplanet-0.2.2/squishyplanet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: squishyplanet
-Version: 0.2.0
+Version: 0.2.2
 Summary: A package for dealing with non-spherical exoplanets
 Author-email: Ben Cassese <b.c.cassese@columbia.edu>
 License: MIT
@@ -26,11 +26,12 @@ Requires-Dist: ipykernel
 
 # squishyplanet
 
-[![status](https://joss.theoj.org/papers/2b62acea4e4d6c0de73309184861d1e9/status.svg)](https://joss.theoj.org/papers/2b62acea4e4d6c0de73309184861d1e9)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.06972/status.svg)](https://doi.org/10.21105/joss.06972)
 [![Documentation Status](https://readthedocs.org/projects/squishyplanet/badge/?version=latest)](https://squishyplanet.readthedocs.io/en/latest/?badge=latest)
 ![Build Status](https://github.com/ben-cassese/squishyplanet/actions/workflows/tests.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/ben-cassese/squishyplanet/badge.svg?branch=main&service=github)](https://coveralls.io/github/ben-cassese/squishyplanet?branch=main)
 ![PyPI - Version](https://img.shields.io/pypi/v/squishyplanet)
+ [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 A package for modeling non-spherical exoplanets.
 
@@ -52,23 +53,20 @@ See the [installation instructions](https://squishyplanet.readthedocs.io/en/late
 
 ## Attribution and License
 
- [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[hopefully joss badge]
 
-``squishyplanet`` is made freely available under the MIT License. If you use this code in your research, please cite the accompanying JOSS paper. The citation information will be updated once the paper is submitted/accepted.
+``squishyplanet`` is made freely available under the MIT License. If you use this code in your research, please cite the accompanying JOSS paper:
 
 ```
-@article{
-    squishyplanet,
-    doi = {},
-    url = {},
-    year = 2024,
-    month = {},
-    publisher = {},
-    volume = {},
-    number = {},
-    author = {},
-    title = {squishyplanet: modeling transits of non-spherical exoplanets in JAX},
-    journal = {}
+@article{squishyplanet,
+   author = {{Cassese}, Ben and {Vega}, Justin and {Lu}, Tiger and {Rice}, Malena and {Poddar}, Avishi and {Kipping}, David},
+   doi = {10.21105/joss.06972},
+   journal = {Journal of Open Source Software},
+   month = aug,
+   number = {100},
+   pages = {6972},
+   title = {{squishyplanet: modeling transits of non-spherical exoplanets in JAX}},
+   url = {https://joss.theoj.org/papers/10.21105/joss.06972},
+   volume = {9},
+   year = {2024}
 }
 ```

{squishyplanet-0.2.0 → squishyplanet-0.2.2}/tests/test_projected_parameterization.py

@@ -13,9 +13,8 @@ def test_projected_parameterization():
     t_exp = 5 * u.min
     times = jnp.arange(-30, 30, t_exp.to(u.hour).value) * u.hour.to(u.day)
 
-    for i in range(1_000):
+    for i in range(2_000):
         key, *subkeys = jax.random.split(key, (5,))
-        # if i < 529: continue
 
         # the 3d planet
         injected_state = {
@@ -29,8 +28,8 @@ def test_projected_parameterization():
             "r": 0.1,
             "i": 89.9720 * jnp.pi / 180,
             "ld_u_coeffs": jnp.array([0.4, 0.26]),
-            "f1": jax.random.uniform(subkeys[0], (1,), minval=0.0, maxval=0.5),
-            "f2": jax.random.uniform(subkeys[1], (1,), minval=0.0, maxval=0.5),
+            "f1": jax.random.uniform(subkeys[0], (1,), minval=0.0, maxval=0.99),
+            "f2": jax.random.uniform(subkeys[1], (1,), minval=0.0, maxval=0.99),
             "obliq": jax.random.uniform(subkeys[2], (1,), minval=0.0, maxval=jnp.pi),
             "prec": jax.random.uniform(subkeys[3], (1,), minval=0.0, maxval=jnp.pi),
             "tidally_locked": False,
@@ -68,4 +67,10 @@ def test_projected_parameterization():
         assert jnp.min(lc1 >= r**2)
         assert jnp.min(lc2 >= r**2)
 
+        # single point outliers
+        diff = jnp.diff(lc1)
+        assert jnp.abs(jnp.argmax(diff) - jnp.argmin(diff)) != 1
+        diff = jnp.diff(lc2)
+        assert jnp.abs(jnp.argmax(diff) - jnp.argmin(diff)) != 1
+
         assert jnp.allclose(lc1, lc2)