ssapy-toolkit 1.0.0__py3-none-any.whl

ssapy_toolkit/Accelerations/__init__.py

@@ -0,0 +1,18 @@
+"""Acceleration models and utilities for orbit propagation."""
+
+import importlib
+import os
+
+# Get the directory of the current file
+sub_dir = os.path.dirname(__file__)
+
+# Loop through all Python files in this directory and import their functions
+for filename in os.listdir(sub_dir):
+    if filename.endswith(".py") and filename != "__init__.py":
+        module_name = f"{__name__}.{filename[:-3]}"
+        module = importlib.import_module(module_name)
+
+        # Add all attributes of the module to the package namespace
+        for attr in dir(module):
+            if not attr.startswith("_"):  # Avoid internal attributes
+                globals()[attr] = getattr(module, attr)

ssapy_toolkit/Accelerations/accel_add.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+
+def accel_add(*accel_funcs):
+    """
+    Returns a function that sums multiple acceleration functions.
+
+    Parameters
+    ----------
+    accel_funcs : list of functions
+        Each must take (r) or (r, t) depending on your usage.
+
+    Returns
+    -------
+    combined : function
+        A function that evaluates and sums all input accelerations.
+    """
+    def combined(r, t=None):
+        total = np.zeros(3)
+        for f in accel_funcs:
+            try:
+                total += f(r, t)
+            except TypeError:
+                total += f(r)
+        return total
+    return combined

ssapy_toolkit/Accelerations/accel_circularize.py

@@ -0,0 +1,88 @@
+# ssapy_toolkit/Accelerations/accel_circularize.py
+
+import numpy as np
+from ..constants import EARTH_MU, EARTH_RADIUS  # [56]
+
+_orbit_achieved = False  # global variable to track circularization
+
+
+def reset_orbit_status():
+    """Reset the internal latch so circularization thrust can be used again."""
+    global _orbit_achieved
+    _orbit_achieved = False
+
+
+def accel_to_circular(r, v, t=None, *, thrust, tol=10.0, min_altitude=100e3):
+    """
+    Acceleration command that steers (r, v) toward a circular orbit at radius |r|.
+
+    Designed to be passed into leapfrog(..., accels=[...]) where leapfrog may call
+    accelerations as f(r,v,t) (t is accepted but not required here).
+
+    Parameters
+    ----------
+    r : array_like, shape (3,)
+        Position vector (m).
+    v : array_like, shape (3,)
+        Velocity vector (m/s).
+    t : optional
+        Time (ignored; present for integrator compatibility).
+    thrust : float
+        Magnitude of available acceleration (m/s^2).
+    tol : float, optional
+        Convergence tolerance on ||v_target - v|| (m/s). Default 10.
+    min_altitude : float, optional
+        Minimum altitude above Earth's surface to allow control (m). Default 100 km.
+
+    Returns
+    -------
+    a : ndarray, shape (3,)
+        Acceleration command (m/s^2), or zeros if converged/disabled.
+    """
+    global _orbit_achieved
+
+    if _orbit_achieved:
+        return np.zeros(3, dtype=float)
+
+    r = np.asarray(r, dtype=float).reshape(3)
+    v = np.asarray(v, dtype=float).reshape(3)
+
+    r_norm = np.linalg.norm(r)
+    if r_norm == 0.0 or thrust == 0.0:
+        return np.zeros(3, dtype=float)
+
+    if r_norm < EARTH_RADIUS + float(min_altitude):
+        return np.zeros(3, dtype=float)
+
+    # Unit radial direction
+    r_hat = r / r_norm
+
+    # Tangential velocity component
+    v_r = float(np.dot(v, r_hat))
+    v_t_vec = v - v_r * r_hat
+    v_t = np.linalg.norm(v_t_vec)
+
+    if v_t > 0.0:
+        t_hat = v_t_vec / v_t
+    else:
+        # Fallback if velocity is purely radial: pick a consistent tangential direction
+        t_hat = np.cross(np.array([0.0, 0.0, 1.0]), r_hat)
+        n = np.linalg.norm(t_hat)
+        if n == 0.0:
+            return np.zeros(3, dtype=float)
+        t_hat /= n
+
+    # Circular speed at current radius
+    v_circ = np.sqrt(EARTH_MU / r_norm)
+
+    # Desired circular velocity vector (purely tangential)
+    v_target = v_circ * t_hat
+
+    dv = v_target - v
+    dv_norm = np.linalg.norm(dv)
+
+    if dv_norm <= float(tol) or dv_norm == 0.0:
+        _orbit_achieved = True
+        return np.zeros(3, dtype=float)
+
+    return float(thrust) * (dv / dv_norm)

ssapy_toolkit/Accelerations/accel_deltav.py

@@ -0,0 +1,50 @@
+import numpy as np
+
+def accel_deltav(dv: float, thrust_accel: float, center_idx: int, dt: float = 1.0) -> dict:
+    """
+    Build a Δv-based along-track accel profile centered at a given step.
+
+    Parameters
+    ----------
+    dv : float
+        Signed total Δv to deliver (m/s). (Only its sign matters.)
+    thrust_accel : float
+        Available constant acceleration magnitude (m/s²). Must be > 0.
+    center_idx : int
+        Index in your time array where the burn is centered.
+    dt : float, optional
+        Uniform timestep between your indices (s). Defaults to 1 s.
+
+    Returns
+    -------
+    profile : dict
+        A dict with keys:
+          - 'thrust' : signed acceleration (m/s²)
+          - 'start'  : start index (int)
+          - 'end'    : end index (int)
+        which you can pass directly to `leapfrog(..., velocity=profile)`.
+    """
+    if thrust_accel <= 0:
+        raise ValueError("`thrust_accel` must be positive")
+    if dt <= 0:
+        raise ValueError("`dt` must be positive")
+
+    # total burn time (s) required for |Δv|
+    burn_time = abs(dv) / thrust_accel
+
+    # number of steps (round to nearest int, minimum 1)
+    steps = max(1, int(round(burn_time / dt)))
+
+    # center the burn on center_idx
+    half = steps // 2
+    start = center_idx - half
+    end = start + steps  # ensures end - start == steps
+
+    # signed acceleration to match dv's sign
+    signed_accel = thrust_accel * np.sign(dv)
+
+    return {
+        "thrust": signed_accel,
+        "start": start,
+        "end": end,
+    }

ssapy_toolkit/Accelerations/accel_deltav_vector.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+
+def accel_deltav_vector(dv, duration):
+    """
+    Compute the constant acceleration vector needed to achieve a given Δv in a set time.
+
+    Parameters
+    ----------
+    dv : array_like, shape (3,)
+        Desired change in velocity vector (m/s).
+    duration : float
+        Time over which to apply the acceleration (s).
+
+    Returns
+    -------
+    thrust : float
+        Magnitude of the required acceleration (m/s²).
+    direction : ndarray, shape (3,)
+        Unit vector indicating acceleration direction.
+    a_vec : ndarray, shape (3,)
+        Acceleration vector (m/s²) that, when applied constantly over `duration`, yields `dv`.
+
+    Raises
+    ------
+    ValueError
+        If `duration` is zero or negative.
+    """
+    dv = np.asarray(dv, dtype=float)
+    if duration <= 0:
+        raise ValueError("Duration must be positive and non-zero.")
+    dv_norm = np.linalg.norm(dv)
+    if dv_norm == 0:
+        return 0.0, np.zeros(3), np.zeros(3)
+
+    thrust = dv_norm / duration
+    direction = dv / dv_norm
+    a_vec = thrust * direction
+    return thrust, direction, a_vec

ssapy_toolkit/Accelerations/accel_earth_harmonics.py

@@ -0,0 +1,172 @@
+# ssapy_toolkit/Accelerations/accel_earth_harmonics.py
+
+import numpy as np
+from ..constants import EARTH_MU, EARTH_RADIUS
+
+
+def _check_r_safe(r2: float) -> None:
+    """Raise error if r is below Earth's surface."""
+    r_mag = float(np.sqrt(r2))
+    if r_mag < EARTH_RADIUS:
+        raise ValueError(f"r magnitude ({r_mag:.2f} m) is below Earth's surface.")
+
+
+def accel_J2(r: np.ndarray) -> np.ndarray:
+    J2 = 1.08262668e-3
+    mu = EARTH_MU
+    Re = EARTH_RADIUS
+
+    r = np.asarray(r, dtype=float).reshape(3)
+    r2 = float(np.dot(r, r))
+    _check_r_safe(r2)
+    r_mag = np.sqrt(r2)
+
+    inv_r5 = 1.0 / (r2 * r_mag**3)  # = 1/r^5
+    z = r[2]
+    u = z / r_mag
+    k2 = 5.0 * u**2 - 1.0
+
+    factor2 = 1.5 * J2 * mu * Re**2 * inv_r5
+    return factor2 * np.array([r[0] * k2, r[1] * k2, r[2] * (5.0 * u**2 - 3.0)])
+
+
+def accel_J3(r: np.ndarray) -> np.ndarray:
+    J3 = -2.5324105e-6
+    mu = EARTH_MU
+    Re = EARTH_RADIUS
+
+    r = np.asarray(r, dtype=float).reshape(3)
+    r2 = float(np.dot(r, r))
+    _check_r_safe(r2)
+    r_mag = np.sqrt(r2)
+
+    inv_r6 = 1.0 / (r2**3)  # = 1/r^6
+    z = r[2]
+    u = z / r_mag
+
+    P3 = 0.5 * (5.0 * u**3 - 3.0 * u)
+    dP3 = 0.5 * (15.0 * u**2 - 3.0)
+    factor3 = -mu * J3 * Re**3 * inv_r6
+    return factor3 * (4.0 * P3 * r - dP3 * r * u * np.array([0.0, 0.0, 1.0]))
+
+
+def accel_J4(r: np.ndarray) -> np.ndarray:
+    J4 = -1.6198976e-6
+    mu = EARTH_MU
+    Re = EARTH_RADIUS
+
+    r = np.asarray(r, dtype=float).reshape(3)
+    r2 = float(np.dot(r, r))
+    _check_r_safe(r2)
+    r_mag = np.sqrt(r2)
+
+    inv_r7 = 1.0 / (r2**2 * r_mag**3)  # = 1/r^7
+    z = r[2]
+    u = z / r_mag
+
+    P4 = (1.0 / 8.0) * (35.0 * u**4 - 30.0 * u**2 + 3.0)
+    dP4 = (1.0 / 8.0) * (140.0 * u**3 - 60.0 * u)
+    factor4 = -mu * J4 * Re**4 * inv_r7
+    return factor4 * (5.0 * P4 * r - dP4 * r * u * np.array([0.0, 0.0, 1.0]))
+
+
+def accel_J5(r: np.ndarray) -> np.ndarray:
+    J5 = -2.272960828e-7
+    mu = EARTH_MU
+    Re = EARTH_RADIUS
+
+    r = np.asarray(r, dtype=float).reshape(3)
+    r2 = float(np.dot(r, r))
+    _check_r_safe(r2)
+    r_mag = np.sqrt(r2)
+
+    inv_r9 = 1.0 / (r2**4 * r_mag)  # = 1/r^9
+    z = r[2]
+    u = z / r_mag
+
+    P5 = (1.0 / 8.0) * (63.0 * u**5 - 70.0 * u**3 + 15.0 * u)
+    dP5 = (1.0 / 8.0) * (315.0 * u**4 - 210.0 * u**2 + 15.0)
+    factor5 = -mu * J5 * Re**5 * inv_r9
+    return factor5 * (6.0 * P5 * r - dP5 * r * u * np.array([0.0, 0.0, 1.0]))
+
+
+def accel_J6(r: np.ndarray) -> np.ndarray:
+    J6 = 5.406812391e-7
+    mu = EARTH_MU
+    Re = EARTH_RADIUS
+
+    r = np.asarray(r, dtype=float).reshape(3)
+    r2 = float(np.dot(r, r))
+    _check_r_safe(r2)
+    r_mag = np.sqrt(r2)
+
+    inv_r10 = 1.0 / (r2**4 * r_mag**2)  # = 1/r^10
+    z = r[2]
+    u = z / r_mag
+
+    P6 = (1.0 / 16.0) * (231.0 * u**6 - 315.0 * u**4 + 105.0 * u**2 - 5.0)
+    dP6 = (1.0 / 16.0) * (1386.0 * u**5 - 1260.0 * u**3 + 210.0 * u)
+    factor6 = -mu * J6 * Re**6 * inv_r10
+    return factor6 * (7.0 * P6 * r - dP6 * r * u * np.array([0.0, 0.0, 1.0]))
+
+
+def accel_J7(r: np.ndarray) -> np.ndarray:
+    J7 = -3.529000898e-7
+    mu = EARTH_MU
+    Re = EARTH_RADIUS
+
+    r = np.asarray(r, dtype=float).reshape(3)
+    r2 = float(np.dot(r, r))
+    _check_r_safe(r2)
+    r_mag = np.sqrt(r2)
+
+    inv_r11 = 1.0 / (r2**4 * r_mag**3)  # = 1/r^11
+    z = r[2]
+    u = z / r_mag
+
+    P7 = (1.0 / 16.0) * (429.0 * u**7 - 693.0 * u**5 + 315.0 * u**3 - 35.0 * u)
+    dP7 = (1.0 / 16.0) * (3003.0 * u**6 - 3465.0 * u**4 + 945.0 * u**2 - 35.0)
+    factor7 = -mu * J7 * Re**7 * inv_r11
+    return factor7 * (8.0 * P7 * r - dP7 * r * u * np.array([0.0, 0.0, 1.0]))
+
+
+def accel_J8(r: np.ndarray) -> np.ndarray:
+    J8 = 2.532000898e-7
+    mu = EARTH_MU
+    Re = EARTH_RADIUS
+
+    r = np.asarray(r, dtype=float).reshape(3)
+    r2 = float(np.dot(r, r))
+    _check_r_safe(r2)
+    r_mag = np.sqrt(r2)
+
+    inv_r12 = 1.0 / (r2**5 * r_mag**2)  # = 1/r^12
+    z = r[2]
+    u = z / r_mag
+
+    P8 = (1.0 / 128.0) * (6435.0 * u**8 - 12012.0 * u**6 + 6930.0 * u**4 - 1260.0 * u**2 + 35.0)
+    dP8 = (1.0 / 128.0) * (51480.0 * u**7 - 72072.0 * u**5 + 27720.0 * u**3 - 2520.0 * u)
+    factor8 = -mu * J8 * Re**8 * inv_r12
+    return factor8 * (9.0 * P8 * r - dP8 * r * u * np.array([0.0, 0.0, 1.0]))
+
+
+def accel_earth_harmonics(r: np.ndarray) -> np.ndarray:
+    """
+    Central gravity + J2..J8 zonal harmonics.
+    """
+    r = np.asarray(r, dtype=float).reshape(3)
+    r2 = float(np.dot(r, r))
+    _check_r_safe(r2)
+    r_mag = np.sqrt(r2)
+
+    a_central = -EARTH_MU * r / (r_mag**3)  # [59]
+    return (
+        a_central
+        + accel_J2(r)
+        + accel_J3(r)
+        + accel_J4(r)
+        + accel_J5(r)
+        + accel_J6(r)
+        + accel_J7(r)
+        + accel_J8(r)
+    )

ssapy_toolkit/Accelerations/accel_equitorial.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+
+def accel_equatorial(r, v, magnitude):
+    """
+    Acceleration vector always in the equatorial (east/west) direction,
+    i.e. perpendicular to the Earth's spin axis and radial direction,
+    positive -> counter-clockwise (eastward), negative -> clockwise.
+
+    Parameters
+    ----------
+    r : array_like, shape (3,)
+        Position (radial) vector in meters.
+    v : array_like, shape (3,)
+        (Unused; kept for signature consistency.)
+    magnitude : float
+        Desired magnitude of the equatorial-plane acceleration in m/s^2.
+
+    Returns
+    -------
+    a : ndarray, shape (3,)
+        Equatorial-plane acceleration vector in m/s^2.
+    """
+    r = np.asarray(r, dtype=float).reshape(3)
+
+    if magnitude == 0:
+        return np.zeros(3, dtype=float)
+
+    norm_r = np.linalg.norm(r)
+    if norm_r == 0:
+        return np.zeros(3, dtype=float)
+
+    r_hat = r / norm_r
+    z_hat = np.array([0.0, 0.0, 1.0], dtype=float)
+
+    equ_dir = np.cross(z_hat, r_hat)
+    norm_eq = np.linalg.norm(equ_dir)
+    if norm_eq == 0:
+        return np.zeros(3, dtype=float)
+
+    return float(magnitude) * equ_dir / norm_eq

ssapy_toolkit/Accelerations/accel_inclination.py

@@ -0,0 +1,40 @@
+# ssapy_toolkit/Accelerations/accel_inclination.py
+
+import numpy as np
+
+
+def accel_inclination(r, v, magnitude):
+    """
+    Acceleration vector always in the local north/south direction,
+    i.e. perpendicular to the radial direction but aimed toward
+    the Earth's North pole (or South if magnitude < 0).
+
+    Parameters
+    ----------
+    r : array_like, shape (3,)
+        Position (radial) vector in meters.
+    v : array_like, shape (3,)
+        (Unused; kept for signature consistency.)
+    magnitude : float
+        Desired magnitude of the inclination-change acceleration in m/s^2.
+        Positive -> northward; negative -> southward.
+
+    Returns
+    -------
+    a : ndarray, shape (3,)
+        Inclination-change acceleration vector in m/s^2.
+    """
+    r = np.asarray(r, dtype=float).reshape(3)
+    norm_r = np.linalg.norm(r)
+    if norm_r == 0.0 or magnitude == 0.0:
+        return np.zeros(3, dtype=float)
+
+    r_hat = r / norm_r
+    z_hat = np.array([0.0, 0.0, 1.0], dtype=float)
+
+    north_dir = z_hat - np.dot(z_hat, r_hat) * r_hat
+    norm_nd = np.linalg.norm(north_dir)
+    if norm_nd == 0.0:
+        return np.zeros(3, dtype=float)
+
+    return float(magnitude) * north_dir / norm_nd

ssapy_toolkit/Accelerations/accel_moon.py

@@ -0,0 +1,46 @@
+# ssapy_toolkit/Accelerations/accel_moon.py
+
+import numpy as np
+from astropy.time import Time
+from astropy import units as u
+from astropy.coordinates import get_body, GCRS, solar_system_ephemeris
+
+from ..constants import MOON_MU
+from ..Time_Functions import to_gps
+
+
+def accel_point_moon(r: np.ndarray, time) -> np.ndarray:
+    """
+    Point-mass lunar gravity in GCRF.
+
+    Parameters
+    ----------
+    r : array_like, shape (3,)
+        Satellite position vector in GCRF (m), Earth-centered.
+    time : float | datetime-like | astropy.time.Time | array_like
+        Time corresponding to the state (anything supported by to_gps()).
+
+    Returns
+    -------
+    a_moon : ndarray, shape (3,)
+        Acceleration from the Moon (m/s^2).
+    """
+    r = np.asarray(r, dtype=float).reshape(3)
+
+    # 1) Convert time to GPS seconds since 1980-01-06
+    time_gps = to_gps(time)  # [176]
+    t = Time(time_gps, format="gps", scale="utc")
+
+    # 2) Get Moon position in GCRS at this time using JPL ephemeris
+    with solar_system_ephemeris.set("jpl"):
+        moon_gcrs = get_body("moon", t).transform_to(GCRS(obstime=t))
+
+    r_moon = moon_gcrs.cartesian.xyz.to(u.m).value  # (3,)
+
+    # 3) Compute delta and gravitational acceleration
+    delta = r_moon - r
+    d = np.linalg.norm(delta)
+    if d == 0.0:
+        return np.zeros(3, dtype=float)
+
+    return MOON_MU * delta / d**3

ssapy_toolkit/Accelerations/accel_plane.py

@@ -0,0 +1,44 @@
+# ssapy_toolkit/Accelerations/accel_plane.py
+
+import numpy as np
+
+
+def accel_plane(r, v, magnitude):
+    """
+    Tangential acceleration in the orbital plane, perpendicular to r̂.
+
+    Parameters
+    ----------
+    r : array_like, shape (3,)
+        Position vector in meters.
+    v : array_like, shape (3,)
+        Velocity vector in meters per second.
+    magnitude : float
+        Desired acceleration magnitude in m/s^2.
+        Positive → along the direction of motion;
+        negative → opposite direction.
+
+    Returns
+    -------
+    a : ndarray, shape (3,)
+        Tangential acceleration vector in m/s^2.
+    """
+    r = np.asarray(r, dtype=float).reshape(3)
+    v = np.asarray(v, dtype=float).reshape(3)
+
+    if magnitude == 0:
+        return np.zeros(3, dtype=float)
+
+    norm_r = np.linalg.norm(r)
+    if norm_r == 0:
+        return np.zeros(3, dtype=float)
+
+    r_hat = r / norm_r
+
+    # Remove radial component of v to get purely tangential direction
+    tangential = v - np.dot(v, r_hat) * r_hat
+    norm_tan = np.linalg.norm(tangential)
+    if norm_tan == 0:
+        return np.zeros(3, dtype=float)
+
+    return float(magnitude) * tangential / norm_tan

ssapy_toolkit/Accelerations/accel_point_earth.py

@@ -0,0 +1,9 @@
+import numpy as np
+from ..constants import EARTH_MU
+
+
+def accel_point_earth(r):
+    x, y, z = r
+    r_mag = np.sqrt(x**2 + y**2 + z**2)
+    factor = -EARTH_MU / (r_mag**3)
+    return np.array([factor * x, factor * y, factor * z])

ssapy_toolkit/Accelerations/accel_radial.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+
+def accel_radial(r, magnitude):
+    """
+    Acceleration vector pointing radially outward from Earth's center
+    with user-specified magnitude.
+
+    Parameters
+    ----------
+    r : array_like, shape (3,)
+        Position vector in meters.
+    magnitude : float
+        Acceleration magnitude in m/s^2.
+
+    Returns
+    -------
+    a : ndarray, shape (3,)
+        Acceleration vector in m/s^2.
+
+    Author: Travis Yeager
+    """
+    r = np.asarray(r)
+    norm_r = np.linalg.norm(r)
+    if norm_r == 0.0:
+        return np.zeros(3)
+    return magnitude * r / norm_r

ssapy_toolkit/Accelerations/accel_sun.py

@@ -0,0 +1,38 @@
+import numpy as np
+from astropy.time import Time
+from astropy import units as u
+from astropy.coordinates import get_body, GCRS, solar_system_ephemeris
+
+from ..constants import SUN_MU
+from ..Time_Functions import to_gps
+
+
+def accel_point_sun(r: np.ndarray, time) -> np.ndarray:
+    """
+    Point-mass solar gravity in GCRF, given raw_time (same input as leapfrog).
+
+    Parameters
+    ----------
+    r : array_like, shape (3,)
+        Satellite position vector in GCRF (m), Earth-centered.
+    time : float or datetime-like or array_like
+        The time array element from leapfrog (same type you passed into leapfrog).
+
+    Returns
+    -------
+    a_sun : ndarray, shape (3,)
+        Acceleration from the Sun (m/s²).
+    """
+    # 1) Convert time to GPS seconds
+    time_gps = to_gps(time)
+    t = Time(time_gps, format="gps", scale="utc")
+
+    # 2) Get Sun position in GCRS at this time using JPL ephemeris
+    with solar_system_ephemeris.set('jpl'):
+        sun_gcrs = get_body("sun", t).transform_to(GCRS(obstime=t))
+
+    r_sun = sun_gcrs.cartesian.xyz.to(u.m).value
+
+    # 3) Compute delta and gravitational acceleration
+    delta = r_sun - r
+    return SUN_MU * delta / np.linalg.norm(delta) ** 3

ssapy_toolkit/Accelerations/accel_uniform_earth.py

@@ -0,0 +1,31 @@
+# ssapy_toolkit/Accelerations/accel_uniform_earth.py
+
+import numpy as np
+from ..constants import EARTH_RADIUS, EARTH_MU
+
+
+def accel_uniform_earth(r):
+    """
+    Piecewise gravity model:
+    - Outside Earth: point-mass gravity ~ -mu r / |r|^3
+    - Inside Earth (uniform-density sphere): linear gravity ~ -mu r / R^3
+
+    Parameters
+    ----------
+    r : array_like, shape (3,)
+        Position vector (m).
+
+    Returns
+    -------
+    a : ndarray, shape (3,)
+        Acceleration (m/s^2).
+    """
+    x, y, z = r
+    r_mag = np.sqrt(x**2 + y**2 + z**2)
+
+    if r_mag < EARTH_RADIUS:
+        factor = -EARTH_MU / (EARTH_RADIUS**3)
+    else:
+        factor = -EARTH_MU / (r_mag**3)
+
+    return np.array([factor * x, factor * y, factor * z])