kelvinzero 0.1.0__tar.gz

kelvinzero-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kyle Cooper and Yanni Nikas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kelvinzero-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include src/kelvinzero/viewer_dist *

kelvinzero-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: kelvinzero
+Version: 0.1.0
+Summary: Eclipse-minimising sun-synchronous orbits in a mean-Sun rotating frame: the model and the visualizer behind the Kelvin Zero paper.
+Author: Kyle Cooper, Yanni Nikas
+License: MIT
+Project-URL: Homepage, https://k0webapp.web.app/
+Project-URL: Paper, https://k0webapp.web.app/Kelvin-Zero-Whitepaper.pdf
+Project-URL: Source, https://github.com/kylecooper7/kelvin-zero
+Project-URL: Issues, https://github.com/kylecooper7/kelvin-zero/issues
+Keywords: sun-synchronous orbit,eclipse,analemma,astrodynamics,J2,beta angle
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: figures
+Requires-Dist: matplotlib>=3.7; extra == "figures"
+Requires-Dist: contourpy>=1.1; extra == "figures"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: matplotlib>=3.7; extra == "dev"
+Requires-Dist: contourpy>=1.1; extra == "dev"
+Dynamic: license-file
+
+# Kelvin Zero
+
+**Eclipse-minimising sun-synchronous orbits in a mean-Sun rotating frame — the open model.**
+
+This package is the complete, inspectable source of every number, figure and 3-D view in the
+Kelvin Zero whitepaper and the interactive visualizer at <https://k0webapp.web.app>. It is pure
+NumPy, a few hundred lines, and organised the way the paper is:
+
+| module | what it holds |
+|---|---|
+| `kelvinzero.sun` | the apparent Sun (USNO low-precision ephemeris), the mean Sun, the **analemma**, Earth's heliocentric position |
+| `kelvinzero.frames` | the **EMI** (inertial) and **MSSI** (mean-Sun synchronous) frames, sidereal time |
+| `kelvinzero.orbit` | the sun-synchronous condition, J2 nodal precession, 3-D positions, the **β angle**, the cylindrical-shadow **eclipse fraction**, yearly statistics |
+| `kelvinzero.regions` | the always / sometimes / never-eclipsed **region maps** and their ∂U / ∂I contours |
+| `kelvinzero.figures` | the paper's figures (matplotlib) |
+| `kelvinzero.viz` | runs the **visualizer** locally — the same one as the website |
+| `kelvinzero.reference` | reference values for cross-checking other implementations |
+
+## Install
+
+```bash
+pip install kelvinzero            # model + the built visualizer (NumPy only)
+pip install "kelvinzero[figures]" # + matplotlib, for the figures
+```
+
+or from a checkout: `pip install -e ".[dev]"`.
+
+## Thirty seconds
+
+```python
+from kelvinzero import Orbit, yearly_eclipse_stats, no_eclipse_beta_deg
+
+o = Orbit(altitude_km=800, raan_offset_deg=270)   # dawn–dusk, LTAN 06:00; inclination is set by the SSO condition
+print(o.inclination_deg)                           # 98.603
+print(no_eclipse_beta_deg(800))                    # 62.69  — eclipse-free once |β| exceeds this
+print(yearly_eclipse_stats(o))                     # eclipse_fraction≈0.0267, eclipse_days≈74, β from −89.9° to −58.0°
+```
+
+```bash
+kelvinzero stats --alt 1500 --raan 270      # a fixed plane that is never eclipsed
+kelvinzero sweep --alt 800                  # yearly eclipse versus node offset
+kelvinzero figures out/                     # regenerate the paper's figures
+kelvinzero viz --alt 800 --raan 270 --view eclipse    # the visualizer, in your browser, served from your machine
+kelvinzero reference reference.json         # values to test another implementation against
+```
+
+## The visualizer
+
+`kelvinzero viz` serves a built copy of the visualizer from <https://k0webapp.web.app> on a local
+port and opens it — the identical React + Three.js application, minus the website chrome. Its
+source is in [`viewer/`](viewer): the JavaScript model in `viewer/src/model` mirrors this package
+function for function (`sun.js`, `frames.js`, `orbit.js`, `regions.js`), and the 3-D scene is
+`viewer/src/scene/OrbitScene.js`. To work on it:
+
+```bash
+cd viewer && npm install
+npm run dev      # live-reloading dev server
+npm test         # the JS model against this package's reference values (reference.json)
+npm run build    # refreshes the copy shipped in src/kelvinzero/viewer_dist
+```
+
+## The model in one paragraph
+
+A circular orbit of altitude *h* is sun-synchronous when its J2 nodal precession equals the mean
+Sun's rate, which fixes the inclination (`sso_inclination_deg`). In the **MSSI** frame — EMI
+rotated about the spin axis by the mean solar longitude *L(d)* — such a plane is frozen and the
+real Sun traces the **analemma** (`sun_direction_mssi`, `analemma_mssi`). The Sun's elevation
+above the plane is the **β angle** (`beta_angle`); the fraction of each revolution spent in
+Earth's cylindrical shadow is the closed form `eclipse_fraction_per_orbit`, zero once
+|β| ≥ asin(R/(R+h)). Averaging over the year gives `yearly_eclipse_stats`. Mapping
+`max_t p·s` and `min_t p·s` over the sphere (`compute_sun_dot_extrema`) classifies every direction
+as always / sometimes / never eclipsed for a given altitude (`classify_regions`,
+`region_contours`).
+
+Conventions: `d` is days since J2000.0 (2000-01-01 12:00); the node offset Ω is measured from the
+mean Sun (Ω = 0 → LTAN 12:00, 90 → 18:00, 270 → 06:00); EMI has x toward the vernal equinox and z
+along the spin axis.
+
+## Verification
+
+`pytest` checks the closed-form eclipse fraction against brute-force cylindrical-shadow sweeps,
+the USNO ephemeris against the NOAA/Spencer series, frame conventions (an exact SSO is frozen in
+MSSI, the Sun is west of the mean Sun in November, Ω = 90° ⇒ LTAN 18:00), the region maps against
+the β-angle picture, and the headline numbers of the paper. `kelvinzero reference` writes the
+values that the visualizer's JavaScript model is tested against.
+
+## Citing
+
+If you use the model or the paper, please cite the release (a `CITATION.cff` is included, so
+GitHub's "Cite this repository" button gives you BibTeX/APA):
+
+> K. Cooper and Y. Nikas, *Kelvin Zero: eclipse-minimising sun-synchronous orbits in a mean-Sun
+> rotating frame*, v0.1.0 (2026). https://github.com/kylecooper7/kelvin-zero
+
+## License
+
+MIT.

kelvinzero-0.1.0/README.md

@@ -0,0 +1,97 @@
+# Kelvin Zero
+
+**Eclipse-minimising sun-synchronous orbits in a mean-Sun rotating frame — the open model.**
+
+This package is the complete, inspectable source of every number, figure and 3-D view in the
+Kelvin Zero whitepaper and the interactive visualizer at <https://k0webapp.web.app>. It is pure
+NumPy, a few hundred lines, and organised the way the paper is:
+
+| module | what it holds |
+|---|---|
+| `kelvinzero.sun` | the apparent Sun (USNO low-precision ephemeris), the mean Sun, the **analemma**, Earth's heliocentric position |
+| `kelvinzero.frames` | the **EMI** (inertial) and **MSSI** (mean-Sun synchronous) frames, sidereal time |
+| `kelvinzero.orbit` | the sun-synchronous condition, J2 nodal precession, 3-D positions, the **β angle**, the cylindrical-shadow **eclipse fraction**, yearly statistics |
+| `kelvinzero.regions` | the always / sometimes / never-eclipsed **region maps** and their ∂U / ∂I contours |
+| `kelvinzero.figures` | the paper's figures (matplotlib) |
+| `kelvinzero.viz` | runs the **visualizer** locally — the same one as the website |
+| `kelvinzero.reference` | reference values for cross-checking other implementations |
+
+## Install
+
+```bash
+pip install kelvinzero            # model + the built visualizer (NumPy only)
+pip install "kelvinzero[figures]" # + matplotlib, for the figures
+```
+
+or from a checkout: `pip install -e ".[dev]"`.
+
+## Thirty seconds
+
+```python
+from kelvinzero import Orbit, yearly_eclipse_stats, no_eclipse_beta_deg
+
+o = Orbit(altitude_km=800, raan_offset_deg=270)   # dawn–dusk, LTAN 06:00; inclination is set by the SSO condition
+print(o.inclination_deg)                           # 98.603
+print(no_eclipse_beta_deg(800))                    # 62.69  — eclipse-free once |β| exceeds this
+print(yearly_eclipse_stats(o))                     # eclipse_fraction≈0.0267, eclipse_days≈74, β from −89.9° to −58.0°
+```
+
+```bash
+kelvinzero stats --alt 1500 --raan 270      # a fixed plane that is never eclipsed
+kelvinzero sweep --alt 800                  # yearly eclipse versus node offset
+kelvinzero figures out/                     # regenerate the paper's figures
+kelvinzero viz --alt 800 --raan 270 --view eclipse    # the visualizer, in your browser, served from your machine
+kelvinzero reference reference.json         # values to test another implementation against
+```
+
+## The visualizer
+
+`kelvinzero viz` serves a built copy of the visualizer from <https://k0webapp.web.app> on a local
+port and opens it — the identical React + Three.js application, minus the website chrome. Its
+source is in [`viewer/`](viewer): the JavaScript model in `viewer/src/model` mirrors this package
+function for function (`sun.js`, `frames.js`, `orbit.js`, `regions.js`), and the 3-D scene is
+`viewer/src/scene/OrbitScene.js`. To work on it:
+
+```bash
+cd viewer && npm install
+npm run dev      # live-reloading dev server
+npm test         # the JS model against this package's reference values (reference.json)
+npm run build    # refreshes the copy shipped in src/kelvinzero/viewer_dist
+```
+
+## The model in one paragraph
+
+A circular orbit of altitude *h* is sun-synchronous when its J2 nodal precession equals the mean
+Sun's rate, which fixes the inclination (`sso_inclination_deg`). In the **MSSI** frame — EMI
+rotated about the spin axis by the mean solar longitude *L(d)* — such a plane is frozen and the
+real Sun traces the **analemma** (`sun_direction_mssi`, `analemma_mssi`). The Sun's elevation
+above the plane is the **β angle** (`beta_angle`); the fraction of each revolution spent in
+Earth's cylindrical shadow is the closed form `eclipse_fraction_per_orbit`, zero once
+|β| ≥ asin(R/(R+h)). Averaging over the year gives `yearly_eclipse_stats`. Mapping
+`max_t p·s` and `min_t p·s` over the sphere (`compute_sun_dot_extrema`) classifies every direction
+as always / sometimes / never eclipsed for a given altitude (`classify_regions`,
+`region_contours`).
+
+Conventions: `d` is days since J2000.0 (2000-01-01 12:00); the node offset Ω is measured from the
+mean Sun (Ω = 0 → LTAN 12:00, 90 → 18:00, 270 → 06:00); EMI has x toward the vernal equinox and z
+along the spin axis.
+
+## Verification
+
+`pytest` checks the closed-form eclipse fraction against brute-force cylindrical-shadow sweeps,
+the USNO ephemeris against the NOAA/Spencer series, frame conventions (an exact SSO is frozen in
+MSSI, the Sun is west of the mean Sun in November, Ω = 90° ⇒ LTAN 18:00), the region maps against
+the β-angle picture, and the headline numbers of the paper. `kelvinzero reference` writes the
+values that the visualizer's JavaScript model is tested against.
+
+## Citing
+
+If you use the model or the paper, please cite the release (a `CITATION.cff` is included, so
+GitHub's "Cite this repository" button gives you BibTeX/APA):
+
+> K. Cooper and Y. Nikas, *Kelvin Zero: eclipse-minimising sun-synchronous orbits in a mean-Sun
+> rotating frame*, v0.1.0 (2026). https://github.com/kylecooper7/kelvin-zero
+
+## License
+
+MIT.

kelvinzero-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kelvinzero"
+version = "0.1.0"
+description = "Eclipse-minimising sun-synchronous orbits in a mean-Sun rotating frame: the model and the visualizer behind the Kelvin Zero paper."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Kyle Cooper" }, { name = "Yanni Nikas" }]
+keywords = ["sun-synchronous orbit", "eclipse", "analemma", "astrodynamics", "J2", "beta angle"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: Scientific/Engineering :: Astronomy",
+  "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = ["numpy>=1.24"]
+
+[project.optional-dependencies]
+figures = ["matplotlib>=3.7", "contourpy>=1.1"]
+dev = ["pytest>=7", "matplotlib>=3.7", "contourpy>=1.1"]
+
+[project.urls]
+Homepage = "https://k0webapp.web.app/"
+Paper = "https://k0webapp.web.app/Kelvin-Zero-Whitepaper.pdf"
+Source = "https://github.com/kylecooper7/kelvin-zero"
+Issues = "https://github.com/kylecooper7/kelvin-zero/issues"
+
+[project.scripts]
+kelvinzero = "kelvinzero.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+kelvinzero = ["viewer_dist/**/*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

kelvinzero-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

kelvinzero-0.1.0/src/kelvinzero/__init__.py

@@ -0,0 +1,64 @@
+"""Kelvin Zero — eclipse-minimising sun-synchronous orbits in a mean-Sun rotating frame.
+
+The model behind the paper and the visualizer at https://k0webapp.web.app. Everything is pure
+NumPy; figures need matplotlib, the local 3-D viewer needs plotly (``pip install kelvinzero[viz]``).
+
+Quick start::
+
+    from kelvinzero import Orbit, yearly_eclipse_stats
+    print(yearly_eclipse_stats(Orbit(altitude_km=800, raan_offset_deg=270)))
+"""
+
+from .constants import DEG, J2, MU, R_EARTH, TROPICAL_YEAR_DAYS
+from .frames import eci_to_display, frame_angle, gmst, lat_lng_to_vec, rotate_z, vec_to_lat_lng
+from .orbit import (
+    Orbit,
+    YearlyStats,
+    alpha_deg_for_altitude,
+    altitude_for_sso_inclination_deg,
+    argument_of_latitude,
+    best_node_offset,
+    beta_angle,
+    eclipse_fraction_per_orbit,
+    is_eclipsed,
+    ltan_hours,
+    no_eclipse_beta_deg,
+    orbit_normal_eci,
+    orbit_ring_eci,
+    orbital_period,
+    plane_normal,
+    plane_point,
+    raan_eci,
+    raan_mssi,
+    raan_precession_rate,
+    satellite_position_eci,
+    sso_inclination_deg,
+    yearly_eclipse_fraction_sampled,
+    yearly_eclipse_stats,
+)
+from .regions import (
+    REGION_ALWAYS_ECLIPSE,
+    REGION_NO_ECLIPSE,
+    REGION_SOME_ECLIPSE,
+    SunDotExtrema,
+    classify_regions,
+    compute_sun_dot_extrema,
+    region_area_fractions,
+    region_contours,
+    sun_dot_extrema_at,
+)
+from .sun import (
+    SunState,
+    analemma_mssi,
+    earth_heliocentric_ecliptic,
+    ecliptic_eci,
+    mean_sun_longitude,
+    sun_direction_eci,
+    sun_direction_mssi,
+    sun_state,
+    year_markers,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [name for name in dir() if not name.startswith("_")]

kelvinzero-0.1.0/src/kelvinzero/__main__.py

@@ -0,0 +1,102 @@
+"""Command-line interface.
+
+    python -m kelvinzero stats --alt 800 --raan 270
+    python -m kelvinzero sweep --alt 800
+    python -m kelvinzero figures out/
+    python -m kelvinzero viz --alt 800 --raan 270 --view eclipse
+    python -m kelvinzero reference reference.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+import numpy as np
+
+from .orbit import Orbit, alpha_deg_for_altitude, best_node_offset, ltan_hours, no_eclipse_beta_deg, orbital_period, yearly_eclipse_stats
+
+
+def cmd_stats(a):
+    o = Orbit(a.alt, a.raan)
+    st = yearly_eclipse_stats(o, 366)
+    print(f"altitude            {o.altitude_km:8.1f} km")
+    print(f"SSO inclination     {o.inclination_deg:8.3f} deg")
+    print(f"period              {orbital_period(o.altitude_km) / 60:8.2f} min")
+    print(f"node offset Ω       {o.raan_offset_deg:8.2f} deg  (LTAN {ltan_hours(o.raan_offset_deg):05.2f} h)")
+    print(f"eclipse-free |β| ≥  {float(no_eclipse_beta_deg(o.altitude_km)):8.2f} deg")
+    print(f"β over the year     {st.beta_min_deg:8.2f} … {st.beta_max_deg:.2f} deg")
+    print(f"yearly eclipse      {100 * st.eclipse_fraction:8.3f} % of time  (sun exposure {100 * st.sun_exposure:.3f} %)")
+    print(f"days with eclipse   {st.eclipse_days:8.1f} / 365")
+    print(f"region cone α       {float(alpha_deg_for_altitude(o.altitude_km)):8.2f} deg")
+
+
+def cmd_sweep(a):
+    print(f"altitude {a.alt:g} km: yearly eclipse vs node offset")
+    for O in np.arange(0, 360, a.step):
+        st = yearly_eclipse_stats(Orbit(a.alt, float(O)), 183)
+        bar = "#" * int(round(st.eclipse_fraction * 100))
+        print(f"  Ω = {O:5.1f}°  {100 * st.eclipse_fraction:6.2f} %  {bar}")
+    O, st = best_node_offset(a.alt, a.step, 183)
+    print(f"best: Ω = {O:g}°  ({100 * st.eclipse_fraction:.3f} % of the year, {st.eclipse_days:.0f} days with eclipse)")
+
+
+def cmd_figures(a):
+    from .figures import make_all
+
+    make_all(a.out, a.only)
+
+
+def cmd_viz(a):
+    from .viz import serve
+
+    serve(port=a.port, open_browser=not a.no_browser, alt=a.alt, raan=a.raan, view=a.view, day=a.day, cam=a.cam, frame=a.frame)
+
+
+def cmd_reference(a):
+    from .reference import write_reference
+
+    print("wrote", write_reference(a.out))
+
+
+def main(argv=None):
+    # Windows consoles often default to a legacy code page; make Greek letters and ≥ printable everywhere.
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(encoding="utf-8", errors="replace")
+            except (ValueError, OSError):
+                pass
+    p = argparse.ArgumentParser(prog="kelvinzero", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = p.add_subparsers(dest="cmd", required=True)
+    s = sub.add_parser("stats", help="yearly eclipse statistics for one orbit")
+    s.add_argument("--alt", type=float, default=800.0, help="altitude (km)")
+    s.add_argument("--raan", type=float, default=270.0, help="node offset from the mean Sun (deg)")
+    s.set_defaults(fn=cmd_stats)
+    s = sub.add_parser("sweep", help="yearly eclipse versus node offset at one altitude")
+    s.add_argument("--alt", type=float, default=800.0)
+    s.add_argument("--step", type=float, default=10.0)
+    s.set_defaults(fn=cmd_sweep)
+    s = sub.add_parser("figures", help="regenerate the paper's figures (matplotlib)")
+    s.add_argument("out", nargs="?", default="figures")
+    s.add_argument("--only", nargs="*")
+    s.set_defaults(fn=cmd_figures)
+    s = sub.add_parser("viz", help="run the Kelvin Zero visualizer locally (the same one as k0webapp.web.app)")
+    s.add_argument("--alt", type=float, help="altitude (km)")
+    s.add_argument("--raan", type=float, help="node offset from the mean Sun (deg)")
+    s.add_argument("--view", choices=["overview", "eclipse", "frames", "helio", "sun"], help="preset view to open")
+    s.add_argument("--day", type=float, help="timeline day (0-365.24)")
+    s.add_argument("--cam", help="camera preset: sun, antisun, pole, side, follow, above")
+    s.add_argument("--frame", choices=["EMI", "MSSI"])
+    s.add_argument("--port", type=int, default=0, help="local port (default: a free one)")
+    s.add_argument("--no-browser", action="store_true", help="just serve; do not open a browser")
+    s.set_defaults(fn=cmd_viz)
+    s = sub.add_parser("reference", help="write reference values (JSON) for cross-checking other implementations")
+    s.add_argument("out", nargs="?", default="reference.json")
+    s.set_defaults(fn=cmd_reference)
+    a = p.parse_args(argv)
+    a.fn(a)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

kelvinzero-0.1.0/src/kelvinzero/constants.py

@@ -0,0 +1,25 @@
+"""Physical constants. These match the values used by the Kelvin Zero visualizer so the two
+implementations can be compared number for number."""
+
+import math
+
+DEG = math.pi / 180.0
+TWO_PI = 2.0 * math.pi
+
+MU = 398600.4418  # km^3/s^2, Earth gravitational parameter
+R_EARTH = 6378.137  # km, WGS84 equatorial radius
+J2 = 1.08262668e-3
+SECONDS_PER_DAY = 86400.0
+TROPICAL_YEAR_DAYS = 365.2422
+
+#: Mean-sun rate: the uniform eastward motion of the fictitious mean Sun along the equator
+#: (USNO low-precision ephemeris), degrees per day. An exactly sun-synchronous orbit's node
+#: precesses at this rate.
+MEAN_SUN_RATE_DEG_DAY = 0.9856474
+MEAN_SUN_RATE_RAD_S = MEAN_SUN_RATE_DEG_DAY * DEG / SECONDS_PER_DAY
+
+#: Rate used when solving the sun-synchronous inclination (rad/s).
+OMEGA_SSO_REQ = TWO_PI / (TROPICAL_YEAR_DAYS * SECONDS_PER_DAY)
+
+ALT_MIN_KM = 100.0
+ALT_MAX_KM = 2000.0