Toby
ad8b889437
- femap/: planar best-effort solver, build, result and page (fe-map.aethercosmology.com) - satellites/: The Sync Test build, ISS elements, SatNOGS timings and page (iss.aethercosmology.com) - src/handoff/The_Shape_of_Distance_PRESENTATION.html: inputs for both - CONTRIBUTING.md; README and LICENSE-DATA cover all four sites; GitHub mirror for issues and pull requests Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
460 lines
22 KiB
Python
460 lines
22 KiB
Python
"""The Sync Test: ISS position and an imitated signal on four maps.
|
||
|
||
../.venv/bin/python build.py -> data/sync.json, site/index.html
|
||
|
||
Orbit: data/iss_25544_20261028.tle, fetched 2026-10-29 from
|
||
https://celestrak.org/NORAD/elements/gp.php?CATNR=25544&FORMAT=TLE
|
||
(epoch 2026-10-28 14:18 UTC), propagated with SGP4 (python sgp4).
|
||
|
||
For every second of 16 orbits:
|
||
station SGP4 position -> Earth-fixed (GMST rotation) -> geodetic lat/lon
|
||
map speed speed of the point beneath the station across each flat map
|
||
(models.py: North-pole AE, dual-pole AE on 0N 0E, Mercator with its
|
||
east and west edges joined)
|
||
signal starts level with the station at each northbound equator
|
||
crossing and moves along the map's track at the measured speed:
|
||
7.07 km/s, the straight-line (level-flight) reading of the SatNOGS
|
||
recordings of 3 Oct 2026 (satnogs.py), which over a plane is also
|
||
the speed of the point beneath. lag = time since the station was
|
||
where the signal is.
|
||
On the globe the same recordings fit the published orbit (7.36 km/s at
|
||
altitude, x R/r on the ground); check_globe() confirms the signal stays level
|
||
there, as it must, since both come from the orbit.
|
||
"""
|
||
import json, math, os, sys
|
||
import numpy as np
|
||
from sgp4.api import Satrec, jday
|
||
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
SRC = os.path.join(HERE, "..", "src")
|
||
sys.path.insert(0, SRC)
|
||
from models import R # 6371.0 km sphere shared with the cable survey
|
||
from build import land # Natural Earth 110m, rings of [lon, lat]
|
||
|
||
TLE = os.path.join(HERE, "data", "iss_25544_20261028.tle")
|
||
START = (2026, 10, 28, 15, 0, 0) # first northbound equator crossing after this
|
||
N_ORBITS = 16
|
||
MARGIN_S = 2 * 3600 # track after the last orbit, for a signal running ahead
|
||
STEP = 10 # s between samples sent to the page
|
||
G0 = 9.80665e-3 # km/s^2
|
||
OMEGA = 7.2921150e-5 # rad/s
|
||
WGS_A, WGS_F = 6378.137, 1 / 298.257223563
|
||
MIN_POP = 1_000_000
|
||
DEDUP_KM = 30 # merge districts of one city
|
||
SATNOGS = os.path.join(HERE, "data", "satnogs_20261003.json") # satnogs.py
|
||
F_UHF = 437.55e6 # Hz, the recorded downlink
|
||
C_KMS = 299_792.458
|
||
|
||
|
||
def gmst(jd):
|
||
t = (jd - 2451545.0) / 36525.0
|
||
s = 67310.54841 + (876600 * 3600 + 8640184.812866) * t + 0.093104 * t**2 - 6.2e-6 * t**3
|
||
return np.radians((s % 86400.0) / 240.0)
|
||
|
||
|
||
def propagate(sat, t0jd, t0fr, secs):
|
||
jd = np.full(secs.shape, t0jd)
|
||
fr = t0fr + secs / 86400.0
|
||
e, r, v = sat.sgp4_array(jd, fr)
|
||
assert not e.any(), "sgp4 error"
|
||
g = gmst(jd + fr)
|
||
c, s = np.cos(g), np.sin(g)
|
||
x = c * r[:, 0] + s * r[:, 1]
|
||
y = -s * r[:, 0] + c * r[:, 1]
|
||
z = r[:, 2]
|
||
vx = c * v[:, 0] + s * v[:, 1] + OMEGA * y
|
||
vy = -s * v[:, 0] + c * v[:, 1] - OMEGA * x
|
||
vz = v[:, 2]
|
||
return np.stack([x, y, z], 1), np.stack([vx, vy, vz], 1)
|
||
|
||
|
||
def geodetic(p):
|
||
x, y, z = p.T
|
||
e2 = WGS_F * (2 - WGS_F)
|
||
lon = np.degrees(np.arctan2(y, x))
|
||
rho = np.hypot(x, y)
|
||
lat = np.arctan2(z, rho * (1 - e2))
|
||
for _ in range(6):
|
||
n = WGS_A / np.sqrt(1 - e2 * np.sin(lat) ** 2)
|
||
h = rho / np.cos(lat) - n
|
||
lat = np.arctan2(z, rho * (1 - e2 * n / (n + h)))
|
||
return np.degrees(lat), lon, h
|
||
|
||
|
||
def unit(lat, lon):
|
||
p, l = np.radians(lat), np.radians(lon)
|
||
return np.stack([np.cos(p) * np.cos(l), np.cos(p) * np.sin(l), np.sin(p)], -1)
|
||
|
||
|
||
def to_latlon(u):
|
||
u = u / np.linalg.norm(u, axis=-1, keepdims=True)
|
||
return np.degrees(np.arcsin(np.clip(u[..., 2], -1, 1))), np.degrees(np.arctan2(u[..., 1], u[..., 0]))
|
||
|
||
|
||
# flat maps, vectorised forms of models.ae_xy / dualpole_xy / mercator_xy (km)
|
||
def ae_xy(lat, lon):
|
||
r = R * np.radians(90 - lat)
|
||
t = np.radians(lon)
|
||
return r * np.sin(t), -r * np.cos(t)
|
||
|
||
|
||
def dualpole_xy(lat, lon):
|
||
p, l = np.radians(lat), np.radians(lon)
|
||
c = np.arccos(np.clip(np.cos(p) * np.cos(l), -1, 1))
|
||
k = np.where(c < 1e-9, 1.0, c / np.where(c < 1e-9, 1.0, np.sin(c)))
|
||
return R * k * np.cos(p) * np.sin(l), R * k * np.sin(p)
|
||
|
||
|
||
def mercator_xy(lat, lon):
|
||
return R * np.radians(lon), R * np.log(np.tan(np.pi / 4 + np.radians(np.clip(lat, -85, 85)) / 2))
|
||
|
||
|
||
MAPS = {"ae": ae_xy, "dualpole": dualpole_xy, "mercator": mercator_xy}
|
||
WRAP = {"mercator": 2 * math.pi * R}
|
||
|
||
|
||
def step_lengths(f, u, wrap=None):
|
||
"""Length on the map of each 1-s step between unit vectors u[i] and u[i+1].
|
||
Steps longer than 20 km on the map (dual-pole rim) are subdivided along the
|
||
great circle until the pieces are short."""
|
||
lat, lon = to_latlon(u)
|
||
x, y = f(lat, lon)
|
||
dx, dy = np.diff(x), np.diff(y)
|
||
if wrap:
|
||
dx = (dx + wrap / 2) % wrap - wrap / 2
|
||
d = np.hypot(dx, dy)
|
||
for i in np.nonzero(d > 20)[0]:
|
||
n = int(min(20000, math.ceil(d[i] / 2)))
|
||
w = np.linspace(0, 1, n + 1)[:, None]
|
||
sub = u[i] * (1 - w) + u[i + 1] * w
|
||
la, lo = to_latlon(sub)
|
||
sx, sy = f(la, lo)
|
||
ddx = np.diff(sx)
|
||
if wrap:
|
||
ddx = (ddx + wrap / 2) % wrap - wrap / 2
|
||
d[i] = np.hypot(ddx, np.diff(sy)).sum()
|
||
return d
|
||
|
||
|
||
def main():
|
||
sn = json.load(open(SATNOGS))
|
||
v_sig = round(sn["v_kms"], 2) # straight-line reading of the recordings = speed in level flight over a plane
|
||
l1, l2 = [s.strip() for s in open(TLE).read().splitlines()[1:3]]
|
||
sat = Satrec.twoline2rv(l1, l2)
|
||
jd0, fr0 = jday(*START)
|
||
span = int(N_ORBITS * 93 * 60 + 3 * 3600)
|
||
secs = np.arange(span + 1, dtype=float)
|
||
pos, vel = propagate(sat, jd0, fr0, secs)
|
||
lat, lon, alt = geodetic(pos)
|
||
|
||
# northbound equator crossings (linear interpolation within the second)
|
||
up = np.nonzero((lat[:-1] < 0) & (lat[1:] >= 0))[0]
|
||
nodes = up + (-lat[up]) / (lat[up + 1] - lat[up])
|
||
assert len(nodes) >= N_ORBITS + 1
|
||
t0 = math.floor(nodes[0])
|
||
nodes = nodes[: N_ORBITS + 1] - t0
|
||
end = int(math.ceil(nodes[-1])) + MARGIN_S
|
||
sl = slice(t0, t0 + end + 1)
|
||
secs, pos, vel, lat, lon, alt = secs[sl] - t0, pos[sl], vel[sl], lat[sl], lon[sl], alt[sl]
|
||
u = unit(lat, lon)
|
||
vmeas = np.linalg.norm(vel, axis=1) # globe reading: km/s relative to the ground, at altitude
|
||
orbit_of = np.clip(np.searchsorted(nodes, secs, side="right") - 1, 0, N_ORBITS - 1)
|
||
inorb = secs < nodes[-1]
|
||
spans = [(int(math.ceil(nodes[k])), int(nodes[k + 1])) for k in range(N_ORBITS)]
|
||
|
||
# globe: point beneath on the 6371 km sphere (geocentric), and the ground speed the measured speed gives it (x R/r)
|
||
r = np.linalg.norm(pos, axis=1)
|
||
uc = pos / r[:, None]
|
||
vglobe = R * np.arccos(np.clip((uc[:-1] * uc[1:]).sum(1), -1, 1))
|
||
vglobe = np.concatenate([[vglobe[0]], (vglobe[:-1] + vglobe[1:]) / 2, [vglobe[-1]]])
|
||
aglobe = np.zeros_like(vglobe)
|
||
aglobe[5:-5] = (vglobe[10:] - vglobe[:-10]) / 10.0 / G0
|
||
vt = vel - (vel * uc).sum(1)[:, None] * uc
|
||
vg_ref = np.linalg.norm(vt, axis=1) * R / r
|
||
|
||
out = {"maps": {}}
|
||
stats = {}
|
||
for name, f in MAPS.items():
|
||
d = step_lengths(f, u, WRAP.get(name))
|
||
S = np.concatenate([[0.0], np.cumsum(d)]) # map km travelled
|
||
v = np.concatenate([[d[0]], (d[:-1] + d[1:]) / 2, [d[-1]]])
|
||
a = np.zeros_like(v)
|
||
a[5:-5] = (v[10:] - v[:-10]) / 10.0 / G0 # g, change of speed along the track
|
||
lag, gap = signal(S, secs, nodes, orbit_of, v_sig)
|
||
out["maps"][name] = {"S": S, "v": v, "a": a, "lag": lag, "gap": gap}
|
||
# restarted every minute instead of every orbit
|
||
sync = np.arange(0.0, nodes[-1], 60.0)
|
||
lag60, gap60 = signal(S, secs, sync, np.clip(np.searchsorted(sync, secs, side="right") - 1, 0, len(sync) - 1), v_sig)
|
||
ends = [np.interp(n - 1, secs, lag) for n in nodes[1:]]
|
||
stats[name] = {
|
||
"v_min": float(v[inorb].min()), "v_max": float(v[inorb].max()),
|
||
"a_max": float(np.abs(a[inorb]).max()),
|
||
"ratio_per_orbit": [float(v[a0:b0].max() / v[a0:b0].min()) for a0, b0 in spans],
|
||
"swing_per_orbit": [float(np.abs(np.diff(v[a0:b0])).sum()) for a0, b0 in spans],
|
||
"track_per_orbit": [float(S[b0] - S[a0]) for a0, b0 in spans],
|
||
"lag_end_mean": float(np.mean(ends)), "lag_end_min": float(np.min(ends)), "lag_end_max": float(np.max(ends)),
|
||
"lag_max": float(lag[inorb].max()), "lead_max": float(-lag[inorb].min()),
|
||
"gap_max": float(np.abs(gap[inorb]).max()),
|
||
"lag60_max": float(np.abs(lag60[inorb]).max()), "gap60_max": float(np.abs(gap60[inorb]).max()),
|
||
}
|
||
stats[name].update(one_orbit_after(S, secs, nodes, v_sig))
|
||
# dual-pole rim: closest approach to 0N 180E
|
||
rim = np.degrees(np.arccos(np.clip(-u[inorb][:, 0], -1, 1)))
|
||
stats["dualpole"]["rim_min_deg"] = float(rim.min())
|
||
|
||
# cities: station or signal above the horizon (mean altitude), XOR = out of sync
|
||
h_mean = float(alt[inorb].mean())
|
||
lam = math.acos(R / (R + h_mean))
|
||
cities = load_cities()
|
||
cu = unit(np.array([c[1] for c in cities]), np.array([c[2] for c in cities]))
|
||
cl = math.cos(lam)
|
||
idx = np.arange(0, int(nodes[-1]), STEP)
|
||
sees = (u[idx] @ cu.T) >= cl
|
||
worst = np.full(len(idx), 10**9)
|
||
for name in MAPS:
|
||
tau_i = idx - out["maps"][name]["lag"][idx]
|
||
uu = np.stack([np.interp(tau_i, secs, u[:, k]) for k in range(3)], 1)
|
||
bad = sees ^ ((uu @ cu.T) >= cl)
|
||
worst = np.minimum(worst, bad.sum(1))
|
||
stats[name]["cities_now_max"] = int(bad.sum(1).max())
|
||
|
||
# opening frame: within the first two orbits, at least 10 min before a restart and with cities out of
|
||
# sync on every map, the moment when the smallest lag over the three maps is largest
|
||
lagmin = np.min([out["maps"][n]["lag"][idx] for n in MAPS], axis=0)
|
||
nxt = nodes[np.minimum(orbit_of[idx] + 1, N_ORBITS)]
|
||
ok = (idx < nodes[2]) & (nxt - idx >= 600) & (worst >= 8)
|
||
t_init = int(idx[np.argmax(np.where(ok, lagmin, -1))])
|
||
stats["globe"] = {"v_min": float(vglobe[inorb].min()), "v_max": float(vglobe[inorb].max()),
|
||
"a_max": float(np.abs(aglobe[inorb]).max()),
|
||
"ratio_per_orbit": [float(vglobe[a0:b0].max() / vglobe[a0:b0].min()) for a0, b0 in spans],
|
||
"swing_per_orbit": [float(np.abs(np.diff(vglobe[a0:b0])).sum()) for a0, b0 in spans],
|
||
"track_per_orbit": [float(vglobe[a0:b0].sum()) for a0, b0 in spans],
|
||
"signal_drift_km_max": check_globe(secs, uc, vg_ref, nodes, orbit_of),
|
||
"ref_mean": float(vg_ref[inorb].mean())}
|
||
stats["measured"] = {"v_sig": v_sig, "v_min": float(vmeas[inorb].min()), "v_max": float(vmeas[inorb].max()),
|
||
"alt_mean": h_mean, "horizon_deg": math.degrees(lam), "horizon_km": R * lam,
|
||
"period_min": float(np.diff(nodes).mean() / 60), "signal_per_orbit_km": v_sig * float(np.diff(nodes).mean())}
|
||
stats["recorded"] = recorded_map_speeds(sn, lat, out, inorb)
|
||
stats["one_listener"] = one_listener(u, uc, lat, lon, h_mean)
|
||
stats["satnogs"] = {k: sn[k] for k in ("v_kms", "burst")} | {
|
||
"passes": {k: {x: q[x] for x in ("utc", "stations", "t0_rms_s", "v_kms", "offset_sd_median_hz")} for k, q in sn["passes"].items()}}
|
||
|
||
# page data: 10-s samples
|
||
k = np.arange(0, end + 1, STEP)
|
||
epoch = jd0 + fr0 + t0 / 86400.0
|
||
page = {
|
||
"tle": [l1, l2], "epoch_unix": round((epoch - 2440587.5) * 86400.0, 3), "step": STEP,
|
||
"nodes": [round(n, 2) for n in nodes.tolist()], "horizon_deg": round(math.degrees(lam), 3),
|
||
"alt_km": round(h_mean, 1), "t_init": t_init, "v_sig": v_sig, "vg_ref": round(stats["globe"]["ref_mean"], 4),
|
||
"lat": np.round(lat[k], 3).tolist(), "lon": np.round(lon[k], 3).tolist(),
|
||
"vmeas": np.round(vmeas[k] * 1000).astype(int).tolist(), # m/s
|
||
"vglobe": np.round(vglobe[k] * 1000).astype(int).tolist(), # m/s
|
||
"aglobe": np.round(aglobe[k] * 1000).astype(int).tolist(), # milli-g
|
||
"maps": {n: {"v": np.round(m["v"][k] * 1000).astype(int).tolist(), # m/s
|
||
"a": np.round(m["a"][k] * 1000).astype(int).tolist(), # milli-g
|
||
"S": np.round(m["S"][k], 1).tolist()} # map km travelled; the page derives the signal
|
||
for n, m in out["maps"].items()},
|
||
"cities": [list(c[:4]) for c in cities],
|
||
"stats": stats,
|
||
}
|
||
with open(os.path.join(HERE, "data", "sync.json"), "w") as fh:
|
||
json.dump(page, fh, separators=(",", ":"))
|
||
vals = copy_values(page, stats)
|
||
if not os.path.exists(os.path.join(HERE, "template.html")):
|
||
return
|
||
page["land"] = land()
|
||
tpl = open(os.path.join(HERE, "template.html"), encoding="utf-8").read()
|
||
d3 = open(os.path.join(SRC, "raw", "lib", "d3.min.js"), encoding="utf-8").read()
|
||
assert tpl.count("/*DATA*/null") == 1 and tpl.count("/*D3*/") == 1 and "</script" not in d3
|
||
unused = [k for k in vals if "{{" + k + "}}" not in tpl]
|
||
if unused:
|
||
print("not quoted on the page:", ", ".join(unused))
|
||
for key, val in vals.items():
|
||
tpl = tpl.replace("{{" + key + "}}", val)
|
||
assert "{{" not in tpl, tpl[tpl.index("{{"):][:40]
|
||
html = tpl.replace("/*DATA*/null", json.dumps(page, separators=(",", ":"))).replace("/*D3*/", d3)
|
||
with open(os.path.join(HERE, "site", "index.html"), "w", encoding="utf-8") as fh:
|
||
fh.write(html)
|
||
|
||
|
||
def signal(S, secs, sync, k, v_sig):
|
||
"""Source level with the station at each sync time, then moving along the map track at v_sig.
|
||
Returns lag (s since the station was where the signal is) and gap (map km, station ahead > 0)."""
|
||
Ssync = np.interp(sync[k], secs, S)
|
||
sig = Ssync + v_sig * (secs - sync[k])
|
||
return secs - np.interp(sig, S, secs), S - sig
|
||
|
||
|
||
def one_orbit_after(S, secs, nodes, v_sig):
|
||
"""Lag and gap one orbit after the signal is lined up, for every start time 1 min apart."""
|
||
P = float(np.diff(nodes).mean())
|
||
starts = np.arange(0.0, nodes[-1] - P, 60.0)
|
||
target = np.interp(starts, secs, S) + v_sig * P
|
||
lag = starts + P - np.interp(target, S, secs)
|
||
gap = np.interp(starts + P, secs, S) - target
|
||
return {"lag1_min": float(lag.min()), "lag1_max": float(lag.max()), "gap1_min": float(gap.min()), "gap1_max": float(gap.max())}
|
||
|
||
|
||
def load_cities():
|
||
"""GeoNames cities of MIN_POP or more; places within DEDUP_KM of a larger one are merged into it."""
|
||
rows = []
|
||
for row in open(os.path.join(SRC, "raw", "geonames", "cities15000.txt"), encoding="utf-8"):
|
||
c = row.rstrip("\n").split("\t")
|
||
if int(c[14] or 0) >= MIN_POP:
|
||
rows.append((c[2], round(float(c[4]), 3), round(float(c[5]), 3), c[8], int(c[14])))
|
||
rows.sort(key=lambda c: -c[4])
|
||
kept, ku = [], []
|
||
for c in rows:
|
||
cv = unit(np.array(c[1]), np.array(c[2]))
|
||
if ku and (np.array(ku) @ cv).max() >= math.cos(DEDUP_KM / R):
|
||
continue
|
||
kept.append(c); ku.append(cv)
|
||
return kept
|
||
|
||
|
||
def recorded_map_speeds(sn, lat, out, inorb):
|
||
"""Map speed at each SatNOGS receiver's closest approach (3 Oct 2026). On the North-pole AE and Mercator
|
||
maps the speed depends only on latitude and direction (northbound / southbound), so it is read from this
|
||
orbit's track at the same latitude and direction."""
|
||
north = np.gradient(lat) > 0
|
||
res = {}
|
||
for key, p in sn["passes"].items():
|
||
ca = sorted(p["ca"], key=lambda x: x[2])
|
||
nb = ca[-1][0] > ca[0][0] if abs(ca[-1][0] - ca[0][0]) > 1 else None
|
||
row = {"recorded_kms": p["v_kms"], "northbound": nb}
|
||
for name in ("ae", "mercator"):
|
||
v = out["maps"][name]["v"]
|
||
sp = []
|
||
for la, lo, t in ca:
|
||
if nb is None: # pass near its northern or southern limit: take both branches
|
||
m = inorb
|
||
else:
|
||
m = inorb & (north == nb)
|
||
i = np.nonzero(m)[0]
|
||
j = i[np.argmin(np.abs(lat[i] - la))]
|
||
sp.append(float(v[j]))
|
||
row[name] = {"mean": float(np.mean(sp)), "max": float(np.max(sp))}
|
||
res[key] = row
|
||
return res
|
||
|
||
|
||
def one_listener(u, uc, lat, lon, h):
|
||
"""The station over the North-pole AE plane, adjusting its own frequency so that one receiver
|
||
(VK4JBE, Brisbane) hears the shift the globe predicts, 2 min before its highest pass in this window.
|
||
Returns the error heard by neighbours at F_UHF."""
|
||
rx = (-27.492, 153.069)
|
||
ball = uc * (R + h)
|
||
dx, dy = ae_xy(lat, lon)
|
||
disc = np.stack([dx, dy, np.full_like(dx, h)], 1)
|
||
|
||
def rxpos(la, lo):
|
||
e = unit(np.array(la), np.array(lo))
|
||
q = ae_xy(np.array(la), np.array(lo))
|
||
return e * R, e, np.array([float(q[0]), float(q[1]), 0.0])
|
||
|
||
def shifts(la, lo):
|
||
P, e, Q = rxpos(la, lo)
|
||
fb = -F_UHF / C_KMS * np.gradient(np.linalg.norm(ball - P, axis=1))
|
||
fd = -F_UHF / C_KMS * np.gradient(np.linalg.norm(disc - Q, axis=1))
|
||
el = np.degrees(np.arcsin(np.clip(((ball - P) @ e) / np.linalg.norm(ball - P, axis=1), -1, 1)))
|
||
return fb, fd, el
|
||
|
||
fb, fd, el = shifts(*rx)
|
||
tca = int(np.argmax(el))
|
||
t = tca - 120
|
||
cor = fb[t] - fd[t]
|
||
res = {"rx": "VK4JBE, Brisbane", "max_el": float(el[tca]), "el": float(el[t]), "correction_hz": float(cor)}
|
||
for dk, brg, nm in ((100, 90, "east100"), (1000, 0, "north1000")):
|
||
p, l, dd, b = math.radians(rx[0]), math.radians(rx[1]), dk / R, math.radians(brg)
|
||
p2 = math.asin(math.sin(p) * math.cos(dd) + math.cos(p) * math.sin(dd) * math.cos(b))
|
||
l2 = l + math.atan2(math.sin(b) * math.sin(dd) * math.cos(p), math.cos(dd) - math.sin(p) * math.sin(p2))
|
||
fb2, fd2, el2 = shifts(math.degrees(p2), math.degrees(l2))
|
||
res[nm] = {"error_hz": float(fd2[t] + cor - fb2[t]), "el": float(el2[t])}
|
||
return res
|
||
|
||
|
||
def mmss(s):
|
||
s = int(round(s))
|
||
return f"{s // 60} min {s % 60:02d} s" if s >= 60 else f"{s} s"
|
||
|
||
|
||
def fmt_v(x):
|
||
return f"{x:,.0f}" if x >= 100 else f"{x:.2f}"
|
||
|
||
|
||
def rng(xs, f):
|
||
lo, hi = f(min(xs)), f(max(xs))
|
||
return lo if lo == hi else f"{lo}–{hi}"
|
||
|
||
|
||
def copy_values(page, st):
|
||
"""Numbers quoted in the page text, from this run."""
|
||
import datetime as dt
|
||
utc = lambda t: dt.datetime.fromtimestamp(page["epoch_unix"] + t, dt.timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
|
||
m, ae, dp, me, gl, rec, one, sn = (st[k] for k in ("measured", "ae", "dualpole", "mercator", "globe", "recorded", "one_listener", "satnogs"))
|
||
l1 = page["tle"][0]
|
||
yy, doy = int(l1[18:20]), float(l1[20:32])
|
||
ep = dt.datetime(2000 + yy, 1, 1, tzinfo=dt.timezone.utc) + dt.timedelta(days=doy - 1)
|
||
b = sn["burst"]
|
||
rms = [q["t0_rms_s"] for q in sn["passes"].values()]
|
||
el = lambda km: f"{math.degrees(math.atan2(m['alt_mean'], km)):.1f}"
|
||
v = {
|
||
"V_SIG": f"{m['v_sig']:.2f}", "V_ORBIT_RANGE": f"{m['v_min']:.2f}–{m['v_max']:.2f}",
|
||
"ALT": f"{m['alt_mean']:.0f}", "PERIOD": f"{m['period_min']:.1f}",
|
||
"HORIZON_DEG": f"{m['horizon_deg']:.1f}", "HORIZON_KM": f"{m['horizon_km']:,.0f}",
|
||
"EL_HORIZON": el(m["horizon_km"]), "EL_10000": el(10000),
|
||
"GLOBE_V_RANGE": f"{gl['v_min']:.2f}–{gl['v_max']:.2f}", "GLOBE_DRIFT": f"{gl['signal_drift_km_max']:.2f}",
|
||
"N_CITIES": f"{len(page['cities'])}", "N_ORBITS": f"{len(page['nodes']) - 1}",
|
||
"START_UTC": utc(page["nodes"][0]), "EPOCH_UTC": ep.strftime("%Y-%m-%d %H:%M UTC"),
|
||
"SIG_TRACK": f"{round(m['signal_per_orbit_km'], -2):,.0f}",
|
||
"AE_LAG": f"{ae['lag_end_mean'] / 60:.0f} min", "ME_LAG": f"{me['lag_end_mean'] / 60:.0f} min",
|
||
"DP_LAG": f"{dp['lag_end_min'] / 60:.0f}–{dp['lag_end_max'] / 60:.0f} min",
|
||
"AE_LAG60": mmss(ae["lag60_max"]), "AE_GAP60": f"{round(ae['gap60_max'], -2):,.0f}",
|
||
"SN_RMS": rng(rms, lambda x: f"{x:.1f}"), "SN_N": f"{sum(q['stations'] for q in sn['passes'].values())}",
|
||
"SN_OFFSET": f"{np.median([q['offset_sd_median_hz'] for q in sn['passes'].values()]):.0f}",
|
||
"SN_V": f"{sn['v_kms']:.2f}",
|
||
"BURST_UTC": b["utc"].replace(" UTC", "")[11:] + " UTC on 3 October 2026", "BURST_N": f"{b['receivers']}",
|
||
"BURST_UP": f"{b['up']}", "BURST_DOWN": f"{b['down']}",
|
||
"BURST_MIN": f"−{abs(b['min_hz']) / 1000:.1f}", "BURST_MAX": f"+{b['max_hz'] / 1000:.1f}",
|
||
"REC_AE_SOUTH": rng([rec[k]["ae"]["mean"] for k in ("2026-10-03_SouthAmerica", "2026-10-03_Australia")], lambda x: f"{x:.0f}"),
|
||
"REC_AE_EU": f"{rec['2026-10-03_Europe']['ae']['mean']:.1f}",
|
||
"REC_V_SOUTH": rng([rec[k]["recorded_kms"] for k in ("2026-10-03_SouthAmerica", "2026-10-03_Australia")], lambda x: f"{x:.2f}"),
|
||
"REC_V_EU": f"{rec['2026-10-03_Europe']['recorded_kms']:.2f}",
|
||
"ONE_COR": f"{abs(one['correction_hz']) / 1000:.1f}", "ONE_E100": f"{abs(one['east100']['error_hz']):,.0f}",
|
||
"ONE_N1000": f"{abs(one['north1000']['error_hz']) / 1000:.1f}",
|
||
"DP_RIM": f"{dp['rim_min_deg']:.1f}",
|
||
"DP_VMAX": f"{dp['v_max']:,.0f}",
|
||
"AE_XSIG": f"{ae['v_max'] / m['v_sig']:.1f}",
|
||
}
|
||
for k, s in (("G", gl), ("AE", ae), ("DP", dp), ("ME", me)):
|
||
v[k + "_VR"] = f"{fmt_v(s['v_min'])}–{fmt_v(s['v_max'])}"
|
||
v[k + "_AMAX"] = f"{s['a_max']:,.0f}" if s["a_max"] >= 100 else f"{s['a_max']:.2f}"
|
||
v[k + "_RATIO"] = "×" + rng(s["ratio_per_orbit"], lambda x: f"{x:.2f}" if x < 10 else f"{x:.0f}")
|
||
v[k + "_SWING"] = rng(s["swing_per_orbit"], lambda x: f"{x:,.0f}" if x >= 10 else f"{x:.2f}")
|
||
v[k + "_TRACK"] = rng(s["track_per_orbit"], lambda x: f"{round(x, -2):,.0f}")
|
||
if k != "G":
|
||
v[k + "_LAGEND"] = (mmss(s["lag_end_mean"]) if s["lag_end_max"] - s["lag_end_min"] < 2
|
||
else f"{mmss(s['lag_end_min'])} – {mmss(s['lag_end_max'])}")
|
||
v[k + "_GAP"] = f"{s['gap_max']:,.0f}"
|
||
v[k + "_LAG1"] = f"{s['lag1_min'] / 60:.0f}–{s['lag1_max'] / 60:.0f} min"
|
||
v[k + "_GAP1"] = f"{round(s['gap1_min'], -2):,.0f}–{round(s['gap1_max'], -2):,.0f}"
|
||
v[k + "_LAG60"] = mmss(s["lag60_max"])
|
||
assert abs(gl["ratio_per_orbit"][0] - 1) < 0.01 and gl["signal_drift_km_max"] < 1
|
||
return v
|
||
|
||
|
||
def check_globe(secs, uc, vg, nodes, orbit_of):
|
||
"""Globe: a signal moving at the measured speed scaled to the ground (R/r), started level at each
|
||
crossing, against the station's point beneath on the sphere. Largest separation in km: zero up to
|
||
integration error, since both come from the same orbit."""
|
||
ang = np.arccos(np.clip((uc[:-1] * uc[1:]).sum(1), -1, 1))
|
||
S = np.concatenate([[0.0], np.cumsum(R * ang)])
|
||
M = np.concatenate([[0.0], np.cumsum((vg[:-1] + vg[1:]) / 2)])
|
||
m = secs < nodes[-1]
|
||
sig = np.interp(nodes[orbit_of], secs, S) + M - np.interp(nodes[orbit_of], secs, M)
|
||
return float(np.abs(S - sig)[m].max())
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|