"""orbitlight: planets, planetary atmospheres and stellar companions in the public archives of high-resolution spectra and radial velocities.

    python orbitlight.py planets bank|dace|rvcat|targets|measure|census|merge|followup|ledger|eccentric|calibrate|benchmark|lbl|vet|orbits|tess|tois|validate|system|weigh|controls|strict|sparse|recovery|window|figure|dip|companions-read|progress|epochs-trial ...
    python orbitlight.py solar plan|days|lbl|fit|reflected|orbit|molecules|eclipse ...
    python orbitlight.py giants plan|fetch|search|record|reflected|emission|opacities ...
    python orbitlight.py transits plan|fetch|run|record ...
    python orbitlight.py companions plan|test|search|survey|reanalyse|validate ...
    python orbitlight.py binaries series|orbit|rows|search|measure|depth|template|zero|shift ...
    python orbitlight.py eclipses fetch|fit|table ...
    python orbitlight.py publish OUT LABEL=DATA ...
    python orbitlight.py publish scan FOLDER [--git]
    python orbitlight.py publish check FOLDER PUBLIC
    python orbitlight.py pipeline run|start|watch|stop|pause|resume|decide|publish|chain|peers|status|end|deploy ...
    python orbitlight.py selftest

Each mode's --help gives its method and options. Data live under ORBITLIGHT_DATA (default ./data) and results under ORBITLIGHT_RESULTS (default
<data>/results); the array work runs on ORBITLIGHT_DEVICE, by default the CUDA device where there is one and the CPU otherwise."""
import argparse
import concurrent.futures as cf
import csv
import datetime
import glob
import gzip
import http.client
import inspect
import io
import json
import logging
import math
import os
import random
import re
import shutil
import subprocess
import sys
import threading
import time
import types
import urllib.error
import urllib.parse
import urllib.request
import warnings
import zlib

import numpy as np
import torch


# The archives and the helpers every mode shares; data under ORBITLIGHT_DATA, results under ORBITLIGHT_RESULTS.
archive_DATA = os.path.abspath(os.environ.get("ORBITLIGHT_DATA") or "data")
archive_RESULTS = os.path.abspath(os.environ.get("ORBITLIGHT_RESULTS") or os.path.join(archive_DATA, "results"))


def archive_data(*parts):
    """Path under the data root."""
    return os.path.join(archive_DATA, *parts)


def archive_results(*parts):
    """Path under the results root."""
    return os.path.join(archive_RESULTS, *parts)


def archive_record_run(run_id, title, archive, selection, approach, n_targets, n_unit, params, null_summary, sensitivity, result, rows):
    """A run's description and its per-target rows written as JSON under the results root, one file per run, replacing the last."""
    os.makedirs(archive_RESULTS, exist_ok=True)
    path = os.path.join(archive_RESULTS, run_id + ".json")
    json.dump(dict(id=run_id, title=title, archive=archive, selection=selection, approach=approach, n_targets=n_targets, n_unit=n_unit, params=params,
                   null=null_summary, sensitivity=sensitivity, result=result, finished=time.strftime("%Y-%m-%d"), rows=rows), open(path, "w"), separators=(",", ":"))
    return path


def archive_quiet_warnings():
    """Silence the expected astropy and numpy warnings (empty, all-NaN, invalid, overflow, divide); show all others."""
    warnings.filterwarnings("ignore", category=RuntimeWarning,
                            message=r"(Mean of empty slice|All-NaN (slice|axis) encountered|invalid value encountered"
                                    r"|divide by zero encountered|overflow encountered|Degrees of freedom <= 0)")
    try:
        from astropy.utils.exceptions import AstropyWarning
    except ImportError:
        return
    warnings.filterwarnings("ignore", category=AstropyWarning)


def archive_num(x, missing=None):
    """Catalogue value as a finite float, else missing."""
    try:
        v = float(x)
    except (TypeError, ValueError):
        return missing
    return v if math.isfinite(v) else missing


archive_UA = {"User-Agent": "orbitlight Python-urllib/%d.%d" % sys.version_info[:2]}

archive_TAP = {
    "eso": "https://archive.eso.org/tap_obs/sync",
    "exoplanets": "https://exoplanetarchive.ipac.caltech.edu/TAP/sync",
    "gaia": "https://gea.esac.esa.int/tap-server/tap/sync",
    "vizier": "https://tapvizier.cds.unistra.fr/TAPVizieR/tap/sync",
}

archive_MAXREC = 10000000
# the Gaia partner data centre that holds the releases under ESA's table and column names, writing its array columns in braces
archive_GAIA_PARTNER = "https://gaia.ari.uni-heidelberg.de/tap/sync"


def archive_get(url, headers=None, payload=None, timeout=120, retries=4, byte_range=None, soft=False, pause=5):
    """Bytes of a URL with retries and growing pauses, PAYLOAD posted where given; byte_range slices; soft returns None on 404 or exhausted retries and logs the latter."""
    h = dict(archive_UA)
    if headers:
        h.update(headers)
    if byte_range:
        h["Range"] = "bytes=%d-%d" % byte_range
    last = None
    for attempt in range(retries):
        try:
            req = urllib.request.Request(url, headers=h, data=payload)
            return urllib.request.urlopen(req, timeout=timeout).read()
        except urllib.error.HTTPError as e:
            last = e
            if soft and e.code == 404:
                return None
        except Exception as e:
            last = e
        if attempt < retries - 1:
            time.sleep(pause * (attempt + 1))
    if soft:
        sys.stderr.write("archive_get: %s failed %d times (%s); returned None\n" % (url, retries, repr(last)[:200]))
        return None
    raise last


def archive_tap(service, query, fmt="csv", method=None, timeout=600, maxrec=None, retries=4):
    """ADQL on a named TAP service or sync URL, tried RETRIES times: rows as dicts (csv) or text; MAXREC set to avoid silent 50000-row cuts. Gaia's queries go to ESA's archive and its partner
    (archive_GAIA_PARTNER), DR3's to the partner first, the other asked where the first does not answer."""
    if service == "gaia":
        sites = (archive_GAIA_PARTNER, archive_TAP["gaia"]) if "gaiadr3." in query else (archive_TAP["gaia"], archive_GAIA_PARTNER)
        try:
            return archive_tap(sites[0], query, fmt, "POST", timeout, maxrec, 2)
        except Exception:
            return archive_tap(sites[1], query, fmt, "POST", timeout, maxrec, retries)
    url = archive_TAP.get(service, service)
    if maxrec is None:
        maxrec = archive_MAXREC
    params = dict(REQUEST="doQuery", LANG="ADQL", FORMAT=fmt, QUERY=query)
    if maxrec:
        params["MAXREC"] = maxrec
    method = method or ("GET" if service in ("eso", "exoplanets") else "POST")
    enc = urllib.parse.urlencode(params)
    if method == "GET":
        raw = archive_get(url + "?" + enc, timeout=timeout, retries=retries)
    else:
        raw = archive_get(url, payload=enc.encode(), timeout=timeout, retries=retries)
    text = raw.decode("utf-8-sig", errors="replace")
    if fmt == "votable":
        if b"QUERY_STATUS\" value=\"ERROR" in raw:
            raise IOError("%s answered with an error: %s" % (service, text[:400]))
    elif fmt in ("csv", "json") and text.lstrip()[:1] == "<":
        raise IOError("%s answered with an HTML or XML page instead of %s: %s" % (service, fmt, text[:200]))
    if fmt == "csv":
        return list(csv.DictReader(io.StringIO(text)))
    if fmt == "json":
        return json.loads(text)
    if fmt == "votable":
        return archive_votable_rows(raw)
    return text


def archive_votable_rows(raw):
    """Rows of a VOTable as dicts of Python values."""
    from astropy.io.votable import parse_single_table
    t = parse_single_table(io.BytesIO(raw)).to_table()
    return [dict(zip(t.colnames, [x.item() if hasattr(x, "item") else x for x in row])) for row in t]


def archive_pmap(fn, items, threads=8):
    """fn over items on a bounded thread pool, results in order."""
    with cf.ThreadPoolExecutor(threads) as ex:
        return list(ex.map(fn, items))


# SIMBAD's tables as parquet on Hugging Face
archive_SIMBAD = "phanerozoic/SIMBAD"
archive_SIMBAD_CACHE = {}


def archive_simbad_table(name, columns):
    """COLUMNS of a table of the SIMBAD mirror, cached."""
    key = (name, tuple(columns))
    if key not in archive_SIMBAD_CACHE:
        import pyarrow.parquet as pq
        from huggingface_hub import snapshot_download
        root = snapshot_download(archive_SIMBAD, repo_type="dataset", allow_patterns="data/%s/*" % name)
        archive_SIMBAD_CACHE[key] = pq.read_table(os.path.join(root, "data", name), columns=list(columns))
    return archive_SIMBAD_CACHE[key]


def archive_simbad_key(s):
    """An identifier without spaces, in capitals."""
    return "".join(str(s).split()).upper()


def archive_simbad_hash(s):
    """An identifier's key as a signed 64-bit FNV-1a hash, as the key_hash kernel computes it."""
    h = 14695981039346656037
    for c in archive_simbad_key(s).encode():
        h = ((h ^ c) * 1099511628211) & 0xFFFFFFFFFFFFFFFF
    return h - (1 << 64) if h >= 1 << 63 else h


def archive_simbad_hashes(column):
    """The key hash of every string of a pyarrow string column, on the device."""
    import pyarrow as pa
    out = []
    for chunk in column.chunks:
        if _gpu_kernels() is None:
            out.append(torch.as_tensor([archive_simbad_hash(s) for s in chunk.to_pylist()], dtype=torch.int64, device=gpu_DEVICE))
            continue
        _, offsets, data = chunk.buffers()
        off = np.frombuffer(offsets, dtype=np.int64 if pa.types.is_large_string(chunk.type) else np.int32)[chunk.offset:chunk.offset + len(chunk) + 1]
        raw = np.frombuffer(data, dtype=np.uint8) if data is not None else np.zeros(1, np.uint8)
        out.append(_gpu_kernels().key_hash(torch.as_tensor(raw, device=gpu_DEVICE), torch.as_tensor(off.astype(np.int64), device=gpu_DEVICE), _gpu_stream()))
    return torch.cat(out)


archive_SIMBAD_TYPES = ("Pl", "Pl?", "BD*", "BD?")


def archive_simbad_build(folder):
    """The SIMBAD mirror's index written to FOLDER: every identifier's key hash with its oid, every object-paper and parent-child link, every object's
    position and velocity, and the planets and brown dwarfs with their names."""
    import pyarrow.compute as pc
    import pyarrow.parquet as pq
    os.makedirs(folder, exist_ok=True)
    save = lambda name, x: np.save(os.path.join(folder, name + ".npy"), x)
    t = archive_simbad_table("ident", ("id", "oidref"))
    save("id_hash", gpu_host(archive_simbad_hashes(t["id"])))
    save("id_oid", t["oidref"].to_numpy())
    t = archive_simbad_table("has_ref", ("oidref", "oidbibref"))
    save("ref_oid", t["oidref"].to_numpy()), save("ref_bib", t["oidbibref"].to_numpy())
    t = archive_simbad_table("h_link", ("parent", "child"))
    save("link_parent", t["parent"].to_numpy()), save("link_child", t["child"].to_numpy())
    t = archive_simbad_table("basic", ("oid", "ra", "dec", "rvz_radvel", "main_id", "otype"))
    save("basic_oid", t["oid"].to_numpy())
    for c, name in (("ra", "basic_ra"), ("dec", "basic_dec"), ("rvz_radvel", "basic_rv")):
        save(name, t[c].to_numpy(zero_copy_only=False).astype(float))
    pq.write_table(t.select(["oid", "main_id", "otype"]).filter(pc.is_in(t["otype"], value_set=__import__("pyarrow").array(archive_SIMBAD_TYPES))),
                   os.path.join(folder, "companions.parquet"))
    archive_SIMBAD_CACHE.clear()


def archive_simbad_array(name):
    """One array of the SIMBAD mirror's index on the device, the index built into DATA/simbad_index on first use."""
    if name not in archive_SIMBAD_CACHE:
        folder = archive_data("simbad_index")
        if not os.path.exists(os.path.join(folder, "companions.parquet")):
            archive_simbad_build(folder)
        archive_SIMBAD_CACHE[name] = torch.as_tensor(np.load(os.path.join(folder, name + ".npy")), device=gpu_DEVICE)
    return archive_SIMBAD_CACHE[name]


def archive_simbad_oids(names):
    """SIMBAD's oid of each identifier of NAMES, matched by key hash on the device: a dict of name to oid, each way of writing one identifier among NAMES given it."""
    keys = {}
    for n in names:
        keys.setdefault(archive_simbad_hash(n), []).append(n)
    h = archive_simbad_array("id_hash")
    hit = torch.isin(h, torch.as_tensor(list(keys), dtype=torch.int64, device=gpu_DEVICE))
    return {n: int(o) for a, o in zip(gpu_host(h[hit]), gpu_host(archive_simbad_array("id_oid")[hit])) for n in keys[int(a)]}


def archive_simbad_select(name, oids):
    """The positions of the index array NAME whose values are among OIDS."""
    return torch.isin(archive_simbad_array(name), torch.as_tensor(sorted(set(oids)), dtype=torch.int64, device=gpu_DEVICE))


def archive_simbad_velocities(names):
    """SIMBAD's radial velocity (km/s) of each identifier of NAMES: a dict of name to velocity."""
    oids = archive_simbad_oids(names)
    hit = archive_simbad_select("basic_oid", oids.values())
    rv = {int(o): float(v) for o, v in zip(gpu_host(archive_simbad_array("basic_oid")[hit]), gpu_host(archive_simbad_array("basic_rv")[hit])) if math.isfinite(v)}
    return {n: rv[o] for n, o in oids.items() if o in rv}


def archive_simbad_velocity_near(ra, dec, radius_arcsec=10.0):
    """SIMBAD's radial velocity (km/s) of the nearest object with one within RADIUS_ARCSEC of a J2000 position, or None."""
    a, d, v = (archive_simbad_array(x) for x in ("basic_ra", "basic_dec", "basic_rv"))
    sep = torch.hypot((torch.remainder(a - ra + 180.0, 360.0) - 180.0) * math.cos(math.radians(dec)), d - dec)
    sep = torch.where(torch.isfinite(v), sep, torch.full_like(sep, float("inf")))
    i = int(torch.argmin(sep))
    return float(v[i]) if float(sep[i]) < radius_arcsec / 3600.0 else None


def archive_simbad_near(ra, dec, radius_arcsec=10.0):
    """SIMBAD's main identifier of the object nearest a J2000 position within RADIUS_ARCSEC, or None."""
    import pyarrow.compute as pc
    if not (math.isfinite(ra) and math.isfinite(dec)):
        return None
    a, d = archive_simbad_array("basic_ra"), archive_simbad_array("basic_dec")
    sep = torch.hypot((torch.remainder(a - ra + 180.0, 360.0) - 180.0) * math.cos(math.radians(dec)), d - dec)
    sep = torch.where(torch.isfinite(sep), sep, torch.full_like(sep, float("inf")))
    i = int(torch.argmin(sep))
    if float(sep[i]) >= radius_arcsec / 3600.0:
        return None
    t = archive_simbad_table("basic", ("oid", "main_id"))
    t = t.filter(pc.equal(t["oid"], int(archive_simbad_array("basic_oid")[i])))
    return t["main_id"][0].as_py() if len(t) else None


def archive_simbad_within(positions, radius_arcsec=10.0):
    """SIMBAD's objects within RADIUS_ARCSEC of each J2000 position (ra, dec) of POSITIONS, read from the mirror's index sorted by declination: for each its oids, nearest first."""
    a, d, o = (gpu_host(archive_simbad_array(x)) for x in ("basic_ra", "basic_dec", "basic_oid"))
    keep = np.isfinite(a) & np.isfinite(d)
    a, d, o = a[keep], d[keep], o[keep]
    order = np.argsort(d)
    a, d, o = a[order], d[order], o[order]
    w, out = radius_arcsec / 3600.0, []
    for ra, dec in positions:
        lo, hi = np.searchsorted(d, dec - w), np.searchsorted(d, dec + w)
        sep = np.hypot((np.remainder(a[lo:hi] - ra + 180.0, 360.0) - 180.0) * math.cos(math.radians(dec)), d[lo:hi] - dec) if math.isfinite(ra) and math.isfinite(dec) else np.zeros(0)
        k = np.argsort(sep)
        out.append([int(o[lo + j]) for j in k if sep[j] < w])
    return out


def archive_simbad_companions(names):
    """SIMBAD's planets and brown dwarfs linked to each identifier of NAMES as its children: a dict of name to (main_id, otype, oid)."""
    import pyarrow.parquet as pq
    oids = archive_simbad_oids(names)
    hit = archive_simbad_select("link_parent", oids.values())
    if "companions" not in archive_SIMBAD_CACHE:
        t = pq.read_table(os.path.join(archive_data("simbad_index"), "companions.parquet"))
        archive_SIMBAD_CACHE["companions"] = {o: (m, k) for o, m, k in zip(t["oid"].to_pylist(), t["main_id"].to_pylist(), t["otype"].to_pylist())}
    kinds, by = archive_SIMBAD_CACHE["companions"], {}
    for p, c in zip(gpu_host(archive_simbad_array("link_parent")[hit]).tolist(), gpu_host(archive_simbad_array("link_child")[hit]).tolist()):
        if c in kinds:
            by.setdefault(p, []).append(kinds[c] + (c,))
    return {n: sorted(by.get(oids.get(n), [])) for n in names}


archive_SIMBAD_BINARIES = ("EB*", "EB?", "SB*", "SB?", "El*", "El?", "RS*", "RS?")


def archive_simbad_binaries():
    """SIMBAD's eclipsing, spectroscopic, ellipsoidal and RS CVn binaries and their candidates (archive_SIMBAD_BINARIES): right ascension,
    declination (deg) and the type's place in that list, sorted by declination, kept in DATA/simbad_index/binaries.npy once built."""
    if "binaries" not in archive_SIMBAD_CACHE:
        path = archive_data("simbad_index", "binaries.npy")
        if not os.path.exists(path):
            import pyarrow as pa
            import pyarrow.compute as pc
            t = archive_simbad_table("basic", ("ra", "dec", "otype"))
            t = t.filter(pc.is_in(t["otype"], value_set=pa.array(archive_SIMBAD_BINARIES)))
            kind = np.array([archive_SIMBAD_BINARIES.index(k) for k in t["otype"].to_pylist()], float)
            x = np.column_stack([t["ra"].to_numpy(zero_copy_only=False).astype(float), t["dec"].to_numpy(zero_copy_only=False).astype(float), kind])
            x = x[np.isfinite(x).all(axis=1)]
            archive_SIMBAD_CACHE.pop(("basic", ("ra", "dec", "otype")), None)
            os.makedirs(os.path.dirname(path), exist_ok=True)
            tmp = archive_tmp(path)
            with open(tmp, "wb") as fh:
                np.save(fh, x[np.argsort(x[:, 1])])
            archive_place(tmp, path)
        archive_SIMBAD_CACHE["binaries"] = np.load(path)
    return archive_SIMBAD_CACHE["binaries"]


def archive_simbad_basic(names, columns=("main_id", "otype")):
    """COLUMNS of SIMBAD's basic table for each identifier of NAMES: a dict of name to a dict of column to value."""
    import pyarrow as pa
    import pyarrow.compute as pc
    oids = archive_simbad_oids(names)
    t = archive_simbad_table("basic", ("oid",) + tuple(columns))
    t = t.filter(pc.is_in(t["oid"], value_set=pa.array(sorted(set(oids.values())), type=t["oid"].type)))
    rows = {o: dict(zip(columns, vals)) for o, *vals in zip(t["oid"].to_pylist(), *(t[c].to_pylist() for c in columns))}
    return {n: rows[o] for n, o in oids.items() if o in rows}


def archive_simbad_papers(names, words=("planet", "companion", "radial veloc"), most=None):
    """SIMBAD's papers on each identifier of NAMES whose titles contain any of WORDS, of at most MOST objects where given: name to (bibcode, year, title)."""
    import pyarrow as pa
    import pyarrow.compute as pc
    oids = archive_simbad_oids(names)
    hit = archive_simbad_select("ref_oid", oids.values())
    pairs = list(zip(gpu_host(archive_simbad_array("ref_oid")[hit]).tolist(), gpu_host(archive_simbad_array("ref_bib")[hit]).tolist()))
    ref = archive_simbad_table("ref", ("oidbib", "bibcode", "year", "title", "nbobject"))
    ref = ref.filter(pc.is_in(ref["oidbib"], value_set=pa.array(sorted({b for _, b in pairs}), type=ref["oidbib"].type)))
    info = {b: (c, y, t or "", n) for b, c, y, t, n in zip(*(ref[x].to_pylist() for x in ("oidbib", "bibcode", "year", "title", "nbobject")))}
    by = {}
    for o, b in pairs:
        if b in info and any(w in info[b][2].lower() for w in words) and (most is None or (info[b][3] or 0) <= most):
            by.setdefault(o, []).append(info[b][:3])
    return {n: sorted(by.get(oids.get(n), []), key=lambda r: -(r[1] or 0)) for n in names}


def archive_spectra(ra, dec, radius_deg=0.01):
    """Every archived spectrum of a position: ESO Phase 3 products, CFHT SPIRou planes through the CADC and Keck NIRSPEC frames through KOA, each with its source, instrument, identifier, time span (MJD), exposure (s) and wavelength span (m)."""
    rows = []
    q = ("SELECT dp_id, instrument_name, t_min, t_max, t_exptime, em_min, em_max, snr FROM ivoa.ObsCore WHERE dataproduct_type = 'spectrum' AND "
         "CONTAINS(POINT('ICRS', s_ra, s_dec), CIRCLE('ICRS', %.5f, %.5f, %g)) = 1" % (ra, dec, radius_deg))
    for r in archive_tap("eso", q):
        rows.append(dict(src="ESO", inst=r["instrument_name"], id=r["dp_id"], t0=float(r["t_min"]), t1=float(r["t_max"]), exp=archive_num(r["t_exptime"]),
                         lo=archive_num(r["em_min"]), hi=archive_num(r["em_max"]), snr=archive_num(r["snr"])))
    q = ("SELECT p.productID, p.time_bounds_lower, p.time_bounds_upper, p.time_exposure, p.energy_bounds_lower, p.energy_bounds_upper, p.dataRelease "
         "FROM caom2.Observation o JOIN caom2.Plane p ON o.obsID = p.obsID WHERE o.collection = 'CFHT' AND o.instrument_name = 'SPIRou' AND "
         "o.intent = 'science' AND INTERSECTS(CIRCLE('ICRS', %.5f, %.5f, %g), p.position_bounds) = 1" % (ra, dec, radius_deg))
    # one plane per exposure, the telluric-corrected product (t), and public ones alone
    for r in archive_tap(archive_CADC_TAP, q, method="POST", maxrec=20000):
        t0, t1 = archive_num(r["time_bounds_lower"]), archive_num(r["time_bounds_upper"])
        if t0 is not None and t1 is not None and r["productID"].endswith("t") and (r.get("dataRelease") or "")[:10] <= time.strftime("%Y-%m-%d"):
            rows.append(dict(src="CADC", inst="SPIRou", id=r["productID"], t0=t0, t1=t1, exp=archive_num(r["time_exposure"]),
                             lo=archive_num(r["energy_bounds_lower"]), hi=archive_num(r["energy_bounds_upper"]), snr=None, release=r.get("dataRelease")))
    return rows + archive_koa_spectra(ra, dec, radius_deg)


def archive_koa_spectra(ra, dec, radius_deg=0.01):
    """Keck NIRSPEC spectrograph frames of a position through KOA, object frames of the spectrograph camera alone, each with its start (MJD), exposure (s) and wavelength span (m)."""
    q = ("SELECT koaid, mjd, elaptime, waveblue, wavered FROM koa_nirspec WHERE camera = 'spec' AND koaimtyp = 'object' AND "
         "CONTAINS(POINT('icrs', ra, dec), CIRCLE('icrs', %.5f, %.5f, %g)) = 1" % (ra, dec, radius_deg))
    rows = []
    for r in archive_tap(archive_KOA_TAP, q, method="POST", maxrec=20000):
        t0, exp = archive_num(r["mjd"]), archive_num(r["elaptime"]) or 0.0
        if t0 is None:
            continue
        lo, hi = archive_num(r["waveblue"]), archive_num(r["wavered"])
        rows.append(dict(src="KOA", inst="NIRSPEC", id=r["koaid"], t0=t0, t1=t0 + exp / 86400.0, exp=exp, lo=lo * 1e-6 if lo else None,
                         hi=hi * 1e-6 if hi else None, snr=None))
    return rows


archive_CADC_TAP = "https://ws.cadc-ccda.hia-iha.nrc-cnrc.gc.ca/argus/sync"
archive_KOA_TAP = "https://koa.ipac.caltech.edu/TAP/sync"
archive_CADC_FILE = "https://ws.cadc-ccda.hia-iha.nrc-cnrc.gc.ca/data/pub/CFHT/"


def archive_path(folder, r):
    """Where an archived spectrum, a row of archive_spectra or of an ESO listing, is kept in FOLDER: its identifier made a file name."""
    return os.path.join(folder, re.sub(r"[^A-Za-z0-9_.-]", "_", r.get("dp_id") or r["id"]) + ".fits")


def archive_tmp(path):
    """A temporary file beside PATH of this process's and thread's own, so that processes writing the same file at once never meet."""
    return "%s.%d.%d.tmp" % (path, os.getpid(), threading.get_ident())


def archive_place(tmp, path):
    """The written file TMP put in PATH's place; where another process has just put PATH there, its copy stands and TMP is removed."""
    try:
        os.replace(tmp, path)
    except PermissionError:
        os.remove(tmp)
        if not os.path.exists(path):
            raise
    return path


def archive_save(path, data):
    """DATA, bytes, written to PATH whole (archive_tmp, archive_place)."""
    tmp = archive_tmp(path)
    open(tmp, "wb").write(data)
    return archive_place(tmp, path)


def archive_download(r, path):
    """One archived spectrum, a row of archive_spectra (src, id) or of an ESO listing (dp_id), fetched to PATH unless it is already there: the CADC's
    SPIRou products from its CFHT collection, the rest from ESO. PATH, or None where the archive refuses it, as for a proprietary or withdrawn
    product."""
    if os.path.exists(path):
        return path
    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
    try:
        if r.get("src") in ("CADC", "SOPHIE", "HARPN"):
            b = archive_get(archive_CADC_FILE + r["id"] + ".fits" if r["src"] == "CADC" else planets_SOPHIE + planets_SOPHIE_FILE % r["id"] if r["src"] == "SOPHIE" else planets_TNG_FILES + r["id"] + "_S1D_A.fits.gz", timeout=600, soft=True)
            b = gzip.decompress(b) if b and b[:2] == b"\x1f\x8b" else b
            if b and b[:6] == b"SIMPLE":
                return archive_save(path, b)
            return None
        return path if archive_eso_download(r.get("dp_id") or r["id"], path) else None
    except Exception:
        return None


archive_HARPS_MIRROR = "datasets/phanerozoic/HARPS/"
archive_HF_FS = []


def archive_harps_path(dp_id):
    """A HARPS product's path in the mirror: HARPS/<year-month>/<day>T<hour>/<identifier>.fits, by the time ESO created the product, so that no folder
    nears the Hub's 10000 files."""
    return "HARPS/%s/%s/%s.fits" % (dp_id[4:11], dp_id[12:17], re.sub(r"[^A-Za-z0-9_.-]", "_", dp_id))


def archive_eso_download(dp_id, path):
    """Download one public ESO product to PATH, from the HARPS mirror on Hugging Face where it holds the product, else from ESO; True when a FITS file
    arrived."""
    try:
        from huggingface_hub import HfFileSystem
        archive_HF_FS or archive_HF_FS.append(HfFileSystem())
        tmp = archive_tmp(path)
        archive_HF_FS[0].get_file(archive_HARPS_MIRROR + archive_harps_path(dp_id), tmp)
        if open(tmp, "rb").read(6) == b"SIMPLE":
            archive_place(tmp, path)
            return True
    except Exception:
        pass
    b = archive_get("https://dataportal.eso.org/dataportal_new/file/" + dp_id, timeout=300)
    if b[:6] != b"SIMPLE":
        return False
    archive_save(path, b)
    return True


def archive_exoplanets(query):
    """Rows of ADQL on the NASA Exoplanet Archive."""
    return archive_tap("exoplanets", query)


def archive_eso_listing(ra, dec, inst, min_snr=10.0, radius_deg=0.01):
    """The public ESO Phase 3 spectra of a position from one instrument above MIN_SNR, in time order: dp_id, t_min and snr each."""
    q = ("SELECT dp_id, instrument_name, t_min, snr, obs_release_date FROM ivoa.ObsCore WHERE dataproduct_type = 'spectrum' AND "
         "CONTAINS(POINT('ICRS', s_ra, s_dec), CIRCLE('ICRS', %.5f, %.5f, %g)) = 1" % (ra, dec, radius_deg))
    today = time.strftime("%Y-%m-%d")
    return sorted((r for r in archive_tap("eso", q) if r["instrument_name"] == inst and (archive_num(r["snr"]) or 0) > min_snr and (r.get("obs_release_date") or "")[:10] <= today),
                  key=lambda r: float(r["t_min"]))


archive_ESO_INDEX = {}


def archive_eso_listings(positions, inst, min_snr=10.0, radius_deg=0.01):
    """archive_eso_listing for many (ra, dec) positions from a single query: the instrument's whole Phase 3 spectrum index is fetched once per run and
    matched locally. Returns one time-ordered listing per position."""
    if inst not in archive_ESO_INDEX:
        rows = archive_tap("eso", "SELECT dp_id, s_ra, s_dec, t_min, snr FROM ivoa.ObsCore WHERE dataproduct_type = 'spectrum' AND instrument_name = '%s'"
                           % inst, timeout=1800)
        col = lambda k: np.array([archive_num(r[k], np.nan) for r in rows])
        dec = col("s_dec")
        o = np.argsort(np.nan_to_num(dec, nan=99.0))
        archive_ESO_INDEX[inst] = dict(dp_id=np.array([r["dp_id"] for r in rows])[o], ra=col("s_ra")[o], dec=dec[o], t_min=col("t_min")[o], snr=col("snr")[o])
    x = archive_ESO_INDEX[inst]
    out = []
    for ra, dec in positions:
        lo, hi = np.searchsorted(x["dec"], dec - radius_deg), np.searchsorted(x["dec"], dec + radius_deg)
        dra = (np.remainder(x["ra"][lo:hi] - ra + 180.0, 360.0) - 180.0) * math.cos(math.radians(dec))
        k = lo + np.where((np.hypot(dra, x["dec"][lo:hi] - dec) < radius_deg) & (np.nan_to_num(x["snr"][lo:hi]) > min_snr))[0]
        k = k[np.argsort(x["t_min"][k])]
        out.append([dict(dp_id=str(x["dp_id"][i]), instrument_name=inst, t_min=float(x["t_min"][i]), snr=float(x["snr"][i])) for i in k])
    return out


def archive_eso_fetch(rows, folder, streams=4, most=None, best=False):
    """The listed ESO products fetched into FOLDER, MOST of them spread evenly over the listing's span (or the MOST of highest signal to noise with BEST), those present kept: their paths."""
    if most and len(rows) > most:
        rows = sorted(rows, key=lambda r: -(archive_num(r.get("snr")) or 0))[:most] if best else [rows[int(i)] for i in np.unique(np.linspace(0, len(rows) - 1, most).round())]
    os.makedirs(folder, exist_ok=True)
    return [p for p in archive_pmap(lambda r: archive_download(r, archive_path(folder, r)), rows, streams) if p]


def archive_gaia_star(ra, dec, vmag=None, radius_arcsec=30.0, physical=True):
    """A star's Gaia DR3 source, the brightest within RADIUS_ARCSEC of a J2000 position and 2.5 mag of VMAG, with its astrometry, RUWE, excess noise
    and velocity summary, and with PHYSICAL its FLAME mass and radius; or None."""
    q = ("SELECT source_id, ra, dec, parallax, pmra, pmdec, ruwe, astrometric_excess_noise, astrometric_excess_noise_sig, phot_g_mean_mag, "
         "non_single_star, ipd_frac_multi_peak, radial_velocity, radial_velocity_error, rv_amplitude_robust, rv_chisq_pvalue FROM gaiadr3.gaia_source WHERE CONTAINS(POINT('ICRS', ra, dec), "
         "CIRCLE('ICRS', %.6f, %.6f, %.6f)) = 1" % (ra, dec, radius_arcsec / 3600.0))
    rows = [r for r in archive_tap("gaia", q) if vmag is None or not math.isfinite(vmag) or abs((archive_num(r["phot_g_mean_mag"]) or 99.0) - vmag) < 2.5]
    if not rows:
        return None
    best = min(rows, key=lambda r: archive_num(r["phot_g_mean_mag"]) or 99.0)
    if physical:
        ap = archive_tap("gaia", "SELECT mass_flame, radius_flame, teff_gspphot FROM gaiadr3.astrophysical_parameters WHERE source_id = %s" % best["source_id"])
        best.update(ap[0] if ap else dict(mass_flame="", radius_flame="", teff_gspphot=""))
    return best


def archive_gaia_solutions(source_ids):
    """Gaia DR3's two-body orbits, acceleration solutions and velocity trends of SOURCE_IDS, by source."""
    ids = sorted({str(s) for s in source_ids})
    out = {s: dict(orbit=[], acceleration=[], trend=[]) for s in ids}
    for kind, table in (("orbit", "nss_two_body_orbit"), ("acceleration", "nss_acceleration_astro"), ("trend", "nss_non_linear_spectro")):
        for i in range(0, len(ids), 500):
            for r in archive_tap("gaia", "SELECT * FROM gaiadr3.%s WHERE source_id IN (%s)" % (table, ", ".join(ids[i:i + 500]))):
                out[str(r["source_id"])][kind].append(r)
    return out


def archive_hipparcos_of(source_id):
    """The Hipparcos number of a Gaia DR3 source from DR3's best neighbours, or None."""
    rows = archive_tap("gaia", "SELECT original_ext_source_id FROM gaiadr3.hipparcos2_best_neighbour WHERE source_id = %s" % source_id)
    return int(rows[0]["original_ext_source_id"]) if rows else None


# VizieR's catalogues as parquet on Hugging Face, each table at <catalogue>/<table>.parquet
archive_VIZIER = "phanerozoic/VizieR"
archive_VIZIER_CACHE = {}


def archive_vizier(catalogue, table, columns=None):
    """A table of the VizieR mirror, its COLUMNS alone where given, cached."""
    key = (catalogue, table, tuple(columns) if columns else None)
    if key not in archive_VIZIER_CACHE:
        import pyarrow.parquet as pq
        from huggingface_hub import hf_hub_download
        archive_VIZIER_CACHE[key] = pq.read_table(hf_hub_download(archive_VIZIER, "%s/%s.parquet" % (catalogue, table), repo_type="dataset"),
                                                  columns=list(columns) if columns else None)
    return archive_VIZIER_CACHE[key]


def archive_vizier_text(query, timeout=120, retries=2, rows=False):
    """The reply to the asu-tsv QUERY from the first of VizieR's sites (planets_VIZIER_SITES) to answer that holds its catalogue, as text, with ROWS one that has rows, or None: a site without the catalogue says so in a reply that otherwise reads as a table with no rows."""
    for site in planets_VIZIER_SITES:
        raw = archive_get("%s/viz-bin/asu-tsv?%s" % (site, query), timeout=timeout, retries=retries, soft=True)
        if raw and b"VizieR" in raw[:4000] and b"#INFO\tError=" not in raw:
            text = raw.decode("utf-8", "replace")
            if not rows or sum(1 for x in text.splitlines() if x and not x.startswith("#")) > 3:
                return text
    return None


def archive_vizier_table(source, timeout=60):
    """A whole table of VizieR, SOURCE its catalogue and table (archive_vizier_text): its rows as dicts of text; an error where no site gives them."""
    q = urllib.parse.urlencode({"-source": source, "-out.max": "unlimited", "-out.all": ""})
    for attempt in range(6):
        text = archive_vizier_text(q, timeout, 3, rows=True)
        if text:
            lines = [x for x in text.splitlines() if x and not x.startswith("#")]
            keys = [k.strip() for k in lines[0].split("\t")]
            return [dict(zip(keys, [c.strip() for c in x.split("\t")])) for x in lines[3:]]
        # the sites answer empty for a while after several whole tables in a row
        time.sleep(120)
    raise IOError("no VizieR site answered with %s" % source)


def archive_vizier_file(path, timeout=120):
    """A file of the CDS archive's catalogues, PATH under its cats folder, from the first of VizieR's sites to serve it, as text, or None."""
    for site in planets_VIZIER_SITES:
        raw = archive_get("%s/ftp/cats/%s" % (site, path), timeout=timeout, retries=2, soft=True)
        if raw and not raw.lstrip().startswith(b"<"):
            return raw.decode("latin-1")
    return None


def archive_earth(mjd):
    """The Earth's barycentric place (AU, equatorial axes of J2000) at the epochs MJD: the opposite of the Sun's geocentric place from its
    low-precision ecliptic longitude and distance (the Astronomical Almanac's, good to about a hundredth of a degree)."""
    n = np.asarray(mjd, float) - 51544.5
    g = np.radians(357.528 + 0.9856003 * n)
    lam = np.radians(280.460 + 0.9856474 * n + 1.915 * np.sin(g) + 0.020 * np.sin(2.0 * g))
    r = 1.00014 - 0.01671 * np.cos(g) - 0.00014 * np.cos(2.0 * g)
    eps = math.radians(23.439)
    return np.stack([-r * np.cos(lam), -r * np.sin(lam) * math.cos(eps), -r * np.sin(lam) * math.sin(eps)], -1)


def archive_parallax_factors(ra, dec, mjd):
    """The parallax factors of a star at RA, DEC (degrees, or of many as columns of one) at the epochs MJD: its displacement along right ascension (times
    cos dec) and along declination for a parallax of one, seen from the Earth's barycentric place (archive_earth)."""
    x, y, z = archive_earth(mjd).T
    a, d = np.radians(ra), np.radians(dec)
    return x * np.sin(a) - y * np.cos(a), (x * np.cos(a) + y * np.sin(a)) * np.sin(d) - z * np.cos(d)


# Kervella et al.'s (2022) columns, from the authors' release in the mirror, under VizieR's names for them: the Hipparcos-Gaia long-term proper motion
# and the proper-motion anomaly at Gaia's epoch, 2016.0
archive_KERVELLA = {"HIP": "HIP", "PlxG3": "PlxG3", "RUWE": "RUWE", "M1": "M1", "R1": "R1", "dVt": "dVt", "e_dVt": "e_dVt", "pmRAH2EG3b": "muHGGRA",
                    "e_pmRAH2EG3b": "e_muHGGRA", "pmDEH2EG3b": "muHGGDec", "e_pmDEH2EG3b": "e_muHGGDec", "PMaRAH2EG3b": "PMaGRA",
                    "e_PMaRAH2EG3b": "e_PMaGRA", "PMaDEH2EG3b": "PMaGDec", "e_PMaDEH2EG3b": "e_PMaGDec", "snrPMaH2EG3b": "PMaG3snr"}


def archive_kervella(hip=None, ra=None, dec=None):
    """A star's Hipparcos-Gaia proper-motion anomaly, long-term proper motion and mass from Kervella et al. (2022), by Hipparcos number or else the
    nearest star within 10 arcsec, under VizieR's column names; None where the catalogue holds no star there or no anomaly for it."""
    t = archive_vizier("J/A+A/657/A7", "Hip-EDR3-PMa_v7")
    if hip:
        i = np.where(t["HIP"].to_numpy(zero_copy_only=False) == hip)[0]
    else:
        a, d = (t[c].to_numpy(zero_copy_only=False).astype(float) for c in ("RA_ICRS", "DE_ICRS"))
        sep = np.hypot((np.remainder(a - ra + 180.0, 360.0) - 180.0) * math.cos(math.radians(dec)), d - dec)
        i = np.where(sep == np.nanmin(sep))[0] if np.nanmin(sep) < 10.0 / 3600.0 else []
    if not len(i):
        return None
    row = {k: t[c][int(i[0])].as_py() for k, c in archive_KERVELLA.items()}
    if not all(archive_num(row[k]) is not None for k in ("pmRAH2EG3b", "pmDEH2EG3b", "PMaRAH2EG3b", "PMaDEH2EG3b", "snrPMaH2EG3b")):
        return None
    return dict(row, source="Kervella et al. (2022)")


archive_NIST_LINES = ("https://physics.nist.gov/cgi-bin/ASD/lines1.pl?spectra=%s&output_type=0&low_w=%g&upp_w=%g&unit=0"
              "&submit=Retrieve+Data&de=0&plot_out=0&I_scale_type=1&format=3&line_out=0&remove_js=on&en_unit=0&output=0"
              "&bibrefs=1&page_size=15&show_obs_wl=1&show_calc_wl=1&unc_out=1&order_out=0&max_low_enrg=&show_av=2"
              "&max_upp_enrg=&tsb_value=0&min_str=&A_out=0&intens_out=on&max_str=&allowed_out=1&forbid_out=1"
              "&min_accur=&min_intens=&conf_out=on&term_out=on&enrg_out=on&J_out=on")


def archive_nist_lines(spectrum, lo, hi, cache_dir=None):
    """NIST ASD lines of one spectrum between lo and hi (A): ion, vacuum wavelength, intensity, Aki, lower-level energy."""
    path = None
    if cache_dir:
        os.makedirs(cache_dir, exist_ok=True)
        path = os.path.join(cache_dir, "%s_%g_%g.tsv" % (spectrum.replace(" ", "_"), lo, hi))
    if path and os.path.exists(path):
        t = open(path, encoding="utf-8").read()
    else:
        b = archive_get(archive_NIST_LINES % (urllib.parse.quote_plus(spectrum), lo, hi), timeout=300, retries=3, soft=True)
        t = b.decode("utf-8", "replace") if b else ""
        if "Input Error" in t or "<html" in t[:200].lower():
            t = ""
        if path and t:
            open(path, "w", encoding="utf-8").write(t)
    out = []
    for r in csv.DictReader(io.StringIO(t), delimiter="\t"):
        r = {k.strip('"'): (v or "").strip('"') for k, v in r.items() if k}
        w = r.get("obs_wl_vac(A)") or r.get("ritz_wl_vac(A)")
        air = not w
        w = w or r.get("obs_wl_air(A)") or r.get("ritz_wl_air(A)")
        try:
            w = float(w)
        except (TypeError, ValueError):
            continue
        if air and w > 2000.0:
            w = float(archive_air_to_vac(w))
        out.append(dict(ion=spectrum, lam=w, intens=r.get("intens", ""), aki=r.get("Aki(s^-1)", ""),
                        ei=r.get("Ei(cm-1)", "")))
    return out


def archive_run_cli(main, description=None):
    """The command line of a mode run as its analysis, or as `record`, which also writes the run's record; every other keyword of MAIN is an option,
    `--name value` (a list as several values), with the keyword's default; DESCRIPTION is the mode's help."""
    archive_quiet_warnings()
    p = argparse.ArgumentParser(prog=sys.argv[0], description=description, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("mode", nargs="?", choices=("run", "record"), default="run")
    for name, par in inspect.signature(main).parameters.items():
        d = par.default
        if name == "record" or d is inspect.Parameter.empty or d is None:
            continue
        flag = "--" + name.replace("_", "-")
        if isinstance(d, bool):
            p.add_argument(flag, dest=name, default=d, type=lambda v: v.lower() in ("1", "true", "yes", "on"))
        elif isinstance(d, (list, tuple)):
            p.add_argument(flag, dest=name, default=list(d), nargs="+", type=type(d[0]) if d else str)
        else:
            p.add_argument(flag, dest=name, default=d, type=type(d))
    a = vars(p.parse_args())
    main(record=a.pop("mode") == "record", **a)


archive_SITES = {"Paranal": (-70.4045, -24.6272, 2635.0), "LaSilla": (-70.7380, -29.2567, 2400.0), "CFHT": (-155.4681, 19.8253, 4204.0)}


def archive_location(site):
    """EarthLocation of a named site among the observatories whose spectra are read."""
    from astropy.coordinates import EarthLocation
    import astropy.units as u
    lon, lat, h = archive_SITES[site]
    return EarthLocation.from_geodetic(lon=lon * u.deg, lat=lat * u.deg, height=h * u.m)


def archive_barycentric_correction(ra, dec, mjd_utc, site):
    """Barycentric correction (km/s) for an observatory-frame radial velocity."""
    from astropy.coordinates import SkyCoord
    from astropy.time import Time
    import astropy.units as u
    return SkyCoord(ra * u.deg, dec * u.deg).radial_velocity_correction(
        kind="barycentric", obstime=Time(mjd_utc, format="mjd"), location=archive_location(site)).to(u.km / u.s).value


def archive_vac_to_air(w):
    """Air wavelength (A) of a vacuum wavelength (Morton 2000)."""
    s2 = (1e4 / np.asarray(w, float)) ** 2
    return w / (1.0 + 0.0000834254 + 0.02406147 / (130.0 - s2) + 0.00015998 / (38.9 - s2))


def archive_air_to_vac(w, iterations=3):
    """Vacuum wavelength (A) of an air wavelength."""
    v = np.asarray(w, float).copy()
    for _ in range(iterations):
        v = v + (w - archive_vac_to_air(v))
    return v


def archive_tag(*parts):
    """A file name of PARTS joined by underscores, every character but a letter, a digit or one of +_.- made an underscore."""
    return re.sub(r"[^A-Za-z0-9+_.-]", "_", "_".join(str(p) for p in parts))


# The array work, in torch on ORBITLIGHT_DEVICE (the CUDA device where there is one, else the CPU): arrays or tensors in, tensors out.

gpu_DEVICE = torch.device(os.environ.get("ORBITLIGHT_DEVICE") or ("cuda" if torch.cuda.is_available() else "cpu"))
gpu_F64 = torch.float64
gpu_NAN = float("nan")



def gpu_budget():
    """The most bytes one intermediate block may take: a gibibyte on a card, and on the CPU a sixteenth of the memory free when the process starts, a gibibyte at most."""
    if gpu_DEVICE.type == "cuda":
        return 1 << 30
    try:
        import psutil
        return int(min(1 << 30, max(1 << 26, psutil.virtual_memory().available / 16)))
    except ImportError:
        return 1 << 28


gpu_BUDGET = gpu_budget()


def gpu_dev(x, dtype=gpu_F64):
    """An array, list or tensor as a tensor of DTYPE on the device."""
    if isinstance(x, torch.Tensor):
        return x.to(device=gpu_DEVICE, dtype=dtype)
    return torch.as_tensor(np.asarray(x), dtype=dtype, device=gpu_DEVICE)


def gpu_host(x):
    """A tensor as a numpy array."""
    return x.detach().cpu().numpy() if isinstance(x, torch.Tensor) else np.asarray(x)


def gpu_interp(x, xp, fp, left=gpu_NAN, right=gpu_NAN):
    """Linear interpolation: the rows FP (..., n), given at the increasing abscissae XP (n,), read at X, LEFT below XP and RIGHT above it."""
    x, xp, fp = gpu_dev(x), gpu_dev(xp), gpu_dev(fp)
    n = xp.shape[-1]
    j = torch.searchsorted(xp, x, right=True).clamp(1, n - 1)
    x0, x1 = xp[j - 1], xp[j]
    d = x1 - x0
    w = torch.where(d > 0, (x - x0) / torch.where(d > 0, d, torch.ones_like(d)), torch.zeros_like(d))
    out = fp[..., j - 1] + (fp[..., j] - fp[..., j - 1]) * w
    out = torch.where(x < xp[0], torch.full_like(out, left), out)
    return torch.where(x > xp[-1], torch.full_like(out, right), out)


def gpu_interp_rows(x, xps, fps):
    """numpy.interp of each pair (xp, fp) of XPS and FPS at the abscissae X, NaN beyond each xp's ends, as rows (pairs, len(x)), with numpy's own
    arithmetic: the value at an abscissa equal to a sample, else the slope times the distance from the sample below plus its value, from the sample
    above where that is not finite."""
    X = gpu_dev(x)
    L = max([len(a) for a in xps] + [2])
    XP = torch.full((len(xps), L), float("inf"), dtype=gpu_F64, device=gpu_DEVICE)
    FP = torch.full((len(xps), L), gpu_NAN, dtype=gpu_F64, device=gpu_DEVICE)
    last = torch.as_tensor([len(a) - 1 for a in xps], device=gpu_DEVICE)
    for i, (a, b) in enumerate(zip(xps, fps)):
        XP[i, :len(a)], FP[i, :len(b)] = gpu_dev(a), gpu_dev(b)
    Xb = X[None, :].expand(len(xps), -1).contiguous()
    j = (torch.searchsorted(XP, Xb, right=True) - 1).clamp(min=0)
    j = torch.minimum(j, (last - 1).clamp(min=0)[:, None])
    x0, x1, f0, f1 = XP.gather(1, j), XP.gather(1, j + 1), FP.gather(1, j), FP.gather(1, j + 1)
    slope = (f1 - f0) / (x1 - x0)
    out = slope * (Xb - x0) + f0
    out = torch.where(torch.isnan(out), slope * (Xb - x1) + f1, out)
    out = torch.where(torch.isnan(out) & (f0 == f1), f0, out)
    out = torch.where(Xb == x0, f0, out)
    xlast, flast = XP.gather(1, last.clamp(min=0)[:, None]), FP.gather(1, last.clamp(min=0)[:, None])
    out = torch.where(Xb == xlast, flast.expand_as(out), out)
    return torch.where((Xb < XP[:, :1]) | (Xb > xlast) | (last[:, None] < 0), torch.full_like(out, gpu_NAN), out)


def gpu_shift_rows(rows, v, left=gpu_NAN, right=gpu_NAN):
    """Each row of ROWS (b, n), sampled on the integer grid centred on zero, read by linear interpolation at the grid plus its own shift V[i], LEFT and
    RIGHT beyond its ends."""
    rows, v = gpu_dev(rows), gpu_dev(v)
    n = rows.shape[1]
    x = torch.arange(n, dtype=gpu_F64, device=gpu_DEVICE)[None, :] + v[:, None]
    j = torch.floor(x).clamp(0, n - 2).long()
    fr = x - j
    r = torch.arange(rows.shape[0], device=gpu_DEVICE)[:, None]
    out = rows[r, j] * (1.0 - fr) + rows[r, j + 1] * fr
    out = torch.where(x < 0, torch.full_like(out, left), out)
    return torch.where(x > n - 1, torch.full_like(out, right), out)


def gpu_running_median(y, size):
    """The running median along the last axis of Y: at each sample the element of rank SIZE // 2 among the SIZE samples centred on it, the ends
    repeated."""
    y = gpu_dev(y)
    lead, tail = size // 2, size - 1 - size // 2
    shape = y.shape[:-1]
    p = torch.cat([y[..., :1].expand(*shape, lead), y, y[..., -1:].expand(*shape, tail)], -1)
    n = y.shape[-1]
    if gpu_DEVICE.type == "cuda" and 2 * (size - 1) <= 4096 and _gpu_kernels() is not None:
        return _gpu_kernels().running_median_rows(p.reshape(-1, p.shape[-1]).contiguous(), n, size, _gpu_stream()).reshape(y.shape)
    chunk = max(1024, int(gpu_BUDGET / (8 * size * max(int(np.prod(shape)), 1))))
    out = torch.empty_like(y)
    for c0 in range(0, n, chunk):
        c1 = min(c0 + chunk, n)
        out[..., c0:c1] = p[..., c0:c1 + size - 1].unfold(-1, size, 1).kthvalue(size // 2 + 1, dim=-1).values
    return out


def gpu_nanmedian(F, dim=0):
    """The median along DIM over finite values: the mean of the two middle values where their count is even, NaN where there is none."""
    X = gpu_dev(F).movedim(dim, 0)
    fin = torch.isfinite(X)
    n = fin.sum(0)
    S = torch.sort(torch.where(fin, X, torch.full_like(X, float("inf"))), dim=0).values
    lo, hi = torch.clamp((n - 1) // 2, min=0), torch.clamp(n // 2, min=0)
    med = 0.5 * (S.gather(0, lo[None]) + S.gather(0, hi[None]))[0]
    return torch.where(n > 0, med, torch.full_like(med, gpu_NAN))


def gpu_nanmean(F, dim=0):
    """The mean along DIM over finite values."""
    X = gpu_dev(F)
    fin = torch.isfinite(X)
    n = fin.sum(dim)
    s = torch.where(fin, X, torch.zeros_like(X)).sum(dim)
    return torch.where(n > 0, s / n.clamp(min=1), torch.full_like(s, gpu_NAN))


def gpu_nanstd(F, dim=0):
    """The standard deviation along DIM over finite values, no degree of freedom removed."""
    X = gpu_dev(F)
    fin = torch.isfinite(X)
    n = fin.sum(dim)
    m = gpu_nanmean(X, dim)
    d = torch.where(fin, X - m.unsqueeze(dim), torch.zeros_like(X))
    v = (d * d).sum(dim) / n.clamp(min=1)
    return torch.where(n > 0, torch.sqrt(v), torch.full_like(v, gpu_NAN))


def gpu_rowpoly(F, deg=3, least=100):
    """Each row of F divided by a polynomial of degree DEG in x = (i - n/2) / n fitted by least squares over its finite samples, rows of LEAST finite
    samples or fewer left as they are."""
    X = gpu_dev(F)
    n = X.shape[1]
    x = (torch.arange(n, dtype=gpu_F64, device=gpu_DEVICE) - n / 2.0) / n
    V = torch.stack([x ** k for k in range(deg, -1, -1)], 1)
    fin = torch.isfinite(X)
    G = (fin.to(gpu_F64) @ (V[:, :, None] * V[:, None, :]).reshape(n, -1)).reshape(-1, deg + 1, deg + 1)
    b = torch.where(fin, X, torch.zeros_like(X)) @ V
    use = fin.sum(1) > least
    out = X.clone()
    if use.any():
        c = torch.linalg.solve(G[use], b[use][:, :, None])[:, :, 0]
        out[use] = X[use] / (c @ V.T)
    return out


def gpu_sysrem(R, sd, n=3):
    """SysRem (Tamuz et al. 2005) over the residual matrix R: N rank-one systematics, each the product of a per-row and a per-column factor fitted by
    six alternations weighted by each column's scatter SD, taken out of every row, NaN left as it is."""
    R = gpu_dev(R)
    fin = torch.isfinite(R)
    X = torch.where(fin, R, torch.zeros_like(R))
    W = torch.where(fin, 1.0 / torch.clamp(gpu_dev(sd), min=1e-12)[None, :] ** 2, torch.zeros_like(R))
    for _ in range(n):
        a = torch.ones(X.shape[0], dtype=gpu_F64, device=gpu_DEVICE)
        c = torch.zeros(X.shape[1], dtype=gpu_F64, device=gpu_DEVICE)
        for _ in range(6):
            c = (W * X * a[:, None]).sum(0) / torch.clamp((W * a[:, None] ** 2).sum(0), min=1e-30)
            a = (W * X * c[None, :]).sum(1) / torch.clamp((W * c[None, :] ** 2).sum(1), min=1e-30)
        X = X - a[:, None] * c[None, :]
    return torch.where(fin, X, torch.full_like(X, gpu_NAN))


def gpu_xcorr(R, T, sd=None, vmax=300):
    """The inverse-variance cross-correlation of each residual row of R with the template T over -VMAX..VMAX samples, each sample weighted by its
    scatter SD (columns not finite in every row given no weight), normalised by the weighted template's norm over the samples it meets at each lag, so
    that a row of unit noise gives unit scatter: absorption positive; (rows, 2 VMAX + 1)."""
    R, T = gpu_dev(R), gpu_dev(T)
    n = R.shape[1]
    w = 1.0 / gpu_dev(sd) if sd is not None else torch.ones(n, dtype=gpu_F64, device=gpu_DEVICE)
    fin = torch.isfinite(R)
    Wt = torch.where(fin.all(0), w, torch.zeros_like(w))
    X = torch.where(fin, R * w[None, :], torch.zeros_like(R)) * Wt[None, :]
    m = 1 << int(math.ceil(math.log2(2 * n)))
    ft = torch.conj(torch.fft.rfft(T, m))
    den = torch.fft.irfft(torch.fft.rfft(Wt ** 2, m) * torch.conj(torch.fft.rfft(T ** 2, m)), m)
    pick = torch.cat([torch.arange(m - vmax, m, device=gpu_DEVICE), torch.arange(0, vmax + 1, device=gpu_DEVICE)])
    norm = torch.sqrt(torch.clamp(den[pick], min=1e-30))
    rows = max(1, int(gpu_BUDGET / (16 * m)))
    out = torch.empty((R.shape[0], 2 * vmax + 1), dtype=gpu_F64, device=gpu_DEVICE)
    for i0 in range(0, R.shape[0], rows):
        out[i0:i0 + rows] = -torch.fft.irfft(torch.fft.rfft(X[i0:i0 + rows], m) * ft, m)[:, pick] / norm
    return out


def gpu_planet_frame(ccf, vp, w, kp_grid, vrest):
    """Cross-correlation rows summed in the planet's frame: for each trial semi-amplitude K_p and rest velocity, each row read at vrest + K_p VP[k]
    by linear interpolation on its one km/s grid (nothing beyond its ends) and weighted by W[k]; (K_p, rest velocity)."""
    ccf, vp, w, kp, vr = gpu_dev(ccf), gpu_dev(vp), gpu_dev(w), gpu_dev(kp_grid), gpu_dev(vrest)
    vmax = (ccf.shape[1] - 1) // 2
    x = vr[None, None, :] + kp[:, None, None] * vp[None, :, None] + vmax
    j = torch.floor(x).clamp(0, 2 * vmax - 1).long()
    fr = x - j
    r = torch.arange(ccf.shape[0], device=gpu_DEVICE)[None, :, None]
    val = ccf[r, j] * (1.0 - fr) + ccf[r, j + 1] * fr
    val = torch.where((x >= 0) & (x <= 2 * vmax), val, torch.zeros_like(val))
    return (w[None, :, None] * val).sum(1) / max(float(w.sum()), 1e-9)


def gpu_kepler_E(M, e, iterations=16):
    """The eccentric anomaly of mean anomalies M and eccentricities E (broadcast), by Newton's method from M + e sin M (1 + e cos M)."""
    E = M + e * torch.sin(M) * (1 + e * torch.cos(M))
    for _ in range(iterations):
        E = E - (E - e * torch.sin(E) - M) / (1 - e * torch.cos(E))
    return E


_gpu_CUDA = r"""
#include <ATen/ATen.h>
#include <cuda_runtime.h>

__device__ double kepler_E(double t, double P, double tp, double ec) {
    double x = (t - tp) / P;
    double M = 6.283185307179586 * (x - floor(x));
    double E = M + ec * sin(M) * (1.0 + ec * cos(M));
    for (int it = 0; it < 40; ++it) {
        double d = (E - ec * sin(E) - M) / (1.0 - ec * cos(E));
        E -= d;
        if (fabs(d) < 1e-15) break;
    }
    return E;
}

__device__ double kepler_shape(double t, double P, double tp, double ec, double w) {
    double E = kepler_E(t, P, tp, ec);
    double nu = 2.0 * atan2(sqrt(1.0 + ec) * sin(0.5 * E), sqrt(1.0 - ec) * cos(0.5 * E));
    return cos(nu + w) + ec * cos(w);
}

__global__ void keplerian_kernel(const double* t, const double* P, const double* tp, const double* e, const double* w, double* out, long nb, long nt,
                                 long tstride, int shape) {
    long i = (long) blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= nb * nt) return;
    long b = i / nt, k = i % nt;
    double tk = t[b * tstride + k];
    out[i] = shape ? kepler_shape(tk, P[b], tp[b], e[b], w[b]) : kepler_E(tk, P[b], tp[b], e[b]);
}

at::Tensor keplerian_rows(at::Tensor t, at::Tensor P, at::Tensor tp, at::Tensor e, at::Tensor w, int64_t shape, int64_t stream) {
    long nb = P.size(0), nt = t.size(t.dim() - 1);
    long tstride = t.dim() == 2 ? nt : 0;
    auto out = at::empty({nb, nt}, t.options());
    long n = nb * nt;
    if (n > 0) keplerian_kernel<<<(n + 255) / 256, 256, 0, (cudaStream_t) stream>>>(t.data_ptr<double>(), P.data_ptr<double>(), tp.data_ptr<double>(),
                                                                                    e.data_ptr<double>(), w.data_ptr<double>(), out.data_ptr<double>(), nb,
                                                                                    nt, tstride, (int) shape);
    return out;
}

// the census model's residuals: problem q at night k, the linear part plus each Keplerian's |K| shape, less the velocity, over the error, times the mask
__global__ void census_kernel(const double* p, const long long* owner, const double* T, const double* V, const double* S, const double* M,
                              const double* X, double* out, long m, long n, long R, int nl, int nk, int kp) {
    long i = (long) blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= m * n) return;
    long q = i / n, k = i % n, r = (long) owner[q];
    const double* pq = p + q * kp;
    double mod = pq[0] * X[r * n + k];
    for (int j = 1; j < nl; ++j) mod = mod + pq[j] * X[((long) j * R + r) * n + k];
    double t = T[r * n + k];
    for (int c = 0; c < nk; ++c) {
        const double* kq = pq + nl + 5 * c;
        mod = mod + fabs(kq[4]) * kepler_shape(t, kq[0], kq[1], fmin(kq[2] * kq[2] + kq[3] * kq[3], 0.9), atan2(kq[3], kq[2]));
    }
    out[i] = (mod - V[r * n + k]) / S[r * n + k] * M[r * n + k];
}

at::Tensor census_residuals(at::Tensor p, at::Tensor owner, at::Tensor T, at::Tensor V, at::Tensor S, at::Tensor M, at::Tensor X, int64_t nl,
                            int64_t nk, int64_t stream) {
    long m = p.size(0), R = T.size(0), n = T.size(1);
    auto out = at::empty({m, n}, p.options());
    if (m * n > 0) census_kernel<<<(m * n + 255) / 256, 256, 0, (cudaStream_t) stream>>>(p.data_ptr<double>(), (const long long*) owner.data_ptr<int64_t>(),
                                                                                      T.data_ptr<double>(), V.data_ptr<double>(), S.data_ptr<double>(),
                                                                                      M.data_ptr<double>(), X.data_ptr<double>(), out.data_ptr<double>(),
                                                                                      m, n, R, (int) nl, (int) nk, (int) p.size(1));
    return out;
}

// one thread per symmetric positive-definite system: Cholesky in place, then forward and back substitution
__global__ void spd_kernel(double* A, double* x, long nb, int k) {
    long q = (long) blockIdx.x * blockDim.x + threadIdx.x;
    if (q >= nb) return;
    double* a = A + q * k * k;
    double* b = x + q * k;
    for (int j = 0; j < k; ++j) {
        double d = a[j * k + j];
        for (int c = 0; c < j; ++c) d -= a[j * k + c] * a[j * k + c];
        d = sqrt(d);
        a[j * k + j] = d;
        for (int i = j + 1; i < k; ++i) {
            double s = a[i * k + j];
            for (int c = 0; c < j; ++c) s -= a[i * k + c] * a[j * k + c];
            a[i * k + j] = s / d;
        }
    }
    for (int i = 0; i < k; ++i) {
        double s = b[i];
        for (int c = 0; c < i; ++c) s -= a[i * k + c] * b[c];
        b[i] = s / a[i * k + i];
    }
    for (int i = k - 1; i >= 0; --i) {
        double s = b[i];
        for (int c = i + 1; c < k; ++c) s -= a[c * k + i] * b[c];
        b[i] = s / a[i * k + i];
    }
}

at::Tensor spd_solve(at::Tensor A, at::Tensor b, int64_t stream) {
    auto a = A.contiguous().clone();
    auto x = b.contiguous().clone();
    long nb = a.size(0);
    if (nb > 0) spd_kernel<<<(nb + 127) / 128, 128, 0, (cudaStream_t) stream>>>(a.data_ptr<double>(), x.data_ptr<double>(), nb, (int) a.size(1));
    return x;
}

// each block sorts one tile's samples with their positions in shared memory, and each thread walks the sorted list for its window's median
__global__ void running_median_kernel(const double* P, double* out, long n, long width, int size, int tile, int cap) {
    extern __shared__ double smem[];
    double* val = smem;
    int* pos = (int*) (smem + cap);
    long r = blockIdx.y;
    long t0 = (long) blockIdx.x * tile;
    int count = (int) (n - t0 < tile ? n - t0 : tile);
    int len = count + size - 1;
    const double* row = P + r * width + t0;
    for (int i = threadIdx.x; i < cap; i += blockDim.x) {
        double x = i < len ? row[i] : INFINITY;
        val[i] = isnan(x) ? INFINITY : x;
        pos[i] = i < len ? i : 0x7fffffff;
    }
    __syncthreads();
    for (int k = 2; k <= cap; k <<= 1) {
        for (int j = k >> 1; j > 0; j >>= 1) {
            for (int i = threadIdx.x; i < cap; i += blockDim.x) {
                int l = i ^ j;
                if (l > i) {
                    double a = val[i], b = val[l];
                    int pa = pos[i], pb = pos[l];
                    bool greater = a > b || (a == b && pa > pb);
                    if (greater == ((i & k) == 0)) { val[i] = b; val[l] = a; pos[i] = pb; pos[l] = pa; }
                }
            }
            __syncthreads();
        }
    }
    for (int o = threadIdx.x; o < count; o += blockDim.x) {
        int need = size / 2;
        for (int i = 0; i < len; ++i) {
            int p = pos[i];
            if (p >= o && p < o + size) {
                if (need == 0) { out[r * n + t0 + o] = val[i]; break; }
                --need;
            }
        }
    }
}

// each string's FNV-1a hash over its bytes, spaces and tabs dropped and ASCII letters in capitals
__global__ void key_hash_kernel(const unsigned char* data, const long long* offsets, long long* out, long n) {
    long i = (long) blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= n) return;
    unsigned long long h = 14695981039346656037ULL;
    for (long long k = offsets[i]; k < offsets[i + 1]; ++k) {
        unsigned char c = data[k];
        if (c == ' ' || c == '\t') continue;
        if (c >= 'a' && c <= 'z') c -= 32;
        h = (h ^ c) * 1099511628211ULL;
    }
    out[i] = (long long) h;
}

at::Tensor key_hash(at::Tensor data, at::Tensor offsets, int64_t stream) {
    long n = offsets.size(0) - 1;
    auto out = at::empty({n}, offsets.options());
    if (n > 0) key_hash_kernel<<<(n + 255) / 256, 256, 0, (cudaStream_t) stream>>>(data.data_ptr<uint8_t>(), (const long long*) offsets.data_ptr<int64_t>(),
                                                                                (long long*) out.data_ptr<int64_t>(), n);
    return out;
}

at::Tensor running_median_rows(at::Tensor P, int64_t n, int64_t size, int64_t stream) {
    long rows = P.size(0), width = P.size(1);
    int cap = 64;
    while (cap < 2 * (size - 1)) cap <<= 1;
    int tile = cap - (int) (size - 1);
    auto out = at::empty({rows, n}, P.options());
    if (rows > 0 && n > 0) {
        dim3 grid((unsigned) ((n + tile - 1) / tile), (unsigned) rows);
        running_median_kernel<<<grid, 256, cap * (sizeof(double) + sizeof(int)), (cudaStream_t) stream>>>(P.data_ptr<double>(), out.data_ptr<double>(),
                                                                                                        n, width, (int) size, tile, cap);
    }
    return out;
}

// the light of a quadratically limb-darkened disk of radius R, in the unit disk's radius
__device__ float lit_disk(float R, float c0, float c1, float c2) {
    float R2 = R * R, q = fmaxf(1.0f - R2, 0.0f);
    return 3.14159265358979f * (c0 * R2 + c1 * (2.0f / 3.0f) * (1.0f - q * sqrtf(q)) + c2 * (R2 - 0.5f * R2 * R2));
}

// the fraction of the disk's light a disk of radius k at separation z hides, as gpu_occulted computes it: the covered inner disk in closed form and the
// partly covered annuli by Gauss-Legendre over r = r0 + (r1 - r0)(1 - cos psi) / 2, CPSI holding cos psi and SPW sin psi times the weights
__device__ float hidden_light(float z, float k, float u1, float u2, const float* cpsi, const float* spw, int nodes) {
    float c0 = 1.0f - u1 - u2, c1 = u1 + 2.0f * u2, c2 = -u2;
    float zz = fmaxf(z, 1e-9f);
    if (zz <= k - 1.0f) return 1.0f;
    float inner = fminf(fmaxf(k - zz, 0.0f), 1.0f), r0 = fabsf(zz - k), r1 = fminf(zz + k, 1.0f), span = fmaxf(r1 - r0, 0.0f), acc = 0.0f;
    if (r0 < 1.0f) {
        for (int j = 0; j < nodes; ++j) {
            float r = r0 + span * (1.0f - cpsi[j]) * 0.5f;
            float c = (r * r + zz * zz - k * k) / fmaxf(2.0f * r * zz, 1e-12f);
            float mu = sqrtf(fmaxf(1.0f - r * r, 0.0f));
            acc += (c0 + c1 * mu + c2 * mu * mu) * 2.0f * r * acosf(fminf(fmaxf(c, -1.0f), 1.0f)) * span * 0.5f * spw[j];
        }
    }
    return (lit_disk(inner, c0, c1, c2) + acc) / lit_disk(1.0f, c0, c1, c2);
}

// one body (row of PR: k, P, a, inc, ecc, w, u1, u2) at one time, its light averaged over the time's NS instants (TS, time-major), as gpu_transit
// computes it
__global__ void transit_kernel(const float* ts, const float* pr, const float* cpsi, const float* spw, float* out, long nb, long nt, int ns, int nodes) {
    long i = (long) blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= nb * nt) return;
    long b = i / nt, j = i % nt;
    const float* q = pr + b * 8;
    float k = q[0], P = q[1], a = q[2], si = sinf(q[3]), e = q[4], w = q[5], u1 = q[6], u2 = q[7];
    const float twopi = 6.28318530717959f;
    float hp = 1.57079632679490f - w;
    float ea = atan2f(sqrtf(1.0f - e * e) * sinf(hp), e + cosf(hp));
    float base = ea - e * sinf(ea), sum = 0.0f;
    for (int s = 0; s < ns; ++s) {
        float M = fmodf(base + twopi * ts[j * ns + s] / P, twopi);
        if (M < 0.0f) M += twopi;
        float E = M + e * sinf(M) * (1.0f + e * cosf(M));
        for (int it = 0; it < 12; ++it) E = E - (E - e * sinf(E) - M) / (1.0f - e * cosf(E));
        float ta = 2.0f * atan2f(sqrtf(1.0f + e) * sinf(0.5f * E), sqrtf(1.0f - e) * cosf(0.5f * E));
        float sn = sinf(w + ta);
        float z = a * (1.0f - e * e) / (1.0f + e * cosf(ta)) * sqrtf(fmaxf(1.0f - sn * sn * si * si, 0.0f));
        z = sn > 0.0f ? z : -z;
        sum += (z >= 0.0f && z < 1.0f + k) ? 1.0f - hidden_light(z, k, u1, u2, cpsi, spw, nodes) : 1.0f;
    }
    out[i] = sum / ns;
}

at::Tensor transit_rows(at::Tensor ts, at::Tensor pr, at::Tensor cpsi, at::Tensor spw, int64_t ns, int64_t stream) {
    long nb = pr.size(0), nt = ts.size(0) / ns;
    auto out = at::empty({nb, nt}, ts.options());
    long n = nb * nt;
    if (n > 0) transit_kernel<<<(n + 255) / 256, 256, 0, (cudaStream_t) stream>>>(ts.data_ptr<float>(), pr.data_ptr<float>(), cpsi.data_ptr<float>(),
                                                                                spw.data_ptr<float>(), out.data_ptr<float>(), nb, nt, (int) ns,
                                                                                (int) cpsi.size(0));
    return out;
}
"""

_gpu_kernel_module = []


def _gpu_msvc_environment():
    """The Visual C++ build environment taken into this process from vcvars64.bat where cl is not already on the path, for the CUDA kernels' first
    build on Windows."""
    if os.name != "nt" or shutil.which("cl"):
        return
    root = os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)")
    found = subprocess.run([os.path.join(root, "Microsoft Visual Studio", "Installer", "vswhere.exe"), "-latest", "-products", "*", "-property",
                            "installationPath"], capture_output=True, text=True).stdout.strip()
    bat = os.path.join(found, "VC", "Auxiliary", "Build", "vcvars64.bat")
    text = subprocess.run('"%s" >nul && set' % bat, capture_output=True, text=True, shell=True).stdout
    for line in text.splitlines():
        if "=" in line:
            key, val = line.split("=", 1)
            os.environ[key] = val


def _gpu_kernels():
    """The compiled kernels, the Keplerian curves, the census residuals, the positive-definite solves, the running medians, the identifier hashes and
    the transit light curves, built once and cached by torch, or None where there is no CUDA device or no compiler."""
    if not _gpu_kernel_module:
        mod = None
        if gpu_DEVICE.type == "cuda":
            try:
                from torch.utils.cpp_extension import load_inline
                _gpu_msvc_environment()
                os.environ.setdefault("TORCH_CUDA_ARCH_LIST", "%d.%d" % torch.cuda.get_device_capability())
                decl = ("torch::Tensor keplerian_rows(torch::Tensor t, torch::Tensor P, torch::Tensor tp, torch::Tensor e, torch::Tensor w, int64_t shape, "
                        "int64_t stream);\ntorch::Tensor census_residuals(torch::Tensor p, torch::Tensor owner, torch::Tensor T, torch::Tensor V, "
                        "torch::Tensor S, torch::Tensor M, torch::Tensor X, int64_t nl, int64_t nk, int64_t stream);\ntorch::Tensor spd_solve(torch::Tensor A, "
                        "torch::Tensor b, int64_t stream);\ntorch::Tensor running_median_rows(torch::Tensor P, int64_t n, int64_t size, int64_t stream);\n"
                        "torch::Tensor key_hash(torch::Tensor data, torch::Tensor offsets, int64_t stream);\ntorch::Tensor transit_rows(torch::Tensor ts, "
                        "torch::Tensor pr, torch::Tensor cpsi, torch::Tensor spw, int64_t ns, int64_t stream);")
                mod = load_inline(name="orbitlight_kernels4", cpp_sources=decl, cuda_sources=_gpu_CUDA, extra_cuda_cflags=["-O3"], verbose=False,
                                  functions=["keplerian_rows", "census_residuals", "spd_solve", "running_median_rows", "key_hash", "transit_rows"])
            except Exception:
                mod = None
        _gpu_kernel_module.append(mod)
    return _gpu_kernel_module[0]


def _gpu_stream():
    """The current CUDA stream's handle, on which the compiled kernels launch."""
    return torch.cuda.current_stream().cuda_stream


def _gpu_kernel_rows(t, P, tp, e, w, shape):
    """The compiled kernel for one orbit per row (b, 1) at times shared by every orbit (1, n) or of its own (b, n): the shape cos(nu + w) + e cos w,
    or with SHAPE false the eccentric anomaly; None where the kernel does not apply."""
    if t.dim() == 2 and P.dim() == 2 and P.shape[1] == 1 and _gpu_kernels() is not None:
        b = max(P.shape[0], tp.shape[0], e.shape[0], w.shape[0], t.shape[0])
        if t.shape[0] in (1, b) and all(z.dim() == 2 and z.shape[1] == 1 for z in (tp, e, w)):
            args = [z.reshape(-1).expand(b).contiguous() for z in (P, tp, e, w)]
            return _gpu_kernels().keplerian_rows(t[0].contiguous() if t.shape[0] == 1 else t.contiguous(), *args, int(shape), _gpu_stream())
    return None


def gpu_anomaly(t, P, tp, e):
    """The eccentric anomaly at times T of orbits (P, tp, e), each broadcast against T."""
    t, P, tp, e = (gpu_dev(z) for z in (t, P, tp, e))
    E = _gpu_kernel_rows(t, P, tp, e, torch.zeros_like(P), False)
    if E is not None:
        return E
    return gpu_kepler_E(2 * math.pi * torch.remainder((t - tp) / P, 1.0), e)


def gpu_keplerian(t, P, tp, e, w):
    """The unit Keplerian velocity curve cos(nu + w) + e cos w at times T for orbits (P, tp, e, w), each broadcast against T."""
    t, P, tp, e, w = (gpu_dev(z) for z in (t, P, tp, e, w))
    out = _gpu_kernel_rows(t, P, tp, e, w, True)
    if out is not None:
        return out
    E = gpu_kepler_E(2 * math.pi * torch.remainder((t - tp) / P, 1.0), e)
    nu = 2 * torch.atan2(torch.sqrt(1 + e) * torch.sin(E / 2), torch.sqrt(1 - e) * torch.cos(E / 2))
    return torch.cos(nu + w) + e * torch.cos(w)


def gpu_gls(t, y, dy=None, freqs=None, chunk=None):
    """The generalised Lomb-Scargle periodogram (Zechmeister and Kuerster 2009) with a floating mean, in the standard normalisation: at each frequency
    the share of the weighted variance about the weighted mean that a sinusoid takes out. Y may hold many series at the times T as rows (b, n); the
    power is (b, frequencies), or (frequencies,) for one series."""
    t, Y = gpu_dev(t), gpu_dev(y)
    one = Y.dim() == 1
    Y = Y[None, :] if one else Y
    w = torch.ones_like(t) if dy is None else 1.0 / gpu_dev(dy) ** 2
    w = w / w.sum()
    f = gpu_dev(freqs)
    Yb = Y @ w
    Yc = Y - Yb[:, None]
    YY = (Yc * Yc) @ w
    chunk = chunk or max(1, int(gpu_BUDGET / (8 * 4 * len(t))))
    out = torch.empty((Y.shape[0], len(f)), dtype=gpu_F64, device=gpu_DEVICE)
    tc = t - t.mean()
    for i0 in range(0, len(f), chunk):
        ph = 2 * math.pi * f[i0:i0 + chunk, None] * tc[None, :]
        c, s = torch.cos(ph), torch.sin(ph)
        C, S = c @ w, s @ w
        CC = (c * c) @ w - C * C
        SS = (s * s) @ w - S * S
        CS = (c * s) @ w - C * S
        YC = (Yc * w[None, :]) @ c.T
        YS = (Yc * w[None, :]) @ s.T
        D = CC * SS - CS * CS
        out[:, i0:i0 + chunk] = (SS[None, :] * YC ** 2 + CC[None, :] * YS ** 2 - 2 * CS[None, :] * YC * YS) / (YY[:, None] * D[None, :])
    return out[0] if one else out


def gpu_baluev(z, fmax, t, dy=None):
    """Baluev's (2008) false-alarm level of the highest peak Z of a standard-normalised generalised Lomb-Scargle periodogram searched up to FMAX: the
    single-frequency level joined to the Davies bound's expected number of upcrossings."""
    from scipy.special import gammaln
    t = np.asarray(t, float)
    w = np.ones_like(t) if dy is None else np.asarray(dy, float) ** -2
    w = w / w.sum()
    n = len(t)
    nh, nk = n - 1, n - 3
    z = np.clip(np.asarray(z, float), 0.0, 1.0)
    single = (1.0 - z) ** (0.5 * nk)
    teff = math.sqrt(4 * math.pi * (np.dot(w, t ** 2) - np.dot(w, t) ** 2))
    gam = math.sqrt(2.0 / nh) * math.exp(gammaln(nh / 2.0) - gammaln((nh - 1) / 2.0))
    tau = fmax * teff * gam * (1.0 - z) ** (0.5 * (nk - 1)) * np.sqrt(0.5 * nh * z)
    # 1 - (1 - single) exp(-tau)
    return -np.expm1(-tau) + single * np.exp(-tau)


def gpu_baluev_level(fap, fmax, t, dy=None):
    """The power at which gpu_baluev() gives the false-alarm level FAP, by bisection."""
    lo, hi = 0.0, 1.0
    for _ in range(100):
        mid = 0.5 * (lo + hi)
        lo, hi = (mid, hi) if float(gpu_baluev(mid, fmax, t, dy)) > fap else (lo, mid)
    return 0.5 * (lo + hi)


def gpu_gls_fit(t, y, dy, f):
    """The floating-mean sinusoid at frequency F fitted to Y by weighted least squares: (offset, cosine and sine amplitudes)."""
    t, y = np.asarray(t, float), np.asarray(y, float)
    w = np.ones_like(t) if dy is None else np.asarray(dy, float) ** -2
    X = np.column_stack([np.ones_like(t), np.cos(2 * np.pi * f * t), np.sin(2 * np.pi * f * t)]) * np.sqrt(w)[:, None]
    return np.linalg.lstsq(X, y * np.sqrt(w), rcond=None)[0]


def gpu_solve_spd(A, b):
    """The solutions x of the symmetric positive-definite systems A x = b, A (m, k, k) and b (m, k): Cholesky in the compiled kernel on the GPU, torch's
    solver elsewhere."""
    if A.is_cuda and _gpu_kernels() is not None:
        return _gpu_kernels().spd_solve(A, b, _gpu_stream())
    return torch.linalg.solve(A, b[:, :, None])[:, :, 0]


def gpu_lm(fun, p0, lo=None, hi=None, f_scale=None, iters=200, tol=1e-10, graph=False):
    """Least squares for many problems by Levenberg-Marquardt: FUN maps parameter rows (m, k) and the problem each belongs to (m,) to
    residuals (m, n), a problem's unused residuals zero; P0 (b, k) the starts; LO and HI (k,) or (b, k) bounds, every step projected into them and a
    parameter on a bound whose gradient points out of the box held there for the step; F_SCALE, where given, the soft L1 loss rho(z) = 2 (sqrt(1 + z)
    - 1) on (r / F_SCALE)^2 by iteratively reweighted steps. The Jacobian by central differences. A problem stops once a step improves its cost by less
    than TOL of it or no damping finds a better point. With GRAPH, on the GPU, every problem takes each step, those stopped left as they are, one step
    is captured as a CUDA graph and replayed, and the problems' state is read every ten steps; FUN must then launch device work alone. Returns the
    parameters (b, k) and each problem's sum of squared residuals at them, F_SCALE's loss applied where given."""
    p0 = gpu_dev(p0)
    b, k = p0.shape
    lo = gpu_dev(lo).expand(b, k) if lo is not None else torch.full_like(p0, -float("inf"))
    hi = gpu_dev(hi).expand(b, k) if hi is not None else torch.full_like(p0, float("inf"))
    p = torch.minimum(torch.maximum(p0, lo), hi)

    def cost(r):
        if f_scale is None:
            return (r * r).sum(1)
        z = (r / f_scale) ** 2
        return (2.0 * f_scale ** 2 * (torch.sqrt(1.0 + z) - 1.0)).sum(1)
    every = torch.arange(b, device=gpu_DEVICE)
    r = fun(p, every)
    c = cost(r)
    mu = torch.full((b,), 1e-3, dtype=gpu_F64, device=gpu_DEVICE)
    active = torch.ones(b, dtype=torch.bool, device=gpu_DEVICE)
    if graph and gpu_DEVICE.type == "cuda":
        rows = every.repeat_interleave(2 * k)

        def step():
            h = 1e-7 * (1.0 + p.abs())
            up = torch.minimum(p + h, hi)
            dn = torch.maximum(p - h, lo)
            steps = torch.cat([p[:, None, :] + torch.diag_embed(up - p), p[:, None, :] + torch.diag_embed(dn - p)], 1)
            rr = fun(steps.reshape(-1, k), rows).reshape(b, 2 * k, -1)
            J = ((rr[:, :k] - rr[:, k:]) / (up - dn).clamp(min=1e-300)[:, :, None]).transpose(1, 2)
            sw = torch.ones_like(r) if f_scale is None else (1.0 + (r / f_scale) ** 2) ** -0.25
            Jw, rw = J * sw[:, :, None], r * sw
            g = (Jw.transpose(1, 2) @ rw[:, :, None])[:, :, 0]
            held = ((p <= lo) & (g > 0)) | ((p >= hi) & (g < 0))
            Jw = Jw * (~held)[:, None, :]
            g = torch.where(held, torch.zeros_like(g), g)
            A = Jw.transpose(1, 2) @ Jw
            D = torch.diagonal(A, dim1=1, dim2=2).clamp(min=1e-30)
            A = A + torch.diag_embed(held.to(gpu_F64))
            pn = torch.minimum(torch.maximum(p - gpu_solve_spd(A + mu[:, None, None] * torch.diag_embed(D), g), lo), hi)
            rn = fun(pn, every)
            cn = cost(rn)
            better = active & torch.isfinite(cn) & (cn < c)
            small = better & ((c - cn) <= tol * c.clamp(min=1e-30))
            p.copy_(torch.where(better[:, None], pn, p))
            r.copy_(torch.where(better[:, None], rn, r))
            c.copy_(torch.where(better, cn, c))
            mu.copy_(torch.where(active, torch.where(better, mu / 3.0, mu * 4.0).clamp(1e-12, 1e12), mu))
            active.copy_(active & ~(small | (mu >= 1e12)))
        side = torch.cuda.Stream()
        side.wait_stream(torch.cuda.current_stream())
        cap = torch.cuda.CUDAGraph()
        with torch.cuda.stream(side):
            step()
            cap.capture_begin()
            step()
            cap.capture_end()
        torch.cuda.current_stream().wait_stream(side)
        for it in range(1, iters):
            cap.replay()
            if it % 10 == 0 and not bool(active.any()):
                break
        return p, c
    for _ in range(iters):
        ia = torch.nonzero(active)[:, 0]
        pa, ra, ca, ma = p[ia], r[ia], c[ia], mu[ia]
        na = len(ia)
        la, ha = lo[ia], hi[ia]
        # central differences, one-sided at a bound
        h = 1e-7 * (1.0 + pa.abs())
        up = torch.minimum(pa + h, ha)
        dn = torch.maximum(pa - h, la)
        steps = torch.cat([pa[:, None, :] + torch.diag_embed(up - pa), pa[:, None, :] + torch.diag_embed(dn - pa)], 1)
        rr = fun(steps.reshape(-1, k), ia.repeat_interleave(2 * k)).reshape(na, 2 * k, -1)
        J = ((rr[:, :k] - rr[:, k:]) / (up - dn).clamp(min=1e-300)[:, :, None]).transpose(1, 2)
        # the soft L1 loss as weights on the residuals and the Jacobian, rho'(z)^(1/2) = (1 + z)^(-1/4)
        sw = torch.ones_like(ra) if f_scale is None else (1.0 + (ra / f_scale) ** 2) ** -0.25
        Jw, rw = J * sw[:, :, None], ra * sw
        g = (Jw.transpose(1, 2) @ rw[:, :, None])[:, :, 0]
        # a parameter on a bound whose descent would leave the box is held there for this step
        held = ((pa <= la) & (g > 0)) | ((pa >= ha) & (g < 0))
        Jw = Jw * (~held)[:, None, :]
        g = torch.where(held, torch.zeros_like(g), g)
        A = Jw.transpose(1, 2) @ Jw
        D = torch.diagonal(A, dim1=1, dim2=2).clamp(min=1e-30)
        A = A + torch.diag_embed(held.to(gpu_F64))
        pn = pa - gpu_solve_spd(A + ma[:, None, None] * torch.diag_embed(D), g)
        pn = torch.minimum(torch.maximum(pn, la), ha)
        rn = fun(pn, ia)
        cn = cost(rn)
        better = torch.isfinite(cn) & (cn < ca)
        small = better & ((ca - cn) <= tol * ca.clamp(min=1e-30))
        p[ia] = torch.where(better[:, None], pn, pa)
        r[ia] = torch.where(better[:, None], rn, ra)
        c[ia] = torch.where(better, cn, ca)
        mu[ia] = torch.where(better, ma / 3.0, ma * 4.0).clamp(1e-12, 1e12)
        active[ia] = ~(small | (mu[ia] >= 1e12))
        if not bool(active.any()):
            break
    return p, c


def gpu_ensemble(logp, p0, steps, thin=10, seed=11, graph=False):
    """Ensemble MCMC on the device by differential-evolution moves (ter Braak 2006), one half of the walkers moved against the other: LOGP maps rows (b, d)
    to log-probabilities, P0 (walkers, d) starts the chain, and with GRAPH each step is a replayed CUDA graph. Returns every THIN-th step and each
    walker's acceptance fraction."""
    x = gpu_dev(p0).clone()
    W, d = x.shape
    halves = (torch.arange(W // 2, device=gpu_DEVICE), torch.arange(W // 2, W, device=gpu_DEVICE))
    lp = logp(x)
    g0 = torch.full((1,), 2.38 / math.sqrt(2.0 * d), dtype=gpu_F64, device=gpu_DEVICE)
    one = torch.ones(1, dtype=gpu_F64, device=gpu_DEVICE)
    torch.manual_seed(seed)
    chain = torch.empty(((steps + thin - 1) // thin, W, d), dtype=gpu_F64, device=gpu_DEVICE)
    moved = torch.zeros(W, dtype=gpu_F64, device=gpu_DEVICE)
    at = torch.zeros(1, dtype=torch.long, device=gpu_DEVICE)

    def step():
        for a, b in (halves, halves[::-1]):
            na, nb = len(a), len(b)
            j = torch.randint(0, nb, (na,), device=gpu_DEVICE)
            k = (j + torch.randint(1, nb, (na,), device=gpu_DEVICE)) % nb
            xb = x[b]
            gamma = torch.where(torch.rand(1, dtype=gpu_F64, device=gpu_DEVICE) < 0.1, one, g0)
            prop = x[a] + gamma * (1.0 + 1e-5 * torch.randn((na, 1), dtype=gpu_F64, device=gpu_DEVICE)) * (xb[j] - xb[k])
            lq = logp(prop)
            take = torch.log(torch.rand(na, dtype=gpu_F64, device=gpu_DEVICE)) < lq - lp[a]
            x[a] = torch.where(take[:, None], prop, x[a])
            lp[a] = torch.where(take, lq, lp[a])
            moved[a] += take.to(gpu_F64)
        # each block of THIN steps writes one row, its last state kept
        chain.index_copy_(0, torch.div(at, thin, rounding_mode="floor"), x[None])
        at.add_(1)
    if graph and gpu_DEVICE.type == "cuda":
        side = torch.cuda.Stream()
        side.wait_stream(torch.cuda.current_stream())
        cap = torch.cuda.CUDAGraph()
        with torch.cuda.stream(side):
            step()
            cap.capture_begin()
            step()
            cap.capture_end()
        torch.cuda.current_stream().wait_stream(side)
        for _ in range(steps - 1):
            cap.replay()
    else:
        for _ in range(steps):
            step()
    return gpu_host(chain), gpu_host(moved / steps)


def gpu_profile(logp, lo, hi, index, edges, pop=64, gens=1500, seeds=(7, 11, 13, 17)):
    """A log-probability's profile over one parameter: for each band of parameter INDEX between consecutive EDGES, the others within LO and HI, the best
    of LOGP (rows (b, d) to log-probabilities on the device) found by differential evolution run for every band at once, POP members a band for GENS
    generations (rand/1, crossover 0.9, the scale drawn from 0.5 to 1 each generation) from each of SEEDS, the better kept; then each band takes its
    neighbours' best parameters, moved into the band, wherever they fit better, until none improves. Returns each band's best log-probability and its
    parameters."""
    G, d = len(edges) - 1, len(lo)
    LOb, HIb = gpu_dev(np.tile(lo, (G, 1))), gpu_dev(np.tile(hi, (G, 1)))
    LOb[:, index], HIb[:, index] = gpu_dev(edges[:-1]), gpu_dev(edges[1:])
    rows = torch.arange(G, device=gpu_DEVICE)[:, None]
    cols = torch.arange(d, device=gpu_DEVICE)
    fb, xb = None, None
    for seed in seeds:
        gen = torch.Generator(device=gpu_DEVICE)
        gen.manual_seed(seed)
        x = LOb[:, None, :] + (HIb - LOb)[:, None, :] * torch.rand((G, pop, d), generator=gen, dtype=gpu_F64, device=gpu_DEVICE)
        f = logp(x.reshape(-1, d)).reshape(G, pop)
        for _ in range(gens):
            r = torch.randint(0, pop, (3, G, pop), generator=gen, device=gpu_DEVICE)
            scale = 0.5 + 0.5 * torch.rand(1, generator=gen, dtype=gpu_F64, device=gpu_DEVICE)
            v = x[rows, r[0]] + scale * (x[rows, r[1]] - x[rows, r[2]])
            cross = (torch.rand((G, pop, d), generator=gen, dtype=gpu_F64, device=gpu_DEVICE) < 0.9) | (cols == torch.randint(0, d, (G, pop, 1), generator=gen,
                                                                                                                             device=gpu_DEVICE))
            trial = torch.minimum(torch.maximum(torch.where(cross, v, x), LOb[:, None, :]), HIb[:, None, :])
            ft = logp(trial.reshape(-1, d)).reshape(G, pop)
            better = ft > f
            x, f = torch.where(better[..., None], trial, x), torch.where(better, ft, f)
        k = f.argmax(1)
        fs, xs = f[rows[:, 0], k], x[rows[:, 0], k]
        if fb is None:
            fb, xb = fs, xs
        else:
            keep = fs > fb
            fb, xb = torch.where(keep, fs, fb), torch.where(keep[:, None], xs, xb)
    # Each band then tries its neighbours' best parameters, moved into the band, keeping them where they fit better, until no band improves.
    inner = torch.arange(G, device=gpu_DEVICE)
    for _ in range(4 * G):
        moved = False
        for shift in (1, -1):
            cand = torch.minimum(torch.maximum(torch.roll(xb, shift, 0), LOb), HIb)
            fc = logp(cand)
            ok = (fc > fb) & ((inner >= 1) if shift == 1 else (inner <= G - 2))
            xb, fb = torch.where(ok[:, None], cand, xb), torch.where(ok, fc, fb)
            moved = moved or bool(ok.any())
        if not moved:
            break
    return gpu_host(fb), gpu_host(xb)


def gpu_bls(t, y, dy, periods, durations, oversample=10):
    """Box least squares (Kovacs et al. 2002) on the device: at each trial period, the box of DURATIONS no longer than a quarter of the period and the
    phase with the highest depth over error, the periods taken in blocks and each block's phase cut into bins of 1/OVERSAMPLE of the shortest
    duration. Returns its signal-to-noise, depth, duration and mid-transit time per period."""
    t, y, P = gpu_dev(t), gpu_dev(y), gpu_dev(periods)
    Ph = np.asarray(periods, float)
    w = 1.0 / gpu_dev(dy) ** 2
    W, WY, t0 = w.sum(), (w * y).sum(), t.min()
    step = min(durations) / oversample
    best = [torch.full((len(P),), -float("inf"), dtype=gpu_F64, device=gpu_DEVICE)] + [torch.zeros(len(P), dtype=gpu_F64, device=gpu_DEVICE) for _ in range(3)]
    c0 = 0
    while c0 < len(P):
        chunk = max(1, int(gpu_BUDGET / (48 * max(len(t), 2 * int(math.ceil(Ph[c0] / step))))))
        nb = max(2, int(math.ceil(float(Ph[c0:c0 + chunk].max()) / step)))
        chunk = max(1, min(chunk, int(gpu_BUDGET / (48 * max(len(t), 2 * nb)))))
        Pc = P[c0:c0 + chunk]
        bins = torch.clamp((torch.remainder((t[None, :] - t0) / Pc[:, None], 1.0) * nb).long(), max=nb - 1)
        Wb = torch.zeros((len(Pc), nb), dtype=gpu_F64, device=gpu_DEVICE).scatter_add_(1, bins, w.expand(len(Pc), -1))
        Yb = torch.zeros((len(Pc), nb), dtype=gpu_F64, device=gpu_DEVICE).scatter_add_(1, bins, (w * y).expand(len(Pc), -1))
        del bins
        width = Pc / nb
        fits = [D for D in durations if D <= 0.25 * float(Ph[c0:c0 + chunk].min())]
        Ls = [torch.clamp(torch.round(D / width).long(), min=1, max=nb - 1) for D in fits]
        # cumulative sums with the first bins repeated as far as the longest box reaches, for boxes that wrap past phase one
        Lmax = max([int(L.max()) for L in Ls] + [1])
        zero = torch.zeros((len(Pc), 1), dtype=gpu_F64, device=gpu_DEVICE)
        Wc = torch.cat([zero, torch.cumsum(torch.cat([Wb, Wb[:, :Lmax]], 1), 1)], 1)
        Yc = torch.cat([zero, torch.cumsum(torch.cat([Yb, Yb[:, :Lmax]], 1), 1)], 1)
        for D, L in zip(fits, Ls):
            idx = torch.arange(nb, device=gpu_DEVICE)[None, :] + L[:, None]
            Win, Yin = Wc.gather(1, idx) - Wc[:, :nb], Yc.gather(1, idx) - Yc[:, :nb]
            Wout = W - Win
            ok = (Win > 0) & (Wout > 0)
            Wi, Wo = Win.clamp(min=1e-300), Wout.clamp(min=1e-300)
            depth = (WY - Yin) / Wo - Yin / Wi
            snr = torch.where(ok, depth / torch.sqrt(1.0 / Wi + 1.0 / Wo), torch.full_like(depth, -float("inf")))
            top, s = snr.max(1)
            up = top > best[0][c0:c0 + chunk]
            best[0][c0:c0 + chunk] = torch.where(up, top, best[0][c0:c0 + chunk])
            best[1][c0:c0 + chunk] = torch.where(up, depth.gather(1, s[:, None])[:, 0], best[1][c0:c0 + chunk])
            best[2][c0:c0 + chunk] = torch.where(up, torch.full_like(top, D), best[2][c0:c0 + chunk])
            best[3][c0:c0 + chunk] = torch.where(up, t0 + (s + 0.5 * L) * width, best[3][c0:c0 + chunk])
        c0 += len(Pc)
    return tuple(gpu_host(x) for x in best)


# The spectra machinery the modes share: loading, grids, residuals, cross-correlation, the planet's frame and line-by-line velocities.

# the speed of light (km/s)
spectra_C = 299792.458

spectra_BANDS = {"optical": dict(lo=3800.0, hi=7880.0, telluric=((6270.0, 6330.0), (6440.0, 6620.0), (6860.0, 6970.0), (7150.0, 7360.0), (7580.0, 7720.0)),
                                instruments=("ESPRESSO", "HARPS", "UVES", "FEROS", "SOPHIE", "HARPN")),
                "nir": dict(lo=9500.0, hi=25000.0, telluric=((11050.0, 11700.0), (13300.0, 14900.0), (17900.0, 19700.0), (24000.0, 25000.0)),
                            instruments=("SPIRou", "NIRPS", "CRIRES", "NIRSPEC")),
                # the solar mode's span, for templates alone
                "visible": dict(lo=3800.0, hi=9500.0, telluric=((6270.0, 6330.0), (6440.0, 6620.0), (6860.0, 6970.0), (7150.0, 7360.0), (7580.0, 7720.0)),
                                instruments=())}

spectra_SKY = (5889.95, 5895.92)
spectra_GRIDS = {}

# the errors a missing, truncated or malformed FITS product raises, which skip the spectrum; any other error stops the run
spectra_UNREADABLE = (OSError, ValueError, KeyError, IndexError, TypeError)


def spectra_band(inst):
    """The band an instrument's spectra belong to."""
    return next(b for b, d in spectra_BANDS.items() if inst in d["instruments"])


def spectra_grid(band="optical"):
    """A band's common wavelength grid (A, air), uniform in velocity at 1 km/s."""
    if band not in spectra_GRIDS:
        lo, hi = spectra_BANDS[band]["lo"], spectra_BANDS[band]["hi"]
        n = int(np.log(hi / lo) * spectra_C)
        spectra_GRIDS[band] = lo * np.exp(np.arange(n) / spectra_C)
    return spectra_GRIDS[band]


def spectra_gaps(g, wl):
    """The grid samples G whose nearest valid pixels WL on either side lie more than 3 km/s apart, where interpolation would stand in for missing data, as across the gap between two detectors."""
    j = np.clip(np.searchsorted(wl, g), 1, len(wl) - 1)
    return (wl[j] / wl[j - 1] - 1.0) * spectra_C > 3.0


def spectra_onto(items, grid, size=501, clean_errors=False, dtype=float):
    """Spectra, each (wl, f, e) at wavelengths WL, read on GRID by linear interpolation over their samples of positive finite flux (with CLEAN_ERRORS, of
    positive finite error too) and divided by their running medians over SIZE samples (gpu_running_median), gaps given each spectrum's median: the
    fluxes and errors on the grid as rows of DTYPE, the errors None where E is, and the wavelengths each read."""
    F, E, used = np.full((len(items), len(grid)), np.nan, dtype), None, []
    if items and items[0][2] is not None:
        E = np.full((len(items), len(grid)), np.nan, dtype)
    step = max(1, int(gpu_BUDGET // (64 * len(grid))))
    for b0 in range(0, len(items), step):
        xs, fs, es = [], [], []
        for wl, f, e in items[b0:b0 + step]:
            ok = np.isfinite(f) & (f > 0)
            if clean_errors:
                ok &= np.isfinite(e) & (e > 0)
            xs.append(wl[ok])
            fs.append(f[ok])
            es.append(e[ok] if E is not None else None)
        used += xs
        FI = gpu_interp_rows(grid, xs, fs)
        cont = gpu_running_median(torch.where(torch.isfinite(FI), FI, gpu_nanmedian(FI, 1)[:, None]), size)
        F[b0:b0 + len(xs)] = gpu_host(FI / cont)
        if E is not None:
            E[b0:b0 + len(xs)] = gpu_host(gpu_interp_rows(grid, xs, es) / cont)
    return F, E, used


def spectra_normalise(F, ref, band, E=None):
    """Rows on a band's grid divided by the median of the rows REF marks, the near-infrared's deep bands set aside, a cubic in wavelength divided out
    of each row and the telluric bands set aside, less one: the residuals, each wavelength's scatter among the REF rows floored at a tenth of its
    median, the errors E divided by the same median where given, and the median, as tensors."""
    g = gpu_dev(spectra_grid(band))
    master = gpu_nanmedian(F[ref], 0)
    R = F / master
    if band == "nir":
        # the near infrared's telluric bands and the samples where the median lies at 0.2 or below set aside before the fit
        R[:, ~(master > 0.2)] = gpu_NAN
        for lo, hi in spectra_BANDS[band]["telluric"]:
            R[:, (g > lo) & (g < hi)] = gpu_NAN
    R = gpu_rowpoly(R, 3)
    for lo, hi in spectra_BANDS[band]["telluric"]:
        R[:, (g > lo) & (g < hi)] = gpu_NAN
    R = R - 1.0
    # each wavelength's scatter, the weight of the inverse-variance cross-correlation, floored at a tenth of its median
    sd = gpu_nanstd(R[ref], 0)
    floor = gpu_nanmedian(sd, 0)
    sd = torch.where(torch.isfinite(sd) & (sd > 0), torch.maximum(sd, 0.1 * floor), floor)
    return R, sd, (E / master if E is not None else None), master


def spectra_sysrem(R, sd, n=3):
    """SysRem (Tamuz et al. 2005) over the residual matrix: N rank-one systematics, each the product of a per-spectrum and a per-wavelength factor fitted by alternation weighted by each wavelength's scatter SD, taken out of every spectrum, NaN left as it is."""
    return gpu_host(gpu_sysrem(R, sd, n))


def spectra_ccf(R, T, sd=None, vmax=300):
    """Inverse-variance cross-correlation of each residual row with a template over -VMAX..VMAX km/s (one sample a km/s on the grid), each sample weighted by its scatter SD, the sum normalised by the weighted template's norm so a row of unit noise gives unit scatter: absorption positive."""
    return gpu_host(gpu_xcorr(R, T, sd, vmax))


def lbl_lines(T, good):
    """A template's lines on the 0.4 km/s grid: its minima 4 per cent deep or more, each over the samples within 1.2 times its half-depth width, where
    GOOD holds over the whole window and no earlier line overlaps it: (start, end, minimum) per line."""
    lines = []
    for m in np.where((T[1:-1] < T[:-2]) & (T[1:-1] <= T[2:]) & (T[1:-1] < 0.96))[0] + 1:
        half = 1.0 - (1.0 - T[m]) / 2.0
        lft, rgt = m, m
        while lft > 0 and T[lft] < half and m - lft < 40:
            lft -= 1
        while rgt < len(T) - 1 and T[rgt] < half and rgt - m < 40:
            rgt += 1
        hw = max(m - lft, rgt - m)
        l0, r0 = m - int(1.2 * hw) - 1, m + int(1.2 * hw) + 2
        if l0 < 0 or r0 > len(T) or not good[l0:r0].all() or (lines and l0 < lines[-1][1]):
            continue
        lines.append((l0, r0, m))
    return np.array(lines, int).reshape(-1, 3)


def lbl_shifts(F, E, T, lines, chunk=512):
    """Each spectrum's shift in each line (m/s) by Bouchy's derivative estimate, the residual against the template T projected on its derivative with the
    line's own linear continuum solved beside it, with its photon error, in blocks of CHUNK lines: (V, SV), (spectra, lines), NaN where a line's
    equations are singular."""
    dT = gpu_dev(np.gradient(T))
    Td, Fd, Ed = gpu_dev(T), gpu_dev(F), gpu_dev(E)
    S, L = Fd.shape[0], len(lines)
    V = torch.full((S, L), gpu_NAN, dtype=gpu_F64, device=gpu_DEVICE)
    SV = torch.full((S, L), gpu_NAN, dtype=gpu_F64, device=gpu_DEVICE)
    for c0 in range(0, L, chunk):
        ln = lines[c0:c0 + chunk]
        width = ln[:, 1] - ln[:, 0]
        W = int(width.max())
        k = torch.arange(W, device=gpu_DEVICE)
        l0, wd = torch.as_tensor(ln[:, 0], device=gpu_DEVICE), torch.as_tensor(width, device=gpu_DEVICE)
        inside = (k[None, :] < wd[:, None]).to(gpu_F64)
        idx = (l0[:, None] + k[None, :]).clamp(max=len(T) - 1)
        A = torch.stack([-dT[idx], torch.ones_like(inside), k[None, :].to(gpu_F64) - wd[:, None] / 2.0], -1) * inside[..., None]
        resid = (Fd[:, idx] - Td[idx][None]) * inside[None]
        wt = inside[None] / torch.clamp(Ed[:, idx], min=1e-4) ** 2
        N = torch.einsum("slw,lwp,lwq->slpq", wt, A, A)
        b = torch.einsum("slw,lwp,slw->slp", wt, A, resid)
        ok = torch.linalg.det(N).abs() > 1e-12
        cov = torch.linalg.inv(torch.where(ok[..., None, None], N, torch.eye(3, dtype=gpu_F64, device=gpu_DEVICE)))
        sol = (cov @ b[..., None])[..., 0]
        V[:, c0:c0 + chunk] = torch.where(ok, sol[..., 0] * 400.0, torch.full_like(sol[..., 0], gpu_NAN))
        SV[:, c0:c0 + chunk] = torch.where(ok, torch.sqrt(torch.clamp(cov[..., 0, 0], min=0.0)) * 400.0, torch.full_like(sol[..., 0], gpu_NAN))
    return gpu_host(V), gpu_host(SV)


def lbl_corr(V, x, least):
    """Each column of V's Pearson correlation with X over the rows where both are finite, and its two-sided p-value from Student's t with n - 2 degrees
    of freedom; NaN where fewer than LEAST rows."""
    from scipy.stats import t as student
    x = np.asarray(x, float)
    ok = np.isfinite(V) & np.isfinite(x)[:, None]
    n = ok.sum(0)
    with np.errstate(all="ignore"):
        xm = np.where(ok, x[:, None], 0.0).sum(0) / n
        vm = np.where(ok, V, 0.0).sum(0) / n
        dx, dv = np.where(ok, x[:, None] - xm, 0.0), np.where(ok, V - vm, 0.0)
        r = np.clip((dx * dv).sum(0) / np.sqrt((dx * dx).sum(0) * (dv * dv).sum(0)), -1.0, 1.0)
        p = 2.0 * student.sf(np.abs(r) * np.sqrt((n - 2) / np.maximum(1.0 - r * r, 1e-300)), n - 2)
    use = n >= least
    return np.where(use, r, np.nan), np.where(use, p, np.nan)


def lbl_grid():
    """The line-by-line grid, uniform in log wavelength at 0.4 km/s from 3800 to 6880 A."""
    return 3800.0 * np.exp(np.arange(int(np.log(6880.0 / 3800.0) * spectra_C / 0.4)) * 0.4 / spectra_C)


def lbl_indices(F, grid):
    """Each row of F on GRID's Ca II H and K index (S, uncalibrated: triangular cores of 1.09 A over continuum bands of 20 A) and H alpha index (a 1.6 A
    core over its two side bands)."""
    def band(i, centre, half, tri):
        k = np.abs(grid - centre) < half
        w_ = (1.0 - np.abs(grid[k] - centre) / half) if tri else np.ones(k.sum())
        return float(np.nansum(F[i, k] * w_) / np.nansum(w_ * np.isfinite(F[i, k])))
    S = np.array([(band(i, 3968.47, 1.09, True) + band(i, 3933.66, 1.09, True)) / (band(i, 3901.07, 10.0, False) + band(i, 4001.07, 10.0, False))
                  for i in range(len(F))])
    HA = np.array([band(i, 6562.81, 0.8, False) / (0.5 * (band(i, 6550.87, 5.375, False) + band(i, 6580.31, 4.375, False))) for i in range(len(F))])
    return S, HA


def lbl_velocities(F, E, robust=False):
    """Spectra F (errors E) on the line-by-line grid measured line by line against their median: the median's lines (lbl_lines) and every spectrum's
    shift in each with its error (lbl_shifts), then three passes that set aside the shifts more than 5 robust standard deviations from their
    spectrum's median and give each line a jitter, the excess of its residuals' mean square about the spectra's weighted means over its errors' (with
    ROBUST, of their median square over 0.455, a normal law's, over its errors' median square): the lines, the shifts with those set aside NaN, their
    errors, and each shift's variance with its line's jitter."""
    T = gpu_host(gpu_nanmedian(gpu_dev(F), 0))
    lines = lbl_lines(T, np.isfinite(F).all(0) & np.isfinite(T))
    V, SV = lbl_shifts(F, E, T, lines)
    jit = np.zeros(len(lines))
    for _ in range(3):
        s2 = SV ** 2 + jit[None, :] ** 2
        rv = np.nansum(V / s2, 1) / np.nansum(1.0 / s2, 1)
        res = V - rv[:, None]
        z = res / np.sqrt(s2)
        zc = z - np.nanmedian(z, 1)[:, None]
        V = np.where(np.abs(zc) < 5.0 * 1.4826 * np.nanmedian(np.abs(zc), 1)[:, None], V, np.nan)
        if robust:
            jit = np.sqrt(np.clip(np.nan_to_num(np.nanmedian(res ** 2, 0) / 0.455 - np.nanmedian(SV ** 2, 0)), 0.0, None))
        else:
            jit = np.sqrt(np.clip(np.nan_to_num(np.nanmean(res ** 2 - SV ** 2, 0)), 0.0, None))
    return lines, V, SV, SV ** 2 + jit[None, :] ** 2


def spectra_planet_frame(ccf, vp, w, kp_grid, vrest):
    """Cross-correlation rows summed in the planet's frame: a map over the trial semi-amplitudes K_p and rest velocities, VP holding each row's
    sin(2 pi phase) and W its weight."""
    return gpu_host(gpu_planet_frame(ccf, vp, w, kp_grid, vrest))


def spectra_load_many(paths, threads=8):
    """spectra_load over PATHS on THREADS threads, in order, None for each product that does not load."""
    def one(path):
        try:
            return spectra_load(path)
        except spectra_UNREADABLE:
            return None
    return archive_pmap(one, list(paths), threads)


def spectra_read(paths):
    """The spectra at PATHS as spectra_load reads them, (w, f, e, meta) each, those that do not load left out."""
    return [s for s in spectra_load_many(paths) if s is not None]


def spectra_vsys(spectra, fallback=None):
    """A series' systemic velocity (km/s): the median of the pipeline velocities where the products carry them, else FALLBACK where given, else the SIMBAD
    mirror's for the star nearest the spectra's position within 10 arcsec, else the median of the observing blocks' target velocities, else zero."""
    rvs = [s[3]["rv"] for s in spectra if s[3].get("rv") is not None]
    if rvs:
        return float(np.median(rvs))
    if fallback is not None:
        return float(fallback)
    pos = [(s[3]["ra"], s[3]["dec"]) for s in spectra if s[3].get("ra") is not None and s[3].get("dec") is not None]
    if pos:
        v = archive_simbad_velocity_near(float(np.median([p[0] for p in pos])), float(np.median([p[1] for p in pos])))
        if v is not None:
            return v
    obs = [s[3]["rv_ob"] for s in spectra if s[3].get("rv_ob") is not None]
    return float(np.median(obs)) if obs else 0.0


def spectra_align(F, master, max_kms=20):
    """Each row's velocity against the median spectrum (km/s): the whole-sample shift on the one km/s grid within MAX_KMS at which the row's lines match the median's best by least squares over the samples the median absorbs by 5 per cent or more, refined by a parabola through the best three."""
    master = gpu_dev(master)
    use = torch.isfinite(master) & (master < 0.95)
    M = torch.where(use, master - 1.0, torch.zeros_like(master))
    X = gpu_dev(F) - 1.0
    X = torch.where(torch.isfinite(X), X, torch.zeros_like(X))
    shifts = np.arange(-max_kms, max_kms + 1)
    # each row's cost at every whole-sample shift, the row wrapped round at its ends
    cost = gpu_host(torch.stack([(((torch.roll(X, -int(s), dims=1) - M[None, :]) ** 2) * use[None, :]).sum(1) for s in shifts], 1))
    out = np.zeros(F.shape[0])
    for i in range(F.shape[0]):
        k = int(np.argmin(cost[i]))
        if 0 < k < len(shifts) - 1:
            a, b, c = cost[i, k - 1], cost[i, k], cost[i, k + 1]
            den = a - 2 * b + c
            out[i] = shifts[k] + (0.5 * (a - c) / den if den > 0 else 0.0)
        else:
            out[i] = shifts[k]
    return out


def spectra_residuals(spectra, vsys, band, align=True, info=None):
    """Residuals on the band's grid: each spectrum in the primary's frame (its header velocity, else VSYS, then its own shift against the median spectrum when ALIGN) over its running median, divided by the median spectrum, a cubic taken out, telluric regions and the samples across a gap half or more of the spectra share NaN; with each wavelength's scatter."""
    g = spectra_grid(band)

    def onto(spectra, shifts):
        F, _, used = spectra_onto([(w / (1.0 + ((meta["rv"] if meta.get("rv") is not None else vsys) + dv) / spectra_C), f, None)
                                   for (w, f, e, meta), dv in zip(spectra, shifts)], g)
        return F, np.array([spectra_gaps(g, u) for u in used])
    F, gaps = onto(spectra, np.zeros(len(spectra)))
    # a gap most of the spectra share, as between two detectors, set aside
    common = gaps.mean(0) >= 0.5
    F[:, common] = np.nan
    if align:
        shifts = spectra_align(F, gpu_nanmedian(gpu_dev(F), 0))
        moved = np.abs(shifts) >= 0.5
        if moved.any():
            F[moved] = onto([s for s, m in zip(spectra, moved) if m], shifts[moved])[0]
            F[:, common] = np.nan
        if info is not None:
            info["vstar"] = np.array([(meta["rv"] if meta.get("rv") is not None else vsys) + (dv if mv else 0.0) for (_, _, _, meta), dv, mv in zip(spectra, shifts, moved)])
    every = torch.ones(len(F), dtype=torch.bool, device=gpu_DEVICE)
    R, sd, _, master = spectra_normalise(gpu_dev(F), every, band)
    return gpu_host(R), gpu_host(sd), gpu_host(master)


def spectra_template(spectra, vsys, band):
    """A template star's absorption pattern on the band's grid: one minus its median normalised spectrum in its own frame, negative values zero."""
    return spectra_depths(spectra_residuals(spectra, vsys, band)[2])


def spectra_depths(master):
    """A normalised spectrum's line depths: one minus it, negative values and gaps zero."""
    return np.where(np.isfinite(master), np.clip(1.0 - master, 0.0, None), 0.0)


def spectra_lambert(phase):
    """Lambert's phase function at orbital phase PHASE (0 at inferior conjunction): zero there and one at superior conjunction, where the lit face is
    full."""
    alpha = 2.0 * np.pi * np.abs(np.asarray(phase, float) - 0.5)
    return (np.sin(alpha) + (np.pi - alpha) * np.cos(alpha)) / np.pi


def spectra_unpattern(ccf, half=40):
    """The star's own pattern taken out of every cross-correlation row at its own strength: the rows' median shape, scaled to each row by least squares within HALF km/s of the star's velocity and subtracted over the whole row, then the rows' remaining median."""
    vmax = (ccf.shape[1] - 1) // 2
    pattern = np.median(ccf, axis=0)
    core = slice(vmax - half, vmax + half + 1)
    pc = pattern[core]
    scale = (ccf[:, core] * pc[None, :]).sum(1) / max(float((pc ** 2).sum()), 1e-30)
    out = ccf - scale[:, None] * pattern[None, :]
    return out - np.median(out, axis=0)[None, :]


def spectra_components(ccf, k):
    """The cross-correlation rows with their K leading principal components taken out, the shapes the star's own residual pattern takes from night to night, which a companion's trail, moving from row to row, does not share."""
    if not k:
        return ccf
    U, S, Vt = np.linalg.svd(ccf, full_matrices=False)
    return ccf - (U[:, :k] * S[:k]) @ Vt[:k]


def spectra_lay(w, f, T, v, depth, band="optical"):
    """The flux F at wavelengths W with the line depths T, given on a band's grid, laid into it at DEPTH and moved by V km/s."""
    return f * (1.0 - depth * np.interp(w, spectra_grid(band) * (1.0 + v / spectra_C), T, left=0.0, right=0.0))


def spectra_kp(p, a_au=0.05):
    """A planet's orbital speed (km/s) on a circular orbit of the archive's semi-major axis, A_AU where it gives none."""
    return 2 * np.pi * (p["pl_orbsmax"] or a_au) * 1.495978707e8 / (p["pl_orbper"] * 86400.0)


def spectra_load(path):
    """A spectrum as air wavelengths (A) in the barycentric frame, flux and error, with its mid-time (MJD), the pipeline's stellar velocity (km/s) where the header holds one, and its instrument."""
    from astropy.io import fits
    with fits.open(path) as h:
        H = h[0].header
        if "HIERARCH OHP DRS BJD" in H:
            # SOPHIE's one-dimensional spectrum of the object's fibre, already in air and the barycentric frame, its flux relative and its error from the signal-to-noise of the order near 5300 A
            f = np.asarray(h[0].data, float)
            w = float(H["CRVAL1"]) + float(H["CDELT1"]) * np.arange(len(f))
            snr = archive_num(H.get("HIERARCH OHP DRS CAL EXT SN26"), float("nan"))
            e = np.sqrt(np.abs(f) * abs(float(np.nanmedian(f[(w > 5200.0) & (w < 5400.0)])))) / snr if snr and snr > 0 else np.sqrt(np.abs(f))
            return w, f, e, dict(mjd=float(H["HIERARCH OHP DRS BJD"]) - 2400000.5, rv=None, rv_ob=None, inst="SOPHIE", snr=snr, berv=float(H["HIERARCH OHP DRS BERV"]), ra=None, dec=None)
        if "HIERARCH TNG QC BJD" in H:
            # HARPS-N's newer one-dimensional spectrum, a row a sample, in the barycentric frame, its samples of any quality flag set aside
            t = h[1].data
            f = np.where(np.asarray(t["quality"]) == 0, np.asarray(t["flux"], float), np.nan)
            return np.asarray(t["wavelength_air"], float), f, np.asarray(t["error"], float), dict(mjd=float(H["HIERARCH TNG QC BJD"]) - 2400000.5, rv=archive_num(H.get("HIERARCH TNG QC CCF RV")), rv_ob=None, inst="HARPN",
                                                                                               snr=archive_num(H.get("HIERARCH TNG QC ORDER50 SNR"), float("nan")), berv=float(H["HIERARCH TNG QC BERV"]), ra=None, dec=None)
        inst = str(H.get("INSTRUME", "")).strip()
        mjd = float(H.get("MJD-OBS", np.nan)) + float(H.get("EXPTIME", 0)) / 172800.0
        rv, rv_ob = None, None
        # the pipeline's velocity where the product carries one; the observing block's target velocity, often a placeholder, kept apart
        for key in ("HIERARCH ESO QC CCF RV", "HIERARCH ESO DRS CCF RVC", "HIERARCH ESO DRS CCF RV"):
            if key in H and np.isfinite(float(H[key])):
                rv = float(H[key])
                break
        ob = archive_num(H.get("HIERARCH ESO TEL TARG RADVEL"))
        if ob is not None and 0.0 < abs(ob) < 500.0:
            rv_ob = ob
        if inst.upper().startswith("SPIROU") or "SPIROU" in str(H.get("INSTRUME", "")).upper() or len(h) > 1 and h[1].name in ("FluxA", "FLUXA"):
            # the CADC t product: per-order flux (telluric corrected), wavelength (nm, vacuum) and blaze in image extensions
            ext = {x.name.upper(): x for x in h[1:]}
            f = np.asarray(ext["FLUXA"].data if "FLUXA" in ext else h[1].data, float)
            w = np.asarray(ext["WAVEA"].data, float) * 10.0
            bl = np.asarray(ext["BLAZEA"].data, float) if "BLAZEA" in ext else np.ones_like(f)
            with np.errstate(all="ignore"):
                f = f / bl
            e = np.sqrt(np.abs(f))
            order = np.argsort(w.ravel())
            w, f, e = w.ravel()[order], f.ravel()[order], e.ravel()[order]
            w = archive_vac_to_air(w)
            # the wavelengths are the observatory's; the barycentric correction and the order 35 signal-to-noise sit in the extensions' headers
            H1 = h[1].header if len(h) > 1 else {}
            berv = next((float(x[k]) for x in (H, H1) for k in ("BERV",) if k in x and np.isfinite(float(x[k]))), None)
            if berv is None:
                berv = archive_barycentric_correction(float(H["RA_DEG"]), float(H["DEC_DEG"]), mjd, "CFHT") if "RA_DEG" in H else 0.0
            w = w * (1.0 + berv / spectra_C)
            rv = rv if rv is not None else next((float(x[k]) for x in (H, H1) for k in ("CCFRV",) if k in x and np.isfinite(float(x[k]))), None)
            snr = next((float(x[k]) for x in (H1, H) for k in ("EXTSN035", "SNR35", "SPEMSNR") if k in x and np.isfinite(float(x[k]))), np.nan)
            return w, f, e, dict(mjd=mjd, rv=rv, inst="SPIRou", snr=snr, berv=berv, ra=archive_num(H.get("RA_DEG")), dec=archive_num(H.get("DEC_DEG")))
        t = h[1].data
        names = {n.upper(): n for n in t.columns.names}
        wname = names.get("WAVE_AIR") or names.get("WAVE") or t.columns.names[0]
        w = np.asarray(t[wname][0], float)
        f = np.asarray(t[names["FLUX"]][0] if "FLUX" in names else t[t.columns.names[1]][0], float)
        e = np.asarray(t[names["ERR"]][0], float) if "ERR" in names else np.sqrt(np.abs(f))
        if not np.any(np.isfinite(e) & (e > 0)):
            # a product without errors (the older HARPS reductions) takes the photon-counting proxy
            e = np.sqrt(np.abs(f))
        ucd = str(h[1].header.get("TUCD%d" % (t.columns.names.index(wname) + 1), ""))
        unit = str(h[1].header.get("TUNIT%d" % (t.columns.names.index(wname) + 1), "")).strip().lower()
        spec = str(H.get("SPECSYS", h[1].header.get("SPECSYS", ""))).upper()
        berv = None
        for key in ("HIERARCH ESO QC BERV", "HIERARCH ESO DRS BERV"):
            if key in H:
                berv = float(H[key])
                break
        if berv is None:
            site = "Paranal" if inst.upper() in ("ESPRESSO", "UVES", "CRIRES", "XSHOOTER") else "LaSilla"
            berv = archive_barycentric_correction(float(H["RA"]), float(H["DEC"]), mjd, site)
        snr = float(H.get("SNR", np.nan))
        ra, dec = archive_num(H.get("RA")), archive_num(H.get("DEC"))
    if unit == "nm":
        w = w * 10.0
    elif unit in ("um", "micron", "micrometer", "micrometre") or w.max() < 100:
        w = w * 1e4
    if "obs.atmos" not in ucd and wname.upper() != "WAVE_AIR":
        w = archive_vac_to_air(w)
    if not spec.startswith("BARY"):
        w = w * (1.0 + berv / spectra_C)
    return w, f, e, dict(mjd=mjd, rv=rv, rv_ob=rv_ob, inst=inst, snr=snr, berv=berv, ra=ra, dec=dec)


planets_DOC = """Planets in archived radial velocities. The HARPS-RVBank's SERVAL velocities and activity indicators (Trifonov et al. 2020) are joined to every
other instrument's public velocities in DACE, and each star's velocities are searched for Keplerians around and beside the planets the NASA Exoplanet
Archive lists for it. A signal is then tested across three reductions of the same HARPS spectra (SERVAL's, the HARPS pipeline's in DACE and
line-by-line velocities measured here), the star's activity indicators, the two halves of its nights, its other instruments, Gaia's astrometry and its
TESS light curves, and its orbit is sampled.

    bank      the bank's star list and velocities from VizieR, and the archive's planets
    dace      DACE's public velocities of the census's stars, each star found by position
    rvcat     the stars of ESO's HARPS radial-velocity catalogue the bank does not hold, with the catalogue's velocities as their bank, as a data root
    tables    the stars of the published HIRES tables the census does not search, with those velocities as their bank, as a data root
    sophie    the stars of the SOPHIE archive, with its pipeline's velocities as their bank, as a data root
    harpsn    the stars of the TNG archive's public HARPS-N spectra, with its pipeline's velocities as their bank, as a data root
    neid      the stars of NEID's archive, with its pipeline's velocities as their bank, as a data root
    elodie    the stars of the ELODIE archive, with its velocities as their bank, as a data root
    carmenes  the stars of CARMENES's first data release, with its two reductions as their bank and second reduction, as a data root
    peers     the root's stars given the other data roots' velocities of them
    targets   the archive's HARPS targets (or another spectrograph's) beyond the census, set up as a data root of their own
    measure   a targets root's stars measured from their spectra: cross-correlation velocities as its bank, line-by-line velocities beside them
    census    a share of the stars searched
    merge     the shares joined, each unflagged signal's period tested in the stars' S index
    transitsearch the census stars' TESS light curves searched blind for transits
    eccentric the census's residuals searched by a Keplerian periodogram, eccentric orbits included
    calibrate the census run blind on the archive's planets and scored on them; with --wobble, the weighing's wobble rule set on Gaia DR3's published solutions
    benchmark the census run on stars whose answers are known: Proxima, alpha Cen A and B, and the Sun from the solar mode
    lbl       a star's line-by-line velocities from its HARPS spectra
    followup  every signal decided, known, new or rejected: the census's, the varying stars' companions and TESS's candidates; signals.csv and
              planets.csv
    vet       signals across reductions, indicators, halves, other instruments and Gaia, of one star or of a list
    orbits    a star's Keplerians sampled
    tess      a star's TESS light curves at its signals' periods: rotation and transits
    tois      TESS's planet candidates weighed with archived velocities at their transit ephemerides
    validate  TESS's planet candidates validated statistically with TRICERATOPS
    system    a planetary system's case: models, aliases, stability, detection limits and figures
    weigh     a long-period companion's true mass from velocities and Hipparcos-Gaia astrometry
    ledger    each new body's predicted orbit tested against observations made after its discovery; failures are rejected at the next followup
    controls  what the decision does to settled candidates and to open ones, read from the root's records with nothing weighed; with --indicators, how often an activity indicator holds power at a known planet's period
    strict    the strict-periodicity test of Hara et al. (2022) on the root's known and new signals and those rejected for activity
    sparse    the census's stars' sinusoids searched one at a time, by RELAX and from the l1 periodogram, scored against the blind census on the archive's planets
    recovery  a range of periods tried before the search is carried over it: confirmed planets found there, what it adds and what noise alone gives
    window    what the search's detrending costs a transit of each length
    figure    each signal past the search's vetting of one star drawn from its light curves
    dip       one lone dip of a star read closely: every light curve of its sector, its neighbours and the orbits' conjunctions
    companions-read the root's new companions one by one, with Gaia's marks and the catalogues that hold them
    progress  the TESS stage's stars searched by kind of light curve, its rate and the time left
    epochs-trial the reading of Gaia DR4's epoch astrometry tried on ESA's pre-release"""

planets_ROOT = archive_data("planets")
planets_RESULTS = archive_results("planets")

# HARPS's fibre upgrade of 2015 June, which moved its velocities by an offset of their own (MJD)
planets_HARPS_UPGRADE = 57172.5

planets_INDICATORS = ("S", "Halpha", "FWHM", "BIS", "CRX", "dLW")


def planets_path(*parts):
    """Path under the planets data root."""
    return os.path.join(planets_ROOT, *parts)


# what a root planets_tables set up says of its bank, the spectrograph it comes from, the upgrade that moved its zero point (MJD) and the labels of its two reductions; the HARPS-RVBank's otherwise
planets_BANK_INFO = json.load(open(planets_path("bank.json"))) if os.path.exists(planets_path("bank.json")) else {}
planets_BANK_FAMILY, planets_UPGRADE = planets_BANK_INFO.get("family", "HARPS"), planets_BANK_INFO.get("upgrade", planets_HARPS_UPGRADE)


# the tables a new data root takes from the root it is set up from, each of which it would otherwise fetch or build again
planets_SHARED = ("known.csv", "solutions.csv", "toi.csv", "ctoi.csv", "imaging.csv", "exoplanet_eu.csv", "eclipsing_binaries.npy", "eclipsing_candidates.npy", "tess/index.npz", "tess/sectors.json")


def planets_share_tables(source, out):
    """The tables of planets_SHARED and the SIMBAD index taken from the data root SOURCE into the data root OUT where it lacks them, the index by hard links where the disk allows."""
    pairs = [(os.path.join(source, "planets", *name.split("/")), os.path.join(out, "planets", *name.split("/"))) for name in planets_SHARED]
    pairs += [(p, os.path.join(out, "simbad_index", os.path.basename(p))) for p in glob.glob(os.path.join(source, "simbad_index", "*"))]
    for src, kept in pairs:
        if os.path.exists(src) and not os.path.exists(kept):
            os.makedirs(os.path.dirname(kept), exist_ok=True)
            try:
                os.link(src, kept) if "simbad_index" in kept else shutil.copyfile(src, kept)
            except OSError:
                shutil.copyfile(src, kept)


def planets_write(path, rows, keys=None):
    """ROWS, dicts, written to PATH as CSV with the columns KEYS, by default the first row's."""
    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
    keys = keys or (list(rows[0].keys()) if rows else [])
    with open(path, "w", newline="", encoding="utf-8") as fh:
        w = csv.DictWriter(fh, fieldnames=keys, extrasaction="ignore")
        w.writeheader()
        w.writerows(rows)
    return path


def planets_read(path):
    """A CSV file's rows as dicts."""
    return list(csv.DictReader(open(path, encoding="utf-8")))


def planets_num(x):
    """Catalogue value as a finite float, else NaN."""
    v = archive_num(x)
    return float("nan") if v is None else v


def planets_late_type(sp):
    """An F, G, K or M star of luminosity class III or fainter."""
    sp = (sp or "").strip()
    return bool(sp) and sp[0] in "FGKM" and not sp.startswith(("Fe", "Ge")) and not any(c in sp for c in ("Ia", "Ib", "Iab", "II/", "II-", " II", "II "))


def planets_mass(sp):
    """The spectral type's mass (solar masses) behind the minimum masses."""
    sp = (sp or "").strip()
    return 1.5 if any(c in sp for c in ("III", "IV/III")) else {"F": 1.2, "G": 1.0, "K": 0.75, "M": 0.45}.get(sp[:1], 1.0)


def planets_star_mass(star):
    """A star's mass (solar masses): its row's where its root's table gives one (planets_carmenes), else its spectral type's."""
    return archive_num(star.get("Mass")) or planets_mass(star.get("SpType"))


def planets_kepler(t, P, tp, e, w):
    """The unit Keplerian velocity curve, cos(nu + w) + e cos w."""
    M = 2 * np.pi * (((t - tp) / P) % 1.0)
    E = M + e * np.sin(M)
    for _ in range(30):
        E = E - (E - e * np.sin(E) - M) / (1.0 - e * np.cos(E))
    nu = 2 * np.arctan2(np.sqrt(1 + e) * np.sin(E / 2), np.sqrt(1 - e) * np.cos(E / 2))
    return np.cos(nu + w) + e * np.cos(w)


def planets_least_mass(f, m1):
    """The companion's mass (solar masses) whose mass function m^3/(m1+m)^2 is F, by bisection over every element of F and M1 at once."""
    f, m1 = np.asarray(f, float), np.asarray(m1, float)
    lo, hi = np.zeros(np.broadcast(f, m1).shape), np.full(np.broadcast(f, m1).shape, 100.0)
    for _ in range(80):
        mid = 0.5 * (lo + hi)
        below = mid ** 3 / (m1 + mid) ** 2 < f
        lo, hi = np.where(below, mid, lo), np.where(below, hi, mid)
    out = 0.5 * (lo + hi)
    return float(out) if out.ndim == 0 else out


def planets_msini(P, K, e, m1):
    """Minimum mass in Jupiter masses of a Keplerian of period P (d), semi-amplitude K (m/s) and eccentricity e about a star of m1 solar masses."""
    return planets_least_mass(1.0361e-7 * (1 - e ** 2) ** 1.5 * (K / 1000.0) ** 3 * P, m1) * 1047.57


def planets_bank():
    """The bank's star list and velocities from VizieR (J/A+A/636/A74) and the NASA Exoplanet Archive's planets with their hosts' names, positions and proper
    motions, written under ROOT as bank_stars.csv, bank_velocities.csv and known.csv."""
    stars = archive_tap("vizier", 'SELECT "recno", "Nrv", "Name", "RAJ2000", "DEJ2000", "SpType", "Teff", "Bmag", "Vmag", "Gmag", "Dist", "SimbadName" '
                                  'FROM "J/A+A/636/A74/list"')
    planets_write(planets_path("bank_stars.csv"), stars)
    vel = archive_tap("vizier", 'SELECT "Name", "BJD", "DRVmlcnzp", "e_DRVmlcnzp", "CRX", "e_CRX", "dLW", "e_dLW", "Halpha", "e_Halpha", "NaD1", "NaD2", '
                                '"FWHMDRS", "BIS", "SNRDRS" FROM "J/A+A/636/A74/rvbank"')
    planets_write(planets_path("bank_velocities.csv"), vel)
    known = archive_exoplanets(planets_KNOWN)
    planets_write(planets_path("known.csv"), known)
    print("%d stars, %d velocities, %d catalogued planets" % (len(stars), len(vel), len(known)), flush=True)


planets_KNOWN = "SELECT hostname, hd_name, hip_name, ra, dec, sy_pmra, sy_pmdec, pl_name, pl_orbper, pl_bmassj, pl_orbeccen, pl_rvamp FROM pscomppars"
planets_SOLUTIONS = "SELECT pl_name, hostname, hd_name, hip_name, tic_id, ra, dec, sy_pmra, sy_pmdec, pl_orbper FROM ps"
planets_CATALOGUED = []
# the Extrasolar Planets Encyclopaedia's catalogue, each of its statuses asked for by its query, and the columns kept of it
planets_EU = "https://exoplanet.eu/catalog/csv/"
planets_EU_STATUSES = ("confirmed", "candidate", "controversial", "retracted", "unconfirmed")
planets_EU_KEYS = ("name", "planet_status", "orbital_period", "ra", "dec", "star_name", "star_alternate_names", "alternate_names", "discovered")
planets_ENCYCLOPAEDIA = []


def planets_archive(days=1.0):
    """The archive's default parameters (known.csv) and every published solution (solutions.csv) in ROOT, fetched again once DAYS old, the old copy
    kept where the archive does not answer. Returns the solutions."""
    for name, query in (("known.csv", planets_KNOWN), ("solutions.csv", planets_SOLUTIONS)):
        path = planets_path(name)
        if os.path.exists(path) and time.time() - os.path.getmtime(path) < days * 86400.0:
            continue
        try:
            rows = archive_exoplanets(query)
        except Exception as exc:
            if not os.path.exists(path):
                raise
            print("the archive did not answer (%s); %s kept" % (str(exc)[:120], name), flush=True)
            continue
        tmp = archive_tmp(path)
        planets_write(tmp, rows)
        archive_place(tmp, path)
    return planets_read(planets_path("solutions.csv"))


def planets_finder(rows):
    """A finder match(ra, dec, tic, names, P, radius, tolerance) of the planets ROWS, each under the archive's column names with its star's other names in aliases where it has them, of
    a star by TIC, name or position, those within TOLERANCE of P in period where given; match.host and match.period give each planet's star and period."""
    col = lambda k: np.array([planets_num(r.get(k)) for r in rows])
    ra0, dec0, per = col("ra"), col("dec"), col("pl_orbper")
    pmra, pmdec = np.nan_to_num(col("sy_pmra")), np.nan_to_num(col("sy_pmdec"))
    by_tic, by_name = {}, {}
    for i, r in enumerate(rows):
        tic = re.sub(r"\D", "", r.get("tic_id") or "")
        if tic:
            by_tic.setdefault(int(tic), []).append(i)
        for n in [r.get(c) for c in ("hostname", "hd_name", "hip_name")] + list(r.get("aliases", ())):
            if (n or "").strip():
                by_name.setdefault(archive_simbad_key(n), []).append(i)
    order = np.argsort(np.nan_to_num(dec0, nan=99.0))
    names_, dsorted = np.array([r["pl_name"] for r in rows]), np.nan_to_num(dec0, nan=99.0)[order]

    def match(ra, dec, tic=None, names=(), P=None, radius=60.0, tolerance=0.05):
        idx = set(by_tic.get(int(tic), ())) if tic not in (None, "") else set()
        for n in names:
            if n:
                idx.update(by_name.get(archive_simbad_key(n), ()))
        if math.isfinite(ra) and math.isfinite(dec):
            # the proper motion carries a position less than 0.1 deg in sixteen years
            j = order[np.searchsorted(dsorted, dec - 0.1):np.searchsorted(dsorted, dec + 0.1)]
            cosd = math.cos(math.radians(dec))
            sep = lambda a, d: np.hypot(((a - ra + 180.0) % 360.0 - 180.0) * cosd, d - dec) * 3600.0
            near = np.minimum(sep(ra0[j], dec0[j]), sep(ra0[j] - 16.0 * pmra[j] / 3.6e6 / cosd, dec0[j] - 16.0 * pmdec[j] / 3.6e6)) < radius
            idx.update(j[near].tolist())
        return sorted({str(names_[i]) for i in idx if P is None or abs(P / per[i] - 1.0) < tolerance})
    match.host = {r["pl_name"]: r["hostname"] for r in rows}
    match.period = {r["pl_name"]: planets_num(r.get("pl_orbper")) for r in rows}
    return match


def planets_catalogued(days=1.0):
    """A finder (planets_finder) of the archive's planets of a star in any published solution."""
    if not planets_CATALOGUED:
        planets_CATALOGUED.append(planets_finder(planets_archive(days)))
    return planets_CATALOGUED[0]


def planets_encyclopaedia(days=1.0):
    """A finder (planets_finder) of the planets of the Extrasolar Planets Encyclopaedia (exoplanet.eu), every status of its catalogue (planets_EU_STATUSES), kept as ROOT/exoplanet_eu.csv
    in order of name and fetched again once DAYS old, the file's time moved first so that one process of those side by side asks, the old copy kept where the site does not answer whole;
    match.status gives each planet's status and match.cite how a row names it."""
    if not planets_ENCYCLOPAEDIA:
        path = planets_path("exoplanet_eu.csv")
        held = os.path.exists(path)
        if not held or time.time() - os.path.getmtime(path) >= days * 86400.0:
            if held:
                os.utime(path)
            try:
                rows = {}
                for status in planets_EU_STATUSES:
                    raw = archive_get(planets_EU + "?" + urllib.parse.urlencode({"query_f": '"%s" in planet_status' % status}), timeout=300, retries=2)
                    got = list(csv.DictReader(io.StringIO(raw.decode("utf-8-sig", "replace"))))
                    # the query matches the status's words, so that "confirmed" also brings the unconfirmed
                    if any(status not in r["planet_status"].lower() for r in got) or status == "confirmed" and len(got) < 1000:
                        raise IOError("%s: %d rows, not all of that status" % (status, len(got)))
                    rows.update({(r["name"], r["planet_status"]): r for r in got})
                tmp = archive_tmp(path)
                planets_write(tmp, [rows[k] for k in sorted(rows)], planets_EU_KEYS)
                archive_place(tmp, path)
            except Exception as exc:
                if not held:
                    raise
                print("exoplanet.eu did not answer whole (%s); exoplanet_eu.csv kept" % str(exc)[:120], flush=True)
        kept = planets_read(path)
        tic = lambda r: re.search(r"TIC[\s-]*(\d+)", "%s, %s" % (r.get("star_alternate_names"), r.get("alternate_names")))
        found = planets_finder([dict(pl_name=r["name"], hostname=r["star_name"], ra=r["ra"], dec=r["dec"], pl_orbper=r["orbital_period"], tic_id=tic(r).group(1) if tic(r) else "",
                                     aliases=(r.get("star_alternate_names") or "").split(",")) for r in kept])
        found.status = {r["name"]: r["planet_status"].strip().lower() for r in kept}
        found.cite = {r["name"]: "exoplanet.eu %s, %s%s" % (r["name"], r["planet_status"].strip().lower(), " (%s)" % r["discovered"] if r["discovered"] else "") for r in kept}
        planets_ENCYCLOPAEDIA.append(found)
    return planets_ENCYCLOPAEDIA[0]


def planets_place(r, stars, exo):
    """Where a decided row R's star lies and what it is called, as a finder (planets_finder) takes them: a TESS candidate's from its row of ExoFOP's tables EXO, a census star's from STARS,
    and a star the TESS stage searched from its record's details."""
    x = exo.get(r["label"]) if r["kind"] in ("validated", "toi") else None
    if x:
        return planets_radec(x) + (x.get("TIC ID"), ())
    s = stars.get(r["name"], {})
    if not s and r.get("ra") is not None:
        return planets_num(r["ra"]), planets_num(r["dec"]), r.get("tic"), (r["name"],)
    return planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000")), None, (r["name"], s.get("SimbadName"))


def planets_encyclopaedia_decide(sig, stars):
    """The rows of SIG the decisions make new or leave candidates set against the Encyclopaedia (planets_encyclopaedia) at their stars, within 5 per cent in period or 25 per cent for a
    companion, whose long orbit the data bound less closely, each entry named in the row's catalogued. A body it lists as retracted alone is rejected. A TESS candidate is known where it
    lists it as confirmed, an independent validation where validated, since the catalogue's candidates include the TOIs themselves. Any other body it lists is known."""
    found = planets_encyclopaedia()
    exo = {x["label"]: x for x in planets_exofop()}
    for r in sig:
        if r["status"] not in ("new", "candidate", "likely"):
            continue
        hits = found(*planets_place(r, stars, exo), planets_num(r.get("orbit_P") or r["P"]), tolerance=0.25 if r["kind"] == "companion" else 0.05)
        if not hits:
            continue
        said = {found.status[n] for n in hits}
        r["catalogued"] = "; ".join([x for x in (r.get("catalogued"),) if x] + [found.cite[n] for n in hits])
        if said == {"retracted"}:
            r.update(status="rejected", reason="retracted")
        elif r["kind"] not in ("validated", "toi") or "confirmed" in said:
            r.update(status="known", reason="catalogued", contribution="independent validation" if r["kind"] == "validated" else "")


def planets_false_decide(sig, stars):
    """The new bodies and candidates of SIG at a star, by SIMBAD's object, and within 5 per cent of a period the California Legacy Survey judged false (ROOT/cls_false_positives.csv, as planets_tables keeps it) rejected, the Survey's cause named in catalogued."""
    path = planets_path("cls_false_positives.csv")
    if not os.path.exists(path):
        return
    false = planets_read(path)
    names = {r["name"]: (stars.get(r["name"], {}).get("SimbadName") or r["name"]).strip() for r in sig if r["status"] in ("new", "candidate")}
    oids = archive_simbad_oids(sorted(set(names.values()) | {x["SimbadName"] for x in false if x["SimbadName"]}))
    by = {}
    for x in false:
        if x["SimbadName"] in oids:
            by.setdefault(oids[x["SimbadName"]], []).append(x)
    for r in sig:
        if r["status"] in ("new", "candidate"):
            P = planets_num(r.get("orbit_P") or r["P"])
            hit = next((x for x in by.get(oids.get(names[r["name"]]), []) if abs(P / planets_num(x["Per"]) - 1.0) < 0.05), None)
            if hit:
                r.update(status="rejected", reason="a published false positive", catalogued="; ".join([y for y in (r.get("catalogued"),) if y] + ["California Legacy Survey false positive, cause %s" % hit["Cause"]]))


# each published survey's reading of a signal it tabulates: Butler et al.'s (2017) and the California Legacy Survey's (Rosenthal et al. 2021)
planets_SURVEY_READINGS = dict(Published="planet", Candidate="candidate", SRC="candidate", Activity="activity", K="planet", C="candidate", A="activity", R="activity", N="artifact", S="star")


def planets_survey_signals():
    """The signals the published HIRES surveys tabulate, Butler et al.'s (2017) table 2 and the California Legacy Survey's planets.dat (Rosenthal et al. 2021): each with its survey, star, period, median period where the survey gives one, and reading (planets_SURVEY_READINGS), kept beside the data roots in vizier_index/survey_signals.csv once read, since the catalogues are fixed; an error where no site serves them."""
    path = os.path.join(os.path.dirname(archive_DATA), "vizier_index", "survey_signals.csv")
    if os.path.exists(path):
        return planets_read(path)
    butler, cls = archive_vizier_file("J/AJ/153/208/table2.dat"), archive_vizier_file("J/ApJS/255/8/planets.dat")
    if not butler or not cls:
        raise IOError("no VizieR site served the published surveys' signals")
    rows = [dict(survey="Butler et al. 2017", star=x[5:15].strip(), P=float(x[25:35]), P_median="", reading=planets_SURVEY_READINGS[x[60:69].strip()]) for x in butler.splitlines() if x.strip()]
    for x in cls.splitlines():
        if x.strip():
            f = x.split("|")
            cps = f[1].strip().upper()
            rows.append(dict(survey="California Legacy Survey", star="HD " + cps if cps[0].isdigit() else cps, P=float(f[12]), P_median=float(f[13]), reading=planets_SURVEY_READINGS[f[2].strip()]))
    os.makedirs(os.path.dirname(path), exist_ok=True)
    tmp = archive_tmp(path)
    planets_write(tmp, rows, ["survey", "star", "P", "P_median", "reading"])
    archive_place(tmp, path)
    return planets_read(path)


def planets_survey_match(kind, P, signals):
    """The signal of SIGNALS, a star's rows of planets_survey_signals, that a decided signal of KIND at the period P is, or None: within 5 per cent, a companion within 25 per cent, or within a factor of two of one the survey reads as a star, since a long orbit seen in part binds its period only loosely, on the survey's side as on this one."""
    def same(x):
        for Q in (planets_num(x["P"]), planets_num(x["P_median"])):
            if kind != "companion":
                if abs(P / Q - 1.0) < 0.05:
                    return True
            elif 0.5 < P / Q < 2.0 if x["reading"] == "star" else abs(P / Q - 1.0) < 0.25:
                return True
        return False
    return next((x for x in signals if same(x)), None)


def planets_survey_decide(sig, stars):
    """The new bodies, candidates and likely planets of SIG set against the signals the published surveys tabulate at their stars, by SIMBAD's object (planets_survey_signals, planets_survey_match), the survey named in catalogued. One it reads as activity or an artifact is rejected as a published false positive; any other is known, an independent validation where it is a TESS candidate's."""
    rows = [r for r in sig if r["status"] in ("new", "candidate", "likely")]
    signals = planets_survey_signals()
    names = {r["name"]: (stars.get(r["name"], {}).get("SimbadName") or r["name"]).strip() for r in rows}
    forms = {x["star"]: planets_name_forms(x["star"]) + [re.sub(r"(?<=\d)[A-Z]$", "", x["star"])] for x in signals}
    oids = archive_simbad_oids(sorted(set(names.values()) | {f for fs in forms.values() for f in fs}))
    by = {}
    for x in signals:
        oid = next((oids[f] for f in forms[x["star"]] if f in oids), None)
        if oid is not None:
            by.setdefault(oid, []).append(x)
    for r in rows:
        hit = planets_survey_match(r["kind"], planets_num(r.get("orbit_P") or r["P"]), by.get(oids.get(names[r["name"]]), []))
        if hit:
            note = "; ".join([y for y in (r.get("catalogued"),) if y] + ["%s, %s at %.4g d" % (hit["survey"], hit["reading"], planets_num(hit["P"]))])
            if hit["reading"] in ("activity", "artifact"):
                r.update(status="rejected", reason="a published false positive", catalogued=note)
            else:
                r.update(status="known", reason="catalogued", contribution="independent validation" if r["kind"] == "validated" else "", catalogued=note)


def planets_radec(x):
    """A TESS candidate's J2000 position (deg) from its ExoFOP row, sexagesimal or decimal; NaN where unreadable."""
    def angle(text, scale):
        parts = str(text or "").strip().split(":")
        try:
            value = [float(p) for p in parts]
        except ValueError:
            return float("nan")
        if len(value) == 1:
            return value[0]
        return (-1.0 if parts[0].startswith("-") else 1.0) * (abs(value[0]) + value[1] / 60.0 + (value[2] if len(value) > 2 else 0.0) / 3600.0) * scale
    return angle(x.get("RA"), 15.0), angle(x.get("Dec"), 1.0)


def planets_bank_arrays():
    """The bank's usable velocities as arrays, read from bank_velocities.csv once and kept beside it in bank_velocities.npz while the table is unchanged:
    each row's star and its (MJD, velocity, error, S where the table gives it, H alpha, FWHM, bisector, CRX, dLW)."""
    src, cache = planets_path("bank_velocities.csv"), planets_path("bank_velocities.npz")
    stamp = "%d %d" % (os.path.getsize(src), int(os.path.getmtime(src)))
    if os.path.exists(cache):
        with np.load(cache) as z:
            if str(z["stamp"]) == stamp:
                return z["name"], z["rows"]
    name, rows = [], []
    for r in csv.DictReader(open(src, encoding="utf-8")):
        v, e = planets_num(r["DRVmlcnzp"]), planets_num(r["e_DRVmlcnzp"])
        if math.isfinite(v) and math.isfinite(e) and abs(v) < 1e6 and 0 < e < 1e3:
            name.append(r["Name"])
            rows.append([float(r["BJD"]) - 2400000.5, v, e, planets_num(r.get("S")), planets_num(r["Halpha"]), planets_num(r["FWHMDRS"]), planets_num(r["BIS"]),
                         planets_num(r["CRX"]), planets_num(r["dLW"])])
    name, rows = np.array(name, dtype=str), np.array(rows, float).reshape(-1, 9)
    tmp = archive_tmp(cache)
    with open(tmp, "wb") as fh:
        np.savez(fh, stamp=stamp, name=name, rows=rows)
    archive_place(tmp, cache)
    return name, rows


def planets_bank_series(names=None):
    """The bank's velocities by star, of NAMES alone where given: rows of (MJD, velocity, error, S, H alpha, FWHM, bisector, CRX, dLW), the S index left for
    DACE to fill."""
    name, rows = planets_bank_arrays()
    keep = np.isin(name, sorted(names)) if names is not None else np.ones(len(name), bool)
    bank = {}
    for n, r in zip(name[keep].tolist(), rows[keep].tolist()):
        bank.setdefault(n, []).append(r)
    return bank


def planets_bank_raw(names):
    """The bank's rows of the stars NAMES, by star."""
    out = {}
    for r in csv.DictReader(open(planets_path("bank_velocities.csv"), encoding="utf-8")):
        if r["Name"] in names:
            out.setdefault(r["Name"], []).append(r)
    return out


def planets_eligible(stars, bank):
    """The stars the census searches: late types whose bank velocities cover 15 nights or more over 100 days or more."""
    out = []
    for n, rows in bank.items():
        t = np.array([x[0] for x in rows])
        if planets_late_type(stars.get(n, {}).get("SpType")) and len(np.unique(np.floor(t + 0.3))) >= 15 and t.max() - t.min() >= 100:
            out.append(n)
    return sorted(out)


def planets_targets(out, min_nights=15, min_span=100.0, threads=6, inst="HARPS"):
    """The archive's HARPS targets (or INST's) beyond the census, set up for a census of their own in the data root OUT, its instrument in
    OUT/planets/measure.json and each target named by SIMBAD's object nearest its J2000 position within 10 arcsec. Every target of ESO's spectra above a
    signal-to-noise ratio of 20 with MIN_NIGHTS nights or more over MIN_SPAN days or more is kept, targets within 10 arcsec of one another joined under the
    name with the most nights, and a star the census already searches, recognised by its name or within 3 arcmin of its J2000 position, left out. Each is
    matched to its Gaia DR3 source, the brightest of G = 3 to 13.5 within 30 arcsec, and its position carried back to J2000 by the source's proper motion;
    targets sharing a source are joined, and those within 10 arcsec of a census star at J2000 are left out. The source's colour and absolute magnitude
    give its class (F from BP-RP 0.45, G from 0.78, K from 0.98 and M from 1.85, luminosity class III where M_G is brighter than 2.5), and its G and
    colour its V (Riello et al. 2021). The targets are written as OUT/planets/bank_stars.csv, with an empty bank_velocities.csv, an empty dace.csv and the
    archive's planets beside them, so that `planets dace` and `census` run in OUT as they run here."""
    q = ("SELECT target_name, AVG(s_ra) AS ra, AVG(s_dec) AS dec, COUNT(DISTINCT FLOOR(t_min + 0.3)) AS nights, MIN(t_min) AS t0, MAX(t_min) AS t1 "
         "FROM ivoa.ObsCore WHERE instrument_name = '%s' AND dataproduct_type = 'spectrum' AND snr > 20 GROUP BY target_name" % inst)
    rows = [r for r in archive_tap("eso", q) if int(r["nights"]) >= min_nights and float(r["t1"]) - float(r["t0"]) >= min_span and r["ra"] and r["dec"]]
    rows.sort(key=lambda r: -int(r["nights"]))
    print("%d %s targets with %d nights over %d days in the archive" % (len(rows), inst, min_nights, min_span), flush=True)
    sep = lambda a, b: math.hypot((a[0] - b[0]) * math.cos(math.radians(a[1])), a[1] - b[1]) * 3600.0
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    eligible = [n for n in planets_eligible(stars, planets_bank_series()) if stars[n].get("RAJ2000")]
    searched = [(float(stars[n]["RAJ2000"]), float(stars[n]["DEJ2000"])) for n in eligible]
    norm = lambda s: (lambda x: "GJ" + x[2:] if x.startswith("GL") else x)(re.sub(r"[\s_.\-]", "", str(s or "")).upper())
    known = {norm(x) for n in eligible for x in (n, stars[n].get("SimbadName")) if x}
    kept = []
    for r in rows:
        pos = (float(r["ra"]), float(r["dec"]))
        # a census star, by name or within 3 arcmin of its J2000 position
        if norm(r["target_name"]) in known or any(sep(pos, s) < 180.0 for s in searched):
            continue
        if not any(sep(pos, k["pos"]) < 10.0 for k in kept):
            kept.append(dict(name=archive_tag(r["target_name"].strip()), pos=pos, nights=int(r["nights"]), span=float(r["t1"]) - float(r["t0"])))
    print("%d beyond the census, names joined; matching each to Gaia DR3" % len(kept), flush=True)

    def gaia(k):
        # a cone-only query keeps the archive on its sky index
        q_ = ("SELECT source_id, ra, dec, pmra, pmdec, phot_g_mean_mag, bp_rp, parallax, ruwe FROM gaiadr3.gaia_source WHERE CONTAINS(POINT('ICRS', ra, dec), "
              "CIRCLE('ICRS', %.6f, %.6f, %.6f)) = 1" % (k["pos"][0], k["pos"][1], 30.0 / 3600.0))
        try:
            g = [x for x in archive_tap("gaia", q_, timeout=120) if 3.0 < (planets_num(x.get("phot_g_mean_mag")) or 99.0) < 13.5]
        except Exception:
            g = []
        return k, (min(g, key=lambda x: planets_num(x["phot_g_mean_mag"])) if g else None)
    out_rows, names, sources = [], set(), set()
    for k, g in archive_pmap(gaia, kept, threads=threads):
        G, c, plx, pmra, pmdec = (planets_num(g.get(x)) for x in ("phot_g_mean_mag", "bp_rp", "parallax", "pmra", "pmdec")) if g else (float("nan"),) * 5
        if not (math.isfinite(G) and math.isfinite(c)) or g["source_id"] in sources:
            continue
        # the Gaia position carried back from 2016.0 to J2000
        dec0 = float(g["dec"]) - (pmdec if math.isfinite(pmdec) else 0.0) * 16.0 / 3.6e6
        ra0 = float(g["ra"]) - (pmra if math.isfinite(pmra) else 0.0) * 16.0 / 3.6e6 / math.cos(math.radians(dec0))
        if any(sep((ra0, dec0), s) < 10.0 for s in searched):
            continue
        sources.add(g["source_id"])
        cls = "A" if c < 0.45 else "F" if c < 0.78 else "G" if c < 0.98 else "K" if c < 1.85 else "M"
        giant = math.isfinite(plx) and plx > 0 and G + 5.0 * math.log10(plx / 100.0) < 2.5
        name = k["name"] if k["name"] not in names else "%s_%d" % (k["name"], len(names))
        names.add(name)
        out_rows.append(dict(Name=name, SpType=cls + ("III" if giant else "V"), Vmag=round(G - (-0.02704 + 0.01424 * c - 0.2156 * c * c + 0.01426 * c ** 3), 2),
                             RAJ2000=round(ra0, 6), DEJ2000=round(dec0, 6), SimbadName=archive_simbad_near(ra0, dec0) or "", nights=k["nights"], span_d=round(k["span"]),
                             gaia_source_id=g["source_id"], ruwe=g.get("ruwe", "")))
    folder = os.path.join(out, "planets")
    os.makedirs(folder, exist_ok=True)
    planets_write(os.path.join(folder, "bank_stars.csv"), out_rows, list(out_rows[0].keys()))
    with open(os.path.join(folder, "bank_velocities.csv"), "w", newline="", encoding="utf-8") as f:
        f.write(open(planets_path("bank_velocities.csv"), encoding="utf-8").readline())
    planets_write(os.path.join(folder, "dace.csv"), [], planets_DACE_KEYS)
    planets_share_tables(archive_DATA, out)
    json.dump(dict(inst=inst, min_nights=min_nights, min_span=min_span, stars=len(out_rows)), open(os.path.join(folder, "measure.json"), "w"), separators=(",", ":"))
    print("%d %s targets with %d nights over %d days; %d after joining names; %d with a Gaia source beyond the census, %d of them F to M" % (
        len(rows), inst, min_nights, min_span, len(kept), len(out_rows), sum(1 for r in out_rows if planets_late_type(r["SpType"]))), flush=True)


# ESO's catalogue of HARPS pipeline velocities, one row per spectrum (doi:10.18727/archive/33)
planets_RVCAT = "https://dataportal.eso.org/dataportal_new/file/ADP.2023-12-04T15:16:53.464"


def planets_rvcat(out, min_nights=4):
    """The stars of ESO's HARPS radial-velocity catalogue (HARPS_RVCAT_2023_DR1) that the HARPS-RVBank does not hold, set up as a data root of their own
    with the catalogue's pipeline velocities as its bank, so that census, merge, followup and ledger run there as they run here. A spectrum keeps its
    drift-corrected CCF velocity and error where it is of a star, the velocity is within 1000 km/s, the error lies between 0 and 1 km/s and SIMBAD's
    object lies within 10 arcsec of the pointing, or as far as its proper motion carries it from J2000 to the observation. Spectra are grouped by SIMBAD's
    identifier, each star keeping the instrument mode and mask of most of its spectra, named after its most frequent target name, with SIMBAD's spectral
    type, magnitudes and J2000 position; a star the bank holds, by SIMBAD identifier, name or within 3 arcmin of its position, and one with fewer than
    MIN_NIGHTS nights are left out. Writes OUT/planets/bank_stars.csv, bank_velocities.csv, an empty dace.csv, the archive's planets and rvcat.json."""
    from astropy.io import fits
    path = planets_path("HARPS_RVCAT_2023_DR1.fits")
    if not os.path.exists(path):
        archive_save(path, archive_get(planets_RVCAT, timeout=1800))
    d = fits.getdata(path, 1)
    col = lambda k: np.asarray(d[k])
    text = lambda k: np.char.strip(col(k).astype(str))
    rv, err, sid = col("drs_ccf_rvc").astype(float), col("drs_dvrms").astype(float), text("main_id_simbad")
    mjd = col("mjd_obs").astype(float)
    pm = np.hypot(np.nan_to_num(col("pmra_simbad").astype(float)), np.nan_to_num(col("pmdec_simbad").astype(float)))
    reach = 10.0 + 1.2 * pm / 1000.0 * np.abs((mjd - 51544.5) / 365.25)
    ok = (np.char.startswith(np.char.upper(text("dpr_type")), "STAR") & np.isfinite(rv) & (np.abs(rv) < 1000.0) & np.isfinite(err) & (err > 0) &
          (err < 1000.0) & (sid != "") & (col("angDist_simbad").astype(float) < reach))
    norm = lambda s: (lambda x: "GJ" + x[2:] if x.startswith("GL") else x)(re.sub(r"[\s_.\-*]", "", str(s or "")).upper())
    bank = planets_read(planets_path("bank_stars.csv"))
    held = {norm(x) for r in bank for x in (r["Name"], r.get("SimbadName")) if x}
    bpos = np.array([[planets_num(r["RAJ2000"]), planets_num(r["DEJ2000"])] for r in bank])
    mode, mask, obj = text("ins_mode"), text("drs_mask"), text("tel_object")
    groups = {}
    for i in np.where(ok)[0]:
        groups.setdefault(sid[i], []).append(i)
    stars, vel, names = [], [], set()
    for s, idx in sorted(groups.items()):
        idx = np.array(idx)
        keys = [(mode[i], mask[i]) for i in idx]
        top = max(set(keys), key=keys.count)
        idx = idx[[k == top for k in keys]]
        if len(np.unique(np.floor(mjd[idx] + 0.3))) < min_nights:
            continue
        i0 = idx[0]
        ra, dec = float(d["ra_simbad"][i0]), float(d["dec_simbad"][i0])
        sep = np.hypot((bpos[:, 0] - ra) * math.cos(math.radians(dec)), bpos[:, 1] - dec) * 3600.0
        targets = [obj[i] for i in idx]
        name = archive_tag(max(set(targets), key=targets.count).replace(" ", ""))
        if norm(s) in held or norm(name) in held or np.nanmin(sep) < 180.0:
            continue
        name = name if name not in names else "%s_%d" % (name, len(names))
        names.add(name)
        num = lambda k: archive_num(d[k][i0], "")
        stars.append(dict(recno=len(stars) + 1, Nrv=len(idx), Name=name, RAJ2000=round(ra, 6), DEJ2000=round(dec, 6), SpType=str(d["sp_type_simbad"][i0]).strip(),
                          Teff="", Bmag=num("Bmag_simbad"), Vmag=num("Vmag_simbad"), Gmag="", Dist="", SimbadName=s))
        vel += [dict(Name=name, BJD=float(d["drs_bjd"][i]), DRVmlcnzp=round(1000.0 * rv[i], 3), e_DRVmlcnzp=round(float(err[i]), 3), FWHMDRS=float(d["drs_ccf_fwhm"][i]),
                     BIS=float(d["drs_bis_span"][i]), SNRDRS=float(d["drs_snr"][i])) for i in idx]
    folder = os.path.join(out, "planets")
    os.makedirs(folder, exist_ok=True)
    planets_write(os.path.join(folder, "bank_stars.csv"), stars, ["recno", "Nrv", "Name", "RAJ2000", "DEJ2000", "SpType", "Teff", "Bmag", "Vmag", "Gmag", "Dist",
                                                                   "SimbadName"])
    planets_write(os.path.join(folder, "bank_velocities.csv"), vel, ["Name", "BJD", "DRVmlcnzp", "e_DRVmlcnzp", "CRX", "e_CRX", "dLW", "e_dLW", "Halpha", "e_Halpha",
                                                                      "NaD1", "NaD2", "FWHMDRS", "BIS", "SNRDRS"])
    planets_write(os.path.join(folder, "dace.csv"), [], planets_DACE_KEYS)
    planets_share_tables(archive_DATA, out)
    json.dump(dict(catalogue="HARPS_RVCAT_2023_DR1", doi="10.18727/archive/33", spectra=int(ok.sum()), stars=len(stars), velocities=len(vel)),
              open(os.path.join(folder, "rvcat.json"), "w"), separators=(",", ":"))
    print("%d of %d spectra with a velocity and a SIMBAD object; %d stars the bank does not hold with %d nights or more, %d of them F to M, %d velocities" % (
        int(ok.sum()), len(rv), len(stars), min_nights, sum(1 for r in stars if planets_late_type(r["SpType"])), len(vel)), flush=True)


# the published velocity tables planets_tables reads, at VizieR's sites: the California Legacy Survey's stars, velocities and false positives (Rosenthal et al. 2021), Butler et al.'s (2017) HIRES stars with those velocities as Tal-Or et al. (2019) corrected them, and the Lick
# planet search's stars and velocities (Fischer et al. 2014); the publications' codes name the series
planets_TABLES = dict(cls_stars="J/ApJS/255/8/table2", cls="J/ApJS/255/8/table6", cls_false="J/ApJS/255/8/table7", butler_stars="J/AJ/153/208/targets", butler="J/MNRAS/484/L8/table1", lick_stars="J/ApJS/210/5/table1", lick="J/ApJS/210/5/table2")
planets_TABLE_CODES = dict(cls="2021ApJS..255....8R", butler="2019MNRAS.484L...8T", lick="2014ApJS..210....5F")
# HIRES's detector upgrade of 2004 August (MJD)
planets_HIRES_UPGRADE = 53220.0


def planets_simbad_stars(oids):
    """The position, main identifier, spectral type and magnitudes of SIMBAD's objects OIDS, from the mirror's tables: oid to a dict of ra, dec, main, sp and mags, filter to magnitude."""
    import pyarrow as pa
    import pyarrow.compute as pc
    basic = archive_simbad_table("basic", ("oid", "ra", "dec", "main_id", "sp_type"))
    basic = basic.filter(pc.is_in(basic["oid"], value_set=pa.array(sorted(set(oids)), type=basic["oid"].type)))
    place = {o: dict(ra=a, dec=d, main=m, sp=s, mags={}) for o, a, d, m, s in zip(*(basic[c].to_pylist() for c in ("oid", "ra", "dec", "main_id", "sp_type")))}
    flux = archive_simbad_table("flux", ("oidref", "filter", "flux"))
    flux = flux.filter(pc.is_in(flux["oidref"], value_set=pa.array(sorted(place), type=flux["oidref"].type)))
    for o, f, x in zip(*(flux[c].to_pylist() for c in ("oidref", "filter", "flux"))):
        place[o]["mags"][f] = x
    return place


def planets_tables(out, min_nights=4):
    """The stars of the published HIRES tables (planets_TABLES) the census does not search, set up as a data root of their own, so that census, merge, followup and ledger run there as they run here. A star is known by SIMBAD's object of its name; its bank is the California Legacy Survey's HIRES velocities where it
    holds the star and Tal-Or et al.'s otherwise, each with its S index, before and after HIRES's upgrade of 2004 two series; where the Survey holds it Tal-Or et al.'s velocities are the same spectra's second reduction, and the Survey's APF and Lick velocities, or the Lick search's own, dewar by dewar, its other instruments, written
    as OUT/planets/dace.csv. Left out are a star the census searches, by SIMBAD's object or within 10 arcsec of its J2000 position, one SIMBAD does not place, and one with fewer than MIN_NIGHTS nights. Writes OUT/planets/bank_stars.csv, bank_velocities.csv, dace.csv, cls_false_positives.csv, the archive's planets and bank.json."""
    # each table read once, kept in OUT/planets/tables/, a pause after each
    os.makedirs(os.path.join(out, "planets", "tables"), exist_ok=True)
    tables = {}
    for k, source in planets_TABLES.items():
        kept = os.path.join(out, "planets", "tables", k + ".csv")
        if os.path.exists(kept):
            tables[k] = planets_read(kept)
            continue
        tables[k] = archive_vizier_table(source)
        tmp = archive_tmp(kept)
        planets_write(tmp, tables[k], list(tables[k][0]))
        archive_place(tmp, kept)
        time.sleep(30)
    print(", ".join("%s %d rows" % (k, len(v)) for k, v in tables.items()), flush=True)
    hd = lambda n: "HD %s" % n if n.isdigit() else n
    lick_names = {r["Name"]: hd(r["Name"]) for r in tables["lick_stars"]}
    butler_names = {r["Name"]: r["SimbadName"] for r in tables["butler_stars"]}
    cls_names = {r["CPS"]: r["SimbadName"] for r in tables["cls_stars"]}
    every = sorted({n for names in (lick_names, butler_names, cls_names) for n in names.values() if n})
    oids = archive_simbad_oids(every)
    bank0 = planets_read(planets_path("bank_stars.csv"))
    census = [r for r in bank0 if r["Name"] in planets_eligible({x["Name"]: x for x in bank0}, planets_bank_series())]
    held = set(archive_simbad_oids(sorted({r["SimbadName"] for r in census if r.get("SimbadName")})).values())
    cra, cdec = np.array([planets_num(r["RAJ2000"]) for r in census]), np.array([planets_num(r["DEJ2000"]) for r in census])
    place = planets_simbad_stars(oids.values())
    by = {}
    of = lambda names, k: oids.get(names.get(k))
    for r in tables["cls"]:
        o = of(cls_names, r["CPS"])
        if o and archive_num(r["RVel"]) is not None and archive_num(r["e_RVel"]):
            by.setdefault(o, {}).setdefault("cls_" + r["Inst"], []).append((float(r["BJD"]), float(r["RVel"]), float(r["e_RVel"]), planets_num(r.get("SVal"))))
    for r in tables["butler"]:
        o = of(butler_names, r["Name"])
        if o and archive_num(r["RVcor"]) is not None and archive_num(r["e_RVcor"]):
            by.setdefault(o, {}).setdefault("butler", []).append((float(r["BJD"]), float(r["RVcor"]), float(r["e_RVcor"]), planets_num(r.get("S"))))
    for r in tables["lick"]:
        o = of(lick_names, r["Name"])
        if o and archive_num(r["RVel"]) is not None and archive_num(r["e_RVel"]):
            by.setdefault(o, {}).setdefault("lick_%s" % r["CCD"], []).append((float(r["JD"]) + 2400000.0, float(r["RVel"]), float(r["e_RVel"]), float("nan")))
    star_rows, vel, dace, names, left = [], [], [], set(), dict(census=0, place=0, nights=0, no_hires=0)
    mjd = lambda x: x - 2400000.5
    for o, sets in sorted(by.items()):
        p = place.get(o)
        if o in held:
            left["census"] += 1
            continue
        if not p or p["ra"] is None or p["dec"] is None:
            left["place"] += 1
            continue
        ra, dec = float(p["ra"]), float(p["dec"])
        if len(cra) and np.nanmin(np.hypot(((cra - ra + 180.0) % 360.0 - 180.0) * math.cos(math.radians(dec)), cdec - dec)) * 3600.0 < 10.0:
            left["census"] += 1
            continue
        cps = sets.get("cls_j", []) + sets.get("cls_k", [])
        bank = sorted(cps or sets.get("butler", []))
        if not bank:
            left["no_hires"] += 1
            continue
        if len({math.floor(mjd(x[0]) + 0.3) for x in bank}) < min_nights:
            left["nights"] += 1
            continue
        name = archive_tag(re.sub(r"^[*\s]+", "", " ".join(str(p["main"]).split())).replace(" ", ""))
        name = name if name not in names else "%s_%d" % (name, len(names))
        names.add(name)
        vmag, bmag = archive_num(p["mags"].get("V"), ""), archive_num(p["mags"].get("B"), "")
        star_rows.append(dict(recno=len(star_rows) + 1, Nrv=len(bank), Name=name, RAJ2000=round(ra, 6), DEJ2000=round(dec, 6), SpType=str(p["sp"] or "").strip(), Teff="", Bmag=bmag, Vmag=vmag, Gmag="", Dist="", SimbadName=str(p["main"]).strip()))
        vel += [dict(Name=name, BJD=x[0], DRVmlcnzp=x[1], e_DRVmlcnzp=x[2], S=x[3] if math.isfinite(x[3]) else "") for x in bank]
        row = lambda inst, code, x: dict(name=name, dace_name=name, inst=inst, drs=code, mode="", mjd=mjd(x[0]), rv=x[1], rv_err=x[2], qc="", smw=x[3] if math.isfinite(x[3]) else "", halpha="", fwhm="", bis="", sn50="")
        if cps:
            dace += [row("HIRES-PRE04" if mjd(x[0]) < planets_HIRES_UPGRADE else "HIRES-POST04", planets_TABLE_CODES["butler"], x) for x in sets.get("butler", [])]
            dace += [row("APF", planets_TABLE_CODES["cls"], x) for x in sets.get("cls_apf", [])]
        if sets.get("cls_lick"):
            dace += [row("LICK", planets_TABLE_CODES["cls"], x) for x in sets["cls_lick"]]
        else:
            dace += [row("LICK%s" % k[5:], planets_TABLE_CODES["lick"], x) for k, xs in sets.items() if k.startswith("lick_") for x in xs]
    folder = os.path.join(out, "planets")
    os.makedirs(folder, exist_ok=True)
    planets_write(os.path.join(folder, "bank_stars.csv"), star_rows, ["recno", "Nrv", "Name", "RAJ2000", "DEJ2000", "SpType", "Teff", "Bmag", "Vmag", "Gmag", "Dist", "SimbadName"])
    planets_write(os.path.join(folder, "bank_velocities.csv"), vel, ["Name", "BJD", "DRVmlcnzp", "e_DRVmlcnzp", "CRX", "e_CRX", "dLW", "e_dLW", "Halpha", "e_Halpha", "NaD1", "NaD2", "FWHMDRS", "BIS", "SNRDRS", "S"])
    planets_write(os.path.join(folder, "dace.csv"), dace, planets_DACE_KEYS)
    planets_write(os.path.join(folder, "cls_false_positives.csv"), tables["cls_false"])
    planets_share_tables(archive_DATA, out)
    json.dump(dict(family="HIRES", upgrade=planets_HIRES_UPGRADE, label="HIRES, first reduction", second_label="HIRES, second reduction", catalogues=planets_TABLE_CODES), open(os.path.join(folder, "bank.json"), "w"), separators=(",", ":"))
    late = sum(1 for r in star_rows if planets_late_type(r["SpType"]))
    print("%d stars, %d of them F to M, %d bank velocities, %d of other series; left out: %s" % (len(star_rows), late, len(vel), len(dace), left), flush=True)


# the SOPHIE archive at Haute-Provence: its tables' query, the one-dimensional spectrum of a sequence, and the date (MJD) of the fibre change of 2011 that moved its zero point (Perruchot et al. 2011)
planets_SOPHIE, planets_SOPHIE_FILE, planets_SOPHIE_UPGRADE = "http://atlas.obs-hp.fr/sophie/sophie.cgi?", "c=i&a=mime:application/fits&o=sophie:[s1d,%s]", 55730.0
# HARPS-N's change of detector of 2012 September, which moved its zero point (MJD)
planets_HARPSN_UPGRADE = 56197.0
# NEID's archive at the NASA Exoplanet Science Institute, and the date (MJD) of its return to the sky after the fire of 2022, a series on either side
planets_NEID_TAP, planets_NEID_UPGRADE = "https://neid.ipac.caltech.edu/TAP/sync", 59880.0


def planets_zero_curve(keys, t, v, e, width=90.0, least=8):
    """The slow drift of a spectrograph's zero point from its quieter stars: each series of KEYS's velocities V (m/s) at times T with errors E taken about its own weighted mean, the series of ten velocities or more whose robust scatter lies in the lower half of those, and in each bin of WIDTH days the median over those series of their mean there, where LEAST series have one; three passes, each series' mean taken after the last pass's curve. Returns the bins' times and the curve about its median, read between them by linear interpolation; a bin's median of whole series leaves no one star's own signal in it."""
    ids = np.unique(keys, return_inverse=True)[1]
    w = 1.0 / (np.asarray(e, float) ** 2 + 4.0)
    bins = np.floor((t - t.min()) / width).astype(int)
    order = np.argsort(ids, kind="stable")
    starts = np.searchsorted(ids[order], np.arange(int(ids.max()) + 1))
    groups = np.split(order, starts[1:])
    at, curve = np.array([t.min(), t.max()]), np.zeros(2)
    for _ in range(3):
        z = np.interp(t, at, curve)
        means = np.bincount(ids, w * (v - z)) / np.bincount(ids, w)
        r = v - z - means[ids]
        scatter = np.array([1.4826 * np.median(np.abs(r[g] - np.median(r[g]))) if len(g) >= 10 else np.inf for g in groups])
        quiet = scatter <= np.median(scatter[np.isfinite(scatter)])
        use = quiet[ids]
        pairs = bins[use].astype(np.int64) * (int(ids.max()) + 1) + ids[use]
        keys_, inv = np.unique(pairs, return_inverse=True)
        star_mean = np.bincount(inv, (w * (v - means[ids]))[use]) / np.bincount(inv, w[use])
        star_bin = keys_ // (int(ids.max()) + 1)
        have = [(b, float(np.median(star_mean[star_bin == b]))) for b in np.unique(star_bin) if (star_bin == b).sum() >= least]
        at = t.min() + (np.array([b for b, _ in have]) + 0.5) * width
        curve = np.array([x for _, x in have])
        curve = curve - np.median(curve)
    return at, curve


def planets_name_forms(name):
    """The forms in which SIMBAD may know a star an observing archive names NAME: as it stands with the catalogue number's leading zeros gone, and written as the survey it comes from writes it."""
    n = re.sub(r"^(HD|HIP|GJ|GL|HR|TYC)0+(?=\d)", r"\1", name.strip())
    x = re.sub(r"[\s_-]", "", n).upper()
    forms = [n]
    for pattern, form in ((r"^TOI0*(\d+)$", "TOI-%s"), (r"^K0*(\d+)$", "KOI-%s"), (r"^KOI0*(\d+)$", "KOI-%s"), (r"^EP(\d+)$", "EPIC %s"), (r"^EPIC(\d+)$", "EPIC %s"), (r"^KIC(\d+)$", "KIC %s"), (r"^GL(\d+.*)$", "GJ %s"), (r"^GJ(\d+.*)$", "GJ %s"),
                          (r"^WASP(\d+)$", "WASP-%s"), (r"^KEPLER(\d+)$", "Kepler-%s"), (r"^HATP(\d+)$", "HAT-P-%s"), (r"^XO(\d+)$", "XO-%s"), (r"^TRES(\d+)$", "TrES-%s"), (r"^KELT(\d+)$", "KELT-%s"), (r"^QATAR(\d+)$", "Qatar-%s"), (r"^COROT(\d+)$", "CoRoT-%s"), (r"^K2(\d+)$", "K2-%s")):
        m = re.match(pattern, x)
        if m:
            forms.append(form % m.group(1))
    return forms


def planets_archive_root(out, rows, family, label, spectra, upgrade, min_nights, code):
    """A spectrograph's whole archive set up as a data root of its own, so that census, merge, followup and ledger run there as they run here: ROWS, a dict for each science velocity with its object's name, position (J2000, degrees), mask, mode ("main", "second" for the same spectra's other reduction, or another, a mode of its own being another instrument's), time (MJD), velocity and error (m/s), width, bisector, signal-to-noise and the identifier of its spectrum. A star is known to SIMBAD by the archive's name for it (planets_name_forms) where that object lies within five arcminutes of the archive's position, or else as the brightest of its objects within 10 arcsec of that position, names of one object joined. Its bank is its velocities in the main mode under the mask most of them share, on either side of the date UPGRADE that moved the zero point, less the slow drift of the zero point its quieter stars show (planets_zero_curve). A second reduction, less its own drift, is written as OUT/planets/dace.csv; where the archive holds none, one comes from the star's own one-dimensional spectra, listed in OUT/planets/spectra.csv, measured when a signal or a companion wants it (planets_lbl, planets_reduce, planets_companion). Left out are a star SIMBAD does not place and one with fewer than MIN_NIGHTS nights. Writes OUT/planets/bank_stars.csv, bank_velocities.csv, dace.csv, spectra.csv, zero_points.csv, the archive's planets and bank.json."""
    objects = sorted({r["objname"] for r in rows})
    first = {}
    for r in rows:
        first.setdefault(r["objname"], r)
    forms = {n: planets_name_forms(n) for n in objects}
    oids = archive_simbad_oids(sorted({f for fs in forms.values() for f in fs}))
    place = planets_simbad_stars(oids.values())

    def agrees(n, o):
        # a name holds where its object lies within five arcminutes of the archive's position, which a programme's own label for a star need not
        p, x = place.get(o), first[n]
        if not p or p["ra"] is None or p["dec"] is None:
            return False
        sep = math.hypot(((float(p["ra"]) - x["ra"] + 180.0) % 360.0 - 180.0) * math.cos(math.radians(float(p["dec"]))), float(p["dec"]) - x["dec"]) * 3600.0
        return not sep >= 300.0
    oid_of = {n: next((oids[f] for f in forms[n] if f in oids and agrees(n, oids[f])), None) for n in objects}
    unplaced = [n for n in objects if oid_of[n] is None]
    near = archive_simbad_within([(first[n]["ra"], first[n]["dec"]) for n in unplaced])
    place.update(planets_simbad_stars([o for x in near for o in x]))
    for n, candidates in zip(unplaced, near):
        known = [o for o in candidates if o in place]
        # the star the spectrograph pointed at, the brightest object there, the nearest where SIMBAD gives none a magnitude
        lit = [o for o in known if archive_num(place[o]["mags"].get("V")) is not None]
        oid_of[n] = min(lit, key=lambda o: place[o]["mags"]["V"]) if lit else known[0] if known else None
    by = {}
    for r in rows:
        if oid_of[r["objname"]] is not None:
            by.setdefault(oid_of[r["objname"]], []).append(r)
    left = dict(place=sum(1 for n in objects if oid_of[n] is None), nights=0)
    commonest = lambda xs: [x for x in xs if x["mask"] == max(set(y["mask"] for y in xs), key=[y["mask"] for y in xs].count)]
    bank, other, second = {}, {}, {}
    for o, xs in by.items():
        bank[o] = sorted(commonest([x for x in xs if x["mode"] == "main"]), key=lambda x: x["mjd"]) if any(x["mode"] == "main" for x in xs) else []
        second[o] = sorted(commonest([x for x in xs if x["mode"] == "second"]), key=lambda x: x["mjd"]) if any(x["mode"] == "second" for x in xs) else []
        other[o] = sorted(commonest([x for x in xs if x["mode"] not in ("main", "second")]), key=lambda x: x["mjd"]) if any(x["mode"] not in ("main", "second") for x in xs) else []
    keep = [o for o in bank if place[o]["ra"] is not None and place[o]["dec"] is not None and len({math.floor(x["mjd"] + 0.3) for x in bank[o]}) >= min_nights]
    left["nights"] = len(bank) - len(keep)
    series = np.array([2 * o + (x["mjd"] >= upgrade) for o in keep for x in bank[o]], np.int64)
    tt, vv, ee = (np.array([x[k] for o in keep for x in bank[o]], float) for k in ("mjd", "v", "e"))
    at, curve = planets_zero_curve(series, tt, vv, ee)
    at2, curve2 = None, None
    if any(second[o] for o in keep):
        at2, curve2 = planets_zero_curve(np.array([2 * o + (x["mjd"] >= upgrade) for o in keep for x in second[o]], np.int64), *(np.array([x[k] for o in keep for x in second[o]], float) for k in ("mjd", "v", "e")))
    star_rows, vel, dace, listed, names = [], [], [], [], set()
    for o in keep:
        p = place[o]
        counts = {}
        for x in bank[o]:
            counts[x["objname"]] = counts.get(x["objname"], 0) + 1
        top = max(counts, key=counts.get)
        name = archive_tag(planets_name_forms(top)[0].replace(" ", ""))
        name = name if name not in names else "%s_%d" % (name, len(names))
        names.add(name)
        star_rows.append(dict(recno=len(star_rows) + 1, Nrv=len(bank[o]), Name=name, RAJ2000=round(float(p["ra"]), 6), DEJ2000=round(float(p["dec"]), 6), SpType=str(p["sp"] or "").strip(), Teff="", Bmag=archive_num(p["mags"].get("B"), ""),
                              Vmag=archive_num(p["mags"].get("V"), ""), Gmag=archive_num(p["mags"].get("G"), ""), Dist="", SimbadName=str(p["main"]).strip()))
        vel += [dict(Name=name, BJD=x["mjd"] + 2400000.5, DRVmlcnzp=round(x["v"] - float(np.interp(x["mjd"], at, curve)), 3), e_DRVmlcnzp=round(x["e"], 3), FWHMDRS=x["fwhm"], BIS=x["span"], SNRDRS=x["snr"]) for x in bank[o]]
        listed += [dict(name=name, seq=x["id"], mjd=round(x["mjd"], 5), snr=x["snr"]) for x in bank[o]]
        dace += [dict(name=name, dace_name=name, inst="%s-%s" % (family, x["mode"]), drs="CCF", mode="", mjd=x["mjd"], rv=x["v"], rv_err=x["e"], qc="", smw="", halpha="", fwhm=x["fwhm"], bis=x["span"], sn50=x["snr"]) for x in other[o]]
        dace += [dict(name=name, dace_name=name, inst=family, drs=code, mode="", mjd=x["mjd"], rv=round(x["v"] - float(np.interp(x["mjd"], at2, curve2)), 3), rv_err=round(x["e"], 3), qc="", smw="", halpha="", fwhm=x["fwhm"], bis=x["span"], sn50=x["snr"]) for x in second[o]]
    folder = os.path.join(out, "planets")
    os.makedirs(folder, exist_ok=True)
    planets_write(os.path.join(folder, "bank_stars.csv"), star_rows, ["recno", "Nrv", "Name", "RAJ2000", "DEJ2000", "SpType", "Teff", "Bmag", "Vmag", "Gmag", "Dist", "SimbadName"])
    planets_write(os.path.join(folder, "bank_velocities.csv"), vel, ["Name", "BJD", "DRVmlcnzp", "e_DRVmlcnzp", "CRX", "e_CRX", "dLW", "e_dLW", "Halpha", "e_Halpha", "NaD1", "NaD2", "FWHMDRS", "BIS", "SNRDRS", "S"])
    planets_write(os.path.join(folder, "dace.csv"), dace, planets_DACE_KEYS)
    planets_write(os.path.join(folder, "spectra.csv"), listed, ["name", "seq", "mjd", "snr"])
    planets_write(os.path.join(folder, "zero_points.csv"), [dict(mjd=round(float(a_), 2), zero=round(float(c), 3)) for a_, c in zip(at, curve)], ["mjd", "zero"])
    planets_share_tables(archive_DATA, out)
    json.dump(dict(family=family, upgrade=upgrade, label=label, second_label=family + ", second reduction", spectra=spectra, catalogues={family: code}), open(os.path.join(folder, "bank.json"), "w"), separators=(",", ":"))
    print("%d stars, %d of them F to M, %d bank velocities, %d of its other mode, the zero point's %d bins from %+.1f to %+.1f m/s; left out: %s" % (len(star_rows), sum(1 for r in star_rows if planets_late_type(r["SpType"])), len(vel), len(dace), len(at), curve.min(), curve.max(), left), flush=True)


def planets_sophie(out, min_nights=4):
    """The stars of the SOPHIE archive (planets_SOPHIE) set up as a data root (planets_archive_root): the pipeline's cross-correlation velocities of its science spectra with realistic errors below 50 m/s, the high-resolution mode its main one, the high-efficiency mode's velocities another instrument's, across the fibre change of 2011."""
    from astropy.coordinates import SkyCoord

    def table(ask):
        lines = archive_get(planets_SOPHIE + ask + "&a=csv%5B%2C%5D", timeout=900).decode("latin-1", "replace").splitlines()
        return list(csv.DictReader(io.StringIO("\n".join(x for x in lines if x and not x.startswith("#")))))
    mode = {r["seq"]: r["mode"] for r in table("n=sophie&d=seq,mode")}
    raw = sorted(table("n=sophiescc&d=seq,objname,mask,ccf_offline,rv,fwhm,err,span,obstype,sn26,bjd,ra,dec"), key=lambda x: x["ccf_offline"])
    # the archive's positions are B1950's
    ra, dec = np.array([planets_num(r["ra"]) for r in raw]), np.array([planets_num(r["dec"]) for r in raw])
    good = np.isfinite(ra) & np.isfinite(dec)
    icrs = SkyCoord(ra[good], dec[good], unit="deg", frame="fk4").icrs
    ra[good], dec[good] = icrs.ra.deg, icrs.dec.deg
    rows, seen = [], set()
    # the online reduction of a sequence and mask ahead of an offline one
    for r, a_, d_ in zip(raw, ra.tolist(), dec.tolist()):
        t, v, e = (planets_num(r[k]) for k in ("bjd", "rv", "err"))
        m = mode.get(r["seq"])
        if r["obstype"] == "SCI" and m in ("HR", "HE") and math.isfinite(t) and math.isfinite(v) and 0 < e < 0.05 and (r["seq"], r["mask"]) not in seen:
            seen.add((r["seq"], r["mask"]))
            rows.append(dict(objname=r["objname"], ra=a_, dec=d_, mask=r["mask"], mode="main" if m == "HR" else m, mjd=t - 2400000.5, v=1000.0 * v, e=1000.0 * e, fwhm=r["fwhm"], span=r["span"], snr=r["sn26"], id=r["seq"]))
    print("%d velocities of the science spectra" % len(rows), flush=True)
    planets_archive_root(out, rows, "SOPHIE", "SOPHIE, pipeline", "SOPHIE", planets_SOPHIE_UPGRADE, min_nights, "SOPHIE archive")


# the TNG archive's table service and files, and the keys of the two reductions' headers: the newer's cross-correlation product and the older's bisector product, each's time, velocity, error, line width, bisector span, signal-to-noise and mask
planets_TNG_TAP, planets_TNG_FILES = "http://archives.ia2.inaf.it/vo/tap/tng/", "http://archives.ia2.inaf.it/files/tng/"
planets_TNG_READ = dict(new=("QC BJD", "QC CCF RV", "QC CCF RV ERROR", "QC CCF FWHM", "QC CCF BIS SPAN", "QC ORDER50 SNR", "QC CCF MASK"), old=("DRS BJD", "DRS CCF RVC", "DRS CCF NOISE", "DRS CCF FWHM", "DRS BIS SPAN", "DRS SPE EXT SN50", "DRS CCF MASK"))


def planets_tng_listing():
    """The TNG archive's public HARPS-N science products that hold each exposure's velocity in either reduction, the solar programme's left out, from its table service by an asynchronous job: a row for each with its file, object, place and date."""
    ask = urllib.parse.urlencode(dict(REQUEST="doQuery", LANG="ADQL", FORMAT="csv", MAXREC=5000000, PHASE="RUN", QUERY="SELECT EXP_ID, OBJECT, RA, DEC, DATE_OBS FROM tng.TNG_TAP WHERE INSTRUMENT = 'HARPN' AND OBS_MODE = 'SCIENCE' AND policy = 'FREE' AND PROGRAM <> 'SOLAR' AND (EXP_ID LIKE 'r.HARPN.%CCF_A.fits.gz' OR EXP_ID LIKE 'HARPN.%bis%_A.fits.gz')")).encode()
    job = urllib.request.urlopen(urllib.request.Request(planets_TNG_TAP + "async", data=ask, headers=archive_UA), timeout=300).geturl()
    for _ in range(360):
        phase = archive_get(job + "/phase", timeout=60).decode().strip()
        if phase in ("COMPLETED", "ERROR", "ABORTED"):
            break
        time.sleep(10)
    if phase != "COMPLETED":
        raise IOError("the TNG archive's job ended %s" % phase)
    rows = csv.DictReader(io.StringIO(archive_get(job + "/results/result", timeout=1800).decode("utf-8", "replace")))
    return [r for r in rows if r["EXP_ID"].endswith("_CCF_A.fits.gz") and r["EXP_ID"].startswith("r.") or "_bis_" in r["EXP_ID"]]


def planets_harpsn(out, min_nights=4, threads=6):
    """The stars of the TNG archive's public HARPS-N spectra set up as a data root (planets_archive_root): each exposure's pipeline velocity in the archive's two reductions, the newer's its bank and the older's, corrected for its drift, its second reduction, each with its error, line width, bisector and signal-to-noise, read from its product's header and kept in OUT/planets/harpsn_products.csv as they arrive, so that a setup cut short goes on where it stopped; the newer's spectra measured line by line where a signal wants a third."""
    from astropy.io import fits
    folder = os.path.join(out, "planets")
    os.makedirs(folder, exist_ok=True)
    kept = os.path.join(folder, "harpsn_products.csv")
    keys = ["file", "object", "ra", "dec", "kind", "bjd", "rv", "err", "fwhm", "span", "snr", "mask", "check"]
    done = {r["file"] for r in planets_read(kept)} if os.path.exists(kept) else set()
    listing = planets_tng_listing()
    print("%d public products, %d already read" % (len(listing), len(done)), flush=True)
    lock = threading.Lock()
    if not done:
        planets_write(kept, [], keys)
    fh = open(kept, "a", newline="", encoding="utf-8")
    writer = csv.DictWriter(fh, fieldnames=keys)

    def angle(text, scale):
        parts = (text or "").split(":")
        return (-1.0 if parts[0].strip().startswith("-") else 1.0) * scale * sum(abs(planets_num(p)) / 60.0 ** i for i, p in enumerate(parts))

    def read(r):
        kind = "new" if r["EXP_ID"].startswith("r.") else "old"
        raw = archive_get(planets_TNG_FILES + r["EXP_ID"], timeout=300, retries=2, soft=True)
        if not raw:
            return
        try:
            H = fits.getheader(io.BytesIO(gzip.decompress(raw)))
        except (OSError, ValueError, EOFError, zlib.error):
            return
        row = dict(zip(("bjd", "rv", "err", "fwhm", "span", "snr", "mask"), (H.get("HIERARCH TNG " + k, "") for k in planets_TNG_READ[kind])))
        row.update(file=r["EXP_ID"], object=r["OBJECT"].strip(), ra=round(angle(r["RA"], 15.0), 6), dec=round(angle(r["DEC"], 1.0), 6), kind=kind, check=H.get("HIERARCH TNG QC SCIRED CHECK", ""))
        with lock:
            writer.writerow(row)
            fh.flush()
    todo = [r for r in listing if r["EXP_ID"] not in done]
    for i in range(0, len(todo), 500):
        if planets_search_ends():
            sys.exit(3)
        archive_pmap(read, todo[i:i + 500], threads)
        print("%d of %d read" % (min(i + 500, len(todo)), len(todo)), flush=True)
    fh.close()
    rows = []
    for r in planets_read(kept):
        t, v, e = planets_num(r["bjd"]), planets_num(r["rv"]), planets_num(r["err"])
        if math.isfinite(t) and math.isfinite(v) and 0 < e < 0.05 and r["check"] != "0" and r["object"].upper() not in ("SUN", "NONE", ""):
            rows.append(dict(objname=r["object"], ra=planets_num(r["ra"]), dec=planets_num(r["dec"]), mask=r["mask"], mode="main" if r["kind"] == "new" else "second", mjd=t - 2400000.5, v=1000.0 * v, e=1000.0 * e, fwhm=r["fwhm"], span=r["span"], snr=r["snr"], id=r["file"].split("_CCF_")[0]))
    print("%d velocities of the science spectra" % len(rows), flush=True)
    planets_archive_root(out, rows, "HARPS-N", "HARPS-N, newer pipeline", "HARPN", planets_HARPSN_UPGRADE, min_nights, "TNG archive")


# ELODIE's table of its cross-correlations at Haute-Provence, the floors (m/s) of its velocities with simultaneous thorium and without, and the masks it publishes for all
planets_ELODIE, planets_ELODIE_FLOOR, planets_ELODIE_MASKS = "http://atlas.obs-hp.fr/elodie/fE.cgi?n=e501&a=csv%5B%2C%5D", dict(main=7.0, OBJ=30.0), ("R37000K0", "R37000F0")


def planets_elodie(out, min_nights=4):
    """The stars of the ELODIE archive (planets_ELODIE) set up as a data root (planets_archive_root): the velocities of its object fibre's cross-correlations above a signal-to-noise of 20, already barycentric, those with simultaneous thorium its main ones and the others another instrument's, each with Queloz's (1995) error, 0.04 km/s times the root of the correlation's width over its contrast and the signal-to-noise, joined to the mode's floor (planets_ELODIE_FLOOR). The table gives each exposure's night alone, taken at its middle at Haute-Provence, a tenth of a day or two from its time, as the orbits of days and more allow. A second reduction comes from the other roots' velocities of its stars (planets_peers)."""
    text = archive_get(planets_ELODIE, timeout=900).decode("latin-1", "replace")
    rows = []
    for f in csv.reader(io.StringIO("\n".join(x for x in text.splitlines() if x and x[0] not in "#$"))):
        if len(f) < 17 or f[-11].strip() != "obj" or f[-10].strip() not in planets_ELODIE_MASKS:
            continue
        sn, v, width, contrast = (planets_num(x) for x in (f[-7], f[-6], f[-5], f[-4]))
        place = re.fullmatch(r"J(\d\d)(\d\d)(\d\d\.\d)([+-])(\d\d)(\d\d)(\d\d)", f[-16].strip())
        if not (sn >= 20.0 and abs(v) > 0.0 and width > 0.0 and contrast > 0.02 and place):
            continue
        mode = "main" if f[-9].strip().startswith("OBTH") else "OBJ"
        night = datetime.datetime.strptime(f[-13].strip(), "%Y%m%d") - datetime.datetime(1858, 11, 17)
        h, m, s, sign, dd, dm, ds = place.groups()
        rows.append(dict(objname=",".join(f[:-16]).strip(), ra=15.0 * (int(h) + int(m) / 60.0 + float(s) / 3600.0), dec=(-1.0 if sign == "-" else 1.0) * (int(dd) + int(dm) / 60.0 + int(ds) / 3600.0), mask=f[-10].strip(), mode=mode, mjd=night.days + 0.98, v=1000.0 * v, e=math.hypot(planets_ELODIE_FLOOR[mode], 40.0 * math.sqrt(width) / (sn * contrast)), fwhm=width, span="", snr=sn, id="%s/%s" % (f[-13].strip(), f[-12].strip())))
    print("%d velocities of the object fibre" % len(rows), flush=True)
    planets_archive_root(out, rows, "ELODIE", "ELODIE, pipeline", None, 99999.0, min_nights, "ELODIE archive")


def planets_neid(out, min_nights=4):
    """The stars of NEID's archive set up as a data root (planets_archive_root): the pipeline's velocities of its science spectra past their proprietary months, neither flagged nor rejected by the archive, with errors below 50 m/s, at the flux-weighted mean time of each exposure, the high-resolution mode its main one and the high-efficiency mode's velocities another instrument's, on either side of the fire of 2022. The archive's table holds one reduction, so that a second comes from the other roots' velocities of its stars (planets_peers) or from their HARPS spectra measured line by line (planets_reduce)."""
    rows, today = [], time.time() / 86400.0 + 40587.0
    for r in archive_tap(planets_NEID_TAP, "SELECT object, qrad, qdecd, obsmode, obstype, flagged, rejected, ccflines, obsmjd, ccfjdsum, ccfrvmod, dvrms, extsnr, l2propint, l2filename FROM neidl2", method="POST"):
        t, v, e, mid = planets_num(r["obsmjd"]), planets_num(r["ccfrvmod"]), planets_num(r["dvrms"]), planets_num(r["ccfjdsum"]) - 2400000.5
        if r["obstype"].strip() == "Sci" and r["flagged"].strip() == "0" and r["rejected"].strip() == "0" and planets_num(r["ccflines"]) > 0 and math.isfinite(v) and 0 < e < 0.05 and t + 30.44 * planets_num(r["l2propint"]) <= today:
            rows.append(dict(objname=r["object"].strip(), ra=planets_num(r["qrad"]), dec=planets_num(r["qdecd"]), mask="", mode="main" if r["obsmode"].strip() == "hr" else r["obsmode"].strip().upper(), mjd=mid if abs(mid - t) < 1.0 else t, v=1000.0 * v, e=1000.0 * e, fwhm="", span="", snr=r["extsnr"], id=r["l2filename"].strip()))
    print("%d velocities of the science spectra" % len(rows), flush=True)
    planets_archive_root(out, rows, "NEID", "NEID, pipeline", None, planets_NEID_UPGRADE, min_nights, "NEID archive")


# CARMENES's first data release (Ribas et al. 2023): its stars at VizieR's sites, each star's velocities and the nightly zero points at the project's archive, and the publication's code, which names the series
planets_CARMENES_STARS, planets_CARMENES_FILES, planets_CARMENES_CODE = "J/A+A/670/A139/table1", "https://carmenes.cab.inta-csic.es/gto/getDR1DataPublic.action?id=", "2023A&A...670A.139R"


def planets_carmenes(out, min_nights=4, threads=4):
    """The stars of CARMENES's first data release (planets_CARMENES_STARS) set up as a data root of their own, so that census, merge, followup and ledger run there as they run here. A star is known to SIMBAD by its Karmn identifier or its name. Its velocities are those of the spectra the release leaves unflagged: SERVAL's less each night's zero point as its bank and first reduction, and RACCOON's cross-correlation velocities less the same zero point as its second reduction, written as OUT/planets/dace.csv, with RACCOON's line width and bisector, SERVAL's chromatic index and line width, H alpha, sodium, and the mean of the three Ca II infrared lines' indices in the S index's place. The release's mass, radius, temperature and rotation period of each star are kept in its row. A star the census also searches stays, since these are other spectra. Left out are one SIMBAD does not place and one with fewer than MIN_NIGHTS nights. Writes OUT/planets/bank_stars.csv, bank_velocities.csv, dace.csv, the archive's planets and bank.json."""
    raw = archive_get(planets_VIZIER_SITES[0] + "/ftp/cats/" + planets_CARMENES_STARS.rpartition("/")[0] + "/table1.dat", timeout=120, retries=2, soft=True)
    table = [dict(Karmn=x[:11].strip(), Name=x[12:36].strip(), NAVC=x[37:40].strip(), Mass=x[45:51].strip(), Rad=x[59:65].strip(), Teff=x[73:77].strip(), Prot=x[82:88].strip())
             for x in raw.decode("latin-1").splitlines() if x.strip()] if raw else archive_vizier_table(planets_CARMENES_STARS)
    zero = {}
    for line in archive_get(planets_CARMENES_FILES + "carmenes.dr1.nzp.csv", timeout=300).decode("ascii", "replace").splitlines()[1:]:
        cells = line.split(",")
        if len(cells) >= 2 and math.isfinite(planets_num(cells[0])) and math.isfinite(planets_num(cells[1])):
            zero[int(float(cells[0]))] = float(cells[1])
    said = lambda r: ("Karmn %s" % r["Karmn"], " ".join(r["Name"].split()))
    oids = archive_simbad_oids(sorted({n for r in table for n in said(r)}))
    place = planets_simbad_stars([oids[n] for r in table for n in said(r) if n in oids])

    def fetch(r):
        raw = archive_get(planets_CARMENES_FILES + urllib.parse.quote(r["Karmn"] + "_SERVAL+RACOON.csv"), timeout=300, soft=True)
        return r, raw.decode("utf-8", "replace") if raw and raw[:4] == b"BJD," else None
    star_rows, vel, dace, names, left = [], [], [], set(), dict(no_velocities=0, place=0, nights=0)
    for r, text in archive_pmap(fetch, table, threads):
        if text is None:
            left["no_velocities"] += 1
            continue
        p = next((place[oids[n]] for n in said(r) if oids.get(n) in place and place[oids[n]]["ra"] is not None and place[oids[n]]["dec"] is not None), None)
        if not p:
            left["place"] += 1
            continue
        name = archive_tag(said(r)[1].replace(" ", ""))
        name = name if name not in names else "%s_%d" % (name, len(names))
        first, second = [], []
        for x in csv.DictReader(io.StringIO(text)):
            num = lambda k: planets_num(x.get(k))
            t = num("BJD")
            if num("FLAG") != 0.0 or not math.isfinite(t):
                continue
            ca = [y for y in (num("CAIRT1"), num("CAIRT2"), num("CAIRT3")) if math.isfinite(y)]
            S = sum(ca) / len(ca) if ca else ""
            if math.isfinite(num("AVC")) and math.isfinite(num("E_AVC")):
                first.append(dict(Name=name, BJD=x["BJD"], DRVmlcnzp=x["AVC"], e_DRVmlcnzp=x["E_AVC"], CRX=x["CRX"], e_CRX=x["E_CRX"], dLW=x["DLW"], e_dLW=x["E_DLW"], Halpha=x["HALPHA"], e_Halpha=x["E_HALPHA"], NaD1=x["NAD1"],
                                  NaD2=x["NAD2"], FWHMDRS=x["CCF_FWHM"], BIS=x["CCF_BIS"], SNRDRS=x["SNREF"], S=S))
            z = zero.get(math.floor(t))
            if z is not None and math.isfinite(num("CCF_RV")) and math.isfinite(num("CCF_E_RV")):
                second.append(dict(name=name, dace_name=name, inst="CARMENES", drs=planets_CARMENES_CODE, mode="", mjd=t - 2400000.5, rv=1000.0 * num("CCF_RV") - z, rv_err=1000.0 * num("CCF_E_RV"), qc="", smw=S, halpha=x["HALPHA"],
                                   fwhm=x["CCF_FWHM"], bis=x["CCF_BIS"], sn50=x["SNREF"]))
        if len({math.floor(float(x["BJD"]) - 2400000.5 + 0.3) for x in first}) < min_nights:
            left["nights"] += 1
            continue
        names.add(name)
        sp = str(p["sp"] or "").strip()
        star_rows.append(dict(recno=len(star_rows) + 1, Nrv=len(first), Name=name, RAJ2000=round(float(p["ra"]), 6), DEJ2000=round(float(p["dec"]), 6), SpType=sp if planets_late_type(sp) else "MV", Teff=archive_num(r.get("Teff"), ""),
                              Bmag=archive_num(p["mags"].get("B"), ""), Vmag=archive_num(p["mags"].get("V"), ""), Gmag=archive_num(p["mags"].get("G"), ""), Dist="", SimbadName=str(p["main"]).strip(), Mass=archive_num(r.get("Mass"), ""),
                              Rad=archive_num(r.get("Rad"), ""), Prot=archive_num(r.get("Prot"), ""), Karmn=r["Karmn"]))
        vel += first
        dace += second
    folder = os.path.join(out, "planets")
    os.makedirs(folder, exist_ok=True)
    planets_write(os.path.join(folder, "bank_stars.csv"), star_rows, ["recno", "Nrv", "Name", "RAJ2000", "DEJ2000", "SpType", "Teff", "Bmag", "Vmag", "Gmag", "Dist", "SimbadName", "Mass", "Rad", "Prot", "Karmn"])
    planets_write(os.path.join(folder, "bank_velocities.csv"), vel, ["Name", "BJD", "DRVmlcnzp", "e_DRVmlcnzp", "CRX", "e_CRX", "dLW", "e_dLW", "Halpha", "e_Halpha", "NaD1", "NaD2", "FWHMDRS", "BIS", "SNRDRS", "S"])
    planets_write(os.path.join(folder, "dace.csv"), dace, planets_DACE_KEYS)
    planets_share_tables(archive_DATA, out)
    json.dump(dict(family="CARMENES", upgrade=99999.0, label="CARMENES, first reduction", second_label="CARMENES, second reduction", catalogues=dict(carmenes=planets_CARMENES_CODE)), open(os.path.join(folder, "bank.json"), "w"), separators=(",", ":"))
    print("%d stars, %d first-reduction velocities, %d second-reduction velocities; left out: %s" % (len(star_rows), len(vel), len(dace), left), flush=True)


def planets_measure(streams=12, least=4):
    """The stars of a root planets_targets set up, measured from their archived spectra of the root's instrument (measure.json): each star's line-by-line
    and cross-correlation velocities from the same spectra (planets_lbl), the cross-correlation velocities written as the root's bank, each with its
    spectrum's line-by-line error, and the line-by-line velocities kept beside them as the second reduction, so that census, merge, followup and ledger run
    in the root. A star already measured is passed over; one with fewer than LEAST spectra is listed with why in measure_failed.txt."""
    inst = json.load(open(planets_path("measure.json")))["inst"]
    stars = planets_read(planets_path("bank_stars.csv"))
    listings = archive_eso_listings([(float(s["RAJ2000"]), float(s["DEJ2000"])) for s in stars], inst, 20.0)
    for i, (s, listing) in enumerate(zip(stars, listings)):
        if os.path.exists(planets_path("ccf", archive_tag(s["Name"]) + ".npz")):
            continue
        try:
            planets_lbl(s["Name"], streams=streams, least=least, listing=listing, inst=inst, ccf=True)
        except (SystemExit, Exception) as exc:
            with open(planets_path("measure_failed.txt"), "a", encoding="utf-8") as fh:
                fh.write("%s\t%s\n" % (s["Name"], str(exc)[:200].replace("\n", " ")))
        print("%d of %d stars" % (i + 1, len(stars)), flush=True)
    rows = []
    for s in stars:
        p = planets_path("ccf", archive_tag(s["Name"]) + ".npz")
        if os.path.exists(p):
            d = np.load(p)
            rows += [dict(Name=s["Name"], BJD=float(t) + 2400000.5, DRVmlcnzp=round(float(v), 3), e_DRVmlcnzp=round(float(e), 3), SNRDRS=float(sn))
                     for t, v, e, sn in zip(d["mjd"], d["v"], d["rv_err"], d["snr"]) if math.isfinite(v) and math.isfinite(e) and e > 0]
    planets_write(planets_path("bank_velocities.csv"), rows, ["Name", "BJD", "DRVmlcnzp", "e_DRVmlcnzp", "CRX", "e_CRX", "dLW", "e_dLW", "Halpha", "e_Halpha", "NaD1",
                                                               "NaD2", "FWHMDRS", "BIS", "SNRDRS"])
    print("%s: %d velocities of %d stars written as the bank" % (inst, len(rows), len({r["Name"] for r in rows})), flush=True)


def planets_bank_label():
    """The label of a root's bank velocities in a vet record: the HARPS-RVBank's SERVAL velocities, ESO's pipeline velocities in a root planets_rvcat set
    up, the cross-correlation velocities of a root planets_measure measured, or the label a root planets_tables set up gives its own."""
    if planets_BANK_INFO:
        return planets_BANK_INFO["label"]
    if os.path.exists(planets_path("rvcat.json")):
        return "ESO HARPS pipeline"
    return "orbitlight cross-correlation" if os.path.exists(planets_path("measure.json")) else "bank SERVAL"


planets_DACE_KEYS = ["name", "dace_name", "inst", "drs", "mode", "mjd", "rv", "rv_err", "qc", "smw", "halpha", "fwhm", "bis", "sn50"]


def planets_dace(threads=3, radius_arcsec=60.0, names=None, timeout=120.0):
    """DACE's public velocities of the census's stars, or in a root that planets_targets or planets_rvcat set up of every F to M star in bank_stars.csv,
    written as ROOT/dace.csv. Each star is looked up in DACE's spectroscopy database within RADIUS_ARCSEC of its J2000 position; DACE's target whose catalogue
    name is the bank's, else the one nearest the position, is the one whose time series is fetched: every instrument's series from the standard
    pipeline's CCF velocities and from publications. One row per velocity: the bank's name, DACE's, the instrument, the pipeline or publication, the
    mode, the time (MJD), the velocity and its error (m/s), the pipeline's quality flag, the Mount Wilson S index, H alpha, the CCF's FWHM and bisector
    span, and the signal-to-noise ratio at order 50, where given. Stars DACE has no frames for are listed in dace_absent.txt. Each call to DACE is given
    TIMEOUT seconds and tried four times."""
    from astropy.coordinates import Angle, SkyCoord
    from dace_query.spectroscopy import Spectroscopy
    logging.disable(logging.ERROR)
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    every = os.path.exists(planets_path("measure.json")) or os.path.exists(planets_path("rvcat.json"))
    names = [n.strip() for n in names] if names else (sorted(n for n in stars if planets_late_type(stars[n].get("SpType"))) if every else
                                                      planets_eligible(stars, planets_bank_series()))
    compact = lambda s: "".join(str(s).split()).upper()

    def retry(f, *args, **kw):
        for attempt in range(4):
            got = planets_call(f, timeout, *args, **kw)
            if got is not None:
                return got
            time.sleep(10 * (attempt + 1))
        return None

    def target(n):
        s = stars[n]
        ra, dec = float(s["RAJ2000"]), float(s["DEJ2000"])
        r = retry(Spectroscopy.query_region, sky_coord=SkyCoord(ra, dec, unit="deg"), angle=Angle(radius_arcsec, unit="arcsec"), limit=100000, output_format="dict")
        if not r or not r.get("target_name"):
            return None
        best = None
        for tn, cat, ra2, dec2 in zip(r["target_name"], r["target_catname"], r["ra_deg"], r["dec_deg"]):
            if not tn:
                continue
            d = math.hypot((float(ra2) - ra) * math.cos(math.radians(dec)), float(dec2) - dec) * 3600.0
            key = (compact(cat) not in (compact(n), compact(s.get("SimbadName", ""))), d)
            if best is None or key < best[0]:
                best = (key, tn)
        return best[1] if best else None

    def one(n):
        tn = target(n)
        if tn is None:
            return n, None, []
        g = retry(Spectroscopy.get_timeseries, tn, sorted_by_instrument=True, output_format="numpy") or {}
        rows = []
        for inst, d in g.items():
            for drs, d2 in d.items():
                for mode, d3 in d2.items():
                    m = len(d3["rjd"])
                    col = lambda key: d3[key] if key in d3 else [float("nan")] * m
                    for row in zip(d3["rjd"], d3["rv"], d3["rv_err"], col("drs_qc"), col("spectro_smw"), col("spectro_halpha"), col("ccf_fwhm"), col("ccf_bispan"),
                                   col("spectro_sn50")):
                        try:
                            vals = [float(x) for x in row]
                        except (TypeError, ValueError):
                            continue
                        if all(math.isfinite(x) for x in vals[:3]):
                            rows.append([n, tn, str(inst), str(drs), str(mode), vals[0] - 0.5] + vals[1:])
        return n, tn, rows

    os.makedirs(planets_ROOT, exist_ok=True)
    lock = threading.Lock()
    with open(planets_path("dace.csv"), "w", newline="", encoding="utf-8") as fh, open(planets_path("dace_absent.txt"), "w", encoding="utf-8") as absent:
        w = csv.writer(fh)
        w.writerow(planets_DACE_KEYS)
        done = 0
        with cf.ThreadPoolExecutor(threads) as ex:
            for f in cf.as_completed([ex.submit(one, n) for n in names]):
                n, tn, rows = f.result()
                with lock:
                    if tn is None:
                        absent.write(n + "\n")
                    w.writerows(rows)
                    done += 1
                    if done % 25 == 0:
                        fh.flush()
                        print("%d of %d stars" % (done, len(names)), flush=True)
    print("done: %d stars" % len(names), flush=True)


def planets_peers(sources):
    """Each star of the root given the velocities the other data roots SOURCES hold of it, a star being the same by SIMBAD's object: each root's bank, its first reduction and its eras together, as an instrument named by its spectrograph, appended to ROOT/dace.csv in place of what this step last put there. A census then fits them with the root's own and a vet tests each spectrograph's alone, so that a signal one spectrograph finds is held against another's; a star whose velocities this changes loses its vet record and its system analysis, so that the next decision makes them again. Returns the stars it changes."""
    here = planets_read(planets_path("bank_stars.csv"))
    said = lambda r: (r.get("SimbadName") or r["Name"]).strip()
    mine = archive_simbad_oids(sorted({said(r) for r in here}))
    home = {mine[said(r)]: r["Name"] for r in here if said(r) in mine}
    rows, counted = [], {}
    for source in sources:
        info, measured = os.path.join(source, "planets", "bank.json"), os.path.join(source, "planets", "measure.json")
        family = json.load(open(info)).get("family") if os.path.exists(info) else json.load(open(measured))["inst"] if os.path.exists(measured) else "HARPS"
        theirs = planets_read(os.path.join(source, "planets", "bank_stars.csv"))
        oids = archive_simbad_oids(sorted({said(r) for r in theirs}))
        given = {r["Name"]: home[oids[said(r)]] for r in theirs if oids.get(said(r)) in home}
        for x in csv.DictReader(open(os.path.join(source, "planets", "bank_velocities.csv"), encoding="utf-8")):
            name = given.get(x["Name"])
            v, e = planets_num(x["DRVmlcnzp"]), planets_num(x["e_DRVmlcnzp"])
            if name and math.isfinite(v) and math.isfinite(e) and abs(v) < 1e6 and 0 < e < 1e3:
                rows.append(dict(name=name, dace_name=x["Name"], inst=family, drs="CCF peer", mode="", mjd=float(x["BJD"]) - 2400000.5, rv=v, rv_err=e, qc="", smw=x.get("S", ""), halpha=x.get("Halpha", ""), fwhm=x.get("FWHMDRS", ""), bis=x.get("BIS", ""), sn50=x.get("SNRDRS", "")))
        counted[family] = len(given)
    path = planets_path("dace.csv")
    before = planets_read(path)
    kept = [r for r in before if r["drs"] != "CCF peer"]
    # a spectrograph the root's own tables already hold of a star is not given it again, nor the root's own, so that no spectra count twice
    own = json.load(open(planets_path("bank.json"))).get("family") if os.path.exists(planets_path("bank.json")) else json.load(open(planets_path("measure.json")))["inst"] if os.path.exists(planets_path("measure.json")) else None
    have = {(r["name"], planets_family(r["inst"] or "")) for r in kept}
    rows = [x for x in rows if planets_family(x["inst"] or "") != planets_family(own or "HARPS") and (x["name"], planets_family(x["inst"] or "")) not in have]
    tmp = archive_tmp(path)
    planets_write(tmp, kept + rows, planets_DACE_KEYS)
    archive_place(tmp, path)
    tally = lambda xs: {n: sum(1 for x in xs if x["name"] == n) for n in {x["name"] for x in xs}}
    old, new = tally([r for r in before if r["drs"] == "CCF peer"]), tally(rows)
    changed = sorted(n for n in set(old) | set(new) if old.get(n) != new.get(n))
    for n in changed:
        for p in (os.path.join(planets_RESULTS, "vet", archive_tag(n) + ".json"), os.path.join(planets_RESULTS, "system", archive_tag(n), "analysis.json")):
            if os.path.exists(p):
                os.remove(p)
    print("%d stars here; %d velocities of the other roots' stars: %s; %d stars changed" % (len(here), len(rows), counted, len(changed)), flush=True)
    return changed


def planets_dace_series(names=None):
    """DACE's velocities by star and series (instrument, pipeline or publication, mode), of NAMES alone where given, those the pipeline's quality control
    failed left out: rows of (MJD, velocity, error, S, H alpha, FWHM, bisector, CRX, dLW), the last two empty."""
    raw = {}
    for r in csv.DictReader(open(planets_path("dace.csv"), encoding="utf-8")):
        if names is not None and r["name"] not in names:
            continue
        v, e = planets_num(r["rv"]), planets_num(r["rv_err"])
        if math.isfinite(v) and math.isfinite(e) and 0 < e < 1e3 and planets_num(r["qc"]) != 0.0:
            raw.setdefault(r["name"], {}).setdefault((r["inst"], r["drs"], r["mode"]), []).append(
                [planets_num(r["mjd"]), v, e, planets_num(r["smw"]), planets_num(r["halpha"]), planets_num(r["fwhm"]), planets_num(r["bis"]), float("nan"), float("nan")])
    return raw


def planets_family(inst):
    """An instrument's family, its eras and upgrades together (HARPS03 and HARPS15, HIRES-PRE04 and HIRES-POST04, HARPN and HARPS-N)."""
    f = re.sub(r"(\d+|-PRE04|-POST04|\+)$", "", inst)
    return {"HARPN": "HARPS-N"}.get(f, f)


def planets_join(n, insts, bank_rows, sptype):
    """A star's series with the bank's HARPS, or the spectrograph a root's bank comes from, in place of DACE's: the bank's velocities before and after its upgrade as two series, each given the S
    index of DACE's velocity of that spectrograph within 5 minutes of it, and, for F, G and K stars, DACE's velocities of it further than that from every bank
    velocity, as series of their own: for HARPS those of its pipeline, for another spectrograph those of the second reduction a root planets_tables set up holds."""
    harps = {k: x for k, x in insts.items() if planets_family(k[0]) == planets_BANK_FAMILY}
    out = {k: x for k, x in insts.items() if planets_family(k[0]) != planets_BANK_FAMILY}
    reduction = lambda k: "CCF" in k[1] or planets_BANK_FAMILY != "HARPS"
    rows = [list(x) for x in bank_rows]
    dace = sorted((x for k, xs in harps.items() if reduction(k) for x in xs), key=lambda x: x[0])
    td = np.array([x[0] for x in dace])
    tb = np.array([x[0] for x in rows])
    if len(td) and len(tb):
        j = np.clip(np.searchsorted(td, tb), 0, len(td) - 1)
        j = np.where((j > 0) & (np.abs(td[j - 1] - tb) < np.abs(td[j] - tb)), j - 1, j)
        for i in np.where(np.abs(td[j] - tb) < 5.0 / 1440.0)[0]:
            if math.isfinite(dace[j[i]][3]):
                rows[i][3] = dace[j[i]][3]
    bank_name = "%s bank" % planets_BANK_FAMILY if planets_BANK_INFO else "HARPS-RVBank"
    for label, sel in (("pre", [x for x in rows if x[0] < planets_UPGRADE]), ("post", [x for x in rows if x[0] >= planets_UPGRADE])):
        if sel:
            out[(bank_name, "SERVAL CCF" if not planets_BANK_INFO else planets_BANK_INFO["label"], label)] = sel
    if (sptype or " ")[0] != "M":
        sb = np.sort(tb)
        for k, xs in harps.items():
            if not reduction(k):
                continue
            if len(sb):
                tk = np.array([x[0] for x in xs])
                jj = np.clip(np.searchsorted(sb, tk), 0, len(sb) - 1)
                near = np.minimum(np.abs(sb[jj] - tk), np.abs(sb[np.maximum(jj - 1, 0)] - tk))
                xs = [x for x, d in zip(xs, near) if d >= 5.0 / 1440.0]
            if xs:
                out[(k[0], k[1], k[2] + " unbanked")] = xs
    return out


def planets_clean(rows):
    """A series without the velocities whose errors exceed five times its median error or which lie further from its median than 15 times its scaled median
    absolute deviation or 30 m/s, whichever is more."""
    x = np.array(rows)
    x = x[x[:, 2] <= 5.0 * np.median(x[:, 2])]
    med = np.median(x[:, 1])
    return x[np.abs(x[:, 1] - med) <= max(15.0 * 1.4826 * np.median(np.abs(x[:, 1] - med)), 30.0)].tolist()


def planets_choose(insts):
    """One set of series per instrument family: the pipeline's CCF series where there are any, each instrument and mode from its pipeline version with the
    most velocities, else the series of the one publication with the most velocities; a publication's series is set aside when half its times or more fall
    within 5 minutes of the times already kept, and every series whose median error exceeds 20 m/s."""
    fams = {}
    for k in insts:
        fams.setdefault(planets_family(k[0]), []).append(k)
    kept = []
    for fam, ks in sorted(fams.items(), key=lambda x: -sum(len(insts[k]) for k in x[1] if "CCF" in k[1])):
        drs = [k for k in ks if "CCF" in k[1]]
        if drs:
            best = {}
            for k in drs:
                if (k[0], k[2]) not in best or len(insts[k]) > len(insts[best[(k[0], k[2])]]):
                    best[(k[0], k[2])] = k
            kept += list(best.values())
        else:
            pubs = {}
            for k in ks:
                pubs.setdefault(k[1], []).append(k)
            bib = max(pubs, key=lambda b: sum(len(insts[k]) for k in pubs[b]))
            have = np.sort(np.array([x[0] for k in kept for x in insts[k]] or [-1e9]))
            for k in pubs[bib]:
                tk = np.array([x[0] for x in insts[k]])
                j = np.clip(np.searchsorted(have, tk), 1, max(len(have) - 1, 1))
                near = np.minimum(np.abs(have[np.minimum(j, len(have) - 1)] - tk), np.abs(have[j - 1] - tk))
                if np.mean(near < 5.0 / 1440.0) < 0.5:
                    kept.append(k)
    return [k for k in kept if insts[k] and np.median([x[2] for x in insts[k]]) <= 20.0]


def planets_series(n, dace, bank, sptype):
    """A star's chosen series, cleaned and numbered from the one with most velocities: rows of (MJD, velocity, error, series number, S, H alpha, FWHM,
    bisector, CRX, dLW), and the series' labels."""
    insts = {k: planets_clean(x) for k, x in planets_join(n, dace.get(n, {}), bank.get(n, []), sptype).items() if x}
    insts = {k: x for k, x in insts.items() if x}
    keep = sorted(planets_choose(insts), key=lambda k: -len(insts[k]))
    return [x[:3] + [float(i)] + x[3:] for i, k in enumerate(keep) for x in insts[k]], [" ".join(x for x in k if x) for k in keep]


def planets_nightly(rows):
    """Rows averaged per night and series (nights split at La Silla's local noon), the velocity weighted by its inverse variance, the indicators by count."""
    s = np.asarray(rows, float)
    _, inv = np.unique(np.floor(s[:, 0] + 0.3) * 100.0 + s[:, 3], return_inverse=True)
    m = int(inv.max()) + 1
    w = 1.0 / s[:, 2] ** 2
    W = np.bincount(inv, w, m)
    cols = [np.bincount(inv, s[:, 0], m) / np.bincount(inv, minlength=m), np.bincount(inv, w * s[:, 1], m) / W, 1.0 / np.sqrt(W)]
    for j in range(3, s.shape[1]):
        ok = np.isfinite(s[:, j])
        cnt = np.bincount(inv[ok], minlength=m)
        cols.append(np.where(cnt > 0, np.bincount(inv[ok], s[ok, j], m) / np.maximum(cnt, 1), np.nan))
    return np.column_stack(cols)


def planets_known(path):
    """The archive's planets by host, and a function finding a star's host by name or by its position carried back to J2000."""
    norm = lambda s: (lambda x: "GJ" + x[2:] if x.startswith("GL") and x[2:3].isdigit() else x)(re.sub(r"[\s_]", "", str(s or "")).upper())
    host_names, host_pos, planets_of = {}, {}, {}
    for p in planets_read(path):
        planets_of.setdefault(p["hostname"], []).append(dict(name=p["pl_name"], P=planets_num(p["pl_orbper"]), K=planets_num(p["pl_rvamp"]),
                                                            e=planets_num(p["pl_orbeccen"])))
        for col in ("hostname", "hd_name", "hip_name"):
            if p.get(col):
                host_names.setdefault(norm(p[col]), p["hostname"])
        if p["hostname"] not in host_pos:
            dec = planets_num(p["dec"])
            host_pos[p["hostname"]] = (planets_num(p["ra"]) - 16.0 * np.nan_to_num(planets_num(p["sy_pmra"])) / 3.6e6 / math.cos(math.radians(dec)),
                                       dec - 16.0 * np.nan_to_num(planets_num(p["sy_pmdec"])) / 3.6e6)
    hosts = list(host_pos)
    hpos = np.array([host_pos[h] for h in hosts])

    def host_of(name, simbad, ra, dec):
        for nm in (name, simbad):
            k = norm(nm)
            for key in (k, k[:-1] if len(k) > 2 and k.endswith("A") and k[-2].isdigit() else None):
                if key and key in host_names:
                    return host_names[key]
        if not (math.isfinite(ra) and math.isfinite(dec)):
            return None
        d = np.degrees(np.arccos(np.clip(np.sin(np.radians(dec)) * np.sin(np.radians(hpos[:, 1])) + np.cos(np.radians(dec)) * np.cos(np.radians(hpos[:, 1])) *
                                         np.cos(np.radians(ra - hpos[:, 0])), -1, 1))) * 3600.0
        i = int(np.nanargmin(d))
        return hosts[i] if d[i] < 10.0 else None
    return planets_of, host_of


def planets_model(p, t, X, nk):
    """The linear part (offsets, trend, activity) and nk Keplerians, each (P, tp, sqrt(e) cos w, sqrt(e) sin w, K)."""
    nl = X.shape[1]
    out = X @ p[:nl]
    for k in range(nk):
        P, tp, c, s, K = p[nl + 5 * k:nl + 5 * k + 5]
        out = out + abs(K) * planets_kepler(t, P, tp, min(c * c + s * s, 0.9), math.atan2(s, c))
    return out


def planets_fit_many(t, v, sig, X, keps, bounds_frac):
    """The joint fit of the linear part X and the Keplerians from each set of starts in KEPS (planets_fit_batch): the set whose fit leaves the least
    chi-square, with that chi-square."""
    return planets_fit_batch([(t, v, sig, X, keps, bounds_frac)])[0]


def planets_fit_batch(asks, budget=2e8):
    """The fits of many requests ASKS, each (t, v, sig, X, keps, bounds), together by Levenberg-Marquardt (gpu_lm): the linear part X and the Keplerians
    from each set of starts in keps, least squares with the soft L1 loss at 3 sigma, each period held within its fraction of its start and each sqrt(e)
    cos w and sqrt(e) sin w within 0.95, the linear part solved first. Every start of every request is a problem, the problems of one shape (as many
    linear terms and Keplerians, nights within a factor of two) solved in blocks of at most BUDGET residuals per evaluation, each request's nights
    padded to its block's longest and the padding given no weight; for each request the start whose fit leaves the least chi-square, with that
    chi-square."""
    probs = []
    for a, (t, v, sig, X, keps, fr) in enumerate(asks):
        lin = np.linalg.lstsq(X / sig[:, None], v / sig, rcond=None)[0]
        nl, nk = X.shape[1], len(keps[0])
        for kep in keps:
            p0 = np.array(list(lin) + [x for k in kep for x in k], float)
            lo, hi = np.full(len(p0), -np.inf), np.full(len(p0), np.inf)
            for i, f_ in enumerate(fr):
                j = nl + 5 * i
                lo[j], hi[j] = kep[i][0] * (1 - f_), kep[i][0] * (1 + f_)
                lo[j + 2:j + 4], hi[j + 2:j + 4] = -0.95, 0.95
            probs.append((a, nl, nk, len(t), np.clip(p0, lo + 1e-9, hi - 1e-9), lo, hi))
    shapes = {}
    for q, pr in enumerate(probs):
        shapes.setdefault((pr[1], pr[2], int(np.ceil(np.log2(max(pr[3], 2))))), []).append(q)
    params, chi2 = [None] * len(probs), np.full(len(probs), np.inf)
    for (nl, nk, bucket), members in shapes.items():
        block = max(16, int(budget / ((2 * (nl + 5 * nk) + 1) * 2 ** bucket)))
        for b0 in range(0, len(members), block):
            sel = members[b0:b0 + block]
            reqs = sorted({probs[q][0] for q in sel})
            row = {a: i for i, a in enumerate(reqs)}
            n = max(len(asks[a][0]) for a in reqs)
            T, V, S, M = (np.zeros((len(reqs), n)) for _ in range(4))
            XX = np.zeros((nl, len(reqs), n))
            for i, a in enumerate(reqs):
                t, v, sig, X = asks[a][:4]
                m = len(t)
                T[i, :m], V[i, :m], S[i, :m], M[i, :m], XX[:, i, :m] = t, v, sig, 1.0, X.T
                T[i, m:], S[i, m:] = t[0], 1.0
            T, V, S, M, XX = (gpu_dev(z) for z in (T, V, S, M, XX))
            owner = torch.as_tensor([row[probs[q][0]] for q in sel], device=gpu_DEVICE)
            kern = _gpu_kernels() if gpu_DEVICE.type == "cuda" else None

            def resid(p, idx):
                if kern is not None:
                    return kern.census_residuals(p.contiguous(), owner[idx].contiguous(), T, V, S, M, XX.contiguous(), nl, nk, _gpu_stream())
                r = owner[idx]
                m_ = p[:, :1] * XX[0][r]
                for j in range(1, nl):
                    m_ = m_ + p[:, j:j + 1] * XX[j][r]
                for i in range(nk):
                    P, tp, c, s, K = (p[:, nl + 5 * i + j:nl + 5 * i + j + 1] for j in range(5))
                    m_ = m_ + K.abs() * gpu_keplerian(T[r], P, tp, torch.clamp(c * c + s * s, max=0.9), torch.atan2(s, c))
                return (m_ - V[r]) / S[r] * M[r]
            p, _ = gpu_lm(resid, np.array([probs[q][4] for q in sel]), np.array([probs[q][5] for q in sel]), np.array([probs[q][6] for q in sel]), f_scale=3.0,
                          graph=kern is not None)
            c2 = gpu_host((resid(p, torch.arange(len(sel), device=gpu_DEVICE)) ** 2).sum(1))
            for q, pq, cq in zip(sel, gpu_host(p), c2):
                params[q], chi2[q] = pq, cq
    of = {}
    for q, pr in enumerate(probs):
        of.setdefault(pr[0], []).append(q)
    out = []
    for a in range(len(asks)):
        best = min(of[a], key=lambda q: chi2[q])
        out.append((params[best], float(chi2[best])))
    return out


def planets_starts(t, r, sig, P, eccs=(0.05, 0.3, 0.6)):
    """Keplerian starts at period P over the eccentricities ECCS and four arguments of periastron, their amplitude and phase from a circular orbit fitted
    linearly to the residuals R."""
    X = np.column_stack([np.cos(2 * np.pi * t / P), np.sin(2 * np.pi * t / P), np.ones_like(t)])
    c = np.linalg.lstsq(X / sig[:, None], r / sig, rcond=None)[0]
    K0, phi = max(math.hypot(c[0], c[1]), 0.5), math.atan2(c[1], c[0])
    return [[P, P * (phi + w0) / (2 * np.pi), math.sqrt(e0) * math.cos(w0), math.sqrt(e0) * math.sin(w0), K0]
            for e0 in eccs for w0 in np.radians((0.0, 90.0, 180.0, 270.0))]


def planets_search(name, rows, labels, star, planets_of, host_of, blind=False, state=None):
    """One star's model and signals. The velocities and indicators are averaged per night and series; each series with three nights or more gets an offset,
    and the model holds the indicators (each standardised within its series) that correlate with the velocities at p below 0.01 once a quadratic is out of
    them, and Keplerians: first the archive's planets of the star, each started at its catalogue period and eccentricity and held within 1 per cent of
    the period, then signals found one at a time in the residuals by a generalised Lomb-Scargle periodogram from 1.5 d to twice the span, the periods
    within 5 per cent or a resolution element of a signal already in the model set aside, each standing at a Baluev false-alarm level below 1e-3 and
    fitted jointly with everything before it, up to eight, with a jitter for each series added to its errors.
    A linear trend, or a quadratic over 300 d of span or more, joins the model last, only where it lowers the BIC by more than 10 with the Keplerians in,
    so that a long orbit is searched as a Keplerian rather than taken up by a trend. BLIND leaves the archive's planets out of the model, records them
    beside it, and searches for up to two more signals than they number, so that the search can be scored on them. Before the search, nights further
    from the model than six times the residuals' scaled median absolute deviation and five times the median error are set aside, at most one in twenty.
    Each found signal carries its flags: an indicator whose own periodogram has power within 5 per cent of its period at a false-alarm level below 0.01,
    nearness to a catalogued planet's period or to the 1-day and 1-year aliases of the signals before it, a period longer than the span, and a jitter
    above 10 m/s. Returns the star's record and signal rows, or None for a star the census passes; a dict STATE receives the final model's times,
    residuals, errors with the jitters, series numbers and periods."""
    steps = planets_search_steps(name, rows, labels, star, planets_of, host_of, blind, state)
    try:
        ask = next(steps)
        while True:
            ask = steps.send(planets_fit_many(*ask))
    except StopIteration as done:
        return done.value


def planets_search_stream(jobs):
    """planets_search for many stars together, each job its arguments (name, rows, labels, star, planets_of, host_of, blind, state): the stars' searches
    advanced in rounds, each round's fits of every star solved together (planets_fit_batch), each star's (index, result) yielded as soon as its search
    ends."""
    steps, asks = {}, {}
    for i, job in enumerate(jobs):
        g = planets_search_steps(*job)
        try:
            asks[i], steps[i] = next(g), g
        except StopIteration as done:
            yield i, done.value
    while asks:
        keys = list(asks)
        for i, answer in zip(keys, planets_fit_batch([asks[i] for i in keys])):
            try:
                asks[i] = steps[i].send(answer)
            except StopIteration as done:
                del asks[i]
                yield i, done.value


def planets_search_many(jobs):
    """planets_search_stream's results in the jobs' order."""
    out = [None] * len(jobs)
    for i, got in planets_search_stream(jobs):
        out[i] = got
    return out


def planets_search_steps(name, rows, labels, star, planets_of, host_of, blind=False, state=None):
    """planets_search's steps as a generator: each joint fit is yielded as planets_fit_many's arguments (t, v, sig, X, keps, bounds) and answered with
    its parameters and chi-square; returns the star's record and signal rows, or None."""
    from scipy.stats import pearsonr
    s = planets_nightly(rows)
    inst = s[:, 3].astype(int)
    keep = np.bincount(inst)[inst] >= 3
    s, inst = s[keep], inst[keep]
    t, v, e = s[:, 0], s[:, 1], s[:, 2]
    span = float(t.max() - t.min()) if len(t) else 0.0
    sptype = star.get("SpType", "")
    rec = dict(name=name, sptype=sptype, nights=len(t), span_d=round(span), instruments={labels[k]: int((inst == k).sum()) for k in np.unique(inst)})
    if not planets_late_type(sptype) or len(t) < 15 or span < 100:
        return None
    tt = (t - t.mean()) / 365.25
    # offsets only; a trend is tested after the Keplerians
    cols = [np.ones_like(t)]
    for k in np.unique(inst)[1:]:
        cols.append((inst == k).astype(float))
    # the indicators are tested against the velocities less a quadratic trend
    base = np.column_stack(cols + [tt] + ([tt ** 2] if span >= 300 else []))
    r0 = v - base @ np.linalg.lstsq(base / e[:, None], v / e, rcond=None)[0]
    # each indicator standardised within its series
    for j in range(len(planets_INDICATORS)):
        for k in np.unique(inst):
            m = inst == k
            x = s[m, 4 + j]
            sd = np.nanstd(x) if np.isfinite(x).sum() >= 3 else 0.0
            s[m, 4 + j] = (x - np.nanmedian(x)) / sd if sd > 0 else np.nan
    used = []
    for j, label in enumerate(planets_INDICATORS):
        x = s[:, 4 + j]
        ok = np.isfinite(x)
        if ok.sum() < 0.5 * len(t) or ok.sum() < 12 or np.std(x[ok]) == 0:
            continue
        if pearsonr(r0[ok], x[ok])[1] < 0.01:
            cols.append(np.where(ok, x, 0.0))
            used.append(label)
    X = np.column_stack(cols)
    host = host_of(name, star.get("SimbadName"), planets_num(star.get("RAJ2000")), planets_num(star.get("DEJ2000")))
    known = [k for k in (planets_of.get(host, []) if host else []) if math.isfinite(k["P"]) and 1.0 < k["P"] < 3.0 * span]
    most = 8
    if blind:
        rec["catalogue"] = [dict(name=k["name"], P=k["P"], K=k["K"], e=k["e"]) for k in known]
        most, known = max(4, len(known) + 2), []
    m1 = planets_star_mass(star)
    # a jitter for each series, added to its errors
    series, ii = np.unique(inst, return_inverse=True)
    jit = np.ones(len(series))
    sig = np.hypot(e, jit[ii])
    kep, fr, kinds = [], [], []
    for k in known:
        e0 = k["e"] if math.isfinite(k["e"]) else 0.1
        # a catalogued planet starts at its catalogue eccentricity alone
        starts = planets_starts(t, r0, sig, k["P"], (min(max(e0, 0.02), 0.8),))
        for st0 in starts:
            st0[4] = k["K"] if math.isfinite(k["K"]) else max(np.std(r0), 1.0)
        best = yield (t, v, sig, X, [kep + [st0] for st0 in starts], fr + [0.01])
        nl = X.shape[1]
        kep = [list(best[0][nl + 5 * i:nl + 5 * i + 5]) for i in range(len(kep) + 1)]
        fr.append(0.01)
        kinds.append(("known", k["name"]))
    resid_of = lambda p: v - (planets_model(p, t, X, len(kep)) if kep else X @ p)
    p_cur = (yield (t, v, sig, X, [kep], fr))[0] if kep else np.linalg.lstsq(X / sig[:, None], v / sig, rcond=None)[0]
    # the outlying nights set aside, the furthest first, from the residuals about a quadratic
    r_ = resid_of(p_cur)
    Q = np.column_stack([np.ones_like(t), tt, tt ** 2])
    r_ = r_ - Q @ np.linalg.lstsq(Q / sig[:, None], r_ / sig, rcond=None)[0]
    dev = np.abs(r_ - np.median(r_))
    out_i = np.argsort(-dev)[:len(t) // 20]
    out_i = out_i[dev[out_i] > max(6.0 * 1.4826 * np.median(dev), 5.0 * np.median(e))]
    if len(out_i):
        keep_i = np.setdiff1d(np.arange(len(t)), out_i)
        t, v, e, s, X, inst, ii, tt = t[keep_i], v[keep_i], e[keep_i], s[keep_i], X[keep_i], inst[keep_i], ii[keep_i], tt[keep_i]
        sig = np.hypot(e, jit[ii])
        p_cur = (yield (t, v, sig, X, [kep], fr))[0] if kep else np.linalg.lstsq(X / sig[:, None], v / sig, rcond=None)[0]
    rec["set_aside"] = int(len(out_i))
    found = []
    freq = np.linspace(1.0 / (2.0 * span), 1.0 / 1.5, 40000)
    for it in range(most):
        resid = resid_of(p_cur)
        for j in range(len(series)):
            m = ii == j
            if m.sum() >= 3:
                jit[j] = max(math.sqrt(max(np.mean(resid[m] ** 2) - np.mean(e[m] ** 2), 0.0)), 0.5)
        sig = np.hypot(e, jit[ii])
        pw = gpu_host(gpu_gls(t, resid, sig, freq))
        # the periods within 5 per cent, or a resolution element, of a signal already in the model set aside
        for k_ in kep:
            pw[(np.abs(1.0 / freq / k_[0] - 1.0) < 0.05) | (np.abs(freq - 1.0 / k_[0]) < 1.0 / span)] = 0.0
        k = int(np.argmax(pw))
        fap = float(gpu_baluev(pw[k], freq[-1], t, sig))
        if fap > 1e-3:
            break
        best = yield (t, v, sig, X, [kep + [st0] for st0 in planets_starts(t, resid, sig, 1.0 / freq[k])], fr + [0.05])
        nl = X.shape[1]
        kep = [list(best[0][nl + 5 * i:nl + 5 * i + 5]) for i in range(len(kep) + 1)]
        fr.append(0.05)
        p_cur = best[0]
        kinds.append(("found", "signal %d" % (it + 1)))
        found.append(fap)
    # a linear or quadratic trend joins the model where it lowers the BIC by more than 10
    def lnl_of(p, XX):
        r = v - (planets_model(p, t, XX, len(kep)) if kep else XX @ p)
        return -0.5 * float(np.sum(r ** 2 / sig ** 2 + np.log(2 * np.pi * sig ** 2)))
    bic_best, trend = -2.0 * lnl_of(p_cur, X), []
    nl0 = X.shape[1]
    for terms in ([tt], [tt, tt ** 2])[:2 if span >= 300 else 1]:
        XX = np.column_stack([X] + terms)
        pp = (yield (t, v, sig, XX, [kep], fr))[0] if kep else np.linalg.lstsq(XX / sig[:, None], v / sig, rcond=None)[0]
        bic = -2.0 * lnl_of(pp, XX) + len(terms) * math.log(len(t))
        if bic < bic_best - 10.0:
            bic_best, trend, X_t, p_t = bic, [round(float(x), 3) for x in pp[nl0:nl0 + len(terms)]], XX, pp
    if trend:
        X, p_cur = X_t, p_t
        kep = [list(p_cur[X.shape[1] + 5 * i:X.shape[1] + 5 * i + 5]) for i in range(len(kep))]
    rms = float(np.std(resid_of(p_cur)))
    # the jitter that flags a star is its largest series'
    jitter = float(jit[0])
    rec.update(host=host, activity_regressors=used, jitter=round(jitter, 2), jitters={labels[u]: round(float(jit[j]), 2) for j, u in enumerate(series)},
               rms_resid=round(rms, 2), n_known=len(known), n_found=len(found), trend=trend, t_mean=round(float(t.mean()), 2))
    out, fi = [], 0
    ind_pw = {}
    for j, lab in enumerate(planets_INDICATORS):
        x = s[:, 4 + j]
        ok = np.isfinite(x)
        if ok.sum() >= 12 and np.std(x[ok]) > 0:
            ind_pw[j] = (gpu_host(gpu_gls(t[ok], x[ok], None, freq)), t[ok])
    for i, (kind, label) in enumerate(kinds):
        P, tp, c, sn, K = kep[i]
        ecc = min(c * c + sn * sn, 0.9)
        msini = planets_msini(P, abs(K), ecc, m1)
        row = dict(name=name, sptype=sptype, vmag=star.get("Vmag", ""), host=host or "", kind=kind, label=label, nights=len(t), span_d=round(span), P=round(P, 4),
                   K=round(abs(K), 2), e=round(ecc, 3), msini_mjup=round(msini, 4), msini_mearth=round(msini * 317.83, 1), rms_resid=round(rms, 2),
                   jitter=round(jitter, 2), regressors=";".join(used), fap="", flags="")
        if kind == "found":
            row["fap"] = found[fi]
            fi += 1
            flags = []
            near = np.abs(1.0 / freq / P - 1.0) < 0.05
            for j, (pa, tj) in ind_pw.items():
                if near.any():
                    kk = int(np.argmax(np.where(near, pa, -1)))
                    if float(gpu_baluev(pa[kk], freq[-1], tj)) < 0.01:
                        flags.append("%s at P" % planets_INDICATORS[j])
            flags += ["near %s" % kn["name"] for kn in known if abs(P / kn["P"] - 1.0) < 0.05]
            for j2 in range(i):
                f2 = 1.0 / kep[j2][0]
                for base_f in (1.0 / 1.0027, 1.0 / 365.25):
                    for sgn in (1, -1):
                        if f2 + sgn * base_f > 0 and abs(1.0 / P - (f2 + sgn * base_f)) < 0.05 / P:
                            flags.append("alias of %.2f d" % kep[j2][0])
            if P > span:
                flags.append("longer than the span")
            if jitter > 10.0:
                flags.append("jitter %.0f m/s" % jitter)
            row["flags"] = "; ".join(flags)
        out.append(row)
    if state is not None:
        state.update(t=t, resid=resid_of(p_cur), sig=sig, groups=ii, periods=[float(k_[0]) for k_ in kep])
    return rec, out


planets_SIGNAL_KEYS = ["name", "sptype", "vmag", "host", "kind", "label", "nights", "span_d", "P", "K", "e", "msini_mjup", "msini_mearth", "rms_resid", "jitter",
                       "regressors", "fap", "flags"]


def planets_share(part=None, hosts=False):
    """The census's stars, of the share K/N where PART is given: the eligible stars ranked by their count of velocities, every Nth from the Kth, and with
    HOSTS only those the archive lists planets for. A star with no bank velocities, as in a root that planets_targets set up, is eligible where its DACE
    velocities cover 15 nights or more over 100 days or more. Returns the names, the star records, and the archive's planets by host with the host finder."""
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    planets_of, host_of = planets_known(planets_path("known.csv"))
    # each star's count of velocities, read without keeping the velocities
    times, sizes, dace_times = {}, {}, {}
    for r in csv.DictReader(open(planets_path("bank_velocities.csv"), encoding="utf-8")):
        if math.isfinite(planets_num(r["DRVmlcnzp"])) and math.isfinite(planets_num(r["e_DRVmlcnzp"])):
            times.setdefault(r["Name"], []).append([float(r["BJD"]) - 2400000.5])
    for r in csv.DictReader(open(planets_path("dace.csv"), encoding="utf-8")):
        sizes[r["name"]] = sizes.get(r["name"], 0) + 1
        if r["name"] not in times and math.isfinite(planets_num(r["rv"])):
            dace_times.setdefault(r["name"], []).append([float(r["mjd"])])
    names = planets_eligible(stars, dict(dace_times, **times))
    sizes = {n: len(times.get(n, [])) + sizes.get(n, 0) for n in names}
    del times, dace_times
    if hosts:
        names = [n for n in names if host_of(n, stars[n].get("SimbadName"), planets_num(stars[n].get("RAJ2000")), planets_num(stars[n].get("DEJ2000")))]
    rank = {n: i for i, n in enumerate(sorted(names, key=lambda n: (-sizes[n], n)))}
    if part:
        k, n_parts = (int(x) for x in part.split("/"))
        names = [n for n in names if rank[n] % n_parts == k]
    return names, stars, planets_of, host_of


def planets_kepler_power(t, r, sig, groups, pmin=1.5, eccs=(0.3, 0.5, 0.65, 0.8, 0.9), phases=16, oversample=5, shuffle=None):
    """The Keplerian periodogram of velocities R at times T with errors SIG and an offset for each of GROUPS: at every frequency from 1/(2 x span) to 1/PMIN,
    spaced at 1/(OVERSAMPLE x span), the circular orbit and every eccentricity of ECCS at PHASES times of periastron, each orbit's two linear terms solved
    exactly with the offsets profiled out, and the improvement in chi-square over the offsets alone, in single precision. SHUFFLE, a numpy Generator,
    permutes the velocities and their errors within each group first, for a null. Returns the frequencies, the best improvement at each and the circular
    orbit's, the offsets-only chi-square, and the best orbit: period, eccentricity, time of periastron, K, omega and improvement."""
    dev = gpu_DEVICE
    t, r, sig = (np.asarray(x, float) for x in (t, r, sig))
    g = np.asarray(groups, int)
    if shuffle is not None:
        r, sig = r.copy(), sig.copy()
        for k in np.unique(g):
            idx = np.where(g == k)[0]
            perm = shuffle.permutation(idx)
            r[idx], sig[idx] = r[perm], sig[perm]
    _, g = np.unique(g, return_inverse=True)
    span = float(t.max() - t.min())
    freqs = np.arange(1.0 / (2.0 * span), 1.0 / pmin, 1.0 / (oversample * span))
    w = 1.0 / sig ** 2
    onehot = np.zeros((len(t), int(g.max()) + 1))
    onehot[np.arange(len(t)), g] = 1.0
    wsum = onehot.T @ w
    rt = r - ((onehot.T @ (w * r)) / wsum)[g]
    chi0 = float(np.sum(w * rt ** 2))
    combos = [(0.0, 0.0)] + [(e, k / phases) for e in eccs for k in range(phases)]
    f32 = dict(dtype=torch.float32, device=dev)
    E = torch.tensor([c[0] for c in combos], **f32)[None, :, None]
    PH = torch.tensor([c[1] for c in combos], dtype=torch.float64, device=dev)[None, :, None]
    T = torch.tensor(t - t.min(), dtype=torch.float64, device=dev)[None, None, :]
    W, R, OH, WS = (torch.tensor(x, **f32) for x in (w, rt, onehot, wsum))
    G = torch.tensor(g, dtype=torch.long, device=dev)
    sp, sm = torch.sqrt(1 + E), torch.sqrt(1 - E)
    chunk = max(8, int(2.0e7 / (len(combos) * len(t))))
    best, circ = np.empty(len(freqs)), np.empty(len(freqs))
    top = (-1.0, None)
    with torch.no_grad():
        for i0 in range(0, len(freqs), chunk):
            F = torch.tensor(freqs[i0:i0 + chunk], dtype=torch.float64, device=dev)[:, None, None]
            M = 2 * math.pi * torch.remainder(F * T - PH, 1.0).to(torch.float32)
            Ea = gpu_kepler_E(M, E, 10)
            nu = 2 * torch.atan2(sp * torch.sin(Ea / 2), sm * torch.cos(Ea / 2))
            c, s = torch.cos(nu), torch.sin(nu)
            # the offsets profiled out: each basis vector less its weighted mean in each group
            c = c - ((c * W) @ OH / WS)[..., G]
            s = s - ((s * W) @ OH / WS)[..., G]
            cw, sw = c * W, s * W
            Scc, Sss, Scs, Src, Srs = (cw * c).sum(-1), (sw * s).sum(-1), (cw * s).sum(-1), (cw * R).sum(-1), (sw * R).sum(-1)
            det = Scc * Sss - Scs ** 2
            det = torch.where(det > 1e-9 * Scc * Sss, det, torch.full_like(det, float("inf")))
            A = (Src * Sss - Srs * Scs) / det
            B = (Srs * Scc - Src * Scs) / det
            d = A * Src + B * Srs
            dmax, cidx = d.max(dim=1)
            best[i0:i0 + F.shape[0]] = dmax.double().cpu().numpy()
            circ[i0:i0 + F.shape[0]] = d[:, 0].double().cpu().numpy()
            j = int(torch.argmax(dmax))
            if float(dmax[j]) > top[0]:
                ci = int(cidx[j])
                top = (float(dmax[j]), (i0 + j, ci, float(A[j, ci]), float(B[j, ci])))
    fi, ci, A_, B_ = top[1]
    P_, e_ = 1.0 / freqs[fi], combos[ci][0]
    return dict(freqs=freqs, best=best, circ=circ, chi0=chi0, P=P_, e=e_, tp=float(t.min() + combos[ci][1] * P_), K=math.hypot(A_, B_),
                omega=math.atan2(-B_, A_), dchi2=top[0], dchi2_circular=float(circ[fi]))


def planets_eccentric(part=None, perms=50, min_dchi2=25.0, hosts=False):
    """The census's residuals searched for one more Keplerian, eccentric orbits included, to RESULTS/eccentric/stars[.partKofN].jsonl. Each star of the share
    is modelled as the census models it (planets_search), and the residuals of its final model, with its jitters, are searched by planets_kepler_power. Where
    the best orbit improves chi-square by MIN_DCHI2 or more, sets of the residuals permuted within each series give the null's highest improvements, eight at first and PERMS where the best orbit stands above all eight, and
    a Gumbel distribution fitted to them gives the false-alarm level. Each star's best orbit is kept with its period, eccentricity, K, minimum mass, its
    improvement over the circular orbit at the same period, and its nearness to the census's periods and their 1-day and 1-year aliases. A star any share has recorded is passed over, and the search ends between stars
    with exit status 3 where a long search would (planets_search_ends). Run on every star, without PART, the search ends by keeping its candidates (planets_eccentric_merge)."""
    names, stars, planets_of, host_of = planets_share(part, hosts)
    bank = planets_bank_series(set(names))
    dace = planets_dace_series(set(names))
    mark = (".part%sof%s" % tuple(part.split("/"))) if part else ""
    folder = os.path.join(planets_RESULTS, "eccentric")
    os.makedirs(folder, exist_ok=True)
    rng = np.random.default_rng(5)
    held = {r["name"] for r in planets_eccentric_records()}
    jobs = []
    for name in names:
        if name in held:
            continue
        rows, labels = planets_series(name, dace, bank, stars.get(name, {}).get("SpType"))
        if rows:
            jobs.append((name, rows, labels, stars.get(name, {}), planets_of, host_of, False, {}))
    models = planets_search_many(jobs)
    with open(os.path.join(folder, "stars%s.jsonl" % mark), "a", encoding="utf-8") as out:
        for count, (job, got) in enumerate(zip(jobs, models)):
            if planets_search_ends():
                sys.exit(3)
            name, star, keep = job[0], job[3], job[7]
            if got is None or not keep:
                continue
            t, r, sig, g = keep["t"], keep["resid"], keep["sig"], keep["groups"]
            kp = planets_kepler_power(t, r, sig, g)
            span = float(t.max() - t.min())
            near = []
            for Q in keep["periods"]:
                if abs(kp["P"] / Q - 1.0) < 0.05:
                    near.append("near %.2f d" % Q)
                elif any(abs(1.0 / kp["P"] - abs(1.0 / Q + sg * b)) < 0.02 / kp["P"] for b in (1.0 / 1.0027, 1.0 / 365.25) for sg in (1, -1)):
                    near.append("alias of %.2f d" % Q)
            if kp["P"] > span:
                near.append("longer than the span")
            rec = dict(name=name, sptype=star.get("SpType", ""), nights=len(t), span_d=round(span), census_periods=[round(Q, 4) for Q in keep["periods"]],
                       P=round(kp["P"], 4), e=kp["e"], K=round(kp["K"], 2), omega=round(kp["omega"], 3), tp=round(kp["tp"], 3), dchi2=round(kp["dchi2"], 2),
                       dchi2_circular=round(kp["dchi2_circular"], 2), chi2_0=round(kp["chi0"], 2),
                       msini_mearth=round(planets_msini(kp["P"], kp["K"], kp["e"], planets_mass(star.get("SpType"))) * 317.83, 1), flags="; ".join(near))
            if kp["dchi2"] >= min_dchi2 and perms:
                null = [planets_kepler_power(t, r, sig, g, shuffle=rng)["dchi2"] for _ in range(min(perms, 8))]
                if kp["dchi2"] > max(null):
                    null += [planets_kepler_power(t, r, sig, g, shuffle=rng)["dchi2"] for _ in range(perms - len(null))]
                null = np.array(null)
                beta = max(float(np.std(null, ddof=1)) * math.sqrt(6.0) / math.pi, 1e-9)
                mu = float(np.mean(null)) - 0.5772 * beta
                rec.update(null_draws=len(null), null_mean=round(float(np.mean(null)), 2), null_sd=round(float(np.std(null, ddof=1)), 2), null_max=round(float(null.max()), 2),
                           fap=float(-math.expm1(-math.exp(-(kp["dchi2"] - mu) / beta))))
            out.write(json.dumps(rec) + "\n")
            out.flush()
            print("%4d %-12s n %4d | P %9.3f e %.2f K %6.2f | dchi2 %7.1f (circular %7.1f)%s %s" % (
                count, name, len(t), rec["P"], rec["e"], rec["K"], rec["dchi2"], rec["dchi2_circular"],
                " FAP %.1e" % rec["fap"] if "fap" in rec else "", rec["flags"]), flush=True)
    print("done: %d stars" % len(names), flush=True)
    if not part:
        planets_eccentric_merge()


def planets_eccentric_records():
    """Every star's best orbit the eccentric search's shares hold under RESULTS/eccentric, one a star, a line a write cut short left out."""
    recs = {}
    for f in sorted(glob.glob(os.path.join(planets_RESULTS, "eccentric", "stars*.jsonl"))):
        for x in open(f, encoding="utf-8"):
            try:
                r = json.loads(x)
            except ValueError:
                continue
            recs[r["name"]] = r
    return list(recs.values())


def planets_eccentric_merge():
    """The eccentric search's shares joined into RESULTS/eccentric/candidates.csv: every star's best orbit with a false-alarm level below 0.01, the orbits
    without a flag first, each in order of false-alarm level. Beside the search's own flags, an orbit is flagged whose periastron would lie within two
    stellar radii (the radius taken as the spectral type's mass to the power 0.8) and whose period lies within 5 per cent of a year or half a year."""
    recs = planets_eccentric_records()
    for r in recs:
        m1 = planets_mass(r["sptype"])
        flags = [r["flags"]] if r["flags"] else []
        if (m1 * (r["P"] / 365.25) ** 2) ** (1.0 / 3.0) * (1.0 - r["e"]) < 2.0 * 0.00465 * m1 ** 0.8:
            flags.append("periastron within 2 stellar radii")
        if any(abs(r["P"] / y - 1.0) < 0.05 for y in (365.25, 182.63)):
            flags.append("near a year or half")
        r["flags"] = "; ".join(flags)
    cand = sorted((r for r in recs if r.get("fap", 1.0) < 0.01), key=lambda r: (bool(r["flags"]), r["fap"]))
    keys = ["name", "sptype", "nights", "span_d", "P", "e", "K", "msini_mearth", "dchi2", "dchi2_circular", "fap", "null_mean", "null_sd", "flags", "census_periods"]
    planets_write(os.path.join(planets_RESULTS, "eccentric", "candidates.csv"), [{k: r.get(k, "") for k in keys} for r in cand], keys)
    print("%d stars searched, %d with an orbit below a false-alarm level of 0.01" % (len(recs), len(cand)), flush=True)
    for r in cand:
        print("%-12s %-8s n %4d | P %9.3f e %.2f K %6.2f msini %7.1f ME | dchi2 %7.1f circular %7.1f | FAP %.1e | %s" % (
            r["name"], r["sptype"][:8], r["nights"], r["P"], r["e"], r["K"], r["msini_mearth"], r["dchi2"], r["dchi2_circular"], r["fap"], r["flags"]), flush=True)


# stars whose answers are known: planets with periods (d) and published semi-amplitudes (m/s), refuted signals and disputed ones
planets_BENCHMARK = {
    "GJ551": dict(label="Proxima Cen", planets=[("Proxima Cen b", 11.1868, 1.24), ("Proxima Cen d", 5.1224, 0.39)],
                  disputed=[("Proxima Cen c", 1928.0, 1.2)], false=[]),
    # alpha Cen B from its 2023 ESPRESSO series alone; its HARPS series scatter by 36 m/s about the binary orbit's quadratic
    "GJ559B": dict(label="alpha Cen B", planets=[], disputed=[], false=[("alpha Cen Bb", 3.2357, 0.51)], series="ESPRESSO19"),
    "GJ559A": dict(label="alpha Cen A", planets=[], disputed=[], false=[]),
}


def planets_match(found, P):
    """The found signal at a period P: 'recovered' within 2 per cent, 'alias' within 2 per cent of one of its 1-day or 1-year aliases, else None; with
    the signal."""
    for f in found:
        if abs(float(f["P"]) / P - 1.0) < 0.02:
            return "recovered", f
    for f in found:
        if any(fa > 0 and abs(1.0 / float(f["P"]) / fa - 1.0) < 0.02 for fa in (abs(1.0 / P + s * b) for b in (1.0 / 1.0027, 1.0 / 365.25) for s in (1, -1))):
            return "alias", f
    return None, None


def planets_benchmark_job(t, y, e, g, S, HA, progs):
    """The census's search of the Sun's velocities Y (times T, errors E, series G, S, H alpha and the series' labels PROGS) as a planets_search_many
    job."""
    nan = np.full(len(t), np.nan)
    return ("Sun", np.column_stack([t, y, e, g, S, HA, nan, nan, nan, nan]).tolist(), progs, dict(SpType="G2V", RAJ2000="", DEJ2000=""), {}, lambda *a: None,
            False, None)


def planets_benchmark_found(got):
    """A search's found signals: their periods, amplitudes, false-alarm levels and flags."""
    return [dict(P=float(r["P"]), K=float(r["K"]), fap=float(r["fap"]), flags=r["flags"]) for r in got[1] if r["kind"] == "found"] if got else []


def planets_benchmark(sun=None, periods=(2.0, 3.5, 6.0, 10.0, 17.0, 30.0, 50.0, 85.0, 150.0, 250.0, 450.0, 800.0), amplitudes=(0.5, 1.0, 1.5, 2.0, 3.0,
                      5.0, 8.0), phases=4, seed=13):
    """The census run on stars whose answers are known, to RESULTS/benchmark.json. Proxima and alpha Cen A and B, read as the census reads them with
    the archive's planets left out (alpha Cen B from its ESPRESSO series alone), each found signal set against their planets, the false planet once
    claimed for alpha Cen B and the disputed Proxima c, and every other found signal kept with its flags as a false alarm. Then the Sun, from its daily
    velocities from HARPS (SUN, by default the solar mode's velocities.csv, made by its plan, days and lbl steps where it is missing): its own
    velocities as observed, where DE440's planets project onto the line from the Sun to the Earth at Jupiter's and
    Saturn's synodic periods (398.9 and 378.1 d); the same less DE440's, the Sun's activity alone, where every found signal is a false alarm; and that
    activity with circular planets laid into it at PERIODS and AMPLITUDES, PHASES each, each recovered where a found signal lies within 2 per cent of its
    period, which gives the census's completeness against a real star's noise."""
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    planets_of, host_of = planets_known(planets_path("known.csv"))
    names = [n for n in planets_BENCHMARK if n in stars]
    bank, dace = planets_bank_series(set(names)), planets_dace_series(set(names))
    out = dict(stars={})
    for name in names:
        truth = planets_BENCHMARK[name]
        rows, labels = planets_series(name, dace, bank, stars[name].get("SpType"))
        if truth.get("series"):
            kept = [k for k, lab in enumerate(labels) if truth["series"] in lab]
            rows = [r[:3] + [float(kept.index(int(r[3])))] + r[4:] for r in rows if int(r[3]) in kept]
            labels = [labels[k] for k in kept]
        got = planets_search(name, rows, labels, stars[name], planets_of, host_of, blind=True) if rows else None
        if got is None:
            continue
        found = [r for r in got[1] if r["kind"] == "found"]
        used = set()
        res = dict(label=truth["label"], nights=got[0]["nights"], span_d=got[0]["span_d"], jitter=got[0]["jitter"], planets=[], false=[], disputed=[],
                   others=[])
        for kind in ("planets", "false", "disputed"):
            for pl_name, P, K in truth[kind]:
                status, f = planets_match(found, P)
                if f is not None:
                    used.add(id(f))
                res[kind].append(dict(name=pl_name, P=P, K=K, status=status or "not found", found_P=float(f["P"]) if f else None,
                                      found_K=float(f["K"]) if f else None, flags=f["flags"] if f else None))
        res["others"] = [dict(P=float(f["P"]), K=float(f["K"]), fap=float(f["fap"]), flags=f["flags"]) for f in found if id(f) not in used]
        out["stars"][name] = res
        print("%-12s %4d nights: planets %s; false %s; disputed %s; other signals %s" % (
            truth["label"], res["nights"], [(x["name"], x["status"]) for x in res["planets"]], [(x["name"], x["status"]) for x in res["false"]],
            [(x["name"], x["status"]) for x in res["disputed"]], ["%.2f d%s" % (x["P"], " (%s)" % x["flags"] if x["flags"] else "") for x in res["others"]]),
              flush=True)
    sun = sun or os.path.join(solar_RESULTS, "HARPS_Sun", "velocities.csv")
    if not os.path.exists(sun):
        solar_plan("Sun", "HARPS"), solar_days("Sun", "HARPS"), solar_lbl("Sun", "HARPS")
    if os.path.exists(sun):
        rows_ = list(csv.DictReader(open(sun, encoding="utf-8")))
        t = np.array([float(r["mjd"]) for r in rows_])
        v = np.array([float(r["rv"]) for r in rows_])
        e = np.array([float(r["rv_err"]) for r in rows_])
        de = np.array([float(r["de440"]) for r in rows_])
        S = np.array([float(r["S"]) for r in rows_])
        HA = np.array([float(r["Halpha"]) for r in rows_])
        progs = sorted({r["programme"] for r in rows_})
        g = np.array([float(progs.index(r["programme"])) for r in rows_])
        # the days the solar mode's fit sets aside, beyond 5 robust standard deviations of the velocities less DE440's within each programme
        r_ = v - de
        for k in np.unique(g):
            m = g == k
            r_[m] -= np.median(r_[m])
        ok = np.abs(r_) < 5.0 * 1.4826 * np.median(np.abs(r_))
        t, v, e, de, S, HA, g = t[ok], v[ok], e[ok], de[ok], S[ok], HA[ok], g[ok]
        sun_res = {}
        for label, got in zip(("observed", "activity"), planets_search_many([planets_benchmark_job(t, y, e, g, S, HA, progs) for y in (v, v - de)])):
            sun_res[label] = planets_benchmark_found(got)
            print("Sun, %s: %s" % (label, ["%.1f d %.2f m/s%s" % (f["P"], f["K"], " (%s)" % f["flags"] if f["flags"] else "") for f in sun_res[label]]), flush=True)
        sun_res["observed_synodic"] = {name_: planets_match([dict(P=f["P"]) for f in sun_res["observed"]], P)[0] or "not found"
                                       for name_, P in (("Jupiter", 398.88), ("Saturn", 378.09))}
        rng = np.random.default_rng(seed)
        draws = [(i, j, P, v - de + K * np.sin(2 * np.pi * t / P + rng.uniform(0, 2 * np.pi)))
                 for i, P in enumerate(periods) for j, K in enumerate(amplitudes) for _ in range(phases)]
        grid = np.zeros((len(periods), len(amplitudes)))
        for (i, j, P, _), got in zip(draws, planets_search_many([planets_benchmark_job(t, y, e, g, S, HA, progs) for _, _, _, y in draws])):
            grid[i, j] += (planets_match(planets_benchmark_found(got), P)[0] == "recovered") / phases
        for i, P in enumerate(periods):
            print("  Sun with a planet laid in at %6.1f d: recovered %s at %s m/s" % (P, list(np.round(grid[i], 2)), list(amplitudes)), flush=True)
        sun_res.update(days=len(t), first=round(float(t.min()), 1), last=round(float(t.max()), 1), periods=list(periods), amplitudes=list(amplitudes),
                       recovered=grid.tolist())
        out["sun"] = sun_res
    json.dump(out, open(os.path.join(planets_RESULTS, "benchmark.json"), "w"), separators=(",", ":"))


def planets_census(part=None, blind=False, hosts=False):
    """A share of the census: the stars whose rank by number of velocities is K modulo N for --part K/N, every star otherwise; each star's record to
    RESULTS/census/stars[.partKofN].jsonl and its signals to RESULTS/census/signals[.partKofN].csv. BLIND searches without the archive's planets (into
    RESULTS/census_blind/), and HOSTS keeps to the stars the archive lists planets for. A star with no bank velocities, as in a root that planets_targets set
    up, is searched where its DACE velocities cover 15 nights or more over 100 days or more. Run on every star, without PART or BLIND, the census ends by
    joining its results (planets_merge)."""
    names, stars, planets_of, host_of = planets_share(part, hosts)
    bank = planets_bank_series(set(names))
    dace = planets_dace_series(set(names))
    mark = (".part%sof%s" % tuple(part.split("/"))) if part else ""
    folder = os.path.join(planets_RESULTS, "census_blind" if blind else "census")
    os.makedirs(folder, exist_ok=True)
    jobs = []
    for name in names:
        rows, labels = planets_series(name, dace, bank, stars.get(name, {}).get("SpType"))
        if rows:
            jobs.append((name, rows, labels, stars.get(name, {}), planets_of, host_of, blind, None))
    # a whole census takes the place of any shares before it
    if not part:
        for f in glob.glob(os.path.join(folder, "*.part*of*")):
            os.remove(f)
    n_sig = n_new = done = 0
    t0 = time.time()
    with open(os.path.join(folder, "stars%s.jsonl" % mark), "w", encoding="utf-8") as out_stars, \
            open(os.path.join(folder, "signals%s.csv" % mark), "w", newline="", encoding="utf-8") as out_sig:
        w = csv.DictWriter(out_sig, fieldnames=planets_SIGNAL_KEYS, extrasaction="ignore")
        w.writeheader()
        # each star written and printed as its search ends
        for i, got in planets_search_stream(jobs):
            done += 1
            if got is None:
                continue
            out_stars.write(json.dumps(got[0]) + "\n")
            w.writerows(got[1])
            out_stars.flush()
            out_sig.flush()
            new = [r for r in got[1] if r["kind"] == "found"]
            n_sig, n_new = n_sig + len(got[1]), n_new + len(new)
            print("%5d/%d %6.0f s  %-14s %4d nights  %s" % (done, len(jobs), time.time() - t0, got[0]["name"], got[0]["nights"], "; ".join(
                "%s %.4g d %.2f m/s%s" % ("new" if r["kind"] == "found" else "known", r["P"], r["K"], " [%s]" % r["flags"] if r["flags"] else "")
                for r in got[1]) or "nothing"), flush=True)
    print("done: %d stars, %d signals, %d of them new" % (len(names), n_sig, n_new), flush=True)
    if not part and not blind:
        planets_merge()


def planets_s_test(times, svals, P):
    """A period's power in a star's S index: the series given, each less its median and averaged per night, searched by a Lomb-Scargle periodogram from
    1.5 d to twice their span; the highest peak with its false-alarm level, and the highest power within 10 per cent of P, P/2 or 2P with its level."""
    t, s = [], []
    for tk, sk in zip(times, svals):
        tk, sk = np.asarray(tk), np.asarray(sk)
        _, inv = np.unique(np.floor(tk + 0.3), return_inverse=True)
        tn, sn = np.bincount(inv, tk) / np.bincount(inv), np.bincount(inv, sk) / np.bincount(inv)
        t += list(tn)
        s += list(sn - np.median(sn))
    if len(t) < 12:
        return dict(s_nights=len(t))
    t, s = np.array(t), np.array(s)
    f = np.linspace(1.0 / (2.0 * (t.max() - t.min())), 1.0 / 1.5, 40000)
    p = gpu_host(gpu_gls(t, s, None, f))
    fap = lambda x: float(gpu_baluev(x, f[-1], t))
    k = int(np.argmax(p))
    best = None
    for mult in (1.0, 0.5, 2.0):
        near = np.abs(1.0 / f / (P * mult) - 1.0) < 0.1
        if near.any():
            kk = int(np.argmax(np.where(near, p, -1)))
            if best is None or p[kk] > best[1]:
                best = (1.0 / f[kk], p[kk], mult)
    out = dict(s_nights=len(t), s_peak_d=round(1.0 / f[k], 2), s_peak_fap="%.1e" % fap(p[k]))
    if best:
        out.update(s_near_d=round(best[0], 2), s_near_mult=best[2], s_near_power=round(float(best[1]), 3), s_near_fap="%.1e" % fap(best[1]))
    return out


def planets_write_stars(path, stars):
    """The census's star records written to PATH as CSV, one row per star, its lists and dicts as compact JSON."""
    keys = list(dict.fromkeys(k for s in stars for k in s))
    planets_write(path, [{k: json.dumps(v, separators=(",", ":")) if isinstance(v, (dict, list)) else v for k, v in s.items()} for s in stars], keys)


def planets_merge():
    """The census's shares joined into RESULTS/signals.csv and RESULTS/stars.csv, one row per star with its lists and dicts as compact JSON, each found
    signal without flags given its period's power in the star's S index from every series DACE gives one for (planets_s_test); a decided table it replaces kept as RESULTS/signals_decided.csv, which the publication reads until this one is decided."""
    table = os.path.join(planets_RESULTS, "signals.csv")
    if os.path.exists(table) and "reason" in open(table, encoding="utf-8").readline().strip().split(","):
        shutil.copyfile(table, os.path.join(planets_RESULTS, "signals_decided.csv"))
    sig, stars = [], []
    for f in sorted(glob.glob(os.path.join(planets_RESULTS, "census", "signals*.csv"))):
        sig += planets_read(f)
    for f in sorted(glob.glob(os.path.join(planets_RESULTS, "census", "stars*.jsonl"))):
        stars += [json.loads(x) for x in open(f, encoding="utf-8")]
    planets_write_stars(os.path.join(planets_RESULTS, "stars.csv"), stars)
    S = {}
    for r in csv.DictReader(open(planets_path("dace.csv"), encoding="utf-8")):
        if r["smw"] not in ("", "nan") and 0 < planets_num(r["smw"]) < 5:
            S.setdefault(r["name"], {}).setdefault(r["inst"] + " " + r["drs"] + " " + r["mode"], []).append((float(r["mjd"]), float(r["smw"])))
    for r in sig:
        if r["kind"] == "found" and not r["flags"]:
            series = [v for v in S.get(r["name"], {}).values() if len(v) >= 5]
            r.update(planets_s_test([[x[0] for x in v] for v in series], [[x[1] for x in v] for v in series], float(r["P"])))
    planets_write(os.path.join(planets_RESULTS, "signals.csv"), sig, planets_SIGNAL_KEYS + planets_S_KEYS)
    print("%d stars modelled, %d signals, %d found, %d without flags" % (len(stars), len(sig), sum(1 for r in sig if r["kind"] == "found"),
                                                                       sum(1 for r in sig if r["kind"] == "found" and not r["flags"])), flush=True)


planets_S_KEYS = ["s_nights", "s_peak_d", "s_peak_fap", "s_near_d", "s_near_mult", "s_near_power", "s_near_fap"]


def planets_write_calibration(res, rows, extra, folder=None):
    """The calibration's summary RES written to FOLDER/calibration.json (FOLDER by default RESULTS), its catalogued planets ROWS to
    calibration_planets.csv, and its found signals that match no catalogued planet or alias, EXTRA, to calibration_unmatched.csv."""
    folder = folder or planets_RESULTS
    json.dump(res, open(os.path.join(folder, "calibration.json"), "w"), separators=(",", ":"))
    planets_write(os.path.join(folder, "calibration_planets.csv"), rows, ["star", "planet", "P", "K", "nights", "rms", "snr_expected", "status", "found_P",
                                                                           "found_K"])
    planets_write(os.path.join(folder, "calibration_unmatched.csv"), extra, ["star", "P", "K", "msini_mearth", "fap", "flags"])


def planets_calibrate():
    """The blind census scored on the archive's planets, to RESULTS/calibration.json with its planets and unmatched signals as CSV
    (planets_write_calibration). A catalogued planet of a blind star with a semi-amplitude in the
    archive is recovered where a found signal lies within 2 per cent of its period, found at an alias where one lies within 2 per cent of the frequency of
    one of its 1-day or 1-year aliases, and missed otherwise; its expected signal-to-noise is its catalogue K over the star's residual scatter times
    sqrt(2/N) for N nights. The recovered share is given in bins of expected signal-to-noise and of period, and every found signal that matches no catalogued
    planet nor an alias of one is listed. The blind census of the archive's hosts is run first where it has not been."""
    if not glob.glob(os.path.join(planets_RESULTS, "census_blind", "stars*.jsonl")):
        planets_census(blind=True, hosts=True)
    stars, sig = [], []
    for f in sorted(glob.glob(os.path.join(planets_RESULTS, "census_blind", "stars*.jsonl"))):
        stars += [json.loads(x) for x in open(f, encoding="utf-8")]
    for f in sorted(glob.glob(os.path.join(planets_RESULTS, "census_blind", "signals*.csv"))):
        sig += planets_read(f)
    found = {}
    for r in sig:
        if r["kind"] == "found":
            found.setdefault(r["name"], []).append(r)
    aliases = lambda P: [abs(1.0 / P + s * b) for b in (1.0 / 1.0027, 1.0 / 365.25) for s in (1, -1)]
    rows, extra = [], []
    for s in stars:
        fs = found.get(s["name"], [])
        matched = set()
        for c in s.get("catalogue", []):
            P, K = float(c["P"]), planets_num(c["K"])
            status, hit = "missed", None
            for i, f in enumerate(fs):
                if abs(float(f["P"]) / P - 1.0) < 0.02:
                    status, hit = "recovered", i
                    break
            if hit is None:
                for i, f in enumerate(fs):
                    if any(fa > 0 and abs(1.0 / float(f["P"]) / fa - 1.0) < 0.02 for fa in aliases(P)):
                        status, hit = "alias", i
                        break
            if hit is not None:
                matched.add(hit)
            snr = K / (s["rms_resid"] * math.sqrt(2.0 / s["nights"])) if math.isfinite(K) and s["rms_resid"] > 0 else float("nan")
            rows.append(dict(star=s["name"], planet=c["name"], P=round(P, 4), K=K, nights=s["nights"], rms=s["rms_resid"], snr_expected=round(snr, 1), status=status,
                             found_P=float(fs[hit]["P"]) if hit is not None else None, found_K=float(fs[hit]["K"]) if hit is not None else None))
        extra += [dict(star=s["name"], P=float(f["P"]), K=float(f["K"]), msini_mearth=float(f["msini_mearth"]), fap=float(f["fap"]), flags=f["flags"])
                  for i, f in enumerate(fs) if i not in matched]

    def share(sel):
        n = len(sel)
        return dict(n=n, recovered=sum(r["status"] == "recovered" for r in sel), alias=sum(r["status"] == "alias" for r in sel),
                    fraction=round(sum(r["status"] == "recovered" for r in sel) / n, 3) if n else None)
    scored = [r for r in rows if math.isfinite(r["snr_expected"])]
    by_snr = {"%g-%g" % (lo, hi): share([r for r in scored if lo <= r["snr_expected"] < hi]) for lo, hi in ((0, 3), (3, 5), (5, 10), (10, 20), (20, 1e9))}
    by_period = {"%g-%g d" % (lo, hi): share([r for r in scored if lo <= r["P"] < hi and r["snr_expected"] >= 5]) for lo, hi in
                 ((1, 10), (10, 100), (100, 1000), (1000, 1e9))}
    res = dict(stars=len(stars), planets=len(rows), scored=len(scored), by_expected_snr=by_snr, by_period_above_snr5=by_period,
               extra_signals=len(extra), extra_unflagged=sum(1 for x in extra if not x["flags"]))
    planets_write_calibration(res, rows, extra)
    print("%d host stars, %d catalogued planets, %d with a catalogue K" % (len(stars), len(rows), len(scored)), flush=True)
    for label, d in by_snr.items():
        print("  expected S/N %-8s %4d planets: %4d recovered (%s), %3d at an alias" % (label, d["n"], d["recovered"], d["fraction"], d["alias"]), flush=True)
    for label, d in by_period.items():
        print("  S/N above 5, P %-12s %4d planets: %4d recovered (%s), %3d at an alias" % (label, d["n"], d["recovered"], d["fraction"], d["alias"]), flush=True)
    print("  %d found signals match no catalogued planet or alias, %d of them without flags" % (len(extra), res["extra_unflagged"]), flush=True)


def planets_wobble_calibration():
    """The weighing's rule on the wobble (planets_weigh_holds) set on what Gaia DR3 publishes, to RESULTS/wobble_calibration.json: its two-body solutions that hold an
    astrometric orbit and its accelerations, of stars brighter than G 13, read from ESA's archive in 48 parts of source_id with each star's excess noise. Each solution's
    photocentre over Gaia's window, its Thiele-Innes elements' orbit or its acceleration's polynomial, leaves about a five-parameter solution of the star the wobble
    planets_weigh reads, the root mean square along one axis; that wobble over the excess noise, or over 0.3 mas where that is not significant, gives by steps of wobble the
    percentiles of each kind of solution, the 99th being the table the rule holds (planets_WOBBLE_P99), and the share of each kind the rule turns down."""
    top, parts = 6917528997577384320, 48
    tg, tref = np.linspace(56863.0, 57901.0, 40), 57388.5
    dt = (tg - tref) / 365.25

    def read(select, table, where):
        rows = []
        for k in range(parts):
            lo, hi = top // parts * k, top // parts * (k + 1) if k < parts - 1 else top + 1
            rows += archive_tap("gaia", "SELECT %s, g.ra, g.dec, g.astrometric_excess_noise, g.astrometric_excess_noise_sig FROM gaiadr3.%s AS o JOIN gaiadr3.gaia_source AS g "
                                        "ON o.source_id = g.source_id WHERE o.source_id >= %d AND o.source_id < %d AND g.phot_g_mean_mag < 13 AND %s" % (select, table, lo, hi, where))
        return {key: np.array([planets_num(r[key]) for r in rows]) for key in rows[0]}

    def wobble(x, da, dd):
        # the root mean square along one axis of the offsets DA, DD (solutions, epochs; mas) about each star's position, proper motion and parallax fitted to them
        out = []
        for i in range(0, len(da), 8192):
            fa, fd = archive_parallax_factors(x["ra"][i:i + 8192, None], x["dec"][i:i + 8192, None], tg)
            one, zero, t = np.ones(fa.shape), np.zeros(fa.shape), np.tile(dt, (len(fa), 1))
            A = gpu_dev(np.stack([np.concatenate(c, 1) for c in ((one, zero), (zero, one), (t, zero), (zero, t), (fa, fd))], 2))
            y = gpu_dev(np.concatenate([da[i:i + 8192], dd[i:i + 8192]], 1))
            c = gpu_solve_spd(A.transpose(1, 2) @ A, (A.transpose(1, 2) @ y[:, :, None])[:, :, 0])
            out.append(gpu_host(torch.sqrt(((y - (A @ c[:, :, None])[:, :, 0]) ** 2).mean(1))))
        return np.concatenate(out)
    o = read("o.period, o.eccentricity, o.t_periastron, o.a_thiele_innes, o.b_thiele_innes, o.f_thiele_innes, o.g_thiele_innes", "nss_two_body_orbit", "o.a_thiele_innes IS NOT NULL")
    e = np.nan_to_num(o["eccentricity"])[:, None]
    E = gpu_host(gpu_anomaly(tg[None, :], o["period"][:, None], tref + np.nan_to_num(o["t_periastron"])[:, None], e))
    X, Y = np.cos(E) - e, np.sqrt(1.0 - e * e) * np.sin(E)
    a = read("o.accel_ra, o.accel_dec, o.deriv_accel_ra, o.deriv_accel_dec", "nss_acceleration_astro", "o.accel_ra IS NOT NULL")
    bend = lambda g, j: 0.5 * g[:, None] * dt ** 2 + np.nan_to_num(j)[:, None] * dt ** 3 / 6.0
    kinds = (("orbit", o, wobble(o, o["b_thiele_innes"][:, None] * X + o["g_thiele_innes"][:, None] * Y, o["a_thiele_innes"][:, None] * X + o["f_thiele_innes"][:, None] * Y)),
             ("acceleration", a, wobble(a, bend(a["accel_ra"], a["deriv_accel_ra"]), bend(a["accel_dec"], a["deriv_accel_dec"]))))
    edges = (0.3,) + planets_WOBBLE_STEPS + (float("inf"),)
    out = {}
    for kind, x, w in kinds:
        keep = np.isfinite(w) & np.isfinite(x["astrometric_excess_noise"])
        w, ratio = w[keep], w[keep] / np.maximum(np.where(x["astrometric_excess_noise_sig"][keep] > 2.0, x["astrometric_excess_noise"][keep], 0.0), 0.3)
        limit = np.array(planets_WOBBLE_P99[kind])[np.searchsorted(planets_WOBBLE_STEPS, w, side="right")]
        steps = []
        for lo, hi in zip(edges, edges[1:]):
            m = (w >= lo) & (w < hi)
            q = np.percentile(ratio[m], [50, 84, 95, 99])
            steps.append(dict(wobble_from=lo, wobble_to=hi if math.isfinite(hi) else None, solutions=int(m.sum()), p50=round(float(q[0]), 2), p84=round(float(q[1]), 2), p95=round(float(q[2]), 2),
                              p99=round(float(q[3]), 2)))
        out[kind] = dict(solutions=len(w), turned_down=round(float(np.mean(ratio > limit)), 4), steps=steps)
        print("%s: %d solutions, the rule turns down %.2f per cent" % (kind, len(w), 100.0 * out[kind]["turned_down"]), flush=True)
        for s in steps:
            print("  wobble from %5.2f mas: %6d solutions, ratio at 50 per cent %.2f, 84 %.2f, 95 %.2f, 99 %.2f" % (s["wobble_from"], s["solutions"], s["p50"], s["p84"], s["p95"], s["p99"]), flush=True)
    archive_save(os.path.join(planets_RESULTS, "wobble_calibration.json"), json.dumps(out, separators=(",", ":")).encode())


def planets_own_spectra(name, least_snr):
    """The rows of a star's own spectra in a root that lists them (bank.json's spectra, ROOT/spectra.csv), above the signal-to-noise ratio LEAST_SNR, as an archive's listing gives them; None in any other root."""
    if not planets_BANK_INFO.get("spectra"):
        return None
    return [dict(src=planets_BANK_INFO["spectra"], id=r["seq"], t_min=float(r["mjd"]), snr=planets_num(r["snr"])) for r in planets_read(planets_path("spectra.csv")) if r["name"] == name and planets_num(r["snr"]) > least_snr]


def planets_zero_of(t):
    """The zero point at the times T of a root that keeps a curve of it (ROOT/zero_points.csv, planets_zero_curve), that its bank has had taken out; zeros in any other root."""
    path = planets_path("zero_points.csv")
    if not (planets_BANK_INFO.get("spectra") and os.path.exists(path)):
        return np.zeros(len(t))
    rows = planets_read(path)
    return np.interp(t, [float(r["mjd"]) for r in rows], [float(r["zero"]) for r in rows])


def planets_cal_age(path, mjd):
    """The days between a HARPS spectrum at MJD and the ThAr exposure its wavelengths come from, read from the DRS's CAL TH FILE keyword, or NaN."""
    from astropy.io import fits
    try:
        m = re.search(r"(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d)", str(fits.getheader(path).get("HIERARCH ESO DRS CAL TH FILE", "")))
        cal = datetime.datetime.strptime(m.group(1), "%Y-%m-%dT%H:%M:%S")
        return mjd - (cal - datetime.datetime(1858, 11, 17)).total_seconds() / 86400.0
    except Exception:
        return float("nan")


def planets_lbl(name, per_night=1, streams=12, keep=False, most=0, ra=None, dec=None, least=10, listing=None, inst="HARPS", ccf=False):
    """A star's line-by-line velocities and activity from its public HARPS spectra (or INST's), to ROOT/lbl/<name>.lbl.npz; with CCF, its cross-correlation
    velocities from the same spectra beside them, to ROOT/ccf/<name>.npz (binaries_velocities: against the M-dwarf template, then against the star's own
    lines at those velocities), with each spectrum's line-by-line error. The star's HARPS Phase 3 spectra above a
    signal-to-noise ratio of 20, the PER_NIGHT of highest signal to noise from each night, are fetched over STREAMS connections and read as air wavelengths in
    the barycentric frame, moved by the star's systemic velocity alone and put on a grid uniform in log wavelength at 0.4 km/s from 3800 to 6880 A, each
    divided by its running median over 1001 samples. The median of all of them is the template; its lines are the minima at least 4 per cent deep, each
    taken over the samples within 1.2 times its half-depth width, away from the telluric bands, the sodium sky lines and any sample a spectrum lacks. Each
    spectrum's velocity in each line is Bouchy's derivative estimate, the residual against the template projected on the template's derivative with the
    line's own linear continuum solved beside it, with its photon error. A spectrum's velocity is the weighted mean of its lines after lines more than 5
    sigma from their median are set aside, and an error-weighted iteration gives each line a jitter (lbl_velocities). The Ca II H and K index and the H
    alpha index (lbl_indices) are measured in each spectrum before the telluric bands are set aside. Each line's velocities are correlated with the S
    index across the spectra; the lines whose correlation passes p < 0.01 are the activity-sensitive set, and a second velocity is made from the others.
    Each spectrum's calibration age, the days since the ThAr exposure that gave its wavelengths, is kept beside its velocity: the archive's
    one-dimensional spectra carry the spectrograph's drift since that exposure uncorrected. The spectra are deleted unless KEEP. RA and DEC place a star
    the bank lacks; fewer than LEAST spectra stop it. LISTING, the star's HARPS spectra above a signal-to-noise ratio of 20 where they are already
    listed (archive_eso_listings), replaces the archive query."""
    if ra is None:
        star = next(r for r in planets_read(planets_path("bank_stars.csv")) if r["Name"] == name)
        ra, dec = float(star["RAJ2000"]), float(star["DEJ2000"])
    tag = archive_tag(name)
    folder = planets_path("spectra", tag)
    own = planets_own_spectra(name, 20.0) if listing is None and inst == "HARPS" else None
    rows = listing if listing is not None else own if own is not None else archive_eso_listing(ra, dec, inst, min_snr=20.0)
    nights = {}
    for r in rows:
        nights.setdefault(math.floor(float(r["t_min"]) + 0.3), []).append(r)
    rows = sorted((r for rs in nights.values() for r in sorted(rs, key=lambda r: -(archive_num(r["snr"]) or 0))[:per_night]), key=lambda r: float(r["t_min"]))
    if most and len(rows) > most:
        rows = [rows[int(i)] for i in np.unique(np.linspace(0, len(rows) - 1, most).round())]
    spec = []
    paths = archive_eso_fetch(rows, folder, streams=2 if own is not None else streams)
    for p, s in zip(paths, spectra_load_many(paths)):
        if s is not None:
            s[3]["cal_age"] = planets_cal_age(p, s[3]["mjd"])
            spec.append(s)
    if len(spec) < least:
        raise SystemExit("%s: %d spectra" % (name, len(spec)))
    rvs = [s[3]["rv"] for s in spec if s[3].get("rv") is not None]
    vsys = float(np.median(rvs)) if rvs else 0.0
    grid = lbl_grid()
    F, E, _ = spectra_onto([(w / (1.0 + vsys / spectra_C), f, e) for w, f, e, meta in spec], grid, 1001, clean_errors=True, dtype=np.float32)
    for i, (w, f, e, meta) in enumerate(spec):
        for sky in spectra_SKY:
            F[i, np.abs(grid - sky * (1.0 + meta.get("berv", 0.0) / spectra_C) / (1.0 + vsys / spectra_C)) < 0.15] = np.nan
    # the indices first, H alpha lying inside a telluric band
    S, HA = lbl_indices(F, grid)
    for lo, hi in spectra_BANDS["optical"]["telluric"]:
        F[:, (grid > lo) & (grid < hi)] = np.nan
    lines, V, SV, s2 = lbl_velocities(F, E)
    rv = np.nansum(V / s2, 1) / np.nansum(1.0 / s2, 1)
    rv_err = 1.0 / np.sqrt(np.nansum(1.0 / s2, 1))
    corr, pval = lbl_corr(V - rv[:, None], S, 10)
    quiet = ~(pval < 0.01)
    rv_q = np.nansum(V[:, quiet] / s2[:, quiet], 1) / np.nansum(1.0 / s2[:, quiet], 1)
    rv_q_err = 1.0 / np.sqrt(np.nansum(1.0 / s2[:, quiet], 1))
    t = np.array([s[3]["mjd"] for s in spec])
    o = np.argsort(t)
    os.makedirs(planets_path("lbl"), exist_ok=True)
    # a root's own spectra keep its zero point out of them as its bank does
    if own is not None:
        rv, rv_q = rv - planets_zero_of(t), rv_q - planets_zero_of(t)
    np.savez_compressed(planets_path("lbl", tag + ".lbl.npz"), mjd=t[o], rv=rv[o], rv_err=rv_err[o], rv_quiet=rv_q[o], rv_quiet_err=rv_q_err[o], S=S[o], upgrade=planets_UPGRADE if own is not None else planets_HARPS_UPGRADE,
                        Halpha=HA[o], snr=np.array([s[3].get("snr", np.nan) for s in spec], float)[o],
                        cal_age=np.array([s[3].get("cal_age", np.nan) for s in spec], float)[o], V=V[o].astype(np.float32), SV=SV[o].astype(np.float32),
                        line_lambda=grid[lines[:, 2]], line_corr=corr, line_p=pval, vsys=vsys)
    if ccf:
        # the search spans 400 km/s either side, as halo and cluster stars move at up to a few hundred
        v, height = binaries_velocities(spec, binaries_line_depths(spec, binaries_velocities(spec, np.load(binaries_template_path()), vmax=400)[0]), vmax=400)
        os.makedirs(planets_path("ccf"), exist_ok=True)
        np.savez_compressed(planets_path("ccf", tag + ".npz"), mjd=t[o], v=1000.0 * v[o], height=height[o], rv_err=rv_err[o], snr=np.array([s[3].get("snr", np.nan) for s in spec], float)[o])
    print("%s: %d spectra, %d lines (%d activity-sensitive); rms %.2f m/s (median error %.2f), quiet lines %.2f m/s (%.2f)" % (
        name, len(spec), len(lines), int((~quiet).sum()), float(np.std(rv - np.median(rv))), float(np.median(rv_err)), float(np.std(rv_q - np.median(rv_q))),
        float(np.median(rv_q_err))), flush=True)
    if not keep:
        shutil.rmtree(folder, ignore_errors=True)


def planets_by_night(t, v, e):
    """Velocities averaged per night, weighted by inverse variance: times, velocities and errors."""
    _, inv = np.unique(np.floor(np.asarray(t) + 0.3), return_inverse=True)
    w = 1.0 / np.asarray(e) ** 2
    W = np.bincount(inv, w)
    return np.bincount(inv, w * t) / W, np.bincount(inv, w * v) / W, 1.0 / np.sqrt(W)


def planets_sinusoids(t, v, e, groups, periods):
    """Offsets for each group and a sinusoid at each period fitted by least squares: coefficients, residuals, covariance."""
    cols = [(groups == g).astype(float) for g in np.unique(groups)]
    for P in periods:
        cols += [np.cos(2 * np.pi * t / P), np.sin(2 * np.pi * t / P)]
    A = np.column_stack(cols) / e[:, None]
    c = np.linalg.lstsq(A, v / e, rcond=None)[0]
    return c, v - (A * e[:, None]) @ c, np.linalg.pinv(A.T @ A)


def planets_amplitude(c, cov):
    """The last sinusoid's semi-amplitude and phase (deg) with their errors."""
    a, b = c[-2], c[-1]
    K = math.hypot(a, b)
    eK = math.sqrt(max(a * a * cov[-2, -2] + b * b * cov[-1, -1] + 2 * a * b * cov[-2, -1], 0.0)) / max(K, 1e-12)
    eph = math.degrees(math.sqrt(max(b * b * cov[-2, -2] + a * a * cov[-1, -1] - 2 * a * b * cov[-2, -1], 0.0)) / max(K * K, 1e-12))
    return K, eK, math.degrees(math.atan2(b, a)) % 360.0, eph


def planets_reduction(t, v, e, groups, cands):
    """One velocity set tested: sinusoids taken out one at a time at the highest peak of a generalised Lomb-Scargle periodogram from 1.2 d to twice the
    span while its Baluev false-alarm level stays below 1e-3, up to six, each fit joint with those before; then each candidate period's power and level in
    the residuals of all the others, the power of its two 1-day aliases beside it, and its sinusoid fitted to the first and the second half of the nights."""
    span = t.max() - t.min()
    freq = np.linspace(1.0 / (2.0 * span), 1.0 / 1.2, 60000)
    jit, found = 0.0, []
    for _ in range(6):
        _, r, _ = planets_sinusoids(t, v, np.hypot(e, jit), groups, found)
        jit = math.sqrt(max(np.mean(r ** 2) - np.mean(e ** 2), 0.0))
        p = gpu_host(gpu_gls(t, r, np.hypot(e, jit), freq))
        k = int(np.argmax(p))
        if float(gpu_baluev(p[k], freq[-1], t, np.hypot(e, jit))) > 1e-3:
            break
        found.append(1.0 / freq[k])
    sig = np.hypot(e, jit)
    out = dict(n=len(t), span=round(span), jitter=round(jit, 2), found=[round(P, 3) for P in found], candidates={})
    for P in cands:
        # the others are the found periods away from P and from its 1-day aliases
        others = [x for x in found if abs(x / P - 1.0) > 0.03 and all(abs(1.0 / x - abs(1.0 / P + s / 1.0027)) > 0.02 / P for s in (1, -1))]
        _, r, _ = planets_sinusoids(t, v, sig, groups, others)
        p = gpu_host(gpu_gls(t, r, sig, freq))
        kk = int(np.argmax(np.where(np.abs(freq * P - 1.0) < 0.02, p, -1)))
        Pb = 1.0 / freq[kk]
        aliases = {}
        for sgn in (1, -1):
            fa = abs(1.0 / P + sgn / 1.0027)
            na = np.abs(freq / fa - 1.0) < 0.02 / max(1.0, 1.0 / (fa * P))
            if freq[0] < fa < freq[-1] and na.any():
                aliases["%.3f" % (1.0 / fa)] = round(float(p[np.argmax(np.where(na, p, -1))]), 3)
        halves = []
        for sel in (t <= np.median(t), t > np.median(t)):
            if sel.sum() >= 8:
                c, _, cov = planets_sinusoids(t[sel], r[sel], sig[sel], groups[sel], [Pb])
                K, eK, ph, eph = planets_amplitude(c, cov)
                halves.append(dict(n=int(sel.sum()), K=round(K, 2), eK=round(eK, 2), phase=round(ph, 1), ephase=round(eph, 1)))
        out["candidates"]["%g" % P] = dict(P_peak=round(Pb, 3), power=round(float(p[kk]), 3), aliases=aliases, halves=halves,
                                           fap="%.1e" % float(gpu_baluev(p[kk], freq[-1], t, sig)))
    return out


def planets_indicator(t, x, cands):
    """An indicator's periodogram from 1.2 d to twice its span: its highest peak, and its power and false-alarm level within 5 per cent of each period."""
    ok = np.isfinite(x)
    if ok.sum() < 12 or np.std(x[ok]) == 0:
        return None
    t, x = t[ok], x[ok]
    freq = np.linspace(1.0 / (2.0 * (t.max() - t.min())), 1.0 / 1.2, 60000)
    p = gpu_host(gpu_gls(t, x, None, freq))
    fap = lambda y: "%.1e" % float(gpu_baluev(y, freq[-1], t))
    k = int(np.argmax(p))
    out = dict(top_d=round(1.0 / freq[k], 2), top_fap=fap(p[k]))
    for P in cands:
        kk = int(np.argmax(np.where(np.abs(freq * P - 1.0) < 0.05, p, -1)))
        out["%g" % P] = dict(power=round(float(p[kk]), 3), fap=fap(p[kk]))
    return out


def planets_vet(jobs, show=True):
    """Signals tested, each star's to RESULTS/vet/<name>.json; JOBS are pairs of a star and its periods. Three velocity sets of the same HARPS spectra,
    each averaged per night: the bank's SERVAL velocities (an offset across the fibre upgrade), DACE's HARPS pipeline velocities (an offset between
    HARPS03 and HARPS15, each cleaned as the census cleans), and, where the star's line-by-line file is present, its velocities from all lines and from the
    lines that do not follow the S index, the spectra wavelength-calibrated more than 30 days before they were taken left out; each is tested by
    planets_reduction. The bank's indicators, DACE's S index from every series and the line-by-line S and H alpha are searched by planets_indicator. Each
    instrument family outside HARPS with 8 nights or more is fitted at each period with its own offsets, freely and with the phase of the bank's sinusoid
    held, so that another telescope's velocities test the orbit independently. Gaia DR3's RUWE and non-single-star solutions close it. Returns the records
    by star; with SHOW prints each signal's tests on one line, and a single star's in full."""
    names = sorted({name for name, _ in jobs})
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    bank, raw, dace = planets_bank_series(set(names)), planets_bank_raw(set(names)), planets_dace_series(set(names))
    gaia = dict(zip(names, archive_pmap(lambda n: archive_gaia_star(float(stars[n]["RAJ2000"]), float(stars[n]["DEJ2000"]), archive_num(stars[n].get("Vmag")),
                                                                    physical=False), names)))
    sols = archive_gaia_solutions([g["source_id"] for g in gaia.values() if g])
    os.makedirs(os.path.join(planets_RESULTS, "vet"), exist_ok=True)
    out = {}
    for name, periods in jobs:
        res = planets_vet_star(name, periods, bank.get(name, []), raw.get(name, []), dace.get(name, {}))
        g = gaia[name]
        if g:
            sol = sols[str(g["source_id"])]
            res["gaia"] = dict(source_id=g["source_id"], ruwe=g.get("ruwe"), non_single_star=g.get("non_single_star"),
                               solutions=[r.get("nss_solution_type") for kind in ("orbit", "acceleration", "trend") for r in sol[kind]])
        json.dump(res, open(os.path.join(planets_RESULTS, "vet", archive_tag(name) + ".json"), "w"), separators=(",", ":"))
        out[name] = res
        if show and len(jobs) == 1:
            planets_vet_print(res)
        for P in periods if show else ():
            print(planets_vet_line(res, P), flush=True)
    return out


def planets_vet_star(name, periods, rows, raw_bank, dace, mover=None):
    """One star's vet record at PERIODS from its bank velocities, bank rows and DACE series, without Gaia, each time taken through MOVER where given (planets_night_mover)."""
    res = dict(name=name, periods=periods, sets={}, indicators={}, other_instruments={})
    phases = {}
    mv = mover or (lambda t: np.asarray(t, float))
    if rows:
        x = np.array(rows)
        sets_t, sets_v, sets_e, sets_g = [], [], [], []
        for g, sel in enumerate((x[:, 0] < planets_UPGRADE, x[:, 0] >= planets_UPGRADE)):
            if sel.sum() < 3:
                continue
            tn, vn, en = planets_by_night(mv(x[sel, 0]), x[sel, 1], x[sel, 2])
            sets_t.append(tn), sets_v.append(vn), sets_e.append(en), sets_g.append(np.full(len(tn), g))
        t, v, e, g = (np.concatenate(z) for z in (sets_t, sets_v, sets_e, sets_g))
        o = np.argsort(t)
        t, v, e, g = t[o], v[o], e[o], g[o]
        label = planets_bank_label()
        res["sets"][label] = planets_reduction(t, v, e, g, periods)
        for P in periods:
            c, _, cov = planets_sinusoids(t, v, np.hypot(e, res["sets"][label]["jitter"]), g, [P])
            phases[P] = math.radians(planets_amplitude(c, cov)[2])
        bt = mv(np.array([float(r["BJD"]) - 2400000.5 for r in raw_bank]))
        for key, col in (("CRX", "CRX"), ("dLW", "dLW"), ("Halpha", "Halpha"), ("NaD1", "NaD1"), ("FWHM", "FWHMDRS"), ("BIS", "BIS")):
            xs = np.array([planets_num(r[col]) for r in raw_bank])
            ok = np.isfinite(xs)
            if ok.sum() >= 12:
                _, inv = np.unique(np.floor(bt[ok] + 0.3), return_inverse=True)
                res["indicators"]["bank " + key] = planets_indicator(np.bincount(inv, bt[ok]) / np.bincount(inv), np.bincount(inv, xs[ok]) / np.bincount(inv), periods)
    # the same spectra's other reduction: DACE's HARPS pipeline, or the second reduction a root planets_tables set up holds
    harps = [(k, x) for k, x in dace.items() if (planets_family(k[0]) == planets_BANK_FAMILY if planets_BANK_INFO else k[0] in ("HARPS03", "HARPS15") and "CCF" in k[1])]
    if sum(len(x) for _, x in harps) >= 12:
        tt, vv, ee, gg = [], [], [], []
        for gi, (k, x) in enumerate(harps):
            x = np.array(planets_clean(x))
            tn, vn, en = planets_by_night(mv(x[:, 0]), x[:, 1], x[:, 2])
            tt.append(tn), vv.append(vn), ee.append(en), gg.append(np.full(len(tn), gi))
        t, v, e, g = (np.concatenate(z) for z in (tt, vv, ee, gg))
        o = np.argsort(t)
        res["sets"][planets_BANK_INFO.get("second_label", "DACE HARPS pipeline")] = planets_reduction(t[o], v[o], e[o], g[o], periods)
    S = [(x[0], x[3], k) for k, xs in dace.items() for x in xs if math.isfinite(x[3])]
    if S:
        t = mv(np.array([s[0] for s in S]))
        sv = np.array([s[1] for s in S])
        lab = np.array([" ".join(s[2]) for s in S])
        for u in np.unique(lab):
            sv[lab == u] -= np.median(sv[lab == u])
        _, inv = np.unique(np.floor(t + 0.3), return_inverse=True)
        res["indicators"]["DACE S"] = planets_indicator(np.bincount(inv, t) / np.bincount(inv), np.bincount(inv, sv) / np.bincount(inv), periods)
    lp = planets_path("lbl", archive_tag(name) + ".lbl.npz")
    if os.path.exists(lp):
        d = np.load(lp)
        t, g = mv(d["mjd"]), (d["mjd"] >= float(d["upgrade"]) if "upgrade" in d.files else d["mjd"] >= planets_HARPS_UPGRADE).astype(int)
        stale = d["cal_age"] > 30.0 if "cal_age" in d.files else np.zeros(len(t), bool)
        res["line_by_line_stale_calibrations"] = int(stale.sum())
        for key, ek, label in (("rv", "rv_err", "line-by-line, all lines"), ("rv_quiet", "rv_quiet_err", "line-by-line, quiet lines")):
            m = np.isfinite(d[key]) & np.isfinite(d[ek]) & ~stale
            res["sets"][label] = planets_reduction(t[m], d[key][m], d[ek][m], g[m], periods)
        res["indicators"]["line-by-line S"] = planets_indicator(t, d["S"], periods)
        res["indicators"]["line-by-line H alpha"] = planets_indicator(t, d["Halpha"], periods)
    fams = {}
    for k, xs in dace.items():
        fam = planets_family(k[0])
        if fam != planets_BANK_FAMILY and ("CCF" in k[1] or k[1][:1].isdigit()):
            fams.setdefault(fam, {}).setdefault(k[1], []).append((k, xs))
    for fam, pubs in fams.items():
        # one pipeline or publication per family, the one with the most velocities, its eras as groups
        k_best = max(pubs, key=lambda b: sum(len(xs) for _, xs in pubs[b]))
        tt, vv, ee, gg = [], [], [], []
        for gi, (k, xs) in enumerate(pubs[k_best]):
            x = np.array(planets_clean(xs))
            if len(x) < 3 or np.median(x[:, 2]) > 20.0:
                continue
            tn, vn, en = planets_by_night(mv(x[:, 0]), x[:, 1], x[:, 2])
            tt.append(tn), vv.append(vn), ee.append(en), gg.append(np.full(len(tn), gi))
        if not tt or sum(len(z) for z in tt) < 8:
            continue
        t, v, e, g = (np.concatenate(z) for z in (tt, vv, ee, gg))
        out = dict(source=k_best, nights=len(t), first=round(float(t.min())), last=round(float(t.max())), periods={})
        for P in periods:
            per = {}
            for jit in (0.0, 2.0):
                c, _, cov = planets_sinusoids(t, v, np.hypot(e, jit), g, [P])
                K, eK, ph, eph = planets_amplitude(c, cov)
                per["free, jitter %g" % jit] = dict(K=round(K, 2), eK=round(eK, 2), phase=round(ph, 1), ephase=round(eph, 1))
                if P in phases:
                    se = np.hypot(e, jit)
                    cols = [(g == gi).astype(float) for gi in np.unique(g)] + [np.cos(2 * np.pi * t / P - phases[P])]
                    A = np.column_stack(cols) / se[:, None]
                    cc = np.linalg.lstsq(A, v / se, rcond=None)[0]
                    per["bank phase held, jitter %g" % jit] = dict(K=round(float(cc[-1]), 2), eK=round(float(math.sqrt(np.linalg.pinv(A.T @ A)[-1, -1])), 2))
            if P in phases:
                per["bank phase"] = round(math.degrees(phases[P]) % 360.0, 1)
            out["periods"]["%g" % P] = per
        res["other_instruments"][fam] = out
        # another spectrograph's velocities are a reduction of other spectra
        if len(t) >= 12:
            o = np.argsort(t)
            res["sets"][fam + " velocities"] = planets_reduction(t[o], v[o], e[o], g[o], periods)
    return res


planets_VET_SHORT = {"bank SERVAL": "SERVAL", "ESO HARPS pipeline": "DRS", "DACE HARPS pipeline": "DRS", "orbitlight cross-correlation": "CCF",
                     "line-by-line, all lines": "LBL", "line-by-line, quiet lines": "LBL quiet", "HIRES, first reduction": "HIRES", "HIRES, second reduction": "HIRES2", "CARMENES, first reduction": "CARMENES", "CARMENES, second reduction": "CARMENES2", "SOPHIE, pipeline": "SOPHIE", "HARPS-N, newer pipeline": "HARPS-N", "HARPS-N, second reduction": "HARPS-N2", "NEID, pipeline": "NEID", "ELODIE, pipeline": "ELODIE"}


def planets_vet_line(res, P):
    """A signal's tests on one line."""
    key = "%g" % P
    sets = "; ".join("%s %s K %s" % (planets_VET_SHORT.get(label, label), c["fap"], "/".join("%.1f" % h["K"] for h in c["halves"]))
                     for label, s in res["sets"].items() for c in [s["candidates"].get(key)] if c)
    ind = ", ".join(k for k, r in res["indicators"].items() if r and float(r.get(key, {}).get("fap", "1")) < 0.01)
    other = "; ".join("%s K %.2f+-%.2f" % (fam, d["periods"][key]["free, jitter 0"]["K"], d["periods"][key]["free, jitter 0"]["eK"])
                      for fam, d in res["other_instruments"].items() if key in d["periods"])
    g = res.get("gaia") or {}
    gaia = "RUWE %.2f%s" % (float(g["ruwe"]), "".join(", " + s for s in g["solutions"])) if g.get("ruwe") not in (None, "") else "none"
    return "%-12s %10.3f d | %s | indicators at P: %s | other telescopes: %s | Gaia %s" % (res["name"], P, sets or "none", ind or "none", other or "none", gaia)


def planets_vet_print(res):
    """A vet record printed in full."""
    print("== %s at %s" % (res["name"], ", ".join("%g d" % P for P in res["periods"])), flush=True)
    if res.get("line_by_line_stale_calibrations"):
        print("  line-by-line: %d spectra wavelength-calibrated more than 30 days before they were taken left out" % res["line_by_line_stale_calibrations"], flush=True)
    for label, r in res["sets"].items():
        print("  %-26s n %4d span %5d jitter %5.2f | found %s" % (label, r["n"], r["span"], r["jitter"], ", ".join("%g" % x for x in r["found"])), flush=True)
        for P, c in r["candidates"].items():
            print("      %-8s peak %9.3f power %.3f fap %7s | aliases %s | halves %s" % (P, c["P_peak"], c["power"], c["fap"], c["aliases"], "; ".join(
                "K %.2f+-%.2f phase %.0f" % (h["K"], h["eK"], h["phase"]) for h in c["halves"])), flush=True)
    for label, r in res["indicators"].items():
        if r:
            print("  %-26s top %9.2f d (%s) | %s" % (label, r["top_d"], r["top_fap"], " ".join("%s: %.3f (%s)" % (k, v["power"], v["fap"]) for k, v in r.items()
                                                                                         if isinstance(v, dict))), flush=True)
    for fam, r in res["other_instruments"].items():
        print("  %-26s %d nights %d-%d (%s): %s" % (fam, r["nights"], r["first"], r["last"], r["source"], "; ".join(
            "%s d: %s" % (P, ", ".join("%s K %.2f+-%.2f" % (k, v["K"], v["eK"]) for k, v in d.items() if isinstance(v, dict))) for P, d in r["periods"].items())), flush=True)
    if "gaia" in res:
        print("  Gaia DR3 %s: RUWE %s, non-single-star %s, solutions %s" % (res["gaia"]["source_id"], res["gaia"]["ruwe"], res["gaia"]["non_single_star"],
                                                                           res["gaia"]["solutions"] or "none"), flush=True)


def planets_triage(rows, stars):
    """The candidates ROWS split into those kept and those set aside with why: e of 0.85 or more, fewer than two cycles, within 5 per cent of a year or
    half a year, or a planet the archive lists for the star in any published solution within 5 per cent of the period (planets_catalogued)."""
    match = planets_catalogued()
    kept, aside = [], []
    for r in rows:
        P, e, span = float(r["P"]), float(r["e"]), float(r["span_d"])
        why = []
        if e >= 0.85:
            why.append("degenerate fit")
        if P > 0.5 * span:
            why.append("under two cycles")
        if any(abs(P / y - 1.0) < 0.05 for y in (365.25, 182.63)):
            why.append("year alias")
        s = stars.get(r["name"], {})
        if match(planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000")), names=(r["name"], s.get("SimbadName")), P=P):
            why.append("archive planet")
        (aside if why else kept).append((r, why))
    return [r for r, _ in kept], aside


# how near a signal's period an activity indicator's own highest peak marks it as the indicator's, which 2 of 104 of the archive's planets of the bank's stars are
planets_INDICATOR_TOP = 0.02


def planets_verdict(res, P):
    """A vetted signal at P: the reductions where it holds (false-alarm level below 1e-3, halves agreeing in K and phase within 3 sigma), those where it
    fails with why, the indicators with power at P or their own highest peak within planets_INDICATOR_TOP of it, and the three as a sentence."""
    key = "%g" % P
    held, failed = [], []
    for label, s in res["sets"].items():
        c = s["candidates"].get(key)
        if c is None:
            continue
        why = [] if float(c["fap"]) < 1e-3 else ["fap %s" % c["fap"]]
        if len(c["halves"]) == 2:
            a, b = c["halves"]
            if abs(a["K"] - b["K"]) > 3.0 * math.hypot(a["eK"], b["eK"]):
                why.append("halves' K %.1f and %.1f" % (a["K"], b["K"]))
            if abs((a["phase"] - b["phase"] + 180.0) % 360.0 - 180.0) > 3.0 * math.hypot(a["ephase"], b["ephase"]):
                why.append("halves' phases %.0f and %.0f" % (a["phase"], b["phase"]))
        short = planets_VET_SHORT.get(label, label)
        (failed if why else held).append(short + (" (%s)" % ", ".join(why) if why else ""))
    ind = [k for k, r in res["indicators"].items() if r and (float(r.get(key, {}).get("fap", "1")) < 0.01 or abs(r["top_d"] / P - 1.0) < planets_INDICATOR_TOP)]
    text = ("holds in " + ", ".join(held) if held else "holds in no reduction") + ("; fails " + ", ".join(failed) if failed else "") + (
        "; indicators at P: " + ", ".join(ind) if ind else "")
    return held, failed, ind, text


def planets_families(held):
    """How many independent reductions HELD covers, the line-by-line sets counting as one."""
    return len({h.split()[0] for h in held})


def planets_rotation(bv, s):
    """A dwarf's rotation period (d) from B-V and the S index (Noyes et al. 1984, Mamajek and Hillenbrand 2008), None outside their calibrations."""
    if not (0.44 < bv < 1.2 and s > 0):
        return None
    ccf = 10 ** (1.13 * bv ** 3 - 3.91 * bv ** 2 + 2.84 * bv - 0.47)
    r = 1.34e-4 * ccf * s - 10 ** (-4.898 + 1.918 * bv ** 2 - 2.893 * bv ** 3)
    if r <= 0 or not -5.1 < math.log10(r) < -4.0:
        return None
    x = 1.0 - bv
    tau = 10 ** (1.362 - 0.166 * x + 0.025 * x ** 2 - 5.323 * x ** 3 if x > 0 else 1.362 - 0.14 * x)
    return (0.808 - 2.966 * (math.log10(r) + 4.52)) * tau


def planets_decide(res, P, system, tess, prot=None, modelled=False):
    """Whether a followed signal at P is a planet, and if not why: it must hold in two independent reductions with no indicator at P, or with one where MODELLED says the star's activity, modelled, leaves it standing (planets_activity_test), raise the joint
    model's BIC by more than 10 when removed, have no preferred alias, show no TESS brightness variation at P, P/2 or 2P (the strongest period, or power
    0.1 or more, in PDCSAP flux, QLP's detrended flux having had a star's slow variation taken out), lie more than 10 per cent from each of the star's rotation periods PROT and half of it, and leave its
    system stable on circular orbits."""
    held, _, ind, _ = planets_verdict(res, P)
    if ind and not modelled:
        return False, "activity indicator"
    if planets_families(held) < 2:
        return False, "one reduction"
    req = (system or {}).get("required", {}).get("%g" % P)
    if req is None:
        return False, "no joint model"
    if req["dbic"] <= 10.0:
        return False, "not needed"
    for a in system.get("aliases", {}).get("%g" % P, []):
        if a["observed_ratio"] < 1.0 and a["truth"].get("%.4f d" % P, {}).get("reaching_observed", 1.0) < 0.01:
            return False, "alias"
    c = (tess or {}).get("combined")
    c = None if c and c.get("flux") == "detrended" else c
    if c and float(c["fap"]) < 0.01 and any(abs(c["peak_d"] / q - 1.0) < 0.05 for q in (P, P / 2.0, 2.0 * P)):
        return False, "starspots"
    for label, power in (c or {}).get("near", {}).items():
        if label.split()[0] == "%g" % P and power >= 0.1 and float(c.get("near_fap", {}).get(label, "1")) < 0.01:
            return False, "starspots"
    if any(abs(P / q - 1.0) < 0.1 for x in prot or () for q in (x, x / 2.0)):
        return False, "rotation"
    stab = system.get("stability")
    if isinstance(stab, dict) and stab.get("circular", {}).get("status") != "stable":
        return False, "unstable"
    return True, ""


# the false-alarm level a velocity signal must reach once its star's activity is modelled, the level its indicator must stay above at the signal's period, the draws of the null, and how far a signal must lie from the rotation period and its harmonics
planets_ACTIVITY_FAP, planets_ACTIVITY_IND_FAP, planets_ACTIVITY_DRAWS, planets_ACTIVITY_ROTATION = 1e-3, 0.01, 200, 0.1
planets_ACTIVITY_CACHE = {}


def planets_qp_kernel(t, h, lam, w, prot):
    """The quasi-periodic covariance of a rotating star's activity (Haywood et al. 2014) between the times T (d): amplitude H, evolution timescale LAM, harmonic complexity W and rotation period PROT."""
    tau = t[:, None] - t[None, :]
    return h * h * np.exp(-0.5 * (tau / lam) ** 2 - 0.5 * (np.sin(np.pi * tau / prot) / w) ** 2)


def planets_gp_profile(p, t, y, e, X, gi):
    """The quasi-periodic process of the log parameters P (amplitude, evolution timescale, harmonic complexity, rotation period, then a jitter for each series numbered by GI) on the values Y at the times T with errors E, the linear model X solved by generalized least squares: its negative log likelihood, the covariance's Cholesky factor and the data whitened by it."""
    from scipy.linalg import cholesky, solve_triangular
    h, lam, w, prot = np.exp(p[:4])
    C = planets_qp_kernel(t, h, lam, w, prot) + np.diag(e ** 2 + np.exp(2.0 * np.asarray(p[4:]))[gi])
    try:
        L = cholesky(C, lower=True, check_finite=False)
    except np.linalg.LinAlgError:
        return np.inf, None, None
    yw, Xw = solve_triangular(L, y, lower=True, check_finite=False), solve_triangular(L, X, lower=True, check_finite=False)
    r = yw - Xw @ np.linalg.lstsq(Xw, yw, rcond=None)[0]
    return 0.5 * float(r @ r) + float(np.log(np.diag(L)).sum()), L, yw


def planets_gp_fit(t, y, e, X, gi, p0, free, lo, hi):
    """The parameters of planets_gp_profile that FREE marks fitted by L-BFGS-B within LO and HI from P0, the others held: the parameters and the negative log likelihood."""
    from scipy.optimize import minimize
    p0, free = np.asarray(p0, float), np.asarray(free, bool)

    def nll(q):
        p = p0.copy()
        p[free] = q
        got = planets_gp_profile(p, t, y, e, X, gi)[0]
        return got if math.isfinite(got) else 1e30
    got = minimize(nll, p0[free], method="L-BFGS-B", bounds=list(zip(np.asarray(lo, float)[free], np.asarray(hi, float)[free])))
    p = p0.copy()
    p[free] = got.x
    return p, float(got.fun)


def planets_gp_periodogram(t, L, yw, X, freqs, draws=0, seed=7, chunk=2000):
    """The chi-square a sinusoid at each of FREQS takes out of the whitened data YW beyond the linear model X, the covariance's Cholesky factor L whitening every column; with DRAWS, the highest of the same over FREQS in that many draws of the null, which whitened is white noise. Returns the powers, the null's highest, and the sinusoid's semi-amplitude and its error at each frequency."""
    from scipy.linalg import solve_triangular
    Q = np.linalg.qr(solve_triangular(L, X, lower=True, check_finite=False))[0]
    r = yw - Q @ (Q.T @ yw)
    R = None
    if draws:
        R = np.random.default_rng(seed).standard_normal((len(t), draws))
        R = R - Q @ (Q.T @ R)
    power, K, eK, null = np.empty(len(freqs)), np.empty(len(freqs)), np.empty(len(freqs)), np.full(draws, -np.inf)
    for i in range(0, len(freqs), chunk):
        ph = 2.0 * np.pi * np.outer(t, freqs[i:i + chunk])
        Cw, Sw = (solve_triangular(L, f(ph), lower=True, check_finite=False) for f in (np.cos, np.sin))
        Cw, Sw = Cw - Q @ (Q.T @ Cw), Sw - Q @ (Q.T @ Sw)
        cc, ss, cs = (Cw * Cw).sum(0), (Sw * Sw).sum(0), (Cw * Sw).sum(0)
        det = np.maximum(cc * ss - cs * cs, 1e-300)
        a, b = Cw.T @ r, Sw.T @ r
        power[i:i + chunk] = (ss * a * a - 2.0 * cs * a * b + cc * b * b) / det
        A, B = (ss * a - cs * b) / det, (cc * b - cs * a) / det
        K[i:i + chunk] = np.hypot(A, B)
        eK[i:i + chunk] = np.sqrt(np.maximum((A * A * ss + B * B * cc - 2.0 * A * B * cs) / det, 0.0)) / np.maximum(np.hypot(A, B), 1e-300)
        if draws:
            a, b = Cw.T @ R, Sw.T @ R
            null = np.maximum(null, ((ss[:, None] * a * a - 2.0 * cs[:, None] * a * b + cc[:, None] * b * b) / det[:, None]).max(0))
    return power, null, K, eK


def planets_gumbel_fap(z, null):
    """The false-alarm level of the power Z against NULL, the highest powers of draws of the null, by the Gumbel distribution of their mean and spread."""
    beta = max(float(np.std(null, ddof=1)) * math.sqrt(6.0) / math.pi, 1e-12)
    x = -(z - (float(np.mean(null)) - 0.5772156649 * beta)) / beta
    return 1.0 if x > 700.0 else float(-math.expm1(-math.exp(x)))


def planets_activity_test(t, v, e, g, indicators, P, others=(), prot=(), draws=planets_ACTIVITY_DRAWS):
    """Whether a velocity signal at P outlasts its star's activity (Haywood et al. 2014; Rajpaul et al. 2015). For each activity indicator of INDICATORS, pairs of its name and nightly values at the
    times T (nan where unmeasured), a quasi-periodic Gaussian process is fitted to the indicator, its rotation period started from each of the indicator's three highest peaks and each period of PROT;
    the velocities V with errors E are then given the same process with its timescales held, an amplitude and a jitter for each series G fitted, offsets and sinusoids at OTHERS taken out, and searched
    for a sinusoid in a periodogram whitened by it. The signal holds where that periodogram's power within a resolution element of P has a false-alarm level below planets_ACTIVITY_FAP against DRAWS
    draws of the process alone, the indicator's own whitened periodogram shows nothing there at planets_ACTIVITY_IND_FAP, and P lies further than planets_ACTIVITY_ROTATION from the fitted and listed
    rotation periods, their halves and their thirds, under every indicator. Returns the verdict, why, the highest false-alarm level and each indicator's reading."""
    span = float(t.max() - t.min())
    freqs = np.arange(1.0 / span, 1.0 / 1.5, 1.0 / (5.0 * span))
    near = np.abs(freqs - 1.0 / P) <= 1.0 / span
    if not near.any() or not indicators:
        return dict(P=P, verdict="failed", why="no indicator to model" if not indicators else "outside the periodogram", fap=1.0, readings=[])
    gi = np.searchsorted(np.unique(g), g)
    X = np.column_stack([(gi == k).astype(float) for k in range(int(gi.max()) + 1)] + [f(2.0 * np.pi * t / Q) for Q in others for f in (np.cos, np.sin)])
    readings, why = [], []
    for name, y in indicators:
        m = np.isfinite(y)
        if m.sum() < 20:
            readings.append(dict(indicator=name, note="too few nights"))
            why.append("%s too sparse to model" % name)
            continue
        ti, gj = t[m], np.searchsorted(np.unique(g[m]), g[m])
        yi = y[m] - np.median(y[m])
        yi = yi / (1.4826 * float(np.median(np.abs(yi))) or float(np.std(yi)) or 1.0)
        Xi = np.column_stack([(gj == k).astype(float) for k in range(int(gj.max()) + 1)])
        pw = gpu_host(gpu_gls(ti, yi, np.ones(len(yi)), freqs))
        per = 1.0 / freqs
        loc = np.flatnonzero((pw[1:-1] >= pw[:-2]) & (pw[1:-1] >= pw[2:])) + 1
        loc = loc[(per[loc] >= 1.5) & (per[loc] <= span / 3.0)]
        starts = []
        for k in loc[np.argsort(-pw[loc])]:
            if all(abs(per[k] / q - 1.0) > 0.1 for q in starts):
                starts.append(float(per[k]))
            if len(starts) == 3:
                break
        starts += [q for q in prot if 1.5 <= q <= span / 2.0 and all(abs(q / s - 1.0) > 0.1 for s in starts)]
        best = None
        for q in starts or [span / 10.0]:
            G = int(gj.max()) + 1
            p0 = [0.0, math.log(2.0 * q), math.log(0.7), math.log(q)] + [math.log(0.5)] * G
            lo = [math.log(1e-3), math.log(0.4 * q), math.log(0.2), math.log(0.8 * q)] + [math.log(1e-3)] * G
            hi = [math.log(10.0), math.log(5.0 * span), math.log(5.0), math.log(1.2 * q)] + [math.log(3.0)] * G
            p, nll = planets_gp_fit(ti, yi, np.zeros(len(yi)), Xi, gj, p0, [True] * (4 + G), lo, hi)
            if best is None or nll < best[1]:
                best = (p, nll)
        p_ind = best[0]
        _, Li, ywi = planets_gp_profile(p_ind, ti, yi, np.zeros(len(yi)), Xi, gj)
        if Li is None:
            readings.append(dict(indicator=name, note="no process fits"))
            why.append("%s not modelled" % name)
            continue
        pwi, nulli, _, _ = planets_gp_periodogram(ti, Li, ywi, Xi, freqs, draws)
        fap_ind = planets_gumbel_fap(float(pwi[near].max()), nulli)
        sd = float(np.std(v)) or 1.0
        G = int(gi.max()) + 1
        p0 = np.concatenate([[math.log(sd)], p_ind[1:4], np.full(G, math.log(1.0))])
        lo = np.concatenate([[math.log(1e-2)], p_ind[1:4], np.full(G, math.log(1e-2))])
        hi = np.concatenate([[math.log(10.0 * sd)], p_ind[1:4], np.full(G, math.log(3.0 * sd))])
        pv, _ = planets_gp_fit(t, v, e, X, gi, p0, [True, False, False, False] + [True] * G, lo, hi)
        _, Lv, ywv = planets_gp_profile(pv, t, v, e, X, gi)
        if Lv is None:
            readings.append(dict(indicator=name, note="no process fits the velocities"))
            why.append("velocities not modelled under %s" % name)
            continue
        pwv, nullv, K, eK = planets_gp_periodogram(t, Lv, ywv, X, freqs, draws)
        k = int(np.flatnonzero(near)[np.argmax(pwv[near])])
        fap = planets_gumbel_fap(float(pwv[k]), nullv)
        rot = float(math.exp(p_ind[3]))
        at_rot = any(abs(P / (x / n) - 1.0) < planets_ACTIVITY_ROTATION for x in [rot] + list(prot) for n in (1.0, 2.0, 3.0))
        held = fap < planets_ACTIVITY_FAP and fap_ind >= planets_ACTIVITY_IND_FAP and not at_rot
        readings.append(dict(indicator=name, prot_d=round(rot, 2), lam_d=round(float(math.exp(p_ind[1])), 1), w=round(float(math.exp(p_ind[2])), 2), activity_ms=round(float(math.exp(pv[0])), 2),
                             P_peak=round(float(1.0 / freqs[k]), 4), K=round(float(K[k]), 3), eK=round(float(eK[k]), 3), fap=fap, fap_indicator=fap_ind, held=bool(held)))
        if not held:
            why.append("%s: %s" % (name, "at the rotation" if at_rot else "the indicator holds the period too (%.1e)" % fap_ind if fap_ind < planets_ACTIVITY_IND_FAP else "not significant once modelled (%.1e)" % fap))
    ok = bool(readings) and all(x.get("held") for x in readings)
    return dict(P=P, verdict="held" if ok else "failed", why="; ".join(why), fap=max([x.get("fap", 1.0) for x in readings] or [1.0]), readings=readings)


def planets_indicator_column(label):
    """The column of planets_INDICATORS that a vet record's indicator LABEL, its source and its name ("bank CRX", "DACE S", "line-by-line H alpha"), is read from in a star's nightly rows, or None."""
    head, _, rest = label.partition(" ")
    name = (rest if head in ("bank", "DACE") else label.replace("line-by-line ", "")).replace("H alpha", "Halpha")
    return planets_INDICATORS.index(name) if name in planets_INDICATORS else None


def planets_activity_result(name, P):
    """The activity test's record of the star NAME's signal at P (planets_activity), or None."""
    if name not in planets_ACTIVITY_CACHE:
        planets_ACTIVITY_CACHE[name] = planets_load_json(os.path.join(planets_RESULTS, "activity", archive_tag(name) + ".json")) or {}
    return planets_ACTIVITY_CACHE[name].get("signals", {}).get("%g" % P)


def planets_activity_ready(name, P):
    """Whether the activity test holds the star NAME's signal at P and its system analysis has weighed it, so that the decision follows it."""
    got = planets_activity_result(name, P)
    if not got or got.get("verdict") != "held":
        return False
    system = planets_load_json(os.path.join(planets_RESULTS, "system", archive_tag(name), "analysis.json")) or {}
    return any(abs(P / q - 1.0) < 1e-9 for q in system.get("periods", []))


def planets_activity_text(got):
    """An activity test's record as the activity_model column gives it."""
    return "%s, false-alarm level %.1e%s" % (got["verdict"], got.get("fap", 1.0), "; " + got["why"] if got.get("why") else "")


def planets_activity(part=None):
    """The velocity signals that hold in two independent reductions and are set aside only because an activity indicator shows power at their period, each given the test of planets_activity_test
    with the indicators that do, to RESULTS/activity/<star>.json, made again when the star's nightly velocities or the test's code change. A signal that holds has its star followed again with it
    (planets_followup_star), so that the decision weighs it as it weighs any followed signal, a likely planet until another spectrograph's spectra hold it (planets_second_decide). PART takes the
    share K/N; the pass ends between stars where a long search would, with exit status 3."""
    path = os.path.join(planets_RESULTS, "signals.csv")
    if not os.path.exists(path):
        return
    sig = planets_read(path)
    want = {}
    for r in sig:
        if r["kind"] in ("found", "eccentric") and (r["reason"] == "activity indicator" or r.get("activity_model")):
            want.setdefault(r["name"], set()).add(float(r["P"]))
    names = sorted(want)
    if part:
        k, n = (int(x) for x in part.split("/"))
        names = names[k::n]
    digest = planets_rules_hash(("planets_activity", "planets_activity_test", "planets_indicator_column", "planets_qp_kernel", "planets_gp_profile", "planets_gp_fit", "planets_gp_periodogram", "planets_gumbel_fap"),
                                (planets_ACTIVITY_FAP, planets_ACTIVITY_IND_FAP, planets_ACTIVITY_DRAWS, planets_ACTIVITY_ROTATION))
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    bank, dace = planets_bank_series(set(names)), planets_dace_series(set(names))
    folder = os.path.join(planets_RESULTS, "activity")
    os.makedirs(folder, exist_ok=True)
    for name in names:
        if planets_search_ends():
            sys.exit(3)
        res = planets_load_json(os.path.join(planets_RESULTS, "vet", archive_tag(name) + ".json"))
        rows, _ = planets_series(name, dace, bank, stars.get(name, {}).get("SpType"))
        if not res or not rows:
            continue
        x = planets_nightly(rows)
        t, v, e, g = x[:, 0], x[:, 1], x[:, 2], x[:, 3].astype(int)
        kept = os.path.join(folder, archive_tag(name) + ".json")
        rec, mark = planets_load_json(kept) or {}, "%d:%.4f" % (len(t), float(t.sum()))
        if rec.get("digest") != digest or rec.get("data") != mark:
            rec = dict(digest=digest, data=mark, signals={})
        s = stars.get(name, {})
        prot = [q for q in (archive_num(s.get("Prot")),) if q] + planets_rotation_read(planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000")))
        known = [float(r["P"]) for r in sig if r["name"] == name and r["kind"] == "known"]
        holding = []
        for P in sorted(want[name]):
            key = "%g" % P
            if key not in rec["signals"]:
                held, _, ind, _ = planets_verdict(res, P) if "%g" % P in next(iter(res["sets"].values()), {}).get("candidates", {}) else ([], [], [], "")
                if planets_families(held) < 2 or not ind:
                    rec["signals"][key] = dict(P=P, verdict="not tested", why="holds in fewer than two reductions" if planets_families(held) < 2 else "no indicator at the period")
                    continue
                others = [float(r["P"]) for r in sig if r["name"] == name and r["kind"] in ("found", "eccentric", "known") and r["status"] in ("new", "known", "likely") and abs(float(r["P"]) / P - 1.0) > 0.02]
                cols = []
                for k in ind:
                    c = planets_indicator_column(k)
                    if c is not None and c not in cols:
                        cols.append(c)
                inds = [(planets_INDICATORS[c], x[:, 4 + c]) for c in cols]
                try:
                    rec["signals"][key] = planets_activity_test(t, v, e, g, inds, P, others, prot)
                except Exception as exc:
                    rec["signals"][key] = dict(P=P, verdict="failed", why="%s: %s" % (type(exc).__name__, str(exc)[:120]), fap=1.0)
                print("%-16s P %10.4f %s" % (name[:16], P, planets_activity_text(rec["signals"][key])), flush=True)
            if rec["signals"][key]["verdict"] == "held":
                holding.append(P)
        archive_save(kept, json.dumps(rec, separators=(",", ":")).encode())
        system = planets_load_json(os.path.join(planets_RESULTS, "system", archive_tag(name), "analysis.json")) or {}
        had = system.get("periods", [])
        missing = [P for P in holding if not any(abs(P / q - 1.0) < 1e-9 for q in had)]
        if missing:
            planets_followup_star(name, sorted({q for q in had if not any(abs(q / k - 1.0) < 1e-9 for k in known)} | set(missing)), known)


def planets_followup_star(name, periods, known, lbl_streams=4):
    """One followed star's work: line-by-line velocities where it has none and a fresh vet, its orbits sampled free and circular, the circular orbits
    placing its transit windows in TESS's light curves, and the system analysis, at PERIODS and the archive's KNOWN periods; each step's failure to
    ROOT/followup/<name>.json."""
    errors, system = {}, sorted(set(known) | set(periods))
    if not os.path.exists(planets_path("lbl", archive_tag(name) + ".lbl.npz")):
        try:
            planets_lbl(name, streams=lbl_streams)
        except (SystemExit, Exception) as exc:
            errors["lbl"] = str(exc)[:200]
    planets_vet([(name, periods)])
    for step, call in (("orbits", lambda: planets_orbits(name, system)), ("orbits circular", lambda: planets_orbits(name, system, circular=True)),
                       ("tess", lambda: planets_tess(name, periods)), ("system", lambda: planets_system(name, system))):
        try:
            call()
        except Exception as exc:
            errors[step] = "%s: %s" % (type(exc).__name__, str(exc)[:200])
    os.makedirs(planets_path("followup"), exist_ok=True)
    json.dump(errors, open(planets_path("followup", archive_tag(name) + ".json"), "w"), separators=(",", ":"))


def planets_followup_row(r, res, catalogued=(), unexplained=(), prot=None):
    """A followed signal's decision and follow-up columns for RESULTS/signals.csv, known where the star has a catalogued companion without a period."""
    P, tag = float(r["P"]), archive_tag(r["name"])
    load = lambda p: json.load(open(p)) if os.path.exists(p) else None
    system, tess = load(os.path.join(planets_RESULTS, "system", tag, "analysis.json")), load(os.path.join(planets_RESULTS, "tess", tag + ".json"))
    orbits = load(os.path.join(planets_RESULTS, "orbits", tag + ".json"))
    modelled = bool(planets_verdict(res, P)[2]) and planets_activity_ready(r["name"], P)
    planet, reason = planets_decide(res, P, system, tess, prot, modelled)
    act = planets_activity_result(r["name"], P)
    row = dict(status=("known" if unexplained else "likely" if modelled else "new") if planet else "rejected", reason=("catalogued" if unexplained else "activity modelled" if modelled else "") if planet else reason,
               activity_model=planets_activity_text(act) if act and act.get("verdict") in ("held", "failed") else "",
               catalogued="; ".join(catalogued), ruwe=archive_num((res.get("gaia") or {}).get("ruwe")), rotation_d=round(min(prot, key=lambda q: abs(math.log(P / q))), 1) if prot else "")
    for label, s in res["sets"].items():
        c = s["candidates"].get("%g" % P)
        if c:
            row["fap_" + planets_VET_SHORT.get(label, label).lower().replace(" ", "_")] = float(c["fap"])
    # Match the signal to the sampled planet with the nearest period; planets_orbits keeps each period within 20% of its starting value.
    pl = min(orbits["planets"], key=lambda x: abs(x["P"][0] / P - 1.0)) if orbits else None
    if pl and abs(pl["P"][0] / P - 1.0) < 0.2:
        for key, col in (("P", "orbit_P"), ("msini_mearth", "orbit_msini_mearth"), ("e", "orbit_e"), ("K", "orbit_K")):
            row.update({col: pl[key][0], col + "_lo": pl[key][1], col + "_hi": pl[key][2]})
    if system:
        row["dbic"] = system.get("required", {}).get("%g" % P, {}).get("dbic")
        row["aliases_excluded"] = all(a["observed_ratio"] >= 1.0 and next(v["reaching_observed"] for k, v in a["truth"].items() if k != "%.4f d" % P) < 0.01
                                      for a in system["aliases"].get("%g" % P, []))
    if tess:
        row["tess_power"] = tess["combined"]["near"].get("%g P" % P)
        near = min(tess["windows"], key=lambda k: abs(float(k) / P - 1.0), default=None)
        w = tess["windows"][near] if near is not None and abs(float(near) / P - 1.0) < 0.2 else None
        limits = [x["central"]["radius_limit_rearth"] for x in (w or {}).get("windows", []) if x.get("central", {}).get("probability_covered", 0) >= 0.5]
        row["tess_radius_limit_rearth"] = min(limits) if limits else None
    return row


# the SIMBAD types of a binary star
planets_BINARY_TYPES = ("SB*", "EB*", "El*", "RS*", "WU*", "bL*", "Al*")


def planets_object(mjup):
    """The kind of body of a mass in Jupiter masses: a planet below 13, a brown dwarf below 80, a star above."""
    return "" if not math.isfinite(mjup) else "planet" if mjup < 13.0 else "brown dwarf" if mjup < 80.0 else "star"


def planets_varying(bank, stars, skip):
    """The bank's late-type stars outside SKIP that vary like binaries (4+ nights, reduced chi-square > 25, scatter > 30 m/s and 5 median errors): name to nights."""
    out = {}
    for n, rows in bank.items():
        if n in skip or not planets_late_type(stars.get(n, {}).get("SpType")):
            continue
        x = np.array(rows)
        V, E = [], []
        for sel in (x[:, 0] < planets_UPGRADE, x[:, 0] >= planets_UPGRADE):
            if sel.any():
                _, vn, en = planets_by_night(x[sel, 0], x[sel, 1], x[sel, 2])
                V.append(vn - np.sum(vn / en ** 2) / np.sum(1.0 / en ** 2)), E.append(en)
        v, e = np.concatenate(V), np.concatenate(E)
        if len(v) < 4:
            continue
        chi2r = float(np.sum((v / e) ** 2) / max(len(v) - len(V), 1))
        scatter = float(1.4826 * np.median(np.abs(v - np.median(v))))
        if chi2r > 25.0 and scatter > 30.0 and scatter > 5.0 * float(np.median(e)):
            out[n] = len(v)
    return out


def planets_gaia(names, stars):
    """Each star's Gaia DR3 source and non-single-star solutions, cached in ROOT/gaia.json: name to (source, solutions) or None."""
    path = planets_path("gaia.json")
    cache = json.load(open(path)) if os.path.exists(path) else {}
    todo = [n for n in names if n not in cache]
    if todo:
        found = dict(zip(todo, archive_pmap(lambda n: archive_gaia_star(float(stars[n]["RAJ2000"]), float(stars[n]["DEJ2000"]), archive_num(stars[n].get("Vmag")),
                                                                        physical=False), todo)))
        sols = archive_gaia_solutions([g["source_id"] for g in found.values() if g])
        for n, g in found.items():
            cache[n] = [g, sols[str(g["source_id"])]] if g else None
        json.dump(cache, open(path, "w"), separators=(",", ":"))
    return {n: cache.get(n) for n in names}


# the days Gaia DR3's epochs span, over half of which its orbits' periods are bound loosely
planets_GAIA_WINDOW = 1034.0


def planets_catalogue(names, stars, periods=None):
    """Each star's catalogue entries: SIMBAD binary type, SIMBAD planets and brown dwarfs, Gaia orbits and archive planets, matched to PERIODS if given, a Gaia orbit past half its window matching any period past the window."""
    simbad = {n: (stars.get(n, {}).get("SimbadName") or n).strip() for n in names}
    basic = archive_simbad_basic(sorted(set(simbad.values())))
    kids = archive_simbad_companions(sorted(set(simbad.values())))
    # papers on a few hundred objects at most whose titles name a binary, a companion or an orbit
    papers = archive_simbad_papers(sorted(set(simbad.values())), words=("binar", "companion", "orbit"), most=500)
    gaia = planets_gaia(names, stars)
    known = planets_read(planets_path("known.csv"))
    kra, kdec, kper = (np.array([planets_num(k[c]) for k in known]) for c in ("ra", "dec", "pl_orbper"))
    kpm = np.array([[np.nan_to_num(planets_num(k["sy_pmra"])), np.nan_to_num(planets_num(k["sy_pmdec"]))] for k in known])
    out = {}
    for n in names:
        P = (periods or {}).get(n)
        near = lambda Q, tol: P is None or (math.isfinite(Q) and abs(P / Q - 1.0) < tol)
        hits = []
        otype = (basic.get(simbad[n]) or {}).get("otype") or ""
        if otype in planets_BINARY_TYPES:
            hits.append("SIMBAD " + otype)
        hits += ["SIMBAD %s %s" % (k[1], " ".join(k[0].split())) for k in kids.get(simbad[n], [])]
        hits += ["paper %s" % p[0] for p in papers.get(simbad[n], [])[:3]]
        g = gaia.get(n)
        for o in (g[1]["orbit"] if g else []):
            if near(planets_num(o.get("period")), 0.2) or (P is not None and P > planets_GAIA_WINDOW and planets_num(o.get("period")) > 0.5 * planets_GAIA_WINDOW):
                hits.append("Gaia %s %.1f d" % (o.get("nss_solution_type"), planets_num(o.get("period"))))
        ra, dec = planets_num(stars[n]["RAJ2000"]), planets_num(stars[n]["DEJ2000"])
        cosd = math.cos(math.radians(dec))
        sep = lambda a, d: np.hypot(((a - ra + 180.0) % 360.0 - 180.0) * cosd, d - dec) * 3600.0
        close = np.minimum(sep(kra, kdec), sep(kra - 16.0 * kpm[:, 0] / 3.6e6 / cosd, kdec - 16.0 * kpm[:, 1] / 3.6e6)) < 60.0
        hits += ["archive %s" % known[i]["pl_name"] for i in np.where(close)[0] if near(kper[i], 0.05)]
        out[n] = hits
    return out


def planets_companion(name, perms=50, most=40, seed=17):
    """One star's companion analysis to RESULTS/companion/<name>.json: Keplerian periodogram and permutation null, sampled and weighed orbit, and a
    second reduction from its archive spectra by cross-correlation."""
    star = next(r for r in planets_read(planets_path("bank_stars.csv")) if r["Name"] == name)
    t, v, e, g = planets_nights(name)
    span = float(t.max() - t.min())
    kp = planets_kepler_power(t, v, e, g)
    rng = np.random.default_rng(seed)
    null = np.array([planets_kepler_power(t, v, e, g, shuffle=rng)["dchi2"] for _ in range(perms)])
    beta = max(float(np.std(null, ddof=1)) * math.sqrt(6.0) / math.pi, 1e-9)
    mu = float(np.mean(null)) - 0.5772 * beta
    P0 = kp["P"]
    away = np.abs(1.0 / kp["freqs"] / P0 - 1.0) > 0.05
    s2 = max((kp["chi0"] - kp["dchi2"]) / max(len(t) - (int(g.max()) + 1) - 5, 1), 1.0)
    z = -(kp["dchi2"] - mu) / beta
    rec = dict(name=name, nights=len(t), span_d=round(span), P=round(P0, 4), e=kp["e"], K=round(kp["K"], 2), dchi2=round(kp["dchi2"], 1),
               fap=1.0 if z > 700.0 else float(-math.expm1(-math.exp(z))), null_mean=round(float(np.mean(null)), 1), null_sd=round(float(np.std(null, ddof=1)), 1),
               null_max=round(float(null.max()), 1), cycles=round(span / P0, 2),
               margin=round(float((kp["dchi2"] - kp["best"][away].max()) / s2), 1) if away.any() else None)
    if span >= 2.0 * P0:
        try:
            planets_orbits(name, [P0], steps=20000, label="companion")
            o = json.load(open(os.path.join(planets_RESULTS, "orbits", archive_tag(name) + ".companion.json")))["planets"][0]
            rec["orbit"] = {k: o[k] for k in ("P", "K", "e", "msini_mearth")}
        except Exception as exc:
            rec["orbit_error"] = "%s: %s" % (type(exc).__name__, str(exc)[:200])
    if P0 > 100.0:
        try:
            planets_weigh(name, pmin=0.75 * P0, pmax=1.25 * P0) if span >= 2.0 * P0 else planets_weigh(name)
            w = json.load(open(os.path.join(planets_RESULTS, "weigh", archive_tag(name) + ".json")))
            rec["weigh"] = {k: w[k] for k in ("P_d", "e", "K1_ms", "m2_mjup", "incl_deg", "a_au", "acceleration", "velocity_trend", "p_below_13mjup",
                                              "p_below_80mjup", "period_allowed", "wobble_mas", "excess_noise_mas", "excess_noise_sig") if k in w}
        except BaseException as exc:
            rec["weigh_error"] = str(exc)[:200]
    gs = archive_gaia_star(float(star["RAJ2000"]), float(star["DEJ2000"]), archive_num(star.get("Vmag")), physical=False)
    if gs:
        rec["ruwe"] = archive_num(gs.get("ruwe"))
        hip = archive_hipparcos_of(gs["source_id"]) or planets_hip_near(gs)
        k = planets_anomaly(gs, hip)
        rec["pma_snr"] = round(k["snrPMaH2EG3b"], 1) if k else None
    # The second reduction: the archive's spectra on the bank's nights measured by cross-correlation, or in a root planets_measure measured, where the
    # bank is already that, the same spectra's line-by-line velocities, or in a root planets_tables set up its second reduction of the same spectra.
    night = np.floor(t + 0.3)
    stored = planets_path("lbl", archive_tag(name) + ".lbl.npz")
    rows = sorted((x for k, xs in planets_dace_series({name}).get(name, {}).items() if planets_family(k[0]) == planets_BANK_FAMILY for x in xs), key=lambda x: x[0]) if planets_BANK_INFO else []
    own = None if rows else planets_own_spectra(name, 10.0)
    if rows or planets_BANK_INFO and own is None:
        tv = np.array([x[0] for x in rows])
        v1 = np.array([x[1] for x in rows])
        keep_ = np.isin(np.floor(tv + 0.3), night)
        tv, v1 = tv[keep_], v1[keep_]
    elif os.path.exists(planets_path("measure.json")) and os.path.exists(stored):
        d = np.load(stored)
        tv, v1 = d["mjd"], d["rv"]
        keep_ = np.isin(np.floor(tv + 0.3), night) & np.isfinite(v1)
        tv, v1 = tv[keep_], v1[keep_]
    else:
        best = {}
        for r in own if own is not None else archive_eso_listing(float(star["RAJ2000"]), float(star["DEJ2000"]), "HARPS", 10.0):
            k = math.floor(float(r["t_min"]) + 0.3)
            if k in night and (k not in best or (archive_num(r["snr"]) or 0) > (archive_num(best[k]["snr"]) or 0)):
                best[k] = r
        pick = [best[k] for k in sorted(best)]
        pick = [pick[int(i)] for i in np.unique(np.linspace(0, len(pick) - 1, most).round())] if len(pick) > most else pick
        folder = planets_path("spectra", archive_tag(name) + ".ccf")
        spectra = spectra_read(archive_eso_fetch(pick, folder, streams=2 if own is not None else 4))
        shutil.rmtree(folder, ignore_errors=True)
        tv = np.array([s[3]["mjd"] for s in spectra])
        v1 = binaries_velocities(spectra, binaries_line_depths(spectra, binaries_velocities(spectra, np.load(binaries_template_path()))[0]))[0] * 1000.0 if len(spectra) >= 6 else []
    if len(tv) >= 6:
        at = {k: i for i, k in enumerate(night)}
        j = np.array([at[math.floor(x + 0.3)] for x in tv])
        a, b = v1.copy(), v[j].copy()
        for gi in np.unique(g[j]):
            m = g[j] == gi
            a[m], b[m] = a[m] - a[m].mean(), b[m] - b[m].mean()
        rec["ccf"] = dict(nights=int(len(j)), corr=round(float(np.corrcoef(a, b)[0, 1]), 3), rms=round(float(np.std(a - b)), 1))
    os.makedirs(os.path.join(planets_RESULTS, "companion"), exist_ok=True)
    json.dump(rec, open(os.path.join(planets_RESULTS, "companion", archive_tag(name) + ".json"), "w"), separators=(",", ":"))
    print(json.dumps(rec), flush=True)


# The 99th percentile of the wobble over Gaia's excess noise, or over 0.3 mas where that is not significant, among the orbits and the accelerations Gaia DR3 publishes, in steps
# of wobble ending at planets_WOBBLE_STEPS (mas) and a last step above them (planets_wobble_calibration)
planets_WOBBLE_STEPS = (0.4, 0.5, 0.65, 0.8, 1.0, 1.25, 1.6, 2.0, 2.5)
planets_WOBBLE_P99 = dict(orbit=(1.30, 1.58, 1.87, 2.06, 2.12, 2.39, 2.44, 2.42, 2.49, 3.06), acceleration=(1.32, 1.65, 2.10, 2.56, 3.09, 3.63, 4.26, 5.07, 5.76, 8.83))


def planets_weigh_noise(w):
    """The wobble a weighing (planets_weigh) sets against Gaia's astrometric excess noise, the posterior's median in mas, and that noise, 0.3 mas where it is not significant."""
    eps, sig = w.get("excess_noise_mas"), w.get("excess_noise_sig")
    return w["wobble_mas"][0], max(eps if eps is not None and sig is not None and sig > 2.0 else 0.0, 0.3)


def planets_weigh_holds(w):
    """Whether a weighing's orbit (planets_weigh) stands against Gaia's astrometric excess noise: the wobble its photocentre leaves about Gaia's five-parameter solution within what
    99 per cent of Gaia DR3's published solutions of that wobble leave against their own noise (planets_WOBBLE_P99), its accelerations where the star has one and its orbits
    otherwise. A weighing made before the wobble was read holds."""
    if not w.get("wobble_mas"):
        return True
    wobble, noise = planets_weigh_noise(w)
    return wobble <= planets_WOBBLE_P99["acceleration" if w.get("acceleration") else "orbit"][int(np.searchsorted(planets_WOBBLE_STEPS, wobble, side="right"))] * noise


def planets_weigh_agrees(w):
    """Whether a weighing's orbit (planets_weigh) agrees with Gaia's astrometric excess noise closely enough for its mass to stand: its wobble at most 1.65 times that noise, twice
    the quarter in log the weighing allows above it, which 95 per cent of Gaia DR3's published orbits near a milliarcsecond's wobble keep within. A weighing made before the wobble
    was read agrees."""
    if not w.get("wobble_mas"):
        return True
    wobble, noise = planets_weigh_noise(w)
    return wobble <= math.exp(0.5) * noise


def planets_decide_companion(rec):
    """A companion analysis's verdict and reason: 10+ nights, FAP < 1e-3, period fixed by a margin of 10 or by astrometry whose orbit stands against Gaia's
    excess noise (planets_weigh_holds), second reduction at r >= 0.9."""
    if rec["nights"] < 10:
        return False, "few nights"
    if rec["cycles"] < 2.0:
        # an orbit longer than half the span stands on the astrometry: an anomaly of 5 sigma or a Gaia solution, and a period the prior does not set
        w = rec.get("weigh")
        if not w:
            return False, "under two cycles"
        if not ((rec.get("pma_snr") or 0.0) >= 5.0 or w.get("acceleration") or w.get("velocity_trend")):
            return False, "not significant"
        if not planets_weigh_holds(w):
            return False, "astrometry inconsistent"
        # the periods the profile allows (planets_weigh), or for a weighing without one the sampled 16th to 84th percentiles
        a, b = (w["period_allowed"][0][0], w["period_allowed"][-1][1]) if w.get("period_allowed") else (w["P_d"][1], w["P_d"][2])
        lo, hi = max(0.5 * rec["span_d"], 50.0), 36525.0
        if b > 2.0 * a or b > 0.9 * hi or a < 1.1 * lo:
            return False, "period unbounded"
    elif rec["fap"] >= 1e-3:
        return False, "not significant"
    elif rec.get("margin") is not None and rec["margin"] < 10.0:
        return False, "period ambiguous"
    c = rec.get("ccf") or {}
    if c.get("nights", 0) < 6 or c.get("corr", 0.0) < 0.9:
        return False, "one reduction"
    return True, ""


def planets_companion_row(name, star, rec, cat):
    """A companion's signals.csv row from its analysis REC and catalogue entries CAT."""
    m1 = planets_star_mass(star)
    row = dict(name=name, sptype=star.get("SpType", ""), vmag=star.get("Vmag", ""), kind="companion", label="orbit", nights=rec["nights"], span_d=rec["span_d"],
               fap=rec["fap"], catalogued="; ".join(cat), ruwe=rec.get("ruwe"), pma_snr=rec.get("pma_snr"))
    o, w = rec.get("orbit"), rec.get("weigh")
    if o:
        P, K, e = o["P"][0], o["K"][0], o["e"][0]
        for key, col in (("P", "orbit_P"), ("msini_mearth", "orbit_msini_mearth"), ("e", "orbit_e"), ("K", "orbit_K")):
            row.update({col: o[key][0], col + "_lo": o[key][1], col + "_hi": o[key][2]})
    elif w:
        P, K, e = w["P_d"][0], w["K1_ms"][0], w["e"][0]
        for key, col in (("P_d", "orbit_P"), ("K1_ms", "orbit_K"), ("e", "orbit_e")):
            row.update({col: round(w[key][0], 4), col + "_lo": round(w[key][1], 4), col + "_hi": round(w[key][2], 4)})
    else:
        P, K, e = rec["P"], rec["K"], rec["e"]
    msini = planets_msini(P, K, e, m1)
    row.update(P=round(P, 4), K=round(K, 2), e=round(e, 3), msini_mjup=round(msini, 4), msini_mearth=round(msini * 317.83, 1))
    # the true mass where the weighing's orbit agrees with Gaia's excess noise; the minimum mass stands where it does not
    if w and planets_weigh_agrees(w):
        row.update(mass_mjup=round(w["m2_mjup"][0], 3), mass_mjup_lo=round(w["m2_mjup"][1], 3), mass_mjup_hi=round(w["m2_mjup"][2], 3))
    held, why = planets_decide_companion(rec)
    row.update(status=("known" if cat else "new") if held else "rejected", reason=("catalogued" if cat else "") if held else why,
               object=planets_object(row.get("mass_mjup") or msini))
    return row


def planets_decide_toi(r):
    """A weighed TESS candidate's verdict and reason: ephemeris within 0.1 period, K > 0 at 5 sigma, free phase within 3 sigma of the transit's."""
    if planets_num(r["phase_err"]) > 0.1:
        return False, "ephemeris lost"
    K, snr = planets_num(r["K"]), planets_num(r["snr"])
    if not (K > 0 and snr >= 5.0):
        return False, "not significant"
    eph = planets_num(r.get("ephase_deg"))
    if not math.isfinite(eph):
        eph = math.degrees(planets_num(r["eK_free"]) / max(planets_num(r["K_free"]), 1e-9))
    if abs(planets_num(r["phase_offset_deg"])) > 3.0 * math.hypot(eph, 360.0 * planets_num(r["phase_err"])):
        return False, "phase"
    return True, ""


def planets_toi_rows():
    """The weighed TESS candidates of ROOT/tois.csv, then of tois_eso.csv, tois_rvcat.csv and tois_bank.csv for those not weighed before, as decided signals.csv rows."""
    tois = planets_read(planets_path("tois.csv")) if os.path.exists(planets_path("tois.csv")) else []
    for table in ("tois_eso.csv", "tois_rvcat.csv", "tois_bank.csv"):
        have = {r["toi"] for r in tois}
        if os.path.exists(planets_path(table)):
            tois += [r for r in planets_read(planets_path(table)) if r["toi"] not in have]
    if not tois:
        return []
    if not all(r.get("ra") for r in tois):
        exo = planets_path("toi.csv")
        if not os.path.exists(exo):
            open(exo, "wb").write(archive_get(planets_EXOFOP["toi"], timeout=300))
        from astropy.coordinates import Angle
        pos = {x["TOI"]: (Angle(x["RA"], unit="hourangle").deg, Angle(x["Dec"], unit="deg").deg) for x in planets_read(exo)}
        for r in tois:
            r["ra"], r["dec"] = pos.get(r["toi"], ("", ""))
    match = planets_catalogued()
    basic = archive_simbad_basic(sorted({r["dace_name"] for r in tois}))
    out = []
    for r in tois:
        P, ra, dec = planets_num(r["period"]), planets_num(r["ra"]), planets_num(r["dec"])
        msini = planets_msini(P, abs(planets_num(r["K"])), 0.0, planets_num(r["mstar"]) or 1.0)
        cat = ["archive %s" % n for n in match(ra, dec, r.get("tic"), (r["dace_name"],), P)] + (["archive host %s" % r["archive_host"]] if r.get("archive_host") else [])
        otype = (basic.get(r["dace_name"]) or {}).get("otype") or ""
        if otype in planets_BINARY_TYPES and msini >= 80.0:
            cat.append("SIMBAD " + otype)
        held, why = planets_decide_toi(r)
        snr = planets_num(r["snr"])
        out.append(dict(name=r["dace_name"], kind="toi", label="TOI-" + r["toi"], nights=r["nights"], span_d=r["span_d"], P=round(P, 6), K=r["K"], e=0.0,
                        msini_mjup=round(msini, 4), msini_mearth=round(msini * 317.83, 1), jitter=r["jitter"],
                        fap="%.1e" % (0.5 * math.erfc(snr / math.sqrt(2.0))) if math.isfinite(snr) else "", catalogued="; ".join(cat),
                        status=("known" if cat else "new") if held else "rejected", reason=("catalogued" if cat else "") if held else why,
                        object=planets_object(msini)))
    return out


# MAST's tables of SPOC's threshold-crossing events with their data-validation statistics, one for each search of one sector or of several
planets_TCE = "https://archive.stsci.edu/missions/tess/catalogs/tce/"
planets_TCE_KEYS = ("tce_period", "tce_num_transits", "tce_bin_oedp_stat", "tce_ws_maxmes", "tce_dicco_msky", "tce_dicco_msky_err", "tce_cap_stat",
                    "tce_hap_stat")


def planets_tce(tics):
    """SPOC's threshold-crossing events of the TIC stars TICS with their data-validation statistics (planets_TCE_KEYS), read from every table MAST
    lists, the listing kept a day in ROOT/tce/listing.json and each table fetched into ROOT/tce once, their rows kept as arrays in ROOT/tce/events.npz
    until another table arrives: TIC to its events."""
    if not tics:
        return {}
    folder = planets_path("tce")
    os.makedirs(folder, exist_ok=True)
    listed = os.path.join(folder, "listing.json")
    if os.path.exists(listed) and time.time() - os.path.getmtime(listed) < 86400:
        names = json.load(open(listed))
    else:
        listing = archive_get(planets_TCE, timeout=120, soft=True)
        names = sorted(set(re.findall(r'href="([^"]+_dvr-tcestats\.csv)"', listing.decode("utf-8", "replace")))) if listing else []
        if names:
            archive_save(listed, json.dumps(names).encode())

    def fetch(name):
        path = os.path.join(folder, name)
        if not os.path.exists(path):
            b = archive_get(planets_TCE + name, timeout=600, soft=True)
            if b:
                archive_save(path, b)
    archive_pmap(fetch, names, 4)
    tables = [os.path.basename(p) for p in sorted(glob.glob(os.path.join(folder, "*_dvr-tcestats.csv")))]
    cache, d = os.path.join(folder, "events.npz"), None
    if os.path.exists(cache):
        with np.load(cache) as z:
            if z["tables"].tolist() == tables:
                d = dict(ticid=z["ticid"], values=z["values"])
    if d is None:
        ticid, values = [], []
        for name in tables:
            with open(os.path.join(folder, name), encoding="utf-8", errors="replace") as fh:
                rows = csv.reader(line for line in fh if not line.startswith("#"))
                head = next(rows, [])
                if "ticid" not in head:
                    continue
                at = {k: head.index(k) for k in ("ticid",) + planets_TCE_KEYS if k in head}
                for row in rows:
                    if len(row) > max(at.values()) and row[at["ticid"]].strip().isdigit():
                        ticid.append(int(row[at["ticid"]]))
                        values.append([planets_num(row[at[k]]) if k in at else float("nan") for k in planets_TCE_KEYS])
        d = dict(ticid=np.array(ticid, np.int64), values=np.array(values, float).reshape(-1, len(planets_TCE_KEYS)))
        tmp = archive_tmp(cache)
        with open(tmp, "wb") as fh:
            np.savez(fh, tables=np.array(tables), **d)
        archive_place(tmp, cache)
    out = {}
    hit = np.isin(d["ticid"], np.array(sorted({int(t) for t in tics}), np.int64))
    for t, v in zip(d["ticid"][hit].tolist(), d["values"][hit].tolist()):
        out.setdefault(str(t), []).append(dict(zip(planets_TCE_KEYS, v)))
    return out


def planets_dv(e):
    """A SPOC event's data validation as decided signals.csv columns, with the reason it fails, empty where it passes: a secondary eclipse found at a
    MES of 7.1 or more, the difference image's centroid off the out-of-transit image's at 3 sigma or more, or the halo aperture's statistic above the
    core aperture's, as a ghost's is. Its odd-even statistic is kept beside them; the odd-even test is orbitlight's own (planets_validate_one)."""
    sigma = e["tce_dicco_msky"] / e["tce_dicco_msky_err"] if e["tce_dicco_msky_err"] > 0 else float("nan")
    cols = {k: round(x, 3) if math.isfinite(x) else "" for k, x in (("dv_odd_even", e["tce_bin_oedp_stat"]), ("dv_secondary_mes", e["tce_ws_maxmes"]),
                                                                   ("dv_centroid_sigma", sigma), ("dv_core", e["tce_cap_stat"]), ("dv_halo", e["tce_hap_stat"]))}
    why = "secondary eclipse" if e["tce_ws_maxmes"] >= 7.1 else "centroid offset" if sigma >= 3.0 else "halo" if e["tce_hap_stat"] > e["tce_cap_stat"] else ""
    return cols, why


def planets_occultation_max(x, depth_ppm, P):
    """The deepest occultation (ppm) a planet transiting DEPTH_PPM deep every P days could give behind its star, ExoFOP's row X giving the star's mass,
    radius and temperature: the planet's geometric albedo one and its dayside at the equilibrium temperature without redistribution, a blackbody at 800 nm
    against the star's; zero where ExoFOP lacks them."""
    M, R, T = (planets_num(x.get(k)) for k in ("Stellar Mass (M_Sun)", "Stellar Radius (R_Sun)", "Stellar Eff Temp (K)"))
    if not (M > 0 and R > 0 and T > 0 and P > 0):
        return 0.0
    aR = 215.032 * (M * (P / 365.25) ** 2) ** (1.0 / 3.0) / R
    planck = lambda t: 1.0 / math.expm1(1.4388e-2 / (8.0e-7 * t))
    return depth_ppm * (1.0 / aR ** 2 + planck(T * math.sqrt(1.0 / aR) * (2.0 / 3.0) ** 0.25) / planck(T))


def planets_odd_even_z(t, f, P, t0, dur):
    """How far apart a dip's odd and even transits lie against the scatter of the transits themselves, the flux F at the times T already flattened: each transit's depth the mean within a quarter of the duration DUR of its centre against the mean between 0.75 and 2 durations of it, the two sets' means set against their pooled scatter, as a normal deviate through Student's t, so that a few transits count for little and neither red noise nor changes from transit to transit pass for a difference; None where the transits give no scatter."""
    from scipy import stats
    dt = ((t - t0) / P + 0.5) % 1.0 * P - 0.5 * P
    ep = np.round((t - t0) / P).astype(int)
    depths, epochs = [], []
    for k in np.unique(ep[np.abs(dt) < 2.0 * dur]):
        m = ep == k
        inn, ring = m & (np.abs(dt) < 0.25 * dur), m & (np.abs(dt) > 0.75 * dur) & (np.abs(dt) < 2.0 * dur)
        if inn.sum() >= 2 and ring.sum() >= 4:
            depths.append(float(np.mean(f[ring]) - np.mean(f[inn])))
            epochs.append(int(k))
    depths, epochs = np.array(depths), np.array(epochs)
    odd, even = depths[epochs % 2 == 1], depths[epochs % 2 == 0]
    dof = len(odd) + len(even) - 2
    if not len(odd) or not len(even) or dof < 1:
        return None
    pooled = (float(np.sum((odd - odd.mean()) ** 2)) + float(np.sum((even - even.mean()) ** 2))) / dof
    se = math.sqrt(pooled * (1.0 / len(odd) + 1.0 / len(even)))
    if se <= 0:
        return None
    return round(float(stats.norm.isf(stats.t.sf(abs(float(odd.mean() - even.mean())) / se, dof))), 2)


def planets_odd_even(v):
    """Whether a validation record V's odd and even transits differ: 3 sigma against the light curve's noise and, once read (planets_odd_even_z), 3 sigma against the transits' own scatter, or depths half their mean apart at 5 sigma against that noise, as a binary's seen in few transits are."""
    sigma = v.get("odd_even_sigma") or 0.0
    if sigma < 3.0:
        return False
    if "odd_even_z" not in v:
        return True
    a, b = v.get("depth_odd_ppm"), v.get("depth_even_ppm")
    apart = a is not None and b is not None and (a + b <= 0.0 or abs(a - b) >= 0.25 * (a + b))
    return (v["odd_even_z"] or 0.0) >= 3.0 or (apart and sigma >= 5.0)


# how strongly a candidate's own flattened fold must show its dip to stand, a TOI's as a TOI's selection asks and any other's further, since TRICERATOPS weighs a dip without asking whether it is there and the weakest candidates of a blind search are the least reliable (Thompson et al. 2018)
planets_DIP_TOI, planets_MISSION_DIP = 7.1, 10.0
# and Kepler's, whose false positives and false alarms near the spacecraft's year reach further, as its settled candidates show
planets_DIP_KEPLER = 15.0


def planets_fold_fault(v, label):
    """What a validation record V, of the candidate LABEL, holds against its dip being there: a TOI's flattened fold under planets_DIP_TOI, once read, or any other candidate's under planets_MISSION_DIP, a Kepler candidate's under planets_DIP_KEPLER, or a community TOI's signal-to-noise under planets_TRANSIT_NEW times the highest of the same search upside down (planets_noise_ratio), as a signal of orbitlight's own search must, until they are read; the unflattened fold's box stands in where the flattened has not been read."""
    d = v.get("dip_sigma")
    if d is None and v.get("shape_box_chi2") is not None:
        d = math.sqrt(max(v["shape_box_chi2"], 0.0))
    if label.startswith("TOI-"):
        return "no dip in its fold" if d is not None and d < planets_DIP_TOI else ""
    if (v.get("dip_sigma") or 0.0) < (planets_DIP_KEPLER if label.startswith("KOI-") else planets_MISSION_DIP):
        return "no dip in its fold"
    return "near the noise" if label.startswith("CTOI-") and (v.get("noise_ratio") or 0.0) < planets_TRANSIT_NEW else ""


# the limits of a validation (Giacalone et al. 2021), and those within which a candidate that passes every other test is a likely planet, listed apart
planets_FPP_VALID, planets_NFPP_VALID, planets_FPP_LIKELY, planets_NFPP_LIKELY = 0.015, 0.001, 0.1, 0.003


# the scenarios in which a dip is a planet's, on the target or on an unresolved star with it: a fainter companion's planet is no false positive, only larger than the target's light gives it (Morton et al. 2016)
planets_PLANET_SCENARIOS = ("TP", "PTP", "DTP", "STP", "BTP")


def planets_not_planet(v):
    """The probability that a validation record V's dip is no planet's: its false-positive probability, which counts a planet on the target alone, less the shares of a planet on an unresolved companion (STP) and on an unresolved star behind the target (BTP)."""
    scen = v.get("scenarios") or {}
    return max(v["fpp"] - scen.get("STP", 0.0) - scen.get("BTP", 0.0), 0.0)


def planets_planet_cols(v):
    """A validation record V's columns of its planet: the probability that its dip is no planet's, and the share of the planet's probability that lies on the target, its radius larger than given on the rest."""
    if "fpp" not in v or not v.get("scenarios"):
        return {}
    scen = v["scenarios"]
    planet = sum(scen.get(k, 0.0) for k in planets_PLANET_SCENARIOS)
    return dict(not_planet=round(planets_not_planet(v), 6), on_target=round(sum(scen.get(k, 0.0) for k in ("TP", "PTP", "DTP")) / planet, 4) if planet > 0 else "")


# how many times rarer a false positive is on a star that holds another live candidate or planet (planets_multi_measure), a false-positive probability under that many times its limit passing there, and the radius (Earth's) from which a giant, on which the settled TOIs bear out little of it, takes none
planets_MULTI_BOOST, planets_MULTI_RADIUS = 10.0, 8.0
planets_SIBLINGS = {}


def planets_has_sibling(tic, P, ra=float("nan"), dec=float("nan")):
    """Whether a star holds another live candidate or planet than one of period P: a TOI or community TOI ExoFOP gives for its TIC number TIC, the TFOPWG not having found it false, or a planet the archive lists for the star, at a period that is not P, its half, its double, its third or three times it within 2 per cent."""
    if not planets_SIBLINGS:
        for x in planets_exofop():
            if x.get("TFOPWG Disposition", "").strip() not in ("FP", "FA") and planets_num(x.get("Period (days)")) > 0:
                planets_SIBLINGS.setdefault(str(x["TIC ID"]).strip(), []).append(planets_num(x["Period (days)"]))
    match = planets_catalogued()
    periods = planets_SIBLINGS.get(str(tic).strip(), []) + [match.period[n] for n in match(ra, dec, tic, (), None, 10.0) if match.period[n] > 0]
    return any(all(abs(P / (q * m) - 1.0) >= 0.02 for m in (1.0, 0.5, 2.0, 1.0 / 3.0, 3.0)) for q in periods)


def planets_multi_measure():
    """What another live candidate or planet on a star is worth among the TOIs the TFOPWG has settled, to RESULTS/multi_boost.json: those of a signal-to-noise of 7.1 or more with one (planets_has_sibling) and without, below planets_MULTI_RADIUS and from it, how many of each it found false, and the ratio of the two odds of being false, half a count added to each, the boost planets_MULTI_BOOST stands within. Returns it."""
    out = {}
    rows = [r for r in planets_candidates("toi") if r["TFOPWG Disposition"].strip() in ("CP", "KP", "FP", "FA") and planets_num(r["Planet SNR"]) >= 7.1 and planets_num(r["Period (days)"]) > 0]
    for label, sel in (("below", lambda r: planets_num(r["Planet Radius (R_Earth)"]) < planets_MULTI_RADIUS), ("from", lambda r: planets_num(r["Planet Radius (R_Earth)"]) >= planets_MULTI_RADIUS)):
        tally = dict(sibling=[0, 0], alone=[0, 0])
        for r in rows:
            if sel(r):
                t = tally["sibling" if planets_has_sibling(r["TIC ID"], planets_num(r["Period (days)"]), *planets_radec(r)) else "alone"]
                t[0] += 1
                t[1] += r["TFOPWG Disposition"].strip() in ("FP", "FA")
        odds = lambda t: (t[1] + 0.5) / (t[0] - t[1] + 0.5)
        out[label] = dict(with_sibling=tally["sibling"][0], false_with_sibling=tally["sibling"][1], alone=tally["alone"][0], false_alone=tally["alone"][1], boost=round(odds(tally["alone"]) / odds(tally["sibling"]), 1))
    archive_save(os.path.join(planets_RESULTS, "multi_boost.json"), json.dumps(dict(out, radius=planets_MULTI_RADIUS, used=planets_MULTI_BOOST), separators=(",", ":")).encode())
    return out


# a difference image's reading of a dip's source: the chi-square its place must take out of the images, the error (arcsec) a sector's place holds beside its noise from its file's WCS and a Gaussian's fit of the true shape of a star, and the least a neighbour's share is multiplied by, the chance an image misplaces a source (planets_clear_measure)
planets_IMAGE_CHI2, planets_IMAGE_FLOOR, planets_IMAGE_TAIL = 25.0, 2.0, 1e-3
# and how far past the star's chi-square, over the factor that gives the place its error, the image's best place may lie before it clears no neighbour: 4 sigma
planets_IMAGE_OFF = 16.0


def planets_image_sector(raw, P, t0, D, nulls=12):
    """One sector's target pixel file, the open file RAW, as a difference image of the transits of period P days from T0 (BTJD) lasting D days: for each transit the mean image between 0.8 and 2.5 durations on either side, each side weighing alike so that a pixel's slow drift goes, less the mean within 0.4 of a duration, the transits averaged by their points. Each pixel's error is the scatter of the same image at the same windows moved to NULLS other times of the sector, clear of every transit by 2.5 durations, which holds its correlated noise; with fewer than six such times, the scatter of its frames over the root of the points. Returns the image, the errors, the star's width (pixels) from a round Gaussian fitted within 3.5 pixels of it in the mean image, the file's WCS, the star's place at the sector's date, its J2000 place carried by its proper motion, what that motion has carried it (arcsec, east and north), and the transits held; None where the file holds no transit with light on either side."""
    from astropy.io import fits
    from astropy.wcs import WCS
    from scipy.optimize import least_squares
    with fits.open(raw) as h:
        d, ap, H0 = h[1].data, h[2].header, h[0].header
        t, cube, q = np.asarray(d["TIME"], float), np.asarray(d["FLUX"], float), np.asarray(d["QUALITY"])
        w = WCS(ap)
        ra, dec, pmra, pmdec = float(H0["RA_OBJ"]), float(H0["DEC_OBJ"]), archive_num(H0.get("PMRA"), 0.0), archive_num(H0.get("PMDEC"), 0.0)
    keep = np.isfinite(t) & (q == 0) & (np.isfinite(cube).sum((1, 2)) > 0)
    t, cube = t[keep], cube[keep]
    if len(t) < 50:
        return None
    good = np.isfinite(cube)
    S = np.concatenate([np.zeros((1,) + cube.shape[1:]), np.cumsum(np.where(good, cube, 0.0), axis=0)])
    N = np.concatenate([np.zeros((1,) + cube.shape[1:]), np.cumsum(good, axis=0)])

    def mean(a, b):
        i, j = int(np.searchsorted(t, a)), int(np.searchsorted(t, b))
        if j <= i:
            return None, 0
        with np.errstate(divide="ignore", invalid="ignore"):
            return (S[j] - S[i]) / (N[j] - N[i]), j - i

    def image(mids):
        total, weight, count = None, 0.0, 0
        for c in mids:
            inn, n_in = mean(c - 0.4 * D, c + 0.4 * D)
            before, n_b = mean(c - 2.5 * D, c - 0.8 * D)
            after, n_a = mean(c + 0.8 * D, c + 2.5 * D)
            if n_in < 1 or n_b < 1 or n_a < 1:
                continue
            x = 0.5 * (before + after) - inn
            total = n_in * x if total is None else total + n_in * x
            weight, count = weight + n_in, count + 1
        return (total / weight, weight, count) if count else (None, 0.0, 0)
    mids = t0 + P * np.arange(math.ceil((t.min() - D - t0) / P), math.floor((t.max() + D - t0) / P) + 1)
    if not len(mids):
        return None
    img, weight, count = image(mids)
    if img is None:
        return None
    span = float(t.max() - t.min())
    null = []
    for shift in np.linspace(-0.5 * span, 0.5 * span, 4 * nulls):
        c = mids + shift
        if np.min(np.abs(c[:, None] - mids[None, :])) > 2.5 * D:
            got, _, n_ = image(c)
            if got is not None and n_ >= max(1, count // 2):
                null.append(got)
    err = np.nanstd(np.array(null), axis=0) if len(null) >= 6 else np.nanstd(cube, axis=0) * math.sqrt(1.5 / max(weight, 1.0))
    err = np.where(np.isfinite(err) & (err > 0), err, np.nanmedian(err))
    years = (float(np.median(t)) + 2457000.0 - 2451545.0) / 365.25
    east, north = pmra * years / 1000.0, pmdec * years / 1000.0
    ra_now, dec_now = ra + east / 3600.0 / math.cos(math.radians(dec)), dec + north / 3600.0
    sx, sy = (float(x) for x in w.all_world2pix([[ra_now, dec_now]], 0)[0])
    frame = np.nanmean(cube, 0)
    y, x = np.mgrid[0:frame.shape[0], 0:frame.shape[1]]
    near = np.isfinite(frame) & (np.hypot(x - sx, y - sy) <= 3.5)
    width = 0.85
    if near.sum() >= 8:
        med = float(np.nanmedian(frame[near]))
        noise = np.sqrt(np.maximum(np.abs(frame), 1.0))

        def resid(p):
            return ((p[0] * np.exp(-0.5 * ((x - p[1]) ** 2 + (y - p[2]) ** 2) / p[3] ** 2) + p[4] - frame) / noise)[near]
        try:
            width = float(least_squares(resid, [float(np.nanmax(frame[near])) - med, sx, sy, 0.85, med], bounds=([0.0, -1.0, -1.0, 0.5, -np.inf], [np.inf, frame.shape[1], frame.shape[0], 1.6, np.inf]), max_nfev=50).x[3])
        except ValueError:
            pass
    return dict(img=img, err=err, width=width, w=w, ra=ra_now, dec=dec_now, moved=(east, north), transits=count)


def planets_image_surface(images, east, north):
    """The chi-square a Gaussian takes out of each of IMAGES (planets_image_sector), of the sector's width, with an amplitude and a flat background free in each, at the places EAST and NORTH (arcsec from each image's star, arrays of one length): (sectors, places), a place of negative amplitude taking out nothing."""
    out = np.zeros((len(images), len(east)))
    for k, m in enumerate(images):
        px = m["w"].all_world2pix(np.column_stack([m["ra"] + east / (3600.0 * math.cos(math.radians(m["dec"]))), m["dec"] + north / 3600.0]), 0)
        ok = np.isfinite(m["img"])
        y, x = np.mgrid[0:m["img"].shape[0], 0:m["img"].shape[1]]
        wt, data = 1.0 / m["err"][ok] ** 2, m["img"][ok]
        G = np.exp(-0.5 * ((x[ok][None, :] - px[:, 0, None]) ** 2 + (y[ok][None, :] - px[:, 1, None]) ** 2) / m["width"] ** 2)
        W = wt.sum()
        Gm = (G * wt).sum(1) / W
        top = (G * (wt * (data - float((wt * data).sum()) / W))).sum(1)
        bottom = (G * G * wt).sum(1) - W * Gm * Gm
        out[k] = np.where((top > 0) & (bottom > 0), top * top / np.maximum(bottom, 1e-30), 0.0)
    return out


def planets_image_read(tic, P, t0, D, most=8):
    """A transit's difference images (planets_image_sector) from MAST's bucket, SPOC's target pixel files where any covers a transit, else TESS-SPOC's, MOST sectors at most, spread evenly, each marked with its kind."""
    tics, secs, kinds, sectors = planets_tess_index()
    a, b = int(np.searchsorted(tics, tic)), int(np.searchsorted(tics, tic, side="right"))
    t0m, images = t0 + 56999.5, []
    for kind in (0, 1):
        held = sorted(s for s, k in zip(secs[a:b].tolist(), kinds[a:b].tolist()) if k == kind and "t0" in sectors.get(s, {}) and math.ceil((sectors[s]["t0"] - t0m) / P) * P + t0m <= sectors[s]["t1"])
        held = [held[int(j)] for j in np.unique(np.linspace(0, len(held) - 1, most).round())] if len(held) > most else held
        for s in held:
            raw = archive_get(planets_TESS_BUCKET + planets_tess_key(tic, s, kind, sectors).replace("_lc.fits", "_tp.fits"), timeout=300, soft=True)
            if raw:
                got = planets_image_sector(io.BytesIO(raw), P, t0, D)
                if got:
                    images.append(dict(got, kind=kind))
        if images:
            break
    return images


def planets_image_fit(images):
    """One place on the sky fitted to all a transit's difference images at once (planets_image_surface), on a grid of 3 arcsec about the star and then of half an arcsec about the best. Returns its offset from the star (arcsec, east and north, offset), its error from that surface's curvature, scaled by the fit's reduced chi-square and joined to planets_IMAGE_FLOOR over the root of the sectors, the chi-square it takes out (chi2), the chi-square the star's own place takes out (star_chi2), by how much a chi-square's differences are to be divided to give that error (factor), what its proper motion has carried the star since J2000 (moved), and the sectors and transits held."""
    grid = np.arange(-105.0, 105.1, 3.0)
    ee, nn = np.meshgrid(grid, grid)
    f = planets_image_surface(images, ee.ravel(), nn.ravel()).sum(0)
    i = int(np.argmax(f))
    fine = np.arange(-4.0, 4.1, 0.5)
    fe, fn = np.meshgrid(float(ee.ravel()[i]) + fine, float(nn.ravel()[i]) + fine)
    g = planets_image_surface(images, fe.ravel(), fn.ravel()).sum(0)
    j = int(np.argmax(g))
    east, north, top = float(fe.ravel()[j]), float(fn.ravel()[j]), float(g[j])
    chi, dof = 0.0, 0
    for m in images:
        px = m["w"].all_world2pix([[m["ra"] + east / (3600.0 * math.cos(math.radians(m["dec"]))), m["dec"] + north / 3600.0]], 0)[0]
        ok = np.isfinite(m["img"])
        y, x = np.mgrid[0:m["img"].shape[0], 0:m["img"].shape[1]]
        A = np.column_stack([np.exp(-0.5 * ((x[ok] - px[0]) ** 2 + (y[ok] - px[1]) ** 2) / m["width"] ** 2), np.ones(int(ok.sum()))]) / m["err"][ok][:, None]
        chi += float(np.sum((m["img"][ok] / m["err"][ok] - A @ np.linalg.lstsq(A, m["img"][ok] / m["err"][ok], rcond=None)[0]) ** 2))
        dof += int(ok.sum()) - 2
    scale = max(chi / max(dof, 1), 1.0)
    h = 2.0
    around = planets_image_surface(images, np.array([east - h, east + h, east, east]), np.array([north, north, north - h, north + h])).sum(0)
    # the surface falls by (x / sigma)^2 from its top, its second difference 2 / sigma^2
    var = 0.5 * (2.0 * h ** 2 / max(2.0 * top - around[0] - around[1], 1e-9) + 2.0 * h ** 2 / max(2.0 * top - around[2] - around[3], 1e-9))
    err2 = scale * var + planets_IMAGE_FLOOR ** 2 / len(images)
    return dict(east=round(east, 2), north=round(north, 2), offset=round(math.hypot(east, north), 2), err=round(math.sqrt(err2), 2), chi2=round(top, 1), star_chi2=round(float(planets_image_surface(images, np.array([0.0]), np.array([0.0])).sum()), 1), factor=round(err2 / var, 3), scale=round(scale, 2),
                moved=[round(float(np.mean([m["moved"][k] for m in images])), 2) for k in (0, 1)], sectors=len(images), transits=sum(m["transits"] for m in images), light_curves="SPOC" if images[0]["kind"] == 0 else "TESS-SPOC")


def planets_image_at(images, place, near):
    """The chi-square a Gaussian at each nearby star's own place takes out of a transit's difference images (planets_image_surface), NEAR its stars with their separations and position angles (planets_validate_one's near_probs) in the TIC's J2000 and PLACE its fit (planets_image_fit), the star carried by its motion: star to chi-square."""
    if not near:
        return {}
    ids = sorted(near)
    east = np.array([near[i][0] * math.sin(math.radians(near[i][1])) - place["moved"][0] for i in ids])
    north = np.array([near[i][0] * math.cos(math.radians(near[i][1])) - place["moved"][1] for i in ids])
    return dict(zip(ids, (round(float(x), 1) for x in planets_image_surface(images, east, north).sum(0))))


def planets_source_cleared(v):
    """The probability that a validation record V's dip is no planet's (planets_not_planet) and its nearby-false-positive probability with its difference images read into them: each nearby star's share of the probability (near_probs) multiplied by the likelihood of the images at that star against at the star itself, half the difference of the chi-squares a Gaussian at each takes out over the factor that gives the place its error (planets_image_fit, planets_image_at), held within planets_IMAGE_TAIL and its inverse, the chance an image misplaces a source, where it holds an image whose place takes out planets_IMAGE_CHI2 and those shares, an image whose place lies planets_IMAGE_OFF off the star lowering none of them; and without a star eclipsing the target (planets_TARGET_BINARIES) where Gaia's velocities leave it no room (planets_no_room)."""
    s, near, scen = v.get("source") or {}, v.get("near_probs"), v.get("scenarios")
    if not scen:
        return v["fpp"], v["nfpp"]
    weighed = v["nfpp"]
    if near is not None and s.get("chi2", 0.0) >= planets_IMAGE_CHI2 and "at" in s:
        least = 1.0 if (s["chi2"] - s["star_chi2"]) / s["factor"] > planets_IMAGE_OFF else planets_IMAGE_TAIL
        weighed = sum(p * min(max(math.exp(max(min(0.5 * (s["at"].get(i, 0.0) - s["star_chi2"]) / s["factor"], 500.0), -500.0)), least), 1.0 / planets_IMAGE_TAIL) for i, (_, _, p) in near.items())
    total = sum(x for k, x in scen.items() if k not in ("NTP", "NEB", "NEBx2P") and not (k in planets_TARGET_BINARIES and planets_no_room(v))) + weighed
    return (1.0 - sum(scen.get(k, 0.0) for k in planets_PLANET_SCENARIOS) / total, weighed / total) if total > 0 else (planets_not_planet(v), v["nfpp"])


def planets_validation_decision(v, x, rv, events):
    """A validation record's decision from its own evidence, before any catalogue: (status, reason, vetting columns), the status None for a pass
    still waiting for its runs, and likely for a candidate that passes every test at the likely limits and not at a validation's."""
    P = v.get("period", planets_num(x.get("Period (days)")))
    radius = planets_num(x.get("Planet Radius (R_Earth)"))
    if "fpp" not in v:
        note = v.get("note", "")
        return "rejected", "no light curve" if "light curve" in note else "inside the star" if "inside the star" in note else \
            "duration" if note.startswith("duration") else "no stellar parameters" if "stellar" in note else "analysis failed", {}
    if rv and (rv["object"] in ("star", "brown dwarf") and rv["status"] != "rejected" or rv["reason"] == "phase"):
        return "rejected", "velocities", {}
    if math.isfinite(radius) and radius >= 22.4:
        return "rejected", "radius", {}
    # the probabilities as its difference image leaves them
    fpp, nfpp = planets_source_cleared(v)
    valid = fpp < planets_FPP_VALID and nfpp < planets_NFPP_VALID
    # on a star with another live candidate or planet the limit is planets_MULTI_BOOST times higher, on the means of ten runs
    boosted = not valid and fpp < planets_MULTI_BOOST * planets_FPP_VALID and nfpp < planets_NFPP_VALID and v.get("runs", 0) >= 10 and radius < planets_MULTI_RADIUS and planets_has_sibling(v.get("tic") or x.get("TIC ID"), P, *planets_radec(x))
    valid = valid or boosted
    if not valid and not (fpp < planets_FPP_LIKELY and nfpp < planets_NFPP_LIKELY):
        return "rejected", "not validated", {}
    # a pass stands on the means of ten runs, the light curves' checks and SPOC's data validation of its event
    if valid and v.get("runs", 0) < 10:
        return None, "", {}
    # a dip half an orbit on is an eclipse where it lies 3 sigma or more beyond the deepest occultation a planet could give
    sec, sig = v.get("depth_secondary_ppm"), v.get("secondary_sigma")
    most = planets_occultation_max(x, v.get("depth_ppm", 0.0), P)
    excess = (sec - most) / (sec / sig) if sec and sig and sig > 0 else 0.0
    checks = planets_check_cols(v, P, x)
    # a transit its star leaves no room for, as 1 of 1,373 confirmed planets' and 83 of 1,111 false positives' on ExoFOP's stars and durations are
    phys = planets_transit_physical(dict(P=P, depth_ppm=planets_num(x.get("Depth (ppm)")), duration_h=planets_num(x.get("Duration (hours)"))), x.get("Stellar Radius (R_Sun)"), x.get("Stellar Mass (M_Sun)"))
    own = "not vetted" if "odd_even_sigma" not in v else "odd-even depths" if planets_odd_even(v) else "secondary eclipse" if excess >= 3.0 else \
        "variability" if planets_transit_smooth(v) else "a neighbour's variability" if v.get("variable_neighbours") else \
        "astrometric binary" if (checks.get("ruwe") or 0.0) >= planets_RUWE_MAX else "a double star in Gaia" if (v.get("gaia_nss") or 0.0) > 0.0 or planets_rv_moving(v) else "source off the star" if planets_centroid_off(v) else \
        "the star's rotation" if (checks.get("gaia_vbroad") or 0.0) >= planets_SPIN_FAST and planets_SPIN_LOW <= (checks.get("spin_ratio") or 0.0) <= planets_SPIN_HIGH else \
        "inside the star" if phys.startswith("orbit") else "duration" if phys else ""
    near = [e for e in events.get(str(v["tic"]), []) if abs(e["tce_period"] / P - 1.0) < 0.01]
    cols, why = planets_dv(max(near, key=lambda e: e["tce_num_transits"] if math.isfinite(e["tce_num_transits"]) else -1.0)) if near else ({}, "")
    cols.update(odd_even_sigma=v.get("odd_even_sigma", ""), secondary_sigma=v.get("secondary_sigma", ""), occultation_max_ppm=round(most, 1),
                secondary_excess_sigma=round(excess, 2), multiplicity_boost=planets_MULTI_BOOST if boosted else "", **checks)
    if (v.get("source") or {}).get("offset") is not None:
        cols.update(source_offset=v["source"]["offset"], source_err=v["source"]["err"], fpp_image=round(fpp, 6), nfpp_image=round(nfpp, 6))
    return ("rejected" if own or why else "new" if valid else "likely"), own or why, cols


def planets_validated_rows(tois):
    """The TESS candidates validated statistically (RESULTS/validate/, planets_validate) as decided signals.csv rows. A candidate is new where the
    probability that its dip is no planet's (planets_not_planet) lies below 0.015 and its nearby-false-positive probability below 0.001 (the limits of Giacalone et al. 2021), each the mean of ten
    runs, as its difference image leaves them (planets_source_cleared), ExoFOP's radius is below two Jupiter radii, the light curves it was weighed from show its odd and even transits' depths within 3 sigma of
    each other, no dip of 3 sigma half an orbit on, a transit's box rather than the star's own variation at the period (planets_transit_smooth), Gaia's RUWE
    below planets_RUWE_MAX, a dip's source not placed off the star (planets_centroid_off), no star spinning at planets_SPIN_FAST or more with the period at its spin's limit (planets_check_cols),
    an orbit and a transit's length its star allows (planets_transit_physical), and SPOC's data validation of its threshold-crossing event, its TIC star's event within 1 per
    cent of its period with the most transits, finds nothing against it where SPOC raised one (planets_dv), unless velocities weighed at its transits
    (TOIS, planets_toi_rows) put a star or brown dwarf there or a phase other than the transit's, and not decided again where those velocities already
    made it new; a pass from fewer runs waits for the rest, a pass weighed without those checks is not vetted, and the rest are rejected with why. A
    candidate the archive lists in any published solution (planets_catalogued) or the TFOPWG now gives as a known or confirmed planet is known, an
    independent validation where it passes; one the TFOPWG now gives as a false positive or false alarm, or whose period ExoFOP has moved by more than 1
    per cent from the one it was weighed at, is rejected. ExoFOP's tables are read again once a day old."""
    folder = os.path.join(planets_RESULTS, "validate")
    exo = {x["label"]: x for x in planets_exofop(1.0)}
    listed_in = planets_catalogued()
    weighed = {r["label"]: r for r in tois}
    recs = [json.load(open(path)) for path in sorted(glob.glob(os.path.join(folder, "*.json")))]
    events = planets_tce({v["tic"] for v in recs if "fpp" in v and planets_source_cleared(v)[0] < planets_FPP_LIKELY and planets_source_cleared(v)[1] < planets_NFPP_LIKELY})
    out = []
    # Kepler's and K2's candidates enter once the benchmark of their settled ones bears them out (planets_mission_scored)
    scored = {m for m, source in (("Kepler", "koi"), ("K2", "k2")) if planets_mission_scored(source)}
    for v in recs:
        label = v.get("label") or "TOI-" + v["toi"]
        x, rv = exo.get(label, {}), weighed.get(label)
        if rv and rv["status"] == "new" or x.get("mission") and x["mission"] not in scored:
            continue
        fpp, nfpp = (max(v[k], 0.0) if k in v else "" for k in ("fpp", "nfpp"))
        row = dict(name="TIC %s" % v["tic"], kind="validated", label=label, nights="", span_d="", P=v.get("period", planets_num(x.get("Period (days)"))), K="", e="", msini_mjup="",
                   msini_mearth="", fap="%.1e" % fpp if "fpp" in v else "", object="planet", catalogued="", fpp=fpp, nfpp=nfpp,
                   radius_rearth=x.get("Planet Radius (R_Earth)", ""))
        status, reason, cols = planets_validation_decision(v, x, rv, events)
        if status is None:
            continue
        # a likely planet stands on the checks planets_validate_checks reads
        if status == "likely" and "checks_read" not in v:
            status, reason = "rejected", "not validated"
        if status in ("new", "likely") and planets_fold_fault(v, label):
            status, reason = "rejected", planets_fold_fault(v, label)
        row.update(cols, status=status, reason=reason, **planets_planet_cols(v))
        disp = x.get("TFOPWG Disposition", "")
        ra, dec = planets_radec(x) if x else (float("nan"), float("nan"))
        cat = listed_in(ra, dec, v["tic"], (), planets_num(row["P"]))
        if cat or disp in ("KP", "CP"):
            row.update(contribution="independent validation" if row["status"] == "new" else "", status="known", reason="catalogued",
                       catalogued="; ".join(["archive %s" % n for n in cat] + (["TFOPWG %s" % disp] if disp in ("KP", "CP") else [])))
        elif disp in ("FP", "FA"):
            row.update(status="rejected", reason="TFOPWG %s" % disp)
        elif "fpp" in v and abs(planets_num(x.get("Period (days)")) / planets_num(row["P"]) - 1.0) > 0.01:
            row.update(status="rejected", reason="ephemeris revised")
        elif row["status"] == "new":
            row["contribution"] = "statistical validation"
        out.append(row)
    return out


def planets_list(rows, stars):
    """The new planets and companions of ROWS for RESULTS/planets.csv, named after their hosts and lettered after the archive's planets of the same
    star, and after them the likely planets for RESULTS/likely_planets.csv, lettered after those, each with its status."""
    new = [r for r in rows if r["status"] in ("new", "likely")]
    simbad = {r["name"]: (stars.get(r["name"], {}).get("SimbadName") or r["name"]).strip() for r in new}
    main = archive_simbad_basic(sorted(set(simbad.values()) | {r["name"] for r in new}), ("main_id",))

    def host_of(name):
        found = (main.get(simbad[name]) or main.get(name) or {}).get("main_id")
        if not found and name in stars:
            found = archive_simbad_near(planets_num(stars[name].get("RAJ2000")), planets_num(stars[name].get("DEJ2000")))
        return " ".join((found or name).split())
    taken = {}
    for r in rows:
        if r["kind"] == "known" and r["label"][-1:].isalpha() and r["label"][-2:-1] == " ":
            taken[r["name"]] = max(taken.get(r["name"], "a"), r["label"][-1].lower())
    # a validated community TOI is named after a TOI validated on its star, else after its star
    stems = {r["name"]: r["label"].split(".")[0] for r in rows if r["kind"] == "validated" and r["label"].startswith("TOI-")}
    exo = {x["label"]: x for x in planets_exofop()}
    kept = planets_path("stellar.json")
    stellar = json.load(open(kept)) if os.path.exists(kept) else {}

    def star_of(r):
        # the star's temperature, radius and mass with the planet's radius: ExoFOP's for a TESS candidate, else Gaia DR3's FLAME for the bank's star,
        # kept in ROOT/stellar.json
        x = exo.get(r["label"])
        if r["kind"] in ("validated", "toi") and x:
            return [archive_num(x.get(k)) for k in ("Stellar Eff Temp (K)", "Stellar Radius (R_Sun)", "Stellar Mass (M_Sun)", "Planet Radius (R_Earth)")]
        s = stars.get(r["name"])
        if s and archive_num(s.get("Mass")):
            stellar[r["name"]] = [archive_num(s.get("Teff")), archive_num(s.get("Rad")), archive_num(s.get("Mass"))]
        elif s and r["name"] not in stellar:
            try:
                g = archive_gaia_star(float(s["RAJ2000"]), float(s["DEJ2000"]), archive_num(s.get("Vmag"))) or {}
            except Exception:
                g = {}
            stellar[r["name"]] = [archive_num(g.get("teff_gspphot")), archive_num(g.get("radius_flame")),
                                  archive_num(g.get("mass_flame")) or planets_mass(s.get("SpType"))]
        # a transit the blind search found gives its radius from its depth, and one of the TESS stage its star from its light curve's header
        if r["kind"] == "transit" and r.get("star"):
            return [archive_num(x) for x in r["star"]] + [archive_num(r.get("radius_rearth"))]
        return stellar.get(r["name"], [None] * 3) + [archive_num(r.get("radius_rearth")) if r["kind"] == "transit" else None]

    def mags_of(r):
        # a TESS candidate's star's J and K magnitudes from the TIC (planets_tic_cone), kept in ROOT/stellar.json
        x = exo.get(r["label"])
        if r["kind"] not in ("validated", "toi") or not x:
            return None, None
        key = "mags TIC %d" % int(x["TIC ID"])
        if key not in stellar:
            try:
                row = next(s for s in planets_tic_cone(int(x["TIC ID"])) if str(s["ID"]) == str(int(x["TIC ID"])))
            except Exception:
                return None, None
            stellar[key] = [archive_num(row["Jmag"]), archive_num(row["Kmag"])]
        return tuple(stellar[key])
    match, discoverer, eu = planets_catalogued(), planets_discoverers(), planets_encyclopaedia()
    hosts = dict(eu.host, **match.host)

    def archived(r):
        # the archive's planets of the star and those the Encyclopaedia holds of it beside them, for a TESS candidate its confirmed ones, its candidates including the TOIs themselves
        where = planets_place(r, stars, exo)
        listed = match(*where, None, 10.0)
        said = ("confirmed",) if r["kind"] in ("validated", "toi") else ("confirmed", "candidate", "controversial", "unconfirmed")
        same = lambda n, m: match.period[m] > 0 and abs(eu.period[n] / match.period[m] - 1.0) < 0.05
        return listed + [n for n in eu(*where, None, 10.0) if eu.status[n] in said and n not in listed and not any(same(n, m) for m in listed)]
    out = []
    for r in sorted(new, key=lambda x: (x["status"] != "new", x["name"], float(x["P"]))):
        host = host_of(r["name"])
        listed = archived(r) if r["object"] != "star" else []
        if r["object"] == "star":
            letter = "B"
        else:
            letter = chr(ord(max([taken.get(r["name"], "a"), chr(ord("a") + len(listed))] +
                                 [n.split()[-1] for n in listed if re.fullmatch(r"[a-z]", n.split()[-1])])) + 1)
            taken[r["name"]] = letter
        stem = r["label"].split(".")[0] if r["kind"] == "toi" else stems.get(r["name"], r["name"]) if r["kind"] == "validated" else host
        stem = hosts[listed[0]] if listed else stem
        pick = lambda col, fallback: r.get(col) if r.get(col) not in (None, "") else fallback
        teff, rs, ms, rp = star_of(r)
        P = planets_num(pick("orbit_P", r["P"]))
        sunlight, teq, zone = planets_sunlight(P, teff, rs, ms)
        # the mass: weighed with the astrometry, or from the velocities, a transiting candidate's at the inclination of its transit and the others' least
        msini = archive_num(pick("orbit_msini_mearth", r["msini_mearth"]))
        mass, basis = (archive_num(r.get("mass_mjup")) * 317.83, "measured") if archive_num(r.get("mass_mjup")) else \
            (msini, "measured" if r["kind"] in ("toi", "transit") else "minimum") if msini and r["kind"] != "validated" else (None, "")
        character = planets_character(r["object"], P, teff, rs, ms, rp, mass, basis, *mags_of(r), teq)
        out.append(dict(planet="%s %s" % (stem, letter), host=host, kind=r["object"], found_by={"found": "census", "eccentric": "eccentric search", "companion": "companions",
                                                                                                 "toi": "TESS", "validated": "validation",
                                                                                                 "transit": "transit search", "astrometry": "astrometry"}[r["kind"]],
                        status=r["status"], contribution=planets_CONTRIBUTION[r["kind"]] if r["status"] == "new" else "likely planet", discovered_by=discoverer(r), candidate=r["label"] if r["kind"] in ("validated", "toi") else "",
                        P_d=pick("orbit_P", r["P"]), P_lo=r.get("orbit_P_lo", ""), P_hi=r.get("orbit_P_hi", ""), K_ms=pick("orbit_K", r["K"]),
                        K_lo=r.get("orbit_K_lo", ""), K_hi=r.get("orbit_K_hi", ""), e=pick("orbit_e", r["e"]),
                        e_lo=r.get("orbit_e_lo", ""), e_hi=r.get("orbit_e_hi", ""), msini_mearth=pick("orbit_msini_mearth", r["msini_mearth"]),
                        msini_mearth_lo=r.get("orbit_msini_mearth_lo", ""), msini_mearth_hi=r.get("orbit_msini_mearth_hi", ""),
                        msini_mjup=round(msini / 317.83, 4) if msini else r["msini_mjup"],
                        mass_mjup=r.get("mass_mjup", ""), mass_mjup_lo=r.get("mass_mjup_lo", ""), mass_mjup_hi=r.get("mass_mjup_hi", ""), nights=r["nights"],
                        span_d=r["span_d"], prediction=r.get("prediction", ""), second_instrument=r.get("second_instrument", ""), second_nights=r.get("second_nights", ""),
                        second_scale=r.get("second_scale", ""), second_scale_err=r.get("second_scale_err", ""), second_phase_sigma=r.get("second_phase_sigma", ""), second_test=r.get("second_test", ""),
                        dr4_test=r.get("dr4_test", ""), dr4_ln_bayes=r.get("dr4_ln_bayes", ""), dr4_control=r.get("dr4_control", ""), dr4_snr_least=r.get("dr4_snr_least", ""), dr4_mass_mjup=r.get("dr4_mass_mjup", ""),
                        dr4_mass_lo=r.get("dr4_mass_lo", ""), dr4_mass_hi=r.get("dr4_mass_hi", ""), dr4_incl_deg=r.get("dr4_incl_deg", ""),
                        fpp=r.get("fpp", ""), nfpp=r.get("nfpp", ""), multiplicity_boost=r.get("multiplicity_boost", ""), not_planet=r.get("not_planet", ""), on_target=r.get("on_target", ""), source_offset=r.get("source_offset", ""), source_err=r.get("source_err", ""), fpp_image=r.get("fpp_image", ""), nfpp_image=r.get("nfpp_image", ""),
                        sunlight=round(sunlight, 3) if sunlight else "", teq_k=round(teq) if teq else "", habitable_zone=zone or "", **character,
                        bank_name=r["name"]))
    json.dump(stellar, open(kept, "w"), separators=(",", ":"))
    return out


# Kopparapu et al.'s (2014) habitable zone, its recent-Venus and early-Mars edges: each edge's sunlight (Earth's) as S + a T + b T^2 + c T^3 + d T^4,
# T the star's temperature less 5780 K, from 2600 to 7200 K
planets_HZ = ((1.776, 2.136e-4, 2.533e-8, -1.332e-11, -3.097e-15), (0.320, 5.547e-5, 1.526e-9, -2.874e-12, -5.011e-16))


def planets_sunlight(P, teff, radius, mass):
    """The sunlight (Earth's) of an orbit of P days about a star of TEFF K and RADIUS and MASS solar, its equilibrium temperature (K, no albedo and the heat
    spread over the planet) and its place against the habitable zone (planets_HZ, the star's temperature held within 2600 to 7200 K): inside, hotter or
    colder; Nones where a value is missing."""
    if not (P and P > 0 and teff and teff > 0 and radius and radius > 0 and mass and mass > 0):
        return None, None, None
    S = radius ** 2 * (teff / 5772.0) ** 4 / (mass * (P / 365.25) ** 2) ** (2.0 / 3.0)
    T = min(max(teff, 2600.0), 7200.0) - 5780.0
    hot, cold = (sum(c * T ** i for i, c in enumerate(edge)) for edge in planets_HZ)
    return S, 278.6 * S ** 0.25, "hotter" if S > hot else "colder" if S < cold else "inside"


# Chen and Kipping's (2017) mean mass-radius relation, R = C M^s in Earth's units, over the masses of each regime: rocky, Neptunian and Jovian
planets_MR = ((2.04, 1.0, 0.279), (132.0, 0.80811, 0.589), (26600.0, 17.74, -0.044))


def planets_radius_of(mass):
    """The radius (Earth's) Chen and Kipping's relation gives a mass (Earth's); None beyond the Jovian regime."""
    return next((c * mass ** s for hi, c, s in planets_MR if mass < hi), None)


def planets_mass_of(radius):
    """The mass (Earth's) Chen and Kipping's relation gives a radius (Earth's) in its rocky and Neptunian regimes; None above them, where a giant's radius
    no longer tells its mass."""
    for hi, c, s in planets_MR[:2]:
        mass = (radius / c) ** (1.0 / s)
        if mass < hi:
            return mass
    return None


def planets_character(body, P, teff, rs, ms, radius, mass, basis, jmag, kmag, teq):
    """A body's inferred character for planets.csv, from its period P (days), its star's temperature TEFF (K), radius RS and mass MS (solar), its radius
    from a transit and its MASS (Earth's) of BASIS measured or minimum, with the star's J and K magnitudes and the equilibrium temperature TEQ: the
    orbit's size; the radius from the mass or the mass from the radius where only one is known (planets_radius_of, planets_mass_of); the density, surface
    gravity and escape speed; a composition by radius (a brown dwarf or star by mass) and a character by equilibrium temperature and size; tidal locking
    expected where Gladman et al.'s (1996) time for it from a 12-hour spin lies within 1 Gyr (Q 100 and k2 0.3 below 1.6 Earth radii, Q 1e5 and k2 0.5
    above, a moment of inertia of 0.3 M R^2); the star's colour and its apparent diameter in the planet's sky; and for a transiting planet the
    transmission and emission spectroscopy metrics of Kempton et al. (2018)."""
    out = dict.fromkeys(("a_au", "mass_mearth", "mass_basis", "radius_rearth", "radius_basis", "density_gcc", "gravity_earth", "escape_kms", "composition", "character",
                         "tidally_locked", "star_color", "star_in_sky_deg", "tsm", "esm"), "")
    a = (ms * (P / 365.25) ** 2) ** (1.0 / 3.0) if ms and P else None
    if teff:
        out["star_color"] = "red" if teff < 3700 else "orange" if teff < 5200 else "yellow" if teff < 6000 else "yellow-white" if teff < 7500 else \
            "white" if teff < 10000 else "blue-white"
    if a:
        out["a_au"] = round(a, 4)
        if rs:
            out["star_in_sky_deg"] = round(2.0 * math.degrees(math.asin(min(1.0, rs * 0.0046505 / a))), 2)
    if body == "star":
        out["composition"] = "star"
        return out
    rbasis = "transit" if radius else ""
    if not radius and mass:
        radius, rbasis = planets_radius_of(mass), "predicted"
    if not mass and radius:
        mass, basis = planets_mass_of(radius), "predicted"
    out.update(radius_basis=rbasis, mass_basis=basis if mass else "", radius_rearth=round(radius, 2) if radius else "")
    if mass:
        out["mass_mearth"] = round(mass, 2)
    if body == "brown dwarf":
        out["composition"] = "brown dwarf"
    elif radius:
        out["composition"] = "rocky" if radius < 1.5 else "rocky or water-rich" if radius < 2.0 else \
            "sub-Neptune: a rocky core under hydrogen, or a water world" if radius < 4.0 else "Neptune-like" if radius < 6.0 else "sub-Saturn" if radius < 8.0 \
            else "gas giant"
    if radius and mass:
        out.update(density_gcc=round(5.514 * mass / radius ** 3, 2), gravity_earth=round(mass / radius ** 2, 2), escape_kms=round(11.186 * math.sqrt(mass / radius), 1))
    if radius and teq:
        size = "rocky planet" if radius < 1.5 else "super-Earth" if radius < 2.0 else "sub-Neptune" if radius < 4.0 else "Neptune" if radius < 6.0 else \
            "sub-Saturn" if radius < 8.0 else "Jupiter"
        heat = "temperate" if teq < 350 else "warm" if teq < 800 else "hot" if teq < 2000 else "ultra-hot"
        out["character"] = "lava world" if radius < 2.0 and teq >= 1200 else ("ultra-short-period " if P < 1.0 else "") + heat + " " + size
    if a and radius and mass and ms:
        Q, k2 = (100.0, 0.3) if radius < 1.6 else (1e5, 0.5)
        lock = (2.0 * math.pi / 43200.0) * (a * 1.496e11) ** 6 * 0.3 * mass * 5.972e24 * Q / (3.0 * 6.674e-11 * (ms * 1.989e30) ** 2 * k2 * (radius * 6.371e6) ** 3)
        out["tidally_locked"] = "expected" if lock < 3.156e16 else ""
    if rbasis == "transit" and radius and teq and rs:
        if mass and jmag is not None:
            scale = 0.190 if radius < 1.5 else 1.26 if radius < 2.75 else 1.28 if radius < 4.0 else 1.15
            out["tsm"] = round(scale * radius ** 3 * teq / (mass * rs ** 2) * 10.0 ** (-jmag / 5.0), 1)
        if teff and kmag is not None:
            planck = lambda t: 1.0 / math.expm1(1.4388e-2 / (7.5e-6 * t))
            out["esm"] = round(4.29e6 * planck(1.10 * teq) / planck(teff) * (radius * 0.009158 / rs) ** 2 * 10.0 ** (-kmag / 5.0), 1)
    return out


planets_CONTRIBUTION = {"found": "discovery", "eccentric": "discovery", "companion": "discovery", "transit": "discovery", "astrometry": "discovery", "toi": "mass confirmation",
                        "validated": "statistical validation"}
planets_DISCOVERER = "CharlesCNorton"


def planets_discoverers():
    """Who first found a signal: for a TESS candidate, the pipeline that raised its TOI (SPOC or QLP) or the submitter of its community TOI;
    planets_DISCOVERER otherwise."""
    exo = {x["label"]: x for x in planets_exofop()}
    promoted = {re.sub(r"[^0-9.]", "", x.get("Promoted to TOI") or ""): x for k, x in exo.items() if k.startswith("CTOI-") and (x.get("Promoted to TOI") or "").strip()}
    community = lambda x: "%s%s, community TOI" % (x.get("User") or "unnamed", " (%s)" % x["Group"] if (x.get("Group") or "").strip() else "")

    def of(r):
        if r["kind"] not in ("validated", "toi"):
            return planets_DISCOVERER
        x = exo.get(r["label"], {})
        if x.get("mission"):
            return x["mission"]
        if r["label"].startswith("CTOI-"):
            return community(x)
        if r["label"][4:] in promoted:
            return community(promoted[r["label"][4:]])
        source = (x.get("Source") or "").strip()
        return "TESS SPOC" if source.lower().startswith("spoc") else "TESS QLP" if source.lower().startswith("qlp") else ("TESS " + source).strip()
    return of


planets_DECISION_KEYS = ["status", "reason", "contribution", "discovered_by", "object", "prediction", "orbit_P", "orbit_P_lo", "orbit_P_hi", "orbit_msini_mearth", "orbit_msini_mearth_lo", "orbit_msini_mearth_hi", "orbit_e", "orbit_e_lo", "orbit_e_hi",
                         "orbit_K", "orbit_K_lo", "orbit_K_hi", "mass_mjup", "mass_mjup_lo", "mass_mjup_hi", "fap_serval", "fap_drs", "fap_lbl", "fap_lbl_quiet", "fap_hires", "fap_hires2", "fap_carmenes", "fap_carmenes2", "fap_sophie", "fap_harps-n", "fap_harps-n2", "fap_neid", "fap_elodie",
                         "dbic", "aliases_excluded", "tess_power", "tess_radius_limit_rearth", "rotation_d", "activity_model", "ruwe", "pma_snr", "catalogued", "fpp", "nfpp", "multiplicity_boost", "not_planet", "on_target", "source_offset", "source_err", "fpp_image", "nfpp_image",
                         "radius_rearth", "odd_even_sigma", "secondary_sigma", "occultation_max_ppm", "secondary_excess_sigma", "dv_odd_even", "dv_secondary_mes", "dv_centroid_sigma", "dv_core", "dv_halo",
                         "t0_btjd", "depth_ppm", "duration_h", "transit_snr", "transits", "single_event_share", "centroid_arcsec", "centroid_err", "centroid_sigma", "gaia_vbroad", "spin_ratio", "gaia_nss", "gaia_rv_scatter", "gaia_rv_gof",
                         "second_instrument", "second_nights", "second_scale", "second_scale_err", "second_phase_sigma", "second_test",
                         "dr4_test", "dr4_ln_bayes", "dr4_control", "dr4_snr_least", "dr4_mass_mjup", "dr4_mass_lo", "dr4_mass_hi", "dr4_incl_deg"]


def planets_followup(workers=6, report=False):
    """Every signal decided into RESULTS/signals.csv and the new bodies listed in RESULTS/planets.csv; REPORT re-decides from saved results."""
    sig = [r for r in planets_read(os.path.join(planets_RESULTS, "signals.csv")) if r["kind"] in ("known", "found")]
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    # Candidates from the eccentric-orbit search (planets eccentric) that carry no flags and lie more than 5% in period from every census signal of the
    # same star are vetted and decided in the same way as census signals.
    epath = os.path.join(planets_RESULTS, "eccentric", "candidates.csv")
    for x in (planets_read(epath) if os.path.exists(epath) else []):
        if x["flags"] or any(s["name"] == x["name"] and abs(float(s["P"]) / float(x["P"]) - 1.0) < 0.05 for s in sig):
            continue
        sig.append(dict(name=x["name"], sptype=x["sptype"], vmag=stars.get(x["name"], {}).get("Vmag", ""), host="", kind="eccentric", label="eccentric orbit",
                        nights=x["nights"], span_d=x["span_d"], P=x["P"], K=x["K"], e=x["e"], msini_mjup=round(float(x["msini_mearth"]) / 317.83, 4),
                        msini_mearth=x["msini_mearth"], fap=x["fap"], flags=""))
    heavy = lambda r: r["kind"] in ("found", "eccentric") and (float(r["msini_mjup"]) > 13.0 or float(r["K"]) >= 100.0)
    routed = {r["name"] for r in sig if heavy(r)}
    for r in sig:
        r.update(dict.fromkeys(planets_DECISION_KEYS, ""), object=planets_object(float(r["msini_mjup"])))
        # a companion's signal is decided in its star's companion row
        r.update(status="known") if r["kind"] == "known" else r.update(status="rejected", reason="companion") if heavy(r) else \
            r.update(status="rejected", reason="flagged") if r["flags"] else None
    cand = [r for r in sig if not r["status"]]
    kept, aside = planets_triage(cand, stars)
    for r, why in aside:
        r.update(status="known" if "archive planet" in why else "rejected", reason="; ".join(why))
    jobs = {}
    for r in kept:
        jobs.setdefault(r["name"], []).append(float(r["P"]))
    # with REPORT each star's saved vet record, and a fresh vet for those without one
    saved = {n: os.path.join(planets_RESULTS, "vet", archive_tag(n) + ".json") for n in jobs} if report else {}
    vet = {n: v for n, v in ((n, json.load(open(p))) for n, p in saved.items() if os.path.exists(p))
           if all(any(abs(P / q - 1.0) < 1e-9 for q in v["periods"]) for P in jobs[n])}
    vet.update(planets_vet([(n, ps) for n, ps in jobs.items() if n not in vet], show=False) if len(vet) < len(jobs) else {})
    follow, cands = {}, {}
    for r in kept:
        P = float(r["P"])
        held, failed, ind, text = planets_verdict(vet[r["name"]], P)
        cands[(r["name"], P)] = r
        act = planets_activity_result(r["name"], P)
        if act and act.get("verdict") in ("held", "failed"):
            r["activity_model"] = planets_activity_text(act)
        # a signal an indicator marks is followed where the star's activity, modelled, leaves it standing (planets_activity)
        if planets_families(held) >= 2 and (not ind or planets_activity_ready(r["name"], P)):
            follow.setdefault(r["name"], []).append(P)
        else:
            r.update(status="rejected", reason="activity indicator" if ind else "one reduction")
    known = {}
    for s in sig:
        if s["kind"] == "known":
            known.setdefault(s["name"], []).append((s["label"], float(s["P"])))
    # the followed stars' catalogued companions
    simbad = {n: (stars.get(n, {}).get("SimbadName") or n).strip() for n in follow}
    linked = archive_simbad_companions(sorted(set(simbad.values())))
    catalogued = {n: ["%s %.4g d" % kp for kp in known.get(n, [])] + ["%s (SIMBAD %s)" % c[:2] for c in linked.get(simbad[n], [])] for n in follow}
    # SIMBAD's companions without an archive period, the archive's planets matched to SIMBAD's objects
    archived = archive_simbad_oids(sorted({lb for n in follow for lb, _ in known.get(n, [])}))
    unexplained = {n: [m for m, _, o in linked.get(simbad[n], []) if o not in {archived.get(lb) for lb, _ in known.get(n, [])} and
                       archive_simbad_key(m) not in {archive_simbad_key(lb) for lb, _ in known.get(n, [])}] for n in follow}
    # the bank's stars beyond the census that vary as a companion's would, the census's companion stars beside them
    census = {r["name"] for r in planets_read(os.path.join(planets_RESULTS, "stars.csv"))}
    varying = planets_varying(planets_bank_series(), stars, census)
    explained = planets_catalogue(sorted(varying), stars)
    rows, analyse = [], set(routed)
    for n, nights in sorted(varying.items()):
        if explained[n] or nights < 10:
            s = stars[n]
            rows.append(dict(name=n, sptype=s.get("SpType", ""), vmag=s.get("Vmag", ""), kind="companion", label="variation", nights=nights,
                             status="known" if explained[n] else "rejected", reason="catalogued" if explained[n] else "few nights",
                             catalogued="; ".join(explained[n])))
        else:
            analyse.add(n)
    folder = planets_path("followup")
    os.makedirs(folder, exist_ok=True)

    def run(name, args, log):
        """Run one star's follow-up in a separate process, logging to ROOT/followup/LOG and retrying once on failure. With REPORT, saved results are
        reused, except that a star is rerun when its saved system analysis lacks one of its periods, and a companion analysis is run when none is saved
        or the saved one failed for want of the primary star's mass."""
        saved = os.path.join(planets_RESULTS, "companion", archive_tag(name) + ".json")
        system = os.path.join(planets_RESULTS, "system", archive_tag(name), "analysis.json")
        rerun = (args[0] == "--companion" and (not os.path.exists(saved) or "no primary mass" in json.load(open(saved)).get("weigh_error", ""))) or \
            (args[0] == "--star" and not (os.path.exists(system) and all(any(abs(float(P) / q - 1.0) < 1e-9 for q in json.load(open(system))["periods"])
                                                                      for P in args[3].split(","))))
        if report and not rerun:
            return name, 0
        cmd = [sys.executable, "-u", os.path.abspath(__file__), "planets", "followup"] + args
        for _ in range(2):
            with open(os.path.join(folder, log), "w", encoding="utf-8") as fh:
                code = subprocess.run(cmd, stdout=fh, stderr=subprocess.STDOUT).returncode
            if code == 0:
                break
        return name, code
    tasks = [(n, ["--star", n, "--periods", ",".join(repr(P) for P in follow[n]), "--known", ",".join(repr(P) for _, P in known.get(n, []))],
              archive_tag(n) + ".log") for n in follow] + [(n, ["--companion", n], archive_tag(n) + ".companion.log") for n in sorted(analyse)]
    failed = set()
    with cf.ThreadPoolExecutor(workers) as ex:
        for f in cf.as_completed([ex.submit(run, *task) for task in tasks]):
            name, code = f.result()
            failed |= {name} if code else set()
    # each followed star's rotation period from its S index and colour, as the Sun's activity lies at its rotation and half of it
    dace = planets_dace_series(set(follow))
    s_med = {n: float(np.median([x[3] for xs in dace.get(n, {}).values() for x in xs if 0 < x[3] < 5])) if any(0 < x[3] < 5 for xs in dace.get(n, {}).values()
                                                                                                          for x in xs) else float("nan") for n in follow}
    prot = {n: [q for q in (archive_num(stars.get(n, {}).get("Prot")) or planets_rotation(planets_num(stars.get(n, {}).get("Bmag")) - planets_num(stars.get(n, {}).get("Vmag")), s_med[n]),) if q] + planets_rotation_read(planets_num(stars.get(n, {}).get("RAJ2000")), planets_num(stars.get(n, {}).get("DEJ2000"))) for n in follow}
    for name in follow:
        vp = os.path.join(planets_RESULTS, "vet", archive_tag(name) + ".json")
        res = json.load(open(vp)) if os.path.exists(vp) else vet[name]
        for P in follow[name]:
            cands[(name, P)].update(planets_followup_row(cands[(name, P)], res, catalogued[name], unexplained[name], prot[name]))
            if name in failed:
                cands[(name, P)].update(status="rejected", reason="follow-up failed")
    recs = {}
    for name in sorted(analyse):
        path = os.path.join(planets_RESULTS, "companion", archive_tag(name) + ".json")
        if os.path.exists(path) and name not in failed:
            recs[name] = json.load(open(path))
        else:
            s = stars[name]
            rows.append(dict(name=name, sptype=s.get("SpType", ""), vmag=s.get("Vmag", ""), kind="companion", label="orbit", status="rejected",
                             reason="analysis failed"))
    period = lambda rec: (rec.get("orbit") or {}).get("P", [None])[0] or (rec.get("weigh") or {}).get("P_d", [None])[0] or rec["P"]
    cats = planets_catalogue(sorted(recs), stars, {n: period(rec) for n, rec in recs.items()})
    rows += [planets_companion_row(n, stars[n], rec, cats[n]) for n, rec in sorted(recs.items())]
    # a root with its own bank weighs TESS's candidates among its stars with it at each decision, as ExoFOP's table now stands
    if planets_BANK_INFO:
        planets_tois(fit_only=True, source="bank")
    tois = planets_toi_rows()
    # a root of the TESS stage keeps the transit signals that pass the search's vetting alone, its rejections counted in its records, each star decided once
    if os.path.exists(planets_path("tess.json")):
        transit = [r for r in planets_transit_kept(stars) if r["status"] != "rejected"]
    else:
        transit = planets_transit_rows(stars, full=True)
    rows += tois + planets_validated_rows(tois) + transit
    sig += rows
    sig += planets_epochs_rows(stars, sig)
    planets_encyclopaedia_decide(sig, stars)
    planets_false_decide(sig, stars)
    planets_survey_decide(sig, stars)
    planets_second_decide(sig)
    planets_epochs_decide(sig)
    # Apply the verdicts of planets ledger: a new body whose predicted orbit failed against later observations is rejected.
    lpath, kinds = os.path.join(planets_RESULTS, "ledger.csv"), {"census": "found", "eccentric search": "eccentric", "companions": "companion", "TESS": "toi",
                                                                 "validation": "validated", "transit search": "transit", "astrometry": "astrometry"}
    for x in (planets_read(lpath) if os.path.exists(lpath) else []):
        for r in sig:
            if r["status"] == "new" and r["name"] == x["bank_name"] and r["kind"] == kinds[x["found_by"]] and abs(float(r["P"]) / float(x["P_d"]) - 1.0) < 0.2:
                r["prediction"] = x["prediction"]
                if x["prediction"] == "failed":
                    r.update(status="rejected", reason="prediction failed")
    discoverer = planets_discoverers()
    for r in sig:
        r["contribution"] = planets_CONTRIBUTION[r["kind"]] if r["status"] == "new" else "likely planet" if r["status"] == "likely" else "" if r["status"] != "known" else \
            "independent detection" if r["kind"] in ("found", "eccentric", "companion", "transit", "astrometry") and r["reason"] in ("archive planet", "catalogued") and r.get("label") != "variation" \
            else "independent mass measurement" if r["kind"] == "toi" else r.get("contribution", "") if r["kind"] == "validated" else ""
        r["discovered_by"] = discoverer(r) if r["kind"] in ("validated", "toi") or r["status"] in ("new", "candidate", "likely") else ""
    planets_write(os.path.join(planets_RESULTS, "signals.csv"), sig, planets_SIGNAL_KEYS + planets_S_KEYS + planets_DECISION_KEYS)
    listed = planets_list(sig, stars)
    found, likely = [r for r in listed if r["status"] == "new"], [r for r in listed if r["status"] == "likely"]
    planets_write(os.path.join(planets_RESULTS, "planets.csv"), found, list(listed[0].keys()) if listed else ["planet"])
    planets_write(os.path.join(planets_RESULTS, "likely_planets.csv"), likely, list(listed[0].keys()) if listed else ["planet"])
    planets_singles_table()
    try:
        planets_epochs_predict(found, stars)
    except Exception as exc:
        print("DR4's predictions left as they stand: %s: %s" % (type(exc).__name__, str(exc)[:160]), flush=True)
    for r in found:
        mass = "%s Mjup true" % r["mass_mjup"] if r["mass_mjup"] not in ("", None) else "%s Mearth minimum" % r["msini_mearth"]
        print("%-26s %-11s %12.3f d  %s" % (r["planet"], r["kind"], float(r["P_d"]), mass), flush=True)


def planets_draws_save(path, rec, **arrays):
    """Posterior draws written beside the JSON record at PATH, in the file of the same name ending .draws.npz, each of ARRAYS under its name; REC's draws
    field is set to that file's name."""
    npz = path[:-len(".json")] + ".draws.npz"
    np.savez_compressed(npz, **{k: np.asarray(v, float) for k, v in arrays.items()})
    rec["draws"] = os.path.basename(npz)


def planets_draws_load(path, rec):
    """The posterior draws of the JSON record REC at PATH: the arrays of the .npz file its draws field names, by name."""
    with np.load(os.path.join(os.path.dirname(path), rec["draws"])) as d:
        return {k: d[k] for k in d.files}


def planets_orbits(name, periods, steps=30000, mstar=None, ebound=0.9, others=True, seed=11, circular=False, label=None, extra=None):
    """A star's Keplerians sampled, to RESULTS/orbits/<name>.json. The bank's velocities averaged per night, an offset for each side of the fibre upgrade and
    a jitter, and every DACE instrument family outside HARPS with 5 nights or more (all but the bank's left out where OTHERS is false), each era with its
    offset and each family with its jitter.
    Nights more than six scaled median absolute deviations and five median errors from the circular fit are set aside, at most one in twenty, as the
    census sets them aside. One Keplerian per starting period, each with its period (within 20 per cent of the start), time of inferior conjunction, which a nearly circular orbit fixes where it leaves periastron free, sqrt(e) cos omega, sqrt(e) sin omega (e
    below EBOUND) and semi-amplitude, started from a circular least-squares fit carried to the likelihood's maximum by Levenberg-Marquardt and sampled for
    STEPS steps by differential-evolution moves on the device (gpu_ensemble), the second half of the chain kept; with CIRCULAR every eccentricity is held at
    zero and the rest sampled about the circular fit. The medians and 16th to 84th percentiles of each period, K, e, minimum mass for a star of MSTAR solar
    masses (by default Gaia's FLAME mass as ROOT/stellar.json keeps it, else the spectral type's) and time of inferior conjunction, the best fit's scatter, the chain's autocorrelation time (emcee's estimate),
    and its log-likelihood beside that of the same orbits held circular; with CIRCULAR to <name>.circular.json, with LABEL to <name>.<label>.json. 256
    posterior draws of each planet's (P, tp, e, omega, K) go to the .draws.npz file beside the JSON, as one array (planet, draw, parameter) named draws.
    EXTRA is an .npz file of additional nightly velocities (mjd, rv, rv_err in m/s), fitted as a separate series with its own offset and jitter."""
    import emcee
    star = next(r for r in planets_read(planets_path("bank_stars.csv")) if r["Name"] == name)
    mstar = mstar or archive_num(star.get("Mass")) or ((planets_load_json(planets_path("stellar.json")) or {}).get(name) or [None] * 3)[2] or planets_mass(star.get("SpType"))
    groups, jgroups, T, Vv, Ee = [], [], [], [], []
    x = np.array(planets_bank_series({name}).get(name, []))
    for g, sel in enumerate((x[:, 0] < planets_UPGRADE, x[:, 0] >= planets_UPGRADE)):
        if sel.sum() >= 3:
            tn, vn, en = planets_by_night(x[sel, 0], x[sel, 1], x[sel, 2])
            keep = np.abs(vn - np.median(vn)) <= max(15.0 * 1.4826 * np.median(np.abs(vn - np.median(vn))), 30.0)
            T.append(tn[keep]), Vv.append(vn[keep]), Ee.append(en[keep]), groups.append(np.full(keep.sum(), len(groups))), jgroups.append(np.zeros(keep.sum(), int))
    labels, jlabels = ["%s %s" % (planets_BANK_FAMILY, s) for s, sel in zip(("pre", "post"), (x[:, 0] < planets_UPGRADE, x[:, 0] >= planets_UPGRADE)) if sel.sum() >= 3], [planets_BANK_FAMILY]
    if others:
        fams = {}
        for k, xs in planets_dace_series({name}).get(name, {}).items():
            fam = planets_family(k[0])
            if fam != planets_BANK_FAMILY:
                fams.setdefault(fam, {}).setdefault(k[1], []).append((k, xs))
        for fam, pubs in fams.items():
            kb = max(pubs, key=lambda b: sum(len(xs) for _, xs in pubs[b]))
            added = False
            for k, xs in pubs[kb]:
                y = np.array(planets_clean(xs))
                if len(y) < 5 or np.median(y[:, 2]) > 20.0:
                    continue
                tn, vn, en = planets_by_night(y[:, 0], y[:, 1], y[:, 2])
                T.append(tn), Vv.append(vn), Ee.append(en), groups.append(np.full(len(tn), len(groups))), jgroups.append(np.full(len(tn), len(jlabels)))
                labels.append(" ".join(z for z in k if z))
                added = True
            if added:
                jlabels.append(fam)
    if extra:
        d = np.load(extra)
        T.append(d["mjd"]), Vv.append(d["rv"]), Ee.append(d["rv_err"]), groups.append(np.full(len(d["mjd"]), len(groups)))
        jgroups.append(np.full(len(d["mjd"]), len(jlabels)))
        labels.append("newer"), jlabels.append("newer")
    t, v, e, gidx, jidx = (np.concatenate(z) for z in (T, Vv, Ee, groups, jgroups))
    ng, nj, n = len(labels), len(jlabels), len(periods)
    t0 = float(np.round(np.median(t)))
    Tt, Vt, E2t = gpu_dev(t), gpu_dev(v), gpu_dev(e ** 2)
    Gt, Jt = torch.as_tensor(gidx, device=gpu_DEVICE), torch.as_tensor(jidx, device=gpu_DEVICE)

    def model(q, cap=None):
        """Velocities for parameter rows Q (b, d), a tensor, each eccentricity held below CAP where given."""
        m = q[:, :ng][:, Gt]
        for i in range(n):
            P, tc, sc, ss, K = (q[:, ng + nj + 5 * i + j:ng + nj + 5 * i + j + 1] for j in range(5))
            ecc = sc * sc + ss * ss
            ecc = ecc if cap is None else torch.clamp(ecc, max=cap)
            w = torch.atan2(ss, sc)
            # the time of periastron from the conjunction, where the true anomaly is pi/2 - omega
            E = 2 * torch.atan2(torch.sqrt(1 - ecc) * torch.sin(math.pi / 4 - w / 2), torch.sqrt(1 + ecc) * torch.cos(math.pi / 4 - w / 2))
            m = m + K * gpu_keplerian(Tt[None, :], P, tc - P * (E - ecc * torch.sin(E)) / (2 * math.pi), ecc, w)
        return m

    def logp(q):
        """The log-likelihood of parameter rows Q (b, d) on the device, -inf outside the bounds."""
        jit = q[:, ng:ng + nj]
        ok = ((jit >= 0) & (jit < 50)).all(1)
        for i in range(n):
            P, tc, sc, ss, K = (q[:, ng + nj + 5 * i + j] for j in range(5))
            ok = ok & (0.8 * periods[i] < P) & (P < 1.2 * periods[i]) & (K > 0) & (sc * sc + ss * ss < ebound) & ((tc - t0).abs() < P)
        s2 = E2t[None, :] + jit[:, Jt] ** 2
        r = Vt[None, :] - model(q, ebound)
        lp = -0.5 * (r * r / s2 + torch.log(2 * math.pi * s2)).sum(1)
        return torch.where(ok & torch.isfinite(lp), lp, torch.full_like(lp, -float("inf")))

    def lnprob(p):
        """logp of parameter rows P as arrays."""
        return gpu_host(logp(gpu_dev(np.atleast_2d(p))))

    # the start, circular orbits fitted linearly
    cols = [(gidx == gi).astype(float) for gi in range(ng)]
    for P in periods:
        cols += [np.cos(2 * np.pi * (t - t0) / P), np.sin(2 * np.pi * (t - t0) / P)]
    c = np.linalg.lstsq(np.column_stack(cols) / e[:, None], v / e, rcond=None)[0]
    p = list(c[:ng]) + [1.0] * nj
    for i, P in enumerate(periods):
        A, B = c[ng + 2 * i], c[ng + 2 * i + 1]
        # the conjunction a quarter of an orbit after the velocity's peak; the eccentricity starts at 0.01, or inside EBOUND where that is tighter
        p += [P, t0 + P * (math.atan2(B, A) / (2 * np.pi) + 0.25), min(0.1, 0.5 * math.sqrt(ebound)), 0.0, max(math.hypot(A, B), 0.3)]
    ecc_idx = [ng + nj + 5 * i + j for i in range(n) for j in (2, 3)]
    free_idx = [i for i in range(len(p)) if i not in ecc_idx]

    def fit(q, held):
        """The likelihood's maximum from Q by Levenberg-Marquardt, each period within 3 per cent of its start and the jitters refitted four times; with
        HELD the eccentricities zero. Returns the parameters and their log-likelihood."""
        q = np.array(q, float)
        if held:
            q[ecc_idx] = 0.0
        free = [i for i in range(len(q)) if not ng <= i < ng + nj and not (held and i in ecc_idx)]
        lo, hi = np.full(len(q), -np.inf), np.full(len(q), np.inf)
        for i in range(n):
            j = ng + nj + 5 * i
            lo[j], hi[j] = 0.97 * periods[i], 1.03 * periods[i]
            lo[j + 2:j + 4], hi[j + 2:j + 4] = -math.sqrt(ebound), math.sqrt(ebound)
            lo[j + 4] = 1e-3
        free_t = torch.as_tensor(free, device=gpu_DEVICE)
        for _ in range(4):
            base, S = gpu_dev(q), torch.sqrt(E2t + gpu_dev(q[ng:ng + nj])[Jt] ** 2)

            def resid(x, idx):
                full = base.repeat(len(x), 1)
                full[:, free_t] = x
                return (Vt[None, :] - model(full, 0.99 * ebound)) / S[None, :]
            x, _ = gpu_lm(resid, np.clip(q[free], lo[free] + 1e-9, hi[free] - 1e-9)[None, :], lo[free], hi[free], iters=400)
            q[free] = gpu_host(x[0])
            r = v - gpu_host(model(gpu_dev(q[None, :]), 0.99 * ebound))[0]
            q[ng:ng + nj] = [min(math.sqrt(max(np.mean(r[jidx == j] ** 2) - np.mean(e[jidx == j] ** 2), 0.0)), 49.0) for j in range(nj)]
        for i in range(n):
            j = ng + nj + 5 * i
            e2 = q[j + 2] ** 2 + q[j + 3] ** 2
            if e2 >= 0.99 * ebound:
                q[j + 2:j + 4] *= math.sqrt(0.98 * ebound / e2)
            q[j + 1] = t0 + (q[j + 1] - t0 + 0.5 * q[j]) % q[j] - 0.5 * q[j]
        return q, float(lnprob(q)[0])
    # the nights the census sets aside, judged against the circular fit
    r = v - gpu_host(model(gpu_dev(fit(p, True)[0][None, :])))[0]
    dev = np.abs(r - np.median(r))
    aside = np.argsort(-dev)[:len(t) // 20]
    aside = aside[dev[aside] > max(6.0 * 1.4826 * np.median(dev), 5.0 * np.median(e))]
    if len(aside):
        keep = np.setdiff1d(np.arange(len(t)), aside)
        t, v, e, gidx, jidx = t[keep], v[keep], e[keep], gidx[keep], jidx[keep]
        Tt, Vt, E2t = gpu_dev(t), gpu_dev(v), gpu_dev(e ** 2)
        Gt, Jt = torch.as_tensor(gidx, device=gpu_DEVICE), torch.as_tensor(jidx, device=gpu_DEVICE)
    best, lnl_free = fit(p, False)
    circ, lnl_circ = fit(best, True)
    # with CIRCULAR the eccentricities stay at zero and only the other parameters are sampled
    centre, sampled = (circ, np.array(free_idx)) if circular else (best, np.arange(len(best)))

    C, S_idx = gpu_dev(centre), torch.as_tensor(sampled, device=gpu_DEVICE)

    def logp_s(q):
        """logp of the sampled parameters Q (b, len(sampled)), the others held at the centre's."""
        full = C.repeat(len(q), 1)
        full[:, S_idx] = q
        return logp(full)
    lnprob_s = lambda q: gpu_host(logp_s(gpu_dev(np.atleast_2d(q))))
    ndim = len(sampled)
    nw = max(4 * ndim, 48)
    rng = np.random.default_rng(seed)
    # the walkers spread by half the likelihood's own width in each parameter at the fit, the others held, and at most by 0.1 m/s in offsets and jitters and, per orbit,
    # 1e-4 P in P, 0.01 P in the conjunction, 0.02 in each sqrt(e) term and 0.05 K in K
    scale = np.full(len(best), 0.1)
    for i in range(n):
        j = ng + nj + 5 * i
        se = min(0.02, 0.3 * math.sqrt(ebound))
        scale[j:j + 5] = (1e-4 * centre[j], 0.01 * centre[j], se, se, max(0.05 * centre[j + 4], 0.05))
    scale, c0 = scale[sampled], centre[sampled]
    step_ = 0.01 * scale
    bump = np.diag(step_)
    lp0, up_, dn_ = lnprob_s(c0)[0], lnprob_s(c0 + bump), lnprob_s(c0 - bump)
    with np.errstate(all="ignore"):
        wide = 0.5 / np.sqrt(np.maximum(-(up_ + dn_ - 2.0 * lp0) / step_ ** 2, 0.0))
    scale = np.where(np.isfinite(wide) & (wide > 0), np.minimum(wide, scale), scale)
    p0 = c0 + scale * rng.standard_normal((nw, ndim))
    bad = ~np.isfinite(lnprob_s(p0))
    while bad.any():
        p0[bad] = c0 + 0.1 * scale * rng.standard_normal((bad.sum(), ndim))
        bad = ~np.isfinite(lnprob_s(p0))
    # differential-evolution moves, for the orbits' correlated parameters, every tenth step kept and the first half of the chain set aside
    chain, accept = gpu_ensemble(logp_s, p0, steps, thin=10, seed=seed, graph=True)
    kept = chain[len(chain) // 2:]
    chs = kept.reshape(-1, ndim)
    ch = np.tile(centre, (len(chs), 1))
    ch[:, sampled] = chs
    pct = lambda z: [round(float(np.percentile(z, q)), 4) for q in (50, 16, 84)]
    res = dict(name=name, mstar=mstar, series=labels, nights=len(t), set_aside=int(len(aside)), span=round(float(t.max() - t.min())),
               first_mjd=round(float(t.min()), 3), last_mjd=round(float(t.max()), 3), lnl_free=round(lnl_free, 2), lnl_circular=round(lnl_circ, 2),
               circular=bool(circular), rms_best=round(float(np.std(v - gpu_host(model(gpu_dev(centre[None, :])))[0])), 2), jitter={jl: pct(ch[:, ng + j]) for j, jl in enumerate(jlabels)},
               acceptance=round(float(np.mean(accept)), 3), steps=steps, walkers=nw, phase="conjunction",
               autocorrelation_steps=round(10.0 * float(np.max(emcee.autocorr.integrated_time(kept, quiet=True))), 1), planets=[])
    draws = []
    for i in range(n):
        P, K = ch[:, ng + nj + 5 * i], ch[:, ng + nj + 5 * i + 4]
        ecc = ch[:, ng + nj + 5 * i + 2] ** 2 + ch[:, ng + nj + 5 * i + 3] ** 2
        msini = planets_msini(P, K, ecc, mstar) * 317.83
        # the time of inferior conjunction, where a transit would fall, the one nearest the series' median time
        tc = ch[:, ng + nj + 5 * i + 1]
        tc = tc + P * np.round((centre[ng + nj + 5 * i + 1] - tc) / P)
        j = np.linspace(0, len(ch) - 1, min(256, len(ch))).astype(int)
        om = np.arctan2(ch[j, ng + nj + 5 * i + 3], ch[j, ng + nj + 5 * i + 2])
        E = 2 * np.arctan2(np.sqrt(1 - ecc[j]) * np.sin(np.pi / 4 - om / 2), np.sqrt(1 + ecc[j]) * np.cos(np.pi / 4 - om / 2))
        res["planets"].append(dict(P=pct(P), K=pct(K), e=pct(ecc), e_95=round(float(np.percentile(ecc, 95)), 4), msini_mearth=pct(msini), tc_mjd=pct(tc)))
        draws.append(np.round(np.column_stack([P[j], tc[j] - P[j] * (E - ecc[j] * np.sin(E)) / (2 * np.pi), ecc[j], om, K[j]]), 6))
    os.makedirs(os.path.join(planets_RESULTS, "orbits"), exist_ok=True)
    path = os.path.join(planets_RESULTS, "orbits", archive_tag(name) + ("." + label if label else "") + (".circular" if circular else "") + ".json")
    planets_draws_save(path, res, draws=np.array(draws))
    json.dump(res, open(path, "w"), separators=(",", ":"))
    print("%s: %d nights over %d d (%s), rms %.2f m/s, lnL %.1f free and %.1f circular, acceptance %.2f, autocorrelation %.0f steps" % (
        name, res["nights"], res["span"], ", ".join(labels), res["rms_best"], lnl_free, lnl_circ, res["acceptance"], res["autocorrelation_steps"]), flush=True)
    for pl in res["planets"]:
        print("  P %s  K %s  e %s  msini %s Earth masses  conjunction %s" % (pl["P"], pl["K"], pl["e"], pl["msini_mearth"], pl["tc_mjd"]), flush=True)


def planets_transit_flux(path, invert=False, window=1.0):
    """A star's TESS light curves (eclipses_fetch's file PATH) as the transit search reads them: each sector binned to ten minutes, or left at its
    cadence where that is longer, and divided by its running median over WINDOW days, the points 5 robust standard deviations above the median set aside, as a star's flares; with INVERT, those as far below it too, what would stand as bright events upside down, and the flux turned upside down about one, so that a flare set aside right way up is no dip upside down: the
    times, fluxes, the robust standard deviation and the number of sectors, or None where there is no light curve."""
    T, F = [], []
    d = np.load(path) if path else None
    for sec in (np.unique(d["sector"]) if d is not None else []):
        m = (d["sector"] == sec) & np.isfinite(d["flux"])
        if m.sum() < 100:
            continue
        t, fl = d["time"][m], d["flux"][m]
        _, inv = np.unique(np.floor((t - t.min()) * 144.0), return_inverse=True)
        n = np.bincount(inv)
        tb, fb = np.bincount(inv, t) / n, np.bincount(inv, fl) / n
        if len(tb) > 150:
            # WINDOW days' bins, whatever the cadence
            width = max(3, int(round(window / float(np.median(np.diff(tb))))) | 1)
            T.append(tb), F.append(fb / gpu_host(gpu_running_median(fb, width)))
    if not T:
        return None
    t, f = np.concatenate(T), np.concatenate(F)
    sd = 1.4826 * float(np.median(np.abs(f - np.median(f))))
    keep = (f < 1.0 + 5.0 * sd) & (f > 1.0 - 5.0 * sd if invert else True)
    return t[keep], 2.0 - f[keep] if invert else f[keep], sd, len(T)


def planets_transit_red_snr(t, f, live, P, t0, D, depth, transits):
    """A box's signal-to-noise against the light curve's noise on the box's own timescale (Pont et al. 2006): its DEPTH times the square root of
    its TRANSITS over the robust scatter of the means of the out-of-transit flux in windows as long as the box, each window three quarters covered or
    more, the points LIVE marks alone; None where fewer than ten windows are."""
    dt = ((t - t0) / P + 0.5) % 1.0 * P - 0.5 * P
    out = live & (np.abs(dt) > D)
    if out.sum() < 20 or transits < 1:
        return None
    _, inv, cnt = np.unique(np.floor((t[out] - t[out].min()) / D), return_inverse=True, return_counts=True)
    means = (np.bincount(inv, f[out]) / cnt)[cnt >= 0.75 * D * 144.0]
    if len(means) < 10:
        return None
    sd = 1.4826 * float(np.median(np.abs(means - np.median(means))))
    return round(depth * math.sqrt(transits) / sd, 2) if sd > 0 else None


planets_TRANSIT_DURATIONS = np.array([1, 2, 3, 4, 6, 9, 12]) / 24.0
# the radius (the Sun's) under which a star's search also tries the short transits a planet makes across a small star, and those transits' lengths (days)
planets_SMALL_STAR, planets_SHORT_DURATIONS = 0.6, np.array([0.5, 0.75]) / 24.0


def planets_small_star(rstar):
    """Whether a star of radius RSTAR (the Sun's) is small enough for the short transits (planets_SMALL_STAR)."""
    x = archive_num(rstar)
    return x is not None and math.isfinite(x) and 0.0 < x < planets_SMALL_STAR


def planets_transit_durations(rstar):
    """The transit lengths the box search tries about a star of radius RSTAR (the Sun's): planets_TRANSIT_DURATIONS, with planets_SHORT_DURATIONS before them about a small star (planets_small_star)."""
    return np.concatenate([planets_SHORT_DURATIONS, planets_TRANSIT_DURATIONS]) if planets_small_star(rstar) else planets_TRANSIT_DURATIONS
# the long stage of the search (planets_transit_long): its longest period, its boxes (days) and the days its light curves are detrended over
planets_TRANSIT_LONGEST, planets_TRANSIT_LONG_DURATIONS, planets_TRANSIT_LONG_WINDOW = 0.0, np.array([2, 3, 4, 6, 9, 12, 16]) / 24.0, 2.0


def planets_transit_periods(span, pmin, pmax):
    """The transit search's trial periods over a baseline of SPAN days, from PMAX down to PMIN, spaced in frequency so that a transit of the shortest
    central duration drifts by a fraction of itself over the baseline."""
    grid, x = [], 1.0 / pmax
    while x < 1.0 / pmin:
        grid.append(x)
        x += 0.077 * (1.0 / x) ** (1.0 / 3.0) * x / (2.0 * span)
    return 1.0 / np.array(grid)


def planets_transit_backfill(part=None):
    """The stored transit searches, of the share K/N where PART is given, that lack their signals' red-noise signal-to-noise (planets_transit_red_snr)
    or the highest signal-to-noise of the same search of the light curve turned upside down given them, from the light curves each search read, the
    signals' transits masked in turn as the search masked them, ending between searches where a long search would end between stars
    (planets_search_ends)."""
    done = 0
    paths = sorted(glob.glob(os.path.join(planets_RESULTS, "transitsearch", "*.json")))
    if part:
        k, n = (int(x) for x in part.split("/"))
        paths = paths[k::n]
    for path in paths:
        if planets_search_ends():
            return
        rec = planets_load_json(path)
        if not rec or not rec.get("signals") or (all("red_snr" in g for g in rec["signals"]) and "inverted_snr" in rec):
            continue
        got = planets_transit_flux(os.path.join(eclipses_ROOT, "lightcurves", rec["name"] + ".npz"))
        if got is None:
            continue
        t, f, sd, _ = got
        live = planets_transit_unmasked(t, [(P, t0, D / 24.0) for P, t0, D in rec.get("masked", [])])
        span = float(t.max() - t.min())
        periods = planets_transit_periods(span, rec["pmin"], min(rec["pmax"], 0.5 * span) if "peaks" in rec else rec["pmax"])
        rec["inverted_snr"] = round(float(np.max(gpu_bls(t[live], 2.0 - f[live], np.full(int(live.sum()), sd), periods, np.array(rec["durations_h"]) / 24.0 if rec.get("durations_h") else planets_TRANSIT_DURATIONS)[0])), 2)
        for g in rec["signals"]:
            P, t0, D = g["P"], g["t0_btjd"], g["duration_h"] / 24.0
            g["red_snr"] = planets_transit_red_snr(t, f, live, P, t0, D, g["depth_ppm"] / 1e6, g["transits"])
            live &= ~(np.abs(((t - t0) / P + 0.5) % 1.0 * P - 0.5 * P) < D)
        archive_save(path, json.dumps(rec, separators=(",", ":")).encode())
        done += 1
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("%d searches given their signals' red-noise signal-to-noise and their inverted search's" % done, flush=True)


def planets_transit_unmasked(t, mask):
    """The times T outside the transits of MASK, (period, epoch in BTJD, duration in days) each, within a duration of each transit's middle."""
    live = np.ones(len(t), bool)
    for P, t0, D in mask:
        live &= ~(np.abs(((t - t0) / P + 0.5) % 1.0 * P - 0.5 * P) < D)
    return live


def planets_transit_known(tic=None, ra=float("nan"), dec=float("nan")):
    """The transits already registered for a star, (period, epoch in BTJD, duration in days) each: those of the TOIs and community TOIs ExoFOP's tables
    in ROOT give for its TIC number TIC, or within an arcminute of its J2000 position RA, DEC where TIC is not given."""
    if not planets_TRANSIT_KNOWN:
        rows = []
        for x in planets_exofop():
            P, t0, D = planets_num(x.get("Period (days)")), planets_num(x.get("Epoch (BJD)")) - 2457000.0, planets_num(x.get("Duration (hours)")) / 24.0
            if P > 0 and math.isfinite(t0) and D > 0:
                rows.append((str(x.get("TIC ID", "")).strip(), planets_radec(x), (P, t0, D)))
        by_tic = {}
        for t_, _, e in rows:
            by_tic.setdefault(t_, []).append(e)
        planets_TRANSIT_KNOWN.append((by_tic, np.array([p[0] for _, p, _ in rows]), np.array([p[1] for _, p, _ in rows]), [e for _, _, e in rows]))
    by_tic, xra, xdec, eph = planets_TRANSIT_KNOWN[0]
    if tic is not None:
        return by_tic.get(str(tic), [])
    if not (math.isfinite(ra) and math.isfinite(dec)) or not len(xra):
        return []
    sep = np.hypot(((xra - ra + 180.0) % 360.0 - 180.0) * math.cos(math.radians(dec)), xdec - dec) * 3600.0
    return [eph[j] for j in np.where(sep < 60.0)[0]]


planets_TRANSIT_KNOWN = []
# this file's time of writing when the process started, a long search ending between stars once the file is replaced (planets_code_changed)
planets_CODE = os.stat(os.path.abspath(__file__)).st_mtime_ns


def planets_code_changed():
    """Whether this file has been replaced since the process started."""
    try:
        return os.stat(os.path.abspath(__file__)).st_mtime_ns != planets_CODE
    except OSError:
        return False


# the free bytes on the results' disk under which a long search ends between stars, before a full disk cuts its records short
planets_DISK_LOW = 2e9


# the seconds a long search may spend on one star, and while a pause is asked for, before its process ends: an archive's job that never ends holds
# the process for good, its calls answered but never finished
planets_STAR_LIMIT, planets_PAUSE_LIMIT = 3 * 3600, 15 * 60
planets_STAR_CLOCK = []


def planets_star_watch():
    """Ends the process with exit status 3 once planets_STAR_LIMIT seconds, or planets_PAUSE_LIMIT while a pause is asked for, pass with no call of
    planets_search_ends, which a long search makes between stars; printed. The process's claim is taken over in its time."""
    while True:
        time.sleep(30)
        idle, pause = time.time() - planets_STAR_CLOCK[0], os.environ.get("ORBITLIGHT_PAUSE")
        if idle > planets_STAR_LIMIT or (idle > planets_PAUSE_LIMIT and pause and os.path.exists(pause)):
            print("%.0f s on one star: the process ends" % idle, flush=True)
            os._exit(3)


def planets_search_ends():
    """Whether a long search ends between stars: once this file has been replaced (planets_code_changed), once the file the environment variable
    ORBITLIGHT_PAUSE names exists, or once the disk that holds the results has less than planets_DISK_LOW bytes free; the last two are printed. Its
    first call starts the watch on the time between calls (planets_star_watch)."""
    if not planets_STAR_CLOCK:
        planets_STAR_CLOCK.append(time.time())
        threading.Thread(target=planets_star_watch, daemon=True).start()
    planets_STAR_CLOCK[0] = time.time()
    if planets_code_changed():
        return True
    pause = os.environ.get("ORBITLIGHT_PAUSE")
    if pause and os.path.exists(pause):
        print("%s exists: the search pauses" % pause, flush=True)
        return True
    free = shutil.disk_usage(planets_RESULTS).free
    if free < planets_DISK_LOW:
        print("%.1f GB free on the disk of %s: the search ends" % (free / 1e9, planets_RESULTS), flush=True)
        return True
    return False


def planets_transit_current(path):
    """Whether the stored transit search at PATH is the current search's: a census star's that read each sector's detrended flux (eclipses_fetch), or a star the TESS stage searched, whose
    light curves are PDCSAP's, without light curves or with its peaks without three transits set aside (planets_transit_search), a small star's having tried the short transits (planets_transit_durations)."""
    if not os.path.exists(path):
        return False
    rec = planets_load_json(path)
    if not rec:
        return False
    return bool(rec.get("note")) or "peaks" in rec and ("durations_h" in rec or not planets_small_star(rec.get("rstar"))) if rec.get("tic") else bool(rec.get("detrended"))


# the transit search's shortest period
planets_TRANSIT_PMIN = 0.2


def planets_transit_peaks(out, t, f, sd, live, periods, durations, oversample, snr_min, most, peaks, **mark):
    """The highest peaks above SNR_MIN of a box search (gpu_bls) of the points LIVE of a light curve at PERIODS and DURATIONS, added to the record OUT, each carrying MARK: PEAKS of them at most, each with its transits, odd and even depths, secondary and red-noise signal-to-noise (planets_transit_red_snr) and its
    transits masked before the next, until MOST have three transits or more with none dominating, the others kept apart as set_aside, or until the masks leave under a quarter of the light curve."""
    found = 0
    for _ in range(peaks):
        # the search ends where the transits already masked leave under a quarter of the light curve
        if live.sum() < 0.25 * len(t):
            break
        snr, depth, dur, mid = gpu_bls(t[live], f[live], np.full(int(live.sum()), sd), periods, durations, oversample)
        k = int(np.argmax(snr))
        if not snr[k] >= snr_min:
            break
        P, t0, D = float(periods[k]), float(mid[k]), float(dur[k])
        dt = ((t - t0) / P + 0.5) % 1.0 * P - 0.5 * P
        inn, ring, epoch = live & (np.abs(dt) < 0.5 * D), live & (np.abs(dt) > D) & (np.abs(dt) < 3.0 * D), np.round((t - t0) / P)
        events = []
        for ep in np.unique(epoch[inn]):
            a, b = inn & (epoch == ep), ring & (epoch == ep)
            if a.sum() >= 2 and b.sum() >= 4:
                dep, err = float(np.mean(f[b]) - np.mean(f[a])), sd * math.sqrt(1.0 / a.sum() + 1.0 / b.sum())
                events.append(dict(epoch=int(ep), time=round(t0 + ep * P, 4), points=int(a.sum()), depth_ppm=round(1e6 * dep, 1), snr=round(dep / err, 2)))

        def mean_depth(sel):
            if not sel:
                return float("nan"), float("nan")
            dep = np.array([e["depth_ppm"] for e in sel])
            err = np.array([abs(e["depth_ppm"] / e["snr"]) if e["snr"] else np.inf for e in sel])
            w = 1.0 / err ** 2
            return float((w * dep).sum() / w.sum()), float(1.0 / math.sqrt(w.sum()))
        (do, eo), (de, ee) = mean_depth([e for e in events if e["epoch"] % 2]), mean_depth([e for e in events if not e["epoch"] % 2])
        # the light half an orbit on against that one to three durations about it, the transit itself left out where a short period brings it near
        sec_in = live & (np.abs(np.abs(dt) - 0.5 * P) < 0.5 * D)
        sec_out = live & (np.abs(np.abs(dt) - 0.5 * P) > D) & (np.abs(np.abs(dt) - 0.5 * P) < 3.0 * D) & (np.abs(dt) > D)
        sec = (float(np.mean(f[sec_out]) - np.mean(f[sec_in])) / (sd * math.sqrt(1.0 / sec_in.sum() + 1.0 / sec_out.sum()))) if sec_in.sum() >= 3 and sec_out.sum() >= 10 else None
        power = [max(e["snr"], 0.0) ** 2 for e in events]
        share = round(max(power) / sum(power), 3) if sum(power) > 0 else None
        # a peak of fewer than three transits, or of one dominating them, is set aside and counts against PEAKS alone
        if len(events) >= 3 and (share or 0.0) < 0.5:
            out["signals"].append(dict(P=round(P, 6), t0_btjd=round(t0, 5), duration_h=round(24.0 * D, 2), depth_ppm=round(1e6 * float(depth[k]), 1),
                                       snr=round(float(snr[k]), 2), red_snr=planets_transit_red_snr(t, f, live, P, t0, D, float(depth[k]), len(events)),
                                       transits=len(events),
                                       odd_even_sigma=round(abs(do - de) / math.hypot(eo, ee), 2) if events and math.isfinite(do) and math.isfinite(de) else None,
                                       secondary_sigma=round(sec, 2) if sec is not None else None, single_event_share=share, events=events, **mark))
            found += 1
        else:
            out["set_aside"].append(dict(P=round(P, 6), t0_btjd=round(t0, 5), duration_h=round(24.0 * D, 2), depth_ppm=round(1e6 * float(depth[k]), 1),
                                         snr=round(float(snr[k]), 2), transits=len(events), single_event_share=share, **mark))
        live &= ~(np.abs(dt) < D)
        if found >= most:
            break


def planets_transit_search(name, ra, dec, pmin=planets_TRANSIT_PMIN, pmax=20.0, snr_min=9.0, most=5, peaks=10, path=None, mask=(), extra=None, invert=False, longest=planets_TRANSIT_LONGEST, into=None):
    """A star's TESS light curves (eclipses_fetch's file, or PATH where given) searched blind for transits by box least squares on the device, to
    RESULTS/transitsearch/<name>.json, at periods from PMIN days to PMAX or half the light curves' span, whichever is shorter: the transits of MASK,
    (period, epoch in BTJD, duration in days) each, those already registered for the star, set aside first; then the highest peaks above SNR_MIN (planets_transit_peaks);
    and the highest signal-to-noise of the same search of the light curve turned upside down. Periods from PMAX to LONGEST or half the span are then searched on their own (planets_transit_long). EXTRA, the star's own details, is kept in the record, and an earlier
    search's validations of the star are removed. With INVERT the light curves are searched upside down, the highest signal-to-noise then that of the right way up, to RESULTS/transitsearch_inverted/<name>.json. INTO names the folder under RESULTS that a search of changed light curves is kept in."""
    if path is None:
        path = os.path.join(eclipses_ROOT, "lightcurves", name + ".npz")
        if not os.path.exists(path):
            path = eclipses_fetch(name, ra, dec)
    out = dict(name=name, pmin=pmin, pmax=pmax, peaks=peaks, snr_min=snr_min, detrended=True, signals=[], set_aside=[], **(extra or {}))
    got = planets_transit_flux(path, invert)
    if got is not None and float(got[0].max() - got[0].min()) < 4.0 * pmin:
        got = None
    if got is None:
        out["note"] = "no TESS light curve"
    else:
        t, f, sd, nsec = got
        span = float(t.max() - t.min())
        periods = planets_transit_periods(span, pmin, min(pmax, 0.5 * span))
        live = planets_transit_unmasked(t, mask)
        durations = planets_transit_durations((extra or {}).get("rstar"))
        # the same search of the light curve turned upside down, whose highest peak is the star's own noise ceiling
        out.update(sectors=nsec, points=int(len(t)), span_d=round(span, 1), noise_ppm=round(1e6 * sd, 1), periods=len(periods), durations_h=[round(24.0 * D, 2) for D in durations],
                   masked=[[round(P, 6), round(t0, 5), round(24.0 * D, 2)] for P, t0, D in mask],
                   inverted_snr=round(float(np.max(gpu_bls(t[live], 2.0 - f[live], np.full(int(live.sum()), sd), periods, durations)[0])), 2))
        planets_transit_peaks(out, t, f, sd, live, periods, durations, 10, snr_min, most, peaks)
        planets_transit_long(out, path, invert, mask, longest, snr_min, most, peaks)
    folder = into or ("transitsearch_inverted" if invert else "transitsearch")
    os.makedirs(os.path.join(planets_RESULTS, folder), exist_ok=True)
    stored = os.path.join(planets_RESULTS, folder, archive_tag(name) + ".json")
    if os.path.exists(stored) and folder == "transitsearch":
        # an earlier search's validations name its signals by their order, which this search's need not keep
        for p in glob.glob(os.path.join(planets_RESULTS, "validate_transits", archive_tag(name) + "_*.json")):
            if re.fullmatch(re.escape(archive_tag(name)) + r"_\d+\.json", os.path.basename(p)):
                os.remove(p)
    archive_save(stored, json.dumps(out, separators=(",", ":")).encode())
    print("%s: %s" % (name, out.get("note") or "%d sectors, %d signals%s" % (out["sectors"], len(out["signals"]), "".join(
        "; P %.4f d S/N %.1f %d transits" % (s["P"], s["snr"], s["transits"]) for s in out["signals"]))), flush=True)
    return out


def planets_transit_long(out, path, invert, mask, longest, snr_min=9.0, most=5, peaks=10):
    """The periods from a search's longest, OUT's pmax, to LONGEST or half the light curves' span searched on their own and added to the record OUT, each signal marked long, the record marked with LONGEST: a long transit's light curves detrended over planets_TRANSIT_LONG_WINDOW days, the transits of MASK and of the search's signals
    masked and not those it set aside, which a long orbit's own lone transits may be, boxes of planets_TRANSIT_LONG_DURATIONS on bins of a fifth of the shortest, and a noise ceiling of their own (inverted_snr_long), since a light curve's slow noise reaches higher here than at the shorter periods."""
    if longest <= out["pmax"] or "note" in out:
        return
    got = planets_transit_flux(path, invert, planets_TRANSIT_LONG_WINDOW)
    if got is None:
        return
    t, f, sd, _ = got
    span = float(t.max() - t.min())
    out["longest"] = longest
    if 0.5 * span <= out["pmax"]:
        return
    periods = planets_transit_periods(span, out["pmax"], min(longest, 0.5 * span))
    live = planets_transit_unmasked(t, list(mask) + [(g["P"], g["t0_btjd"], g["duration_h"] / 24.0) for g in out["signals"]])
    out.update(periods_long=len(periods), inverted_snr_long=round(float(np.max(gpu_bls(t[live], 2.0 - f[live], np.full(int(live.sum()), sd), periods, planets_TRANSIT_LONG_DURATIONS, 5)[0])), 2))
    planets_transit_peaks(out, t, f, sd, live, periods, planets_TRANSIT_LONG_DURATIONS, 5, snr_min, most, peaks, long=True)


# the boxes of the search for lone transits (hours), the signal-to-noise a dip must reach, and its multiple of the highest the same search finds upside down
planets_SINGLE_DURATIONS, planets_SINGLE_SNR, planets_SINGLE_CEILING = (2.0, 3.0, 4.0, 6.0, 9.0, 12.0, 16.0), 9.0, 1.5
# the days from a light curve's edge within which a dip is the spacecraft settling, and the days and other stars by which a dip shared in time is the spacecraft's
planets_SINGLE_EDGE, planets_SINGLE_SHARED_DAYS, planets_SINGLE_SHARED = 1.0, 0.5, 2


def planets_single_dips(t, f, durations=planets_SINGLE_DURATIONS):
    """The significance of a dip at every place of a light curve T, F (planets_transit_flux) for each box of DURATIONS hours: the mean flux of the same length on both sides, stopping short of a gap, less the mean inside, divided by the robust scatter of that measure over the light curve for that box, which holds its correlated noise: rows (durations, points), NaN where a box or its sides are not three quarters covered."""
    cadence = float(np.median(np.diff(t)))
    out = np.full((len(durations), len(t)), np.nan)
    # the running counts and sums over the regular grid the bins lie on
    grid = np.round((t - t[0]) / cadence).astype(np.int64)
    n = int(grid[-1]) + 2
    count, total = np.zeros(n), np.zeros(n)
    np.add.at(count, grid + 1, 1.0)
    np.add.at(total, grid + 1, f)
    count, total = np.cumsum(count), np.cumsum(total)
    for k, hours in enumerate(durations):
        half = max(int(round(0.5 * hours / 24.0 / cadence)), 1)
        width = 2 * half + 1
        a, b, c, d = np.clip(grid - half - width, 0, n - 1), np.clip(grid - half, 0, n - 1), np.clip(grid + half + 1, 0, n - 1), np.clip(grid + half + 1 + width, 0, n - 1)
        inner, left, right = count[c] - count[b], count[b] - count[a], count[d] - count[c]
        ok = (inner >= 0.75 * width) & (left >= 0.75 * width) & (right >= 0.75 * width)
        with np.errstate(divide="ignore", invalid="ignore"):
            dip = 0.5 * ((total[b] - total[a]) / left + (total[d] - total[c]) / right) - (total[c] - total[b]) / inner
        if ok.sum() >= 20:
            good = dip[ok]
            out[k, ok] = (good - np.median(good)) / max(1.4826 * float(np.median(np.abs(good - np.median(good)))), 1e-12)
    return out


def planets_single_events(path, mask=(), most=6):
    """The lone transits of a star's light curves (the file PATH), MASK's transits set aside: its light curves detrended over planets_TRANSIT_LONG_WINDOW days and the highest places of planets_single_dips above planets_SINGLE_SNR and planets_SINGLE_CEILING times the highest of the same search upside down, MOST at most, each with its time (BTJD), box, depth and significance, and the depth a third of a box on either side of it. A place within planets_SINGLE_EDGE days of a light curve's start or end or of a gap, where the flux ramps as the spacecraft settles, is left out, as is a dip those two depths do not hold within half of its own, the slope of a star's own variation. Returns the events, the ceiling and the light curves' times."""
    got, upside = planets_transit_flux(path, False, planets_TRANSIT_LONG_WINDOW), planets_transit_flux(path, True, planets_TRANSIT_LONG_WINDOW)
    if got is None or upside is None:
        return [], None, np.zeros(0)
    t, f, sd, _ = got
    keep = planets_transit_unmasked(t, mask)
    t, f = t[keep], f[keep]
    tu, fu = upside[0][planets_transit_unmasked(upside[0], mask)], upside[1][planets_transit_unmasked(upside[0], mask)]
    if len(t) < 100 or len(tu) < 100:
        return [], None, t
    ceiling = float(np.nanmax(np.nan_to_num(planets_single_dips(tu, fu), nan=-np.inf)))
    z = planets_single_dips(t, f)
    events = []
    best = np.nan_to_num(z, nan=-np.inf)
    # each point's distance from the nearest start or end of its stretch of the light curve, a stretch ending at a gap of half a day
    breaks = np.where(np.diff(t) > 0.5)[0]
    starts, ends = t[np.concatenate([[0], breaks + 1])], t[np.concatenate([breaks, [len(t) - 1]])]
    j = np.clip(np.searchsorted(starts, t, side="right") - 1, 0, len(starts) - 1)
    edge = np.minimum(t - starts[j], ends[j] - t) < planets_SINGLE_EDGE
    for _ in range(most):
        k, i = np.unravel_index(int(np.argmax(best)), best.shape)
        if not best[k, i] >= max(planets_SINGLE_SNR, planets_SINGLE_CEILING * ceiling):
            break
        hours = planets_SINGLE_DURATIONS[k]
        D = hours / 24.0
        near = np.abs(t - t[i])
        inn, ring = near < 0.5 * D, (near > 0.75 * D) & (near < 2.5 * D)
        depth = float(np.mean(f[ring]) - np.mean(f[inn]))
        third = lambda c: float(np.mean(f[ring]) - np.mean(f[np.abs(t - c) < D / 6.0])) if (np.abs(t - c) < D / 6.0).sum() >= 2 else float("nan")
        early, late = third(t[i] - D / 3.0), third(t[i] + D / 3.0)
        if not edge[i] and 0.5 * depth <= early <= 1.5 * depth and 0.5 * depth <= late <= 1.5 * depth:
            events.append(dict(T=round(float(t[i]), 4), hours=hours, depth_ppm=round(1e6 * depth, 1), snr=round(float(best[k, i]), 2), points=int(inn.sum()), early_ppm=round(1e6 * early, 1), late_ppm=round(1e6 * late, 1)))
        best[:, near < 2.0 * D + 16.0 / 24.0] = -np.inf
    return events, round(ceiling, 2), t


def planets_single_velocities(T, D, tess, t, v, e, g, draws=400, seed=19):
    """A lone transit at T (BTJD), D days long, set against a star's nightly velocities V at MJD T with errors E, an offset for each of G: at every period the light curves' times TESS leave it, a transit falling nowhere else they cover, circular orbits with their conjunction at the transit, the star's velocity -K sin 2 pi (t - Tc) / P, K positive, and the most chi-square any takes out, against the same search at DRAWS other times. Returns the best orbit's period, K and error, that chi-square, its false-alarm level against those draws with one added, the longest period the velocities' span can test and the share of periods left."""
    Tc = T + 56999.5
    span = float(t.max() - t.min())
    freq = np.arange(1.0 / (3.0 * span), 1.0 / max(10.0, 2.0 * D), 1.0 / (10.0 * span))
    # a period is left where every other transit it places in the light curves' span falls in a gap
    cover = np.sort(tess)
    def open_at(P):
        k = np.arange(math.floor((cover[0] - T) / P), math.ceil((cover[-1] - T) / P) + 1)
        k = k[k != 0]
        places = T + k * P
        j = np.clip(np.searchsorted(cover, places), 1, len(cover) - 1)
        return not np.any(np.minimum(np.abs(cover[j] - places), np.abs(cover[j - 1] - places)) < 0.25 * D)
    periods = np.array([1.0 / x for x in freq if open_at(1.0 / x)])
    if not len(periods):
        return None
    w = 1.0 / e ** 2
    y, inv = v.copy(), np.unique(g, return_inverse=True)[1]
    weights, means = np.bincount(inv, w), np.bincount(inv, w * y)
    y = y - (means / weights)[inv]

    def scan(tc):
        ph = 2.0 * np.pi * (t[None, None, :] - tc[:, None, None]) / periods[None, :, None]
        x = -np.sin(ph)
        xm = (np.stack([np.bincount(inv, w * row, minlength=len(weights)) for row in x.reshape(-1, len(t))]) / weights).reshape(x.shape[0], x.shape[1], len(weights))
        x = x - xm[:, :, inv]
        top = (x * (w * y)).sum(-1)
        bottom = (x * x * w).sum(-1)
        return np.where(top > 0, top * top / np.maximum(bottom, 1e-30), 0.0), top / np.maximum(bottom, 1e-30), bottom
    gain, K, bottom = scan(np.array([Tc]))
    i = int(np.argmax(gain[0]))
    rng = np.random.default_rng(seed)
    null = np.concatenate([scan(rng.uniform(t.min(), t.max(), 40))[0].max(1) for _ in range(draws // 40)])
    chi = float(np.sum(w * y * y))
    scale = math.sqrt(max((chi - gain[0, i]) / max(len(t) - len(weights) - 1, 1), 1.0))
    return dict(P=round(float(periods[i]), 3), K=round(float(K[0, i]), 2), eK=round(scale / math.sqrt(float(bottom[0, i])), 2), dchi2=round(float(gain[0, i]), 1), fap=round((1.0 + float((null >= gain[0, i]).sum())) / (1.0 + len(null)), 5), null_top=round(float(null.max()), 1), periods=len(periods), left=round(len(periods) / len(freq), 3), nights=int(len(t)), span_d=round(span))


def planets_singles(part=None):
    """The lone transits of the census's stars, each star's to RESULTS/singles/<star>.json: its light curves read from MAST's bucket by the brightest TIC star within 20 arcsec of it, SPOC's where it has them and TESS-SPOC's otherwise (planets_tess_lightcurves), the transits of its registered candidates and of its transit search's signals set aside (planets_transit_known), each dip (planets_single_events) set against the star's velocities (planets_single_velocities). A star with a record is passed over; PART takes the share K/N; the pass ends between stars where a long search would, with exit status 3, and runs for planets_DR4_PASS seconds at most."""
    from astroquery.mast import Catalogs
    from astropy.coordinates import SkyCoord
    import astropy.units as u
    names, stars, _, _ = planets_share(part)
    folder = os.path.join(planets_RESULTS, "singles")
    os.makedirs(folder, exist_ok=True)
    tics, _, kinds, _ = planets_tess_index()
    held = {k: set(tics[kinds == k].tolist()) for k in (0, 1)}
    cache = planets_path("singles_cache")
    started = time.time()
    for name in names:
        kept = os.path.join(folder, archive_tag(name) + ".json")
        if os.path.exists(kept):
            continue
        if planets_search_ends():
            sys.exit(3)
        if time.time() - started > planets_DR4_PASS:
            break
        s = stars[name]
        ra, dec = float(s["RAJ2000"]), float(s["DEJ2000"])
        rec = dict(name=name)
        try:
            near = Catalogs.query_region(SkyCoord(ra, dec, unit="deg"), radius=20 * u.arcsec, catalog="TIC")
            near.sort("Tmag")
            tic = int(near["ID"][0]) if len(near) else None
            kind = 0 if tic in held[0] else 1 if tic in held[1] else None
            rec.update(tic=tic)
            path = planets_tess_lightcurves(tic, cache, kind)[0] if kind is not None else None
            if not path:
                rec["note"] = "no light curve"
            else:
                found = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")) or {}
                mask = list(planets_transit_known(ra=ra, dec=dec)) + [(g["P"], g["t0_btjd"], g["duration_h"] / 24.0) for g in found.get("signals", [])]
                events, ceiling, cover = planets_single_events(path, mask)
                rec.update(ceiling=ceiling, events=events, points=int(len(cover)))
                rows, labels = planets_series(name, planets_dace_series({name}), planets_bank_series({name}), s.get("SpType"))
                x = planets_nightly(rows) if rows else np.zeros((0, 4))
                if len(x) >= 8:
                    for ev in events:
                        got = planets_single_velocities(ev["T"], ev["hours"] / 24.0, cover, x[:, 0], x[:, 1], np.hypot(x[:, 2], 1.0), x[:, 3])
                        ev.update(velocities=got)
                os.remove(path)
        except IOError as exc:
            print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
            continue
        except Exception as exc:
            rec["note"] = "%s: %s" % (type(exc).__name__, str(exc)[:200])
        archive_save(kept, json.dumps(rec, separators=(",", ":")).encode())
        print("%s: %s" % (name, rec.get("note") or "%d dips, ceiling %s%s" % (len(rec["events"]), rec["ceiling"], "".join("; T %.2f %g h %.0f ppm S/N %.1f%s" % (ev["T"], ev["hours"], ev["depth_ppm"], ev["snr"], " velocities P %.1f K %.1f fap %.4f" % (ev["velocities"]["P"], ev["velocities"]["K"], ev["velocities"]["fap"]) if ev.get("velocities") else "") for ev in rec["events"]))), flush=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("share done", flush=True)


def planets_singles_table():
    """The root's lone transits (planets_singles) as RESULTS/single_transits.csv: a star's that holds no more than two of them, each not within planets_SINGLE_SHARED_DAYS of those of planets_SINGLE_SHARED other stars, which the spacecraft's own events leave across its stars, strongest first, each with the orbit its star's velocities best give it and how far that orbit stands above the same search at other times. A list of candidates, each one event: no period is measured and no decision made."""
    rows = []
    for path in glob.glob(os.path.join(planets_RESULTS, "singles", "*.json")):
        rec = planets_load_json(path) or {}
        for e in rec.get("events", []):
            rows.append(dict(star=rec["name"], tic=rec.get("tic"), T_btjd=e["T"], hours=e["hours"], depth_ppm=e["depth_ppm"], snr=e["snr"], dips_on_star=len(rec["events"]), **{"velocity_" + k: (e.get("velocities") or {}).get(k, "") for k in ("P", "K", "eK", "fap", "nights", "span_d")}))
    times = np.array(sorted(r["T_btjd"] for r in rows))
    kept = []
    for r in rows:
        others = np.searchsorted(times, r["T_btjd"] + planets_SINGLE_SHARED_DAYS) - np.searchsorted(times, r["T_btjd"] - planets_SINGLE_SHARED_DAYS) - 1
        if r["dips_on_star"] <= 2 and others < planets_SINGLE_SHARED:
            kept.append(r)
    kept.sort(key=lambda r: -r["snr"])
    if rows:
        planets_write(os.path.join(planets_RESULTS, "single_transits.csv"), kept, list(rows[0].keys()))
    return kept


def planets_lightcurve_drop(name):
    """A star's kept light curve (eclipses_fetch) removed, where it is held and no other process is reading it."""
    try:
        os.remove(os.path.join(eclipses_ROOT, "lightcurves", name + ".npz"))
    except OSError:
        pass


def planets_transit_search_all(part=None):
    """Every census star of the share PART searched for transits (planets_transit_search) from light curves fetched for it and removed after it, the transits of the TOIs and community TOIs
    within an arcminute of it set aside (planets_transit_known), those the current search has searched passed over (planets_transit_current), and each star's
    candidates validated as soon as it is searched (planets_validate_transits); the share ends between stars once this file is replaced or the
    results' disk runs low, or a pause is asked for (planets_search_ends)."""
    names, stars, _, _ = planets_share(part)
    for name in names:
        if planets_search_ends():
            sys.exit(3)
        if planets_transit_current(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")):
            continue
        s = stars[name]
        try:
            ra, dec = float(s["RAJ2000"]), float(s["DEJ2000"])
            planets_lightcurve_drop(name)
            planets_transit_search(name, ra, dec, mask=planets_transit_known(ra=ra, dec=dec))
            planets_validate_transits(names=[name])
        except Exception as exc:
            print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
        planets_lightcurve_drop(name)
        # the device memory each star cached handed back, so that the shares running side by side stay within the card
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()


def planets_null_summary():
    """The search's own vetting's yield in the light curves turned upside down against the same stars' right way up, to RESULTS/null_search.json: of the signals past planets_transit_hopeless, as a planet's or as a binary's (odd and even depths
    that differ or a dip half an orbit on, at 3 sigma), how many each holds by signal-to-noise, by period and by kind of light curve, and for each group the upside-down's share of the right way up's, the share of those signals noise alone accounts for; and what the decision makes of those signals each way up (planets_transit_rows), with the validations the noise's own weighing gave them (planets_null_weigh)."""
    folder = os.path.join(planets_RESULTS, "transitsearch_inverted")
    groups = dict(snr=((9.0, 10.0), (10.0, 12.0), (12.0, 15.0), (15.0, 20.0), (20.0, 30.0), (30.0, 1e9)), period=((0.0, 1.0), (1.0, 3.0), (3.0, 7.0), (7.0, 13.0), (13.0, 1e9)))
    tally, stars = {}, 0
    past = ({}, {})

    def add(which, rec):
        for i, g in enumerate(rec.get("signals", [])):
            if planets_transit_hopeless(rec, i, g):
                continue
            past[which].setdefault(rec["name"], set()).add(i + 1)
            klass = "binary" if (g["odd_even_sigma"] or 0.0) >= 3.0 or (g["secondary_sigma"] or 0.0) >= 3.0 else "planet"
            for name, value in (("snr", g["snr"]), ("period", g["P"])):
                for lo, hi in groups[name]:
                    if lo <= value < hi:
                        key = (klass, name, "%g-%g" % (lo, hi))
                        tally.setdefault(key, [0, 0])[which] += 1
            key = (klass, "light curves", str(rec.get("light_curves")))
            tally.setdefault(key, [0, 0])[which] += 1
    with os.scandir(folder) as it:
        for e in it:
            if not e.name.endswith(".json"):
                continue
            noise, real = planets_load_json(e.path), planets_load_json(os.path.join(planets_RESULTS, "transitsearch", e.name))
            if noise and real and "inverted_snr" in noise:
                stars += 1
                add(0, real), add(1, noise)
    decided = dict(right_way_up={}, upside_down={})
    for which, search, weighed, label in ((0, "transitsearch", "validate_transits", "right_way_up"), (1, "transitsearch_inverted", "validate_inverted", "upside_down")):
        for r in planets_transit_rows({}, sorted(past[which]), search=search, weighed=weighed, shared=False):
            if int(r["label"].split()[-1]) in past[which][r["name"]]:
                key = "%s %s" % (r["object"], r["status"]) if r["status"] != "rejected" else "rejected: %s" % r["reason"]
                decided[label][key] = decided[label].get(key, 0) + 1
    out = dict(stars=stars, finished=time.strftime("%Y-%m-%d %H:%M:%S"), decided=decided, groups=[dict(klass=k[0], by=k[1], group=k[2], right_way_up=v[0], upside_down=v[1], share=round(v[1] / v[0], 3) if v[0] else None) for k, v in sorted(tally.items())])
    archive_save(os.path.join(planets_RESULTS, "null_search.json"), json.dumps(out, separators=(",", ":")).encode())
    return out


# what a stored search of the TESS stage says of its star
planets_SEARCH_DETAILS = ("tic", "light_curves", "ra", "dec", "tmag", "teff", "logg", "rstar", "mstar")


def planets_sample_pass(part, stars, seed, kept, into, search):
    """The stars of a sample of those the TESS root has searched, STARS drawn at random with SEED and kept in RESULTS/KEPT, more drawn beside them where fewer are kept, each searched again into RESULTS/INTO by SEARCH(its stored search, its light curves' file, a folder of its own) where no record stands there, a star without a search or for which SEARCH returns False noted. Each is claimed by a folder under RESULTS/<INTO>_claims while it is searched, so that processes side by side search it once, a claim an hour old being taken over. PART takes the share K/N; the pass runs for planets_DR4_PASS seconds at most and comes round again, and ends between stars where a long search would, with exit status 3. Returns the stars searched."""
    folder, listed = os.path.join(planets_RESULTS, "transitsearch"), os.path.join(planets_RESULTS, kept)
    names = planets_load_json(listed) or []
    if len(names) < stars:
        with os.scandir(folder) as it:
            every = sorted(set(e.name[:-5] for e in it if e.name.endswith(".json")) - set(names))
        names = names + random.Random(seed + len(names)).sample(every, min(stars - len(names), len(every)))
        archive_save(listed, json.dumps(names).encode())
    if part:
        k, n = (int(x) for x in part.split("/"))
        names = names[k::n]
    records, claims = os.path.join(planets_RESULTS, into), os.path.join(planets_RESULTS, into + "_claims")
    os.makedirs(records, exist_ok=True)
    os.makedirs(claims, exist_ok=True)
    started, done = time.time(), 0
    for tag in names:
        stored = os.path.join(records, tag + ".json")
        if os.path.exists(stored):
            continue
        if planets_search_ends():
            sys.exit(3)
        if time.time() - started > planets_DR4_PASS:
            break
        claim = os.path.join(claims, tag)
        try:
            os.mkdir(claim)
        except FileExistsError:
            if time.time() - os.path.getmtime(claim) < 3600:
                continue
        rec = planets_load_json(os.path.join(folder, tag + ".json"))
        note = dict(name=(rec or {}).get("name", tag), note="no search")
        try:
            if rec and not rec.get("note") and rec.get("tic"):
                path, _ = planets_tess_lightcurves(int(rec["tic"]), claim, 0 if rec.get("light_curves") == "SPOC" else 1)
                if path and search(rec, path, claim):
                    done += 1
                    note = None
            if note:
                archive_save(stored, json.dumps(note).encode())
        except Exception as exc:
            print("%s: %s: %s" % (tag, type(exc).__name__, str(exc)[:200]), flush=True)
        finally:
            shutil.rmtree(claim, ignore_errors=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    return done


def planets_null_weigh(part=None):
    """The signals past the search's own vetting in the light curves upside down weighed as a search's candidates are (planets_validate_transits with INVERT), to RESULTS/validate_inverted, so that the decision's whole road is measured against noise; a record made before it kept its star's details takes them from the star's real search. PART takes the share K/N of the stars."""
    folder, names = os.path.join(planets_RESULTS, "transitsearch_inverted"), []
    with os.scandir(folder) as it:
        for e in it:
            rec = planets_load_json(e.path) if e.name.endswith(".json") else None
            if not rec or "inverted_snr" not in rec or all(planets_transit_hopeless(rec, i, g) for i, g in enumerate(rec.get("signals", []))):
                continue
            if "rstar" not in rec:
                real = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", e.name)) or {}
                rec.update({k: real[k] for k in planets_SEARCH_DETAILS if k in real})
                archive_save(e.path, json.dumps(rec, separators=(",", ":")).encode())
            names.append(rec["name"])
    names.sort()
    if part:
        k, n = (int(x) for x in part.split("/"))
        names = names[k::n]
    if names:
        planets_validate_transits(names=names, search="transitsearch_inverted", weighed="validate_inverted", invert=True)


def planets_null_search(part=None, stars=20000, seed=17):
    """The TESS root's search measured against noise alone, as Kepler's was with its inverted light curves (Thompson et al. 2018): STARS stars drawn once at random from those it has searched, kept in RESULTS/null_stars.json, each star's light curves turned upside down and
    searched as the real ones were (planets_transit_search with INVERT), over the same periods with the same transits set aside, and what passes the search's own vetting weighed as a candidate is (planets_null_weigh). No star's dip survives that, so what the vetting and the decision let through there is noise's, set against the same stars' real signals in RESULTS/null_search.json
    (planets_null_summary). PART takes the share K/N; the pass runs for planets_DR4_PASS seconds at most and comes round again, and ends between stars where a long search would, with exit status 3."""
    if not os.path.exists(planets_path("tess.json")):
        return

    def search(rec, path, cache):
        planets_transit_search(rec["name"], rec.get("ra"), rec.get("dec"), pmin=rec["pmin"], pmax=rec["pmax"], path=path, mask=[(P, t0, D / 24.0) for P, t0, D in rec.get("masked", [])], extra={k: rec[k] for k in planets_SEARCH_DETAILS if k in rec}, invert=True, longest=rec.get("longest", 0.0))
        return True
    done = planets_sample_pass(part, stars, seed, "null_stars.json", "transitsearch_inverted", search)
    if os.path.isdir(os.path.join(planets_RESULTS, "transitsearch_inverted")):
        planets_null_weigh(part)
        s = planets_null_summary()
        print("%d stars searched upside down, %d in all so far: %s" % (done, s["stars"], "; ".join("%s %s %s: %d right way up, %d upside down" % (x["klass"], x["by"], x["group"], x["right_way_up"], x["upside_down"]) for x in s["groups"])), flush=True)


# the transits laid into the TESS root's stars' light curves: the signal-to-noise and the period, each drawn evenly in its log between these, the largest radius ratio, the limb darkening and the furthest impact parameter
planets_INJECT_SNR, planets_INJECT_P, planets_INJECT_K, planets_INJECT_LIMB, planets_INJECT_B = (7.0, 40.0), (0.5, 60.0), 0.25, (0.4, 0.25), 0.9


def planets_inject_light(x, t, exposure=0.0, samples=1):
    """The relative flux at times T (BTJD) of the transit X (planets_inject_lay), each time averaged over SAMPLES instants across EXPOSURE days (gpu_transit)."""
    fold = ((np.asarray(t, float) - x["t0_btjd"]) / x["P"] + 0.5) % 1.0 * x["P"] - 0.5 * x["P"]
    one = lambda v: np.array([v], float)
    return gpu_host(gpu_transit(fold, one(x["k"]), one(x["P"]), one(x["a_r"]), one(math.acos(x["b"] / x["a_r"])), one(0.0), one(0.5 * math.pi), one(planets_INJECT_LIMB[0]), one(planets_INJECT_LIMB[1]), exposure, samples))[0].astype(float)


def planets_inject_lay(path, out, rstar, mstar, rng):
    """One planet's transits laid into a star's light curves, the file PATH (planets_tess_lightcurves) written again to the file OUT: a circular orbit about a star of RSTAR and MSTAR solar radii and masses, one each where they are unknown, its period, epoch and impact parameter drawn with the generator RNG (planets_INJECT_P, planets_INJECT_B) until the light curves hold three transits of it or more, and its radius ratio set by the signal-to-noise drawn (planets_INJECT_SNR), the mean depth in its transits times the root of their ten-minute points over the light curves' scatter as the search reads them (planets_transit_flux), and held to planets_INJECT_K. Returns the orbit; None where the light curves hold no such orbit a planet's radius could bring to the least signal-to-noise."""
    got = planets_transit_flux(path)
    if got is None:
        return None
    t, _, sd, _ = got
    R, M = rstar if rstar and rstar > 0 else 1.0, mstar if mstar and mstar > 0 else 1.0
    for _ in range(50):
        P = math.exp(rng.uniform(math.log(planets_INJECT_P[0]), math.log(planets_INJECT_P[1])))
        t0, b = float(t.min()) + rng.uniform(0.0, P), rng.uniform(0.0, planets_INJECT_B)
        a = 215.032 * (M * (P / 365.25) ** 2) ** (1.0 / 3.0) / R
        if a < 1.5:
            continue
        D = P / math.pi * math.asin(min(1.0, math.sqrt(1.0 - b * b) / a))
        inn = np.abs(((t - t0) / P + 0.5) % 1.0 * P - 0.5 * P) < 0.5 * D
        if not inn.any():
            continue
        held = np.unique(np.round((t[inn] - t0) / P), return_counts=True)[1]
        most = planets_INJECT_K ** 2 * math.sqrt(inn.sum()) / sd
        if (held >= 2).sum() >= 3 and most > planets_INJECT_SNR[0]:
            break
    else:
        return None
    snr = math.exp(rng.uniform(math.log(planets_INJECT_SNR[0]), math.log(min(planets_INJECT_SNR[1], most))))
    want = snr * sd / math.sqrt(inn.sum())
    x = dict(P=round(P, 6), t0_btjd=round(t0, 5), b=round(b, 3), a_r=round(a, 3), k=math.sqrt(want), snr=round(snr, 2), transits=int((held >= 2).sum()), duration_h=round(24.0 * D, 3), depth_ppm=round(1e6 * want, 1))
    for _ in range(4):
        x["k"] = x["k"] * math.sqrt(want / max(1.0 - float(np.mean(planets_inject_light(x, t[inn]))), 1e-9))
    x["k"] = round(x["k"], 5)
    with np.load(path) as d:
        flux = d["flux"].copy()
        for c in np.unique(d["cadence"]):
            m = d["cadence"] == c
            flux[m] *= planets_inject_light(x, d["time"][m], float(c) / 1440.0, max(1, min(7, int(math.ceil(float(c) / 2.0)))))
        np.savez(out, time=d["time"], flux=flux, err=d["err"], sector=d["sector"], cadence=d["cadence"])
    return x


def planets_inject_found(rec):
    """The signal of a search with a transit laid in (planets_inject_search) that is that transit: its index, itself and its period's share of the transit's, the first at the transit's period, a half or a third of it, or twice or three times it, within 1 per cent, whose own transits lie within a duration of the transit's; None where the search holds none."""
    x = rec["injected"]
    for i, g in enumerate(rec.get("signals", [])):
        for m in (1.0, 0.5, 1.0 / 3.0, 2.0, 3.0):
            q = min(g["P"], x["P"])
            if abs(g["P"] / (m * x["P"]) - 1.0) < 0.01 and abs(((g["t0_btjd"] - x["t0_btjd"]) / q + 0.5) % 1.0 - 0.5) * q < max(g["duration_h"], x["duration_h"]) / 24.0:
                return i, g, m
    return None


def planets_inject_summary():
    """What the search and its vetting make of the transits laid in, to RESULTS/inject_search.json: of those laid, by signal-to-noise, period, transits covered, length and kind of light curve, how many the search finds at their period or a share of it (planets_inject_found), how many pass its vetting (planets_transit_fault), what turned the rest down, and the percentiles of how much of a found signal its strongest transit leaves (planets_transit_left)."""
    folder = os.path.join(planets_RESULTS, "transitsearch_injected")
    rows = []
    with os.scandir(folder) as it:
        for e in it:
            rec = planets_load_json(e.path) if e.name.endswith(".json") else None
            x = (rec or {}).get("injected")
            if not x or rec.get("note"):
                continue
            hit = planets_inject_found(rec)
            row = dict(kind=str(rec.get("light_curves")), snr=x["snr"], period=x["P"], transits=x["transits"], hours=x["duration_h"], found=bool(hit), fault="not found", left=None)
            if hit:
                g = hit[1]
                alias = planets_transit_alias(g) if (g["odd_even_sigma"] or 0.0) >= 3.0 or planets_transit_scatter(g) < 7.1 else None
                row.update(fault=planets_transit_fault(rec, hit[0], g), left=round(planets_transit_left(alias or g), 3))
            rows.append(row)

    def tally(sel):
        faults, found = {}, [r for r in sel if r["found"]]
        for r in sel:
            if r["fault"]:
                faults[r["fault"]] = faults.get(r["fault"], 0) + 1
        left = [r["left"] for r in found if r["left"] is not None]
        return dict(laid=len(sel), found=len(found), past=sum(1 for r in sel if not r["fault"]), faults=faults, left_5_25_50=[round(float(q), 3) for q in np.percentile(left, [5, 25, 50])] if left else None)
    by = dict(snr=((7.0, 9.0), (9.0, 12.0), (12.0, 16.0), (16.0, 24.0), (24.0, 41.0)), period=((0.0, 1.0), (1.0, 3.0), (3.0, 7.0), (7.0, 13.0), (13.0, 20.0), (20.0, 61.0)), transits=((3, 4), (4, 6), (6, 9), (9, 16), (16, 41), (41, 1000000)), hours=((0.0, 2.0), (2.0, 4.0), (4.0, 6.0), (6.0, 9.0), (9.0, 13.0), (13.0, 1000.0)))
    out = dict(stars=len(rows), finished=time.strftime("%Y-%m-%d %H:%M:%S"), all=tally(rows), groups=[dict(by=name, group="%g-%g" % (lo, hi), **tally([r for r in rows if lo <= r[name] < hi])) for name, bins in by.items() for lo, hi in bins])
    out["groups"] += [dict(by="kind", group=k, **tally([r for r in rows if r["kind"] == k])) for k in sorted({r["kind"] for r in rows})]
    archive_save(os.path.join(planets_RESULTS, "inject_search.json"), json.dumps(out, separators=(",", ":")).encode())
    return out


def planets_inject_search(part=None, stars=4000, seed=29):
    """The TESS root's search measured against planets' transits laid into its own stars' light curves, as Kepler's was (Christiansen et al. 2020): STARS stars drawn once at random from those it has searched, kept in RESULTS/inject_stars.json, each star's light curves given one planet's transits (planets_inject_lay) on an orbit and at a signal-to-noise of its own, and searched as the real ones were (planets_transit_search), over the same periods with the same transits set aside, to RESULTS/transitsearch_injected/<star>.json with the orbit under injected, what the search and its vetting recover being RESULTS/inject_search.json (planets_inject_summary). PART takes the share K/N; the pass runs for planets_DR4_PASS seconds at most and comes round again, and ends between stars where a long search would, with exit status 3."""
    if not os.path.exists(planets_path("tess.json")):
        return

    def search(rec, path, cache):
        laid = os.path.join(cache, "laid.npz")
        x = planets_inject_lay(path, laid, rec.get("rstar"), rec.get("mstar"), np.random.default_rng(zlib.crc32(rec["name"].encode())))
        if not x:
            return False
        planets_transit_search(rec["name"], rec.get("ra"), rec.get("dec"), pmin=rec["pmin"], pmax=rec["pmax"], path=laid, mask=[(P, t0, D / 24.0) for P, t0, D in rec.get("masked", [])], extra=dict({k: rec[k] for k in planets_SEARCH_DETAILS if k in rec}, injected=x), longest=rec.get("longest", 0.0), into="transitsearch_injected")
        return True
    done = planets_sample_pass(part, stars, seed, "inject_stars.json", "transitsearch_injected", search)
    if os.path.isdir(os.path.join(planets_RESULTS, "transitsearch_injected")):
        s = planets_inject_summary()
        print("%d stars given a transit, %d in all so far: %s" % (done, s["stars"], s["all"]), flush=True)


def planets_tess_lightcurves(tic, folder, kind=0):
    """A TIC star's light curves of KIND, SPOC's at two minutes (0) or TESS-SPOC's from the full-frame images (1), read from MAST's bucket
    (planets_tess_index) without keeping them, each sector's PDCSAP flux of quality zero divided by its median, written to FOLDER/<tic>.npz as
    eclipses_fetch writes a star's with each sector's cadence: the file's path, or None where there is none, and the star's position, TESS
    magnitude, temperature, gravity, radius and mass from the first light curve's header, the mass from the gravity and radius."""
    from astropy.io import fits
    tics, secs, kinds, sectors = planets_tess_index()
    a, b = int(np.searchsorted(tics, tic)), int(np.searchsorted(tics, tic, side="right"))
    keep = sorted(s for s, k in zip(secs[a:b].tolist(), kinds[a:b].tolist()) if k == kind and s in sectors)
    T, F, E, S, C, head = [], [], [], [], [], {}
    for s in keep:
        raw = archive_get(planets_TESS_BUCKET + planets_tess_key(tic, s, kind, sectors), timeout=300, soft=True)
        if not raw:
            continue
        with fits.open(io.BytesIO(raw)) as h:
            H, d = h[0].header, h["LIGHTCURVE"].data
            t, f, e, q = (np.asarray(d[k], float) for k in ("TIME", "PDCSAP_FLUX", "PDCSAP_FLUX_ERR", "QUALITY"))
            if not head:
                head = {k: archive_num(H.get(c)) for k, c in (("ra", "RA_OBJ"), ("dec", "DEC_OBJ"), ("tmag", "TESSMAG"), ("teff", "TEFF"), ("logg", "LOGG"),
                                                              ("rstar", "RADIUS"))}
        ok = np.isfinite(t) & np.isfinite(f) & np.isfinite(e) & (e > 0) & (q == 0)
        if ok.sum() < 100:
            continue
        med = np.median(f[ok])
        # the cadence in minutes: two for SPOC, and TESS-SPOC's thirty, ten and 200 seconds through sectors 26, 55 and after
        cadence = 2.0 if kind == 0 else 30.0 if s <= 26 else 10.0 if s <= 55 else 200.0 / 60.0
        T.append(t[ok]), F.append(f[ok] / med), E.append(e[ok] / med), S.append(np.full(int(ok.sum()), s)), C.append(np.full(int(ok.sum()), cadence))
    if head.get("logg") and head.get("rstar"):
        head["mstar"] = round(10.0 ** (head["logg"] - 4.438) * head["rstar"] ** 2, 3)
    if not T:
        return None, head
    os.makedirs(folder, exist_ok=True)
    path = os.path.join(folder, "%d.npz" % tic)
    np.savez(path, time=np.concatenate(T), flux=np.concatenate(F), err=np.concatenate(E), sector=np.concatenate(S), cadence=np.concatenate(C))
    return path, head


# the faintest TESS magnitude the stage searches among the stars only TESS-SPOC's full-frame light curves hold
planets_FFI_FAINTEST = 14.0


def planets_tess_search(part=None, ffi=False, skip=0):
    """TESS's stars with SPOC two-minute light curves, or with FFI those TESS-SPOC's full-frame light curves hold and SPOC's do not, searched blind for
    transits one at a time: those observed in thirteen sectors or fewer first, the most observed of them first, then those observed in more, of the
    share K/N where PART is given, the first SKIP passed over, so that a second machine works far from the first. Each star is claimed by a folder of its name under RESULTS/transitsearch_claims, so that any number of processes
    can take stars side by side, a claim an hour old being taken over; its light curves are read from MAST's bucket (planets_tess_lightcurves) into
    its claim, the transits of its TOIs and community TOIs set aside (planets_transit_known), the star searched (planets_transit_search) as TIC
    <number> with its header's details, its light curves deleted and its candidates validated (planets_validate_transits); a full-frame star fainter
    than planets_FFI_FAINTEST is noted and not searched. A star the current search has searched is passed over (planets_transit_current), and the
    process ends between stars once this file is replaced, the results' disk runs low, or a pause is asked for (planets_search_ends). A star whose stored
    record does not answer within five minutes is noted in RESULTS/transitsearch_hung.txt and passed over, since an open held in the kernel ends only with the machine's restart."""
    tics, secs, kinds, sectors = planets_tess_index()
    ids, counts = np.unique(tics[kinds == (1 if ffi else 0)], return_counts=True)
    if ffi:
        keep = ~np.isin(ids, tics[kinds == 0])
        ids, counts = ids[keep], counts[keep]
    order = ids[np.lexsort((ids, -counts, counts > 13))]
    if part:
        k, n = (int(x) for x in part.split("/"))
        order = order[k::n]
    claims = os.path.join(planets_RESULTS, "transitsearch_claims")
    os.makedirs(claims, exist_ok=True)
    hung = os.path.join(planets_RESULTS, "transitsearch_hung.txt")
    left = set(open(hung).read().split()) if os.path.exists(hung) else set()
    for tic in order[skip:].tolist():
        name = "TIC %d" % tic
        if planets_search_ends():
            sys.exit(3)
        if archive_tag(name) in left:
            continue
        current = planets_call(planets_transit_current, 300.0, os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json"))
        if current is None:
            left.add(archive_tag(name))
            with open(hung, "a") as fh:
                fh.write(archive_tag(name) + "\n")
            print("%s: its stored record does not answer: passed over" % name, flush=True)
        if current is not False:
            continue
        claim = os.path.join(claims, archive_tag(name))
        try:
            os.mkdir(claim)
        except FileExistsError:
            if time.time() - os.path.getmtime(claim) < 3600:
                continue
        try:
            path, head = planets_tess_lightcurves(tic, claim, 1 if ffi else 0)
            extra = dict(head, tic=tic, light_curves="TESS-SPOC" if ffi else "SPOC")
            # a star of the full-frame light curves alone fainter than planets_FFI_FAINTEST is noted and left
            faint = ffi and (head.get("tmag") or 99.0) > planets_FFI_FAINTEST
            if path is None or faint:
                os.makedirs(os.path.join(planets_RESULTS, "transitsearch"), exist_ok=True)
                note = "fainter than T %g" % planets_FFI_FAINTEST if faint else "no %s light curve" % extra["light_curves"]
                archive_save(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json"),
                             json.dumps(dict(name=name, signals=[], note=note, **extra), separators=(",", ":")).encode())
                continue
            planets_transit_search(name, extra.get("ra"), extra.get("dec"), path=path, mask=planets_transit_known(tic=tic), extra=extra)
            os.remove(path)
            planets_validate_transits(names=[name])
        except Exception as exc:
            print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
        finally:
            shutil.rmtree(claim, ignore_errors=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()


def planets_tess_root(source):
    """The data root ROOT set up for the TESS stage (planets_tess_search): marked by planets/tess.json, with the empty census tables `followup` reads,
    and the tables every root shares copied from the data root SOURCE (planets_share_tables)."""
    os.makedirs(planets_path("tess"), exist_ok=True)
    os.makedirs(planets_RESULTS, exist_ok=True)
    empty = {"bank_stars.csv": ["recno", "Nrv", "Name", "RAJ2000", "DEJ2000", "SpType", "Teff", "Bmag", "Vmag", "Gmag", "Dist", "SimbadName"],
             "bank_velocities.csv": ["Name", "BJD", "DRVmlcnzp", "e_DRVmlcnzp", "CRX", "e_CRX", "dLW", "e_dLW", "Halpha", "e_Halpha", "NaD1", "NaD2", "FWHMDRS",
                                     "BIS", "SNRDRS"],
             "dace.csv": planets_DACE_KEYS}
    for name, keys in empty.items():
        if not os.path.exists(planets_path(name)):
            planets_write(planets_path(name), [], keys)
    for name, keys in (("signals.csv", planets_SIGNAL_KEYS), ("stars.csv", ["name"])):
        if not os.path.exists(os.path.join(planets_RESULTS, name)):
            planets_write(os.path.join(planets_RESULTS, name), [], keys)
    planets_share_tables(source, archive_DATA)
    json.dump(dict(stage="tess", source="SPOC two-minute light curves"), open(planets_path("tess.json"), "w"))
    print("TESS root ready", flush=True)


def planets_transit_scatter(g, split=False):
    """A blind-search signal G's signal-to-noise against the scatter of its transits' depths: its signal-to-noise divided by the root of the
    chi-square per degree of freedom of the depths about their weighted mean, the odd and the even transits' each where SPLIT is set, where that
    chi-square lies beyond its 1e-3 false-alarm level, each transit's error the light curve's noise over the root of its points, scaled from the
    transits measured at a signal-to-noise of one or more; its signal-to-noise as it stands otherwise."""
    from scipy.stats import chi2
    ev = g["events"]
    scale = sorted(abs(e["depth_ppm"] / e["snr"]) * math.sqrt(e["points"]) for e in ev if abs(e["snr"]) >= 1.0)
    groups = [[e for e in ev if e["epoch"] % 2 == k] for k in (0, 1)] if split else [ev]
    dof = len(ev) - len([x for x in groups if x])
    if len(ev) < 3 or not scale or dof < 1:
        return g["snr"]
    c2 = 0.0
    for x in groups:
        if x:
            w = np.array([e["points"] for e in x], float) / scale[len(scale) // 2] ** 2
            d = np.array([e["depth_ppm"] for e in x], float)
            c2 += float((w * (d - (w * d).sum() / w.sum()) ** 2).sum())
    return g["snr"] if chi2.sf(c2, dof) >= 1e-3 else g["snr"] / math.sqrt(c2 / dof)


# The eclipsing binaries VizieR holds beyond VSX and SIMBAD, each table by its J2000 positions: TESS's from its two-minute light curves (Prsa et al.
# 2022) and from its full-frame images, new and known (Kostov et al. 2025), those of its OBA and OBAF stars (IJspeert et al. 2021, 2024), its EA-type
# ones (Shi et al. 2022), those with LAMOST spectra (Shi et al. 2025), and Kepler's (Kirk et al. 2016)
planets_EB_TABLES = ("J/ApJS/258/16/tess-ebs", "J/ApJS/279/50/table3", "J/ApJS/279/50/table4", "J/A+A/652/A120/eb-cat", "J/A+A/691/A242/obaf-eb1",
                     "J/ApJS/259/50/table1", "J/ApJS/280/26/table1", "J/AJ/151/68/catalog")
# VizieR's sites, its mirrors before its home; not every mirror holds every catalogue
planets_VIZIER_SITES = ("http://vizier.nao.ac.jp", "https://vizier.cfa.harvard.edu", "https://vizier.idia.ac.za", "http://vizier.china-vo.org", "https://vizier.cds.unistra.fr")


# the stars the TESS Ten Thousand catalogue's network found eclipse-like, unvetted (Kostov et al. 2025)
planets_EB_CANDIDATES = ("J/ApJS/279/50/table2",)

# the variable-star catalogues the known check reads from the VizieR mirror, each as (label, catalogue, its tables, its name columns, its type column, its period columns, its frequency column, and which of its rows
# are binaries: every one, none, or those whose type matches a pattern): VSX; ASAS-SN's (Jayasinghe et al. 2019, 2021); ATLAS's (Heinze et al. 2018); ZTF's periodic variables (Chen et al. 2020); and Gaia DR3's classified
# variables, eclipsing binaries, RR Lyrae stars and rotation periods (Rimoldini et al. 2023, Mowlavi et al. 2023, Clementini et al. 2023, Distefano et al. 2023)
planets_VARIABLES = (("VSX", "B/vsx", ("vsx",), ("Name",), "Type", ("Period",), None, r"(^|[|+/])(E|EA|EB|EW|EC|ELL|R|HB|RS):?($|[|+/])"),
                     ("ASAS-SN", "II/366", ("catv2021",), ("ASASSN-V", "OName", "ID"), "Type", ("Per",), None, r"^(E|EA|EB|EW|ELL|RS)"),
                     ("ATLAS", "J/AJ/156/241", ("table4",), ("ATOID",), "Class", ("fp-period", "ls-Pday"), None, r"^(CBF|CBH|DBF|DBH)$"),
                     ("ZTF", "J/ApJS/249/18", ("table2", "table3"), ("ID",), "Type", ("Per", "Per-g", "Per-r"), None, r"^(EA|EW|RSCVN)$"),
                     ("Gaia DR3", "I/358", ("vclassre",), ("Source",), "Class", (), None, r"^(ECL|RS)$"),
                     ("Gaia DR3 eclipsing", "I/358", ("veb",), ("Source",), None, (), "Freq", True),
                     ("Gaia DR3 RR Lyrae", "I/358", ("vrrlyr",), ("Source",), None, ("PF", "P1O"), None, False),
                     ("Gaia DR3 rotation", "I/358", ("vrm",), ("Source",), None, ("Prot",), None, False))
planets_VARIABLE_ARRAYS = {}


def planets_variable_arrays(label, catalogue, tables, names, tcol, pcols, fcol):
    """A catalogue of planets_VARIABLES as arrays sorted by declination, built once from the VizieR mirror and kept beside the data roots in vizier_index/, read by memory map so that processes side by side share them: the declinations, and
    each row's right ascension, name, type and periods in days, a frequency given as its period and a missing period NaN."""
    if label not in planets_VARIABLE_ARRAYS:
        import pyarrow as pa
        import pyarrow.compute as pc
        folder = os.path.join(os.path.dirname(archive_DATA), "vizier_index")
        tag = archive_tag(label)
        path, decs = os.path.join(folder, tag + ".npy"), os.path.join(folder, tag + ".dec.npy")
        if not (os.path.exists(path) and os.path.exists(decs)):
            parts = []
            for table in tables:
                t = archive_vizier(catalogue, table)
                text = lambda c: pc.cast(t[c], pa.string()) if c in t.column_names else pa.nulls(t.num_rows, pa.string())
                number = lambda c: t[c].to_numpy(zero_copy_only=False).astype(float) if c in t.column_names else np.full(t.num_rows, np.nan)
                name = text(names[0])
                for c in names[1:]:
                    name = pc.coalesce(name, text(c))
                periods = [number(c) for c in pcols]
                if fcol:
                    with np.errstate(divide="ignore", invalid="ignore"):
                        periods.append(1.0 / number(fcol))
                as_bytes = lambda a: pa.chunked_array([pc.cast(pc.fill_null(a, ""), pa.binary())]) if isinstance(a, pa.Array) else pc.cast(pc.fill_null(a, ""), pa.binary())
                parts.append(dict(ra=number("RAdeg"), dec=number("DEdeg"), name=as_bytes(pc.utf8_trim_whitespace(name)), kind=as_bytes(text(tcol) if tcol else pa.nulls(t.num_rows, pa.string())),
                                  periods=np.column_stack(periods) if periods else np.zeros((t.num_rows, 0))))
                archive_VIZIER_CACHE.clear()
            longest = lambda key: max(int(pc.max(pc.binary_length(p[key])).as_py() or 1) for p in parts)
            x = np.zeros(sum(len(p["ra"]) for p in parts), dtype=[("ra", "f8"), ("dec", "f8"), ("name", "S%d" % longest("name")), ("kind", "S%d" % longest("kind")), ("periods", "f8", (max(parts[0]["periods"].shape[1], 1),))])
            at = 0
            for p in parts:
                n = len(p["ra"])
                x["ra"][at:at + n], x["dec"][at:at + n] = p["ra"], p["dec"]
                x["name"][at:at + n], x["kind"][at:at + n] = p["name"].to_pylist(), p["kind"].to_pylist()
                x["periods"][at:at + n] = p["periods"] if p["periods"].shape[1] else np.nan
                at += n
            x = x[np.isfinite(x["ra"]) & np.isfinite(x["dec"])]
            x = x[np.argsort(x["dec"], kind="stable")]
            os.makedirs(folder, exist_ok=True)
            for where, what in ((path, x), (decs, x["dec"].copy())):
                tmp = archive_tmp(where)
                with open(tmp, "wb") as fh:
                    np.save(fh, what)
                archive_place(tmp, where)
        planets_VARIABLE_ARRAYS[label] = (np.load(decs, mmap_mode="r"), np.load(path, mmap_mode="r"))
    return planets_VARIABLE_ARRAYS[label]


def planets_variables_near(ra, dec, radius):
    """The variable stars the catalogues of planets_VARIABLES hold within RADIUS arcsec of a J2000 position RA, DEC (planets_variable_arrays): rows of (catalogue, name, periods in days, whether a binary, separation in arcsec, the catalogue's
    type); an IOError where the mirror cannot be read."""
    rows = []
    cosd = math.cos(math.radians(dec))
    for label, catalogue, tables, names, tcol, pcols, fcol, rule in planets_VARIABLES:
        decs, x = planets_variable_arrays(label, catalogue, tables, names, tcol, pcols, fcol)
        part = x[int(np.searchsorted(decs, dec - radius / 3600.0)):int(np.searchsorted(decs, dec + radius / 3600.0))]
        sep = np.hypot(((part["ra"] - ra + 180.0) % 360.0 - 180.0) * cosd, part["dec"] - dec) * 3600.0
        for r, d in zip(part[sep <= radius], sep[sep <= radius].tolist()):
            kind = r["kind"].decode("utf-8", "replace")
            rows.append([label, r["name"].decode("utf-8", "replace") or "%s %.5f %+.5f" % (label, r["ra"], r["dec"]), [float(p) for p in r["periods"] if p > 0], rule if isinstance(rule, bool) else re.search(rule, kind) is not None, round(d, 1), kind])
    return rows


# what marks a star's rotation among the variable-star catalogues' types
planets_ROTATION_TYPES = r"(^|[|+/])(ROT|BY|BYDra):?($|[|+/])"


def planets_rotation_read(ra, dec):
    """The rotation periods (days) the variable-star catalogues hold of the star at a J2000 position RA, DEC within 10 arcsec (planets_variables_near): Gaia DR3's rotation table's and those of the types of planets_ROTATION_TYPES; none where its place is unknown or the catalogues cannot be read."""
    if not (math.isfinite(ra) and math.isfinite(dec)):
        return []
    try:
        rows = planets_variables_near(ra, dec, 10.0)
    except IOError:
        return []
    return sorted({p for x in rows if x[0] == "Gaia DR3 rotation" or re.search(planets_ROTATION_TYPES, x[5]) for p in x[2]})


def planets_eclipsing_binaries(tables=planets_EB_TABLES, name="eclipsing_binaries"):
    """The stars of the VizieR TABLES, by default the eclipsing binaries of planets_EB_TABLES, as rows of right ascension and declination (J2000, deg)
    and the table's place in TABLES, sorted by declination: each table read from VizieR's sites (archive_vizier_text), all
    kept in ROOT/<name>.npy; an error where a table cannot be had."""
    if name not in planets_EB:
        path = planets_path(name + ".npy")
        if not os.path.exists(path):
            rows = []
            for k, table in enumerate(tables):
                text = archive_vizier_text("-source=%s&-out=_RAJ,_DEJ&-out.max=unlimited&-oc.form=d" % table, 300, rows=True)
                if text is None:
                    raise IOError("no VizieR site answered for %s" % table)
                for line in text.splitlines():
                    parts = line.split("\t")
                    if len(parts) == 2 and not line.startswith("#"):
                        a, d = planets_num(parts[0]), planets_num(parts[1])
                        if math.isfinite(a) and math.isfinite(d):
                            rows.append((a, d, k))
            x = np.array(rows, float).reshape(-1, 3)
            os.makedirs(os.path.dirname(path), exist_ok=True)
            tmp = archive_tmp(path)
            with open(tmp, "wb") as fh:
                np.save(fh, x[np.argsort(x[:, 1])])
            archive_place(tmp, path)
        planets_EB[name] = np.load(path)
    return planets_EB[name]


planets_EB = {}


# the words of a paper's title that make the star it is linked to in SIMBAD a known binary
planets_BINARY_WORDS = ("eclips", "binar", "triple", "quadruple", "multiple system", "EBLM")


def planets_binary_known(ra, dec, P, exo=(), radius=60.0, simbad=archive_SIMBAD_BINARIES, candidates=True, names=(), literature=False):
    """What already knows of a binary found eclipsing at a J2000 position RA, DEC every P days, each named, within RADIUS arcsec: the variable stars of the
    catalogues (planets_variables_near) that are binaries or vary at P, half it or twice it within 1 per cent; SIMBAD's binaries of the types SIMBAD (archive_simbad_binaries);
    VizieR's eclipsing binaries (planets_eclipsing_binaries) and, where CANDIDATES is set, the TESS Ten Thousand catalogue's unvetted eclipse-like stars
    (planets_EB_CANDIDATES); of EXO, the TOIs and community TOIs as (label, ra, dec, period), those at P, half it or twice it within 1 per cent; and
    where LITERATURE is set, the papers SIMBAD links to the star by any of its NAMES whose titles hold one of planets_BINARY_WORDS."""
    if literature and any(names):
        papers = archive_simbad_papers([n for n in names if n], words=planets_BINARY_WORDS)
        found = sorted({b for rows in papers.values() for b, _, _ in rows})
        if found:
            return ["SIMBAD papers %s" % "; ".join(found[:5])]
    if not (math.isfinite(ra) and math.isfinite(dec)):
        return []
    cosd, w = math.cos(math.radians(dec)), radius / 3600.0
    near = lambda a, d: np.hypot(((a - ra + 180.0) % 360.0 - 180.0) * cosd, d - dec) * 3600.0 < radius
    band = lambda d: np.arange(np.searchsorted(d, dec - w), np.searchsorted(d, dec + w))
    with np.errstate(divide="ignore", invalid="ignore"):
        at = lambda q: np.any([np.abs(m * P / q - 1.0) < 0.01 for m in (0.5, 1.0, 2.0)], axis=0)
        out = sorted({"%s %s" % (cat, n) for cat, n, periods, is_binary, *_ in planets_variables_near(ra, dec, radius)
                      if is_binary or any(at(np.array([p]))[0] for p in periods)})
        x = archive_simbad_binaries()
        k = band(x[:, 1])
        out += sorted({"SIMBAD %s" % archive_SIMBAD_BINARIES[int(c)] for c in x[k[near(x[k, 0], x[k, 1])], 2]} &
                      {"SIMBAD %s" % s for s in simbad})
        for tables, name in ((planets_EB_TABLES, "eclipsing_binaries"),) + (((planets_EB_CANDIDATES, "eclipsing_candidates"),) if candidates else ()):
            x = planets_eclipsing_binaries(tables, name)
            k = band(x[:, 1])
            out += sorted({"VizieR %s" % tables[int(c)] for c in x[k[near(x[k, 0], x[k, 1])], 2]})
        out += [label for label, a_, d_, q in exo if near(np.array([a_]), np.array([d_]))[0] and at(np.array([q]))[0]]
    return out


# the arcseconds within which a variable star's light reaches a TESS star's aperture or the pixels its sky is read from
planets_NEIGHBOUR_RADIUS = 360.0
# the arcseconds within which a catalogued variable is the star itself, as the rule on a star's own catalogued binary takes it (planets_transit_rows)
planets_OWN_RADIUS = 10.0
# VSX's type for a star whose variation is its planet's transits
planets_VSX_TRANSIT = r"(^|[|+/])EP:?($|[|+/])"


def planets_variable_neighbours(ra, dec, P):
    """The catalogued variable stars (planets_variables_near) within planets_NEIGHBOUR_RADIUS of a J2000 position RA, DEC whose period lies within 0.2 per
    cent of P, its half or its double, named: a star whose light, inside the aperture or among the pixels its sky is read from, puts its own period
    into the light curve, or the star itself where it is catalogued as a binary. A star VSX types as a planet's transits, and any other entry within
    planets_OWN_RADIUS, is the candidate's own signal and is left out, as is an entry ATLAS itself classes as dubious. An IOError where the catalogues
    cannot be read."""
    if not (math.isfinite(ra) and math.isfinite(dec) and P > 0):
        return []
    at = lambda x: any(abs(m * P / p - 1.0) < 0.002 for p in x[2] for m in (0.5, 1.0, 2.0))
    return sorted({"%s %s" % (x[0], x[1]) for x in planets_variables_near(ra, dec, planets_NEIGHBOUR_RADIUS) if at(x) and not re.search(planets_VSX_TRANSIT, x[5]) and x[5].lower() != "dubious"
                   and (x[3] or x[4] >= planets_OWN_RADIUS)})


def planets_transit_sets(g):
    """The mean depth (ppm) and its error of a blind-search signal G's even transits and of its odd ones, each transit weighted by its points and
    each transit's error the light curve's noise over the root of its points, scaled from the transits measured at a signal-to-noise of one or more."""
    ev = g["events"]
    scale = sorted(abs(e["depth_ppm"] / e["snr"]) * math.sqrt(e["points"]) for e in ev if abs(e["snr"]) >= 1.0)
    out = []
    for k in (0, 1):
        x = [e for e in ev if e["epoch"] % 2 == k]
        n = sum(e["points"] for e in x)
        out.append((sum(e["depth_ppm"] * e["points"] for e in x) / n, scale[len(scale) // 2] / math.sqrt(n)) if n and scale else (float("nan"),) * 2)
    return out


def planets_binary_signal(g, split):
    """A blind-search signal G as its binary's eclipses: where SPLIT, odd and even eclipses of different depths, its period doubled and its epoch and
    depth those of the deeper set (planets_transit_sets); G as it stands otherwise."""
    if not split:
        return g
    (d0, _), (d1, _) = planets_transit_sets(g)
    k = int(d1 > d0)
    return dict(g, P=2.0 * g["P"], t0_btjd=round(g["t0_btjd"] + k * g["P"], 5), depth_ppm=round(max(d0, d1), 1))


def planets_binary_decision(v, x, twin=None):
    """An eclipsing binary's decision from its validation record V and its row X as a TESS candidate (planets_transit_candidate, the star's mass,
    radius and temperature with it): (status, reason). Rejected with the record's note where it holds no probabilities; where neither the dip half an
    orbit on, nor the search's second set of eclipses at the same period TWIN where there is one, lies 3 sigma or more beyond the deepest occultation
    a planet could give (planets_occultation_max), nor is the eclipsing body larger than two Jupiter radii; where the folded light is the star's own
    smooth variation rather than eclipses (planets_transit_smooth), or skewed dips that repeat at half the period (planets_transit_sawtooth); or where TRICERATOPS puts 0.1 per cent of the probability or more on the eclipses
    arising on a nearby or an unresolved background star. New otherwise."""
    if "fpp" not in v:
        return planets_validation_decision(v, x, None, {})[:2]
    if planets_transit_smooth(v) or planets_transit_sawtooth(v):
        return "rejected", "variability"
    most = planets_occultation_max(x, v.get("depth_ppm", 0.0), v.get("period", planets_num(x.get("Period (days)"))))
    sec, sig = v.get("depth_secondary_ppm"), v.get("secondary_sigma")
    excess = (sec - most) / (sec / sig) if sec and sig and sig > 0 else 0.0
    if twin and twin["depth_ppm"] > 0 and twin["snr"] > 0:
        excess = max(excess, (twin["depth_ppm"] - most) / (twin["depth_ppm"] / twin["snr"]))
    if not (excess >= 3.0 or planets_num(x.get("Planet Radius (R_Earth)")) >= 22.4):
        return "rejected", "no binary's eclipse"
    off = planets_source_cleared(v)[1] + sum(v.get("scenarios", {}).get(s, 0.0) for s in ("BTP", "BEB", "BEBx2P"))
    return ("new", "") if off < 0.001 and not planets_centroid_off(v) else ("rejected", "another star")


def planets_transit_velocities(name, sptype, g, mstar):
    """A blind-search signal G of the census star NAME weighed with the star's velocities in ROOT, chosen and cleaned as the census's are
    (planets_series) and averaged per night and series (planets_nightly), at the signal's own ephemeris (planets_transit_rv_fit) about a star of MSTAR
    solar masses: the fit, its series, and the share of a period by which the ephemeris may be off at the velocities' mean epoch, the epoch's error
    taken as the duration over twice the signal-to-noise and the period's as the root of two times that over the cycles its transits span; None where
    the star has fewer than six nights."""
    rows, labels = planets_series(name, planets_dace_series({name}), planets_bank_series({name}), sptype)
    if not rows:
        return None
    x = planets_nightly(rows)
    if len(x) < 6:
        return None
    # the transit's epoch from BTJD to MJD
    P, Tc = g["P"], g["t0_btjd"] + 56999.5
    times = [ev["time"] for ev in g["events"]]
    eTc = g["duration_h"] / 24.0 / (2.0 * max(g["snr"], 1.0))
    eP = math.sqrt(2.0) * eTc / max((max(times) - min(times)) / P, 1.0) if times else eTc
    fit = planets_transit_rv_fit(x[:, 0], x[:, 1], x[:, 2], x[:, 3], P, Tc, mstar)
    return dict(fit, series="; ".join(labels), phase_err=round(math.hypot(eTc, abs(float(x[:, 0].mean()) - Tc) / P * eP) / P, 4))


# TESS's orbit and its multiples to 100 days, and half of it, periods at which its systematics recur
planets_TESS_ORBITS = (6.85,) + tuple(13.7 * n for n in range(1, 8))


def planets_transit_alias(g):
    """A blind-search signal G whose transits fall on every second or every third of its epochs alone, as the signal at that multiple of its period
    with those transits, renumbered: the multiple and residue whose transits, three or more, are detected at the highest signal-to-noise and at 3
    sigma or more while the other epochs' lie within 3 sigma of no dip, each transit weighted by its points and its error the light curve's noise
    over the root of its points (planets_transit_sets); its signal-to-noise that of those transits together, its red-noise signal-to-noise scaled by
    their depth and number, its odd-even significance theirs, and alias the multiple; None where no multiple fits."""
    ev = g["events"]
    scale = sorted(abs(e["depth_ppm"] / e["snr"]) * math.sqrt(e["points"]) for e in ev if abs(e["snr"]) >= 1.0)
    if not scale or g["depth_ppm"] <= 0:
        return None
    s0 = scale[len(scale) // 2]
    mean = lambda x: (sum(e["depth_ppm"] * e["points"] for e in x) / sum(e["points"] for e in x), s0 / math.sqrt(sum(e["points"] for e in x)))
    best = None
    for m in (2, 3):
        for r in range(m):
            on, off = [e for e in ev if e["epoch"] % m == r], [e for e in ev if e["epoch"] % m != r]
            if len(on) < 3 or not off:
                continue
            (d, e), (d_off, e_off) = mean(on), mean(off)
            if d >= 3.0 * e and abs(d_off) < 3.0 * e_off and (best is None or d / e > best[0]):
                best = (d / e, m, r, on, d)
    if best is None:
        return None
    snr, m, r, on, d = best
    events = [dict(e, epoch=(e["epoch"] - r) // m) for e in on]
    sets = [[e for e in events if e["epoch"] % 2 == k] for k in (0, 1)]
    if all(sets):
        (d0, e0), (d1, e1) = mean(sets[0]), mean(sets[1])
        odd_even = round(abs(d0 - d1) / math.hypot(e0, e1), 2)
    else:
        odd_even = None
    power = [max(e["snr"], 0.0) ** 2 for e in events]
    return dict(g, P=round(m * g["P"], 6), t0_btjd=round(g["t0_btjd"] + r * g["P"], 5), depth_ppm=round(d, 1), snr=round(snr, 2),
                red_snr=round(g["red_snr"] * d / g["depth_ppm"] * math.sqrt(len(on) / g["transits"]), 2) if g.get("red_snr") else None,
                transits=len(on), events=events, odd_even_sigma=odd_even, secondary_sigma=None,
                single_event_share=round(max(power) / sum(power), 3) if sum(power) > 0 else None, alias=m)
# the validation's outcomes that leave a transit past every other test a candidate: not validated, or not weighed
planets_TRANSIT_OPEN = ("not validated", "no light curve", "no stellar parameters", "analysis failed")
# the reason of a candidate whose star's variable-star catalogues could not be read
planets_UNREAD = "variable catalogues unread"


def planets_transit_rows(stars, names=None, full=False, old=False, shared=True, search="transitsearch", weighed="validate_transits"):
    """The transit search's signals as signals.csv rows, of the stars NAMES alone where given: rejected on under three transits, one dominant
    transit, odd-even depths, a secondary eclipse, half an orbit on or a second set of transits the search found at the same period and another phase,
    transits whose depths scatter too far for the signal-to-noise against that scatter to reach 7.1 (planets_transit_scatter), one transit taking too much of the signal (planets_transit_left), a period within 1 per
    cent of TESS's orbit, its half or a multiple (planets_TESS_ORBITS), or of an earlier signal's of the star, its half or its double, a red-noise
    signal-to-noise (planets_transit_red_snr) below 7.1, or a signal-to-noise below planets_TRANSIT_CEILING times the highest of the same search of the light
    curve turned upside down, either unmeasured counting as below; of the rest, known where catalogued or a TOI within an arcminute and 1 per cent
    in period, rejected where more than half its transits lie within a duration of those a TOI or community TOI of the star predicts
    (planets_transit_known), or where the star is itself a known eclipsing binary within 10 arcsec or varies at the period (planets_binary_known), candidates
    otherwise, decided on their validation, a candidate the validation does not validate or cannot weigh staying one (planets_TRANSIT_OPEN). A signal
    whose transits fall on every second or every third of its epochs alone is weighed at that multiple of its period (planets_transit_alias). A signal on a star with no TOI within an arcminute, whose odd and even transits differ with each set detected at 3 sigma
    or which shows a secondary eclipse, is weighed instead as a binary's eclipses, a star's row, its period doubled where its odd and even eclipses
    differ (planets_binary_signal), and on the same tests, the odd and even eclipses' depths each held to their own mean: known where a catalogue
    already knows the binary, or with FULL set a paper SIMBAD links to the star (planets_binary_known), a candidate otherwise, decided on its
    validation (planets_binary_decision); so is a candidate on such a star whose validation finds it larger than two Jupiter radii. With FULL set, a
    census star's planet, candidate or validated, is also weighed with the star's velocities at its transit (planets_transit_velocities): new where its
    ephemeris carries to the velocities within a tenth of a period, its semi-amplitude at the transit's phase is positive at 5 sigma and its free phase
    agrees within 3 sigma, as a TESS candidate with velocities is, and rejected where that semi-amplitude gives 13 Jupiter masses or more. A body the
    decision would make new is rejected where the validation's own fold does not show its box at 7.1 sigma (planets_transit_shape). A binary's two equal dips at a period under twice the search's shortest are a planet's transits at half the period where its weighing there
    (planets_validate_checks) makes it new. With OLD set, a
    validation weighed before the folded light's shape was read is decided on as it stands and no neighbour's variability is read (planets_validate_first).
    SHARED sets a signal two stars show against each other (planets_transit_shared), which a caller deciding the rows in parts does across them all. SEARCH and WEIGHED name the folders under RESULTS its searches and their validations are read from."""
    match = planets_catalogued()
    exo = planets_exofop()
    xra, xdec = (np.array(v) for v in zip(*[planets_radec(x) for x in exo])) if exo else (np.zeros(0), np.zeros(0))
    xper = np.array([planets_num(x.get("Period (days)")) for x in exo])
    labelled = list(zip([x["label"] for x in exo], xra.tolist(), xdec.tolist(), xper.tolist()))
    out = []
    paths = [os.path.join(planets_RESULTS, search, archive_tag(n) + ".json") for n in names] if names else \
        sorted(glob.glob(os.path.join(planets_RESULTS, search, "*.json")))
    for path in paths:
        if not os.path.exists(path):
            continue
        rec = planets_load_json(path)
        if not rec:
            continue
        # a star the TESS stage searched is placed by its record's header details
        s = stars.get(rec["name"]) or dict(RAJ2000=rec.get("ra"), DEJ2000=rec.get("dec"), SpType="", Vmag=rec.get("tmag", ""))
        ra, dec = planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000"))
        for i, g in enumerate(rec.get("signals", [])):
            P = g["P"]
            row = dict(name=rec["name"], sptype=s.get("SpType", ""), vmag=s.get("Vmag", ""), kind="transit", label="transit %d" % (i + 1), nights="", span_d="", P=P,
                       star=[rec.get("teff"), rec.get("rstar"), rec.get("mstar")] if rec.get("tic") else None, ra=ra, dec=dec, tic=rec.get("tic"),
                       K="", e="", msini_mjup="", msini_mearth="", fap="", flags="", object="planet", depth_ppm=g["depth_ppm"], duration_h=g["duration_h"],
                       t0_btjd=g["t0_btjd"], transit_snr=g["snr"], transits=g["transits"], odd_even_sigma=g["odd_even_sigma"],
                       secondary_sigma=g["secondary_sigma"], single_event_share=g["single_event_share"])
            sep = np.hypot(((xra - ra + 180.0) % 360.0 - 180.0) * math.cos(math.radians(dec)), xdec - dec) * 3600.0 \
                if len(exo) and math.isfinite(ra) and math.isfinite(dec) else np.full(len(exo), np.inf)
            hosts = [exo[j]["label"] for j in np.where(sep < 60.0)[0]]

            def cat_at(p):
                # the archive's planets of the star within 5 per cent of P, and the TOIs within an arcminute and 1 per cent of it
                with np.errstate(divide="ignore", invalid="ignore"):
                    near = [exo[j]["label"] for j in np.where((sep < 60.0) & (np.abs(p / xper - 1.0) < 0.01))[0]]
                return ["archive %s" % n for n in match(ra, dec, rec.get("tic"), (rec["name"], s.get("SimbadName")), p)] + near
            cat = cat_at(P)
            few = "fewer than three transits" if g["transits"] < 3 else "one transit" if (g["single_event_share"] or 0.0) >= 0.5 else ""
            real = lambda q: q["transits"] >= 3 and (q.get("red_snr") or 0.0) >= 7.1 and q["snr"] >= planets_TRANSIT_CEILING * planets_transit_ceiling(rec, q)
            # a second set of eclipses at the same period and another phase, as an eccentric binary's secondary, where the search found one
            twin = next((q for j, q in enumerate(rec["signals"]) if j != i and abs(q["P"] / P - 1.0) < 1e-3 and real(q)
                         and 0.05 < ((q["t0_btjd"] - g["t0_btjd"]) / P) % 1.0 < 0.95), None)
            split, eclipse = (g["odd_even_sigma"] or 0.0) >= 3.0, (g["secondary_sigma"] or 0.0) >= 3.0 or twin is not None
            # a binary's eclipses, on a star with no TOI, whose transits a search might fold at a wrong period where its mask misses them: odd and even
            # eclipses of different depths, each set detected at 3 sigma, the binary's period then twice the search's, or a secondary eclipse
            host = bool(hosts)
            binary = not few and not cat and not host and (split and all(d >= 3.0 * e for d, e in planets_transit_sets(g)) or not split and eclipse)
            b = planets_binary_signal(g, split and binary)
            # transits on every second or every third epoch alone, a planet's beyond the search's longest period: weighed at that period
            alias = planets_transit_alias(g) if not few and not cat and not binary and (split or planets_transit_scatter(g) < 7.1) else None
            h = alias or g
            if alias:
                cat = cat_at(h["P"])
                few = "fewer than three transits" if h["transits"] < 3 else "one transit" if (h["single_event_share"] or 0.0) >= 0.5 else ""
                split, eclipse = (h["odd_even_sigma"] or 0.0) >= 3.0, twin is not None
                row.update(P=h["P"], depth_ppm=h["depth_ppm"], t0_btjd=h["t0_btjd"], transit_snr=h["snr"], transits=h["transits"],
                           odd_even_sigma=h["odd_even_sigma"], secondary_sigma="", single_event_share=h["single_event_share"], alias=alias["alias"])
            rest = "inconsistent depths" if planets_transit_scatter(h, split and binary) < 7.1 else \
                "uneven transits" if planets_transit_left(h, split and binary) < planets_TRANSIT_LEFT else \
                "TESS orbit" if any(abs(p / q - 1.0) < 0.01 for p in {h["P"], b["P"]} for q in planets_TESS_ORBITS) else \
                "harmonic" if any(abs(h["P"] / (q["P"] * m) - 1.0) < 0.01 for q in rec["signals"][:i] for m in (0.5, 1.0, 2.0)) else \
                "red noise" if not (h.get("red_snr") or 0.0) >= 7.1 else \
                "noise" if not h["snr"] >= planets_TRANSIT_CEILING * planets_transit_ceiling(rec, h) else ""
            v = planets_load_json(os.path.join(planets_RESULTS, weighed, archive_tag(rec["name"], i + 1) + ".json"))
            # a validation weighed at another period than the one the signal is now weighed at, or before the folded light's shape was read
            # (planets_transit_shape), stands for nothing (planets_validate_again)
            if v and (abs(v.get("period", b["P"] if binary else h["P"]) / (b["P"] if binary else h["P"]) - 1.0) > 0.01 or not old and "fpp" in v and "shape_sectors" not in v):
                v = None
            # a signal whose catalogues could not be read stays a candidate until the next decision reads them
            unread = False
            two_dips = binary and not split and g["P"] < 2.0 * rec["pmin"]
            if binary:
                known = []
                if not rest:
                    try:
                        known = planets_binary_known(ra, dec, b["P"], labelled, names=(rec["name"], s.get("SimbadName")), literature=full)
                    except IOError:
                        known, unread = [], True
                row.update(object="star", orbit_P=b["P"], depth_ppm=b["depth_ppm"], t0_btjd=b["t0_btjd"], catalogued="; ".join(known),
                           status="rejected" if rest else "known" if known else "candidate",
                           reason=rest or ("catalogued" if known else planets_UNREAD if unread else ""))
            else:
                why = few or ("odd-even depths" if split else "secondary eclipse" if eclipse else "") or rest
                veto = []
                if not why and not cat:
                    # a candidate whose transits are mostly those a registered TOI or community TOI predicts, within a duration, as a mask that missed
                    # them leaves them
                    eph = planets_transit_known(tic=rec["tic"]) if rec.get("tic") else planets_transit_known(ra=ra, dec=dec)
                    times = [e["time"] for e in h["events"]]
                    if times and any(sum(abs(((x - t0) / Pk + 0.5) % 1.0 - 0.5) * Pk < Dk for x in times) > 0.5 * len(times) for Pk, t0, Dk in eph):
                        why = "a TOI's transits"
                if not why and not cat:
                    # a candidate whose star is itself a known eclipsing binary, within 10 arcsec, or varies at its period
                    try:
                        veto = planets_binary_known(ra, dec, h["P"], radius=10.0, simbad=("EB*", "EB?", "El*", "El?"), candidates=False)
                    except IOError:
                        veto, unread = [], True
                    why = "known binary or variable" if veto else ""
                row.update(catalogued="; ".join(cat or veto), status="rejected" if why else "known" if cat else "candidate",
                           reason=why or ("catalogued" if cat else planets_UNREAD if unread else ""))
            # equal dips half an orbit apart at a period the search's shortest doubled: a planet's transits at half the period, where its weighing there makes it new
            if two_dips and row["status"] == "candidate" and not unread:
                hv = planets_load_json(os.path.join(planets_RESULTS, weighed, archive_tag(rec["name"], i + 1) + "_half.json"))
                half = planets_transit_half(g)
                if hv and "fpp" in hv and not planets_transit_physical(half, hv.get("star_radius"), hv.get("star_mass")) and \
                        planets_validation_decision(hv, planets_transit_candidate(rec["name"], i + 1, half, hv.get("tic"), hv.get("star_radius")), None, {})[0] == "new":
                    binary, v, h, twin = False, hv, half, None
                    row.update(object="planet", orbit_P="", P=h["P"], depth_ppm=h["depth_ppm"], t0_btjd=h["t0_btjd"], transit_snr=h["snr"], secondary_sigma="", odd_even_sigma="", half=1)
            if row["status"] == "candidate" and v and not unread:
                # a binary is weighed with its star's mass and temperature, the deepest occultation a planet could give then known
                as_star = lambda x: planets_transit_candidate(rec["name"], i + 1, x, v.get("tic"), v.get("star_radius"), v.get("star_mass"), v.get("star_teff"))
                cand = as_star(b) if binary else planets_transit_candidate(rec["name"], i + 1, h, v.get("tic"), v.get("star_radius"))
                status, reason, cols = (planets_binary_decision(v, cand, twin) + ({},)) if binary else planets_validation_decision(v, cand, None, {})
                # a candidate the validation could not weigh is still too large for a planet where its depth on the TIC's star gives over two Jupiter radii
                if not binary and status == "rejected" and reason in planets_TRANSIT_OPEN and planets_num(cand.get("Planet Radius (R_Earth)")) >= 22.4:
                    reason = "radius"
                if not binary and not host and (status, reason) == ("rejected", "radius"):
                    # a body larger than two Jupiter radii is a star's: weighed as a binary's eclipses
                    try:
                        known = planets_binary_known(ra, dec, h["P"], labelled, names=(rec["name"], s.get("SimbadName")), literature=full)
                    except IOError:
                        known, unread = [], True
                    row.update(object="star", orbit_P=h["P"], catalogued="; ".join(known))
                    status, reason = ("candidate", planets_UNREAD) if unread else ("known", "catalogued") if known else planets_binary_decision(v, as_star(h))
                # a planet whose star, with the radius and the mass its validation took, leaves no room for its orbit or its transit's length
                phys = planets_transit_physical(h, v.get("star_radius"), v.get("star_mass")) if row["object"] == "planet" else ""
                if phys:
                    status, reason = "rejected", "inside the star" if phys.startswith("orbit") else "duration"
                # a body the rest would make new, where the validation's own fold does not show its dip at 7.1 sigma, is not there
                if status in ("new", "likely") and not old and (v.get("shape_box_chi2") or 0.0) < 7.1 ** 2:
                    status, reason = "rejected", "no dip in its fold"
                # a planet the rest would make new, within the reach of the noise's own signals, stays a candidate
                if status in ("new", "likely") and not binary and not old and row["object"] == "planet" and not h["snr"] >= planets_TRANSIT_NEW * planets_transit_ceiling(rec, h):
                    status, reason = "candidate", "near the noise"
                # a body the rest would make new, where a variable star near it varies at its period, is that star's
                if status in ("new", "likely") and not old:
                    try:
                        neighbours = planets_variable_neighbours(ra, dec, planets_num(row.get("orbit_P") or h["P"]))
                    except IOError:
                        neighbours, status, reason = [], "candidate", planets_UNREAD
                    if neighbours:
                        status, reason = "rejected", "a neighbour's variability"
                        row["catalogued"] = "; ".join(neighbours)
                # a signal past every test but the validation, or one the validation could not weigh, stays a candidate, as does a likely planet until planets_validate_checks has read it
                if status == "rejected" and reason in planets_TRANSIT_OPEN or status == "likely" and "checks_read" not in v:
                    status = "candidate"
                if status is not None:
                    row.update(cols, fpp=max(v["fpp"], 0.0) if "fpp" in v else "", nfpp=max(v["nfpp"], 0.0) if "nfpp" in v else "", status=status, reason=reason,
                               radius_rearth=cand["Planet Radius (R_Earth)"], **planets_planet_cols(v), **planets_check_cols(v, v.get("period", h["P"]), cand))
            if full and row["object"] == "planet" and row["status"] in ("candidate", "new", "likely") and not rec.get("tic") and not unread:
                # a census star's velocities weighed at the transit: new as a TESS candidate with velocities is, a star's or brown dwarf's mass rejected
                mstar = (v or {}).get("star_mass") or planets_mass(s.get("SpType")) or 1.0
                rv = planets_transit_velocities(rec["name"], s.get("SpType", ""), h, mstar)
                if rv:
                    row.update(K=rv["K"], msini_mearth=rv["msini_mearth"], nights=rv["nights"], span_d=rv["span_d"])
                    if rv["snr"] and rv["snr"] >= 5.0 and rv["phase_err"] < 0.1 and abs(rv["phase_offset_deg"]) <= 3.0 * rv["ephase_deg"]:
                        row.update(status="rejected", reason="velocities") if rv["msini_mearth"] >= 13.0 * 317.83 else row.update(status="new", reason="")
            out.append(row)
    if shared:
        planets_transit_shared(out)
    return out


def planets_transit_shared(out):
    """A signal two stars within two arcminutes both show, at one period within one part in ten thousand (or its half or double) and one phase within a duration,
    is the brighter star's: the fainter's row of OUT is rejected as another star's. Each row is set only against those within two arcminutes in declination."""
    import bisect
    live = [r for r in out if r["status"] in ("candidate", "new", "likely") and math.isfinite(planets_num(r["ra"])) and math.isfinite(planets_num(r["dec"]))
            and math.isfinite(planets_num(r["vmag"]))]
    by_dec = sorted((planets_num(r["dec"]), k) for k, r in enumerate(live))
    decs = [d for d, _ in by_dec]
    for x in live:
        px = planets_num(x.get("orbit_P") or x["P"])
        dx = planets_num(x["dec"])
        near = sorted(k for _, k in by_dec[bisect.bisect_left(decs, dx - 120.0 / 3600.0):bisect.bisect_right(decs, dx + 120.0 / 3600.0)])
        for y in (live[k] for k in near):
            py = planets_num(y.get("orbit_P") or y["P"])
            if x["name"] == y["name"] or not planets_num(x["vmag"]) > planets_num(y["vmag"]) or not any(abs(px / (m * py) - 1.0) < 1e-4 for m in (0.5, 1.0, 2.0)):
                continue
            cosd = math.cos(math.radians(planets_num(y["dec"])))
            sep = math.hypot(((planets_num(x["ra"]) - planets_num(y["ra"]) + 180.0) % 360.0 - 180.0) * cosd, planets_num(x["dec"]) - planets_num(y["dec"])) * 3600.0
            q = min(px, py)
            phase = abs(((planets_num(x["t0_btjd"]) - planets_num(y["t0_btjd"])) / q + 0.5) % 1.0 - 0.5) * q
            if sep < 120.0 and phase * 24.0 < max(planets_num(x["duration_h"]), planets_num(y["duration_h"])):
                x.update(status="rejected", reason="another star's signal", catalogued=y["name"])
                break


def planets_transit_ceiling(rec, g):
    """The highest signal-to-noise the search of the record REC found upside down over the range of periods it found the signal G in, infinite where it has none."""
    return rec.get("inverted_snr_long" if g.get("long") else "inverted_snr") or float("inf")


# how much of a signal its strongest transit may take, what it keeps without that transit against what transits alike would keep (planets_transit_left), and the multiple a signal must reach of the highest signal-to-noise the same search finds upside down (planets_transit_ceiling): the limits at which the calibrations keep the most real signals beside the noise, and nine in ten of the transits laid in (planets_null_search, planets_inject_search)
planets_TRANSIT_LEFT, planets_TRANSIT_CEILING = 0.85, 1.25


# the multiple of that highest signal-to-noise a planet's signal must reach to be new and not a candidate, past the signals the light curves turned upside down reach through the whole of the vetting (planets_null_search)
planets_TRANSIT_NEW = 2.5


def planets_transit_left(g, split=False):
    """What a blind-search signal G's signal-to-noise keeps without its strongest transit, against what it would keep were its transits alike: one for transits alike, lower the more of the signal one of them carries, as the few outlying events of noise do; the odd and the even transits each taken about their own mean where SPLIT is set, as a binary's two eclipses differ. Zero where its transits add to nothing."""
    s = np.array([e["snr"] for e in g["events"]], float)
    if split:
        for k in (0, 1):
            m = np.array([e["epoch"] % 2 == k for e in g["events"]])
            if m.any() and s[m].mean() > 0:
                s[m] = s[m] / s[m].mean()
    n, total = len(s), float(s.sum())
    return (1.0 - float(s.max()) / total) * n / (n - 1.0) if n > 1 and total > 0 else 0.0


def planets_transit_fault(rec, i, g):
    """What the search's own vetting finds against the signal G, the Ith of the record REC, whatever the catalogues and its validation say (planets_transit_rows), empty where nothing:
    under three transits or one dominating them; a signal whose transits fall on every second or third epoch alone, weighed at that multiple, taking too much in one of them there (planets_transit_left); or, with no such multiple, depths that scatter too far or one transit taking too much of it on
    either reading of its odd and even transits, a period at TESS's orbit or an earlier signal's, or too low a red-noise or inverted-search signal-to-noise."""
    if g["transits"] < 3:
        return "fewer than three transits"
    if (g["single_event_share"] or 0.0) >= 0.5:
        return "one transit"
    split, scatter = (g["odd_even_sigma"] or 0.0) >= 3.0, planets_transit_scatter(g)
    alias = planets_transit_alias(g) if split or scatter < 7.1 else None
    if alias:
        return "uneven transits" if planets_transit_left(alias) < planets_TRANSIT_LEFT else ""
    if scatter < 7.1 and (not split or planets_transit_scatter(g, True) < 7.1):
        return "inconsistent depths"
    if planets_transit_left(g) < planets_TRANSIT_LEFT and (not split or planets_transit_left(g, True) < planets_TRANSIT_LEFT):
        return "uneven transits"
    if any(abs(g["P"] / q - 1.0) < 0.01 for q in planets_TESS_ORBITS):
        return "TESS orbit"
    if any(abs(g["P"] / (q["P"] * m) - 1.0) < 0.01 for q in rec["signals"][:i] for m in (0.5, 1.0, 2.0)):
        return "harmonic"
    if not (g.get("red_snr") or 0.0) >= 7.1:
        return "red noise"
    return "noise" if not g["snr"] >= planets_TRANSIT_CEILING * planets_transit_ceiling(rec, g) else ""


def planets_transit_hopeless(rec, i, g):
    """Whether the search's own vetting rejects the signal G, the Ith of the record REC (planets_transit_fault)."""
    return bool(planets_transit_fault(rec, i, g))


def planets_rules_hash(functions, values=()):
    """A digest of the source of the named FUNCTIONS of this file and of VALUES, which changes when a rule they hold does."""
    import hashlib
    import inspect
    h = hashlib.sha256()
    for name in functions:
        h.update(inspect.getsource(globals()[name]).encode())
    h.update(repr(values).encode())
    return h.hexdigest()[:16]


def planets_transit_kept(stars, read_only=False):
    """The TESS root's transit rows that are not rejected, each star decided once and again only when it must be, kept in RESULTS/decided.sqlite, so that a decision
    costs what changed and not the whole root: a star whose search record or validations have changed since it was decided, by their times and sizes, is read again;
    one whose signals the search's own vetting rejects outright (planets_transit_hopeless) is done, and any other is decided (planets_transit_rows). Every star that
    has a signal past that vetting is decided again when the rules that decide it or ExoFOP's or the archive's tables change, and when a catalogue could not be read;
    every star is read again when that vetting itself changes, each change found from the rules' source (planets_rules_hash). With READ_ONLY the rows as last decided
    are returned, or None where nothing has been. The fainter of two stars showing one signal is rejected across all the rows (planets_transit_shared)."""
    import hashlib
    import sqlite3
    path = os.path.join(planets_RESULTS, "decided.sqlite")
    if read_only and not os.path.exists(path):
        return None
    db = sqlite3.connect(path, timeout=600)
    db.execute("PRAGMA journal_mode=WAL")
    db.execute("CREATE TABLE IF NOT EXISTS stars (tag TEXT PRIMARY KEY, sig TEXT, live INTEGER, rows TEXT)")
    db.execute("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)")
    if not read_only:
        search, weighed = os.path.join(planets_RESULTS, "transitsearch"), os.path.join(planets_RESULTS, "validate_transits")
        extra = {}
        if os.path.isdir(weighed):
            with os.scandir(weighed) as it:
                for e in it:
                    m = re.fullmatch(r"(.+?)_\d+(?:_half)?\.json", e.name)
                    if m:
                        st = e.stat()
                        extra.setdefault(m.group(1), []).append("%s:%d:%d" % (e.name, st.st_mtime_ns, st.st_size))
        current = {}
        with os.scandir(search) as it:
            for e in it:
                if e.name.endswith(".json"):
                    st = e.stat()
                    current[e.name[:-5]] = "%d:%d|%s" % (st.st_mtime_ns, st.st_size, "|".join(sorted(extra.get(e.name[:-5], ()))))
        tables = []
        for name in ("toi.csv", "ctoi.csv", "known.csv", "eclipsing_binaries.npy", "eclipsing_candidates.npy"):
            p = planets_path(name)
            tables.append(os.path.getsize(p) if name.endswith(".npy") and os.path.exists(p) else hashlib.sha256(open(p, "rb").read()).hexdigest() if os.path.exists(p) else "")
        vetting = planets_rules_hash(("planets_transit_hopeless", "planets_transit_fault", "planets_transit_left", "planets_transit_scatter", "planets_transit_alias", "planets_transit_sets"), (planets_TESS_ORBITS, planets_TRANSIT_LEFT, planets_TRANSIT_CEILING))
        deciding = planets_rules_hash(("planets_transit_rows", "planets_validation_decision", "planets_binary_decision", "planets_transit_smooth", "planets_transit_sawtooth",
                                       "planets_transit_half", "planets_transit_physical", "planets_binary_known", "planets_variable_neighbours", "planets_variables_near",
                                       "planets_check_cols", "planets_centroid_off", "planets_transit_candidate", "planets_occultation_max", "planets_transit_known",
                                       "planets_binary_signal", "planets_has_sibling", "planets_source_cleared", "planets_not_planet", "planets_planet_cols", "planets_no_room", "planets_rv_moving", "planets_odd_even", "planets_fold_fault"),
                                      (planets_VARIABLES, planets_DIP_TOI, planets_MISSION_DIP, planets_DIP_KEPLER, planets_PLANET_SCENARIOS, planets_IMAGE_OFF, planets_TARGET_BINARIES, planets_RV_GOF, planets_RV_P, planets_RV_LEAST, planets_RV_HOST, planets_TRANSIT_NEW, planets_IMAGE_CHI2, planets_IMAGE_TAIL, planets_MULTI_BOOST, planets_MULTI_RADIUS, planets_RUWE_MAX, planets_SPIN_FAST, planets_SPIN_LOW, planets_SPIN_HIGH, planets_OWN_RADIUS, planets_NEIGHBOUR_RADIUS, planets_VSX_TRANSIT,
                                       planets_UNREAD, planets_TRANSIT_OPEN, planets_TRANSIT_PMIN, planets_FPP_VALID, planets_NFPP_VALID, planets_FPP_LIKELY, planets_NFPP_LIKELY, tables))
        meta = dict(db.execute("SELECT key, value FROM meta").fetchall())
        known = dict(db.execute("SELECT tag, sig FROM stars").fetchall()) if meta.get("vetting") == vetting else {}
        redo = {t for t, in db.execute("SELECT tag FROM stars WHERE live = 1")} if meta.get("deciding") != deciding else set()
        redo |= {t for t, in db.execute("SELECT tag FROM stars WHERE rows LIKE ?", ('%"reason": "' + planets_UNREAD + '"%',))}
        done, read = [], 0
        for tag, sig in current.items():
            if known.get(tag) == sig:
                continue
            rec = planets_load_json(os.path.join(search, tag + ".json"))
            if not rec:
                continue
            read += 1
            if any(not planets_transit_hopeless(rec, i, g) for i, g in enumerate(rec.get("signals", []))):
                redo.add(tag)
            else:
                done.append((tag, sig, 0, None))
            if len(done) >= 5000:
                db.executemany("INSERT OR REPLACE INTO stars VALUES (?, ?, ?, ?)", done)
                db.commit()
                done = []
        db.executemany("INSERT OR REPLACE INTO stars VALUES (?, ?, ?, ?)", done)
        db.executemany("DELETE FROM stars WHERE tag = ?", [(t,) for t in set(known) - set(current)])
        db.commit()
        todo = sorted(redo & set(current))
        for c in range(0, len(todo), 500):
            part = todo[c:c + 500]
            got = {}
            for r in planets_transit_rows(stars, part, full=True, shared=False):
                if r["status"] != "rejected":
                    got.setdefault(archive_tag(r["name"]), []).append(r)
            db.executemany("INSERT OR REPLACE INTO stars VALUES (?, ?, ?, ?)", [(t, current[t], 1, json.dumps(got[t], default=float) if t in got else None) for t in part])
            db.commit()
        db.executemany("INSERT OR REPLACE INTO meta VALUES (?, ?)", [("vetting", vetting), ("deciding", deciding)])
        db.commit()
        print("%d stars, %d read again, %d decided" % (len(current), read, len(todo)), flush=True)
    rows = []
    for text, in db.execute("SELECT rows FROM stars WHERE rows IS NOT NULL ORDER BY tag"):
        rows += json.loads(text)
    db.close()
    planets_transit_shared(rows)
    return rows


def planets_transit_centroids(tic, P, t0, D, most=8, nulls=60):
    """Where a transit's dimming comes from, read in its star's light curves from MAST's bucket, SPOC's where any covers a transit, else TESS-SPOC's,
    MOST sectors at most (planets_tess_index, planets_tess_key), for the ephemeris P (days), T0 (BTJD) and duration D (days). In each sector the points
    of quality zero within half a duration of a transit's middle are set against those between one and three durations of it: the PDCSAP and the
    simple-aperture depths, the background's change and the shift of the flux-weighted centroid (MOM_CENTR1, MOM_CENTR2), each with its error from the
    scatter out of transit. The centroid's shift over the simple-aperture depth places the dimming's source from the centroid out of transit (for a
    small depth the centroid moves away from the source by the depth times their separation), and the aperture's WCS turns that place into a position
    on the sky, set against the star's. Each measure's error is the scatter of the same measure taken at the same windows moved, all of a sector's
    transits together, to NULLS other times of the sector clear of the transits by two durations, so that the light curve's correlated noise is in
    it; with fewer than eight such times, twice the error from the scatter out of transit. The source is placed both from the star and from the
    centroid out of transit, which an aperture cut short of the star's light or the frame's conventions move from the star by up to a pixel or so
    while a dimming of the star itself, where it gives most of the aperture's light (CROWDSAP near one), leaves the source on that centroid. Returns
    each sector's measures with its crowding, the sectors' median offsets of the source from the star and from the centroid (arcsec, east and north),
    each with an error, the larger of the sectors' median error and their scatter about the median, over the root of the sectors' number, and its
    significance, and the TIC stars within two arcminutes with the eclipse depth each would need to give the PDCSAP depth; None where no light curve
    covers a transit."""
    from astropy.io import fits
    from astropy.wcs import WCS
    warnings.filterwarnings("ignore")
    tics, secs, kinds, sectors = planets_tess_index()
    a, b = int(np.searchsorted(tics, tic)), int(np.searchsorted(tics, tic, side="right"))
    held = {k: sorted(s for s, kk in zip(secs[a:b].tolist(), kinds[a:b].tolist()) if kk == k and "t0" in sectors.get(s, {})) for k in (0, 1)}
    t0m = t0 + 56999.5
    covers = lambda s: math.ceil((sectors[s]["t0"] - t0m) / P) * P + t0m <= sectors[s]["t1"]
    kind = 0 if any(covers(s) for s in held[0]) else 1
    keep = [s for s in held[kind] if covers(s)]
    keep = [keep[int(j)] for j in np.unique(np.linspace(0, len(keep) - 1, most).round())] if len(keep) > most else keep
    if not keep:
        return None
    out, head = [], {}
    for s in keep:
        raw = archive_get(planets_TESS_BUCKET + planets_tess_key(tic, s, kind, sectors), timeout=300, soft=True)
        if not raw:
            continue
        with fits.open(io.BytesIO(raw)) as h:
            H, d, ap = h[0].header, h["LIGHTCURVE"].data, h["APERTURE"].header
            col = lambda k: np.asarray(d[k], float) if k in d.columns.names else np.full(len(d), np.nan)
            t, pdc, sap, bkg, cx, cy, q = (col(k) for k in ("TIME", "PDCSAP_FLUX", "SAP_FLUX", "SAP_BKG", "MOM_CENTR1", "MOM_CENTR2", "QUALITY"))
            w = WCS(ap)
            ra, dec = archive_num(H.get("RA_OBJ")), archive_num(H.get("DEC_OBJ"))
            crowd = archive_num(h["LIGHTCURVE"].header.get("CROWDSAP"))
            head = head or dict(ra=ra, dec=dec, tmag=archive_num(H.get("TESSMAG")))
            ox, oy = float(ap.get("CRVAL1P", 0.0)), float(ap.get("CRVAL2P", 0.0))
        ok = np.isfinite(t) & np.isfinite(pdc) & np.isfinite(sap) & np.isfinite(cx) & np.isfinite(cy) & np.isfinite(bkg) & (q == 0)
        t, pdc, sap, bkg, cx, cy = (x[ok] for x in (t, pdc, sap, bkg, cx, cy))
        if len(t) < 100:
            continue
        mids = t0 + P * np.arange(math.ceil((t.min() - D - t0) / P), math.floor((t.max() + D - t0) / P) + 1)
        series = (pdc / np.median(pdc), sap / np.median(sap), bkg, -cx, -cy)

        def measure(centres):
            # the windows' out-of-transit means less their in-transit means, for every series at once
            dist = np.min(np.abs(t[:, None] - centres[None, :]), axis=1)
            inn, ring = dist < 0.5 * D, (dist > D) & (dist < 3.0 * D)
            if inn.sum() < 5 or ring.sum() < 20:
                return None, inn, ring
            return np.array([float(np.mean(x[ring]) - np.mean(x[inn])) for x in series]), inn, ring
        true, inn, ring = measure(mids)
        if true is None:
            continue
        # the same windows moved to other times of the sector, clear of every transit by two durations
        clear = lambda c: np.min(np.abs(c[:, None] - mids[None, :]), axis=1).min() > 2.0 * D
        null = [m for m in (measure(mids + shift)[0] for shift in np.linspace(-0.5 * (t.max() - t.min()), 0.5 * (t.max() - t.min()), 4 * nulls)
                            if clear(mids + shift)) if m is not None]
        if len(null) >= 8:
            null = np.array(null)
            err = 1.4826 * np.median(np.abs(null - np.median(null, axis=0)), axis=0)
        else:
            err = 2.0 * np.array([1.4826 * float(np.median(np.abs(x[ring] - np.median(x[ring])))) * math.sqrt(1.0 / inn.sum() + 1.0 / ring.sum()) for x in series])
        (dp, ds, db, sx, sy), (ep, es, eb, esx, esy) = true, err
        # the centroid's shift into transit, and the source's place on the detector from it
        row = dict(sector=s, transits=int(len(np.unique(np.round((t[inn] - t0) / P)))), depth_ppm=round(1e6 * dp, 1), depth_err_ppm=round(1e6 * ep, 1),
                   depth_sap_ppm=round(1e6 * ds, 1), crowding=crowd, background_change=round(db, 3) if math.isfinite(db) else None,
                   background_sigma=round(db / eb, 2) if math.isfinite(db) and eb > 0 else None,
                   shift_px=[round(sx, 6), round(sy, 6)], shift_err_px=[round(esx, 6), round(esy, 6)])
        if ds > 3.0 * es:
            cxo, cyo = float(np.mean(cx[ring])), float(np.mean(cy[ring]))
            sky = lambda x, y: w.all_pix2world([[x - ox, y - oy]], 0)[0]
            arcsec = lambda p, q_: [round((p[0] - q_[0]) * math.cos(math.radians(dec)) * 3600.0, 2), round((p[1] - q_[1]) * 3600.0, 2)]
            src, cen = sky(cxo - sx / ds, cyo - sy / ds), sky(cxo, cyo)
            # the error of the source's place: the shift's error over the depth, one pixel being 21 arcsec
            err = 21.0 * math.hypot(esx, esy) / ds / math.sqrt(2.0)
            row.update(offset_arcsec=arcsec(src, (ra, dec)), from_centroid_arcsec=arcsec(src, cen), centroid_arcsec=arcsec(cen, (ra, dec)),
                       offset_err_arcsec=round(err, 2))
        out.append(row)
    if not out:
        return None
    placed = [r for r in out if "offset_arcsec" in r]
    res = dict(tic=tic, light_curves="SPOC" if kind == 0 else "TESS-SPOC", sectors=out)
    if placed:
        # the sectors' median place of the source, from the star and from the centroid out of transit, so that no one sector's systematics carry
        # it, against the larger of the sectors' median error and their own scatter about it, each over the root of their number
        n = len(placed)
        for key in ("offset_arcsec", "from_centroid_arcsec"):
            x = np.array([r[key] for r in placed])
            off = np.median(x, axis=0)
            scatter = (1.4826 * np.median(np.abs(x - off), axis=0) if n >= 3 else np.abs(x[0] - x[-1]) / math.sqrt(2.0)) if n > 1 else np.zeros(2)
            err = max(float(np.median([r["offset_err_arcsec"] for r in placed])), float(scatter.max())) / math.sqrt(n)
            res[key] = [round(float(v), 2) for v in off]
            res[key.replace("arcsec", "err_arcsec")] = round(err, 2)
            res[key.replace("arcsec", "sigma")] = round(float(np.hypot(*off)) / err, 2) if err > 0 else None
    try:
        cone = planets_tic_real(tic)
        me = [s_ for s_ in cone if str(s_["ID"]) == str(tic)]
        tm = float(me[0]["Tmag"]) if me else head.get("tmag", float("nan"))
        depth = max((r["depth_ppm"] for r in out), default=0.0) / 1e6
        near = []
        for s_ in cone:
            if str(s_["ID"]) != str(tic) and np.isfinite(float(s_["Tmag"])):
                sep = math.hypot((float(s_["ra"]) - head["ra"]) * math.cos(math.radians(head["dec"])), float(s_["dec"]) - head["dec"]) * 3600.0
                if sep < 120.0:
                    near.append(dict(tic=int(s_["ID"]), sep_arcsec=round(sep, 1), dtmag=round(float(s_["Tmag"]) - tm, 2),
                                     eclipse_needed=round(depth * 10 ** (0.4 * (float(s_["Tmag"]) - tm)), 4)))
        res["neighbours"] = sorted(near, key=lambda x: x["eclipse_needed"])[:10]
    except Exception as exc:
        res["neighbours_error"] = "%s: %s" % (type(exc).__name__, str(exc)[:160])
    return res


def planets_transit_dossier(name):
    """Everything the root holds on the blind search's signals of the star NAME, printed: the stored search with each signal's transits, each signal as
    it is weighed (at a multiple of its period where its transits fall on every second or third epoch, planets_transit_alias), its decision
    (planets_transit_rows with the decision's own checks) and validation record, its weighing with the star's velocities (planets_transit_velocities),
    where it is not rejected the place of its dimming's source from the light curves' centroids with the neighbours that could host it
    (planets_transit_centroids), and SIMBAD's identifiers, type and papers on binaries, planets and companions for the star."""
    # titles and names outside the console's code page printed with a stand-in rather than stopping the dossier
    sys.stdout.reconfigure(errors="replace")
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    path = os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")
    if not os.path.exists(path):
        print("%s: no stored search in %s" % (name, planets_RESULTS))
        return
    rec, s = json.load(open(path)), stars.get(name, {})
    print("%s: %s sectors, %s points over %s d, noise %s ppm, inverted S/N %s, masked %s%s" % (
        name, rec.get("sectors"), rec.get("points"), rec.get("span_d"), rec.get("noise_ppm"), rec.get("inverted_snr"), rec.get("masked"),
        "; " + rec["note"] if rec.get("note") else ""))
    for k, x in enumerate(rec.get("set_aside", []), 1):
        print("  set aside %d: P %.5f d, %s transits, single share %s" % (k, x["P"], x["transits"], x["single_event_share"]))
    rows = {r["label"]: r for r in planets_transit_rows(stars, [name], full=True)}
    for i, g in enumerate(rec.get("signals", []), 1):
        h = planets_transit_alias(g) or g
        r = rows.get("transit %d" % i, {})
        print("signal %d: P %.6f d, t0 %.5f BTJD, %.0f ppm, %.2f h, S/N %.1f (%.2f of the inverted search's), red S/N %s, %d transits, odd-even %s, "
              "secondary %s, single share %s" % (i, g["P"], g["t0_btjd"], g["depth_ppm"], g["duration_h"], g["snr"], g["snr"] / (rec.get("inverted_snr") or float("nan")),
                                                g.get("red_snr"), g["transits"], g["odd_even_sigma"], g["secondary_sigma"], g["single_event_share"]))
        for e in g["events"]:
            print("    epoch %4d at %.4f: %3d points, %7.0f ppm, S/N %6.1f" % (e["epoch"], e["time"], e["points"], e["depth_ppm"], e["snr"]))
        if h is not g:
            print("  weighed at %d times the period, %.6f d: %.0f ppm, S/N %.1f, %d transits, odd-even %s" % (h["alias"], h["P"], h["depth_ppm"], h["snr"],
                                                                                                         h["transits"], h["odd_even_sigma"]))
        print("  decision: %s %s (%s) %s; FPP %s NFPP %s" % (r.get("object", ""), r.get("status", ""), r.get("reason", ""), r.get("catalogued", ""), r.get("fpp", ""),
                                                           r.get("nfpp", "")))
        v = planets_load_json(os.path.join(planets_RESULTS, "validate_transits", archive_tag(name, i) + ".json"))
        if v:
            print("  validation: %s" % {k: v.get(k) for k in ("period", "depth_ppm", "fpp", "nfpp", "runs", "odd_even_sigma", "secondary_sigma", "shape_box_chi2",
                                                               "shape_sine_chi2", "shape_box_sigma", "shape_sector_chi2", "shape_sector_scatter", "shape_sectors",
                                                               "note", "star_radius", "star_mass", "star_teff",
                                                               "sectors", "light_curves")})
        if not rec.get("tic"):
            print("  velocities at %.6f d: %s" % (h["P"], planets_transit_velocities(name, s.get("SpType", ""), h, (v or {}).get("star_mass") or
                                                                                      planets_mass(s.get("SpType")))))
        tic = rec.get("tic") or (v or {}).get("tic")
        if tic and r.get("status") != "rejected":
            c = planets_transit_centroids(int(tic), h["P"], h["t0_btjd"], h["duration_h"] / 24.0)
            for x in (c or {}).get("sectors", []):
                print("  sector %3d: %d transits, depth %s +- %s ppm (aperture %s, crowding %s), background change %s (%s sigma), centroid shift %s +- %s "
                      "px, source %s from the star and %s from the centroid +- %s arcsec" % (
                          x["sector"], x["transits"], x["depth_ppm"], x["depth_err_ppm"], x["depth_sap_ppm"], x["crowding"], x["background_change"],
                          x["background_sigma"], x["shift_px"], x["shift_err_px"], x.get("offset_arcsec"), x.get("from_centroid_arcsec"), x.get("offset_err_arcsec")))
            if c and "offset_arcsec" in c:
                print("  centroids (%s), the sectors' median: the source %s +- %s arcsec from the star (%s sigma) and %s +- %s from the centroid (%s sigma)" % (
                    c["light_curves"], c["offset_arcsec"], c["offset_err_arcsec"], c["offset_sigma"], c["from_centroid_arcsec"], c["from_centroid_err_arcsec"],
                    c["from_centroid_sigma"]))
            for x in (c or {}).get("neighbours", [])[:6]:
                print("  neighbour TIC %d at %s arcsec, %+.2f mag: an eclipse of %.2f%% would give the depth" % (x["tic"], x["sep_arcsec"], x["dtmag"],
                                                                                                              100.0 * x["eclipse_needed"]))
    ids = [n for n in (s.get("SimbadName"), name) if n]
    print("SIMBAD: %s" % archive_simbad_basic(ids, ("main_id", "otype")))
    for n, papers in archive_simbad_papers(ids, words=planets_BINARY_WORDS + ("planet", "companion")).items():
        for b, y, title in papers[:12]:
            print("  %s %s %s" % (b, y, title[:150]))


def planets_load_json(path):
    """A JSON file's record, or None where there is none or it cannot be read, as a write a full disk cut short leaves it."""
    try:
        return json.load(open(path)) if os.path.exists(path) else None
    except ValueError:
        return None


def planets_transit_candidate(name, k, g, tic, rstar, mstar=None, teff=None):
    """A blind-search signal G, the Kth of the star NAME, as a row of ExoFOP's TOI table for the validation: its TIC number, ephemeris, duration and
    depth, the radius its depth gives on a star of RSTAR solar radii, and the star's radius, mass MSTAR (solar) and temperature TEFF (K) where given."""
    radius = 109.08 * rstar * math.sqrt(g["depth_ppm"] / 1e6) if rstar and g["depth_ppm"] > 0 else None
    star = {c: repr(float(x)) for c, x in (("Stellar Radius (R_Sun)", rstar), ("Stellar Mass (M_Sun)", mstar), ("Stellar Eff Temp (K)", teff))
            if x not in (None, "") and math.isfinite(planets_num(x))}
    return {"label": "OL-%s.%d" % (archive_tag(name), k), "TOI": "%s.%d" % (archive_tag(name), k), "TIC ID": str(tic), "Period (days)": repr(g["P"]),
            "Epoch (BJD)": repr(g["t0_btjd"] + 2457000.0), "Duration (hours)": repr(g["duration_h"]), "Depth (ppm)": repr(g["depth_ppm"]),
            "Planet Radius (R_Earth)": repr(radius) if radius else "", **star}


# the mass a star of unknown mass is given when a transit's orbit is placed against it, more than a star of its kind holds, so that an orbit inside it
# at that mass is inside it at any
planets_MASS_CEILING = 2.5


def planets_transit_physical(g, rstar, mstar):
    """Why a blind-search signal G cannot be a planet's transit of a star of RSTAR solar radii and MSTAR solar masses, or nothing: its orbit within
    1.5 stellar radii, or its box more than one and a half times, the widest step of the search's durations, the longest transit its orbit allows, a
    central transit of a body of the depth's radius ratio on a circular orbit. Where the star's mass is unknown, its orbit is placed for planets_MASS_CEILING solar masses, the widest it could be, and the
    duration is not judged; nothing where the radius is unknown."""
    rstar, mstar = planets_num(rstar), planets_num(mstar)
    if not rstar > 0:
        return ""
    known = mstar > 0
    a = 215.032 * ((mstar if known else planets_MASS_CEILING) * (g["P"] / 365.25) ** 2) ** (1.0 / 3.0)
    if a < 1.5 * rstar:
        return "orbit inside the star"
    if not known:
        return ""
    longest = 24.0 * g["P"] / math.pi * math.asin(min(1.0, rstar * (1.0 + math.sqrt(max(g["depth_ppm"], 0.0) / 1e6)) / a))
    return "duration %.1f h against at most %.1f h" % (g["duration_h"], longest) if g["duration_h"] > 1.5 * longest else ""


def planets_validate_again(path, P=None):
    """Whether the blind transit search's candidate whose validation record is PATH is to be weighed: it has no record, its record was weighed at
    another period than P by more than 1 per cent or before the folded light's shape was read (planets_transit_shape), or its analysis raised an
    error, fewer than three times."""
    if not os.path.exists(path):
        return True
    v = planets_load_json(path)
    if not v:
        return True
    if P and "period" in v and abs(v["period"] / P - 1.0) > 0.01 or "fpp" in v and "shape_sectors" not in v:
        return True
    # a record made without a light curve before QLP's were asked for is weighed once more
    if v.get("note") == "no light curve or aperture" and not v.get("qlp"):
        return True
    if planets_NO_FIELD in v.get("note", "") or "stellar" in v.get("note", "") and not v.get("gaia_read"):
        return True
    return "fpp" not in v and re.match(r"\w+: ", v.get("note", "")) is not None and v.get("tries", 1) < 3


def planets_validate_first():
    """The stars whose transit-search validation, weighed before the folded light's shape was read (planets_transit_shape), would make a body new as it
    stands (planets_transit_rows): those weighed ahead of the rest."""
    tags = set()
    for path in glob.glob(os.path.join(planets_RESULTS, "validate_transits", "*.json")):
        v = planets_load_json(path)
        if v and "fpp" in v and "shape_sectors" not in v:
            tags.add(re.sub(r"_\d+\.json$", "", os.path.basename(path)))
    if not tags:
        return []
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    return sorted({row["name"] for row in planets_transit_rows(stars, sorted(tags), old=True) if row["status"] == "new"})


def planets_validate_transits(draws=100000, runs=10, part=None, names=None, search="transitsearch", weighed="validate_transits", invert=False):
    """The blind transit search's candidates (planets_transit_rows), of the stars NAMES alone where given, validated statistically as TESS's candidates
    are (planets_validate_one), each star's TIC number the brightest TIC star within 20 arcsec of its J2000 position, each to
    RESULTS/validate_transits/<star>_<k>.json with that number and the TIC's radius, mass and temperature of the star; a planet the star's radius and
    mass rule out (planets_transit_physical) is written with why, unweighed, a binary's eclipses are weighed at the binary's period with its deeper
    eclipses (planets_binary_signal), and a candidate whose analysis raises is written with the error and weighed again, three times at most
    (planets_validate_again). A candidate is claimed by a folder of its name under RESULTS/validate_transits_claims while it is weighed, so that
    processes side by side weigh it once, a claim two hours old being taken over, and the weighing ends between candidates where a long search would
    end between stars (planets_search_ends). PART takes the share K/N of the candidates to weigh. SEARCH and WEIGHED name the folders under RESULTS the searches are read from and the validations kept in, and INVERT reads the star's flux upside down, each record then holding its checks already."""
    from astroquery.mast import Catalogs
    from astropy.coordinates import SkyCoord
    import astropy.units as u
    import socket
    # every network call gives up after five minutes without an answer
    socket.setdefaulttimeout(300)
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    folder = os.path.join(planets_RESULTS, weighed)
    claims = os.path.join(planets_RESULTS, weighed + "_claims")
    os.makedirs(folder, exist_ok=True)
    os.makedirs(claims, exist_ok=True)
    path_of = lambda row: os.path.join(folder, archive_tag(row["name"], int(row["label"].split()[-1])) + ".json")
    weighed_at = lambda row: row.get("orbit_P") or row["P"]
    # a whole root's candidates as last decided where a TESS root keeps them, the rows of the stars asked for otherwise
    listed = (planets_transit_kept(stars, read_only=True) if not names and os.path.exists(planets_path("tess.json")) else None)
    listed = listed if listed is not None else planets_transit_rows(stars, names, search=search, weighed=weighed)
    rows = [row for row in listed if row["status"] == "candidate" and not row.get("half") and planets_validate_again(path_of(row), weighed_at(row))]
    if part:
        kk, nn = (int(x) for x in part.split("/"))
        rows = rows[kk::nn]
    if not rows:
        return
    planets_validate_setup()
    if gpu_DEVICE.type == "cuda" and not planets_VALIDATE_GPU:
        planets_validate_gpu()
        planets_VALIDATE_GPU.append(True)
    for row in rows:
        # the weighing ends between candidates as a long search does between stars
        if planets_search_ends():
            return
        k, path = int(row["label"].split()[-1]), path_of(row)
        claim = os.path.join(claims, os.path.basename(path)[:-5])
        try:
            os.mkdir(claim)
        except FileExistsError:
            if time.time() - os.path.getmtime(claim) < 7200:
                continue
        try:
            if not planets_validate_again(path, weighed_at(row)):
                continue
            tries = (planets_load_json(path) or {}).get("tries", 1) if os.path.exists(path) else 0
            found = planets_load_json(os.path.join(planets_RESULTS, search, archive_tag(row["name"]) + ".json"))
            if not found:
                continue
            g = found["signals"][k - 1]
            binary = row["object"] == "star"
            if binary:
                g = planets_binary_signal(g, (g["odd_even_sigma"] or 0.0) >= 3.0)
            elif row.get("alias"):
                g = planets_transit_alias(g)
            if found.get("tic"):
                # a star the TESS stage searched carries its TIC number and its header's radius, mass and temperature
                tic, rstar, mstar, teff = int(found["tic"]), archive_num(found.get("rstar")), archive_num(found.get("mstar")), archive_num(found.get("teff"))
            else:
                s = stars[row["name"]]
                t = Catalogs.query_region(SkyCoord(float(s["RAJ2000"]), float(s["DEJ2000"]), unit="deg"), radius=20 * u.arcsec, catalog="TIC")
                if not len(t):
                    continue
                t.sort("Tmag")
                tic, rstar, mstar, teff = int(t["ID"][0]), archive_num(t["rad"][0]), archive_num(t["mass"][0]), archive_num(t["Teff"][0])
            r = planets_transit_candidate(row["name"], k, g, tic, rstar, *((mstar, teff) if binary else ()))
            why = "" if binary else planets_transit_physical(g, rstar, mstar)
            if why:
                rec = dict(note=why)
            else:
                cache = planets_path("validate_cache", archive_tag(r["label"]))
                try:
                    rec = planets_validate_one(r, draws, runs, cache=cache, invert=invert) or dict(note="no light curve or aperture", qlp=True)
                except Exception as exc:
                    rec = dict(note="%s: %s" % (type(exc).__name__, str(exc)[:200]), tries=tries + 1)
                shutil.rmtree(cache, ignore_errors=True)
            rec.update(label=r["label"], tic=tic, star_radius=rstar, star_mass=mstar, star_teff=teff, **(dict(checks_read="upside down") if invert else {}))
            archive_save(path, json.dumps(rec, separators=(",", ":")).encode())
            print("%s: %s" % (r["label"], "FPP %.4f NFPP %.5f" % (rec["fpp"], rec["nfpp"]) if "fpp" in rec else rec["note"]), flush=True)
            # the Gaia background TRICERATOPS kept for this candidate removed once it is weighed
            for p in glob.glob(planets_path("validate_backgrounds", "%d_%d_*.csv" % (tic, os.getpid()))):
                os.remove(p)
        finally:
            shutil.rmtree(claim, ignore_errors=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()


def planets_tess(name, periods):
    """A star's TESS light curves (eclipses_fetch) read at PERIODS, to RESULTS/tess/<name>.json. Each sector binned to 30 minutes, divided by its median
    and clipped at 5 sigma; a Lomb-Scargle periodogram per sector from 0.2 to 13 d and over its sectors together from 0.2 to 30 d, each with its highest
    peak, that peak's semi-amplitude and false-alarm level, and the highest power within 5 per cent of each period, half of it and twice it, the sectors together being those of PDCSAP flux, which keeps
    a star's own slow variation, where it has any, QLP's detrended flux having had it taken out and marked flux detrended otherwise. Each sector is
    then flattened by a running median of one day and searched by box least squares within 2 per cent of each period for durations of 1 to 6 hours, the
    trial periods spaced so that an hour-long transit drifts by half its length over the baseline, and the best box's events are measured one by one, each
    against the points within two durations of it, so that a transit shows the same depth at every event and a systematic shows one deep event. Where the
    star's orbits have been sampled, each planet's conjunctions are carried into the sectors with their errors, and a box of the central transit's duration
    (from Gaia's FLAME radius and the orbit) and one of half of it are slid across each conjunction's window, flattened by a two-day running median: the
    share of the conjunction's probability the data cover, the deepest box, and the depth and planet radius below which every covered box lies at 3 sigma.
    The box searches run on the device (gpu_bls), every box position of a window at once."""
    star = next(r for r in planets_read(planets_path("bank_stars.csv")) if r["Name"] == name)
    path = os.path.join(eclipses_ROOT, "lightcurves", name + ".npz")
    if not os.path.exists(path):
        path = eclipses_fetch(name, float(star["RAJ2000"]), float(star["DEJ2000"]))
    if path is None:
        return
    d = np.load(path)
    T, F, S, kept = [], [], [], []
    for sec in np.unique(d["sector"]):
        m = (d["sector"] == sec) & np.isfinite(d["flux"])
        t, f = d["time"][m], d["flux"][m]
        _, inv = np.unique(np.digitize(t, np.arange(t.min(), t.max() + 1 / 48, 1 / 48)), return_inverse=True)
        count = np.bincount(inv)
        tb, fb = np.bincount(inv, t) / count, np.bincount(inv, f) / count
        fb = fb / np.median(fb)
        ok = np.abs(fb - 1) < 5 * 1.4826 * np.median(np.abs(fb - 1))
        T.append(tb[ok]), F.append(fb[ok]), S.append(np.full(ok.sum(), sec))
        kept.append(bool(d["pdcsap"][m].all()) if "pdcsap" in d.files else True)

    def scan(t, f, pmax):
        freq = np.linspace(1.0 / pmax, 1.0 / 0.2, 20000)
        pw = gpu_host(gpu_gls(t, f, None, freq))
        k = int(np.argmax(pw))
        # the false-alarm level over frequencies up to five times the mean Nyquist frequency
        fmax = 2.5 * len(t) / float(t.max() - t.min())
        near, near_fap = {}, {}
        for P in periods:
            for label, q in (("P", P), ("P/2", P / 2), ("2P", 2 * P)):
                if q < pmax:
                    top = float(pw[np.abs(1.0 / freq / q - 1.0) < 0.05].max())
                    near["%g %s" % (P, label)], near_fap["%g %s" % (P, label)] = round(top, 3), "%.1e" % float(gpu_baluev(top, fmax, t))
        return dict(peak_d=round(float(1.0 / freq[k]), 3), power=round(float(pw[k]), 3),
                    semi_amplitude_ppm=round(1e6 * float(np.hypot(*gpu_gls_fit(t, f, None, freq[k])[1:])), 1), fap="%.1e" % float(gpu_baluev(pw[k], fmax, t)), near=near,
                    near_fap=near_fap)

    res = dict(name=name, periods=periods, detrended=True, sectors=[dict(sector=int(s[0]), n=len(t), **scan(t, f, 13.0)) for t, f, s in zip(T, F, S) if len(t) > 200])
    t = np.concatenate(T)
    pdc = [k for k, x in enumerate(kept) if x]
    res["combined"] = dict(scan(np.concatenate([T[k] for k in pdc]), np.concatenate([F[k] for k in pdc]), 30.0), flux="PDCSAP") if pdc else dict(scan(t, np.concatenate(F), 30.0), flux="detrended")
    flat = [f / gpu_host(gpu_running_median(f, 48)) for f in F]
    fl = np.concatenate(flat)
    dy = np.concatenate([np.full(len(x), 1.4826 * np.median(np.abs(x - 1.0))) for x in flat])
    res["transits"] = {}
    for P in periods:
        step = P * (1.0 / 24.0) / (2.0 * float(t.max() - t.min()))
        trials = np.arange(P * 0.98, P * 1.02, step)
        snr_b, depth_b, dur_b, mid_b = gpu_bls(t, fl, dy, trials, np.array([1, 2, 3, 4, 6]) / 24.0)
        k = int(np.argmax(snr_b))
        Pb, tc, dur = float(trials[k]), float(mid_b[k]), float(dur_b[k])
        events = []
        for ep in np.unique(np.round((t - tc) / Pb)):
            c = tc + ep * Pb
            inn = np.abs(t - c) < dur / 2
            near = (np.abs(t - c) < 2 * dur) & ~inn
            if inn.sum() >= 2 and near.sum() >= 4:
                depth = float(np.mean(fl[near]) - np.mean(fl[inn]))
                events.append(dict(epoch=int(ep), time=round(c, 3), points=int(inn.sum()), depth_ppm=round(1e6 * depth, 1),
                                   snr=round(depth / (np.std(fl[near]) / math.sqrt(inn.sum())), 1)))
        res["transits"]["%g" % P] = dict(period=round(Pb, 4), t0_btjd=round(tc, 4), duration_h=round(24 * dur, 1), depth_ppm=round(1e6 * float(depth_b[k]), 1),
                                         snr=round(float(snr_b[k]), 1), trials=len(trials), events=events)
    # each planet's conjunctions in the sectors from the sampled orbits, <name>.circular.json before <name>.json
    res["windows"] = {}
    op = next((json.load(open(f_)) for f_ in (os.path.join(planets_RESULTS, "orbits", archive_tag(name) + x) for x in (".circular.json", ".json"))
               if os.path.exists(f_)), None)
    if op:
        gs = archive_gaia_star(float(star["RAJ2000"]), float(star["DEJ2000"]), archive_num(star.get("Vmag"))) or {}
        rstar = planets_num(gs.get("radius_flame"))
        rstar = rstar if math.isfinite(rstar) else 1.0
        mstar = op.get("mstar") or planets_mass(star.get("SpType"))
        flat2 = [f / gpu_host(gpu_running_median(f, 96)) for f in F]
        for pl in op["planets"]:
            if "tc_mjd" not in pl or not any(abs(pl["P"][0] / P - 1.0) < 0.2 for P in periods):
                continue
            Pm, sP = pl["P"][0], 0.5 * (pl["P"][2] - pl["P"][1])
            Tc, sT = pl["tc_mjd"][0] - 56999.5, 0.5 * (pl["tc_mjd"][2] - pl["tc_mjd"][1])
            a_au = (mstar * (Pm / 365.25) ** 2) ** (1.0 / 3.0)
            full = Pm / np.pi * math.asin(min(1.0, rstar * 0.00465047 / a_au))
            wins, nearest = [], []
            for ts, fs, ss in zip(T, flat2, S):
                eb, ea = int(math.floor((ts.min() - Tc) / Pm)), int(math.ceil((ts.max() - Tc) / Pm))
                nearest.append(dict(sector=int(ss[0]), start_btjd=round(float(ts.min()), 2), end_btjd=round(float(ts.max()), 2),
                                    before=dict(epoch=eb, centre_btjd=round(Tc + eb * Pm, 2), sigma_d=round(math.hypot(sT, eb * sP), 2)),
                                    after=dict(epoch=ea, centre_btjd=round(Tc + ea * Pm, 2), sigma_d=round(math.hypot(sT, ea * sP), 2))))
                for ep in range(eb - 1, ea + 2):
                    c, s = Tc + ep * Pm, math.hypot(sT, ep * sP)
                    if c + 2 * s + full < ts.min() or c - 2 * s - full > ts.max():
                        continue
                    xs = np.arange(c - 3 * s, c + 3 * s, 1.0 / 48.0)
                    w = np.exp(-0.5 * ((xs - c) / s) ** 2) / (math.sqrt(2 * np.pi) * s * 48.0)
                    row = dict(sector=int(ss[0]), epoch=ep, centre_btjd=round(c, 3), sigma_d=round(s, 2))
                    gap, fd = (gpu_dev(ts)[None, :] - gpu_dev(xs)[:, None]).abs(), gpu_dev(fs)
                    for label, dur in (("central", full), ("half", 0.5 * full)):
                        # every box position of the window at once
                        inn, out = (gap < dur / 2).to(gpu_F64), ((gap < 1.5 * dur) & (gap >= dur / 2)).to(gpu_F64)
                        ni, no = inn.sum(1), out.sum(1)
                        mo = (out @ fd) / no.clamp(min=1)
                        depth = mo - (inn @ fd) / ni.clamp(min=1)
                        err = torch.sqrt(((out @ fd ** 2) / no.clamp(min=1) - mo ** 2).clamp(min=0.0) / ni.clamp(min=1))
                        ok = gpu_host((ni >= max(3, 0.5 * dur * 48)) & (no >= 6))
                        if ok.any():
                            snr, lim, depth = gpu_host(depth / err)[ok], gpu_host(depth + 3 * err)[ok], gpu_host(depth)[ok]
                            k = int(np.argmax(snr))
                            row[label] = dict(duration_h=round(24 * dur, 1), probability_covered=round(float(w[ok].sum()), 3), best_snr=round(float(snr[k]), 1),
                                              best_depth_ppm=round(1e6 * float(depth[k]), 1), limit_ppm=round(1e6 * float(lim.max()), 1),
                                              radius_limit_rearth=round(rstar * 109.08 * math.sqrt(max(float(lim.max()), 0.0)), 2))
                    if "central" in row:
                        wins.append(row)
            res["windows"]["%g" % pl["P"][0]] = dict(tc_btjd=round(Tc, 3), sigma_tc_d=round(sT, 3), P=Pm, sigma_P_d=round(sP, 4), rstar=rstar, mstar=mstar,
                                                     central_duration_h=round(24 * full, 1), windows=wins, nearest=nearest)
    os.makedirs(os.path.join(planets_RESULTS, "tess"), exist_ok=True)
    json.dump(res, open(os.path.join(planets_RESULTS, "tess", archive_tag(name) + ".json"), "w"), separators=(",", ":"))
    print("%s: %d sectors; all sectors peak %.2f d (%.0f ppm, %s)" % (name, len(res["sectors"]), res["combined"]["peak_d"], res["combined"]["semi_amplitude_ppm"],
                                                                     res["combined"]["fap"]), flush=True)
    for s in res["sectors"]:
        print("  sector %3d: peak %.2f d (%.0f ppm, %s)" % (s["sector"], s["peak_d"], s["semi_amplitude_ppm"], s["fap"]), flush=True)
    for P, b in res["transits"].items():
        print("  %s d: best box %.4f d, %.1f h, %.0f ppm, S/N %.1f; events %s" % (P, b["period"], b["duration_h"], b["depth_ppm"], b["snr"], ", ".join(
            "%.0f ppm (%.1f)" % (ev["depth_ppm"], ev["snr"]) for ev in b["events"][:12])), flush=True)
    for P, wd in res["windows"].items():
        covered = {w["sector"] for w in wd["windows"]}
        for x in wd["nearest"]:
            if x["sector"] not in covered:
                b, a_ = x["before"], x["after"]
                print("  %s d: no conjunction in sector %d (BTJD %.2f-%.2f); the nearest at %.2f +- %.2f d, %.1f d before it, and %.2f +- %.2f d, %.1f d after it" % (
                    P, x["sector"], x["start_btjd"], x["end_btjd"], b["centre_btjd"], b["sigma_d"], x["start_btjd"] - b["centre_btjd"], a_["centre_btjd"],
                    a_["sigma_d"], a_["centre_btjd"] - x["end_btjd"]), flush=True)
        for w in wd["windows"]:
            for label in ("central", "half"):
                if label in w:
                    x = w[label]
                    print("  %s d conjunction in sector %d at BTJD %.2f +- %.2f d, %.1f-h box: %.0f per cent of its probability covered, deepest %.0f ppm (S/N %.1f), "
                          "depth below %.0f ppm (3 sigma), radius below %.2f Earth radii" % (P, w["sector"], w["centre_btjd"], w["sigma_d"], x["duration_h"],
                                                                                           100 * x["probability_covered"], x["best_depth_ppm"], x["best_snr"],
                                                                                           x["limit_ppm"], x["radius_limit_rearth"]), flush=True)


def planets_tess_refresh(part=None):
    """Each star's TESS reading under RESULTS/tess (planets_tess) that did not read each sector's detrended flux (eclipses_fetch) read again at its periods from light curves fetched for it and
    removed after it. PART takes the share K/N; the pass ends between stars where a long search would end between them, with exit status 3, and a star an archive does not answer for
    comes round again at the next pass."""
    paths = sorted(glob.glob(os.path.join(planets_RESULTS, "tess", "*.json")))
    if part:
        k, n = (int(x) for x in part.split("/"))
        paths = paths[k::n]
    for path in paths:
        if planets_search_ends():
            sys.exit(3)
        rec = planets_load_json(path)
        if not rec or rec.get("detrended"):
            continue
        try:
            planets_lightcurve_drop(rec["name"])
            planets_tess(rec["name"], rec["periods"])
        except Exception as exc:
            print("%s: %s: %s" % (rec["name"], type(exc).__name__, str(exc)[:200]), flush=True)
        planets_lightcurve_drop(rec["name"])
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("share done", flush=True)


def planets_orbits_refresh(part=None):
    """Each star's sampled orbits under RESULTS/orbits that were not sampled by their conjunctions (planets_orbits) sampled again from their medians, a companion's orbit carried into its
    analysis, the stars of new planets first and their orbits' own runs before the circular and the companion's; then the weighing under RESULTS/weigh of each star with a new body that lacks planets_WEIGH_SAMPLER made again (planets_weigh), within a quarter of the periods it
    allowed where it bound them to a factor of two, carried into its star's analysis. PART takes the share K/N; the pass ends between stars where a long search would end between them, with exit status 3."""
    table = os.path.join(planets_RESULTS, "signals.csv")
    new = {archive_tag(r["name"]) for r in planets_read(table) if r["status"] == "new"} if os.path.exists(table) else set()
    paths = sorted(glob.glob(os.path.join(planets_RESULTS, "orbits", "*.json")), key=lambda p: (os.path.basename(p).split(".")[0] not in new, os.path.basename(p).count(".") > 1, p))
    if part:
        k, n = (int(x) for x in part.split("/"))
        paths = paths[k::n]
    for path in paths:
        if planets_search_ends():
            sys.exit(3)
        rec = planets_load_json(path)
        if not rec or not rec.get("planets") or rec.get("phase") == "conjunction":
            continue
        label = "companion" if ".companion" in os.path.basename(path) else None
        extra = planets_path("ledger", "%s.orbits.newer.npz" % archive_tag(rec["name"]))
        try:
            planets_orbits(rec["name"], [p["P"][0] for p in rec["planets"]], steps=rec.get("steps", 30000), circular=bool(rec.get("circular")), label=label,
                           extra=extra if "newer" in rec.get("series", []) and os.path.exists(extra) else None)
            kept = os.path.join(planets_RESULTS, "companion", archive_tag(rec["name"]) + ".json")
            c = planets_load_json(kept) if label else None
            if c and c.get("orbit"):
                o = planets_load_json(path)["planets"][0]
                c["orbit"] = {x: o[x] for x in ("P", "K", "e", "msini_mearth")}
                archive_save(kept, json.dumps(c, separators=(",", ":")).encode())
        except Exception as exc:
            print("%s: %s: %s" % (rec["name"], type(exc).__name__, str(exc)[:200]), flush=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    paths = sorted(p for p in glob.glob(os.path.join(planets_RESULTS, "weigh", "*.json")) if os.path.basename(p)[:-5] in new)
    if part:
        paths = paths[k::n]
    for path in paths:
        if planets_search_ends():
            sys.exit(3)
        w = planets_load_json(path)
        if not w or w.get("sampler") == planets_WEIGH_SAMPLER:
            continue
        a, b = (w["period_allowed"][0][0], w["period_allowed"][-1][1]) if w.get("period_allowed") else (0.0, float("inf"))
        band = dict(pmin=0.75 * a, pmax=1.25 * b) if a > 0 and b <= 2.0 * a else {}
        extra = planets_path("ledger", "%s.weigh.newer.npz" % archive_tag(w["name"]))
        try:
            planets_weigh(w["name"], extra=extra if os.path.exists(extra) else None, **band)
            kept = os.path.join(planets_RESULTS, "companion", archive_tag(w["name"]) + ".json")
            c = planets_load_json(kept)
            if c and c.get("weigh"):
                again = planets_load_json(path)
                c["weigh"] = {x: again[x] for x in c["weigh"] if x in again}
                archive_save(kept, json.dumps(c, separators=(",", ":")).encode())
        except (SystemExit, Exception) as exc:
            print("%s: %s: %s" % (w["name"], type(exc).__name__, str(exc)[:200]), flush=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("share done", flush=True)


# the spectrographs whose archived spectra test an orbit another's velocities gave, measured line by line, and the dates (MJD) on which their zero points moved
planets_SECOND = {"ESPRESSO": (58661.5,), "HARPS": (planets_HARPS_UPGRADE,)}


def planets_second_test(t, v, e, groups, orbits):
    """Velocities V at times T with errors E, an offset for each of GROUPS, held against the orbits ORBITS, each its posterior draws (P, tp, e, omega, K): a sinusoid at each orbit's median period
    with its amplitude and phase free, all fitted together with a jitter, and the same sinusoids fitted to each draw's curve at those times, which gives the amplitude and phase the first velocities
    predict and how far the draws spread them. Each orbit's amplitude over the prediction's median (scale), its error, the phase's distance from the prediction in sigma, the draws' spread and the
    fit's error together, and its verdict: failed where the scale falls short of one by more than the larger of 3 sigma and 30 per cent, or stands at 3 sigma at a phase 3 sigma off the prediction;
    held where it stands at 3 sigma otherwise, an amplitude above the prediction refuting nothing; open otherwise. Returns those, the jitter and the scatter the fit leaves."""
    Z = [(groups == g).astype(float) for g in np.unique(groups)]
    periods = [float(np.median(d[:, 0])) for d in orbits]
    X = np.column_stack(Z + [f(2.0 * np.pi * t / Q) for Q in periods for f in (np.cos, np.sin)])
    jit = 0.0
    for _ in range(8):
        s = np.sqrt(e ** 2 + jit ** 2)
        A = X / s[:, None]
        c = np.linalg.lstsq(A, v / s, rcond=None)[0]
        r = v - X @ c
        jit = math.sqrt(max(np.sum(r ** 2) / max(len(t) - X.shape[1], 1) - np.mean(e ** 2), 0.0))
    s = np.sqrt(e ** 2 + jit ** 2)
    A = X / s[:, None]
    c, cov, solve = np.linalg.lstsq(A, v / s, rcond=None)[0], np.linalg.pinv(A.T @ A), np.linalg.pinv(A)
    out = []
    wrap = lambda x: (x + np.pi) % (2.0 * np.pi) - np.pi
    for i, d in enumerate(orbits):
        k = len(Z) + 2 * i
        pred = (solve @ (planets_kepler_draws(t, d) / s[None, :]).T)[k:k + 2].T
        centre = math.atan2(float(np.mean(pred[:, 1] / np.hypot(*pred.T))), float(np.mean(pred[:, 0] / np.hypot(*pred.T))))
        spread = math.sqrt(float(np.mean(wrap(np.arctan2(pred[:, 1], pred[:, 0]) - centre) ** 2)))
        size, at = math.hypot(c[k], c[k + 1]), math.atan2(c[k + 1], c[k])
        radial, tangent = np.array([math.cos(at), math.sin(at)]), np.array([-math.sin(at), math.cos(at)])
        block = cov[k:k + 2, k:k + 2]
        want = float(np.median(np.hypot(*pred.T)))
        scale, err = size / want, math.sqrt(float(radial @ block @ radial)) / want
        off = abs(float(wrap(at - centre))) / math.hypot(spread, math.sqrt(float(tangent @ block @ tangent)) / size)
        seen = scale >= 3.0 * err
        out.append(dict(scale=round(scale, 3), scale_err=round(err, 3), phase_sigma=round(off, 2),
                        verdict="failed" if scale < 1.0 - max(3.0 * err, 0.3) or seen and off > 3.0 else "held" if seen else "open"))
    return out, round(jit, 2), round(float(np.std(v - X @ c)), 2)


def planets_second(part=None, least=6):
    """Each new planet's star's orbits (planets_orbits) tested in the archived spectra of a spectrograph its root's velocities did not come from (planets_SECOND), to RESULTS/second/<star>.json:
    the star's public spectra above a signal-to-noise ratio of 20 on LEAST nights or more, more than the orbits and the zero points leave no room below, measured line by line (planets_lbl),
    one a night, the nights another series of that instrument gave the orbits left out, and every orbit of the star held against them (planets_second_test). A star's test is made again once its
    orbits are sampled again, and a month on for spectra released since. PART takes the share K/N; the pass ends between stars where a long search would end between them, with exit status 3."""
    path = os.path.join(planets_RESULTS, "signals.csv")
    if not os.path.exists(path):
        return
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    names = sorted({r["name"] for r in planets_read(path) if (r["status"] == "new" or r["status"] == "likely" and r["reason"] == "activity modelled") and r["kind"] in ("found", "eccentric") and r["name"] in stars})
    if part:
        k, n = (int(x) for x in part.split("/"))
        names = names[k::n]
    own = json.load(open(planets_path("measure.json")))["inst"] if os.path.exists(planets_path("measure.json")) else planets_BANK_FAMILY
    folder = os.path.join(planets_RESULTS, "second")
    os.makedirs(folder, exist_ok=True)
    for name in names:
        if planets_search_ends():
            sys.exit(3)
        tag, kept = archive_tag(name), os.path.join(folder, archive_tag(name) + ".json")
        orbit_path = os.path.join(planets_RESULTS, "orbits", tag + ".json")
        o = planets_load_json(orbit_path)
        if not o or o.get("phase") != "conjunction" or "draws" not in o:
            continue
        rec = planets_load_json(kept)
        sampled = os.path.getmtime(orbit_path)
        if rec and rec.get("orbits_sampled") == sampled and time.time() - os.path.getmtime(kept) < 30 * 86400.0:
            continue
        s = stars[name]
        draws = planets_draws_load(orbit_path, o)["draws"]
        tests = []
        try:
            for inst, eras in planets_SECOND.items():
                if inst == own:
                    continue
                listing = archive_eso_listing(float(s["RAJ2000"]), float(s["DEJ2000"]), inst, 20.0)
                # the nights another series of the instrument gave the orbits
                used = {math.floor(x[0] + 0.3) for k_, xs in planets_dace_series({name}).get(name, {}).items() if planets_family(k_[0]) == inst and any(inst in lab for lab in o["series"]) for x in xs}
                listing = [x for x in listing if math.floor(float(x["t_min"]) + 0.3) not in used]
                nights = len({math.floor(float(x["t_min"]) + 0.3) for x in listing})
                line = dict(inst=inst, nights=nights)
                if nights >= max(least, 2 * len(draws) + len(eras) + 4):
                    second = "%s_%s" % (tag, inst)
                    lp = planets_path("lbl", second + ".lbl.npz")
                    if not os.path.exists(lp) or float(np.load(lp)["mjd"].max()) < max(float(x["t_min"]) for x in listing) - 0.5:
                        planets_lbl(second, streams=4, ra=float(s["RAJ2000"]), dec=float(s["DEJ2000"]), least=least, listing=listing, inst=inst)
                    d = np.load(lp)
                    m = np.isfinite(d["rv"]) & np.isfinite(d["rv_err"]) & ~(d["cal_age"] > 30.0) & ~np.isin(np.floor(d["mjd"] + 0.3), sorted(used))
                    t, v, e = planets_by_night(d["mjd"][m], d["rv"][m], d["rv_err"][m])
                    if len(t) >= 2 * len(draws) + len(eras) + 4:
                        got, jit, rms = planets_second_test(t, v, e, np.searchsorted(eras, t), list(draws))
                        line.update(nights=len(t), first=round(float(t.min()), 1), last=round(float(t.max()), 1), jitter=jit, rms=rms, planets=[dict(g, P=p["P"][0]) for g, p in zip(got, o["planets"])])
                tests.append(line)
                print("%s %s: %s" % (name, inst, "; ".join("P %.4g scale %.2f +- %.2f, phase off by %.1f sigma, %s" % (x["P"], x["scale"], x["scale_err"], x["phase_sigma"], x["verdict"]) for x in line.get("planets", []))
                                     or "%d nights" % nights), flush=True)
            archive_save(kept, json.dumps(dict(name=name, orbits_sampled=sampled, tests=tests), separators=(",", ":")).encode())
        except (SystemExit, Exception) as exc:
            print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
    print("share done", flush=True)


def planets_second_decide(sig):
    """The new planets of SIG given what their stars' tests in another spectrograph's spectra (planets_second) hold of them, within 5 per cent in period, their columns second_instrument,
    second_nights, second_scale, second_scale_err, second_phase_sigma and second_test, the instrument's that measures it best where two do; a planet that fails is rejected, and one whose activity was modelled is new once it holds."""
    for r in sig:
        if not (r["status"] == "new" or r["status"] == "likely" and r["reason"] == "activity modelled") or r["kind"] not in ("found", "eccentric"):
            continue
        rec = planets_load_json(os.path.join(planets_RESULTS, "second", archive_tag(r["name"]) + ".json")) or {}
        P = planets_num(r.get("orbit_P") or r["P"])
        hits = [dict(p, inst=t["inst"], nights=t["nights"]) for t in rec.get("tests", []) for p in t.get("planets", []) if abs(p["P"] / P - 1.0) < 0.05]
        if hits:
            x = next((h for h in hits if h["verdict"] == "failed"), min(hits, key=lambda h: h["scale_err"]))
            r.update(second_instrument=x["inst"], second_nights=x["nights"], second_scale=x["scale"], second_scale_err=x["scale_err"], second_phase_sigma=x["phase_sigma"], second_test=x["verdict"])
            if x["verdict"] == "failed":
                r.update(status="rejected", reason="second instrument")
            elif x["verdict"] == "held" and r["status"] == "likely":
                r.update(status="new", reason="")


def planets_reduce(part=None):
    """The signals of RESULTS/signals.csv that stop at one reduction given another, the star's archived HARPS spectra measured line by line (planets_lbl) where it has none: the star's signals vetted again with them, and each that two reductions then hold, with no indicator at its period, followed (planets_followup_star), so that the next decision takes it up. A star whose vet came after its line-by-line velocities is passed over; one without ten usable spectra is noted in RESULTS/reduce/<star>.json and left; one an archive does not answer for comes round again. PART takes the share K/N; the pass ends between stars where a long search would end between them, with exit status 3."""
    table = os.path.join(planets_RESULTS, "signals.csv")
    if not os.path.exists(table):
        return
    rows = planets_read(table)
    todo = {}
    for r in rows:
        if r["kind"] in ("found", "eccentric") and r["reason"] == "one reduction":
            todo.setdefault(r["name"], []).append(float(r["P"]))
    names = sorted(todo)
    if part:
        k, n = (int(x) for x in part.split("/"))
        names = names[k::n]
    folder = os.path.join(planets_RESULTS, "reduce")
    os.makedirs(folder, exist_ok=True)
    for name in names:
        tag = archive_tag(name)
        kept, measured, vetted_at = os.path.join(folder, tag + ".json"), planets_path("lbl", tag + ".lbl.npz"), os.path.join(planets_RESULTS, "vet", tag + ".json")
        if os.path.exists(kept) or os.path.exists(measured) and os.path.exists(vetted_at) and os.path.getmtime(vetted_at) >= os.path.getmtime(measured):
            continue
        if planets_search_ends():
            sys.exit(3)
        try:
            try:
                if not os.path.exists(measured):
                    planets_lbl(name, streams=4)
            except SystemExit as exc:
                archive_save(kept, json.dumps(dict(name=name, note=str(exc)[:200])).encode())
                print("%s: %s" % (name, str(exc)[:200]), flush=True)
                continue
            vetted = planets_vet([(name, todo[name])], show=False)[name]
            verdicts = {P: planets_verdict(vetted, P) for P in todo[name]}
            follow = [P for P, v in verdicts.items() if planets_families(v[0]) >= 2 and not v[2]]
            if follow:
                planets_followup_star(name, follow, [float(r["P"]) for r in rows if r["name"] == name and r["kind"] == "known"], lbl_streams=4)
            archive_save(kept, json.dumps(dict(name=name, periods=todo[name], followed=follow, verdicts={"%g" % P: v[3] for P, v in verdicts.items()})).encode())
            print("%s: %s" % (name, "; ".join("%g d %s" % (P, v[3]) for P, v in verdicts.items())), flush=True)
        except Exception as exc:
            print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("share done", flush=True)


def planets_night_mover(times, rng):
    """A function moving times to other nights' dates: each night of TIMES (MJD) given another's at random by the generator RNG, its times keeping their offsets from its start, so that what the reductions of a night share stays together and what repeats from night to night does not."""
    bases = np.unique(np.floor(np.asarray(times, float) + 0.3))
    moved = rng.permutation(bases)

    def mv(t):
        t = np.asarray(t, float)
        night = np.floor(t + 0.3)
        return moved[np.clip(np.searchsorted(bases, night), 0, len(bases) - 1)] + (t - night)
    return mv


def planets_null_census(seed=31):
    """The census and its vet measured against noise alone, to RESULTS/null_census.json: each star's nights moved to one another's dates (planets_night_mover), which keeps every velocity's noise and what its reductions share and breaks whatever repeats in time, searched without the archive's planets (planets_search_stream), and each signal past the flags, the companions' masses and the triage vetted as the census's are (planets_vet_star): how many are found, unflagged, past the triage and held by two reductions with no indicator at their periods, which would be followed, set against the same counts of the real velocities in RESULTS/signals.csv. The record keeps a digest of the rules it tried, and a run with the same digest does nothing; the run ends between stars where a long search would, with exit status 3."""
    digest = planets_rules_hash(("planets_null_census", "planets_night_mover", "planets_search_steps", "planets_vet_star", "planets_reduction", "planets_verdict", "planets_triage", "planets_indicator", "planets_families"))
    path, table = os.path.join(planets_RESULTS, "null_census.json"), os.path.join(planets_RESULTS, "signals.csv")
    if (planets_load_json(path) or {}).get("digest") == digest or not os.path.exists(table) or os.path.exists(planets_path("tess.json")):
        return
    names, stars, _, _ = planets_share()
    bank, raw, dace = planets_bank_series(set(names)), planets_bank_raw(set(names)), planets_dace_series(set(names))
    jobs, movers = [], {}
    for name in names:
        rows, labels = planets_series(name, dace, bank, stars.get(name, {}).get("SpType"))
        if not rows:
            continue
        times = [x[0] for x in bank.get(name, [])] + [x[0] for xs in dace.get(name, {}).values() for x in xs] + [float(r["BJD"]) - 2400000.5 for r in raw.get(name, [])]
        lp = planets_path("lbl", archive_tag(name) + ".lbl.npz")
        if os.path.exists(lp):
            with np.load(lp) as d:
                times += d["mjd"].tolist()
        movers[name] = planets_night_mover(times, np.random.default_rng(seed + zlib.crc32(name.encode())))
        moved = np.array(rows, float)
        moved[:, 0] = movers[name](moved[:, 0])
        jobs.append((name, moved.tolist(), labels, stars.get(name, {}), {}, lambda *a: None, False, None))
    signals, modelled = [], 0
    for _, got in planets_search_stream(jobs):
        if planets_search_ends():
            sys.exit(3)
        if got:
            modelled += 1
            signals += [r for r in got[1] if r["kind"] == "found"]
    light = [r for r in signals if float(r["msini_mjup"]) <= 13.0 and float(r["K"]) < 100.0]
    clean = [r for r in light if not r["flags"]]
    kept, _ = planets_triage(clean, stars)
    periods = {}
    for r in kept:
        periods.setdefault(r["name"], []).append(float(r["P"]))
    held, one, active = [], 0, 0
    for name, ps in periods.items():
        if planets_search_ends():
            sys.exit(3)
        res = planets_vet_star(name, ps, bank.get(name, []), raw.get(name, []), dace.get(name, {}), movers[name])
        for P in ps:
            verdict = planets_verdict(res, P)
            if verdict[2]:
                active += 1
            elif planets_families(verdict[0]) >= 2:
                held.append(dict(name=name, P=P, text=verdict[3]))
            else:
                one += 1
    real = [r for r in planets_read(table) if r["kind"] == "found"]
    aside = {"degenerate fit", "under two cycles", "year alias", "archive planet"}
    past = [r for r in real if r["reason"] not in ("flagged", "companion") and not set(r["reason"].split("; ")) & aside]
    out = dict(digest=digest, finished=time.strftime("%Y-%m-%d %H:%M:%S"), stars=modelled, moved=dict(found=len(signals), below_a_companion=len(light), unflagged=len(clean), past_the_triage=len(kept), one_reduction=one, an_indicator=active, followed=len(held)),
               real=dict(found=len(real), past_the_triage=len(past), one_reduction=sum(1 for r in past if r["reason"] == "one reduction"), an_indicator=sum(1 for r in past if r["reason"] == "activity indicator"), followed=sum(1 for r in past if r["reason"] not in ("one reduction", "activity indicator"))), held=held)
    archive_save(path, json.dumps(out, separators=(",", ":")).encode())
    print("%d stars: moved %s; real %s" % (modelled, out["moved"], out["real"]), flush=True)


def planets_call(f, timeout, *args, **kw):
    """F's value, or None when it raises or runs past TIMEOUT seconds (it is then left running in a daemon thread)."""
    out = {}

    def run():
        try:
            out["v"] = f(*args, **kw)
        except Exception:
            pass
    th = threading.Thread(target=run, daemon=True)
    th.start()
    th.join(timeout)
    return out.get("v")


def planets_transit_rv_fit(t, v, e, g, P, Tc, mstar):
    """Nightly velocities T (MJD), V and E (m/s) of the series G fitted with an offset per series, a linear trend over 300 days of span or more, a jitter
    and a circular orbit at the period P: once with the transit's phase held at Tc (MJD), the star's velocity -K sin 2 pi (t - Tc) / P with K free and
    signed, and once with the phase free. Returns the nights and span, the held fit's K, its error and signal-to-noise, the free fit's K and its phase
    from the transit's with their errors, the jitter, and the minimum mass (Earth's) the held K gives about a star of MSTAR solar masses."""
    span = float(t.max() - t.min())
    tt = (t - t.mean()) / 365.25
    base = [(g == gi).astype(float) for gi in np.unique(g)] + ([tt] if span >= 300 else [])
    held = -np.sin(2 * np.pi * (t - Tc) / P)
    jit = 0.0
    for _ in range(4):
        s = np.hypot(e, jit)
        X = np.column_stack(base + [held])
        r_ = v - X @ np.linalg.lstsq(X / s[:, None], v / s, rcond=None)[0]
        jit = math.sqrt(max(np.mean(r_ ** 2) - np.mean(e ** 2), 0.0))
    s = np.hypot(e, jit)
    A = np.column_stack(base + [held]) / s[:, None]
    c = np.linalg.lstsq(A, v / s, rcond=None)[0]
    K, eK = float(c[-1]), float(math.sqrt(np.linalg.pinv(A.T @ A)[-1, -1]))
    Af = np.column_stack(base + [held, np.cos(2 * np.pi * (t - Tc) / P)]) / s[:, None]
    cf_ = np.linalg.lstsq(Af, v / s, rcond=None)[0]
    Kf, eKf, ph, eph = planets_amplitude(cf_, np.linalg.pinv(Af.T @ Af))
    return dict(nights=len(t), span_d=round(span), K=round(K, 2), eK=round(eK, 2), snr=round(K / eK, 1) if eK > 0 else "", K_free=round(Kf, 2),
                eK_free=round(eKf, 2), phase_offset_deg=round((ph + 180.0) % 360.0 - 180.0, 0), ephase_deg=round(eph, 1), jitter=round(jit, 2),
                msini_mearth=round(planets_msini(P, abs(K), 0.0, mstar) * 317.83, 1))


def planets_tois(tmag=12.0, threads=3, timeout=60.0, fit_only=False, source="dace", streams=4):
    """TESS's planet candidates weighed with archived velocities, to ROOT/tois.csv. ExoFOP's TOI table is read, and every TOI the TFOPWG lists as a planet
    candidate (PC or APC) brighter than TMAG in the TESS band is looked up in DACE within 10 arcsec, each call given TIMEOUT seconds; the public velocities
    found are kept in ROOT/toi_dace.csv (FIT_ONLY reads them from there). Each candidate's series are chosen and cleaned as the census's are, averaged per
    night, and fitted with an offset per series, a linear trend over 300 days of span or more, a jitter, and a circular orbit at the TESS period: once with
    the transit's phase held, the star's velocity -K sin 2 pi (t - Tc) / P with K free and signed, and once with the phase free. The held phase is good where
    the ephemeris carries to the velocities' mean epoch within 0.1 of a period. Each row: the position, the velocities' nights, span and series, both
    fits' K with its error, the free fit's phase from the transit's with its error, ExoFOP's predicted K, the minimum mass from the held fit, and whether
    the NASA Exoplanet Archive lists the host. SOURCE eso measures the archive's HARPS spectra line by line (planets_lbl) in place of DACE, to
    ROOT/tois_eso.csv; SOURCE rvcat takes the pipeline velocities of ESO's HARPS velocity catalogue (HARPS_RVCAT_2023_DR1, as planets_rvcat keeps it in
    ROOT) of the star within 5 arcsec of the candidate by SIMBAD's J2000 position, in the instrument mode and mask most of its spectra share, to
    ROOT/tois_rvcat.csv; SOURCE bank takes the velocities of the root's own star within 10 arcsec of the candidate, chosen and cleaned as the census's are, to ROOT/tois_bank.csv."""
    from astropy.coordinates import Angle, SkyCoord
    os.makedirs(planets_ROOT, exist_ok=True)
    path = planets_path("toi.csv")
    if not fit_only or not os.path.exists(path):
        open(path, "wb").write(archive_get(planets_EXOFOP["toi"], timeout=300))
    rows = [r for r in planets_read(path) if r["TFOPWG Disposition"] in ("PC", "APC") and planets_num(r["TESS Mag"]) < tmag]
    by_toi = {r["TOI"]: r for r in rows}
    got = {}
    vpath = planets_path("toi_dace.csv")
    if source == "eso":
        # Each candidate's HARPS spectra are listed from a single query of the archive's index; candidates with six nights or more are measured
        # line by line.
        pos = [(Angle(r["RA"], unit="hourangle").deg, Angle(r["Dec"], unit="deg").deg) for r in rows]
        for r, (ra, dec), listing in zip(rows, pos, archive_eso_listings(pos, "HARPS", 20.0)):
            if len({math.floor(x["t_min"] + 0.3) for x in listing}) < 6:
                continue
            tag = "TOI-" + r["TOI"].split(".")[0]
            lp = planets_path("lbl", archive_tag(tag) + ".lbl.npz")
            if not os.path.exists(lp):
                try:
                    planets_lbl(tag, streams=streams, ra=ra, dec=dec, least=6, listing=listing)
                except BaseException as exc:
                    print("%s: %s" % (tag, str(exc)[:160]), flush=True)
                    continue
            d = np.load(lp)
            ok = np.isfinite(d["rv"]) & np.isfinite(d["rv_err"]) & ~(d["cal_age"] > 30.0)
            got[r["TOI"]] = [dict(toi=r["TOI"], dace_name=tag, inst="HARPS15" if t >= planets_HARPS_UPGRADE else "HARPS03", drs="LBL", mode="HARPS", mjd=t, rv=v,
                                  rv_err=e, qc=1.0) for t, v, e in zip(d["mjd"][ok], d["rv"][ok], d["rv_err"][ok])]
    elif source == "bank":
        table = planets_read(planets_path("bank_stars.csv"))
        if not table:
            return
        sra, sdec = np.array([planets_num(s["RAJ2000"]) for s in table]), np.array([planets_num(s["DEJ2000"]) for s in table])
        bank, dace = planets_bank_series(), planets_dace_series()
        for r in rows:
            ra, dec = Angle(r["RA"], unit="hourangle").deg, Angle(r["Dec"], unit="deg").deg
            sep = np.hypot((np.remainder(sra - ra + 180.0, 360.0) - 180.0) * math.cos(math.radians(dec)), sdec - dec) * 3600.0
            k = int(np.nanargmin(sep))
            if sep[k] < 10.0:
                series, labels = planets_series(table[k]["Name"], dace, bank, table[k].get("SpType"))
                got[r["TOI"]] = [dict(toi=r["TOI"], dace_name=table[k]["Name"], inst=labels[int(x[3])], drs="CCF", mode="", mjd=x[0], rv=x[1], rv_err=x[2], qc=1.0) for x in series]
    elif source == "rvcat":
        from astropy.io import fits
        d = fits.getdata(planets_path("HARPS_RVCAT_2023_DR1.fits"), 1)
        col = lambda k: np.asarray(d[k])
        text = lambda k: np.char.strip(col(k).astype(str))
        sid, rv, err = text("main_id_simbad"), col("drs_ccf_rvc").astype(float), col("drs_dvrms").astype(float)
        idx = np.where(np.char.startswith(np.char.upper(text("dpr_type")), "STAR") & np.isfinite(rv) & (np.abs(rv) < 1000.0) & np.isfinite(err) & (err > 0) &
                       (err < 1000.0) & (sid != ""))[0]
        stars, first = np.unique(sid[idx], return_index=True)
        sra, sdec = col("ra_simbad").astype(float)[idx[first]], col("dec_simbad").astype(float)[idx[first]]
        setting, mjd = np.char.add(text("ins_mode"), np.char.add("|", text("drs_mask"))), col("drs_bjd").astype(float) - 2400000.5
        for r in rows:
            ra, dec = Angle(r["RA"], unit="hourangle").deg, Angle(r["Dec"], unit="deg").deg
            sep = np.hypot((np.remainder(sra - ra + 180.0, 360.0) - 180.0) * math.cos(math.radians(dec)), sdec - dec) * 3600.0
            k = int(np.nanargmin(sep))
            if not sep[k] < 5.0:
                continue
            mine = idx[sid[idx] == stars[k]]
            top = max(set(setting[mine]), key=list(setting[mine]).count)
            mine = mine[setting[mine] == top]
            got[r["TOI"]] = [dict(toi=r["TOI"], dace_name=str(stars[k]), inst="HARPS15" if t >= planets_HARPS_UPGRADE else "HARPS03", drs="DRS", mode=str(top), mjd=t,
                                  rv=1000.0 * v, rv_err=e, qc=1.0) for t, v, e in zip(mjd[mine], rv[mine], err[mine])]
    elif fit_only:
        for x in csv.DictReader(open(vpath, encoding="utf-8")):
            if x["toi"] in by_toi:
                got.setdefault(x["toi"], []).append(x)
    else:
        from dace_query.spectroscopy import Spectroscopy
        logging.disable(logging.ERROR)
        # DACE asked once first: where it does not answer, the velocities it gave before are kept and its weighing left as it stands
        if rows and planets_call(Spectroscopy.query_region, timeout, sky_coord=SkyCoord(Angle(rows[0]["RA"], unit="hourangle").deg,
                                                                                         Angle(rows[0]["Dec"], unit="deg").deg, unit="deg"),
                                 angle=Angle(10, unit="arcsec"), limit=1, output_format="dict") is None:
            print("DACE does not answer; %s kept" % ("tois.csv" if os.path.exists(planets_path("tois.csv")) else "nothing weighed"), flush=True)
            return

        def one(r):
            q = planets_call(Spectroscopy.query_region, timeout, sky_coord=SkyCoord(Angle(r["RA"], unit="hourangle").deg, Angle(r["Dec"], unit="deg").deg, unit="deg"),
                             angle=Angle(10, unit="arcsec"), limit=100000, output_format="dict")
            names = [n for n in (q or {}).get("target_name", []) if n]
            if not names:
                return r, []
            tn = max(set(names), key=names.count)
            g = planets_call(Spectroscopy.get_timeseries, timeout, tn, sorted_by_instrument=True, output_format="numpy") or {}
            out = []
            for inst, d in g.items():
                for drs, d2 in d.items():
                    for mode, d3 in d2.items():
                        m = len(d3["rjd"])
                        for x in zip(d3["rjd"], d3["rv"], d3["rv_err"], d3["drs_qc"] if "drs_qc" in d3 else [float("nan")] * m):
                            try:
                                vals = [float(y) for y in x]
                            except (TypeError, ValueError):
                                continue
                            if all(math.isfinite(y) for y in vals[:3]):
                                out.append(dict(toi=r["TOI"], dace_name=tn, inst=str(inst), drs=str(drs), mode=str(mode), mjd=vals[0] - 0.5, rv=vals[1], rv_err=vals[2],
                                                qc=vals[3]))
            return r, out

        with open(vpath, "w", newline="", encoding="utf-8") as fh:
            w = csv.DictWriter(fh, fieldnames=["toi", "dace_name", "inst", "drs", "mode", "mjd", "rv", "rv_err", "qc"])
            w.writeheader()
            with cf.ThreadPoolExecutor(threads) as ex:
                for i, f in enumerate(cf.as_completed([ex.submit(one, r) for r in rows])):
                    r, out = f.result()
                    w.writerows(out)
                    if out:
                        got[r["TOI"]] = [{k: str(v) for k, v in x.items()} for x in out]
                    if (i + 1) % 100 == 0:
                        fh.flush()
                        print("%d of %d candidates looked up, %d with velocities" % (i + 1, len(rows), len(got)), flush=True)
    planets_of, host_of = planets_known(planets_path("known.csv")) if os.path.exists(planets_path("known.csv")) else ({}, None)
    res = []
    for toi_id, xs in got.items():
        r = by_toi[toi_id]
        insts = {}
        for x in xs:
            e = planets_num(x["rv_err"])
            if planets_num(x["qc"]) != 0.0 and 0 < e < 1e3:
                insts.setdefault((x["inst"], x["drs"], x["mode"]), []).append([float(x["mjd"]), float(x["rv"]), e] + [float("nan")] * 6)
        insts = {k: planets_clean(x) for k, x in insts.items() if len(x) >= 3}
        keep = sorted(planets_choose(insts), key=lambda k: -len(insts[k]))
        T, V, E, G = [], [], [], []
        for gi, k in enumerate(keep):
            y = np.array(insts[k])
            tn, vn, en = planets_by_night(y[:, 0], y[:, 1], y[:, 2])
            if len(tn) >= 3:
                T.append(tn), V.append(vn), E.append(en), G.append(np.full(len(tn), gi))
        P, Tc = planets_num(r["Period (days)"]), planets_num(r["Epoch (BJD)"]) - 2400000.5
        if not T or sum(len(z) for z in T) < 6 or not (P > 0 and math.isfinite(Tc)):
            continue
        t, v, e, g = (np.concatenate(z) for z in (T, V, E, G))
        eP, eTc = planets_num(r["Period (days) err"]), planets_num(r["Epoch (BJD) err"])
        n_cyc = abs(t.mean() - Tc) / P
        phase_err = math.hypot(eTc if math.isfinite(eTc) else 0.0, n_cyc * (eP if math.isfinite(eP) else 0.0)) / P
        mstar = planets_num(r["Stellar Mass (M_Sun)"])
        mstar = mstar if mstar > 0 else 1.0
        fit = planets_transit_rv_fit(t, v, e, g, P, Tc, mstar)
        host = host_of("TOI-" + toi_id.split(".")[0], xs[0]["dace_name"], float("nan"), float("nan")) if host_of else None
        res.append(dict(toi=toi_id, tic=r["TIC ID"], dace_name=xs[0]["dace_name"], ra=round(Angle(r["RA"], unit="hourangle").deg, 6),
                        dec=round(Angle(r["Dec"], unit="deg").deg, 6), disposition=r["TFOPWG Disposition"], tmag=r["TESS Mag"], period=P,
                        radius_rearth=r["Planet Radius (R_Earth)"], k_predicted=r["Predicted RV Semi-amplitude (m/s)"], nights=fit["nights"], span_d=fit["span_d"],
                        series="; ".join(" ".join(z for z in k if z) for k in keep), phase_err=round(phase_err, 3),
                        **{k: fit[k] for k in ("K", "eK", "snr", "K_free", "eK_free", "phase_offset_deg", "ephase_deg", "jitter", "msini_mearth")}, mstar=mstar,
                        archive_host=host or ""))
    res.sort(key=lambda x: -(x["snr"] or 0))
    planets_write(planets_path(dict(dace="tois.csv", eso="tois_eso.csv", rvcat="tois_rvcat.csv", bank="tois_bank.csv")[source]), res, list(res[0].keys()) if res else ["toi"])
    print("%d candidates with 6 nights or more of public velocities" % len(res), flush=True)
    for x in res:
        if (x["snr"] or 0) >= 3:
            print("TOI-%-9s %-20s P %9.4f R %6s | n %4d | K %8.2f +- %6.2f (%5.1f sigma) | free phase %+4.0f deg | msini %8.1f | %s" % (
                x["toi"], x["dace_name"][:20], x["period"], str(x["radius_rearth"])[:6], x["nights"], x["K"], x["eK"], x["snr"], x["phase_offset_deg"],
                x["msini_mearth"], x["archive_host"] or "-"), flush=True)


def planets_nights(name):
    """A star's bank velocities averaged per night, each side of the fibre upgrade with three nights or more a group of its own: times, velocities,
    errors and group numbers, in time order."""
    x = np.array(planets_bank_series({name}).get(name, []))
    T, V, E, G = [], [], [], []
    for sel in (x[:, 0] < planets_UPGRADE, x[:, 0] >= planets_UPGRADE):
        if sel.sum() >= 3:
            tn, vn, en = planets_by_night(x[sel, 0], x[sel, 1], x[sel, 2])
            T.append(tn), V.append(vn), E.append(en), G.append(np.full(len(tn), len(G)))
    t, v, e, g = (np.concatenate(z) for z in (T, V, E, G))
    o = np.argsort(t)
    return t[o], v[o], e[o], g[o]


def planets_nights_all(name):
    """A star's bank velocities and, beside them, every DACE instrument family outside HARPS with 5 nights or more, its pipeline or publication with the
    most velocities, cleaned as the census cleans: times, velocities, errors, group numbers (each side of the fibre upgrade and each other era a group),
    family numbers (0 for HARPS), the groups' labels and the families' names, in time order."""
    t, v, e, g = planets_nights(name)
    labels, names = ["%s pre" % planets_BANK_FAMILY, "%s post" % planets_BANK_FAMILY][:int(g.max()) + 1], [planets_BANK_FAMILY]
    T, V, E, G, F = [t], [v], [e], [g], [np.zeros(len(t), int)]
    fams = {}
    for k, xs in planets_dace_series({name}).get(name, {}).items():
        if planets_family(k[0]) != planets_BANK_FAMILY:
            fams.setdefault(planets_family(k[0]), {}).setdefault(k[1], []).append((k, xs))
    for fam, pubs in sorted(fams.items()):
        kb = max(pubs, key=lambda b: sum(len(xs) for _, xs in pubs[b]))
        for k, xs in pubs[kb]:
            y = np.array(planets_clean(xs))
            if len(y) < 5 or np.median(y[:, 2]) > 20.0:
                continue
            if names[-1] != fam:
                names.append(fam)
            tn, vn, en = planets_by_night(y[:, 0], y[:, 1], y[:, 2])
            T.append(tn), V.append(vn), E.append(en), G.append(np.full(len(tn), len(labels))), F.append(np.full(len(tn), len(names) - 1))
            labels.append(" ".join(z for z in k if z))
    t, v, e, g, f = (np.concatenate(z) for z in (T, V, E, G, F))
    o = np.argsort(t)
    return t[o], v[o], e[o], g[o], f[o], labels, names


def planets_system(name, periods, sims=300, grid=40, trials=8, orbits=1e6, mstar=None, others=True, title=None):
    """A planetary system's case from the bank's velocities and every other telescope's beside them (the bank's alone where OTHERS is false), to
    RESULTS/system/<name>/: sequential
    generalised Lomb-Scargle periodograms, each signal's sinusoid fitted jointly with those before, and the window function; maximum-likelihood Keplerian
    models of one planet fewer to one more than PERIODS, the extra one at the next periodogram peak, each with free and with circular orbits, an offset per
    series and a jitter per telescope, their log-likelihoods, BIC, jitters and scatter; for each planet, each of its 1-day and 1-year aliases within the
    periods searched and more than 3 per cent from its period, the alias being the highest peak within 1.5 per cent of |1/P +- 1/day| or |1/P +- 1/year|:
    the circular model refitted with the planet there, and SIMS sets of velocities drawn at the observed times from the circular model with the planet at
    its period and SIMS with it at the alias, the observed ratio of the two peaks' powers set against both; for two planets or more, with REBOUND, the
    system at the minimum masses integrated by WHFast for ORBITS orbits of the innermost planet, circular and with the free fit's eccentricities, with
    MEGNO; and detection limits, circular orbits injected into the circular model's residuals on GRID periods and 16 amplitudes, TRIALS phases each,
    recovered where the residual periodogram's highest peak lies within 2 per cent of the period at a Baluev false-alarm level below 1e-3. Figures of the
    periodograms, the phased orbits (each telescope in its own colour, each planet named after TITLE, by default the bank's name for the star) and the
    limits beside the JSON summary."""
    from astropy.timeseries import LombScargle
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    star = next(r for r in planets_read(planets_path("bank_stars.csv")) if r["Name"] == name)
    mstar = mstar or planets_star_mass(star)
    if others:
        t, v, e, g, fam, glabels, fnames = planets_nights_all(name)
    else:
        t, v, e, g = planets_nights(name)
        fam, glabels, fnames = np.zeros(len(t), int), ["%s pre" % planets_BANK_FAMILY, "%s post" % planets_BANK_FAMILY][:int(g.max()) + 1], [planets_BANK_FAMILY]
    ng = int(g.max()) + 1
    span = float(t.max() - t.min())
    folder = os.path.join(planets_RESULTS, "system", archive_tag(name))
    os.makedirs(folder, exist_ok=True)
    out = dict(name=name, periods=periods, mstar=mstar, nights=len(t), span=round(span, 1), median_error=round(float(np.median(e)), 3))
    freq = np.linspace(1.0 / min(3000.0, 2.0 * span), 1.0 / 1.2, 120000)
    n = len(periods)

    def model(p, k, tt=None, gg=None):
        """The velocities of parameters P with K planets at the times TT of groups GG, by default the star's own."""
        tt, gg = (t, g) if tt is None else (tt, gg)
        m = p[:ng][gg].copy()
        for i in range(k):
            P, tp, sc, ss, K = p[ng + 1 + 5 * i:ng + 6 + 5 * i]
            m = m + K * planets_kepler(tt, P, tp, min(sc * sc + ss * ss, 0.95), math.atan2(ss, sc))
        return m

    nf = int(fam.max()) + 1

    def jitters(r):
        """Each telescope's jitter from residuals R: the excess of their mean square over its errors' mean square."""
        return np.array([math.sqrt(max(np.mean(r[fam == f] ** 2) - np.mean(e[fam == f] ** 2), 0.0)) for f in range(nf)])

    def fit_ml(pers, circular=False):
        """Least-squares Keplerians from circular starts, each period within 3 per cent of its start, each telescope's jitter iterated: parameters (the
        first telescope's jitter in the jitter's slot), lnL and the jitters."""
        k = len(pers)
        cols = [(g == j).astype(float) for j in range(ng)]
        for P in pers:
            cols += [np.cos(2 * np.pi * t / P), np.sin(2 * np.pi * t / P)]
        c = np.linalg.lstsq(np.column_stack(cols) / e[:, None], v / e, rcond=None)[0]
        p = list(c[:ng]) + [1.0]
        for i, P in enumerate(pers):
            A, B = c[ng + 2 * i], c[ng + 2 * i + 1]
            p += [P, P * math.atan2(B, A) / (2 * np.pi), 0.0 if circular else 0.05, 0.0, max(math.hypot(A, B), 0.2)]
        p = np.array(p)
        free = [i for i in range(len(p)) if i != ng and not (circular and i > ng and (i - ng - 1) % 5 in (2, 3))]
        lo, hi = np.full(len(p), -np.inf), np.full(len(p), np.inf)
        for i in range(k):
            j = ng + 1 + 5 * i
            lo[j], hi[j] = pers[i] * 0.97, pers[i] * 1.03
            lo[j + 2:j + 4], hi[j + 2:j + 4] = -0.9, 0.9
            lo[j + 4], hi[j + 4] = 0.0, 1e4
        jit = np.ones(nf)
        Tt, Vt, Gt, free_t = gpu_dev(t), gpu_dev(v), torch.as_tensor(g, device=gpu_DEVICE), torch.as_tensor(free, device=gpu_DEVICE)
        for _ in range(4):
            St, Pfull = gpu_dev(np.hypot(e, jit[fam])), gpu_dev(p)

            def res(q, idx):
                pp = Pfull.repeat(len(q), 1)
                pp[:, free_t] = q
                m = pp[:, :ng][:, Gt]
                for i in range(k):
                    P, tp, sc, ss, K = (pp[:, ng + 1 + 5 * i + j:ng + 2 + 5 * i + j] for j in range(5))
                    m = m + K * gpu_keplerian(Tt[None, :], P, tp, torch.clamp(sc * sc + ss * ss, max=0.95), torch.atan2(ss, sc))
                return (Vt[None, :] - m) / St[None, :]
            q, _ = gpu_lm(res, np.clip(p[free], lo[free] + 1e-9, hi[free] - 1e-9)[None, :], lo[free], hi[free], iters=400)
            p[free] = gpu_host(q[0])
            jit = jitters(v - model(p, k))
        s2 = e ** 2 + jit[fam] ** 2
        p[ng] = jit[0]
        return p, -0.5 * float(np.sum((v - model(p, k)) ** 2 / s2 + np.log(2 * np.pi * s2))), jit

    def sinusoid_residuals(y, pers, s):
        """Y (one series or many as rows) less an offset per series and a sinusoid at each period, fitted by weighted least squares."""
        cols = [(g == j).astype(float) for j in range(ng)]
        for P in pers:
            cols += [np.cos(2 * np.pi * t / P), np.sin(2 * np.pi * t / P)]
        X = np.column_stack(cols)
        Y = np.atleast_2d(y)
        out = Y - (np.linalg.lstsq(X / s[:, None], (Y / s[None, :]).T, rcond=None)[0].T @ X.T)
        return out[0] if np.ndim(y) == 1 else out

    # sequential periodograms, and the window function below them
    seq, found = [], []
    fig, axes = plt.subplots(n + 3, 1, figsize=(7.2, 1.6 * (n + 3)), sharex=True)
    for i in range(n + 2):
        s_i = np.hypot(e, jitters(sinusoid_residuals(v, found, e))[fam])
        r = sinusoid_residuals(v, found, s_i)
        pw = gpu_host(gpu_gls(t, r, s_i, freq))
        k = int(np.argmax(pw))
        fap = float(gpu_baluev(pw[k], freq[-1], t, s_i))
        ax = axes[i]
        ax.semilogx(1.0 / freq, pw, lw=0.6, color="k")
        for lv, style in zip((1e-1, 1e-2, 1e-3), (":", "--", "-")):
            ax.axhline(gpu_baluev_level(lv, freq[-1], t, s_i), color="0.5", lw=0.6, ls=style)
        ax.text(0.01, 0.85, "%d signal%s removed; peak %.3f d, FAP %.0e" % (i, "" if i == 1 else "s", 1.0 / freq[k], fap), transform=ax.transAxes, fontsize=7)
        ax.set_ylabel("power", fontsize=7)
        ax.tick_params(labelsize=7)
        seq.append(dict(peak_d=round(float(1.0 / freq[k]), 4), power=round(float(pw[k]), 3), fap=fap))
        found.append(1.0 / freq[k])
    ax = axes[-1]
    ax.semilogx(1.0 / freq, LombScargle(t, np.ones_like(t), fit_mean=False, center_data=False).power(freq), lw=0.6, color="k")
    ax.text(0.01, 0.85, "window function", transform=ax.transAxes, fontsize=7)
    ax.set_ylabel("power", fontsize=7)
    ax.tick_params(labelsize=7)
    axes[-1].set_xlabel("period (d)", fontsize=8)
    fig.tight_layout()
    fig.savefig(os.path.join(folder, "periodograms.pdf"))
    plt.close(fig)
    out["sequential"] = seq
    # models of one planet fewer to one more
    extra = next((s_["peak_d"] for s_ in seq if all(abs(s_["peak_d"] / P - 1.0) > 0.03 for P in periods)), None)
    models = {}
    for k in range(max(0, n - 1), n + 2):
        pers = list(periods[:k]) if k <= n else (list(periods) + [extra] if extra else None)
        if pers is None:
            continue
        p, lnl, jit = fit_ml(pers)
        pc, lnl_c, jit_c = fit_ml(pers, circular=True)
        models[k] = dict(periods=[round(float(p[ng + 1 + 5 * i]), 4) for i in range(k)], K=[round(float(p[ng + 5 + 5 * i]), 3) for i in range(k)],
                         e=[round(float(p[ng + 3 + 5 * i] ** 2 + p[ng + 4 + 5 * i] ** 2), 3) for i in range(k)], lnl=round(lnl, 2), lnl_circular=round(lnl_c, 2),
                         bic=round(-2 * lnl + (ng + nf + 5 * k) * math.log(len(t)), 2), bic_circular=round(-2 * lnl_c + (ng + nf + 3 * k) * math.log(len(t)), 2),
                         jitter=[round(float(x), 3) for x in jit], rms=round(float(np.std(v - model(p, k))), 3), params=[float(z) for z in p],
                         params_circular=[float(z) for z in pc])
    out["models"] = {str(k): {kk: vv for kk, vv in m.items() if not kk.startswith("params")} for k, m in models.items()}
    # each planet's BIC cost: the models without it less the full models
    out["required"] = {}
    for i, P in enumerate(periods):
        rest = [x for j, x in enumerate(periods) if j != i]
        lnl, lnl_c = fit_ml(rest)[1], fit_ml(rest, circular=True)[1]
        out["required"]["%g" % P] = dict(dbic=round(-2 * lnl + (ng + nf + 5 * (n - 1)) * math.log(len(t)) - models[n]["bic"], 2),
                                         dbic_circular=round(-2 * lnl_c + (ng + nf + 3 * (n - 1)) * math.log(len(t)) - models[n]["bic_circular"], 2))
    pc = np.array(models[n]["params_circular"])
    # each telescope's jitter from the circular model's residuals
    jit_f = jitters(v - model(pc, n))
    s_n = np.hypot(e, jit_f[fam])
    out["groups"] = glabels
    out["telescopes"] = {fnames[f]: dict(nights=int(np.sum(fam == f)), first=round(float(t[fam == f].min()), 1), last=round(float(t[fam == f].max()), 1),
                                         median_error=round(float(np.median(e[fam == f])), 3), jitter=round(float(jit_f[f]), 3)) for f in range(nf)}
    rng = np.random.default_rng(3)
    # the 1-day and 1-year aliases
    out["aliases"] = {}
    for i, P in enumerate(periods):
        others_p = [x for j, x in enumerate(periods) if j != i]
        r = sinusoid_residuals(v, others_p, s_n)
        win = lambda Pc: np.linspace(1.0 / (Pc * 1.015), 1.0 / (Pc * 0.985), 400)
        power = lambda y, fr_: gpu_host(gpu_gls(t, y, s_n, fr_))
        p_own = float(power(r, win(P)).max())
        out["aliases"]["%g" % P] = []
        for base, sgn in ((1.0 / 1.0027, 1), (1.0 / 1.0027, -1), (1.0 / 365.25, 1), (1.0 / 365.25, -1)):
            fa = abs(1.0 / P + sgn * base)
            # aliases outside the periods searched or within 3 per cent of the period left out
            if not (1.0 / span < fa < 1.0 / 1.2) or abs(fa * P - 1.0) < 0.03:
                continue
            wa = win(1.0 / fa)
            pw_a = power(r, wa)
            Pa, p_al = float(1.0 / wa[int(np.argmax(pw_a))]), float(pw_a.max())
            # the circular model refitted with the planet at the alias
            lnl_al = fit_ml([Pa if j == i else x for j, x in enumerate(periods)], circular=True)[1]

            def ratio(y):
                rr = np.atleast_2d(sinusoid_residuals(y, others_p, s_n))
                return np.atleast_2d(power(rr, win(P))).max(1) / np.atleast_2d(power(rr, win(Pa))).max(1)
            obs = float(ratio(v)[0])
            truth = {}
            for label, P_in in (("%.4f d" % P, P), ("%.4f d" % Pa, Pa)):
                q = pc.copy()
                q[ng + 1 + 5 * i] = P_in
                rs = ratio(model(q, n)[None, :] + rng.normal(0.0, s_n, (sims, len(t))))
                truth[label] = dict(median=round(float(np.median(rs)), 3), p16=round(float(np.percentile(rs, 16)), 3), p84=round(float(np.percentile(rs, 84)), 3),
                                    reaching_observed=round(float(np.mean(rs >= obs) if obs >= 1 else np.mean(rs <= obs)), 4))
            out["aliases"]["%g" % P].append(dict(alias=round(Pa, 4), exact=round(1.0 / fa, 4), kind="1-day" if base > 0.5 else "1-year", power=round(p_own, 3),
                                                 alias_power=round(p_al, 3),
                                                 observed_ratio=round(obs, 3), lnl=models[n]["lnl_circular"], lnl_alias=round(lnl_al, 2), truth=truth))
    # stability
    def stability():
        if n < 2:
            return "one planet"
        try:
            import rebound
        except ImportError:
            return "REBOUND not installed"
        stab = {}
        for label, key in (("circular", "params_circular"), ("free", "params")):
            q = models[n][key]
            sim = rebound.Simulation()
            sim.units = ("day", "AU", "Msun")
            sim.add(m=mstar)
            for i in range(n):
                P, tp, sc, ss, K = q[ng + 1 + 5 * i:ng + 6 + 5 * i]
                ecc = min(sc * sc + ss * ss, 0.9)
                sim.add(m=planets_msini(P, K, ecc, mstar) / 1047.57, P=P, e=ecc, omega=math.atan2(ss, sc), M=float(rng.uniform(0, 2 * np.pi)))
            sim.move_to_com()
            sim.integrator = "whfast"
            sim.dt = min(periods) / 25.0
            sim.init_megno()
            sim.exit_max_distance = 5.0
            sim.exit_min_distance = 0.002
            status = "stable"
            try:
                sim.integrate(orbits * min(periods), exact_finish_time=0)
            except Exception as exc:
                status = "unstable: %s" % type(exc).__name__
            stab[label] = dict(status=status, megno=round(float(sim.megno()), 3) if status == "stable" else None, years=round(sim.t / 365.25, 1))
        return stab
    out["stability"] = stability()
    # detection limits in the circular model's residuals
    r_n = v - model(pc, n)
    Pg = np.exp(np.linspace(np.log(1.5), np.log(min(3000.0, 2.0 * span)), grid))
    Kg = np.exp(np.linspace(np.log(0.3), np.log(15.0), 16))
    fq = np.linspace(1.0 / min(3000.0, 2.0 * span), 1.0 / 1.2, 40000)
    ph_ = rng.uniform(0, 2 * np.pi, (len(Pg), len(Kg), trials))
    Y = r_n[None, None, None, :] + Kg[None, :, None, None] * np.sin(2 * np.pi * t[None, None, None, :] / Pg[:, None, None, None] + ph_[..., None])
    Y = sinusoid_residuals(Y.reshape(-1, len(t)), [], s_n)
    peakP, peakZ = np.empty(len(Y)), np.empty(len(Y))
    for b0 in range(0, len(Y), 1024):
        pw = gpu_gls(t, Y[b0:b0 + 1024], s_n, fq)
        z, k = pw.max(1)
        peakP[b0:b0 + 1024], peakZ[b0:b0 + 1024] = 1.0 / fq[gpu_host(k)], gpu_host(z)
    hit = (np.abs(peakP / np.repeat(Pg, len(Kg) * trials) - 1.0) < 0.02) & (gpu_baluev(peakZ, fq[-1], t, s_n) < 1e-3)
    rec = hit.reshape(len(Pg), len(Kg), trials).mean(2)
    lim = []
    for a_, P in enumerate(Pg):
        ok = np.where(rec[a_] >= 0.9)[0]
        K90 = float(Kg[ok[0]]) if len(ok) else float("nan")
        lim.append(dict(P=round(float(P), 3), K90=round(K90, 3), msini90_mearth=round(planets_msini(P, K90, 0.0, mstar) * 317.83, 2) if math.isfinite(K90) else None))
    out["detection_limits"] = lim
    fig, ax = plt.subplots(figsize=(6.5, 4.0))
    im = ax.pcolormesh(Pg, Kg, rec.T, shading="auto", cmap="Greys", vmin=0, vmax=1)
    ax.set_xscale("log")
    ax.set_yscale("log")
    for P, K in zip(models[n]["periods"], [pc[ng + 5 + 5 * i] for i in range(n)]):
        ax.plot(P, K, "o", color="C3", ms=6)
    ax.set_xlabel("period (d)")
    ax.set_ylabel("semi-amplitude (m/s)")
    fig.colorbar(im, ax=ax, label="recovered fraction")
    fig.tight_layout()
    fig.savefig(os.path.join(folder, "detection_limits.pdf"))
    plt.close(fig)
    # each planet phased, the others removed, on its circular orbit
    cols_ = 2 if n > 1 else 1
    fig, axes = plt.subplots(int(math.ceil(n / cols_)), cols_, figsize=(7.2, 2.8 * math.ceil(n / cols_)), squeeze=False)
    for i in range(n):
        ax = axes.flat[i]
        q = pc.copy()
        q[ng + 5 + 5 * i] = 0.0
        yi = v - model(q, n)
        P, tp = pc[ng + 1 + 5 * i], pc[ng + 2 + 5 * i]
        ph = ((t - tp) / P) % 1.0
        for f in range(nf):
            sel = fam == f
            ax.errorbar(ph[sel], yi[sel], yerr=s_n[sel], fmt=".", ms=3, color=("k", "C0", "C2", "C4", "C5")[f % 5], ecolor="0.7", lw=0.5,
                        label=fnames[f] if nf > 1 else None)
        if nf > 1 and i == 0:
            ax.legend(fontsize=7, frameon=False)
        pp = np.linspace(0, 1, 400)
        ax.plot(pp, pc[ng + 5 + 5 * i] * planets_kepler(tp + pp * P, P, tp, 0.0, 0.0), color="C3")
        ax.set_title("%s %s: P = %.4f d, K = %.2f m/s" % (title or name, "bcdefgh"[i], P, pc[ng + 5 + 5 * i]), fontsize=8)
        ax.set_xlabel("phase", fontsize=8)
        ax.set_ylabel("velocity (m/s)", fontsize=8)
        ax.tick_params(labelsize=7)
    for ax in list(axes.flat)[n:]:
        ax.axis("off")
    fig.tight_layout()
    fig.savefig(os.path.join(folder, "phased.pdf"))
    plt.close(fig)
    json.dump(out, open(os.path.join(folder, "analysis.json"), "w"), separators=(",", ":"))
    print("%s: %d nights over %.0f d" % (name, len(t), span), flush=True)
    print("  sequential peaks: %s" % ", ".join("%.3f d (%.0e)" % (s_["peak_d"], s_["fap"]) for s_ in seq), flush=True)
    print("  %s" % "; ".join("%s %d nights, jitter %.2f m/s" % (k, x["nights"], x["jitter"]) for k, x in out["telescopes"].items()), flush=True)
    for k, m in out["models"].items():
        print("  %s planets: lnL %.1f, circular %.1f; BIC %.1f, circular %.1f; jitter %s, rms %.2f" % (k, m["lnl"], m["lnl_circular"], m["bic"], m["bic_circular"],
                                                                                                 m["jitter"], m["rms"]), flush=True)
    for P, lst in out["aliases"].items():
        for a_ in lst:
            print("  %s d against its %s alias %.4f d: power %.3f against %.3f, lnL %.1f against %.1f, observed ratio %.3f; %s" % (
                P, a_["kind"], a_["alias"], a_["power"], a_["alias_power"], a_["lnl"], a_["lnl_alias"], a_["observed_ratio"], a_["truth"]), flush=True)
    print("  stability: %s" % out["stability"], flush=True)


def planets_hip_near(gs, radius_arcsec=10.0):
    """The Hipparcos number of a Gaia DR3 source by position, where DR3's best neighbours give none: Hipparcos's new reduction searched within
    RADIUS_ARCSEC of the Gaia position carried back to J1991.25 by its proper motion, the brightest star there."""
    ra, dec = float(gs["ra"]), float(gs["dec"])
    pmra, pmdec = planets_num(gs.get("pmra")), planets_num(gs.get("pmdec"))
    if math.isfinite(pmra) and math.isfinite(pmdec):
        ra -= pmra * 24.75 / 3.6e6 / math.cos(math.radians(dec))
        dec -= pmdec * 24.75 / 3.6e6
    rows = archive_tap("gaia", "SELECT hip, hp_mag FROM public.hipparcos_newreduction WHERE CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', %.6f, %.6f, %.6f)) = 1 "
                               "ORDER BY hp_mag" % (ra, dec, radius_arcsec / 3600.0))
    return int(rows[0]["hip"]) if rows else None


def planets_anomaly(gs, hip):
    """A Gaia DR3 source's Hipparcos-Gaia proper-motion anomaly: Kervella et al.'s (2022) (archive_kervella) by its Hipparcos number HIP, or by
    position where it has none, else planets_pma's from the two catalogues; None where neither gives one."""
    k = archive_kervella(hip=hip) if hip else archive_kervella(ra=float(gs["ra"]), dec=float(gs["dec"]))
    return k if k is not None else planets_pma(hip, gs["source_id"]) if hip else None


def planets_pma(hip, gaia):
    """A star's Hipparcos-Gaia proper-motion anomaly from Hipparcos's new reduction and Gaia DR3 at ESA's archive: the long-term motion from the Hipparcos
    position at J1991.25 to Gaia's at J2016.0, and Gaia's proper motion less it, in mas/yr, each with its error and 0.1 mas/yr added for the two frames'
    relative spin; None where either catalogue lacks a value, as for a Gaia source without a proper motion."""
    h = archive_tap("gaia", "SELECT ra_rad, de_rad, e_ra_rad, e_de_rad FROM public.hipparcos_newreduction WHERE hip = %d" % hip)
    q = archive_tap("gaia", "SELECT ra, dec, pmra, pmra_error, pmdec, pmdec_error, ra_error, dec_error FROM gaiadr3.gaia_source WHERE source_id = %s" % gaia)
    if not h or not q or any(archive_num(v) is None for v in list(h[0].values()) + list(q[0].values())):
        return None
    h, q = h[0], q[0]
    dt = 24.75
    ra_h, de_h = math.degrees(float(h["ra_rad"])), math.degrees(float(h["de_rad"]))
    ra_g, de_g = float(q["ra"]), float(q["dec"])
    pm_ra = (ra_g - ra_h) * math.cos(math.radians(de_g)) * 3.6e6 / dt
    pm_de = (de_g - de_h) * 3.6e6 / dt
    e_ra = math.hypot(float(h["e_ra_rad"]), float(q["ra_error"])) / dt
    e_de = math.hypot(float(h["e_de_rad"]), float(q["dec_error"])) / dt
    pa = (float(q["pmra"]) - pm_ra, float(q["pmdec"]) - pm_de)
    epa = (math.sqrt(float(q["pmra_error"]) ** 2 + e_ra ** 2 + 0.01), math.sqrt(float(q["pmdec_error"]) ** 2 + e_de ** 2 + 0.01))
    return dict(pmRAH2EG3b=pm_ra, e_pmRAH2EG3b=math.sqrt(e_ra ** 2 + 0.01), pmDEH2EG3b=pm_de, e_pmDEH2EG3b=math.sqrt(e_de ** 2 + 0.01),
                PMaRAH2EG3b=pa[0], e_PMaRAH2EG3b=epa[0], PMaDEH2EG3b=pa[1], e_PMaDEH2EG3b=epa[1], snrPMaH2EG3b=math.hypot(pa[0] / epa[0], pa[1] / epa[1]),
                source="Hipparcos new reduction and Gaia DR3")


# the mark of a weighing whose walkers started at the likelihood's own width (planets_weigh), which planets_orbits_refresh looks for
planets_WEIGH_SAMPLER = 2


def planets_weigh(name, steps=8000, pmin=None, pmax=36525.0, m1=None, extra=None):
    """A long-period companion's mass from a star's velocities and its astrometry together, to RESULTS/weigh/<name>.json. The star's Gaia DR3 source, its
    acceleration and velocity-trend solutions where DR3 holds them, its Hipparcos number from DR3's best neighbours, and its Hipparcos-Gaia proper-motion
    anomaly (planets_anomaly); and one Keplerian orbit of the star about the barycentre, the companion
    dark, fitted to everything at once. The bank's velocities, averaged per night, are read with a zero point on each side of the fibre upgrade and a
    jitter. With an acceleration solution, the proper motion and acceleration at 2016.0 are those of a quadratic fitted to the photocentre over Gaia's
    window; without one, Gaia's proper motion is the photocentre's mean motion over that window; each window's solution, Hipparcos's as Gaia's, fits
    the parallax at the same time, its factors at the star's place (archive_parallax_factors), so that an orbit near a year, which the parallax partly
    takes up, moves the proper motion only by what the parallax leaves. Either is set against the long-term motion, the
    photocentre's displacement from its Hipparcos position (a line fitted over Hipparcos's window) to its Gaia position over 24.75 years, as the observed
    anomaly is set against the long-term proper motion. The wobble the photocentre's orbit leaves about Gaia's five-parameter solution over its window,
    the root mean square along one axis, is held against Gaia's astrometric excess noise, or 0.3 mas where that is not significant: within a quarter in
    log above it, more than which the orbit cannot leave, and within 0.7 below it, to which other causes may add. A velocity-trend solution adds the
    derivatives of a quadratic fitted to the model's velocities across Gaia's window. Where Gaia's spectrometer saw the velocity vary (a chi-square p-value below 0.01), the range of its epoch velocities after outliers,
    less 2.5 km/s for their noise, bounds the model's range of velocity over Gaia's window from below, the shortfall counted at 1 km/s. The parameters
    are log period (PMIN to PMAX days, by default half the series' span to 100 years), the time of periastron, sqrt(e) cos
    omega, sqrt(e) sin omega, the log of the companion's mass as a fraction of the primary's (from 0.3 Jupiter masses up to the primary's own mass, which a
    dark companion cannot exceed, and at most 2 solar masses), cos i, the node, the zero points, the jitter and the
    primary's mass with its prior (M1, a mass and its error in solar masses, where given, else Kervella et al.'s, Gaia's FLAME or spectroscopic FLAME
    mass at 10 per cent, else the spectral type's at 30 per cent). A profile over period (gpu_profile) gives the best orbit in each of 120 bands of
    period, evenly spaced in log period across the prior, each trial orbit's zero points set to the weighted means of its residuals and the search
    widened toward orbits seen face on; the bands whose best lies within 2 of the overall best in log posterior hold the periods the
    data allow, and the overall best, polished by L-BFGS-B, starts the sampler on the device (gpu_ensemble). The companion's mass, period, inclination, eccentricity and separation come with their 16th to 84th percentiles and the probabilities
    that it lies below 13 and 80 Jupiter masses; 256 posterior draws of (P, tp, e, omega, K1) go to the .draws.npz file beside the JSON, named draws.
    EXTRA is an .npz file of additional nightly velocities (mjd, rv, rv_err in m/s), fitted with its own zero point."""
    from scipy.optimize import minimize
    star = next(r for r in planets_read(planets_path("bank_stars.csv")) if r["Name"] == name)
    t, v, err, grp = planets_nights(name)
    if extra:
        d = np.load(extra)
        t, v, err, grp = (np.concatenate([a, b]) for a, b in ((t, d["mjd"]), (v, d["rv"]), (err, d["rv_err"]), (grp, np.full(len(d["mjd"]), int(grp.max()) + 1))))
    v, err = v / 1000.0, err / 1000.0
    ngr = int(grp.max()) + 1
    span = float(t.max() - t.min())
    gs = archive_gaia_star(float(star["RAJ2000"]), float(star["DEJ2000"]), archive_num(star.get("Vmag")))
    if gs is None:
        raise SystemExit("%s: no Gaia DR3 source" % name)
    sid = gs["source_id"]
    # Where Gaia DR3's spectrometer saw the velocity vary (its chi-square p-value below 0.01), the range of its epoch velocities after outliers, less
    # 2.5 km/s for their noise, is a lower bound on the orbit's range of velocity over Gaia's window.
    rv_amp, rv_pval = archive_num(gs.get("rv_amplitude_robust")), archive_num(gs.get("rv_chisq_pvalue"))
    rv_floor = rv_amp - 2.5 if rv_amp is not None and rv_pval is not None and rv_pval < 0.01 and rv_amp > 2.5 else None
    # Gaia DR3's astrometric excess noise, the wobble its five-parameter solution left about the photocentre; where it is not significant, the
    # 0.3 mas that calibration leaves the brightest stars stands for it
    eps, eps_sig = archive_num(gs.get("astrometric_excess_noise")), archive_num(gs.get("astrometric_excess_noise_sig"))
    eps_obs = max(eps if eps is not None and eps_sig is not None and eps_sig > 2.0 else 0.0, 0.3)
    sol = archive_gaia_solutions([sid])[str(sid)]
    acc, trend = sol["acceleration"], sol["trend"]
    hip = archive_hipparcos_of(sid) or planets_hip_near(gs)
    k = planets_anomaly(gs, hip)
    if k is None:
        raise SystemExit("%s: no Hipparcos-Gaia proper-motion anomaly" % name)
    num = lambda x: planets_num(x) if not isinstance(x, float) else x
    plx = num(acc[0]["parallax"]) if acc else num(gs["parallax"])
    if m1:
        m1, m1_err, m1_source = float(m1[0]), float(m1[1]), "given"
    elif archive_num(star.get("Mass")):
        m1, m1_err, m1_source = float(star["Mass"]), 0.1 * float(star["Mass"]), "its root's table"
    elif math.isfinite(num(k.get("M1"))):
        m1, m1_err, m1_source = num(k["M1"]), 0.1 * num(k["M1"]), "Kervella et al. (2022)"
    elif math.isfinite(num(gs.get("mass_flame"))):
        m1, m1_err, m1_source = num(gs["mass_flame"]), 0.1 * num(gs["mass_flame"]), "Gaia DR3 FLAME"
    else:
        spec = archive_tap("gaia", "SELECT mass_flame_spec FROM gaiadr3.astrophysical_parameters_supp WHERE source_id = %s" % sid)
        m1 = num(spec[0]["mass_flame_spec"]) if spec else float("nan")
        m1, m1_err, m1_source = (m1, 0.1 * m1, "Gaia DR3 FLAME, spectroscopic") if math.isfinite(m1) else \
            (planets_mass(star.get("SpType")), 0.3 * planets_mass(star.get("SpType")), "spectral type")
    tref, hip_epoch = 57388.5, 48348.56
    # the time of periastron counted from the velocities' median epoch, so that an orbit carried to a neighbouring period keeps its phase on the nights
    tmid = float(np.median(t))
    tg = np.linspace(56863.0, 57901.0, 40)
    th = np.linspace(47837.2, 49064.45, 40)
    dt_hg = (tref - hip_epoch) / 365.25
    ra_s, dec_s = num(gs["ra"]), num(gs["dec"])

    def design(tt, t0, quad):
        # an astrometric solution over the epochs TT about T0, the right ascensions' rows above the declinations': the place, the proper motion, with
        # QUAD the acceleration, and the parallax, fitted at once, so that the part of an orbit near a year that the parallax takes up is not motion
        dt, (fa, fd) = (tt - t0) / 365.25, archive_parallax_factors(ra_s, dec_s, tt)
        o, z = np.ones_like(tt), np.zeros_like(tt)
        cols = [(o, z), (z, o), (dt, z), (z, dt)] + ([(0.5 * dt ** 2, z), (z, 0.5 * dt ** 2)] if quad else []) + [(fa, fd)]
        return np.column_stack([np.concatenate(c) for c in cols])
    Pg, Pg1, Ph = (np.linalg.pinv(design(tt, t0, quad)) for tt, t0, quad in ((tg, tref, True), (tg, tref, False), (th, hip_epoch, False)))
    pm_hg = np.array([num(k["pmRAH2EG3b"]), num(k["pmDEH2EG3b"])])
    if acc and acc[0].get("accel_ra"):
        A = acc[0]
        obs_dmu = np.array([num(A["pmra"]), num(A["pmdec"])]) - pm_hg
        err_dmu = np.hypot([num(A["pmra_error"]), num(A["pmdec_error"])], [num(k["e_pmRAH2EG3b"]), num(k["e_pmDEH2EG3b"])])
        obs_acc, err_acc = np.array([num(A["accel_ra"]), num(A["accel_dec"])]), np.array([num(A["accel_ra_error"]), num(A["accel_dec_error"])])
    else:
        obs_dmu = np.array([num(k["PMaRAH2EG3b"]), num(k["PMaDEH2EG3b"])])
        err_dmu = np.array([num(k["e_PMaRAH2EG3b"]), num(k["e_PMaDEH2EG3b"])])
        obs_acc = None
    tr = None
    tr_t = np.linspace(tref - 480.0, tref + 480.0, 27)
    Pr = np.linalg.pinv(np.column_stack([np.ones_like(tr_t), tr_t - tref, 0.5 * (tr_t - tref) ** 2]))
    if trend and trend[0].get("first_deriv_velocity"):
        T = trend[0]
        c1e = num(T["first_deriv_velocity_error"])
        if T.get("second_deriv_velocity"):
            c2e = num(T["second_deriv_velocity_error"])
            r12 = float(str(T["corr_vec"]).strip("()[]{}").split(",")[-1])
            cov = np.array([[c1e ** 2, r12 * c1e * c2e], [r12 * c1e * c2e, c2e ** 2]])
            tr = (np.array([num(T["first_deriv_velocity"]), num(T["second_deriv_velocity"])]), np.linalg.inv(cov), 2)
        else:
            tr = (np.array([num(T["first_deriv_velocity"])]), np.array([[1.0 / c1e ** 2]]), 1)
    pmin = pmin or max(0.5 * span, 50.0)
    # the companion's mass as a fraction of the primary's, which a dark companion cannot exceed, from 0.3 Jupiter masses for the primary's prior mass
    LO = np.array([math.log(pmin), 0.0, -0.975, -0.975, math.log(0.3 / 1047.57 / m1), -1.0, 0.0] + [-50.0] * ngr + [math.log(1e-4), m1 - 4 * m1_err])
    HI = np.array([math.log(pmax), 1.0, 0.975, 0.975, 0.0, 1.0, 2 * math.pi] + [50.0] * ngr + [math.log(1.0), m1 + 4 * m1_err])

    Tn, TG, TH, TR = gpu_dev(t), gpu_dev(tg), gpu_dev(th), gpu_dev(tr_t)
    TS = gpu_dev(np.linspace(56863.0, 57901.0, 400))
    PG, PG1, PH, PR = gpu_dev(Pg), gpu_dev(Pg1), gpu_dev(Ph), gpu_dev(Pr)
    AG1 = gpu_dev(design(tg, tref, False))
    Vn, E2, GR = gpu_dev(v), gpu_dev(err ** 2), torch.as_tensor(grp, dtype=torch.long, device=gpu_DEVICE)
    OH = torch.nn.functional.one_hot(GR, ngr).to(gpu_F64)
    OD, ED, LOt, HIt = gpu_dev(obs_dmu), gpu_dev(err_dmu), gpu_dev(LO), gpu_dev(HI)
    OA, EA = (gpu_dev(obs_acc), gpu_dev(err_acc)) if obs_acc is not None else (None, None)
    TV, TW = (gpu_dev(tr[0]), gpu_dev(tr[1])) if tr else (None, None)

    def model(pn, host=True, zero=False):
        """The log-posterior of parameter rows PN (b, d) and each row's period, eccentricity, masses, K1, inclination, separation and zero points, as
        arrays; without HOST the log-posterior alone, on the device. With ZERO each row's zero points are the ones that fit the rest of the row best, the
        weighted means of its residuals in each series within their bounds."""
        p = pn if isinstance(pn, torch.Tensor) else gpu_dev(np.atleast_2d(pn))
        lnP, ph, sc, ss, lq, ci, node = (p[:, j:j + 1] for j in range(7))
        gam, lj, mm1 = p[:, 7:7 + ngr], p[:, 7 + ngr], p[:, 8 + ngr:9 + ngr]
        P, ecc, w, m2 = torch.exp(lnP), sc * sc + ss * ss, torch.atan2(ss, sc), torch.exp(lq) * mm1
        bad = ((p < LOt) | (p > HIt)).any(1) | ((sc * sc + ss * ss)[:, 0] >= 0.95) | (m2[:, 0] > 2.0)
        tp = tmid + ph * P
        si = torch.sqrt(torch.clamp(1.0 - ci * ci, min=0.0))
        mt, Pyr = mm1 + m2, P / 365.25
        K1 = 29.7847 * m2 * si * mt ** (-2.0 / 3.0) * Pyr ** (-1.0 / 3.0) / torch.sqrt(1.0 - ecc * ecc)
        a1 = mt ** (1.0 / 3.0) * Pyr ** (2.0 / 3.0) * m2 / mt * plx
        cw, sw, cO, sO = torch.cos(w), torch.sin(w), torch.cos(node), torch.sin(node)
        Ac, B, F, G = a1 * (cw * cO - sw * sO * ci), a1 * (cw * sO + sw * cO * ci), a1 * (-sw * cO - cw * sO * ci), a1 * (-sw * sO + cw * cO * ci)
        sq = torch.sqrt(1.0 - ecc * ecc)

        def anomalies(tt):
            return gpu_anomaly(tt[None, :], P, tp, ecc)

        def rv(tt):
            E = anomalies(tt)
            nu = 2 * torch.atan2(torch.sqrt(1 + ecc) * torch.sin(E / 2), torch.sqrt(1 - ecc) * torch.cos(E / 2))
            return K1 * (torch.cos(nu + w) + ecc * cw)

        def sky(tt):
            E = anomalies(tt)
            X, Y = torch.cos(E) - ecc, sq * torch.sin(E)
            return Ac * X + F * Y, B * X + G * Y
        dg, ag = sky(TG)
        dh, ah = sky(TH)
        # each window's solution: the places (0, 1), the proper motions (2, 3) and, at Gaia's with an acceleration solution, the accelerations (4, 5)
        yg = torch.cat([ag, dg], 1)
        ch = torch.cat([ah, dh], 1) @ PH.T
        cg = yg @ (PG if OA is not None else PG1).T
        dmu = torch.stack([cg[:, 2] - (cg[:, 0] - ch[:, 0]) / dt_hg, cg[:, 3] - (cg[:, 1] - ch[:, 1]) / dt_hg], 1)
        # the wobble Gaia's five-parameter solution leaves, the root mean square along one axis of the photocentre about it over Gaia's window
        wob = torch.sqrt(((yg - (yg @ PG1.T) @ AG1.T) ** 2).mean(1) + 1e-12)
        s2 = E2[None, :] + torch.exp(2 * lj)[:, None]
        r = Vn[None, :] - rv(Tn)
        if zero:
            gam = torch.minimum(torch.maximum(((r / s2) @ OH) / ((1.0 / s2) @ OH), LOt[7:7 + ngr]), HIt[7:7 + ngr])
        lp = -0.5 * (((r - gam[:, GR]) ** 2 / s2 + torch.log(s2)).sum(1)) - 0.5 * (((dmu - OD) / ED) ** 2).sum(1)
        # the wobble against Gaia's excess noise, in log: within a quarter above it, more than which the orbit cannot leave, and within 0.7 below it,
        # to which other causes may add
        dl = torch.log(wob / eps_obs)
        lp = lp - 0.5 * (dl / torch.where(dl > 0, torch.full_like(dl, 0.25), torch.full_like(dl, 0.7))) ** 2
        if OA is not None:
            lp = lp - 0.5 * (((cg[:, 4:6] - OA) / EA) ** 2).sum(1)
        if TV is not None:
            d = (rv(TR) @ PR.T)[:, 1:1 + tr[2]] - TV
            lp = lp - 0.5 * torch.einsum("bi,ij,bj->b", d, TW, d)
        if rv_floor is not None:
            vs = rv(TS)
            lp = lp - 0.5 * torch.clamp(rv_floor - (vs.max(1).values - vs.min(1).values), min=0.0) ** 2
        lp = lp - 0.5 * ((mm1[:, 0] - m1) / m1_err) ** 2
        lp = torch.where(bad | ~torch.isfinite(lp), torch.full_like(lp, -float("inf")), lp)
        if not host:
            return lp
        der = dict(P=P[:, 0], e=ecc[:, 0], m2=m2[:, 0], m1=mm1[:, 0], K1=K1[:, 0], incl=torch.rad2deg(torch.acos(torch.clamp(ci[:, 0], -1.0, 1.0))),
                   a_au=(mt ** (1.0 / 3.0) * Pyr ** (2.0 / 3.0))[:, 0], wobble=wob, zero=gam)
        return gpu_host(lp), {key: gpu_host(x) for key, x in der.items()}

    logp = lambda pn: model(pn)[0]

    def neg(x):
        """The negative log-posterior of one parameter vector (d,) or of a population as columns (d, s)."""
        x = np.asarray(x, float)
        lp = logp(x.T if x.ndim == 2 else x[None, :])
        val = np.where(np.isfinite(lp), -lp, 1e30)
        return val if x.ndim == 2 else float(val[0])
    def grad(x):
        """The gradient of neg by forward differences of relative step sqrt(machine epsilon), each step turned back where it would leave the bounds."""
        x = np.asarray(x, float)
        h = 1.4901161193847656e-08 * np.where(x >= 0, 1.0, -1.0) * np.maximum(1.0, np.abs(x))
        h = np.where((x + h > HI) | (x + h < LO), -h, h)
        f = neg(np.vstack([x, x[None, :] + np.diag(h)]).T)
        return (f[1:] - f[0]) / h

    # The period profile: in each of 120 bands of period, evenly spaced in log period across the prior, the best orbit, found for every band at once
    # (gpu_profile) with each trial's zero points at their best; the bands whose best lies within 2 of the overall best in log posterior hold the periods
    # the data allow. The search reads cos i through t, cos i = sign(t) (1 - (1 - |t|)^3), which gives room to the orbits seen nearly face on, where a
    # small velocity amplitude meets a large astrometric one; every trial is scored on the model's own parameters.
    def tilt(qq):
        qq = qq.clone()
        qq[:, 5] = torch.sign(qq[:, 5]) * (1.0 - (1.0 - qq[:, 5].abs()) ** 3)
        return qq
    edges = np.linspace(LO[0], HI[0], 121)
    prof, xs = gpu_profile(lambda qq: model(tilt(qq), host=False, zero=True), LO, HI, 0, edges)
    xs = gpu_host(tilt(gpu_dev(xs)))
    xs[:, 7:7 + ngr] = model(xs, zero=True)[1]["zero"]
    top = int(np.argmax(prof))
    best = minimize(neg, xs[top], method="L-BFGS-B", jac=grad, bounds=list(zip(LO, HI)))
    if not best.fun < -prof[top]:
        best.x, best.fun = xs[top], -prof[top]
    ok = np.where(prof >= prof.max() - 2.0)[0]
    allowed = [[round(float(np.exp(edges[s[0]])), 1), round(float(np.exp(edges[s[-1] + 1])), 1)] for s in np.split(ok, np.where(np.diff(ok) > 1)[0] + 1)]
    rng = np.random.default_rng(7)
    nw = max(48, 4 * len(LO))
    p0 = []
    # the walkers spread by half the likelihood's own width in each parameter at the best orbit, the others held
    bump = np.diag(np.maximum(1e-5 * (HI - LO), 1e-7))
    lp0, up_, dn_ = logp(best.x)[0], logp(best.x + bump), logp(best.x - bump)
    with np.errstate(all="ignore"):
        wide = 0.5 / np.sqrt(np.maximum(-(up_ + dn_ - 2.0 * lp0) / np.diag(bump) ** 2, 0.0))
    ball = np.where(np.isfinite(wide) & (wide > 0), np.minimum(wide, 1e-2 * (HI - LO)), 1e-4 * (HI - LO))
    while len(p0) < nw:
        x = np.clip(best.x + ball * rng.standard_normal(len(LO)), LO, HI)
        if np.isfinite(logp(x)[0]):
            p0.append(x)
        else:
            ball = 0.9 * ball
    chain, accept = gpu_ensemble(lambda q: model(q, host=False), np.array(p0), steps, thin=10, seed=7, graph=True)
    half = chain[len(chain) // 2:]
    ch = half.reshape(-1, len(LO))
    # how far the kept chain's two halves lie apart, in the posterior's own widths, the sampler's measure of having settled
    drift = float(np.max(np.abs(half[:len(half) // 2].reshape(-1, len(LO)).mean(0) - half[len(half) // 2:].reshape(-1, len(LO)).mean(0)) / np.maximum(ch.std(0), 1e-12)))
    der = model(ch[::max(len(ch) // 3000, 1)])[1]
    q = lambda key, f=1.0: [float(f * np.percentile(der[key], pc)) for pc in (50, 16, 84)]
    m2s = der["m2"] * 1047.57
    pick = ch[np.linspace(0, len(ch) - 1, min(256, len(ch))).astype(int)]
    Pd, K1d = np.exp(pick[:, 0]), model(pick)[1]["K1"] * 1000.0
    draws = np.round(np.column_stack([Pd, tmid + pick[:, 1] * Pd, pick[:, 2] ** 2 + pick[:, 3] ** 2, np.arctan2(pick[:, 3], pick[:, 2]), K1d]), 6)
    res = dict(name=name, nights=int(len(t)), span_d=round(span), first_mjd=round(float(t.min()), 3), last_mjd=round(float(t.max()), 3), source_id=sid, hip=hip, anomaly_source=k.get("source", "Kervella et al. (2022)"),
               pma_snr=num(k.get("snrPMaH2EG3b")), ruwe=num(gs.get("ruwe")), acceleration=acc[0]["nss_solution_type"] if acc else None,
               velocity_trend=trend[0]["nss_solution_type"] if trend else None, gaia_rv_amplitude_kms=rv_amp, gaia_rv_floor_kms=rv_floor,
               excess_noise_mas=eps, excess_noise_sig=eps_sig, m1_prior=[m1, m1_err], m1_source=m1_source, log_posterior=round(-float(best.fun), 2),
               period_allowed=allowed, acceptance=float(np.mean(accept)), chain_drift=round(drift, 3), P_d=q("P"), e=q("e"), K1_ms=q("K1", 1000.0), m2_mjup=q("m2", 1047.57),
               incl_deg=q("incl"), a_au=q("a_au"), wobble_mas=q("wobble"), p_below_13mjup=float(np.mean(m2s < 13.0)), p_below_80mjup=float(np.mean(m2s < 80.0)), sampler=planets_WEIGH_SAMPLER)
    os.makedirs(os.path.join(planets_RESULTS, "weigh"), exist_ok=True)
    path = os.path.join(planets_RESULTS, "weigh", archive_tag(name) + ".json")
    planets_draws_save(path, res, draws=draws, profile=np.column_stack([np.exp(edges[:-1]), np.exp(edges[1:]), np.exp(xs[:, 0]), prof]))
    json.dump(res, open(path, "w"), separators=(",", ":"))
    print("%s: %d nights over %d d, anomaly %.1f sigma (%s)%s%s | P %.0f (%.0f-%.0f) d, e %.2f, i %.0f deg, m2 %.1f (%.1f-%.1f) MJup, a %.1f au, wobble "
          "%.2f mas against Gaia's %s; P(m2 < 13 MJup) %.2f, P(m2 < 80) %.2f" % (
              name, len(t), span, res["pma_snr"], res["anomaly_source"], ", " + res["acceleration"] if res["acceleration"] else "",
              ", " + res["velocity_trend"] if res["velocity_trend"] else "", res["P_d"][0], res["P_d"][1], res["P_d"][2], res["e"][0], res["incl_deg"][0],
              res["m2_mjup"][0], res["m2_mjup"][1], res["m2_mjup"][2], res["a_au"][0], res["wobble_mas"][0], eps, res["p_below_13mjup"], res["p_below_80mjup"]),
          flush=True)
    print("  periods the data allow: %s" % ", ".join("%.0f-%.0f d" % tuple(a) for a in allowed), flush=True)


# J2017.5, Gaia DR4's reference epoch, as an MJD and in Julian years from J2010.0, the origin of its times
planets_DR4_MJD, planets_DR4_YEARS = 57936.375, 7.5


def planets_epochs_read(path):
    """Gaia DR4's epoch_astrometry in the VOTable at PATH, a path or an open file, by source, its CCDs' values held as arrays in one row a transit or in one row a CCD: the along-scan measurements
    AGIS used, averaged over each field-of-view transit's CCDs by the errors AGIS gave them less the source's excess noise: each transit's time (Julian years from J2017.5, barycentric), position
    and error (mas), the scan angle's sine and cosine and the parallax factor, with the source's unscaled excess noise (mas)."""
    from astropy.table import Table
    t = Table.read(path, format="votable")
    if not len(t):
        return {}

    def rows(c, kind=float, fill=np.nan):
        x = [np.atleast_1d(np.ma.filled(np.ma.asarray(v, kind), fill)) for v in t[c]]
        n = max(len(v) for v in x)
        return np.array([np.pad(v, (0, n - len(v)), constant_values=fill) for v in x])
    pos, err, angle, clock = rows("centroid_pos_al"), rows("centroid_pos_error_al"), rows("scan_pos_angle"), rows("obs_time_tcb")
    flags = rows("used_by_agis_al", bool, False)
    sid, bary, f, noise = (np.asarray(t[c]) for c in ("source_id", "obs_time_bary_corr", "parallax_factor_al", "agis_source_excess_noise"))
    if pos.shape[1] == 1 and "transit_id" in t.colnames:
        # one row a CCD gathered into one row a transit
        where = np.unique(np.column_stack([sid, np.asarray(t["transit_id"])]), axis=0, return_inverse=True)[1].ravel()
        order = np.argsort(where, kind="stable")
        counts = np.bincount(where)
        first = np.cumsum(counts) - counts
        place = np.arange(len(where)) - np.repeat(first, counts)

        def spread(x, fill):
            out = np.full((len(counts), int(counts.max())), fill, dtype=x.dtype)
            out[where[order], place] = x[order, 0]
            return out
        pos, err, angle, clock, flags = spread(pos, np.nan), spread(err, np.nan), spread(angle, np.nan), spread(clock, np.nan), spread(flags, False)
        sid, bary, f, noise = (x[order[first]] for x in (sid, bary, f, noise))
    used = flags & np.isfinite(pos) & np.isfinite(err) & (err > 0)
    wt = np.where(used, 1.0 / np.where(used, err, 1.0) ** 2, 0.0)
    total = wt.sum(1)
    keep = total > 0
    mean = lambda x: (wt[keep] * np.where(used[keep], x[keep], 0.0)).sum(1) / total[keep]
    # a nanosecond in Julian years
    years = 1e-9 / (365.25 * 86400.0)
    sid, out = sid[keep], {}
    w, e = mean(pos), 1.0 / np.sqrt(total[keep])
    day, s, c = (mean(clock) + np.asarray(bary, float)[keep]) * years - planets_DR4_YEARS, mean(np.sin(np.radians(angle))), mean(np.cos(np.radians(angle)))
    f, noise = np.asarray(f, float)[keep], np.asarray(noise, float)[keep]
    for k in np.unique(sid):
        m = sid == k
        o = np.argsort(day[m])
        out[int(k)] = dict(t=day[m][o], w=w[m][o], e=e[m][o], sin=s[m][o], cos=c[m][o], f=f[m][o], excess_noise=float(noise[m][0]))
    return out


def planets_epochs_design(d):
    """The single-star model of an epoch series D (planets_epochs_read) as columns: the place's two offsets, the parallax and the proper motion's two terms."""
    return np.column_stack([d["sin"], d["cos"], d["f"], d["t"] * d["sin"], d["t"] * d["cos"]])


def planets_epochs_star(d, jitter=0.0):
    """The single-star fit of an epoch series D by least squares, the errors joined by JITTER (mas): the five parameters (mas and mas/yr) in the order of planets_epochs_design, their errors, the
    residuals and the chi-square."""
    X, s = planets_epochs_design(d), np.hypot(d["e"], jitter)
    A = X / s[:, None]
    c = np.linalg.lstsq(A, d["w"] / s, rcond=None)[0]
    r = d["w"] - X @ c
    return c, np.sqrt(np.diag(np.linalg.pinv(A.T @ A))), r, float(np.sum((r / s) ** 2))


def planets_epochs_power(d, pmin=2.0, pmax=10000.0, eccs=(0.2, 0.4, 0.6, 0.8), phases=12, oversample=5, jitter=0.0, shuffle=None, chunk=64):
    """The astrometric Keplerian periodogram of an epoch series D (planets_epochs_read): at every frequency from 1/PMAX to 1/PMIN, spaced at 1/(OVERSAMPLE x span), the circular orbit and every
    eccentricity of ECCS at PHASES times of periastron, each orbit's four Thiele-Innes constants solved exactly with the five single-star parameters profiled out (ESA's model: the photocentre at
    (B X + G Y) along right ascension and (A X + F Y) along declination, X = cos E - e, Y = sqrt(1 - e^2) sin E), and the share of the single-star chi-square each takes out. SHUFFLE, a numpy Generator,
    permutes the single-star residuals among the transits first, for a null. Returns the frequencies, the best share at each, and the best orbit: period, eccentricity, time of periastron (Julian
    years from J2017.5 in days), the constants and its share."""
    s = np.hypot(d["e"], jitter)
    A0 = planets_epochs_design(d) / s[:, None]
    Q = gpu_dev(np.linalg.qr(A0)[0])
    y = d["w"] / s
    y = y - gpu_host(Q) @ (gpu_host(Q).T @ y)
    if shuffle is not None:
        y = shuffle.permutation(y)
    chi0 = float(y @ y)
    days = d["t"] * 365.25
    span = float(days.max() - days.min())
    freqs = np.arange(1.0 / pmax, 1.0 / pmin, 1.0 / (oversample * span))
    combos = [(0.0, 0.0)] + [(e, k / phases) for e in eccs for k in range(phases)]
    E0, PH = gpu_dev([c[0] for c in combos])[None, :, None], gpu_dev([c[1] for c in combos])[None, :, None]
    T, SN, CS, W, Y = gpu_dev(days)[None, None, :], gpu_dev(d["sin"] / s), gpu_dev(d["cos"] / s), Q, gpu_dev(y)
    sq = torch.sqrt(1.0 - E0 * E0)
    best = np.empty(len(freqs))
    top = (-1.0, None)
    ridge = torch.eye(4, dtype=gpu_F64, device=gpu_DEVICE)
    with torch.no_grad():
        for i0 in range(0, len(freqs), chunk):
            F = gpu_dev(freqs[i0:i0 + chunk])[:, None, None]
            Ea = gpu_kepler_E(2.0 * math.pi * torch.remainder(F * T - PH, 1.0), E0, 12)
            X_, Y_ = torch.cos(Ea) - E0, sq * torch.sin(Ea)
            B = torch.stack([X_ * SN, Y_ * SN, X_ * CS, Y_ * CS], -1)
            B = B - W @ (W.T @ B)
            N = B.transpose(-1, -2) @ B
            r = (B.transpose(-1, -2) @ Y[:, None])[..., 0]
            scale = torch.diagonal(N, dim1=-2, dim2=-1).sum(-1).clamp(min=1e-30)[..., None, None]
            sol = gpu_solve_spd((N + 1e-9 * scale * ridge).reshape(-1, 4, 4), r.reshape(-1, 4)).reshape(r.shape)
            gain = (sol * r).sum(-1)
            top_gain, at = gain.max(1)
            best[i0:i0 + len(top_gain)] = gpu_host(top_gain) / chi0
            j = int(torch.argmax(top_gain))
            if float(top_gain[j]) > top[0]:
                k = int(at[j])
                top = (float(top_gain[j]), (i0 + j, k, gpu_host(sol[j, k])))
    fi, ck, c = top[1]
    P_, e_ = 1.0 / freqs[fi], combos[ck][0]
    return dict(freqs=freqs, best=best, chi0=chi0, P=P_, e=e_, tp=combos[ck][1] * P_, B=float(c[0]), G=float(c[1]), A=float(c[2]), F=float(c[3]), share=top[0] / chi0)


def planets_epochs_campbell(o, parallax, m1=None):
    """The orbit of Thiele-Innes constants A, B, F, G in the dict O (mas) as the photocentre's semi-major axis (mas), inclination (deg, cos i from A G - B F), and with PARALLAX (mas) and a primary of
    M1 solar masses, the mass function and a dark companion's mass (Jupiter masses)."""
    A, B, F, G = o["A"], o["B"], o["F"], o["G"]
    u, v = 0.5 * (A * A + B * B + F * F + G * G), A * G - B * F
    a0 = math.sqrt(u + math.sqrt(max((u + v) * (u - v), 0.0)))
    out = dict(a0_mas=a0, incl_deg=math.degrees(math.acos(max(min(v / (a0 * a0), 1.0), -1.0))))
    if parallax > 0:
        out["mass_function"] = (a0 / parallax) ** 3 / (o["P"] / 365.25) ** 2
        if m1:
            out["m2_mjup"] = float(planets_least_mass(out["mass_function"], m1)) * 1047.57
    return out


def planets_epochs_weigh(name, d, m1, velocities=None, parallax=None, steps=8000, pmin=2.0, pmax=36525.0, seed=7, bands=120):
    """A star's companion weighed from Gaia's epoch astrometry D (planets_epochs_read) and, with VELOCITIES (times in MJD, velocities and errors in m/s, series numbers), the velocities together, to
    RESULTS/epochs/<name>.json: one Keplerian orbit of the star about the barycentre, the velocities' zero points and jitter, the primary's mass M1 (mass and error, solar masses) and a scale on the astrometric
    errors, the place and proper motion solved exactly at each trial. The photocentre follows the star, shifted toward a companion of mass below the primary's by its share of the light, its
    luminosity taken as the mass to the power 3.5; a companion above the primary's mass is taken as dark. The parallax is sampled within half its value or ten errors, whichever is more, of PARALLAX (mas), by
    default that of the single-star fit with the epoch search's best orbit taken out, so that the mass it sets carries its uncertainty. As in planets_weigh, a profile over BANDS bands of log period from PMIN to PMAX days (gpu_profile) gives the best orbit of each band, those within 2 of the overall best in log posterior
    hold the periods the data allow, and the overall best, polished by L-BFGS-B, starts the sampler on the device (gpu_ensemble). The companion's mass, period, inclination, eccentricity, separation and
    semi-amplitude come with their 16th to 84th percentiles and the probabilities that it lies below 13 and 80 Jupiter masses, and 256 posterior draws of (P, tp, e, omega, K1) in the file beside it."""
    from scipy.optimize import minimize
    s = d["e"]
    Q, R = np.linalg.qr(planets_epochs_design(d) / s[:, None])
    y0 = d["w"] / s
    tmjd = planets_DR4_MJD + d["t"] * 365.25
    if parallax is None:
        o = planets_epochs_power(d, pmin=max(pmin, 2.0), pmax=min(pmax, 10000.0))
        days = d["t"] * 365.25
        Ea = gpu_host(gpu_anomaly(gpu_dev(days)[None, :], gpu_dev([[o["P"]]]), gpu_dev([[o["tp"]]]), gpu_dev([[o["e"]]])))[0]
        X_, Y_ = np.cos(Ea) - o["e"], math.sqrt(1.0 - o["e"] ** 2) * np.sin(Ea)
        orbit = (o["B"] * X_ + o["G"] * Y_) * d["sin"] + (o["A"] * X_ + o["F"] * Y_) * d["cos"]
        parallax = float(np.linalg.solve(R, Q.T @ ((d["w"] - orbit) / s))[2])
    plx_err = float(np.sqrt(np.linalg.pinv((planets_epochs_design(d) / s[:, None]).T @ (planets_epochs_design(d) / s[:, None]))[2, 2]))
    plx_width = max(0.5 * abs(parallax), 10.0 * plx_err)
    Q = np.linalg.qr((planets_epochs_design(d) / s[:, None])[:, [0, 1, 3, 4]])[0]
    t, v, err, grp = velocities if velocities is not None else (np.zeros(0), np.zeros(0), np.ones(0), np.zeros(0, int))
    v, err = np.asarray(v, float) / 1000.0, np.asarray(err, float) / 1000.0
    ngr = int(np.max(grp)) + 1 if len(t) else 0
    tmid = float(np.median(np.concatenate([tmjd, t])))
    M1, M1e = float(m1[0]), float(m1[1])
    # log period, the phase of periastron, sqrt(e) cos omega, sqrt(e) sin omega, the log of the mass ratio, cos i, the node, the zero points, the log jitter, the primary's mass, the log error scale, the parallax
    LO = np.array([math.log(pmin), 0.0, -0.975, -0.975, math.log(0.3 / 1047.57 / M1), -1.0, 0.0] + [-500.0] * ngr + [math.log(1e-4), M1 - 4 * M1e, math.log(0.7), max(parallax - plx_width, 0.01)])
    HI = np.array([math.log(pmax), 1.0, 0.975, 0.975, math.log(100.0), 1.0, 2 * math.pi] + [500.0] * ngr + [math.log(1.0), M1 + 4 * M1e, math.log(50.0), parallax + plx_width])
    TE, SN, CS, YE, QE, FE = gpu_dev(tmjd), gpu_dev(d["sin"] / s), gpu_dev(d["cos"] / s), gpu_dev(y0), gpu_dev(Q), gpu_dev(d["f"] / s)
    Tn, Vn, E2 = gpu_dev(t), gpu_dev(v), gpu_dev(err ** 2)
    GR = torch.as_tensor(np.asarray(grp, int), dtype=torch.long, device=gpu_DEVICE)
    OH = torch.nn.functional.one_hot(GR, ngr).to(gpu_F64) if ngr else None
    LOt, HIt = gpu_dev(LO), gpu_dev(HI)
    n_e = len(y0)

    def model(pn, host=True, zero=False):
        """The log-posterior of parameter rows PN (b, d), with each row's derived values as arrays unless HOST is false; with ZERO each row's zero points are those that fit the rest of it best."""
        p = pn if isinstance(pn, torch.Tensor) else gpu_dev(np.atleast_2d(pn))
        lnP, ph, sc, ss, lq, ci, node = (p[:, j:j + 1] for j in range(7))
        gam, lj, mm1, lf, plx = p[:, 7:7 + ngr], p[:, 7 + ngr], p[:, 8 + ngr:9 + ngr], p[:, 9 + ngr], p[:, 10 + ngr:11 + ngr]
        P, ecc, w, q = torch.exp(lnP), sc * sc + ss * ss, torch.atan2(ss, sc), torch.exp(lq)
        m2 = q * mm1
        bad = ((p < LOt) | (p > HIt)).any(1) | (ecc[:, 0] >= 0.95)
        tp = tmid + ph * P
        si = torch.sqrt(torch.clamp(1.0 - ci * ci, min=0.0))
        mt, Pyr = mm1 + m2, P / 365.25
        sep = mt ** (1.0 / 3.0) * Pyr ** (2.0 / 3.0)
        # the photocentre's share of the separation: the star's, less the companion's share of the light where it is the fainter star
        lit = torch.where(q < 1.0, q ** 3.5 / (1.0 + q ** 3.5), torch.zeros_like(q))
        a0 = sep * (m2 / mt - lit) * plx
        K1 = 29.7847 * m2 * si * mt ** (-2.0 / 3.0) * Pyr ** (-1.0 / 3.0) / torch.sqrt(1.0 - ecc * ecc)
        cw, sw, cO, sO = torch.cos(w), torch.sin(w), torch.cos(node), torch.sin(node)
        Ac, B, F, G = a0 * (cw * cO - sw * sO * ci), a0 * (cw * sO + sw * cO * ci), a0 * (-sw * cO - cw * sO * ci), a0 * (-sw * sO + cw * cO * ci)
        E = gpu_anomaly(TE[None, :], P, tp, ecc)
        X_, Y_ = torch.cos(E) - ecc, torch.sqrt(1.0 - ecc * ecc) * torch.sin(E)
        r = YE[None, :] - ((B * X_ + G * Y_) * SN[None, :] + (Ac * X_ + F * Y_) * CS[None, :]) - plx * FE[None, :]
        r = r - (r @ QE) @ QE.T
        lp = -0.5 * (r * r).sum(1) * torch.exp(-2.0 * lf) - n_e * lf
        if ngr:
            En = gpu_anomaly(Tn[None, :], P, tp, ecc)
            nu = 2 * torch.atan2(torch.sqrt(1 + ecc) * torch.sin(En / 2), torch.sqrt(1 - ecc) * torch.cos(En / 2))
            s2 = E2[None, :] + torch.exp(2 * lj)[:, None]
            rv = Vn[None, :] - K1 * (torch.cos(nu + w) + ecc * cw)
            if zero:
                gam = torch.minimum(torch.maximum(((rv / s2) @ OH) / ((1.0 / s2) @ OH), LOt[7:7 + ngr]), HIt[7:7 + ngr])
            lp = lp - 0.5 * (((rv - gam[:, GR]) ** 2 / s2 + torch.log(s2)).sum(1))
        lp = lp - 0.5 * ((mm1[:, 0] - M1) / M1e) ** 2
        lp = torch.where(bad | ~torch.isfinite(lp), torch.full_like(lp, -float("inf")), lp)
        if not host:
            return lp
        der = dict(P=P[:, 0], e=ecc[:, 0], m2=m2[:, 0], K1=K1[:, 0], incl=torch.rad2deg(torch.acos(torch.clamp(ci[:, 0], -1.0, 1.0))), a_au=sep[:, 0], a0=a0[:, 0], scale=torch.exp(lf), parallax=plx[:, 0], zero=gam)
        return gpu_host(lp), {key: gpu_host(x) for key, x in der.items()}

    def neg(x):
        x = np.asarray(x, float)
        lp = model(x.T if x.ndim == 2 else x[None, :])[0]
        val = np.where(np.isfinite(lp), -lp, 1e30)
        return val if x.ndim == 2 else float(val[0])

    def grad(x):
        x = np.asarray(x, float)
        h = 1.4901161193847656e-08 * np.where(x >= 0, 1.0, -1.0) * np.maximum(1.0, np.abs(x))
        h = np.where((x + h > HI) | (x + h < LO), -h, h)
        f = neg(np.vstack([x, x[None, :] + np.diag(h)]).T)
        return (f[1:] - f[0]) / h

    def tilt(qq):
        # orbits seen nearly face on given more room, as in planets_weigh
        qq = qq.clone()
        qq[:, 5] = torch.sign(qq[:, 5]) * (1.0 - (1.0 - qq[:, 5].abs()) ** 3)
        return qq
    edges = np.linspace(LO[0], HI[0], bands + 1)
    prof, xs = gpu_profile(lambda qq: model(tilt(qq), host=False, zero=True), LO, HI, 0, edges)
    xs = gpu_host(tilt(gpu_dev(xs)))
    if ngr:
        xs[:, 7:7 + ngr] = model(xs, zero=True)[1]["zero"]
    top = int(np.argmax(prof))
    best = minimize(neg, xs[top], method="L-BFGS-B", jac=grad, bounds=list(zip(LO, HI)))
    if not best.fun < -prof[top]:
        best.x, best.fun = xs[top], -prof[top]
    ok = np.where(prof >= prof.max() - 2.0)[0]
    allowed = [[round(float(np.exp(edges[c[0]])), 1), round(float(np.exp(edges[c[-1] + 1])), 1)] for c in np.split(ok, np.where(np.diff(ok) > 1)[0] + 1)]
    rng = np.random.default_rng(seed)
    nw = max(48, 4 * len(LO))
    p0 = []
    # the walkers spread by half the likelihood's own width in each parameter at the best orbit, the others held
    bump = np.diag(np.maximum(1e-5 * (HI - LO), 1e-7))
    lp0, up_, dn_ = model(best.x)[0][0], model(best.x + bump)[0], model(best.x - bump)[0]
    with np.errstate(all="ignore"):
        wide = 0.5 / np.sqrt(np.maximum(-(up_ + dn_ - 2.0 * lp0) / np.diag(bump) ** 2, 0.0))
    ball = np.where(np.isfinite(wide) & (wide > 0), np.minimum(wide, 1e-2 * (HI - LO)), 1e-4 * (HI - LO))
    while len(p0) < nw:
        x = np.clip(best.x + ball * rng.standard_normal(len(LO)), LO, HI)
        if np.isfinite(model(x)[0][0]):
            p0.append(x)
        else:
            ball = 0.9 * ball
    chain, accept = gpu_ensemble(lambda q_: model(q_, host=False), np.array(p0), steps, thin=10, seed=seed, graph=True)
    half = chain[len(chain) // 2:]
    ch = half.reshape(-1, len(LO))
    der = model(ch[::max(len(ch) // 3000, 1)])[1]
    q = lambda key, f=1.0: [float(f * np.percentile(der[key], pc)) for pc in (50, 16, 84)]
    m2s = der["m2"] * 1047.57
    pick = ch[np.linspace(0, len(ch) - 1, min(256, len(ch))).astype(int)]
    Pd, K1d = np.exp(pick[:, 0]), model(pick)[1]["K1"] * 1000.0
    draws = np.round(np.column_stack([Pd, tmid + pick[:, 1] * Pd, pick[:, 2] ** 2 + pick[:, 3] ** 2, np.arctan2(pick[:, 3], pick[:, 2]), K1d]), 6)
    # how far the kept chain's two halves lie apart, in the posterior's own widths, the sampler's measure of having settled
    a_, b_ = half[:len(half) // 2].reshape(-1, len(LO)), half[len(half) // 2:].reshape(-1, len(LO))
    spread = np.maximum(ch.std(0), 1e-12)
    drift = float(np.max(np.abs(a_.mean(0) - b_.mean(0)) / spread))
    res = dict(name=name, transits=n_e, nights=int(len(t)), parallax_mas=q("parallax"), m1_prior=[M1, M1e], log_posterior=round(-float(best.fun), 2), period_allowed=allowed, acceptance=round(float(np.mean(accept)), 3),
               chain_drift=round(drift, 3), P_d=q("P"), e=q("e"), K1_ms=q("K1", 1000.0), m2_mjup=q("m2", 1047.57), incl_deg=q("incl"), a_au=q("a_au"), a0_mas=q("a0"), error_scale=q("scale"),
               p_below_13mjup=float(np.mean(m2s < 13.0)), p_below_80mjup=float(np.mean(m2s < 80.0)))
    os.makedirs(os.path.join(planets_RESULTS, "epochs"), exist_ok=True)
    path = os.path.join(planets_RESULTS, "epochs", archive_tag(name) + ".json")
    planets_draws_save(path, res, draws=draws, profile=np.column_stack([np.exp(edges[:-1]), np.exp(edges[1:]), np.exp(xs[:, 0]), prof]))
    json.dump(res, open(path, "w"), separators=(",", ":"))
    print("%s: %d transits, %d nights | P %.1f (%.1f-%.1f) d, e %.2f, i %.0f deg, m2 %.3f (%.3f-%.3f) MJup, a0 %.3f mas, parallax %.3f mas, errors scaled by %.2f | acceptance %.2f, drift %.2f; P(m2 < 13 MJup) %.2f; periods allowed %s" % (
        name, n_e, len(t), res["P_d"][0], res["P_d"][1], res["P_d"][2], res["e"][0], res["incl_deg"][0], res["m2_mjup"][0], res["m2_mjup"][1], res["m2_mjup"][2], res["a0_mas"][0], res["parallax_mas"][0], res["error_scale"][0],
        res["acceptance"], drift, res["p_below_13mjup"], allowed), flush=True)
    return res


# the day Gaia DR4 is released, after which what it should show is no longer a prediction
planets_DR4_RELEASE = "2026-12-02"
# what one Gaia transit measures of a star brighter than G 13, in microarcseconds, the transits of a star in DR4, from ESA's pre-release sample, and DR4's span in days
planets_DR4_TRANSIT_UAS, planets_DR4_TRANSITS, planets_DR4_SPAN = 40.0, 70, 2008.0


def planets_epochs_predict(found, stars):
    """What Gaia DR4's epoch astrometry should show of each new body of the velocities, FOUND being the rows of planets.csv, to RESULTS/dr4_predictions.csv while DR4 is unreleased: its period, K, eccentricity and
    minimum mass, the star's parallax, the least semi-major axis of the star's own orbit on the sky that K gives, seen edge on (a0_min_uas), the significance of that least orbit in DR4's transits (snr_at_minimum), a line
    on the sky read along scans at every angle, which any tilt only raises, so that a body with a high one and no such orbit in the epochs is not there as the velocities say, and whether DR4 spans a whole orbit (within_span)."""
    if time.strftime("%Y-%m-%d") >= planets_DR4_RELEASE:
        return
    bodies = [r for r in found if r["found_by"] in ("census", "eccentric search", "companions") and r["bank_name"] in stars]
    gaia = planets_gaia(sorted({r["bank_name"] for r in bodies}), stars)
    rows = []
    for r in bodies:
        P, K, e = planets_num(r["P_d"]), planets_num(r["K_ms"]), planets_num(r["e"])
        g = gaia.get(r["bank_name"])
        plx = planets_num(g[0].get("parallax")) if g else float("nan")
        a0 = K * P * 86400.0 * math.sqrt(max(1.0 - (e if math.isfinite(e) else 0.0) ** 2, 0.0)) / (2.0 * math.pi * 1.495978707e11) * plx * 1000.0
        rows.append(dict(planet=r["planet"], host=r["host"], kind=r["kind"], bank_name=r["bank_name"], source_id_dr3=g[0].get("source_id") if g else "", P_d=r["P_d"], K_ms=r["K_ms"], e=r["e"], msini_mearth=r["msini_mearth"],
                         parallax_mas=round(plx, 4) if math.isfinite(plx) else "", a0_min_uas=round(a0, 2) if math.isfinite(a0) else "",
                         snr_at_minimum=round(a0 * math.sqrt(planets_DR4_TRANSITS) / (2.0 * planets_DR4_TRANSIT_UAS), 2) if math.isfinite(a0) else "", within_span=P <= planets_DR4_SPAN))
    planets_write(os.path.join(planets_RESULTS, "dr4_predictions.csv"), rows, ["planet", "host", "kind", "bank_name", "source_id_dr3", "P_d", "K_ms", "e", "msini_mearth", "parallax_mas", "a0_min_uas", "snr_at_minimum", "within_span"])


# ESA's service of the rows TAP does not hold, and its names for the shape of a source's table, one row a transit first
planets_DATALINK = "https://gea.esac.esa.int/data-server/data"
planets_DATALINK_SHAPES = ("DATAMODEL_GAIA", "DATAMODEL_STANDARD")


def planets_epochs_sources(names, stars):
    """Each star's Gaia DR4 source, from its DR3 source (planets_gaia) through DR4's table of the two releases' neighbours, the nearest of its probable matches, kept in ROOT/epochs/sources.json: name to source or None."""
    path = planets_path("epochs", "sources.json")
    kept = planets_load_json(path) or {}
    todo = [n for n in names if n not in kept]
    if todo:
        dr3 = {n: str(g[0]["source_id"]) for n, g in planets_gaia(todo, stars).items() if g}
        ids, best = sorted(set(dr3.values())), {}
        for i in range(0, len(ids), 500):
            for r in archive_tap("gaia", "SELECT source_id, dr3_source_id, angular_distance, probable_match FROM gaiadr4.dr3_neighbourhood WHERE dr3_source_id IN (%s)" % ", ".join(ids[i:i + 500])):
                d, k = planets_num(r["angular_distance"]), r["dr3_source_id"]
                if str(r["probable_match"]).lower() in ("true", "1", "t") and (k not in best or d < best[k][0]):
                    best[k] = (d, r["source_id"])
        for n in todo:
            kept[n] = best[dr3[n]][1] if dr3.get(n) in best else None
        os.makedirs(os.path.dirname(path), exist_ok=True)
        archive_save(path, json.dumps(kept, separators=(",", ":")).encode())
    return {n: kept.get(n) for n in names}


def planets_epochs_load(sources, size=200):
    """Gaia DR4's epoch astrometry of the sources SOURCES (planets_epochs_read), each kept in ROOT/epochs/<source>.npz and fetched from ESA's service where it is absent, SIZE sources to a request, a source it holds nothing of kept empty: source to its series, those with no transits left out."""
    import zipfile
    folder = planets_path("epochs")
    os.makedirs(folder, exist_ok=True)
    path_of = lambda s: os.path.join(folder, "%s.npz" % s)
    todo = sorted({str(s) for s in sources if not os.path.exists(path_of(s))})
    for i in range(0, len(todo), size):
        part, raw = todo[i:i + size], None
        for shape in planets_DATALINK_SHAPES:
            ask = urllib.parse.urlencode(dict(ID=",".join(part), RELEASE="Gaia DR4", RETRIEVAL_TYPE="EPOCH_ASTROMETRY", DATA_STRUCTURE=shape, FORMAT="votable", VALID_DATA="false", USE_ZIP_ALWAYS="true", LINKING_PARAMETER="SOURCE_ID")).encode()
            raw = archive_get(planets_DATALINK, payload=ask, timeout=1800, retries=2, soft=True)
            if raw:
                break
        if not raw:
            raise IOError("ESA's service gave no epoch astrometry")
        series = {}
        with zipfile.ZipFile(io.BytesIO(raw)) as z:
            for member in z.namelist():
                with z.open(member) as fh:
                    series.update(planets_epochs_read(io.BytesIO(fh.read())))
        for s in part:
            d = series.get(int(s), dict(t=np.zeros(0), w=np.zeros(0), e=np.zeros(0), sin=np.zeros(0), cos=np.zeros(0), f=np.zeros(0), excess_noise=0.0))
            tmp = archive_tmp(path_of(s))
            with open(tmp, "wb") as fh:
                np.savez(fh, **d)
            archive_place(tmp, path_of(s))
    out = {}
    for s in sources:
        with np.load(path_of(s)) as z:
            if len(z["t"]):
                out[str(s)] = {k: z[k] for k in z.files}
    return out


def planets_epochs_grid(d, draws, m1, parallax, incl=240, nodes=72):
    """Gaia DR4's epoch series D against the velocities' orbits DRAWS, rows of (P, tp in MJD, e, omega, K in m/s) about a star of M1 solar masses and PARALLAX mas: at each orbit, inclination (0.25 to 90 degrees, and the same retrograde, evenly likely in cos i)
    and node the star's own orbit on the sky is fixed, K giving its size for that inclination, shifted toward a companion below the star's mass by its share of the light (planets_epochs_weigh), and the five single-star parameters are solved beside it. Each point's
    likelihood holds the errors scaled by the least factor of one or more that gives a reduced chi-square of one or less. Returns the log of the mean likelihood over the grid against the same star with no orbit, the likelihood's point at the grid's best, as (orbit, inclination, node),
    the significance of the least orbit, seen edge on, and each (orbit, inclination)'s posterior weight with its companion mass (Jupiter's), inclination (deg) and semi-major axis on the sky (mas)."""
    s = d["e"]
    A0 = planets_epochs_design(d) / s[:, None]
    Q = np.linalg.qr(A0)[0]
    y = d["w"] / s
    y = y - Q @ (Q.T @ y)
    dof, yy = len(y) - 5, float(y @ y)
    t = planets_DR4_MJD + d["t"] * 365.25
    sn, cs = d["sin"] / s, d["cos"] / s
    lnl = lambda c2: -dof * 0.5 * np.log(np.maximum(c2 / dof, 1.0)) - 0.5 * c2 / np.maximum(c2 / dof, 1.0)
    i = np.geomspace(0.25, 90.0, incl + 1)
    wi = np.abs(np.diff(np.cos(np.radians(i))))
    i = np.sqrt(i[:-1] * i[1:])
    ci, si = np.cos(np.radians(i)), np.sin(np.radians(i))
    # both senses of the orbit
    ci2, wi2 = np.concatenate([ci, -ci]), np.concatenate([wi, wi]) / (2.0 * wi.sum())
    om = 2.0 * np.pi * np.arange(nodes) / nodes
    cO, sO = np.cos(om)[None, :], np.sin(om)[None, :]
    D = np.atleast_2d(draws)
    each, weight, masses, sizes, top, least = [], [], [], [], (-np.inf, None), []
    for k, (P, tp, e, w, K) in enumerate(D):
        M = 2.0 * np.pi * (((t - tp) / P) % 1.0)
        E = M + e * np.sin(M)
        for _ in range(30):
            E = E - (E - e * np.sin(E) - M) / (1.0 - e * np.cos(E))
        X, Y = np.cos(E) - e, math.sqrt(1.0 - e * e) * np.sin(E)
        b = np.column_stack([X * sn, Y * sn, X * cs, Y * cs])
        b = b - Q @ (Q.T @ b)
        N, v = b.T @ b, b.T @ y
        cw, sw = math.cos(w), math.sin(w)
        c = ci2[:, None]
        # the Thiele-Innes constants of an orbit of unit size, in the order of B: B, G, A, F
        u = np.stack([cw * sO + sw * cO * c, -sw * sO + cw * cO * c, cw * cO - sw * sO * c, -sw * cO - cw * sO * c], -1)
        a1 = K * P * 86400.0 * math.sqrt(1.0 - e * e) / (2.0 * math.pi * 1.495978707e11) / si
        m2 = planets_least_mass(1.0361e-7 * (1.0 - e * e) ** 1.5 * (K / 1000.0) ** 3 * P / si ** 3, m1)
        q = m2 / m1
        lit = np.where(q < 1.0, q ** 3.5 / (1.0 + q ** 3.5), 0.0)
        a0 = a1 * np.maximum(1.0 - lit * (m1 + m2) / np.maximum(m2, 1e-12), 0.0) * parallax
        a02 = np.concatenate([a0, a0])
        un = (u @ N * u).sum(-1)
        chi = yy - 2.0 * a02[:, None] * (u @ v) + a02[:, None] ** 2 * un
        ll = lnl(chi)
        # the least orbit's signal, seen edge on, against the errors
        least.append(a0[-1] * math.sqrt(float(np.mean(un[incl - 1]))))
        peak = int(np.argmax(ll))
        if ll.flat[peak] > top[0]:
            at = np.unravel_index(peak, ll.shape)
            top = (float(ll.flat[peak]), (k, float(ci2[at[0]]), float(om[at[1]]), float(a02[at[0]]), u[at[0], at[1]]))
        mx = float(ll.max())
        per = np.exp(ll - mx).mean(1) * wi2
        each.append(mx + math.log(float(per.sum())))
        weight.append((np.log(np.maximum(per[:incl] + per[incl:], 1e-300)) + mx))
        masses.append(m2 * 1047.57), sizes.append(a0)
    each = np.array(each)
    base = float(each.max())
    ln_b = base + math.log(float(np.exp(each - base).mean())) - float(lnl(np.array(yy)))
    w = np.array(weight)
    w = np.exp(w - w.max())
    return dict(ln_b=ln_b, best=top[1], snr_least=float(np.median(least)), weight=w / w.sum(), mass=np.array(masses), size=np.array(sizes), incl=i)


def planets_epochs_held(d, draws, m1, most=32):
    """A velocity orbit's posterior draws DRAWS (planets_orbits) held against Gaia DR4's epoch series D (planets_epochs_grid), the star's parallax that of the single-star fit, then with the grid's best orbit taken out: the log Bayes factor of the orbit
    against no orbit (ln_bayes), the same at eight periods about it with nothing else moved (control, their highest), the least orbit's significance (snr_least), the companion's mass (Jupiter's), inclination and size on the sky with their 16th to 84th percentiles, the
    probability that it lies below 13 Jupiter masses, and a verdict: held where ln_bayes is 5 or more and 5 above the control; refuted where it is -5 or less, the data leaving no room for the least orbit K allows; open otherwise."""
    D = np.atleast_2d(draws)
    D = D[np.unique(np.linspace(0, len(D) - 1, most).round().astype(int))]
    plx = float(planets_epochs_star(d)[0][2])
    plx = plx if plx > 0 else abs(plx) + 1e-3
    got = planets_epochs_grid(d, D, m1, plx)
    # the parallax again with the best orbit taken out
    k, _, _, a0, u = got["best"]
    P, tp, e, _, _ = D[k]
    M = 2.0 * np.pi * (((planets_DR4_MJD + d["t"] * 365.25 - tp) / P) % 1.0)
    E = M + e * np.sin(M)
    for _ in range(30):
        E = E - (E - e * np.sin(E) - M) / (1.0 - e * np.cos(E))
    X, Y = np.cos(E) - e, math.sqrt(1.0 - e * e) * np.sin(E)
    orbit = a0 * ((u[0] * X + u[1] * Y) * d["sin"] + (u[2] * X + u[3] * Y) * d["cos"])
    plx2 = float(planets_epochs_star(dict(d, w=d["w"] - orbit))[0][2])
    if plx2 > 0:
        plx = plx2
        got = planets_epochs_grid(d, D, m1, plx)
    control = max(planets_epochs_grid(d, D * np.array([f, 1.0, 1.0, 1.0, 1.0]), m1, plx)["ln_b"] for f in (0.62, 0.71, 0.8, 0.89, 1.12, 1.26, 1.41, 1.59))
    w = got["weight"].ravel()

    def pct(x):
        x = np.asarray(x).ravel()
        o = np.argsort(x)
        c = np.cumsum(w[o])
        return [round(float(x[o][np.searchsorted(c, q)]), 4) for q in (0.5, 0.16, 0.84)]
    incl = np.broadcast_to(got["incl"], got["mass"].shape)
    m = got["mass"]
    verdict = "held" if got["ln_b"] >= 5.0 and got["ln_b"] - control >= 5.0 else "refuted" if got["ln_b"] <= -5.0 else "open"
    return dict(P=round(float(np.median(D[:, 0])), 4), ln_bayes=round(got["ln_b"], 2), control=round(float(control), 2), snr_least=round(got["snr_least"], 2), parallax_mas=round(plx, 4), mass_mjup=pct(m), incl_deg=pct(incl),
                a0_mas=pct(got["size"]), p_below_13mjup=round(float(w[m.ravel() < 13.0].sum()), 4), verdict=verdict)


# the false-alarm level below which an orbit the epochs show of themselves is weighed, and the seconds a pass over a root's stars runs before the round goes on
planets_DR4_FAP, planets_DR4_PASS = 1e-3, 1800.0


def planets_epochs_velocities(t, v, e, g, draws, rest=()):
    """An orbit weighed from the epochs alone, its posterior draws DRAWS (P, tp, e, omega, K), held against a star's velocities V at times T with errors E joined by 1 m/s, an offset for each of G, the star's other orbits REST, posterior draws likewise, taken out at their medians: the log of the mean likelihood over
    the draws against no orbit at all (ln_bayes), each likelihood holding the errors scaled by the least factor of one or more that gives a reduced chi-square of one or less, the argument of periastron as drawn or turned half way, which astrometry alone cannot tell, whichever gives more, with the amplitude the velocities
    give the best draw's curve over its own (scale, scale_err). A draw's period carries its phase over the velocities' whole span, so the draws together hold what the epochs leave open of it. Its verdict: held at 5 or more, failed at -5 or less, open otherwise."""
    less = sum((planets_kepler_draws(t, np.median(x, axis=0)[None, :])[0] for x in rest), np.zeros(len(t)))
    s = np.hypot(e, 1.0)
    Q = np.linalg.qr(np.column_stack([(g == k).astype(float) for k in np.unique(g)]) / s[:, None])[0]
    y = (v - less) / s
    y = y - Q @ (Q.T @ y)
    dof = len(t) - Q.shape[1]
    lnl = lambda c2: -dof * 0.5 * np.log(np.maximum(c2 / dof, 1.0)) - 0.5 * c2 / np.maximum(c2 / dof, 1.0)
    base, best = float(lnl(np.array(float(y @ y)))), None
    for turn in (0.0, math.pi):
        c = planets_kepler_draws(t, draws + np.array([0.0, 0.0, 0.0, turn, 0.0])) / s[None, :]
        c = c - (c @ Q) @ Q.T
        ll = lnl(((y[None, :] - c) ** 2).sum(1))
        top = float(ll.max())
        ln_b = top + math.log(float(np.exp(ll - top).mean())) - base
        if best is None or ln_b > best[0]:
            k = int(np.argmax(ll))
            gain = float(c[k] @ c[k])
            amp = float(c[k] @ y) / gain if gain > 0 else 0.0
            chi = float(((y - amp * c[k]) ** 2).sum())
            best = (ln_b, amp, math.sqrt(max(chi / max(dof - 1, 1), 1.0) / gain) if gain > 0 else float("inf"))
    return dict(ln_bayes=round(best[0], 2), scale=round(best[1], 3), scale_err=round(best[2], 3), verdict="held" if best[0] >= 5.0 else "failed" if best[0] <= -5.0 else "open", nights=int(len(t)))


def planets_epochs_star_record(name, star, source, d, sampled, perms, floor):
    """One star's reading of Gaia DR4's epochs D for RESULTS/dr4/<star>.json (planets_epochs_refresh): each of its velocity orbits held against them (planets_epochs_held), and their own search (planets_epochs_power), an orbit taking out FLOOR of the chi-square or more set against PERMS
    shufflings of the transits' residuals, by a Gumbel law on them. An orbit below planets_DR4_FAP is set against ESA's own orbits, weighed from the epochs alone (planets_epochs_weigh) and that weighing's orbit held against the star's velocities (planets_epochs_velocities), the star's other
    orbits taken out of them, then weighed from both where they hold it."""
    tag = archive_tag(name)
    c, _, r, chi = planets_epochs_star(d)
    rec = dict(name=name, source_id=source, transits=int(len(d["t"])), orbits_sampled=sampled, parallax_mas=round(float(c[2]), 4), reduced_chi2=round(chi / max(len(r) - 5, 1), 3), tests=[], nss=[])
    m1 = archive_num(star.get("Mass")) or ((planets_load_json(planets_path("stellar.json")) or {}).get(name) or [None] * 3)[2] or planets_mass(star.get("SpType"))
    others = []
    folder = os.path.join(planets_RESULTS, "orbits")
    path = os.path.join(folder, tag + ".json")
    o = planets_load_json(path)
    if o and "draws" in o:
        D = planets_draws_load(path, o)["draws"]
        others = list(D)
        for pl, draws in zip(o["planets"], D):
            rec["tests"].append(dict(planets_epochs_held(d, draws, o.get("mstar") or m1), source="orbits"))
    for path, mass in ((os.path.join(planets_RESULTS, "weigh", tag + ".json"), lambda x: x["m1_prior"][0]), (os.path.join(folder, tag + ".companion.json"), lambda x: x.get("mstar") or m1)):
        w = planets_load_json(path)
        if w and "draws" in w:
            D = planets_draws_load(path, w)["draws"]
            rec["tests"].append(dict(planets_epochs_held(d, D[0] if D.ndim == 3 else D, mass(w)), source="companion"))
            others.append(D[0] if D.ndim == 3 else D)
            break
    p = planets_epochs_power(d)
    dchi = p["share"] * p["chi0"]
    s = dict(P=round(p["P"], 4), e=p["e"], share=round(p["share"], 4), dchi2=round(dchi, 1), fap=1.0, **{k: round(v, 3) for k, v in planets_epochs_campbell(p, float(c[2]), m1).items() if k in ("a0_mas", "incl_deg", "m2_mjup")})
    if dchi >= floor:
        rng = np.random.default_rng(zlib.crc32(tag.encode()))
        null = [planets_epochs_power(d, shuffle=rng)["share"] for _ in range(perms)]
        beta = max(float(np.std(null, ddof=1)) * math.sqrt(6.0) / math.pi, 1e-9)
        z = -(p["share"] - (float(np.mean(null)) - 0.5772 * beta)) / beta
        s["fap"] = 1.0 if z > 700.0 else float(-math.expm1(-math.exp(z)))
    rec["search"] = s
    if s["fap"] < planets_DR4_FAP:
        rec["nss"] = [dict(solution_type=x.get("solution_type") or x.get("nss_solution_type"), period=planets_num(x.get("period"))) for x in archive_tap("gaia", "SELECT * FROM gaiadr4.nss_two_body_orbit WHERE source_id = %s" % source)]
        weighed = planets_epochs_weigh(name, d, (m1, 0.1 * m1))
        try:
            t, v, e, g, _, _, _ = planets_nights_all(name)
        except (IndexError, ValueError):
            t = v = e = g = np.zeros(0)
        P = weighed["P_d"][0]
        rest = [x for x in others if abs(float(np.median(x[:, 0])) / P - 1.0) > 0.05]
        if len(t) >= len(np.unique(g)) + 4:
            with np.load(os.path.join(planets_RESULTS, "epochs", tag + ".draws.npz")) as z_:
                rec["velocity_test"] = planets_epochs_velocities(t, v, e, g, z_["draws"], rest)
            if rec["velocity_test"]["verdict"] == "held":
                less = sum((planets_kepler_draws(t, np.median(x, axis=0)[None, :])[0] for x in rest), np.zeros(len(t)))
                planets_epochs_weigh(name, d, (m1, 0.1 * m1), velocities=(t, v - less, e, g))
    return rec


def planets_epochs_refresh(part=None, perms=20, floor=40.0):
    """Gaia DR4's epochs read for each star of the root (planets_epochs_star_record) once it is released and answers, to RESULTS/dr4/<star>.json, the stars of new bodies first, then those with signals, then the census's: fetched as they come (planets_epochs_sources, planets_epochs_load), read again where
    the star's orbits are sampled again. PART takes the share K/N; the pass runs for planets_DR4_PASS seconds at most and comes round again, and ends between stars where a long search would, with exit status 3."""
    if time.strftime("%Y-%m-%d") < planets_DR4_RELEASE:
        return
    try:
        archive_tap("gaia", "SELECT TOP 1 source_id FROM gaiadr4.gaia_source", timeout=120, retries=1)
    except Exception as exc:
        print("Gaia DR4 does not answer: %s" % str(exc)[:160], flush=True)
        return
    names, stars, _, _ = planets_share()
    table = os.path.join(planets_RESULTS, "signals.csv")
    rows = planets_read(table) if os.path.exists(table) else []
    new, signals = {r["name"] for r in rows if r["status"] == "new"}, {r["name"] for r in rows}
    names = sorted(n for n in (set(names) | signals) & set(stars) if math.isfinite(planets_num(stars[n].get("RAJ2000"))))
    names.sort(key=lambda n: (n not in new, n not in signals))
    if part:
        k, n = (int(x) for x in part.split("/"))
        names = names[k::n]
    folder = os.path.join(planets_RESULTS, "dr4")
    os.makedirs(folder, exist_ok=True)
    started, done = time.time(), 0
    for c in range(0, len(names), 50):
        todo = []
        for name in names[c:c + 50]:
            orbit = os.path.join(planets_RESULTS, "orbits", archive_tag(name) + ".json")
            sampled = os.path.getmtime(orbit) if os.path.exists(orbit) else 0.0
            if (planets_load_json(os.path.join(folder, archive_tag(name) + ".json")) or {}).get("orbits_sampled") != sampled:
                todo.append((name, sampled))
        if not todo:
            continue
        try:
            sources = planets_epochs_sources([n for n, _ in todo], stars)
            series = planets_epochs_load([s for s in sources.values() if s])
        except Exception as exc:
            # an archive that does not answer, or that answers with something else: the pass comes round again
            print("the epochs of %d stars not had: %s: %s" % (len(todo), type(exc).__name__, str(exc)[:200]), flush=True)
            return
        for name, sampled in todo:
            if planets_search_ends():
                sys.exit(3)
            if time.time() - started > planets_DR4_PASS:
                print("%d stars read" % done, flush=True)
                return
            source, d = sources.get(name), series.get(str(sources.get(name)))
            try:
                rec = planets_epochs_star_record(name, stars[name], source, d, sampled, perms, floor) if d is not None and len(d["t"]) >= 20 else dict(name=name, source_id=source, orbits_sampled=sampled, note="no epochs")
            except IOError as exc:
                # an archive that did not answer: the star comes round again
                print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
                continue
            except Exception as exc:
                print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
                rec = dict(name=name, source_id=source, orbits_sampled=sampled, note="%s: %s" % (type(exc).__name__, str(exc)[:200]))
            archive_save(os.path.join(folder, archive_tag(name) + ".json"), json.dumps(rec, separators=(",", ":")).encode())
            done += 1
            print("%s: %s" % (name, rec.get("note") or "%d transits, reduced chi-square %.2f; %s; own orbit P %.1f d, false alarm %.1e" % (
                rec["transits"], rec["reduced_chi2"], ", ".join("%.4g d %s (ln B %.1f, mass %.3g MJup)" % (x["P"], x["verdict"], x["ln_bayes"], x["mass_mjup"][0]) for x in rec["tests"]) or "no velocity orbit", rec["search"]["P"], rec["search"]["fap"])), flush=True)
            if gpu_DEVICE.type == "cuda":
                torch.cuda.empty_cache()
    print("share done: %d stars read" % done, flush=True)


def planets_epochs_rows(stars, sig):
    """The orbits Gaia DR4's epochs show of themselves (planets_epochs_refresh) as signals.csv rows, those beside the signals SIG of their star within 5 per cent in period being its velocities' own: known where ESA's orbits hold the star within 20 per cent in period; rejected where the
    star's velocities refute the orbit, new where they hold it, a candidate otherwise."""
    rows = []
    for path in sorted(glob.glob(os.path.join(planets_RESULTS, "dr4", "*.json"))):
        rec = planets_load_json(path) or {}
        s = rec.get("search") or {}
        w = planets_load_json(os.path.join(planets_RESULTS, "epochs", os.path.basename(path)))
        if s.get("fap", 1.0) >= planets_DR4_FAP or not w:
            continue
        name, P = rec["name"], w["P_d"][0]
        if any(x["name"] == name and abs(planets_num(x["P"]) / P - 1.0) < 0.05 for x in sig):
            continue
        star, t = stars.get(name, {}), rec.get("velocity_test") or {}
        K, e = w["K1_ms"][0], w["e"][0]
        msini = planets_msini(P, K, e, w["m1_prior"][0])
        cat = ["Gaia DR4 %s %.1f d" % (x["solution_type"], x["period"]) for x in rec.get("nss", []) if x["period"] > 0 and abs(x["period"] / P - 1.0) < 0.2]
        status, reason = ("known", "catalogued") if cat else ("rejected", "velocities") if t.get("verdict") == "failed" else ("new", "") if t.get("verdict") == "held" else ("candidate", "")
        row = dict(name=name, sptype=star.get("SpType", ""), vmag=star.get("Vmag", ""), kind="astrometry", label="astrometric orbit", nights=t.get("nights", ""), span_d=round(planets_DR4_SPAN), P=round(P, 4), K=round(K, 2), e=round(e, 3), msini_mjup=round(msini, 4),
                   msini_mearth=round(msini * 317.83, 1), fap=s["fap"], flags="", object=planets_object(w["m2_mjup"][0]), mass_mjup=round(w["m2_mjup"][0], 3), mass_mjup_lo=round(w["m2_mjup"][1], 3), mass_mjup_hi=round(w["m2_mjup"][2], 3), status=status, reason=reason,
                   catalogued="; ".join(cat), ruwe="", second_instrument="velocities" if t else "", second_nights=t.get("nights", ""), second_scale=t.get("scale", ""), second_scale_err=t.get("scale_err", ""), second_test=t.get("verdict", ""))
        for key, col in (("P_d", "orbit_P"), ("K1_ms", "orbit_K"), ("e", "orbit_e")):
            row.update({col: round(w[key][0], 4), col + "_lo": round(w[key][1], 4), col + "_hi": round(w[key][2], 4)})
        rows.append(row)
    return rows


def planets_epochs_decide(sig):
    """The bodies of SIG given what Gaia DR4's epochs hold of their velocity orbits (planets_epochs_held), within 5 per cent in period, their columns dr4_test, dr4_ln_bayes, dr4_control, dr4_snr_least, dr4_mass_mjup with its range and dr4_incl_deg. A new body they refute is rejected; one they hold takes the mass
    they give it. What they make of the known bodies is printed, as they test the test."""
    if not os.path.isdir(os.path.join(planets_RESULTS, "dr4")):
        return
    tally = {}
    for r in sig:
        if r["status"] not in ("new", "known") or r["kind"] not in ("known", "found", "eccentric", "companion") or not r.get("P"):
            continue
        rec = planets_load_json(os.path.join(planets_RESULTS, "dr4", archive_tag(r["name"]) + ".json")) or {}
        P = planets_num(r.get("orbit_P") or r["P"])
        x = next((t for t in rec.get("tests", []) if abs(t["P"] / P - 1.0) < 0.05), None)
        if not x:
            continue
        r.update(dr4_test=x["verdict"], dr4_ln_bayes=x["ln_bayes"], dr4_control=x["control"], dr4_snr_least=x["snr_least"], dr4_mass_mjup=x["mass_mjup"][0], dr4_mass_lo=x["mass_mjup"][1], dr4_mass_hi=x["mass_mjup"][2], dr4_incl_deg=x["incl_deg"][0])
        if r["status"] == "known" and x["snr_least"] >= 10.0:
            tally[x["verdict"]] = tally.get(x["verdict"], 0) + 1
        if r["status"] == "new":
            if x["verdict"] == "refuted":
                r.update(status="rejected", reason="no astrometric orbit")
            elif x["verdict"] == "held":
                r.update(mass_mjup=x["mass_mjup"][0], mass_mjup_lo=x["mass_mjup"][1], mass_mjup_hi=x["mass_mjup"][2], object=planets_object(x["mass_mjup"][0]))
    if tally:
        print("Gaia DR4 of the known bodies whose least orbit it could see at 10 sigma: %s" % tally, flush=True)


def planets_kepler_draws(t, draws):
    """Radial velocities (m/s) at times T for each posterior draw (P, tp, e, omega, K), as an array of shape (draws, times)."""
    d = np.asarray(draws, float).reshape(-1, 5)
    return d[:, 4:5] * planets_kepler(np.asarray(t, float)[None, :], d[:, 0:1], d[:, 1:2], d[:, 2:3], d[:, 3:4])


def planets_run_all(tasks, workers=6):
    """Run `orbitlight.py planets <task>` for each task in TASKS, WORKERS at a time, each logged to ROOT/followup/; return the tasks that failed."""
    folder = planets_path("followup")
    os.makedirs(folder, exist_ok=True)

    def run(args):
        with open(os.path.join(folder, archive_tag(*[a for a in args if not a.startswith("-")][:2]) + ".log"), "w", encoding="utf-8") as fh:
            return args, subprocess.run([sys.executable, "-u", os.path.abspath(__file__), "planets"] + list(args), stdout=fh, stderr=subprocess.STDOUT).returncode
    with cf.ThreadPoolExecutor(workers) as ex:
        return [a for a, code in ex.map(run, tasks) if code]


planets_FORM = ("Keplerian radial velocity v(t) = K [cos(nu + omega) + e cos(omega)], where the mean anomaly is M = 2 pi (t - tp) / P, the eccentric "
                "anomaly E solves E - e sin E = M, and the true anomaly satisfies tan(nu / 2) = sqrt((1 + e) / (1 - e)) tan(E / 2). Units: t and tp in "
                "MJD, P in days, omega in radians, K in m/s. Each draw lists (P, tp, e, omega, K).")

planets_LEDGER_KEYS = ["planet", "host", "kind", "found_by", "bank_name", "cutoff_mjd", "P_d", "P_lo", "P_hi", "K_ms", "K_lo", "K_hi", "e", "e_lo", "e_hi",
                       "new_nights", "new_from", "new_to", "scale", "scale_err", "prediction", "tests"]


def planets_ledger(workers=6, most=30):
    """Test each new body's predicted orbit against observations made after its discovery, writing RESULTS/ledger.csv, RESULTS/ledger/<planet>.json and
    beside each record its posterior draws and its system's other planets' draws, the arrays draws and others of <planet>.draws.npz.

    Each body's orbit is stored in closed form as posterior draws, with a cutoff: the date of the last observation used to decide it. Velocities measured
    after the cutoff (HARPS line-by-line velocities for planets and TESS candidates, cross-correlation velocities for companions), minus the predicted
    curves of the other planets in the system, are fitted as an offset plus a scale times the body's predicted curve. The prediction holds if the scale
    is within 3 sigma or 30% of 1, fails if the scale is measured to 0.2 or better and lies outside that range, and stays pending otherwise, as it does
    with fewer than three nights after the cutoff. A body whose prediction holds is refitted with every velocity measured since its discovery, which
    moves its cutoff forward; the other bodies of its star keep their orbits and cutoffs."""
    from astropy.coordinates import Angle
    found = planets_read(os.path.join(planets_RESULTS, "planets.csv"))
    signals = planets_read(os.path.join(planets_RESULTS, "signals.csv"))
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    folder = os.path.join(planets_RESULTS, "ledger")
    os.makedirs(folder, exist_ok=True)
    os.makedirs(planets_path("ledger"), exist_ok=True)
    load = lambda p: json.load(open(p)) if os.path.exists(p) else None
    orbit_path = lambda n: os.path.join(planets_RESULTS, "orbits", archive_tag(n) + ".json")
    weigh_path = lambda n: os.path.join(planets_RESULTS, "weigh", archive_tag(n) + ".json")
    entries = {}
    for p in glob.glob(os.path.join(folder, "*.json")):
        e = load(p)
        if e and "planet" in e:
            # Every record takes its draws from the .draws.npz file beside it and carries the current description of its formula.
            d = planets_draws_load(p, e)
            e.update(draws=d["draws"], others=list(d["others"]), form=planets_FORM)
            entries[e["planet"]] = e
    # A record follows its body's current decision until observations made after its cutoff have tested it, and leaves the ledger once its body is no
    # longer new.
    current = {r["planet"] for r in found}
    for name in list(entries):
        if name not in current or not any(t.get("new_nights") for t in entries[name]["tests"]):
            for f in (archive_tag(name) + ".json", archive_tag(name) + ".draws.npz"):
                if os.path.exists(os.path.join(folder, f)):
                    os.remove(os.path.join(folder, f))
            del entries[name]
    fresh = [r for r in found if r["planet"] not in entries]
    # Sample the orbits (planets orbits, planets weigh) of new bodies that have no posterior draws yet.
    todo = {}
    for r in fresh:
        n = r["bank_name"]
        if r["found_by"] in ("census", "eccentric search"):
            o = load(orbit_path(n))
            if not o or "draws" not in o:
                todo[(n, "orbits")] = ["orbits", n, ",".join(repr(p["P"][0]) for p in o["planets"]) if o else r["P_d"]]
        elif r["found_by"] == "companions":
            w = load(weigh_path(n))
            if not w or "draws" not in w:
                todo[(n, "weigh")] = ["weigh", n]
    for args in planets_run_all(list(todo.values()), workers):
        print("%s %s failed" % tuple(args[:2]), flush=True)
    exofop = {x["TOI"]: x for x in planets_read(planets_path("toi.csv"))} if os.path.exists(planets_path("toi.csv")) else {}
    weighed, made = {}, {}
    for table in ("tois.csv", "tois_eso.csv", "tois_rvcat.csv", "tois_bank.csv"):
        if os.path.exists(planets_path(table)):
            for x in planets_read(planets_path(table)):
                weighed.setdefault(x["toi"], x)
                made.setdefault(x["toi"], os.path.getmtime(planets_path(table)) / 86400.0 + 40587.0)
    dace_last, wanted = {}, {r["bank_name"] for r in fresh if r["found_by"] in ("census", "eccentric search")}
    if wanted and os.path.exists(planets_path("dace.csv")):
        for x in csv.DictReader(open(planets_path("dace.csv"), encoding="utf-8")):
            if x["name"] in wanted:
                dace_last[x["name"]] = max(dace_last.get(x["name"], 0.0), planets_num(x["mjd"]))
    lbl_last = lambda tag: float(np.load(planets_path("lbl", tag + ".lbl.npz"))["mjd"].max()) if os.path.exists(planets_path("lbl", tag + ".lbl.npz")) else 0.0

    def form_of(r):
        """A body's closed form: its posterior draws, the draws of the other planets in its system, the jitter added to later velocities, and the
        star's file tag and position."""
        n, P = r["bank_name"], float(r["P_d"])
        if r["found_by"] in ("census", "eccentric search"):
            o = load(orbit_path(n))
            D = planets_draws_load(orbit_path(n), o)["draws"]
            i = min(range(len(o["planets"])), key=lambda k: abs(o["planets"][k]["P"][0] / P - 1.0))
            return dict(draws=D[i], others=[D[k] for k in range(len(D)) if k != i], jitter=o["jitter"][planets_BANK_FAMILY][0],
                        tag=archive_tag(n), source="HARPS line-by-line", ra=planets_num(stars[n]["RAJ2000"]), dec=planets_num(stars[n]["DEJ2000"]),
                        cutoff=max(o.get("last_mjd", 0.0), dace_last.get(n, 0.0), lbl_last(archive_tag(n))))
        if r["found_by"] == "companions":
            w = load(weigh_path(n))
            c = load(os.path.join(planets_RESULTS, "companion", archive_tag(n) + ".json")) or {}
            return dict(draws=planets_draws_load(weigh_path(n), w)["draws"], others=[], jitter=(c.get("ccf") or {}).get("rms", 10.0), tag=archive_tag(n),
                        source="HARPS cross-correlation",
                        ra=planets_num(stars[n]["RAJ2000"]), dec=planets_num(stars[n]["DEJ2000"]), cutoff=w["last_mjd"])
        # TESS candidates: a circular orbit from the transit ephemeris (P, Tc) and the fitted K, v(t) = -K sin(2 pi (t - Tc) / P).
        toi = next(s["label"][4:] for s in signals if s["kind"] == "toi" and s["name"] == n and abs(float(s["P"]) / P - 1.0) < 1e-3)
        x, wt = exofop[toi], weighed[toi]
        rng = np.random.default_rng(zlib.crc32(toi.encode()))
        err = lambda v: v if math.isfinite(v) else 0.0
        P0, Tc = planets_num(x["Period (days)"]), planets_num(x["Epoch (BJD)"]) - 2400000.5
        d = np.column_stack([P0 + err(planets_num(x["Period (days) err"])) * rng.standard_normal(256),
                             Tc + err(planets_num(x["Epoch (BJD) err"])) * rng.standard_normal(256), np.zeros(256), np.full(256, math.pi / 2),
                             planets_num(wt["K"]) + planets_num(wt["eK"]) * rng.standard_normal(256)])
        tag = "TOI-" + toi.split(".")[0]
        return dict(draws=np.round(d, 6), others=[], jitter=planets_num(wt["jitter"]), tag=tag, source="HARPS line-by-line",
                    ra=Angle(x["RA"], unit="hourangle").deg, dec=Angle(x["Dec"], unit="deg").deg, cutoff=max(made[toi], lbl_last(tag)))

    for r in fresh:
        try:
            f = form_of(r)
        except (KeyError, StopIteration) as exc:
            print("%s: no closed form (%s)" % (r["planet"], exc), flush=True)
            continue
        entries[r["planet"]] = dict(planet=r["planet"], host=r["host"], kind=r["kind"], found_by=r["found_by"], bank_name=r["bank_name"], form=planets_FORM,
                                    cutoff_mjd=round(f.pop("cutoff"), 3), tests=[], **f)

    # Every body's HARPS spectra, listed from a single query of the archive's index.
    names = sorted(entries)
    listings = dict(zip(names, archive_eso_listings([(entries[n]["ra"], entries[n]["dec"]) for n in names], "HARPS", 10.0)))

    def newer(name, e):
        """The star's velocities, one per night, on the nights since the body's discovery (the cutoff of its first test), measured where the archive holds
        three nights or more after the current cutoff: times (MJD), velocities and errors (m/s). The test takes the nights after the current cutoff; a
        refit takes them all."""
        nothing = (np.zeros(0),) * 3
        first = e["tests"][0]["cutoff_mjd"] if e["tests"] else e["cutoff_mjd"]
        # The spectra each method measures: signal to noise above 10 for cross-correlation and above 20 for line-by-line velocities.
        least_snr = 10.0 if e["source"] == "HARPS cross-correlation" else 20.0
        listed = [x for x in listings[name] if x["t_min"] > first + 0.5 and x["snr"] > least_snr]
        if len({math.floor(x["t_min"] + 0.3) for x in listed if x["t_min"] > e["cutoff_mjd"] + 0.5}) < 3:
            return nothing
        if e["source"] == "HARPS cross-correlation":
            best = {}
            for x in listed:
                k = math.floor(x["t_min"] + 0.3)
                if k not in best or x["snr"] > best[k]["snr"]:
                    best[k] = x
            # At most MOST nights, those after the current cutoff first, each group spread evenly over its span.
            spread = lambda xs, n: [xs[int(i)] for i in np.unique(np.linspace(0, len(xs) - 1, n).round())] if len(xs) > n else xs
            late = spread([best[k] for k in sorted(best) if best[k]["t_min"] > e["cutoff_mjd"] + 0.5], most)
            pick = spread([best[k] for k in sorted(best) if best[k]["t_min"] <= e["cutoff_mjd"] + 0.5], most - len(late)) + late
            spool = planets_path("spectra", e["tag"] + ".ledger")
            spectra = spectra_read(archive_eso_fetch(pick, spool, streams=4))
            shutil.rmtree(spool, ignore_errors=True)
            if len(spectra) < 3:
                return nothing
            v = binaries_velocities(spectra, binaries_line_depths(spectra, binaries_velocities(spectra, np.load(binaries_template_path()))[0]))[0] * 1000.0
            t = np.array([s[3]["mjd"] for s in spectra])
            return t, v, np.zeros(len(t))
        p = planets_path("lbl", e["tag"] + ".lbl.npz")
        if not os.path.exists(p) or float(np.load(p)["mjd"].max()) < max(x["t_min"] for x in listed) - 0.5:
            try:
                planets_lbl(e["tag"], ra=e["ra"], dec=e["dec"], least=3, listing=[x for x in listings[name] if x["snr"] > 20.0])
            except (SystemExit, Exception) as exc:
                print("%s: %s" % (e["tag"], str(exc)[:160]), flush=True)
        if not os.path.exists(p):
            return nothing
        d = np.load(p)
        m = (d["mjd"] > first + 0.5) & np.isfinite(d["rv"]) & np.isfinite(d["rv_err"]) & ~(d["cal_age"] > 30.0)
        return planets_by_night(d["mjd"][m], d["rv"][m], d["rv_err"][m]) if m.sum() else nothing

    refit, held = {}, []
    for name, e in sorted(entries.items()):
        if e["tests"] and e["tests"][-1]["prediction"] == "failed":
            continue
        t_all, y_all, err_all = newer(name, e)
        late = t_all > e["cutoff_mjd"] + 0.5
        t, y, err = t_all[late], y_all[late], err_all[late]
        test = dict(date=time.strftime("%Y-%m-%d"), cutoff_mjd=e["cutoff_mjd"], new_nights=int(len(t)), scale=None, scale_err=None, prediction="pending")
        if len(t) >= 3:
            V = planets_kepler_draws(t, e["draws"])
            O = sum((planets_kepler_draws(t, d) for d in e["others"]), np.zeros_like(V))
            # Fit the later velocities, minus the other planets' predicted curves, as an offset plus a scale times the body's predicted curve.
            s2 = err ** 2 + e["jitter"] ** 2 + V.var(0) + O.var(0)
            A = np.column_stack([np.ones_like(t), V.mean(0)]) / np.sqrt(s2)[:, None]
            c = np.linalg.lstsq(A, (y - O.mean(0)) / np.sqrt(s2), rcond=None)[0]
            s, es = float(c[1]), float(math.sqrt(max(np.linalg.pinv(A.T @ A)[1, 1], 0.0)))
            test.update(new_from=round(float(t.min()), 3), new_to=round(float(t.max()), 3), scale=round(s, 3), scale_err=round(es, 3),
                        prediction="pending" if not es <= 0.2 else "held" if abs(s - 1.0) <= max(3.0 * es, 0.3) else "failed")
            if test["prediction"] == "held" and e["found_by"] != "TESS":
                # One refit per star and kind of orbit, with the nights since the earliest discovery among the bodies that held.
                job = ("orbits" if e["found_by"] in ("census", "eccentric search") else "weigh", e["bank_name"])
                if job not in refit or len(t_all) > len(refit[job][1]):
                    refit[job] = (e, t_all, y_all, np.hypot(err_all, e["jitter"] if e["source"] == "HARPS cross-correlation" else 0.0))
                held.append((name, job))
        e["tests"].append(test)
        print("%-24s %-10s cutoff %.1f: %d newer nights, scale %s +- %s, %s" % (name, e["found_by"], e["cutoff_mjd"], test["new_nights"], test["scale"],
                                                                              test["scale_err"], test["prediction"]), flush=True)
    # Refit each star whose bodies held, with every night since their discovery. The bodies that held take the new orbits and move their cutoffs to the
    # last of those nights; the star's other bodies keep their orbits and cutoffs.
    tasks = []
    for (step, n), (e, t_all, y_all, s_all) in refit.items():
        path = planets_path("ledger", "%s.%s.newer.npz" % (e["tag"], step))
        np.savez(path, mjd=t_all, rv=y_all, rv_err=s_all)
        if step == "orbits":
            o = load(orbit_path(n))
            periods = [p["P"][0] for p in o["planets"]] if o else [float(np.median(np.asarray(d)[:, 0])) for d in [e["draws"]] + e["others"]]
            tasks.append(["orbits", n, ",".join(repr(P) for P in periods), "--extra", path])
        else:
            tasks.append(["weigh", n, "--extra", path])
    failed = {(args[0], args[1]) for args in planets_run_all(tasks, workers)}
    for name, job in held:
        if job in failed:
            continue
        e = entries[name]
        P = float(np.median(np.asarray(e["draws"])[:, 0]))
        if job[0] == "orbits":
            o = load(orbit_path(e["bank_name"]))
            D = planets_draws_load(orbit_path(e["bank_name"]), o)["draws"]
            i = min(range(len(o["planets"])), key=lambda k: abs(o["planets"][k]["P"][0] / P - 1.0))
            e.update(draws=D[i], others=[D[k] for k in range(len(D)) if k != i])
        else:
            e["draws"] = planets_draws_load(weigh_path(e["bank_name"]), load(weigh_path(e["bank_name"])))["draws"]
        e["cutoff_mjd"] = round(max(e["cutoff_mjd"], float(refit[job][1].max())), 3)
    rows = []
    for name, e in sorted(entries.items()):
        path = os.path.join(folder, archive_tag(name) + ".json")
        rec = {k: v for k, v in e.items() if k not in ("draws", "others")}
        planets_draws_save(path, rec, draws=e["draws"], others=np.reshape(np.asarray(e["others"], float), (-1,) + np.shape(e["draws"])))
        json.dump(rec, open(path, "w"), separators=(",", ":"))
        d, last = np.asarray(e["draws"]), e["tests"][-1]
        q = lambda k: [round(float(np.percentile(d[:, k], p)), 4) for p in (50, 16, 84)]
        P, K, ecc = q(0), q(4), q(2)
        rows.append(dict(planet=name, host=e["host"], kind=e["kind"], found_by=e["found_by"], bank_name=e["bank_name"], cutoff_mjd=e["cutoff_mjd"], P_d=P[0],
                         P_lo=P[1], P_hi=P[2], K_ms=K[0], K_lo=K[1], K_hi=K[2], e=ecc[0], e_lo=ecc[1], e_hi=ecc[2], new_nights=last["new_nights"],
                         new_from=last.get("new_from", ""), new_to=last.get("new_to", ""), scale=last["scale"], scale_err=last["scale_err"],
                         prediction=last["prediction"], tests=len(e["tests"])))
    planets_write(os.path.join(planets_RESULTS, "ledger.csv"), rows, planets_LEDGER_KEYS)
    count = {k: sum(1 for r in rows if r["prediction"] == k) for k in ("held", "failed", "pending")}
    print("%d bodies: %d held, %d failed, %d pending" % (len(rows), count["held"], count["failed"], count["pending"]), flush=True)


def gpu_occulted(z, k, u1, u2, nodes=24):
    """The fraction of a quadratically limb-darkened disk's light hidden by a disk of radius K at separation Z, both in the occulted disk's radius,
    elementwise: the fully covered inner disk in closed form and the partly covered annuli by Gauss-Legendre over r = r0 + (r1 - r0)(1 - cos psi) / 2,
    which takes up the square-root ends; nothing hidden where Z is negative, the occultor behind."""
    c0, c1, c2 = 1.0 - u1 - u2, u1 + 2.0 * u2, -u2
    disk = lambda R: math.pi * (c0 * R * R + c1 * (2.0 / 3.0) * (1.0 - torch.clamp(1.0 - R * R, min=0.0) ** 1.5) + c2 * (R * R - R ** 4 / 2.0))
    zz = torch.clamp(z, min=1e-9)
    inner = torch.clamp(k - zz, 0.0, 1.0)
    r0, r1 = torch.abs(zz - k), torch.clamp(zz + k, max=1.0)
    x, wq = np.polynomial.legendre.leggauss(nodes)
    psi = torch.as_tensor(0.5 * math.pi * (x + 1.0), dtype=z.dtype, device=z.device)
    wpsi = torch.as_tensor(0.5 * math.pi * wq, dtype=z.dtype, device=z.device)
    span = torch.clamp(r1 - r0, min=0.0)[..., None]
    r = r0[..., None] + span * (1.0 - torch.cos(psi)) / 2.0
    theta = torch.acos(torch.clamp((r * r + zz[..., None] ** 2 - k[..., None] ** 2) / (2.0 * r * zz[..., None]).clamp(min=1e-12), -1.0, 1.0))
    mu = torch.sqrt(torch.clamp(1.0 - r * r, min=0.0))
    annuli = ((c0[..., None] + c1[..., None] * mu + c2[..., None] * mu * mu) * 2.0 * r * theta * span / 2.0 * torch.sin(psi) * wpsi).sum(-1)
    hidden = (disk(inner) + torch.where(r0 < 1.0, annuli, torch.zeros_like(annuli))) / disk(torch.ones_like(k))
    return torch.where(z < 0.0, torch.zeros_like(hidden), torch.where(zz <= k - 1.0, torch.ones_like(hidden), hidden))


def gpu_transit(time, k, P, a, inc, ecc, w, u1, u2, exptime=0.0, nsamples=1, chunk=2048, fused=True):
    """Light curves of bodies of radius ratio K on orbits (P days, A in the occulted star's radius, INC and W in radians, ECC), each parameter (N,),
    at TIME (T,) days from mid-transit, in pytransit's conventions: mid-transit where the true anomaly is pi/2 - W, the projected separation signed by
    sin(W + true anomaly), and each time averaged over NSAMPLES instants spread evenly over EXPTIME; (N, T) on the device in single precision, each
    body and time in one thread of the compiled kernel where there is one and FUSED, else by tensor operations over CHUNK bodies at a time
    (gpu_occulted)."""
    f32 = dict(dtype=torch.float32, device=gpu_DEVICE)
    offs = (np.arange(nsamples) + 0.5) / nsamples - 0.5 if nsamples > 1 else np.zeros(1)
    ts = torch.as_tensor((np.asarray(time, float)[:, None] + exptime * offs[None, :]).ravel(), **f32)
    # the eight parameters stacked on the host and sent to the device in one copy
    k, P, a, inc, ecc, w, u1, u2 = torch.as_tensor(np.stack(np.broadcast_arrays(*(np.asarray(x, float) for x in (k, P, a, inc, ecc, w, u1, u2)))), **f32)
    if fused and gpu_DEVICE.type == "cuda" and _gpu_kernels() is not None:
        x, wq = np.polynomial.legendre.leggauss(24)
        psi = 0.5 * np.pi * (x + 1.0)
        return _gpu_kernels().transit_rows(ts.contiguous(), torch.stack([k, P, a, inc, ecc, w, u1, u2], 1).contiguous(), torch.as_tensor(np.cos(psi), **f32),
                                           torch.as_tensor(np.sin(psi) * 0.5 * np.pi * wq, **f32), len(offs), _gpu_stream())
    out = torch.empty((len(k), len(time)), **f32)
    for i in range(0, len(k), chunk):
        s = slice(i, i + chunk)
        e, ww = ecc[s, None], w[s, None]
        ea = torch.atan2(torch.sqrt(1.0 - e * e) * torch.sin(math.pi / 2.0 - ww), e + torch.cos(math.pi / 2.0 - ww))
        M = torch.remainder(ea - e * torch.sin(ea) + 2.0 * math.pi * ts[None, :] / P[s, None], 2.0 * math.pi)
        E = gpu_kepler_E(M, e, 12)
        ta = 2.0 * torch.atan2(torch.sqrt(1.0 + e) * torch.sin(E / 2.0), torch.sqrt(1.0 - e) * torch.cos(E / 2.0))
        sn = torch.sin(ww + ta)
        z = a[s, None] * (1.0 - e * e) / (1.0 + e * torch.cos(ta)) * torch.sqrt(torch.clamp(1.0 - sn * sn * torch.sin(inc[s, None]) ** 2, min=0.0))
        z = torch.where(sn > 0.0, z, -z)
        near = (z >= 0.0) & (z < 1.0 + k[s, None])
        flux = torch.ones_like(z)
        if bool(near.any()):
            kk, u1b, u2b = (x[s, None].expand_as(z)[near] for x in (k, u1, u2))
            flux[near] = 1.0 - gpu_occulted(z[near], kk, u1b, u2b)
        out[s] = flux.reshape(len(flux), len(time), -1).mean(-1)
    return out


def planets_validate_gpu():
    """TRICERATOPS's parallel likelihoods (lnL_TP_p, lnL_EB_p, lnL_EB_twin_p) replaced in its modules by the same light curves computed on the device
    (gpu_transit) in blocks of 65536 draws, with its constants, dilutions and secondary-eclipse test unchanged."""
    import triceratops.likelihoods as L
    import triceratops.marginal_likelihoods as M

    def dilute(model, cf, host, extra=None):
        Fc = torch.as_tensor(np.asarray(cf, float) / (1.0 - np.asarray(cf, float)), dtype=torch.float32, device=gpu_DEVICE)[:, None]
        Fd = 1.0 / Fc if host else Fc
        return (model + Fd) / (1.0 + Fd)

    def lnl(model, time, flux, sigma):
        f = torch.as_tensor(np.asarray(flux, float), dtype=torch.float64, device=gpu_DEVICE)
        return gpu_host(0.5 * (((f[None, :] - model.double()) ** 2).sum(1) / sigma ** 2))

    def TP(time, flux, sigma, R_p, P_orb, inc, a, R_s, u1, u2, ecc, argp, companion_fluxratio, companion_is_host=False, exptime=0.00139, nsamples=20):
        n = len(np.atleast_1d(R_p))
        k = np.asarray(R_p) * L.Rearth / (np.asarray(R_s) * L.Rsun)
        model = gpu_transit(time, k, np.broadcast_to(P_orb, (n,)), np.asarray(a) / (np.asarray(R_s) * L.Rsun), np.asarray(inc) * (L.pi / 180.0), ecc,
                            (90.0 - np.asarray(argp)) * (L.pi / 180.0), u1, u2, exptime, nsamples)
        return lnl(dilute(model, companion_fluxratio, companion_is_host), time, flux, sigma)

    def EB(time, R_EB, EB_fluxratio, P_orb, inc, a, R_s, u1, u2, ecc, argp, companion_fluxratio, companion_is_host, exptime, nsamples):
        n = len(np.atleast_1d(R_EB))
        P, a_s, i_r = np.broadcast_to(P_orb, (n,)), np.asarray(a) / (np.asarray(R_s) * L.Rsun), np.asarray(inc) * (L.pi / 180.0)
        k = np.asarray(R_EB) / np.asarray(R_s)
        k = np.where((k - 1.0) < 1e-6, k * 0.999, k)
        model = gpu_transit(time, k, P, a_s, i_r, ecc, (90.0 - np.asarray(argp)) * (L.pi / 180.0), u1, u2, exptime, nsamples)
        k2 = np.asarray(R_s) / np.asarray(R_EB)
        k2 = np.where((k2 - 1.0) < 1e-6, k2 * 0.999, k2)
        sec = gpu_transit(np.linspace(-0.05, 0.05, 25), k2, P, a_s, i_r, ecc, (90.0 - np.asarray(argp) + 180.0) * (L.pi / 180.0), u1, u2).min(1).values[:, None]
        to = lambda x: torch.as_tensor(np.asarray(x, float), dtype=torch.float32, device=gpu_DEVICE)[:, None]
        Fc, Fe = to(companion_fluxratio) / (1.0 - to(companion_fluxratio)), to(EB_fluxratio) / (1.0 - to(EB_fluxratio))
        if companion_is_host:
            model, sec = (model + Fe / Fc) / (1.0 + Fe / Fc), (sec + Fc / Fe) / (1.0 + Fc / Fe)
            Fd = 1.0 / (Fc + Fe)
        else:
            model, sec = (model + Fe) / (1.0 + Fe), (sec + 1.0 / Fe) / (1.0 + 1.0 / Fe)
            Fd = Fc / (1.0 + Fe)
        return (model + Fd) / (1.0 + Fd), gpu_host(1.0 - (sec + Fd) / (1.0 + Fd))[:, 0]

    def EB_p(time, flux, sigma, R_EB, EB_fluxratio, P_orb, inc, a, R_s, u1, u2, ecc, argp, companion_fluxratio, companion_is_host=False, exptime=0.00139,
             nsamples=20):
        model, secdepth = EB(time, R_EB, EB_fluxratio, P_orb, inc, a, R_s, u1, u2, ecc, argp, companion_fluxratio, companion_is_host, exptime, nsamples)
        return np.where(secdepth < 1.5 * sigma, lnl(model, time, flux, sigma), np.inf)

    def EB_twin_p(time, flux, sigma, R_EB, EB_fluxratio, P_orb, inc, a, R_s, u1, u2, ecc, argp, companion_fluxratio, companion_is_host=False, exptime=0.00139,
                  nsamples=20):
        return lnl(EB(time, R_EB, EB_fluxratio, P_orb, inc, a, R_s, u1, u2, ecc, argp, companion_fluxratio, companion_is_host, exptime, nsamples)[0], time, flux,
                   sigma)

    def blocks(f, step=65536):
        """F over its draws in blocks of STEP, each argument as long as the draws cut to the block."""
        def run(time, flux, sigma, *args, **kw):
            n = len(np.atleast_1d(args[0]))
            cut = lambda x, s: np.asarray(x)[s] if np.ndim(x) == 1 and len(x) == n else x
            if n <= step:
                return f(time, flux, sigma, *args, **kw)
            return np.concatenate([f(time, flux, sigma, *[cut(x, s) for x in args], **{k: cut(x, s) for k, x in kw.items()})
                                   for s in (slice(i, i + step) for i in range(0, n, step))])
        return run
    for mod in (L, M):
        mod.lnL_TP_p, mod.lnL_EB_p, mod.lnL_EB_twin_p = blocks(TP), blocks(EB_p), blocks(EB_twin_p)


planets_VALIDATE_LOCK = threading.Lock()
planets_VALIDATE_READY = []
planets_VALIDATE_GPU = []
planets_VALIDATE_BACKGROUNDS = []
# the error of a target no archive gave a field-star population for, which a later run weighs again
planets_NO_FIELD = "no field-star population from Gaia"


def planets_ld_lookup(teffs, loggs, u1s, u2s, teff, logg):
    """The limb-darkening coefficients u1 and u2 of the table's rows (TEFFS, LOGGS, U1S, U2S) at each draw's temperature TEFF and gravity LOGG, every draw
    at once; a draw the table holds no row for is an error, as in TRICERATOPS's own lookup."""
    key = lambda t, g: np.round(np.asarray(t, float)).astype(np.int64) * 1000 + np.round(np.asarray(g, float) * 100.0).astype(np.int64)
    rows, want = key(teffs, loggs), key(teff, logg)
    order = np.argsort(rows, kind="stable")
    j = order[np.clip(np.searchsorted(rows[order], want), 0, len(order) - 1)]
    if not (rows[j] == want).all():
        raise ValueError("a draw's temperature and gravity lie outside the limb-darkening table")
    return np.asarray(u1s, float)[j], np.asarray(u2s, float)[j]


def planets_ld_nearest(Zs, Teffs, loggs, u1s, u2s, teff, logg, z):
    """Every background star's limb-darkening coefficients at once, chosen exactly as TRICERATOPS's background scenarios choose them a star at a
    time."""
    def nearest(column, q):
        values, first = np.unique(column, return_index=True)
        q = np.asarray(q, float)
        hi = np.clip(np.searchsorted(values, q), 0, len(values) - 1)
        lo = np.clip(hi - 1, 0, len(values) - 1)
        dlo, dhi = np.abs(values[lo] - q), np.abs(values[hi] - q)
        pick = np.where(dlo < dhi, lo, np.where(dhi < dlo, hi, np.where(first[lo] <= first[hi], lo, hi)))
        return np.where(np.isnan(q), column[0], values[pick])
    T, g = nearest(Teffs, teff), nearest(loggs, logg)
    z = np.asarray(z, float)
    u1, u2 = np.zeros(len(T)), np.zeros(len(T))
    groups = {}
    for i, key in enumerate(zip(T.tolist(), g.tolist())):
        groups.setdefault(key, []).append(i)
    for (t_, g_), idx in groups.items():
        rows = np.where((Teffs == t_) & (loggs == g_))[0]
        if not len(rows):
            raise ValueError("attempt to get argmin of an empty sequence")
        if len(np.unique(Zs[rows])) != len(rows):
            raise ValueError("can only convert an array of size 1 to a Python scalar")
        idx = np.array(idx)
        k = rows[np.argmin(np.abs(Zs[rows][None, :] - z[idx][:, None]), axis=1)]
        u1[idx], u2[idx] = u1s[k], u2s[k]
    return u1, u2


def planets_validate_setup():
    """TRICERATOPS readied for the validation, once a process: lightkurve's download methods without their stdout-suppressing decorator, TRICERATOPS's
    printing silenced, its TESScut cutouts and pixel files refused, the stars' positions coming from the light curves' apertures (planets_validate_one), and its
    limb-darkening grids completed, every temperature and gravity of a metallicity, the table's own and the lattice it rounds companions to, given the
    coefficients of the nearest point the table holds; its bound companions' coefficients looked up for every draw at once and its stellar relations'
    splines evaluated as the piecewise polynomials they are, each giving the values it gave before."""
    import lightkurve.search as lks
    import lightkurve.utils as lku
    import triceratops.marginal_likelihoods as M
    import triceratops.triceratops as tr
    if planets_VALIDATE_READY:
        return tr
    # each lightkurve search method wrapped in suppress_stdout replaced by the function it wraps
    swap = lku.suppress_stdout(lambda: None).__code__
    for owner in [lks] + [v for v in vars(lks).values() if isinstance(v, type)]:
        for name, f in list(vars(owner).items()):
            if getattr(f, "__code__", None) is swap and hasattr(f, "__wrapped__"):
                setattr(owner, name, f.__wrapped__)
    tr.print = lambda *a, **k: None
    tr.lightkurve.search_tesscut = tr.lightkurve.search_targetpixelfile = lambda *a, **k: (_ for _ in ()).throw(RuntimeError("positions from the light curves"))
    # TRICERATOPS's TIC stars read from the kept cones, less those the TIC flags (planets_tic_real), MAST asked only for a star not yet kept
    real = tr.Catalogs

    class Cones:
        query_region = staticmethod(real.query_region)

        @staticmethod
        def query_object(name, radius=None, catalog="TIC"):
            return planets_tic_real(int(str(name).replace("TIC", "").strip()), radius, real)
    tr.Catalogs = Cones
    # TRICERATOPS's Gaia background read through archive_tap, from whichever archive answers
    class GaiaJob:
        def __init__(self, adql):
            self.rows = archive_tap("gaia", adql)

        def get_results(self):
            from astropy.table import Table
            return Table({k: np.array([planets_num(r[k]) for r in self.rows]) for k in (self.rows[0] if self.rows else ())})
    gaia = types.ModuleType("astroquery.gaia")
    gaia.Gaia = types.SimpleNamespace(launch_job=lambda adql, **kw: GaiaJob(adql), launch_job_async=lambda adql, **kw: GaiaJob(adql), ROW_LIMIT=-1)
    sys.modules["astroquery.gaia"] = gaia
    # TRICERATOPS writes each target's Gaia background population into the working directory and reads it back when it weighs the target: the file
    # is moved into the data root under a name of its own, and removed once its candidate is weighed (planets_validate). A target without one is an
    # error, since TRICERATOPS would leave out the six scenarios that need a population and put the false-positive probability too low.
    write = tr.query_gaia_background

    def background(ra, dec, ID, *args, **kw):
        name = write(ra, dec, ID, *args, **kw)
        if not name or not os.path.exists(name):
            raise IOError(planets_NO_FIELD)
        os.makedirs(planets_path("validate_backgrounds"), exist_ok=True)
        planets_VALIDATE_BACKGROUNDS.append(name)
        kept = planets_path("validate_backgrounds", "%s_%d_%d.csv" % (ID, os.getpid(), len(planets_VALIDATE_BACKGROUNDS)))
        os.replace(name, kept)
        return kept
    tr.query_gaia_background = background
    import pandas as pd
    for band, (c1, c2) in (("T", ("aLSM", "bLSM")), ("K", ("a", "b"))):
        table = getattr(M, "ldc_" + band).drop_duplicates(["Z", "Teff", "logg"])
        added = []
        for z, sub in table.groupby("Z"):
            have, tg = set(zip(sub.Teff, sub.logg)), sub[["Teff", "logg"]].to_numpy(float)
            # the lattice TRICERATOPS rounds companions to, 250 K from 3500 to 13000 K and 0.5 dex from 3.5 to 5.0, beside the table's own points
            for t in sorted(set(np.unique(sub.Teff).tolist()) | set(range(3500, 13001, 250))):
                for gg in sorted(set(np.unique(sub.logg).tolist()) | {3.5, 4.0, 4.5, 5.0}):
                    if (t, gg) not in have:
                        row = sub.iloc[int(np.argmin(((tg[:, 0] - t) / 1000.0) ** 2 + (tg[:, 1] - gg) ** 2))].copy()
                        row["Teff"], row["logg"] = t, gg
                        added.append(row)
        table = pd.concat([table, pd.DataFrame(added)], ignore_index=True) if added else table.reset_index(drop=True)
        setattr(M, "ldc_" + band, table)
        for name, col, kind in (("Zs", "Z", float), ("Teffs", "Teff", int), ("loggs", "logg", float), ("u1s", c1, float), ("u2s", c2, float)):
            setattr(M, "ldc_%s_%s" % (band, name), np.array(table[col], dtype=kind))
    # the bound companions' limb-darkening coefficients looked up for every draw at once (planets_ld_lookup) in place of TRICERATOPS's loop over the
    # draws, and its stellar relations' splines evaluated as the piecewise polynomials they are
    loop = ("    for i, (comp_Teff, comp_logg) in enumerate(\n            zip(rounded_Teffs_comp, rounded_loggs_comp)\n            ):\n"
            "        mask = (Teffs_at_Z == comp_Teff) & (loggs_at_Z == comp_logg)\n"
            "        u1s_comp[i], u2s_comp[i] = u1s_at_Z[mask].item(), u2s_at_Z[mask].item()\n")
    M.planets_ld_lookup = planets_ld_lookup
    for name in ("lnZ_STP", "lnZ_SEB"):
        source = inspect.getsource(getattr(M, name))
        if loop in source:
            # compiled at the original's line, so that a traceback through it points into TRICERATOPS's file
            exec(compile("\n" * (getattr(M, name).__code__.co_firstlineno - 1) + source.replace(loop, "    u1s_comp, u2s_comp = planets_ld_lookup(Teffs_at_Z, "
                         "loggs_at_Z, u1s_at_Z, u2s_at_Z, rounded_Teffs_comp, rounded_loggs_comp)\n"), M.__file__, "exec"), M.__dict__)
            setattr(tr, name, M.__dict__[name])
    # the background stars' coefficients chosen for every star at once (planets_ld_nearest) in place of the background scenarios' loop over the stars
    M.planets_ld_nearest = planets_ld_nearest
    for name in ("lnZ_BTP", "lnZ_BEB"):
        source = inspect.getsource(getattr(M, name))
        a = source.find("    u1s_comp, u2s_comp = np.zeros(N_comp), np.zeros(N_comp)\n")
        b = source.find("    # draw random sample of background stars\n", a)
        if 0 <= a < b and "for i in range(N_comp):" in source[a:b]:
            exec(compile("\n" * (getattr(M, name).__code__.co_firstlineno - 1) + source[:a] + "    u1s_comp, u2s_comp = planets_ld_nearest(ldc_Zs, ldc_Teffs, "
                         "ldc_loggs, ldc_u1s, ldc_u2s, Teffs_comp, loggs_comp, Zs_comp)\n" + source[b:], M.__file__, "exec"), M.__dict__)
            setattr(tr, name, M.__dict__[name])
    # every star's separation and position angle from the target in one call, where TRICERATOPS's target makes one call a star
    init = inspect.getsource(tr.target.__init__)
    a, b = init.find("        sep = [0]\n"), init.find('        stars["sep (arcsec)"] = sep')
    if 0 <= a < b and "c_target.separation(c_star)" in init[a:b]:
        import textwrap
        whole = ('        c_target = SkyCoord(stars["ra"].values[0], stars["dec"].values[0], unit="deg")\n'
                 '        c_star = SkyCoord(stars["ra"].values[1:], stars["dec"].values[1:], unit="deg")\n'
                 '        sep = [0] + list(np.round(c_target.separation(c_star).to(u.arcsec).value, 3))\n'
                 '        pa = [0] + list(np.round(c_target.position_angle(c_star).to(u.deg).value, 3))\n')
        exec(compile("\n" * (tr.target.__init__.__code__.co_firstlineno - 1) + textwrap.dedent(init[:a] + whole + init[b:]), tr.__file__, "exec"), tr.__dict__)
        tr.target.__init__ = tr.__dict__.pop("__init__")
    import triceratops.funcs as F
    from scipy.interpolate import PPoly
    for name in ("flux_spline", "flux_spline_J", "flux_spline_H", "flux_spline_K", "Rad_spline_Torres", "Teff_spline_Torres", "Rad_spline_cdwrf",
                 "Teff_spline_cdwrf"):
        if hasattr(getattr(F, name, None), "_eval_args"):
            setattr(F, name, PPoly.from_spline(getattr(F, name)._eval_args))
    planets_VALIDATE_READY.append(True)
    return tr


# MAST's public TESS data in its AWS bucket, read without a query: SPOC's light curves under tess/public/tid and TESS-SPOC's full-frame light curves under
# mast/hlsp/tess-spoc, every sector's listed in MAST's download scripts
planets_TESS_BUCKET = "https://stpubdata.s3.amazonaws.com/"
planets_TESS_LISTS = "https://archive.stsci.edu/missions/tess/download_scripts/sector/"
planets_TESS_INDEX = {}


def planets_tess_index():
    """Every SPOC two-minute and TESS-SPOC full-frame light curve's TIC star and sector, read from MAST's download scripts into ROOT/tess/ on first use:
    index.npz holding the TIC numbers, sectors and kinds (0 SPOC, 1 TESS-SPOC) sorted by TIC, and sectors.json holding each sector's SPOC file names'
    date and configuration, a star SPOC observed in it, and its first and last times (MJD) from that star's light curve's header. Returns the index's
    arrays and the sectors, kept for the life of the process."""
    if planets_TESS_INDEX:
        return planets_TESS_INDEX["tic"], planets_TESS_INDEX["sector"], planets_TESS_INDEX["kind"], planets_TESS_INDEX["sectors"]
    from astropy.io import fits
    folder = planets_path("tess")
    path, spath = os.path.join(folder, "index.npz"), os.path.join(folder, "sectors.json")
    if not (os.path.exists(path) and os.path.exists(spath)):
        os.makedirs(folder, exist_ok=True)
        listing = archive_get(planets_TESS_LISTS, timeout=300).decode("utf-8", "replace")
        numbers = sorted({int(s) for s in re.findall(r"tesscurl_sector_(\d+)_lc\.sh", listing) if int(s) < 1000})

        def spoc(s):
            text = archive_get(planets_TESS_LISTS + "tesscurl_sector_%d_lc.sh" % s, timeout=600).decode("utf-8", "replace")
            return s, re.findall(r"tess(\d+)-s\d{4}-(\d{16})-(\d{4})-s_lc\.fits", text)
        sectors, tics, secs, kinds = {}, [], [], []
        for s, names in archive_pmap(spoc, numbers, 4):
            if names:
                sectors[s] = dict(stem=[names[0][0], names[0][2]], star=int(names[0][1]))
                tics.append(np.array(sorted({int(n[1]) for n in names}), np.int64))
                secs.append(np.full(len(tics[-1]), s, np.int16)), kinds.append(np.zeros(len(tics[-1]), np.int8))
        keys, token = [], None
        while True:
            page = archive_get(planets_TESS_BUCKET + "?list-type=2&prefix=mast/hlsp/tess-spoc/download_scripts/" +
                               ("&continuation-token=" + urllib.parse.quote(token) if token else ""), timeout=300).decode("utf-8", "replace")
            keys += [k for k in re.findall(r"<Key>([^<]+)</Key>", page) if k.endswith("_dl-lc.sh")]
            token = (re.findall(r"<NextContinuationToken>([^<]+)</NextContinuationToken>", page) or [None])[0]
            if not token:
                break

        def ffi(key):
            text = archive_get(planets_TESS_BUCKET + key, timeout=900).decode("utf-8", "replace")
            return np.array(sorted({(int(t), int(s)) for t, s in re.findall(r"phot_(\d{16})-s(\d{4})_tess_v1_lc\.fits", text)}), np.int64).reshape(-1, 2)
        for got in archive_pmap(ffi, keys, 4):
            tics.append(got[:, 0]), secs.append(got[:, 1].astype(np.int16)), kinds.append(np.ones(len(got), np.int8))

        # each sector's span from the header of its star's SPOC light curve, read by a range request
        def span(s):
            raw = archive_get(planets_TESS_BUCKET + planets_tess_key(sectors[s]["star"], s, 0, sectors), byte_range=(0, 28799), timeout=120)
            h = fits.Header.fromstring(raw[:raw.find(b"END     ") + 80].decode("ascii", "replace"))
            return s, float(h["TSTART"]) + 56999.5, float(h["TSTOP"]) + 56999.5
        for s, t0, t1 in archive_pmap(span, sorted(sectors), 8):
            sectors[s].update(t0=t0, t1=t1)
        tic, sec, kind = np.concatenate(tics), np.concatenate(secs), np.concatenate(kinds)
        order = np.lexsort((kind, sec, tic))
        np.savez_compressed(path + ".tmp.npz", tic=tic[order], sector=sec[order], kind=kind[order])
        os.replace(path + ".tmp.npz", path)
        json.dump({str(s): v for s, v in sectors.items()}, open(spath, "w"), separators=(",", ":"))
    d = np.load(path)
    planets_TESS_INDEX.update(tic=d["tic"], sector=d["sector"], kind=d["kind"], sectors={int(s): v for s, v in json.load(open(spath)).items()})
    return planets_tess_index()


planets_TIC_COLUMNS = ("ID", "Tmag", "Vmag", "GAIAmag", "gaiabp", "gaiarp", "Jmag", "Hmag", "Kmag", "ebv", "ra", "dec", "mass", "rad", "Teff", "logg", "plx",
                       "disposition", "duplicate_id")


def planets_tic_cone(tic, radius=None, catalogs=None):
    """The TIC stars within RADIUS (an angle, by default TRICERATOPS's ten pixels of 21 arcsec) of the TIC star TIC as MAST's catalogue service returns
    them, nearest first, with the columns TRICERATOPS reads (planets_TIC_COLUMNS): kept in ROOT/tess/cones/<TIC>.ecsv once fetched, or <TIC>_small.ecsv for the ten pixels of Kepler's 4 arcsec, a request MAST answers
    with Too Many Requests asked again after 30, 60, 90 and 120 seconds."""
    from astropy.table import Table
    import astropy.units as u
    path = planets_path("tess", "cones", ("%d_small.ecsv" if radius is not None and radius.to(u.arcsec).value < 100.0 else "%d.ecsv") % tic)
    if os.path.exists(path):
        return Table.read(path, format="ascii.ecsv")
    if catalogs is None:
        from astroquery.mast import Catalogs as catalogs
    for attempt in range(5):
        try:
            t = catalogs.query_object("TIC%d" % tic, radius=radius if radius is not None else 210.0 * u.arcsec, catalog="TIC")
            break
        except Exception as exc:
            if "429" not in str(exc) or attempt == 4:
                raise
            time.sleep(30 * (attempt + 1))
    t = t[[c for c in planets_TIC_COLUMNS if c in t.colnames]]
    os.makedirs(os.path.dirname(path), exist_ok=True)
    tmp = archive_tmp(path)
    t.write(tmp, format="ascii.ecsv", overwrite=True)
    archive_place(tmp, path)
    return t


# the TIC's flags of an entry that holds no light of its own (Paegert et al. 2021)
planets_TIC_FLAGS = ("ARTIFACT", "DUPLICATE")


def planets_tic_real(tic, radius=None, catalogs=None):
    """The TIC stars about the star TIC (planets_tic_cone) less those the TIC itself flags as artifacts or as duplicates of others (planets_TIC_FLAGS), which share a star's light with it or hold none, the star TIC always kept, and where it is itself flagged as another's duplicate, less that other."""
    t = planets_tic_cone(tic, radius, catalogs)
    me = next((s for s in t if str(s["ID"]) == str(tic)), None)
    twin = str(me["duplicate_id"]) if me is not None and str(me["disposition"]) == "DUPLICATE" else None
    return t[[i for i, s in enumerate(t) if str(s["ID"]) == str(tic) or (str(s["disposition"]) not in planets_TIC_FLAGS and str(s["ID"]) != twin)]]


def planets_tess_key(tic, sector, kind, sectors):
    """A light curve's place in the bucket: SPOC's (KIND 0) from its sector's file-name stem, TESS-SPOC's (KIND 1) and QLP's (KIND 2) from its TIC
    number and sector alone."""
    t = "%016d" % tic
    if kind == 2:
        return "mast/hlsp/qlp/s%04d/%s/%s/%s/%s/hlsp_qlp_tess_ffi_s%04d-%s_tess_v01_llc.fits" % (sector, t[0:4], t[4:8], t[8:12], t[12:16], sector, t)
    if kind == 1:
        return "mast/hlsp/tess-spoc/s%04d/target/%s/%s/%s/%s/hlsp_tess-spoc_tess_phot_%s-s%04d_tess_v1_lc.fits" % (sector, t[0:4], t[4:8], t[8:12], t[12:16], t,
                                                                                                            sector)
    date, scid = sectors[sector]["stem"]
    return "tess/public/tid/s%04d/%s/%s/%s/%s/tess%s-s%04d-%s-%s-s_lc.fits" % (sector, t[0:4], t[4:8], t[8:12], t[12:16], date, sector, t, scid)


def planets_qlp_sectors(tic):
    """The sectors of which MAST's bucket holds a QLP light curve of the TIC star TIC (planets_tess_key, kind 2): every sector of the index asked once
    with a HEAD request, the answer kept in ROOT/tess/qlp/<tic>.json; an error, and nothing kept, where the bucket answers otherwise than with the file
    or its absence."""
    path = planets_path("tess", "qlp", "%d.json" % tic)
    if os.path.exists(path):
        return json.load(open(path))
    sectors = planets_tess_index()[3]

    def held(s):
        try:
            urllib.request.urlopen(urllib.request.Request(planets_TESS_BUCKET + planets_tess_key(tic, s, 2, sectors), method="HEAD", headers=dict(archive_UA)),
                                   timeout=60)
            return s
        except urllib.error.HTTPError as exc:
            if exc.code in (403, 404):
                return None
            raise
    got = sorted(s for s in archive_pmap(held, sorted(sectors), 8) if s)
    os.makedirs(os.path.dirname(path), exist_ok=True)
    archive_save(path, json.dumps(got).encode())
    return got


def planets_bucket_keys(prefix):
    """The keys under PREFIX in MAST's bucket on AWS."""
    return re.findall(r"<Key>([^<]+)</Key>", archive_get(planets_TESS_BUCKET + "?list-type=2&prefix=" + prefix, timeout=120).decode())


def planets_validate_target(r, sectors, cache):
    """TRICERATOPS's target for the candidate R over its quarters, campaigns or SECTORS: its stars from the TIC and its background from Gaia DR3, a Kepler or K2 candidate's within ten of that mission's pixels, the star found at its own place in the TIC."""
    tr = planets_validate_setup()
    tic = int(r["TIC ID"])
    if not r.get("mission"):
        return tr.target(ID=tic, sectors=np.array(sectors), lightkurve_cache_dir=cache)
    import astropy.units as u
    me = next(s for s in planets_tic_cone(tic, 40.0 * u.arcsec, tr.Catalogs) if str(s["ID"]) == str(tic))
    return tr.target(ID=tic, sectors=np.array(sectors), mission=r["mission"], ra=float(me["ra"]), dec=float(me["dec"]), lightkurve_cache_dir=cache)


planets_EVEREST = "https://archive.stsci.edu/hlsps/everest/v2/c%02d/%s00000/%s/hlsp_everest_k2_llc_%s-c%02d_kepler_v2.0_lc.fits"


def planets_everest_into(path):
    """The K2 light-curve file PATH, ktwo<EPIC>-c<campaign>_llc.fits, its PDCSAP_FLUX and SAP_QUALITY replaced cadence by cadence by the flux and flags of EVEREST's light curve of the star, which takes out the telescope's roll; left as it is where MAST holds none."""
    from astropy.io import fits
    m = re.search(r"ktwo(\d{4})(\d{5})-c(\d+)_llc", os.path.basename(path))
    url = planets_EVEREST % (int(m.group(3)), m.group(1), m.group(2), m.group(1) + m.group(2), int(m.group(3)))
    try:
        raw = archive_get(url, timeout=300)
    except Exception as exc:
        if "404" in str(exc):
            return
        raise
    kept = path + ".everest"
    open(kept, "wb").write(raw)
    try:
        with fits.open(kept, memmap=False) as e, fits.open(path, mode="update", memmap=False) as h:
            a, d = e["ARRAYS"].data, h["LIGHTCURVE"].data
            at = {int(c): i for i, c in enumerate(a["CADN"])}
            for j, c in enumerate(d["CADENCENO"]):
                i = at.get(int(c))
                d["PDCSAP_FLUX"][j] = a["FLUX"][i] if i is not None else np.nan
                d["SAP_QUALITY"][j] = int(a["QUALITY"][i]) & planets_KEPLER_BAD if i is not None else planets_KEPLER_BAD
            h.flush()
    finally:
        os.remove(kept)


# the campaigns K2 split in two, each half's files named apart
planets_K2_SPLIT = {9: (91, 92), 10: (101, 102), 11: (111, 112)}


def planets_kepler_fetch(r, cache, stars=False):
    """A Kepler or K2 candidate's long-cadence light curves from MAST's bucket on AWS into the folder CACHE, those of the quarters or campaigns in which a transit falls on its ephemeris, each K2 file's flux and flags replaced by EVEREST's (Luger et al. 2018) where it holds the star (planets_everest_into): their files by quarter or campaign, or None where there are none or the candidate lacks a period, depth or duration; with STARS, a pair of the files and TRICERATOPS's target (planets_validate_target)."""
    from astropy.io import fits
    P, half = planets_num(r["Period (days)"]), planets_num(r["Duration (hours)"]) / 48.0
    t0 = planets_num(r["Epoch (BJD)"]) - 2454833.0
    if not (P > 0 and half > 0 and planets_num(r["Depth (ppm)"]) > 0):
        return None
    shutil.rmtree(cache, ignore_errors=True)
    os.makedirs(cache, exist_ok=True)
    if r["mission"] == "Kepler":
        k = "%09d" % int(r["KIC"])
        keys = [x for x in planets_bucket_keys("kepler/public/lightcurves/%s/%s/" % (k[:4], k)) if x.endswith("_llc.fits")]
    else:
        e = "%09d" % int(r["EPIC"])
        keys = []
        for c in re.findall(r"\d+", r.get("k2_campaigns") or ""):
            for part in planets_K2_SPLIT.get(int(c), (int(c),)):
                keys += [x for x in planets_bucket_keys("k2/public/lightcurves/c%d/%s00000/%s000/ktwo%s-c%02d_llc" % (part, e[:4], e[4:6], e, part)) if x.endswith("_llc.fits")]

    def fetch(key):
        p = os.path.join(cache, key.rsplit("/", 1)[1])
        open(p, "wb").write(archive_get(planets_TESS_BUCKET + key, timeout=300))
        if r["mission"] == "K2":
            planets_everest_into(p)
    archive_pmap(fetch, keys, 2)
    files = {}
    for p in sorted(glob.glob(os.path.join(cache, "*_llc.fits"))):
        with fits.open(p) as h:
            n = h[0].header.get("QUARTER", h[0].header.get("CAMPAIGN"))
            t = np.asarray(h["LIGHTCURVE"].data["TIME"], float)
        t = t[np.isfinite(t)]
        if len(t) and (np.ceil((t.min() - half - t0) / P) * P + t0 <= t.max() + half):
            files[int(n)] = p
    if not stars or not files:
        return files or None
    with planets_VALIDATE_LOCK:
        return files, planets_validate_target(r, sorted(files), cache)


def planets_validate_fetch(r, cache, stars=False, most=8):
    """A TESS candidate's light curves, one a sector, from the sectors in which a transit falls on ExoFOP's ephemeris, MOST sectors at most spread evenly
    over them, fetched from MAST's bucket on AWS by the index of every light curve (planets_tess_index) into the folder CACHE: SPOC's at two minutes
    where a transit falls in one of them, else TESS-SPOC's from the full-frame images at the cadence most of their transit sectors share (the shorter on
    a tie), and SPOC's of every sector where no transit falls in either. Their files by sector, or None where there are none or the candidate lacks a
    period, depth or duration; with STARS, a pair of the files and TRICERATOPS's target for those sectors, its stars from the TIC and its background
    from Gaia DR3. Where neither SPOC's nor TESS-SPOC's light curves cover a transit, QLP's are taken from the sectors in which one falls
    (planets_qlp_sectors)."""
    from astropy.io import fits
    warnings.filterwarnings("ignore")
    if r.get("mission"):
        return planets_kepler_fetch(r, cache, stars)
    tic = int(r["TIC ID"])
    P, t0, half = planets_num(r["Period (days)"]), planets_num(r["Epoch (BJD)"]) - 2400000.5, planets_num(r["Duration (hours)"]) / 48.0
    if not (P > 0 and half > 0 and planets_num(r["Depth (ppm)"]) > 0):
        return None
    tics, secs, kinds, sectors = planets_tess_index()
    a, b = int(np.searchsorted(tics, tic)), int(np.searchsorted(tics, tic, side="right"))
    held = {k: sorted(s for s, kk in zip(secs[a:b].tolist(), kinds[a:b].tolist()) if kk == k) for k in (0, 1)}

    def transits(kind):
        ss = [s for s in held[kind] if "t0" in sectors.get(s, {})]
        lo, hi = np.array([sectors[s]["t0"] for s in ss]), np.array([sectors[s]["t1"] for s in ss])
        return [s for s, k in zip(ss, np.ceil((lo - half - t0) / P) * P + t0 <= hi + half) if k]
    spoc, ffi = transits(0), transits(1)
    if not spoc and not ffi:
        held[2] = planets_qlp_sectors(tic)
        qlp = transits(2)
    else:
        qlp = []
    if qlp:
        kind, keep = 2, qlp
    elif spoc or not ffi:
        kind, keep = 0, spoc or held[0]
    else:
        cads = [1800 if s <= 26 else 600 if s <= 55 else 200 for s in ffi]
        cad = min(set(cads), key=lambda c: (-cads.count(c), c))
        kind, keep = 1, [s for s, c in zip(ffi, cads) if c == cad]
    if not keep:
        return None
    keep = [keep[int(j)] for j in np.unique(np.linspace(0, len(keep) - 1, most).round())] if len(keep) > most else keep
    shutil.rmtree(cache, ignore_errors=True)
    os.makedirs(cache, exist_ok=True)

    def fetch(s):
        key = planets_tess_key(tic, s, kind, sectors)
        open(os.path.join(cache, key.rsplit("/", 1)[1]), "wb").write(archive_get(planets_TESS_BUCKET + key, timeout=300))
    archive_pmap(fetch, keep, 2)
    files = {}
    for p in sorted(glob.glob(os.path.join(cache, "*lc.fits"))):
        with fits.open(p) as h:
            if int(h[0].header.get("TICID", -1)) == tic:
                files.setdefault(int(h[0].header["SECTOR"]), p)
    if not stars or not files:
        return files or None
    # TRICERATOPS's targets built one at a time across the fetching threads
    with planets_VALIDATE_LOCK:
        return files, planets_validate_setup().target(ID=tic, sectors=np.array(sorted(files)), lightkurve_cache_dir=cache)


# ExoFOP's table of high-resolution imaging, a star's record with the files posted for it, and one file
planets_EXOFOP_IMAGING = "https://exofop.ipac.caltech.edu/tess/download_imaging.php?sort=id&output=csv"
planets_EXOFOP_TARGET = "https://exofop.ipac.caltech.edu/tess/target.php?id=%d&json"
planets_EXOFOP_FILE = "https://exofop.ipac.caltech.edu/tess/get_file.php?id=%s"
planets_IMAGED = []


def planets_imaged():
    """The TIC stars ExoFOP lists high-resolution imaging of, from its imaging table kept as ROOT/imaging.csv and fetched where absent."""
    if not planets_IMAGED:
        path = planets_path("imaging.csv")
        if not os.path.exists(path):
            archive_save(path, archive_get(planets_EXOFOP_IMAGING, timeout=600))
        planets_IMAGED.append({int(r["TIC ID"]) for r in planets_read(path) if r["TIC ID"].strip().isdigit()})
    return planets_IMAGED[0]


def planets_band(text):
    """TRICERATOPS's band (Vis, TESS, J, H or K) of a filter given by its wavelength or its name: below 700 nm Vis, to 1000 nm TESS, to 1450 nm J, to
    1900 nm H and beyond K, I being TESS's and Br gamma K's; None where the text gives neither."""
    m = re.search(r"(\d+(?:\.\d+)?)\s*(?:\([^)]*\)\s*)?(nm|microns?|um)\b", text or "", re.I)
    if m:
        w = float(m.group(1)) * (1.0 if m.group(2).lower() == "nm" else 1000.0)
        return "Vis" if w < 700 else "TESS" if w < 1000 else "J" if w < 1450 else "H" if w < 1900 else "K"
    m = re.match(r"\s*(br\s*-?\s*gamma|brg|ks|kp|kcont|k|h|j|i)\b", text or "", re.I)
    return {"h": "H", "j": "J", "i": "TESS"}.get(m.group(1).lower(), "K") if m else None


def planets_contrast_curve(text, name, bands):
    """A contrast curve from the TEXT of one ExoFOP imaging file called NAME, BANDS the bands its observation lists: its band from the file's own header,
    else its name, else the observation's one band; its separations (arcsec) and limits (mag) from its longest table, a run of rows of as many numbers,
    the centres and limits of annuli where the rows give annuli, rows whose own error exceeds 1 mag set aside, each limit held to the least beyond it so
    that the curve rises outward. (band, separations, limits), or None where there is no band, fewer than four rows or a row beyond 20 arcsec."""
    head = re.search(r"wavelength:\s*([\d.]+\s*nm)", text) or re.search(r"^\s*Filter\s*=\s*(\S+)", text, re.M)
    tag = re.search(r"[-_](\d{3})(?:nm)?[-_.]", name) or re.search(r"[-_](brgamma|brg|ks|kp|kcont|k|h|j)[-_.]", name, re.I)
    camera = re.search(r"\d([rb])\.(?:dat|txt|csv|tbl)$", name, re.I)
    band = planets_band(head.group(1)) if head else planets_band(tag.group(1) + (" nm" if tag.group(1).isdigit() else "")) if tag else \
        {"r": "TESS", "b": "Vis"}[camera.group(1).lower()] if camera else (next(iter(bands)) if len(bands) == 1 else None)
    tables, width = [], None
    for line in text.splitlines():
        try:
            x = [float(c) for c in re.split(r"[\s,]+", line.strip()) if c]
        except ValueError:
            x = []
        if len(x) < 2:
            width = None
            continue
        if len(x) != width:
            tables.append([])
        tables[-1].append(x)
        width = len(x)
    rows = max(tables, key=len) if tables else []
    if band is None or len(rows) < 4:
        return None
    annuli = min(len(x) for x in rows) >= 4 and all(abs(x[2] - 0.5 * (x[0] + x[1])) <= 0.01 * max(x[2], 1e-3) for x in rows)
    pairs = sorted((x[2], abs(x[3])) if annuli else (x[0], abs(x[1])) for x in rows if annuli or len(x) < 3 or x[2] <= 1.0)
    sep, lim = np.array([p[0] for p in pairs]), np.array([p[1] for p in pairs])
    if len(sep) < 4 or sep.max() > 20.0:
        return None
    return band, sep, np.minimum.accumulate(lim[::-1])[::-1]


def planets_contrast_curves(tic, folder):
    """The contrast curves of the high-resolution imaging whose files ExoFOP holds for the TIC star TIC (planets_contrast_curve), each written into
    FOLDER as TRICERATOPS reads one: (path, band, description) each. The star's ExoFOP record and each file are kept in ROOT/exofop/ and fetched where
    absent, a record ExoFOP answers empty asked again after 20, 40 and 60 seconds; a star ExoFOP lists no imaging of (planets_imaged) has none."""
    if tic not in planets_imaged():
        return []
    cache = planets_path("exofop")
    os.makedirs(cache, exist_ok=True)
    path = os.path.join(cache, "%d.json" % tic)
    for attempt in range(4):
        if os.path.exists(path) and os.path.getsize(path) > 2:
            break
        if attempt:
            time.sleep(20 * attempt)
        archive_save(path, archive_get(planets_EXOFOP_TARGET % tic, timeout=120))
    try:
        d = json.load(open(path, encoding="utf-8"))
    except ValueError:
        return []
    bands = {}
    for x in d.get("imaging") or []:
        bands.setdefault(x.get("itag"), set()).add(planets_band(x.get("ifilt")))
    os.makedirs(folder, exist_ok=True)
    out = []
    for f in d.get("files") or []:
        if f.get("ftype") != "Image" or (f.get("fext") or "").lower() not in ("dat", "txt", "csv", "tbl"):
            continue
        kept = os.path.join(cache, "%d_%s" % (tic, archive_tag(f["fname"])))
        if not os.path.exists(kept):
            b = archive_get(planets_EXOFOP_FILE % f["fid"], timeout=120, soft=True)
            if not b:
                continue
            open(kept, "wb").write(b)
        curve = planets_contrast_curve(open(kept, encoding="utf-8", errors="replace").read(), f["fname"], bands.get(f.get("ftag"), set()) - {None})
        if curve:
            band, sep, lim = curve
            cc = os.path.join(folder, "contrast%d.csv" % len(out))
            np.savetxt(cc, np.column_stack([sep, lim]), delimiter=",", fmt="%.4f")
            out.append((cc, band, dict(file=f["fname"], band=band, points=len(sep), limit_at_half_arcsec=round(float(np.interp(0.5, sep, lim)), 2))))
    return out


# the quality flags that set a Kepler or K2 cadence aside, those of the archive's default mask: attitude tweaks, safe modes, coarse pointing, Earth pointing, desaturations, manual exclusions, thruster firings
planets_KEPLER_BAD = 1130799


def planets_lightcurve_flux(d):
    """A SPOC, TESS-SPOC, QLP, Kepler or K2 light curve's table D read: the times in BTJD, Kepler's and K2's days from BJD 2454833 carried to it, and the flux of quality zero, or none of the flags planets_KEPLER_BAD for Kepler's and K2's, PDCSAP_FLUX or QLP's detrended DET_FLUX,
    in its first releases KSPSAP_FLUX, divided by its median, a Kepler or K2 cadence 8 robust standard deviations beyond both its neighbours on the same side set aside, as no transit's half-hour points are; None where fewer than 100 points remain."""
    col = next((c for c in ("DET_FLUX", "KSPSAP_FLUX") if c in d.columns.names), "PDCSAP_FLUX")
    kepler = "QUALITY" not in d.columns.names
    t, f, q = np.asarray(d["TIME"], float) - (2167.0 if kepler else 0.0), np.asarray(d[col], float), np.asarray(d["SAP_QUALITY" if kepler else "QUALITY"])
    ok = np.isfinite(t) & np.isfinite(f) & ((q.astype(int) & planets_KEPLER_BAD) == 0 if kepler else q == 0)
    if ok.sum() < 100:
        return None
    t, f = t[ok], f[ok] / np.median(f[ok])
    if kepler:
        a, b = np.diff(f, prepend=f[0]), np.diff(f, append=f[-1])
        sd = 1.4826 * float(np.median(np.abs(a - np.median(a)))) / math.sqrt(2.0)
        lone = (np.sign(a) == -np.sign(b)) & (np.abs(a) > 8.0 * sd) & (np.abs(b) > 8.0 * sd)
        t, f = t[~lone], f[~lone]
    return t, f


def planets_transit_shape(sectors, P, t0, dur):
    """Whether a signal's folded light is a transit's box or the star's own smooth variation at its period. SECTORS, each sector's times (BTJD) and
    flux divided by its median (planets_lightcurve_flux), are each divided by their running median over three periods, which leaves the light at the
    period and its harmonics, clipped at 5 sigma and folded at P days from T0, moved by up to half the duration to where a box of the duration DUR days
    is deepest; that box, two sinusoids at the period and half of it, and both together are fitted by least squares, the noise the scatter about the
    last. Returns the chi-square below a constant the box explains
    (shape_box_chi2) and the sinusoids explain (shape_sine_chi2), the box's depth over its error beside the sinusoids (shape_box_sigma), the box's
    depth in each sector, against the light between 0.75 and 2 durations of it, set against its mean, the reduced chi-square with each sector's error the scatter of the same box a third to two thirds of an
    orbit on (shape_sector_chi2), the depths' scatter over their mean (shape_sector_scatter) and the sectors' number (shape_sectors), and the fold's first
    six harmonics (shape_harmonics), each None where the fold covers no transit. A transit's box puts into the two sinusoids only the share of its variance its first two harmonics hold, and
    keeps the rest of its significance beside them (planets_box_kept); the star's own variation at the period puts as much or more into them as into
    the box and leaves the box short of that (planets_transit_smooth)."""
    none = dict(shape_box_chi2=None, shape_sine_chi2=None, shape_box_sigma=None, shape_sector_chi2=None, shape_sector_scatter=None, shape_sectors=0, shape_harmonics=None)
    T, F, S = [], [], []
    for k, (t, f) in enumerate(sectors):
        size = int(round(3.0 * P / max(float(np.median(np.diff(t))), 1e-4))) | 1
        if size < len(t):
            # the running median read on every STEP-th point, about a hundred to its window
            step = max(1, size // 101)
            f = f / np.interp(t, t[::step], gpu_host(gpu_running_median(f[None, ::step], (size // step) | 1))[0])
        T.append(t), F.append(f - 1.0), S.append(np.full(len(t), k))
    if not T:
        return none
    t, f, sec = np.concatenate(T), np.concatenate(F), np.concatenate(S)
    # clipped at 5 sigma, within a duration of a transit above alone, so that a deep transit keeps its own points
    mid = float(np.median(f))
    limit = 5.0 * 1.4826 * float(np.median(np.abs(f - mid)))
    keep = (f - mid < limit) & ((mid - f < limit) | (np.abs(((t - t0) / P + 0.5) % 1.0 - 0.5) * P < dur))
    t, f, sec = t[keep], f[keep], sec[keep]

    def deepest(shift):
        inn = np.abs((((t - t0 - shift) / P + 0.5) % 1.0 - 0.5) * P) < 0.5 * dur
        return float(np.mean(f[~inn]) - np.mean(f[inn])) if 3 <= inn.sum() < len(f) else -np.inf
    shifts = np.linspace(-0.5 * dur, 0.5 * dur, 21)
    t0 = t0 + float(shifts[int(np.argmax([deepest(s) for s in shifts]))])
    x = ((t - t0) / P + 0.5) % 1.0 - 0.5
    box = (np.abs(x) * P < 0.5 * dur).astype(float)
    if box.sum() < 3 or (1.0 - box).sum() < 10:
        return none
    sines = [g(2.0 * math.pi * k * x) for k in (1, 2) for g in (np.cos, np.sin)]
    one = np.ones_like(f)

    def fit(cols):
        A = np.column_stack(cols + [one])
        c, *_ = np.linalg.lstsq(A, f, rcond=None)
        return A, c, f - A @ c
    A, c, res = fit(sines + [box])
    sd = 1.4826 * float(np.median(np.abs(res - np.median(res))))
    if not sd > 0:
        return none
    base = float(np.sum((f - f.mean()) ** 2))
    gain = lambda cols: round((base - float(np.sum(fit(cols)[2] ** 2))) / sd ** 2, 1)
    err = sd * math.sqrt(float(np.linalg.inv(A.T @ A)[4, 4]))
    # each sector's depth against the light between 0.75 and 2 durations of it, and against the same box a third to two thirds of an orbit on, whose scatter holds the sector's own
    # correlated noise
    deps, errs, q = [], [], dur / P
    for k in np.unique(sec):
        xs, fs = x[sec == k], f[sec == k]

        def depth_at(p):
            y = np.abs((xs - p + 0.5) % 1.0 - 0.5)
            inn, ring = y < 0.5 * q, (y > 0.75 * q) & (y < 2.0 * q)
            return float(np.mean(fs[ring]) - np.mean(fs[inn])) if inn.sum() >= 3 and ring.sum() >= 3 else float("nan")
        far = np.array([depth_at(p) for p in np.linspace(0.35, 0.65, 9)])
        if math.isfinite(depth_at(0.0)) and np.isfinite(far).sum() >= 5 and np.nanstd(far) > 0:
            deps.append(depth_at(0.0)), errs.append(float(np.nanstd(far)))
    chi, scatter = None, None
    if len(deps) >= 2:
        d_, e_ = np.array(deps), np.array(errs)
        mean = float(np.sum(d_ / e_ ** 2) / np.sum(1.0 / e_ ** 2))
        chi = round(float(np.sum((d_ - mean) ** 2 / e_ ** 2)) / (len(d_) - 1), 2)
        scatter = round(float(np.std(d_)) / abs(mean), 3) if mean else None
    # the fold's first six harmonics about the moved epoch, in ppm, with their error
    harm = dict(cos=[round(2e6 * float(np.mean(f * np.cos(2.0 * math.pi * k * x))), 1) for k in range(1, 7)],
                sin=[round(2e6 * float(np.mean(f * np.sin(2.0 * math.pi * k * x))), 1) for k in range(1, 7)], err=round(1e6 * sd * math.sqrt(2.0 / len(f)), 2))
    return dict(shape_box_chi2=gain([box]), shape_sine_chi2=gain(sines), shape_box_sigma=round(-float(c[4]) / err, 2), shape_sector_chi2=chi,
                shape_sector_scatter=scatter, shape_sectors=len(deps), shape_harmonics=harm)


def planets_box_kept(q):
    """The share of a box's significance that stays beside two sinusoids at its period and half of it, for a box of duty cycle Q: the root of the
    share of its variance outside its first two harmonics."""
    q = min(max(q, 1e-6), 0.5)
    inside = sum(2.0 * math.sin(n * math.pi * q) ** 2 / (n * math.pi) ** 2 for n in (1, 2)) / (q * (1.0 - q))
    return math.sqrt(max(1.0 - inside, 0.0))


def planets_transit_smooth(v):
    """Whether a validation record V's folded light is the star's own smooth variation at the period rather than a transit or an eclipse
    (planets_transit_shape): the fold detecting the box at 7.1 sigma or more, the sinusoids at the period and half of it explaining at least as much
    as the box, and the box beside them under 3 sigma, or under three tenths of the significance a transit's box of its duration keeps there
    (planets_box_kept), and 3 sigma or more short of that. A fold too noisy to detect the box judges nothing."""
    s, b, z = v.get("shape_sine_chi2"), v.get("shape_box_chi2"), v.get("shape_box_sigma")
    if None in (s, b, z) or not v.get("period") or not v.get("duration_h"):
        return False
    kept = planets_box_kept(v["duration_h"] / 24.0 / v["period"]) * math.sqrt(max(b, 0.0))
    return b >= 7.1 ** 2 and s >= b and z < max(3.0, 0.3 * kept) and kept - z >= 3.0


def planets_transit_depths_vary(v):
    """Whether a validation record V's transit changes its depth from sector to sector (planets_transit_shape): in three sectors or more, a reduced
    chi-square of 5 or more against the sectors' own noise, with a scatter of a quarter of the mean depth or more. No decision reads it."""
    chi, scatter = v.get("shape_sector_chi2"), v.get("shape_sector_scatter")
    return (v.get("shape_sectors") or 0) >= 3 and chi is not None and scatter is not None and chi >= 5.0 and scatter >= 0.25


def planets_transit_sawtooth(v):
    """Whether a validation record V's fold repeats at half its period, its odd harmonics under a twentieth of its even (planets_transit_shape), with dips skewed
    about their deepest, the sines of its second and fourth harmonics at three tenths of their cosines or more, as a star's pulsation is and an eclipse is not."""
    h = v.get("shape_harmonics")
    if not h:
        return False
    c, s, e = h["cos"], h["sin"], h["err"]
    even, odd = math.sqrt(c[1] ** 2 + s[1] ** 2 + c[3] ** 2 + s[3] ** 2), math.sqrt(c[0] ** 2 + s[0] ** 2 + c[2] ** 2 + s[2] ** 2)
    return even >= 10.0 * e and odd <= 0.05 * even and abs(s[1]) + abs(s[3]) >= 0.3 * (abs(c[1]) + abs(c[3]))


def planets_transit_equal_dips(v):
    """Whether a validation record V's fold shows two dips half an orbit apart that the light cannot tell apart: its even harmonics detected at 5 sigma and its
    odd ones within their errors, a chi-square on the first and third harmonics' four terms under 16 (planets_transit_shape)."""
    h = v.get("shape_harmonics")
    if not h or not h["err"] > 0:
        return False
    c, s, e = h["cos"], h["sin"], h["err"]
    return math.sqrt(c[1] ** 2 + s[1] ** 2 + c[3] ** 2 + s[3] ** 2) >= 5.0 * e and (c[0] ** 2 + s[0] ** 2 + c[2] ** 2 + s[2] ** 2) / e ** 2 < 16.0


def planets_transit_half(g):
    """A blind-search signal G as the signal at half its period, its transits' epochs doubled and its signal-to-noise raised for the transits between them."""
    return dict(g, P=round(0.5 * g["P"], 6), snr=round(g["snr"] * math.sqrt(2.0), 2), red_snr=round(g["red_snr"] * math.sqrt(2.0), 2) if g.get("red_snr") else None,
                odd_even_sigma=None, secondary_sigma=None, events=[dict(e, epoch=2 * e["epoch"]) for e in g["events"]])


def planets_centroid_check(tic, P, t0, dur):
    """What a validation record keeps of where a dip's light comes from (planets_transit_centroids): the source's distance from the star (centroid_arcsec), its error
    (centroid_err) and significance (centroid_sigma), and its significance from the light-weighted centre out of transit (centroid_cen_sigma); empty where the
    light curves place no source."""
    try:
        c = planets_transit_centroids(int(tic), P, t0, dur)
    except Exception:
        return {}
    if not c or "offset_arcsec" not in c:
        return {}
    return dict(centroid_arcsec=round(math.hypot(*c["offset_arcsec"]), 2), centroid_err=c.get("offset_err_arcsec"), centroid_sigma=c.get("offset_sigma"), centroid_cen_sigma=c.get("from_centroid_sigma"))


def planets_centroid_off(v):
    """Whether a validation record V places a dip's source off the star: 5 sigma or more from the star and from the light-weighted centre out of transit
    (planets_centroid_check), as 4 per cent of confirmed planets are and 14 per cent of the candidates SPOC's data validation finds off target. Lower levels do not
    separate the two, so they are reported and decide nothing."""
    return (v.get("centroid_sigma") or 0.0) >= 5.0 and (v.get("centroid_cen_sigma") or 0.0) >= 5.0


def planets_gaia_near(ra, dec):
    """Gaia DR3's RUWE and rotation speed for the star at a position, the brightest within 3 arcsec or else the nearest within 10, each source's place taken at Gaia's epoch or at J2000, by its proper motion, whichever lies nearer, as a position may hold either, read through
    archive_tap and kept in ROOT/gaia_near/, a kept answer without a RUWE asked again: (gaia_ruwe, gaia_vbroad), each None where Gaia gives none; an IOError where no archive answers."""
    path = planets_path("gaia_near", "%.5f_%+.5f.json" % (ra, dec))
    got = planets_load_json(path)
    if got is not None and got.get("gaia_ruwe") is not None:
        return got
    q = ("SELECT ra, dec, pmra, pmdec, phot_g_mean_mag, ruwe, vbroad FROM gaiadr3.gaia_source WHERE CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', %.6f, %.6f, %.6f)) = 1" % (ra, dec, 180.0 / 3600.0))
    try:
        rows = archive_tap("gaia", q)
    except Exception as exc:
        raise IOError("no archive answered for Gaia DR3: %s" % str(exc)[:160])
    cosd = math.cos(math.radians(dec))

    def off(x):
        # the source's distance (arcsec) at Gaia's epoch of 2016.0 or at J2000, the nearer
        a, d, pa, pd = planets_num(x["ra"]), planets_num(x["dec"]), float(np.nan_to_num(planets_num(x["pmra"]))) * 16.0 / 3.6e6, float(np.nan_to_num(planets_num(x["pmdec"]))) * 16.0 / 3.6e6
        return min(math.hypot(((a - s * pa / cosd - ra + 180.0) % 360.0 - 180.0) * cosd, d - s * pd - dec) for s in (0.0, 1.0)) * 3600.0
    placed = [(off(x), x) for x in rows]
    close = [p for p in placed if p[0] < 3.0]
    best = min(close, key=lambda p: planets_num(p[1]["phot_g_mean_mag"]))[1] if close else min((p for p in placed if p[0] < 10.0), key=lambda p: p[0], default=(0.0, {}))[1]
    out = {k: (planets_num(best.get(c)) if math.isfinite(planets_num(best.get(c))) else None) for k, c in (("gaia_ruwe", "ruwe"), ("gaia_vbroad", "vbroad"))}
    os.makedirs(os.path.dirname(path), exist_ok=True)
    archive_save(path, json.dumps(out).encode())
    return out


def planets_gaia_choice(rows, ra, dec):
    """Of Gaia's sources ROWS about a position, the star a record means: the brightest within 3 arcsec or else the nearest within 10, each source's place taken at Gaia's epoch or at J2000, by its proper motion, whichever lies nearer."""
    cosd = math.cos(math.radians(dec))

    def off(x):
        a, d, pa, pd = planets_num(x["ra"]), planets_num(x["dec"]), float(np.nan_to_num(planets_num(x["pmra"]))) * 16.0 / 3.6e6, float(np.nan_to_num(planets_num(x["pmdec"]))) * 16.0 / 3.6e6
        return min(math.hypot(((a - s * pa / cosd - ra + 180.0) % 360.0 - 180.0) * cosd, d - s * pd - dec) for s in (0.0, 1.0)) * 3600.0
    placed = [(off(x), x) for x in rows]
    close = [p for p in placed if p[0] < 3.0]
    return min(close, key=lambda p: planets_num(p[1]["phot_g_mean_mag"]))[1] if close else min((p for p in placed if p[0] < 10.0), key=lambda p: p[0], default=(0.0, {}))[1]


# Gaia's epoch velocities: the goodness of fit of one velocity above which, at a p-value at or below this, a star's velocities move (Katz et al. 2023), as 2 per cent of the settled planets' and 22 per cent of the false positives' do; the epochs a scatter must hold to leave no room for a reflex; the mass of the least star that eclipses and the mass taken for a star where its record gives none (solar)
planets_RV_GOF, planets_RV_P, planets_RV_EPOCHS, planets_RV_LEAST, planets_RV_HOST = 4.0, 0.01, 10, 0.08, 1.5
# the scenarios of a star eclipsing the target, alone or with an unresolved companion's light
planets_TARGET_BINARIES = ("EB", "EBx2P", "PEB", "PEBx2P")


def planets_gaia_marks(ra, dec):
    """Gaia DR3's marks of a double star for the star at a position (planets_gaia_choice), read through archive_tap and kept in ROOT/gaia_marks/: its non-single-star flag (gaia_nss), and where its velocities were measured epoch by epoch, at G_RVS 12 or brighter, the goodness of fit of one velocity with its p-value (gaia_rv_gof, gaia_rv_p) and over planets_RV_EPOCHS epochs or more the standard deviation of those velocities from the error of their median (gaia_rv_scatter, km/s; Katz et al. 2023), each None where Gaia gives none. An IOError where no archive answers."""
    path = planets_path("gaia_marks", "%.5f_%+.5f.json" % (ra, dec))
    got = planets_load_json(path)
    if got is not None:
        return got
    q = ("SELECT ra, dec, pmra, pmdec, phot_g_mean_mag, non_single_star, radial_velocity_error, rv_nb_transits, rv_method_used, rv_renormalised_gof, rv_chisq_pvalue FROM gaiadr3.gaia_source WHERE CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', %.6f, %.6f, %.6f)) = 1" % (ra, dec, 180.0 / 3600.0))
    try:
        rows = archive_tap("gaia", q)
    except Exception as exc:
        raise IOError("no archive answered for Gaia DR3: %s" % str(exc)[:160])
    best = planets_gaia_choice(rows, ra, dec)
    read = lambda c: (lambda x: x if math.isfinite(x) else None)(planets_num(best.get(c)))
    n, e = read("rv_nb_transits"), read("radial_velocity_error")
    out = dict(gaia_nss=read("non_single_star"), gaia_rv_gof=read("rv_renormalised_gof"), gaia_rv_p=read("rv_chisq_pvalue"),
               gaia_rv_scatter=round(math.sqrt(max(e * e - 0.11 ** 2, 0.0) * 2.0 * n / math.pi), 3) if read("rv_method_used") == 1 and n and e is not None and n >= planets_RV_EPOCHS else None)
    os.makedirs(os.path.dirname(path), exist_ok=True)
    archive_save(path, json.dumps(out).encode())
    return out


def planets_rv_moving(v):
    """Whether Gaia's epoch velocities of a validation record V's star move (planets_RV_GOF, planets_RV_P)."""
    return (v.get("gaia_rv_gof") or 0.0) > planets_RV_GOF and v.get("gaia_rv_p") is not None and v["gaia_rv_p"] <= planets_RV_P


def planets_no_room(v):
    """Whether Gaia's epoch velocities of a validation record V's star leave no room for a star eclipsing it: twice their scatter, which that reflex's own variance would pass, below the semi-amplitude of the least star that eclipses at its period, edge on and circular."""
    sd, P, m = v.get("gaia_rv_scatter"), v.get("period"), v.get("star_mass") or planets_RV_HOST
    return sd is not None and bool(P) and 2.0 * sd < 0.0284329 * planets_RV_LEAST * 1047.57 * (m + planets_RV_LEAST) ** (-2.0 / 3.0) * (P / 365.25) ** (-1.0 / 3.0)


# Gaia's RUWE from which a star's astrometry is no longer a single star's (Lindegren et al. 2018), reached by 4 per cent of confirmed planets; the rotation speed
# (km/s) and the period's share of the longest rotation period that speed allows within which a planet's dip may be the star's rotation, reached by none of the
# confirmed planets with a speed
planets_RUWE_MAX, planets_SPIN_FAST, planets_SPIN_LOW, planets_SPIN_HIGH = 1.4, 50.0, 0.7, 1.3


def planets_check_cols(v, P, x):
    """The checks a validation record V holds as signals.csv columns for a signal of period P days and row X: Gaia's RUWE and rotation speed, the period's share of
    the longest rotation period that speed allows on the star's radius (spin_ratio), and where the dip's light comes from (planets_centroid_check)."""
    cols = {}
    if v.get("gaia_ruwe") is not None:
        cols["ruwe"] = v["gaia_ruwe"]
    vb, rstar = v.get("gaia_vbroad"), v.get("star_radius") or planets_num(x.get("Stellar Radius (R_Sun)"))
    if vb:
        cols["gaia_vbroad"] = vb
        if rstar and math.isfinite(rstar) and rstar > 0 and P and P > 0:
            cols["spin_ratio"] = round(P / (2.0 * math.pi * rstar * 6.957e5 / vb / 86400.0), 3)
    if v.get("centroid_arcsec") is not None:
        cols.update(centroid_arcsec=v["centroid_arcsec"], centroid_err=v.get("centroid_err"), centroid_sigma=v.get("centroid_sigma"))
    cols.update({k: v[k] for k in ("gaia_nss", "gaia_rv_scatter", "gaia_rv_gof") if v.get(k) is not None})
    return cols


# the chi-square by which a measured ephemeris must beat the listed one to replace it, five sigma, and the share of its duration a transit must move
planets_EPHEMERIS_GAIN, planets_EPHEMERIS_MOVE = 25.0, 0.25


def planets_ephemeris(sectors, P, t0, dur, span=0.002):
    """The ephemeris a transit's own light curves give. SECTORS, each sector's times (BTJD) and flux divided by its median (planets_lightcurve_flux), are
    each divided by their running median over three durations or 0.75 days, whichever is longer, clipped at 5 sigma above alone so that no transit is cut,
    and binned to a sixth of the duration DUR days. A box of that duration is tried at periods within the share SPAN of P days, spaced so that it drifts by
    a quarter of its length over the light curves, and at phases within two durations of the epoch T0. Returns the best period P and epoch t0 with the
    chi-square below a constant that the box explains (chi2), the best at P itself within half a duration of T0 as a fold on the listed ephemeris finds
    it (chi2_listed), and how far the two ephemerides lie apart within the light curves in days (moved), of the ephemerides within planets_EPHEMERIS_GAIN
    of the best, which the light curves cannot tell apart, the one nearest the listed; with the depth its box gives in ppm (depth_ppm), the transits it
    covers (transits) and the largest share of its chi-square one transit holds (share). None where the light curves show no transit's worth of points."""
    T, F = [], []
    for t, f in sectors:
        if len(t) < 10:
            continue
        size = int(round(max(0.75, 3.0 * dur) / max(float(np.median(np.diff(t))), 1e-4))) | 1
        if size < len(t):
            step = max(1, size // 101)
            f = f / np.interp(t, t[::step], gpu_host(gpu_running_median(f[None, ::step], (size // step) | 1))[0])
        T.append(t), F.append(f - 1.0)
    if not T:
        return None
    t, f = np.concatenate(T), np.concatenate(F)
    order = np.argsort(t)
    t, f = t[order], f[order]
    mid = float(np.median(f))
    keep = f - mid < 5.0 * 1.4826 * float(np.median(np.abs(f - mid)))
    t, f = t[keep], f[keep]
    if len(t) < 30:
        return None
    width = max(dur / 6.0, float(np.median(np.diff(t))))
    _, inv, n = np.unique(((t - t[0]) / width).astype(np.int64), return_inverse=True, return_counts=True)
    w = n.astype(float)
    tb, yb = np.bincount(inv, t) / w, np.bincount(inv, f) / w
    yb = yb - float(np.sum(w * yb) / np.sum(w))
    # the noise per point from the bins' median, which a transit does not move
    var = float(np.median(w * yb ** 2)) / 0.4549
    if not var > 0:
        return None
    W = float(np.sum(w))
    reach = float(np.max(np.abs(tb - t0)))
    step = max(0.25 * dur * P / max(reach, P), 2.0 * span * P / 4000.0)
    trials = P + np.arange(-int(span * P / step), int(span * P / step) + 1) * step
    nb, L = max(16, int(math.ceil(P / (0.25 * dur)))), 4

    def scan(periods, reachable):
        # the best chi-square of each period over the box's places within REACHABLE of the epoch, and the place
        Wb = np.bincount((np.arange(len(periods))[:, None] * nb + np.minimum((((tb[None, :] - t0) / periods[:, None] + 0.5) % 1.0 * nb).astype(np.int64), nb - 1)).ravel(),
                         np.tile(w, len(periods)), minlength=len(periods) * nb).reshape(len(periods), nb)
        Yb = np.bincount((np.arange(len(periods))[:, None] * nb + np.minimum((((tb[None, :] - t0) / periods[:, None] + 0.5) % 1.0 * nb).astype(np.int64), nb - 1)).ravel(),
                         np.tile(w * yb, len(periods)), minlength=len(periods) * nb).reshape(len(periods), nb)
        Wc = np.concatenate([np.zeros((len(periods), 1)), np.cumsum(np.concatenate([Wb, Wb[:, :L]], 1), 1)], 1)
        Yc = np.concatenate([np.zeros((len(periods), 1)), np.cumsum(np.concatenate([Yb, Yb[:, :L]], 1), 1)], 1)
        s = np.arange(nb)
        place = ((s + 0.5 * L) / nb - 0.5)[None, :] * periods[:, None]
        Win, Yin = Wc[:, s + L] - Wc[:, s], Yc[:, s + L] - Yc[:, s]
        with np.errstate(divide="ignore", invalid="ignore"):
            chi = np.where((Win > 0) & (Win < W) & (Yin < 0) & (np.abs(place) <= reachable), Yin ** 2 * W / (Win * (W - Win)) / var, 0.0)
        at = np.argmax(chi, 1)
        return chi[np.arange(len(periods)), at], place[np.arange(len(periods)), at]
    got = [scan(trials[c:c + 128], 2.0 * dur) for c in range(0, len(trials), 128)]
    chi, shift = np.concatenate([g[0] for g in got]), np.concatenate([g[1] for g in got])
    if not chi.max() > 0:
        return None
    away = lambda k: float(np.max(np.abs((tb - t0) / P * (trials[k] - P) + shift[k])))
    k = min(np.where(chi >= chi.max() - planets_EPHEMERIS_GAIN)[0].tolist(), key=away)
    best_P, best_shift = float(trials[k]), float(shift[k])
    listed = float(scan(np.array([P]), 0.5 * dur)[0][0])
    # the transits the box covers, one by one
    inn = np.abs(((tb - t0 - best_shift) / best_P + 0.5) % 1.0 - 0.5) * best_P < 0.5 * dur
    _, where = np.unique(np.round((tb[inn] - t0 - best_shift) / best_P).astype(np.int64), return_inverse=True)
    Wi, Si = np.bincount(where, w[inn]), np.bincount(where, (w * yb)[inn])
    each = np.where(Si < 0, Si ** 2 / Wi / var, 0.0)
    return dict(P=best_P, t0=t0 + best_shift, chi2=round(float(chi[k]), 1), chi2_listed=round(listed, 1), moved=round(away(k), 4), depth_ppm=round(-1e6 * float(Si.sum() / Wi.sum()), 1),
                transits=int(len(Wi)), share=round(float(each.max() / each.sum()), 3) if each.sum() > 0 else 1.0)


def planets_ephemeris_moves(e, dur, depth):
    """Whether a measured ephemeris E (planets_ephemeris) replaces the listed one of a transit of duration DUR days and listed depth DEPTH ppm: it beats the
    listed by planets_EPHEMERIS_GAIN in chi-square, moves the transit by planets_EPHEMERIS_MOVE of its duration and by under half a period, past which
    the light curves cannot tell the cycle, gives no one transit more than half of its chi-square, and gives a depth within a factor of two of the listed,
    which another planet's transits falling in the box do not."""
    return bool(e) and e["chi2"] - e["chi2_listed"] >= planets_EPHEMERIS_GAIN and planets_EPHEMERIS_MOVE * dur <= e["moved"] < 0.5 * e["P"] and e["share"] <= 0.5 and depth > 0 \
        and 0.5 <= e["depth_ppm"] / depth <= 2.0


def planets_ephemeris_kept(raw, r, P, t0, dur):
    """The ephemeris a candidate's light curves RAW give (planets_ephemeris) within 0.2 per cent of its period P or five times the period's listed error in its row R, 1 per cent at
    most, with the period and epoch to read it at: the measure's where it replaces the listed P and T0 (planets_ephemeris_moves), those otherwise."""
    err = next((planets_num(r[k]) for k in r if "Period" in k and "err" in k.lower()), float("nan"))
    e = planets_ephemeris(raw, P, t0, dur, min(0.01, max(0.002, 5.0 * err / P)) if err > 0 else 0.002) if raw and P > 0 and dur > 0 else None
    return (e, e["P"], e["t0"]) if planets_ephemeris_moves(e, dur, planets_num(r["Depth (ppm)"])) else (e, P, t0)


def planets_validate_one(r, draws=100000, runs=10, window=2.0, bins=150, cache=None, parallel=True, files=None, nsamples=5, target=None, fpp_max=0.015,
                         nfpp_max=0.001, invert=False):
    """One TESS, Kepler or K2 candidate, a row of planets_candidates, validated statistically with TRICERATOPS (Giacalone and Dressing 2020): the stars of the TIC
    within 10 pixels with a Gaia DR3 background population, and the target's SPOC, TESS-SPOC, QLP or long-cadence Kepler or K2 light curves (planets_validate_fetch). Each SPOC, Kepler
    or TESS-SPOC light-curve file gives its sector's optimal aperture and, through its aperture's WCS and pixel origin, every star's position on the
    detector, in place of TRICERATOPS's own TESScut cutouts; a QLP file gives its circular best aperture about the star's place, the other stars being
    placed about it by their offsets on the sky, its detrended flux taken for the PDCSAP flux. The PDCSAP flux of quality zero, each sector divided by its running median over 0.75 days with the
    transits bridged, is folded on ExoFOP's ephemeris, its epoch moved by up to half the duration to where a box of the duration is deepest, and binned
    into BINS bins within WINDOW transit durations of mid-transit, each bin's model averaged
    over NSAMPLES times across its width, or for full-frame light curves across their cadence, one time every two minutes; the transit depth is ExoFOP's,
    and the target's mass, radius, temperature and parallax are the TIC's, or ExoFOP's where the TIC gives none; the companions the contrast curves of
    the star's high-resolution imaging on ExoFOP rule out are ruled out (planets_contrast_curves). The same flux, unbinned, gives the
    depths of the odd and the even transits and the depth half an orbit on, each the mean within a quarter of the duration of its centre (within half
    the duration half an orbit on) against the mean between 0.75 and 2 durations of it, with errors from the scatter there; the flux of each sector
    divided by its median alone, folded on the moved epoch, tells a transit's box from the star's own variation at the period (planets_transit_shape).
    Returns the record: the
    false-positive and nearby-false-positive probabilities, their means over RUNS runs of DRAWS draws each (Giacalone et al. 2021), or over three where
    those three already put the means of the probability that its dip is no planet's (planets_not_planet) at FPP_MAX or of its nearby-false-positive probability at NFPP_MAX or above, with each run's; every scenario's mean probability, and each nearby star's own with its separation and position angle (near_probs); the epoch's shift; the
    odd-even and secondary depths and their significances; the shape's chi-squares and the box's significance beside the sinusoids; and the light
    curves' kind, cadence, sectors and points; a note where the light curves cover
    no transit, the target has no stellar parameters or TRICERATOPS weighs no scenario; or None where no light curve covers the candidate. INVERT reads the flux upside down about one, the road a dip of noise would take."""
    from astropy.io import fits
    from astropy.wcs import WCS
    warnings.filterwarnings("ignore")
    tic, P = int(r["TIC ID"]), planets_num(r["Period (days)"])
    head = dict(label=r["label"], toi=r["TOI"], tic=tic)
    t0, dur, depth = planets_num(r["Epoch (BJD)"]) - 2457000.0, planets_num(r["Duration (hours)"]) / 24.0, planets_num(r["Depth (ppm)"]) / 1e6
    files = files if files is not None else planets_validate_fetch(r, cache)
    if not files or not math.isfinite(t0):
        return None
    good = sorted(files)
    if target is None:
        with planets_VALIDATE_LOCK:
            target = planets_validate_target(r, good, cache)
    T, F, aps, coords, cads, raw = [], [], [], [], [], []
    for s in good:
        with fits.open(files[s]) as h:
            d, lh = h["LIGHTCURVE"].data, h["LIGHTCURVE"].header
            cads.append(float(lh.get("TIMEDEL") or 0.0))
            qlp = next((c for c in ("DET_FLUX", "KSPSAP_FLUX") if c in d.columns.names), None)
            if qlp:
                # QLP's light curve, its detrended flux DET_FLUX or in its first releases KSPSAP_FLUX: its circular best aperture (BESTAP, the small,
                # large and best radii in pixels) about the star's place on the detector, and the TIC's stars placed about it by their offsets on the
                # sky at 21 arcsec a pixel, a circular aperture being alike under the detector's turn
                x0, y0 = float(np.nanmedian(d["SAP_X"])), float(np.nanmedian(d["SAP_Y"]))
                rad = float(str(lh.get("BESTAP") or "3.0").split(":")[-1])
                gx, gy = np.meshgrid(np.arange(math.floor(x0 - rad), math.ceil(x0 + rad) + 1), np.arange(math.floor(y0 - rad), math.ceil(y0 + rad) + 1))
                inside = (gx - x0) ** 2 + (gy - y0) ** 2 <= rad ** 2
                aps.append(np.column_stack([gx[inside], gy[inside]]))
                ra_, dec_ = target.stars["ra"].values, target.stars["dec"].values
                coords.append(np.column_stack([x0 + (ra_ - ra_[0]) * math.cos(math.radians(dec_[0])) * 3600.0 / 21.0, y0 + (dec_ - dec_[0]) * 3600.0 / 21.0]))
            else:
                a = h["APERTURE"]
                rows_, cols_ = np.nonzero(np.asarray(a.data).astype(int) & 2)
                aps.append(np.column_stack([cols_ + a.header["CRVAL1P"], rows_ + a.header["CRVAL2P"]]))
                x_, y_ = WCS(a.header).all_world2pix(target.stars["ra"].values, target.stars["dec"].values, 0)
                coords.append(np.column_stack([x_ + a.header["CRVAL1P"], y_ + a.header["CRVAL2P"]]))
            got = planets_lightcurve_flux(d)
        if got is None:
            continue
        t, f = got[0], 2.0 - got[1] if invert else got[1]
        raw.append((t, f))
        intransit = np.abs(((t - t0) / P + 0.5) % 1.0 - 0.5) * P < dur
        if intransit.all():
            continue
        # the running median of the flux with the transits bridged by interpolation
        width = max(3, int(round(0.75 / max(float(np.median(np.diff(t))), 1e-4))) | 1)
        med = gpu_host(gpu_running_median(np.interp(t, t[~intransit], f[~intransit])[None, :], width))[0]
        T.append(t), F.append(f / med)
    if not T:
        return None
    t, f = np.concatenate(T), np.concatenate(F)

    def box(shift):
        y = (((t - t0 - shift) / P + 0.5) % 1.0 - 0.5) * P
        inn, ring = np.abs(y) < 0.5 * dur, (np.abs(y) > 0.75 * dur) & (np.abs(y) < 2.0 * dur)
        return float(np.mean(f[ring]) - np.mean(f[inn])) if inn.sum() >= 3 and ring.sum() >= 10 else -np.inf
    # ExoFOP's epoch moved by up to half the duration to where a box of the duration is deepest in the folded flux
    shifts = np.linspace(-0.5 * dur, 0.5 * dur, 41)
    boxes = np.array([box(s) for s in shifts])
    shift = float(shifts[int(np.argmax(boxes))]) if np.isfinite(boxes).any() else 0.0
    t0 = t0 + shift
    x = (((t - t0) / P + 0.5) % 1.0 - 0.5) * P

    def dip(offset, core, keep):
        inn, ring = keep & (np.abs(offset) < core), keep & (np.abs(offset) > 0.75 * dur) & (np.abs(offset) < 2.0 * dur)
        if inn.sum() < 3 or ring.sum() < 10:
            return float("nan"), float("nan")
        sd = 1.4826 * float(np.median(np.abs(f[ring] - np.median(f[ring]))))
        return float(np.mean(f[ring]) - np.mean(f[inn])), sd * math.sqrt(1.0 / inn.sum() + 1.0 / ring.sum())
    odd = np.round((t - t0) / P) % 2 == 1
    (d_odd, e_odd), (d_even, e_even) = dip(x, 0.25 * dur, odd), dip(x, 0.25 * dur, ~odd)
    d_sec, e_sec = dip((((t - t0) / P) % 1.0 - 0.5) * P, 0.5 * dur, np.ones(len(t), bool))
    d_all, e_all = dip(x, 0.5 * dur, np.ones(len(t), bool))
    e_oe = math.hypot(e_odd, e_even)
    fin = lambda v, digits: round(v, digits) if math.isfinite(v) else None
    checks = dict(depth_odd_ppm=fin(1e6 * d_odd, 1), depth_even_ppm=fin(1e6 * d_even, 1), depth_secondary_ppm=fin(1e6 * d_sec, 1), dip_sigma=fin(d_all / e_all, 2) if e_all > 0 else None,
                  odd_even_sigma=fin(abs(d_odd - d_even) / e_oe, 2) if e_oe > 0 else None, odd_even_z=planets_odd_even_z(t, f, P, t0, dur), secondary_sigma=fin(d_sec / e_sec, 2) if e_sec > 0 else None,
                  **planets_transit_shape(raw, P, t0, dur), **({} if r.get("mission") else planets_centroid_check(tic, P, t0, dur)))
    try:
        checks.update(planets_gaia_near(float(target.stars["ra"].values[0]), float(target.stars["dec"].values[0])))
        checks.update(planets_gaia_marks(float(target.stars["ra"].values[0]), float(target.stars["dec"].values[0])))
    except (IOError, ValueError):
        pass
    near = np.abs(x) < window * dur
    edges = np.linspace(-window * dur, window * dur, bins + 1)
    k = np.digitize(x[near], edges) - 1
    n = np.bincount(k, minlength=bins)
    tb = np.bincount(k, x[near], minlength=bins) / np.maximum(n, 1)
    fb = np.bincount(k, f[near], minlength=bins) / np.maximum(n, 1)
    ok = n > 0
    tb, fb = tb[ok], fb[ok]
    if not (np.abs(tb) < 0.5 * dur).any():
        return dict(head, note="no transit covered by the light curves")
    out_ = np.abs(tb) > 0.75 * dur
    err = float(1.4826 * np.median(np.abs(fb[out_] - np.median(fb[out_])))) if out_.sum() >= 10 else float(np.std(fb))
    target.pix_coords = coords
    target.calc_depths(tdepth=depth, all_ap_pixels=aps)
    # a target the TIC gives no mass, radius, temperature or parallax takes ExoFOP's; TRICERATOPS weighs no scenario without them
    for col, key, value in (("mass", "Stellar Mass (M_Sun)", lambda x: x), ("rad", "Stellar Radius (R_Sun)", lambda x: x),
                            ("Teff", "Stellar Eff Temp (K)", lambda x: x), ("plx", "Stellar Distance (pc)", lambda x: 1000.0 / x)):
        got = planets_num(r.get(key))
        if not math.isfinite(planets_num(target.stars[col].values[0])) and math.isfinite(got) and got > 0:
            target.stars.loc[target.stars.index[0], col] = value(got)
    # and what those two leave out Gaia DR3's FLAME mass and radius, temperature and parallax, of its brightest source within 5 arcsec
    lacking = lambda: [col for col in ("mass", "rad", "Teff", "plx") if not math.isfinite(planets_num(target.stars[col].values[0]))]
    gaia_read = False
    if lacking():
        try:
            g = archive_gaia_star(float(target.stars["ra"].values[0]), float(target.stars["dec"].values[0]), radius_arcsec=5.0) or {}
            gaia_read = True
        except Exception:
            g = {}
        for col, key in (("mass", "mass_flame"), ("rad", "radius_flame"), ("Teff", "teff_gspphot"), ("plx", "parallax")):
            got = planets_num(g.get(key))
            if col in lacking() and math.isfinite(got) and got > 0:
                target.stars.loc[target.stars.index[0], col] = got
    if lacking():
        return dict(head, note="no stellar mass, radius, temperature or parallax in the TIC, ExoFOP or Gaia", gaia_read=gaia_read)
    # each bin's model averaged across its width, or across the cadence where that is longer than two minutes, one time every two minutes
    cadence, width = max(cads), float(edges[1] - edges[0])
    exptime, ns = (width, nsamples) if cadence <= 0.0014 else (max(width, cadence), max(nsamples, min(15, int(math.ceil(cadence / 0.00139)))))
    # the probabilities the means over RUNS runs of DRAWS draws each (Giacalone et al. 2021), stopped after three where the three's sums already put the
    # means of the probability the dip is no planet's at FPP_MAX or of NFPP at NFPP_MAX or above; each scenario's probability summed over the stars it names
    fpps, nfpps, scen, near_share = [], [], {}, {}
    curves = planets_contrast_curves(tic, os.path.join(cache, "imaging")) if cache else []
    for k in range(runs):
        target.calc_probs(time=tb, flux_0=fb, flux_err_0=max(err, 1e-6), P_orb=P, N=draws, verbose=0, exptime=exptime, parallel=parallel, nsamples=ns,
                          contrast_curve_file=[c[0] for c in curves] or None, filt=[c[1] for c in curves] or "TESS")
        probs = target.probs
        if (probs["scenario"].astype(str) == "").all():
            return dict(head, note="TRICERATOPS weighed no scenario")
        fpps.append(float(target.FPP))
        nfpps.append(float(target.NFPP))
        for s_, p_ in zip(probs["scenario"].astype(str), probs["prob"]):
            scen[s_] = scen.get(s_, 0.0) + float(p_)
        # the nearby stars' scenarios, from the sixteenth on, each naming its star
        for i_, p_ in zip(probs["ID"].astype(str).values[15:], probs["prob"].values[15:]):
            near_share[i_] = near_share.get(i_, 0.0) + float(p_)
        if k == 2 and (sum(fpps) - scen.get("STP", 0.0) - scen.get("BTP", 0.0) >= runs * fpp_max or sum(nfpps) >= runs * nfpp_max):
            break
    placed = dict(zip(target.stars["ID"].astype(str), zip(target.stars["sep (arcsec)"].astype(float), target.stars["PA (E of N)"].astype(float))))
    kinds = sorted({r["mission"] if r.get("mission") else "QLP" if "hlsp_qlp" in os.path.basename(files[s]) else "TESS-SPOC" if "tess-spoc" in os.path.basename(files[s]) else "SPOC" for s in good})
    return dict(head, draws=draws, runs=len(fpps), nsamples=ns, period=P, epoch_shift_min=round(1440.0 * shift, 1), depth_ppm=depth * 1e6,
                duration_h=dur * 24.0, light_curves="+".join(kinds), cadence_s=round(cadence * 86400.0), sectors=good, points=int(near.sum()),
                bins=int(ok.sum()), flux_err=err, fpp=float(np.mean(fpps)), nfpp=float(np.mean(nfpps)), fpp_runs=[float("%.4g" % v) for v in fpps],
                nfpp_runs=[float("%.4g" % v) for v in nfpps], stars=int(len(target.stars)), contrast_curves=[c[2] for c in curves], **checks,
                scenarios={s_: p_ / len(fpps) for s_, p_ in scen.items()}, near_probs={i_: [float(placed[i_][0]), float(placed[i_][1]), p_ / len(fpps)] for i_, p_ in near_share.items() if i_ in placed and p_ / len(fpps) >= 1e-7},
                best=dict(probs.sort_values("prob", ascending=False).iloc[0][["ID", "scenario", "R_p", "inc", "b"]].astype(str)))


# ExoFOP's tables of TESS objects of interest and of community TOIs
planets_EXOFOP = {"toi": "https://exofop.ipac.caltech.edu/tess/download_toi.php?sort=toi&output=csv",
                  "ctoi": "https://exofop.ipac.caltech.edu/tess/download_ctoi.php?sort=ctoi&output=csv"}


# the NASA Exoplanet Archive's tables of Kepler's objects of interest and K2's planets and candidates: the mission, the table, the columns read and the rows; their fates as the TFOPWG's are named
planets_KEPLER = dict(koi=("Kepler", "cumulative", "kepid, kepoi_name, koi_disposition, koi_period, koi_time0bk, koi_duration, koi_depth, koi_prad, koi_model_snr, koi_srad, koi_smass, koi_steff, koi_kepmag, ra, dec", "koi_disposition IS NOT NULL"),
                      k2=("K2", "k2pandc", "epic_candname, epic_hostname, tic_id, disposition, k2_campaigns, pl_orbper, pl_tranmid, pl_trandur, pl_trandep, pl_ratror, pl_rade, st_rad, st_mass, st_teff, sy_kepmag, ra, dec", "default_flag = 1"))
planets_KEPLER_FATE = {"CONFIRMED": "CP", "FALSE POSITIVE": "FP", "REFUTED": "FP", "CANDIDATE": "PC"}


def planets_kepler_candidates(source, days=None):
    """Kepler's objects of interest (SOURCE koi) or K2's planets and candidates (k2) from the NASA Exoplanet Archive, the table kept as ROOT/<source>.csv, fetched where absent and, with DAYS, again once the copy is that old, the copy kept where the archive does not answer; each row with its columns named as ExoFOP's are, its mission, its label, KOI-<number> or EPIC-<number>, its fate as the TFOPWG's would read, and its TIC number, K2's from its table and Kepler's from the TIC's own column of KIC numbers, kept in ROOT/koi_tic.json. A K2 row's depth comes from its radius ratio where its table gives none and its duration from a central transit where its table gives none; a row with no TIC number or candidate's name is left out."""
    mission, table, columns, where = planets_KEPLER[source]
    path = planets_path(source + ".csv")
    if not os.path.exists(path) or (days is not None and time.time() - os.path.getmtime(path) > days * 86400.0):
        os.makedirs(planets_ROOT, exist_ok=True)
        try:
            got = archive_tap("exoplanets", "SELECT %s FROM %s WHERE %s" % (columns, table, where))
            if not got:
                raise IOError("the archive answered without its %s table" % table)
            planets_write(path, got, list(got[0]))
        except Exception:
            if not os.path.exists(path):
                raise
    rows, out = planets_read(path), []
    tics = {}
    if source == "koi":
        kept = planets_path("koi_tic.json")
        tics = planets_load_json(kept) or {}
        lacking = sorted({r["kepid"] for r in rows} - set(tics))
        if lacking:
            from astroquery.mast import Catalogs
            for i in range(0, len(lacking), 500):
                for x in Catalogs.query_criteria(catalog="Tic", KIC=lacking[i:i + 500]):
                    tics[str(x["KIC"]).strip()] = str(x["ID"])
            tics.update({k: tics.get(k, "") for k in lacking})
            archive_save(kept, json.dumps(tics).encode())
    for r in rows:
        if source == "koi":
            number, tic = r["kepoi_name"].lstrip("K").lstrip("0"), tics.get(r["kepid"], "")
            row = {"label": "KOI-" + number, "TOI": number, "KIC": r["kepid"], "Period (days)": r["koi_period"], "Epoch (BJD)": repr(planets_num(r["koi_time0bk"]) + 2454833.0), "Duration (hours)": r["koi_duration"], "Depth (ppm)": r["koi_depth"],
                   "Planet Radius (R_Earth)": r["koi_prad"], "Planet SNR": r["koi_model_snr"], "Stellar Radius (R_Sun)": r["koi_srad"], "Stellar Mass (M_Sun)": r["koi_smass"], "Stellar Eff Temp (K)": r["koi_steff"], "TESS Mag": r["koi_kepmag"], "TFOPWG Disposition": planets_KEPLER_FATE.get(r["koi_disposition"], "")}
        else:
            number, tic = r["epic_candname"].replace("EPIC", "").strip(), "".join(c for c in r["tic_id"] if c.isdigit())
            P, Rs, Ms = (planets_num(r[k]) for k in ("pl_orbper", "st_rad", "st_mass"))
            ratio = planets_num(r["pl_ratror"])
            ratio = ratio if ratio > 0 else planets_num(r["pl_rade"]) / (109.12 * Rs) if Rs > 0 else float("nan")
            d = planets_num(r["pl_trandep"]) * 1e4
            central = 24.0 * P / math.pi * math.asin(min(1.0, Rs / (215.032 * ((Ms if Ms > 0 else 1.0) * (P / 365.25) ** 2) ** (1.0 / 3.0)))) if P > 0 and Rs > 0 else float("nan")
            hours = planets_num(r["pl_trandur"])
            row = {"label": "EPIC-" + number, "TOI": number, "EPIC": "".join(c for c in r["epic_hostname"] if c.isdigit()), "k2_campaigns": r["k2_campaigns"], "Period (days)": r["pl_orbper"], "Epoch (BJD)": r["pl_tranmid"], "Duration (hours)": repr(hours if hours > 0 else central),
                   "Depth (ppm)": repr(d if d > 0 else 1e6 * ratio * ratio), "Planet Radius (R_Earth)": r["pl_rade"], "Planet SNR": "", "Stellar Radius (R_Sun)": r["st_rad"], "Stellar Mass (M_Sun)": r["st_mass"], "Stellar Eff Temp (K)": r["st_teff"], "TESS Mag": r["sy_kepmag"], "TFOPWG Disposition": planets_KEPLER_FATE.get(r["disposition"], "")}
        if number and tic:
            row.update({"TIC ID": tic, "RA": r["ra"], "Dec": r["dec"], "mission": mission})
            out.append(row)
    return out


def planets_candidates(source="toi", days=None):
    """ExoFOP's TESS objects of interest (SOURCE toi) or its community TOIs (ctoi), the table kept as ROOT/<source>.csv, fetched where absent and, with
    DAYS, again once the copy is that old, the copy kept where ExoFOP does not answer; each row with its label, TOI-<number> or CTOI-<number>. A community
    TOI's columns are named as the TOI table names them, its number taken as the TOI's, its star's mass taken from the star's surface gravity and radius,
    and its duration read in days where in hours it is under a tenth of the central transit's that its period and star give. SOURCE koi or k2 takes Kepler's or K2's (planets_kepler_candidates)."""
    if source in planets_KEPLER:
        return planets_kepler_candidates(source, days)
    path = planets_path(source + ".csv")
    if not os.path.exists(path) or (days is not None and time.time() - os.path.getmtime(path) > days * 86400.0):
        os.makedirs(planets_ROOT, exist_ok=True)
        try:
            b = archive_get(planets_EXOFOP[source], timeout=300)
            if b"TIC ID" not in b[:4000]:
                raise IOError("ExoFOP answered without its %s table" % source)
            archive_save(path, b)
        except Exception:
            if not os.path.exists(path):
                raise
    rows = planets_read(path)
    for r in rows:
        if source == "toi":
            r["label"] = "TOI-" + r["TOI"]
            continue
        P, D, g, R = (planets_num(r[k]) for k in ("Period (days)", "Duration (hrs)", "Stellar log(g) (cm/s^2)", "Stellar Radius (R_Sun)"))
        M = 10.0 ** (g - 4.438) * R * R if g > 0 and R > 0 else float("nan")
        central = 24.0 * P / math.pi * math.asin(min(1.0, R / (215.032 * (M * (P / 365.25) ** 2) ** (1.0 / 3.0)))) if M > 0 and P > 0 else float("nan")
        r.update({"label": "CTOI-" + r["CTOI"], "TOI": r["CTOI"], "Epoch (BJD)": r["Transit Epoch (BJD)"], "Depth (ppm)": r["Depth ppm"],
                  "Duration (hours)": repr(24.0 * D) if D < 0.1 * central else r["Duration (hrs)"], "Stellar Mass (M_Sun)": repr(M) if M > 0 else ""})
    return rows


def planets_exofop(days=None):
    """ExoFOP's TOIs and then its community TOIs, Kepler's objects of interest and K2's candidates (planets_candidates), DAYS as there."""
    return [x for source in ("toi", "ctoi", "koi", "k2") for x in planets_candidates(source, days)]


def planets_validate_shares(n, args, folder=None):
    """planets_validate's candidates weighed in N shares at once, each `orbitlight.py planets validate --part K/N` with the options ARGS in a process of
    its own at below-normal priority, logged to ROOT/validate_logs/<K>.log and started again where it stops before its share is done, thirty times at
    most; the records, those that pass on ten runs and the candidates left printed every ten minutes."""
    folder = folder or os.path.join(planets_RESULTS, "validate")
    logs = planets_path(os.path.basename(folder) + "_logs")
    os.makedirs(logs, exist_ok=True)
    tail = lambda k: open(os.path.join(logs, "%d.log" % k), encoding="utf-8", errors="replace").read().splitlines() \
        if os.path.exists(os.path.join(logs, "%d.log" % k)) else []

    def share(k):
        for _ in range(30):
            with open(os.path.join(logs, "%d.log" % k), "a", encoding="utf-8") as fh:
                subprocess.run([sys.executable, "-u", os.path.abspath(__file__), "planets", "validate", "--part", "%d/%d" % (k, n)] + args, stdout=fh,
                               stderr=subprocess.STDOUT, creationflags=getattr(subprocess, "BELOW_NORMAL_PRIORITY_CLASS", 0))
            if any("share done" in x for x in tail(k)[-3:]):
                return
    with cf.ThreadPoolExecutor(n) as ex:
        pending = [ex.submit(share, k) for k in range(n)]
        while True:
            waiting = cf.wait(pending, timeout=600).not_done
            recs = []
            for p in glob.glob(os.path.join(folder, "*.json")):
                try:
                    recs.append(json.load(open(p)))
                except ValueError:
                    continue
            left = 0
            for k in range(n):
                lines = tail(k)
                m = next((re.match(r"\s*(\d+)/(\d+) ", x) for x in reversed(lines) if re.match(r"\s*\d+/\d+ ", x)), None)
                left += 0 if not m or any("share done" in x for x in lines[-3:]) else int(m.group(2)) - int(m.group(1))
            print("%s %d records, %d passing on ten runs, %d candidates left in %d shares" % (
                time.strftime("%H:%M"), len(recs), sum(1 for v in recs if v.get("runs", 0) >= 10 and v.get("fpp", 1.0) < 0.015 and v.get("nfpp", 1.0) < 0.001),
                left, len(waiting)), flush=True)
            if not waiting:
                break


def planets_validate_record(prior, rec, redo=False):
    """The record kept after weighing REC over PRIOR: REC where PRIOR has no result, REDO is asked, REC adds contrast curves or a revised period;
    PRIOR otherwise, so that a draw on the same evidence never replaces one."""
    if "fpp" not in prior or redo or ("fpp" in rec and rec.get("contrast_curves") and not prior.get("contrast_curves")) or \
            ("fpp" in rec and prior.get("period") and abs(rec["period"] / prior["period"] - 1.0) > 0.01):
        return rec
    if "fpp" in rec and "contrast_curves" not in prior:
        return dict(prior, contrast_curves=[])
    return prior


def planets_validation_settled(n, folder, again=False, source="toi"):
    """The benchmark's labels in FOLDER/labels.csv: N confirmed or known planets and N false positives or alarms of the TFOPWG or of SOURCE's table, drawn once at random
    and read back after; with AGAIN, none of those the first benchmark drew, a sample its limits were not chosen on."""
    path = os.path.join(folder, "labels.csv")
    if not os.path.exists(path):
        rows = planets_candidates(source)
        usable = [r for r in rows if all(planets_num(r[k]) > 0 for k in ("Period (days)", "Duration (hours)", "Depth (ppm)")) and (source == "k2" or planets_num(r["Planet SNR"]) >= 7.1)]
        first = {x["label"] for x in planets_read(os.path.join(planets_RESULTS, "validate_benchmark", "labels.csv"))} if again else set()
        rng, drawn = random.Random(31 if again else 29), []
        for fates in (("CP", "KP"), ("FP", "FA")):
            pool = sorted(r["TOI"] for r in usable if r["TFOPWG Disposition"] in fates and "TOI-" + r["TOI"] not in first)
            drawn += rng.sample(pool, min(n, len(pool)))
        fate = {r["TOI"]: r for r in rows}
        os.makedirs(folder, exist_ok=True)
        tmp = archive_tmp(path)
        planets_write(tmp, [dict(label=fate[t].get("label", "TOI-" + t), disposition=fate[t]["TFOPWG Disposition"]) for t in drawn], ["label", "disposition"])
        archive_place(tmp, path)
    return [r["label"] for r in planets_read(path)]


def planets_validation_benchmark(again=False, source="toi"):
    """The benchmark, with AGAIN the second one, or that of SOURCE's table, scored to RESULTS/validation_benchmark.json, validation_benchmark_again.json or validation_benchmark_<source>.json: the shares of settled planets and of false positives the validation passes and of those it finds likely, with
    their errors and why the rest were turned down."""
    folder = os.path.join(planets_RESULTS, "validate_benchmark_" + source if source in planets_KEPLER else "validate_benchmark_again" if again else "validate_benchmark")
    fate = {r["label"]: r["disposition"] for r in planets_read(os.path.join(folder, "labels.csv"))}
    exo = {x["label"]: x for x in planets_candidates(source)}
    recs = {}
    for p in glob.glob(os.path.join(folder, "*.json")):
        v = json.load(open(p))
        recs[v.get("label") or "TOI-" + v["toi"]] = v
    events = planets_tce({v["tic"] for v in recs.values() if "fpp" in v})
    out = {}
    for group, fates in (("planets", ("CP", "KP")), ("false_positives", ("FP", "FA"))):
        labels = [label for label, d in fate.items() if d in fates]
        weighed, validated, likely, why = 0, 0, 0, {}
        for label in labels:
            v = recs.get(label)
            status, reason, _ = planets_validation_decision(v, exo.get(label, {}), None, events) if v else (None, "not yet weighed", {})
            if status in ("new", "likely") and planets_fold_fault(v, label):
                status, reason = "rejected", planets_fold_fault(v, label)
            if v and "fpp" in v and status is not None:
                weighed += 1
                validated += status == "new"
                likely += status == "likely"
            if status not in ("new", "likely"):
                key = reason or "waiting for its runs"
                why[key] = why.get(key, 0) + 1
        share = validated / weighed if weighed else float("nan")
        out[group] = dict(drawn=len(labels), weighed=weighed, validated=validated, share=round(share, 4),
                          error=round(math.sqrt(share * (1.0 - share) / weighed), 4) if weighed else None, likely=likely, turned_down=why)
    json.dump(out, open(os.path.join(planets_RESULTS, "validation_benchmark_%s.json" % source if source in planets_KEPLER else "validation_benchmark_again.json" if again else "validation_benchmark.json"), "w"), separators=(",", ":"))
    for group, d in out.items():
        print("%-16s %3d drawn, %3d weighed, %3d validated: %.3f +- %s, %d more likely; turned down: %s" % (group, d["drawn"], d["weighed"], d["validated"], d["share"], d["error"], d["likely"],
                                                                                                          d["turned_down"]), flush=True)
    return out


def planets_validate_refine(part=None, draws=100000, runs=10):
    """The TESS candidates whose validation under RESULTS/validate holds probabilities that do not pass or reads the star's own variation, weighed again
    where their own light curves move them off ExoFOP's ephemeris, since a fold on a period that has drifted smears a transit. Passed over are those the
    TFOPWG has settled or whose radius rules them out, as no weighing changes their decision. Each one's light curves are fetched as its validation
    fetched them (planets_validate_fetch) and its ephemeris measured (planets_ephemeris) within 0.2 per cent of its period or five times the period's
    listed error, 1 per cent at most, the measure kept in RESULTS/validate_ephemeris/<label>.json with the probabilities the candidate held. Where the
    measure replaces the listed ephemeris (planets_ephemeris_moves), the candidate is weighed at it (planets_validate_one), the new record taking the old
    one's place where it holds probabilities, with the listed ephemeris beside it
    and, where it passes, the variable stars near it (planets_variable_neighbours). The candidates nearest to passing come first; PART takes the share K/N;
    the weighing ends between candidates where a long search would end between stars (planets_search_ends), and exits with status 3 so that it is started
    again."""
    from astropy.io import fits
    import socket
    warnings.filterwarnings("ignore")
    socket.setdefaulttimeout(300)
    folder, kept = os.path.join(planets_RESULTS, "validate"), os.path.join(planets_RESULTS, "validate_ephemeris")
    os.makedirs(kept, exist_ok=True)
    exo = {x["label"]: x for x in planets_exofop()}
    todo = []
    for path in glob.glob(os.path.join(folder, "*.json")):
        v = planets_load_json(path)
        if not v or "fpp" not in v or os.path.exists(os.path.join(kept, os.path.basename(path))):
            continue
        r = exo.get(v.get("label") or "TOI-" + str(v.get("toi")))
        if not r or r.get("TFOPWG Disposition") in ("KP", "CP", "FP", "FA") or planets_num(r.get("Planet Radius (R_Earth)")) >= 22.4:
            continue
        if not (planets_not_planet(v) < planets_FPP_VALID and v["nfpp"] < planets_NFPP_VALID) or planets_transit_smooth(v):
            todo.append((planets_not_planet(v) + max(v["nfpp"], 0.0), path, r))
    todo.sort(key=lambda x: (x[0], x[1]))
    if part:
        k, n = (int(x) for x in part.split("/"))
        todo = todo[k::n]
    print("%d candidates in this share" % len(todo), flush=True)
    if not todo:
        return
    planets_validate_setup()
    if gpu_DEVICE.type == "cuda" and not planets_VALIDATE_GPU:
        planets_validate_gpu()
        planets_VALIDATE_GPU.append(True)
    moved_n = 0
    for i, (_, path, r) in enumerate(todo):
        if planets_search_ends():
            sys.exit(3)
        v = planets_load_json(path)
        P, t0, dur = planets_num(r["Period (days)"]), planets_num(r["Epoch (BJD)"]) - 2457000.0, planets_num(r["Duration (hours)"]) / 24.0
        cache = planets_path("validate_cache", archive_tag(r["label"]) + "_ephemeris")
        try:
            files = planets_validate_fetch(r, cache) or {}
            raw = []
            for s in sorted(files):
                with fits.open(files[s]) as h:
                    got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
                if got is not None:
                    raw.append(got)
            e, read_P, read_t0 = planets_ephemeris_kept(raw, r, P, t0, dur)
            line = dict(e or {}, P_listed=P, t0_listed=t0, fpp_before=v["fpp"], nfpp_before=v["nfpp"], period_before=v.get("period"))
            if (read_P, read_t0) != (P, t0):
                moved_n += 1
                r2 = dict(r, **{"Period (days)": repr(e["P"]), "Epoch (BJD)": repr(e["t0"] + 2457000.0)})
                start = time.time()
                rec = planets_validate_one(r2, draws, runs, cache=cache, files=files)
                if rec and "fpp" in rec:
                    if planets_not_planet(rec) < planets_FPP_VALID and rec["nfpp"] < planets_NFPP_VALID:
                        rec["variable_neighbours"] = planets_variable_neighbours(*planets_radec(r), e["P"])
                    rec.update(seconds=round(time.time() - start), likelihoods="gpu" if gpu_DEVICE.type == "cuda" else "pytransit",
                               ephemeris_listed=dict(P=P, t0=t0, chi2=e["chi2_listed"]), ephemeris_chi2=e["chi2"])
                    archive_save(path, json.dumps(rec, separators=(",", ":")).encode())
                    line.update(fpp=rec["fpp"], nfpp=rec["nfpp"])
                else:
                    line.update(note=(rec or {}).get("note", "not weighed"))
            archive_save(os.path.join(kept, os.path.basename(path)), json.dumps(line, separators=(",", ":")).encode())
            print("%4d/%d %-18s %s%s" % (i + 1, len(todo), r["label"], "P %.6f to %.6f, chi2 %s from %s, moved %.2f h" % (P, e["P"], e["chi2"], e["chi2_listed"], e["moved"] * 24.0) if e else "no measure",
                                         ": FPP %.4f NFPP %.5f, was %.4f %.5f" % (line["fpp"], line["nfpp"], v["fpp"], v["nfpp"]) if "fpp" in line else ""), flush=True)
        except IOError as exc:
            # a catalogue or an archive that did not answer: the candidate comes round again at the next start
            print("%s: %s: %s" % (r["label"], type(exc).__name__, str(exc)[:200]), flush=True)
        except Exception as exc:
            print("%s: %s: %s" % (r["label"], type(exc).__name__, str(exc)[:200]), flush=True)
            archive_save(os.path.join(kept, os.path.basename(path)), json.dumps(dict(note=str(exc)[:200]), separators=(",", ":")).encode())
        finally:
            shutil.rmtree(cache, ignore_errors=True)
            for p in glob.glob(planets_path("validate_backgrounds", "%s_%d_*.csv" % (r["TIC ID"], os.getpid()))):
                os.remove(p)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("share done: %d moved of %d" % (moved_n, len(todo)), flush=True)


def planets_validate_checks(part=None, draws=100000, runs=10):
    """The checks read after a validation was weighed added to each record under RESULTS/validate and RESULTS/validate_transits whose probabilities pass as a
    planet's or a binary's: the folded light's shape with its harmonics (planets_transit_shape), where its light comes from (planets_centroid_check) and Gaia's
    RUWE and rotation speed (planets_gaia_near), its light curves fetched as its validation fetched them, at the ephemeris it was weighed at or the one they give
    where that replaces it, since a transit that has drifted reads as depths that change (planets_ephemeris_kept). A search signal under
    twice the search's shortest period whose two dips are equal (planets_transit_equal_dips) is also weighed at half its period, unless the star leaves its orbit no
    room, to <star>_<k>_half.json. A TESS candidate's record also takes the variable stars near it (planets_variable_neighbours). A record keeps a digest of the code
    that measured it, so that a check changed or added reaches every record by itself. PART takes the share K/N; the pass ends between records where a long search
    would end between stars, with exit status 3."""
    from astropy.io import fits
    import socket
    warnings.filterwarnings("ignore")
    socket.setdefaulttimeout(300)
    exo = {x["label"]: x for x in planets_exofop()}
    version = planets_rules_hash(("planets_validate_checks", "planets_transit_shape", "planets_centroid_check", "planets_transit_centroids", "planets_gaia_near", "planets_variable_neighbours",
                                  "planets_ephemeris", "planets_ephemeris_moves", "planets_ephemeris_kept"))
    todo = []
    for folder in ("validate", "validate_transits"):
        for path in glob.glob(os.path.join(planets_RESULTS, folder, "*.json")):
            if path.endswith("_half.json"):
                continue
            v = planets_load_json(path)
            if not v or "fpp" not in v or v.get("checks_read") == version:
                continue
            fpp, nfpp = planets_source_cleared(v)
            off = nfpp + sum(v.get("scenarios", {}).get(s, 0.0) for s in ("BTP", "BEB", "BEBx2P"))
            if (fpp < planets_FPP_LIKELY and nfpp < planets_NFPP_LIKELY) or (folder == "validate_transits" and off < 0.001):
                todo.append((folder, path))
    todo.sort()
    if part:
        k, n = (int(x) for x in part.split("/"))
        todo = todo[k::n]
    print("%d records in this share" % len(todo), flush=True)
    for i, (folder, path) in enumerate(todo):
        if planets_search_ends():
            sys.exit(3)
        v = planets_load_json(path)
        cache = planets_path("validate_cache", os.path.basename(path)[:-5] + "_checks")
        g = None
        try:
            if folder == "validate":
                r = exo.get(v.get("label") or "TOI-" + str(v.get("toi")))
                if not r:
                    continue
                P = v.get("period") or planets_num(r["Period (days)"])
                t0 = planets_num(r["Epoch (BJD)"]) - 2457000.0 + (v.get("epoch_shift_min") or 0.0) / 1440.0
                if v.get("ephemeris_listed"):
                    e = planets_load_json(os.path.join(planets_RESULTS, "validate_ephemeris", os.path.basename(path))) or {}
                    t0 = e.get("t0", t0)
                dur = planets_num(r["Duration (hours)"]) / 24.0
            else:
                m = re.fullmatch(r"(.+)_(\d+)\.json", os.path.basename(path))
                found = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", m.group(1) + ".json"))
                if not found or int(m.group(2)) > len(found["signals"]):
                    continue
                g = found["signals"][int(m.group(2)) - 1]
                P = v.get("period") or g["P"]
                s = planets_binary_signal(g, True) if abs(P / g["P"] - 2.0) < 0.01 else g
                t0, dur = s["t0_btjd"], s["duration_h"] / 24.0
                r = planets_transit_candidate(found["name"], int(m.group(2)), dict(s, P=P), v.get("tic"), v.get("star_radius"), v.get("star_mass"), v.get("star_teff"))
            files = planets_validate_fetch(r, cache) or {}
            raw = []
            for s_ in sorted(files):
                with fits.open(files[s_]) as h:
                    got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
                    if "ra" not in v and h[0].header.get("RA_OBJ") is not None:
                        ra, dec = h[0].header["RA_OBJ"], h[0].header["DEC_OBJ"]
                if got is not None:
                    raw.append(got)
            if not raw:
                continue
            _, read_P, read_t0 = planets_ephemeris_kept(raw, r, P, t0, dur)
            v.update(planets_transit_shape(raw, read_P, read_t0, dur), **planets_centroid_check(r["TIC ID"], read_P, read_t0, dur))
            v.update(planets_gaia_near(ra, dec))
            if folder == "validate":
                v["variable_neighbours"] = planets_variable_neighbours(*planets_radec(r), P)
            v["checks_read"] = version
            archive_save(path, json.dumps(v, separators=(",", ":")).encode())
            line = "%s: RUWE %s, %s km/s, source %s +- %s arcsec" % (os.path.basename(path)[:-5], v.get("gaia_ruwe"), v.get("gaia_vbroad"), v.get("centroid_arcsec"), v.get("centroid_err"))
            half_path = path[:-5] + "_half.json"
            if g and g["P"] < 2.0 * found["pmin"] and abs(P / g["P"] - 1.0) < 0.01 and planets_transit_equal_dips(v) and not os.path.exists(half_path):
                half = planets_transit_half(g)
                why = planets_transit_physical(half, v.get("star_radius"), v.get("star_mass"))
                if why:
                    rec = dict(note=why)
                else:
                    planets_validate_setup()
                    if gpu_DEVICE.type == "cuda" and not planets_VALIDATE_GPU:
                        planets_validate_gpu()
                        planets_VALIDATE_GPU.append(True)
                    rh = planets_transit_candidate(found["name"], int(m.group(2)), half, v.get("tic"), v.get("star_radius"), v.get("star_mass"), v.get("star_teff"))
                    rec = planets_validate_one(rh, draws, runs, cache=cache + "_half") or dict(note="no light curve or aperture")
                    shutil.rmtree(cache + "_half", ignore_errors=True)
                rec.update(tic=v.get("tic"), star_radius=v.get("star_radius"), star_mass=v.get("star_mass"), star_teff=v.get("star_teff"))
                archive_save(half_path, json.dumps(rec, separators=(",", ":")).encode())
                line += "; at half the period %s" % ("FPP %.4f NFPP %.5f" % (rec["fpp"], rec["nfpp"]) if "fpp" in rec else rec.get("note"))
            print("%4d/%d %s" % (i + 1, len(todo), line), flush=True)
        except IOError as exc:
            # a catalogue or an archive that did not answer: the record comes round again at the next start
            print("%s: %s: %s" % (os.path.basename(path), type(exc).__name__, str(exc)[:200]), flush=True)
        except Exception as exc:
            print("%s: %s: %s" % (os.path.basename(path), type(exc).__name__, str(exc)[:200]), flush=True)
            v["checks_read"] = version
            archive_save(path, json.dumps(v, separators=(",", ":")).encode())
        finally:
            shutil.rmtree(cache, ignore_errors=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("share done", flush=True)


def planets_validate_multi(part=None, draws=100000, runs=10):
    """The records under RESULTS/validate and RESULTS/validate_transits, and the settled TOIs of the benchmarks, that hold fewer than RUNS runs though they pass, or would below planets_MULTI_RADIUS with another live candidate or planet on their stars (planets_has_sibling), as a record first weighed above the limit may, weighed again on all of them, its checks kept, those that pass outright first; and what such a star is worth measured again (planets_multi_measure). PART takes the share K/N; the pass ends between records where a long search would end between stars, with exit status 3."""
    from astropy.io import fits
    import socket
    warnings.filterwarnings("ignore")
    socket.setdefaulttimeout(300)
    planets_multi_measure()
    exo = {x["label"]: x for x in planets_exofop()}
    todo = []
    for folder in ("validate", "validate_transits", "validate_benchmark", "validate_benchmark_again", "validate_benchmark_koi", "validate_benchmark_k2"):
        for path in glob.glob(os.path.join(planets_RESULTS, folder, "*.json")):
            if path.endswith("_half.json"):
                continue
            v = planets_load_json(path)
            if not v or "fpp" not in v or v.get("runs", 0) >= runs or planets_not_planet(v) >= planets_MULTI_BOOST * planets_FPP_VALID or v["nfpp"] >= planets_NFPP_VALID:
                continue
            # a record whose fold has been read and does not show its dip gains nothing from more runs
            if folder == "validate" and "dip_sigma" in v and planets_fold_fault(v, v.get("label") or "TOI-" + str(v.get("toi"))):
                continue
            todo.append((planets_not_planet(v) >= planets_FPP_VALID, folder, path))
    todo.sort()
    if part:
        k, n = (int(x) for x in part.split("/"))
        todo = todo[k::n]
    ready = False
    for above, folder, path in todo:
        if planets_search_ends():
            sys.exit(3)
        v = planets_load_json(path)
        if folder != "validate_transits":
            r = exo.get(v.get("label") or "TOI-" + str(v.get("toi")))
            if not r or folder == "validate" and r.get("TFOPWG Disposition", "").strip() in ("KP", "CP", "FP", "FA"):
                continue
            if v.get("ephemeris_listed"):
                e = planets_load_json(os.path.join(planets_RESULTS, "validate_ephemeris", os.path.basename(path))) or {}
                r = dict(r, **{"Period (days)": repr(v["period"]), "Epoch (BJD)": repr(e["t0"] + 2457000.0)}) if "t0" in e else r
        else:
            m = re.fullmatch(r"(.+)_(\d+)\.json", os.path.basename(path))
            found = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", m.group(1) + ".json"))
            if not found or int(m.group(2)) > len(found["signals"]):
                continue
            g = found["signals"][int(m.group(2)) - 1]
            h = g if abs(v.get("period", g["P"]) / g["P"] - 1.0) < 0.01 else planets_transit_alias(g)
            if not h or abs(v.get("period", h["P"]) / h["P"] - 1.0) >= 0.01:
                continue
            r = planets_transit_candidate(found["name"], int(m.group(2)), h, v.get("tic"), v.get("star_radius"))
        P = planets_num(r["Period (days)"])
        if planets_num(r.get("Planet Radius (R_Earth)")) >= 22.4 or above and (not planets_num(r.get("Planet Radius (R_Earth)")) < planets_MULTI_RADIUS or not planets_has_sibling(v.get("tic") or r["TIC ID"], P, *planets_radec(r))):
            continue
        if not ready:
            planets_validate_setup()
            if gpu_DEVICE.type == "cuda" and not planets_VALIDATE_GPU:
                planets_validate_gpu()
                planets_VALIDATE_GPU.append(True)
            ready = True
        cache = planets_path("validate_cache", os.path.basename(path)[:-5] + "_multi")
        try:
            rec = planets_validate_one(r, draws, runs, cache=cache, fpp_max=planets_MULTI_BOOST * planets_FPP_VALID)
            if rec and "fpp" in rec:
                archive_save(path, json.dumps(dict(v, **rec), separators=(",", ":")).encode())
                print("%s: FPP %.4f NFPP %.5f on %d runs, was %.4f" % (r["label"], rec["fpp"], rec["nfpp"], rec["runs"], v["fpp"]), flush=True)
        except Exception as exc:
            print("%s: %s: %s" % (r["label"], type(exc).__name__, str(exc)[:200]), flush=True)
        finally:
            shutil.rmtree(cache, ignore_errors=True)
            for p in glob.glob(planets_path("validate_backgrounds", "%s_%d_*.csv" % (r["TIC ID"], os.getpid()))):
                os.remove(p)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("share done", flush=True)


def planets_gaia_measure():
    """What Gaia's marks of a double star do on the TOIs the TFOPWG has settled, from the benchmarks' records, to RESULTS/gaia_marks.json: of the planets and of the false positives, how many hold a non-single-star solution, how many whose velocities move, how many whose velocities leave a star eclipsing them no room, how many of them all pass as the decision now stands on ten runs, and how many of those have the marks to thank for it. Returns it."""
    groups = dict(CP="planets", KP="planets", FP="false_positives", FA="false_positives")
    out = {g: dict(weighed=0, read=0, double=0, moving=0, no_room=0, decided_new=0, cleared_by_room=0) for g in set(groups.values())}
    exo = {x["label"]: x for x in planets_candidates("toi")}
    recs = {}
    for name in ("validate_benchmark", "validate_benchmark_again"):
        for p in glob.glob(os.path.join(planets_RESULTS, name, "*.json")):
            v = planets_load_json(p)
            if v and "fpp" in v and "gaia_nss" in v:
                recs.setdefault(v.get("label"), v)
    if not recs:
        return out
    events = planets_tce({v["tic"] for v in recs.values()})
    for label, v in recs.items():
        x = exo.get(label, {})
        g = groups.get(x.get("TFOPWG Disposition", "").strip())
        if not g:
            continue
        d = out[g]
        d["weighed"] += 1
        d["read"] += v.get("gaia_rv_scatter") is not None
        d["double"] += (v["gaia_nss"] or 0.0) > 0.0
        d["moving"] += planets_rv_moving(v)
        d["no_room"] += planets_no_room(v)
        new = planets_validation_decision(dict(v, runs=10), x, None, events)[0] == "new"
        d["decided_new"] += new
        d["cleared_by_room"] += new and planets_validation_decision(dict(v, runs=10, gaia_rv_scatter=None), x, None, events)[0] != "new"
    archive_save(os.path.join(planets_RESULTS, "gaia_marks.json"), json.dumps(out, separators=(",", ":")).encode())
    return out


def planets_validate_gaia(part=None):
    """Gaia's marks of a double star (planets_gaia_marks) added to each record under RESULTS/validate and RESULTS/validate_transits and, in the root that holds them, the benchmarks', three stars read at a time, and what they do on the settled TOIs measured (planets_gaia_measure). PART takes the share K/N; the pass ends between its hundreds of records where a long search would end between stars, with exit status 3."""
    exo = {x["label"]: x for x in planets_exofop()}
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))} if os.path.exists(planets_path("bank_stars.csv")) else {}
    todo = []
    for folder in ("validate", "validate_transits", "validate_benchmark", "validate_benchmark_again", "validate_benchmark_koi", "validate_benchmark_k2"):
        for path in glob.glob(os.path.join(planets_RESULTS, folder, "*.json")):
            v = planets_load_json(path)
            if v and "fpp" in v and "gaia_nss" not in v:
                todo.append((folder, path))
    todo.sort()
    if part:
        k, n = (int(x) for x in part.split("/"))
        todo = todo[k::n]
    print("%d records in this share" % len(todo), flush=True)

    def place(folder, path, v):
        if folder == "validate_transits":
            m = re.fullmatch(r"(.+)_\d+(_half)?\.json", os.path.basename(path))
            rec = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", m.group(1) + ".json")) or {}
            s = stars.get(rec.get("name"), {})
            ra, dec = planets_num(rec.get("ra")), planets_num(rec.get("dec"))
            return (ra, dec) if math.isfinite(ra) and math.isfinite(dec) else (planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000")))
        x = exo.get(v.get("label") or "TOI-" + str(v.get("toi")))
        return planets_radec(x) if x else (float("nan"), float("nan"))

    def one(item):
        folder, path = item
        try:
            v = planets_load_json(path)
            ra, dec = place(folder, path, v)
            marks = planets_gaia_marks(ra, dec) if math.isfinite(ra) and math.isfinite(dec) else dict(gaia_nss=None, gaia_rv_scatter=None, gaia_rv_gof=None, gaia_rv_p=None)
            archive_save(path, json.dumps(dict(planets_load_json(path), **marks), separators=(",", ":")).encode())
        except IOError as exc:
            # an archive that did not answer: the record comes round again
            print("%s: %s" % (os.path.basename(path), str(exc)[:200]), flush=True)
    with cf.ThreadPoolExecutor(3) as ex:
        for i in range(0, len(todo), 100):
            if planets_search_ends():
                sys.exit(3)
            list(ex.map(one, todo[i:i + 100]))
    print("share done", flush=True)
    if not part or part.startswith("0/"):
        print(planets_gaia_measure(), flush=True)


def planets_noise_ratio(t, f, sd, P, t0, dur, others=()):
    """A dip's signal-to-noise in the flattened flux F at the times T over the highest of the same search of that flux upside down with its transits and those of OTHERS, (period, epoch, duration) each, set aside, at periods from half a day to 20 days or half the span: the multiple planets_TRANSIT_NEW asks of a signal of orbitlight's own search."""
    span = float(t.max() - t.min())
    periods = planets_transit_periods(span, 0.5, min(20.0, 0.5 * span))
    if not len(periods):
        return None
    durations = planets_TRANSIT_DURATIONS
    width = durations[int(np.argmin(np.abs(durations - dur)))]
    own = float(np.max(gpu_bls(t, f, np.full(len(t), sd), np.array([P]), np.array([width]))[0]))
    live = planets_transit_unmasked(t, [(P, t0, 1.5 * dur)] + [(q, e, 1.5 * d) for q, e, d in others])
    top = float(np.max(gpu_bls(t[live], 2.0 - f[live], np.full(int(live.sum()), sd), periods, durations)[0]))
    return round(own / top, 2) if top > 0 else None


def planets_validate_fold(part=None):
    """Each record under RESULTS/validate and RESULTS/validate_transits and the benchmarks' whose probabilities leave it within reach of a likely planet or of a star with another candidate, given from its light curves flattened as the validation flattens them how strongly its fold shows its dip (dip_sigma), its odd and even depths against the transits' own scatter where they lie 3 sigma apart against the light curve's noise (planets_odd_even_z), and, for a community TOI, a K2 candidate or a settled candidate, how far past the highest of the same search upside down (planets_noise_ratio). PART takes the share K/N; the pass ends between records where a long search would end between stars, with exit status 3."""
    from astropy.io import fits
    import socket
    warnings.filterwarnings("ignore")
    socket.setdefaulttimeout(300)
    exo = {x["label"]: x for x in planets_exofop()}
    todo = []
    for folder in ("validate", "validate_transits", "validate_benchmark", "validate_benchmark_again", "validate_benchmark_koi", "validate_benchmark_k2"):
        for path in glob.glob(os.path.join(planets_RESULTS, folder, "*.json")):
            if path.endswith("_half.json"):
                continue
            v = planets_load_json(path)
            if not v or "fpp" not in v:
                continue
            label = v.get("label") or "TOI-" + str(v.get("toi"))
            lacking = "dip_sigma" not in v or ((v.get("odd_even_sigma") or 0.0) >= 3.0 and "odd_even_z" not in v) or ((label.startswith(("CTOI-", "EPIC-")) or folder.startswith("validate_benchmark")) and "noise_ratio" not in v)
            if not lacking:
                continue
            f, n = planets_source_cleared(v)
            if f < max(planets_MULTI_BOOST * planets_FPP_VALID, planets_FPP_LIKELY) and n < planets_NFPP_LIKELY:
                todo.append((folder, path))
    todo.sort()
    if part:
        k, n = (int(x) for x in part.split("/"))
        todo = todo[k::n]
    print("%d records in this share" % len(todo), flush=True)
    for folder, path in todo:
        if planets_search_ends():
            sys.exit(3)
        v = planets_load_json(path)
        label = v.get("label") or "TOI-" + str(v.get("toi"))
        cache = planets_path("validate_cache", os.path.basename(path)[:-5] + "_fold")
        try:
            if folder == "validate_transits":
                m = re.fullmatch(r"(.+)_(\d+)\.json", os.path.basename(path))
                found = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", m.group(1) + ".json"))
                if not found or int(m.group(2)) > len(found["signals"]):
                    continue
                g = found["signals"][int(m.group(2)) - 1]
                P = v.get("period") or g["P"]
                s_ = planets_binary_signal(g, True) if abs(P / g["P"] - 2.0) < 0.01 else g
                t0, dur = s_["t0_btjd"], s_["duration_h"] / 24.0
                r = planets_transit_candidate(found["name"], int(m.group(2)), dict(s_, P=P), v.get("tic"), v.get("star_radius"), v.get("star_mass"), v.get("star_teff"))
            else:
                r = exo.get(label)
                if not r:
                    continue
                P = v.get("period") or planets_num(r["Period (days)"])
                t0 = planets_num(r["Epoch (BJD)"]) - 2457000.0
                dur = planets_num(r["Duration (hours)"]) / 24.0
            t0 += (v.get("epoch_shift_min") or 0.0) / 1440.0
            files = planets_validate_fetch(r, cache) or {}
            T, F = [], []
            for key in sorted(files):
                with fits.open(files[key]) as h:
                    got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
                if got is None:
                    continue
                t, y = got
                inside = np.abs(((t - t0) / P + 0.5) % 1.0 - 0.5) * P < dur
                if inside.all():
                    continue
                width = max(3, int(round(0.75 / max(float(np.median(np.diff(t))), 1e-4))) | 1)
                T.append(t), F.append(y / gpu_host(gpu_running_median(np.interp(t, t[~inside], y[~inside])[None, :], width))[0])
            if not T:
                archive_save(path, json.dumps(dict(planets_load_json(path), dip_sigma=None, odd_even_z=None, noise_ratio=None), separators=(",", ":")).encode())
                continue
            t, y = np.concatenate(T), np.concatenate(F)
            x = ((t - t0) / P + 0.5) % 1.0 * P - 0.5 * P
            inn, ring = np.abs(x) < 0.5 * dur, (np.abs(x) > 0.75 * dur) & (np.abs(x) < 2.0 * dur)
            got = dict(dip_sigma=None)
            if inn.sum() >= 3 and ring.sum() >= 10:
                sd = 1.4826 * float(np.median(np.abs(y[ring] - np.median(y[ring]))))
                got["dip_sigma"] = round(float((np.mean(y[ring]) - np.mean(y[inn])) / (sd * math.sqrt(1.0 / inn.sum() + 1.0 / ring.sum()))), 2) if sd > 0 else None
            if (v.get("odd_even_sigma") or 0.0) >= 3.0:
                got["odd_even_z"] = planets_odd_even_z(t, y, P, t0, dur)
            if label.startswith(("CTOI-", "EPIC-")) or folder.startswith("validate_benchmark"):
                whole = 1.4826 * float(np.median(np.abs(y - np.median(y))))
                got["noise_ratio"] = planets_noise_ratio(t, y, whole, P, t0, dur, [e for e in planets_transit_known(tic=str(r["TIC ID"]).strip()) if abs(e[0] / P - 1.0) >= 0.01])
            archive_save(path, json.dumps(dict(planets_load_json(path), **got), separators=(",", ":")).encode())
            print("%s: %s" % (os.path.basename(path)[:-5], got), flush=True)
        except IOError as exc:
            # an archive that did not answer: the record comes round again
            print("%s: %s: %s" % (os.path.basename(path)[:-5], type(exc).__name__, str(exc)[:200]), flush=True)
        except Exception as exc:
            print("%s: %s: %s" % (os.path.basename(path)[:-5], type(exc).__name__, str(exc)[:200]), flush=True)
            archive_save(path, json.dumps(dict(planets_load_json(path), dip_sigma=v.get("dip_sigma"), odd_even_z=v.get("odd_even_z"), noise_ratio=v.get("noise_ratio")), separators=(",", ":")).encode())
        finally:
            shutil.rmtree(cache, ignore_errors=True)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    print("share done", flush=True)


def planets_record_row(folder, path, v, exo, settled=False):
    """The candidate a validation record V, at PATH under RESULTS/FOLDER, weighs, as a row of ExoFOP's table at the ephemeris it was weighed at; None where ExoFOP or the search no longer holds it, or unless SETTLED where the TFOPWG has settled it."""
    if folder != "validate_transits":
        r = exo.get(v.get("label") or "TOI-" + str(v.get("toi")))
        if not r or not settled and r.get("TFOPWG Disposition", "").strip() in ("KP", "CP", "FP", "FA"):
            return None
        if v.get("ephemeris_listed"):
            e = planets_load_json(os.path.join(planets_RESULTS, "validate_ephemeris", os.path.basename(path))) or {}
            r = dict(r, **{"Period (days)": repr(v["period"]), "Epoch (BJD)": repr(e["t0"] + 2457000.0)}) if "t0" in e else r
        return r
    m = re.fullmatch(r"(.+)_(\d+)\.json", os.path.basename(path))
    found = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", m.group(1) + ".json")) if m else None
    if not found or int(m.group(2)) > len(found["signals"]):
        return None
    g = found["signals"][int(m.group(2)) - 1]
    P = v.get("period", g["P"])
    h = g if abs(P / g["P"] - 1.0) < 0.01 else planets_binary_signal(g, True) if abs(P / g["P"] - 2.0) < 0.01 and (g["odd_even_sigma"] or 0.0) >= 3.0 else planets_transit_alias(g)
    if not h or abs(P / h["P"] - 1.0) >= 0.01:
        return None
    return planets_transit_candidate(found["name"], int(m.group(2)), h, v.get("tic"), v.get("star_radius"), v.get("star_mass"), v.get("star_teff"))


def planets_clear_measure():
    """What a difference image and the TIC's flags do to the decision on the TOIs the TFOPWG has settled, from the records of RESULTS/validate_clear, to RESULTS/source_clear.json: of the planets and of the false positives weighed, how many passed as they were first weighed, how many pass without the flagged stars, how many hold a place, how many pass as the image leaves their probabilities (planets_source_cleared), and how many of those the decision's other tests leave. Returns it."""
    groups = dict(CP="planets", KP="planets", FP="false_positives", FA="false_positives")
    out = {g: dict(weighed=0, passed_before=0, without_flagged=0, placed=0, with_image=0, decided_new=0) for g in set(groups.values())}
    exo = {x["label"]: x for x in planets_candidates("toi")}
    recs = [v for v in (planets_load_json(p) for p in glob.glob(os.path.join(planets_RESULTS, "validate_clear", "*.json"))) if v and "fpp" in v]
    events = planets_tce({v["tic"] for v in recs})
    for v in recs:
        x = exo.get(v.get("label"), {})
        g = groups.get(x.get("TFOPWG Disposition", "").strip())
        if not g:
            continue
        fpp, nfpp = planets_source_cleared(v)
        d = out[g]
        d["weighed"] += 1
        d["passed_before"] += v.get("not_planet_before", v["fpp_before"]) < planets_FPP_VALID and v["nfpp_before"] < planets_NFPP_VALID
        d["without_flagged"] += planets_not_planet(v) < planets_FPP_VALID and v["nfpp"] < planets_NFPP_VALID
        d["placed"] += (v.get("source") or {}).get("chi2", 0.0) >= planets_IMAGE_CHI2
        d["with_image"] += fpp < planets_FPP_VALID and nfpp < planets_NFPP_VALID
        d["decided_new"] += planets_validation_decision(dict(v, runs=10), x, None, events)[0] == "new"
    archive_save(os.path.join(planets_RESULTS, "source_clear.json"), json.dumps(out, separators=(",", ":")).encode())
    return out


def planets_validate_clear(part=None, draws=100000, runs=10):
    """The records under RESULTS/validate and RESULTS/validate_transits that do not pass and that a false-positive probability without their nearby stars would carry within the limits of a likely planet or of a star with another candidate, nearest to passing first, each given the place of its dip's source in its difference images (planets_image_read, planets_image_fit), kept as source with a digest of the code that read it, and weighed again without the stars the TIC flags, each neighbour's share kept (planets_validate_one), the images read at those neighbours (planets_image_at): on three runs, and on RUNS where the probabilities as the image leaves them (planets_source_cleared) stand within those limits. A record is claimed by a folder of its name under RESULTS/validate_clear_claims while it is read, so that processes side by side read it once, a claim two hours old being taken over. In the root that holds the benchmarks their settled TOIs of those kinds, and those that pass as they stand, are read likewise on three runs into RESULTS/validate_clear, the control of the rule (planets_clear_measure). PART takes the share K/N; the pass ends between records where a long search would end between stars, with exit status 3."""
    import socket
    warnings.filterwarnings("ignore")
    socket.setdefaulttimeout(300)
    version = planets_rules_hash(("planets_image_read", "planets_image_fit", "planets_image_at", "planets_image_sector", "planets_image_surface"), (planets_IMAGE_FLOOR,))
    within = lambda f, n: (f < planets_MULTI_BOOST * planets_FPP_VALID or f < planets_FPP_LIKELY) and n < planets_NFPP_LIKELY
    exo = {x["label"]: x for x in planets_exofop()}

    def without_near(v):
        scen = v.get("scenarios") or {}
        keep = sum(x for k, x in scen.items() if k not in ("NTP", "NEB", "NEBx2P"))
        return 1.0 - sum(scen.get(k, 0.0) for k in planets_PLANET_SCENARIOS) / keep if keep > 0 else 1.0
    todo = []
    for folder in ("validate", "validate_transits"):
        for path in glob.glob(os.path.join(planets_RESULTS, folder, "*.json")):
            if path.endswith("_half.json"):
                continue
            v = planets_load_json(path)
            if not v or "fpp" not in v or planets_not_planet(v) < planets_FPP_VALID and v["nfpp"] < planets_NFPP_VALID or (v.get("source") or {}).get("version") == version:
                continue
            if folder == "validate" and "dip_sigma" in v and planets_fold_fault(v, v.get("label") or "TOI-" + str(v.get("toi"))):
                continue
            f = without_near(v)
            if f < max(planets_MULTI_BOOST * planets_FPP_VALID, planets_FPP_LIKELY) and not str(v.get("label")).startswith(("KOI-", "EPIC-")):
                todo.append((f, folder, path, False))
    bench = [p for name in ("validate_benchmark", "validate_benchmark_again") for p in glob.glob(os.path.join(planets_RESULTS, name, "*.json"))]
    control = os.path.join(planets_RESULTS, "validate_clear")
    if bench:
        os.makedirs(control, exist_ok=True)
        for path in bench:
            v = planets_load_json(path)
            kept = os.path.join(control, os.path.basename(path))
            if not v or "fpp" not in v or (planets_load_json(kept) or {}).get("source", {}).get("version") == version:
                continue
            f = without_near(v)
            if f < max(planets_MULTI_BOOST * planets_FPP_VALID, planets_FPP_LIKELY):
                todo.append((f, "control", path, True))
    todo.sort(key=lambda x: (x[0], x[2]))
    if part:
        k, n = (int(x) for x in part.split("/"))
        todo = todo[k::n]
    print("%d records in this share" % len(todo), flush=True)
    if not todo:
        return
    planets_validate_setup()
    if gpu_DEVICE.type == "cuda" and not planets_VALIDATE_GPU:
        planets_validate_gpu()
        planets_VALIDATE_GPU.append(True)
    home, work = os.getcwd(), planets_path("validate_backgrounds", "work%d" % os.getpid())
    claims = os.path.join(planets_RESULTS, "validate_clear_claims")
    os.makedirs(work, exist_ok=True)
    os.makedirs(claims, exist_ok=True)
    os.chdir(work)
    started = time.time()
    for _, folder, path, is_control in todo:
        if planets_search_ends():
            os.chdir(home)
            shutil.rmtree(work, ignore_errors=True)
            sys.exit(3)
        if time.time() - started > planets_DR4_PASS:
            break
        claim = os.path.join(claims, os.path.basename(path)[:-5] + ("_control" if is_control else ""))
        try:
            os.mkdir(claim)
        except FileExistsError:
            if time.time() - os.path.getmtime(claim) < 7200:
                continue
        kept = os.path.join(control, os.path.basename(path)) if is_control else path
        v = planets_load_json(path)
        r = planets_record_row("validate" if is_control else folder, path, v, exo, settled=is_control) if (planets_load_json(kept) or {}).get("source", {}).get("version") != version else None
        if not r:
            shutil.rmtree(claim, ignore_errors=True)
            continue
        label = r["label"]
        cache = planets_path("validate_cache", archive_tag(label) + "_clear")
        try:
            P, dur = planets_num(r["Period (days)"]), planets_num(r["Duration (hours)"]) / 24.0
            t0 = planets_num(r["Epoch (BJD)"]) - 2457000.0 + (v.get("epoch_shift_min") or 0.0) / 1440.0
            images = planets_image_read(int(r["TIC ID"]), P, t0, dur)
            s = dict(planets_image_fit(images) if images else {}, version=version)

            def seen(got):
                # the image read at the stars this weighing gave a share
                return dict(s, at=planets_image_at(images, s, got["near_probs"])) if images else s
            files, target = planets_validate_fetch(r, cache, stars=True) or (None, None)
            rec = planets_validate_one(r, draws, 3, cache=cache, files=files, target=target, fpp_max=2.0, nfpp_max=2.0) if files else None
            if rec and "fpp" in rec and not is_control:
                f, n = planets_source_cleared(dict(rec, source=seen(rec)))
                if within(f, n) or (folder == "validate_transits" and n + sum(rec["scenarios"].get(k, 0.0) for k in ("BTP", "BEB", "BEBx2P")) < 0.001):
                    rec = planets_validate_one(r, draws, runs, cache=cache, files=files, target=target, fpp_max=2.0, nfpp_max=2.0)
            if rec and "fpp" in rec:
                s = seen(rec)
                f, n = planets_source_cleared(dict(rec, source=s))
                line = dict(v, **rec, source=s)
                if is_control:
                    line.update(fpp_before=v["fpp"], not_planet_before=planets_not_planet(v), nfpp_before=v["nfpp"], label=label)
                archive_save(kept, json.dumps(line, separators=(",", ":")).encode())
                print("%-20s FPP %.4f NFPP %.5f, was %.4f %.5f; source %s +- %s arcsec; %.4f %.5f as the image leaves them" % (label, rec["fpp"], rec["nfpp"], v["fpp"], v["nfpp"], s.get("offset"), s.get("err"), f, n), flush=True)
            elif not is_control:
                # nothing to weigh again: the image kept, so that the record comes round when its code changes
                archive_save(path, json.dumps(dict(v, source=s), separators=(",", ":")).encode())
        except IOError as exc:
            # a catalogue or an archive that did not answer: the record comes round again
            print("%s: %s: %s" % (label, type(exc).__name__, str(exc)[:200]), flush=True)
        except Exception as exc:
            print("%s: %s: %s" % (label, type(exc).__name__, str(exc)[:200]), flush=True)
            if not is_control:
                archive_save(path, json.dumps(dict(v, source=dict(version=version, note=str(exc)[:200])), separators=(",", ":")).encode())
        finally:
            shutil.rmtree(cache, ignore_errors=True)
            shutil.rmtree(claim, ignore_errors=True)
            for p in glob.glob(planets_path("validate_backgrounds", "%s_%d_*.csv" % (r["TIC ID"], os.getpid()))):
                os.remove(p)
        if gpu_DEVICE.type == "cuda":
            torch.cuda.empty_cache()
    os.chdir(home)
    shutil.rmtree(work, ignore_errors=True)
    if bench:
        print(planets_clear_measure(), flush=True)
    print("share done", flush=True)


def planets_control(n=200, seed=1):
    """The decision rules tried on TOIs whose fate TESS's follow-up has settled, so that a rule that rejects real planets, or rejects false positives no more often than planets,
    shows itself: N planets (TFOPWG CP or KP) and N false positives or alarms (FP or FA) drawn at random, each measured as a validation is, at the ephemeris its own light curves
    give where that replaces the listed one (planets_ephemeris_kept), and its record, its probabilities set to pass, decided by planets_validation_decision, with every rule that trips
    on it, the depths that vary from sector to sector among them, which no decision reads (planets_transit_depths_vary). RESULTS/control.json holds the rules' digest and for each group
    how many were judged, those rejected by reason and those each rule trips on; a run with the same digest does nothing. Ends between stars where a long search would, with exit status
    3, keeping what it has in RESULTS/control_parts.jsonl."""
    from astropy.io import fits
    warnings.filterwarnings("ignore")
    digest = planets_rules_hash(("planets_control", "planets_validation_decision", "planets_transit_physical", "planets_transit_smooth", "planets_check_cols", "planets_centroid_off", "planets_variable_neighbours", "planets_transit_shape",
                                 "planets_ephemeris", "planets_ephemeris_moves", "planets_ephemeris_kept", "planets_transit_depths_vary"), (planets_RUWE_MAX, planets_SPIN_FAST, planets_SPIN_LOW, planets_SPIN_HIGH))
    path, parts = os.path.join(planets_RESULTS, "control.json"), os.path.join(planets_RESULTS, "control_parts.jsonl")
    if (planets_load_json(path) or {}).get("digest") == digest:
        return
    held = {}
    if os.path.exists(parts):
        for line in open(parts, encoding="utf-8"):
            x = json.loads(line)
            if x["digest"] == digest:
                held[x["label"]] = x
    rows, groups = [], (("planets", ("CP", "KP")), ("false_positives", ("FP", "FA")))
    for k, (group, fates) in enumerate(groups):
        got = [r for r in planets_candidates("toi") if r["TFOPWG Disposition"].strip() in fates and planets_num(r["Period (days)"]) > 0 and planets_num(r["Duration (hours)"]) > 0]
        random.Random(seed + k).shuffle(got)
        rows += [dict(r, group=group) for r in got[:n]]
    with open(parts, "a", encoding="utf-8") as out:
        for r in rows:
            if r["label"] in held:
                continue
            if planets_search_ends():
                sys.exit(3)
            P, t0, dur = planets_num(r["Period (days)"]), planets_num(r["Epoch (BJD)"]) - 2457000.0, planets_num(r["Duration (hours)"]) / 24.0
            cache = planets_path("validate_cache", archive_tag(r["label"]) + "_control")
            line = dict(label=r["label"], digest=digest, group=r["group"], status="", reason="", rules=[])
            try:
                files = planets_validate_fetch(r, cache) or {}
                raw = []
                for s in sorted(files):
                    with fits.open(files[s]) as h:
                        got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
                    if got is not None:
                        raw.append(got)
                if raw:
                    _, P, t0 = planets_ephemeris_kept(raw, r, P, t0, dur)
                    v = dict(planets_transit_shape(raw, P, t0, dur), **planets_centroid_check(r["TIC ID"], P, t0, dur))
                    ra, dec = planets_radec(r)
                    v.update(planets_gaia_near(ra, dec), **planets_gaia_marks(ra, dec), period=P, duration_h=dur * 24.0, fpp=0.0, nfpp=0.0, runs=10, tic=int(r["TIC ID"]), odd_even_sigma=0.0, secondary_sigma=0.0,
                             variable_neighbours=planets_variable_neighbours(ra, dec, P))
                    line["status"], line["reason"] = planets_validation_decision(v, r, None, {})[:2]
                    cols = planets_check_cols(v, P, r)
                    spun = (cols.get("gaia_vbroad") or 0.0) >= planets_SPIN_FAST and planets_SPIN_LOW <= (cols.get("spin_ratio") or 0.0) <= planets_SPIN_HIGH
                    line["rules"] = [name for name, hit in (("variability", planets_transit_smooth(v)), ("a neighbour's variability", v["variable_neighbours"]),
                                                            ("astrometric binary", (v.get("gaia_ruwe") or 0.0) >= planets_RUWE_MAX), ("a double star in Gaia", (v.get("gaia_nss") or 0.0) > 0.0 or planets_rv_moving(v)), ("source off the star", planets_centroid_off(v)),
                                                            ("the star's rotation", spun), ("the star's size", planets_transit_physical(dict(P=P, depth_ppm=planets_num(r.get("Depth (ppm)")), duration_h=dur * 24.0),
                                                                                                                        r.get("Stellar Radius (R_Sun)"), r.get("Stellar Mass (M_Sun)"))),
                                                            ("depths vary", planets_transit_depths_vary(v))) if hit]
            except Exception as exc:
                line["reason"] = "unread: %s" % type(exc).__name__
            finally:
                shutil.rmtree(cache, ignore_errors=True)
            held[r["label"]] = line
            out.write(json.dumps(line) + "\n")
            out.flush()
    summary = dict(digest=digest, finished=time.strftime("%Y-%m-%d %H:%M:%S"))
    for group, _ in groups:
        judged = [x for x in held.values() if x["status"] and x["group"] == group]
        by, rules = {}, {}
        for x in judged:
            if x["status"] == "rejected":
                by.setdefault(x["reason"], []).append(x["label"])
            for rule in x["rules"]:
                rules.setdefault(rule, []).append(x["label"])
        summary[group] = dict(judged=len(judged), rejected=sum(len(v) for v in by.values()), by_reason=by, trips=rules)
        print("the rules reject %d of %d %s: %s; each rule trips on %s" % (summary[group]["rejected"], len(judged), group.replace("_", " "), {k: len(v) for k, v in by.items()},
                                                                           {k: len(v) for k, v in rules.items()}), flush=True)
    archive_save(path, json.dumps(summary).encode())


def planets_validate(part=None, draws=100000, runs=10, sources=("toi", "ctoi", "koi", "k2"), dispositions=("PC", "APC"), min_snr=7.1, max_snr=None, redo=False,
                     workers=None, candidates=None, benchmark=0, again=False):
    """TESS's planet candidates validated statistically, each to RESULTS/validate/<label>.json (planets_validate_one, RUNS runs of DRAWS draws each), from
    each source of SOURCES: toi, the TOIs of ExoFOP's table whose TFOPWG disposition is among DISPOSITIONS, with a signal-to-noise ratio of MIN_SNR or
    more and below MAX_SNR where given; ctoi, its community TOIs not promoted to TOIs that their submitters take for planet candidates and the TFOPWG has
    given no other disposition, the first of those on one star whose periods agree within 1 per cent, alike or at half or twice, and none whose period so
    agrees with a TOI's of its star (planets_candidates). Each has a period, depth and duration, and the NASA Exoplanet Archive lists no planet of its
    star in any published solution within 5 per cent of its period (planets_catalogued); CANDIDATES, labels, take those candidates alone, whatever their
    selection, and weigh them again. On a CUDA device the scenarios' light curves are computed there with exact Keplerian orbits (planets_validate_gpu). A
    candidate without a light curve, or whose analysis fails, is written with its reason; one whose record was made without the contrast curves of the
    imaging ExoFOP lists of its star, or at a period ExoFOP has since moved by more than 1 per cent, is weighed again; and every network call gives up
    after five minutes without an answer. PART takes the share K/N, every Nth candidate from the Kth, the share's pass running for planets_DR4_PASS seconds at most and coming round again, and ending between candidates where a long search would, with exit status 3;
    without it the candidates are weighed in WORKERS shares at once (planets_validate_shares), by default half the machine's processors and at most 16.
    BENCHMARK weighs instead that many TOIs of each settled fate (planets_validation_settled) into RESULTS/validate_benchmark/, with AGAIN others into RESULTS/validate_benchmark_again/, and scores them
    (planets_validation_benchmark)."""
    import socket
    n = workers or max(1, min(16, (os.cpu_count() or 2) // 2))
    # refreshed before the shares start, so that every share reads the same copies
    fresh = None if part else 1.0
    if part is None:
        for source in ("toi", "ctoi"):
            planets_candidates(source, fresh)
        planets_archive(fresh)
    kepler = sources[0] if sources[0] in planets_KEPLER else None
    folder = os.path.join(planets_RESULTS, ("validate_benchmark_" + kepler if kepler else "validate_benchmark_again" if again else "validate_benchmark") if benchmark else "validate")
    if benchmark:
        candidates = planets_validation_settled(benchmark, folder, again, kepler or "toi")
    if part is None and (benchmark or not candidates) and n > 1:
        planets_validate_shares(n, ["--draws", str(draws), "--runs", str(runs), "--source"] + list(sources) + ["--dispositions"] + list(dispositions) +
                                ["--min-snr", repr(min_snr)] + (["--max-snr", repr(max_snr)] if max_snr else []) + (["--redo"] if redo else []) +
                                (["--benchmark", str(benchmark)] if benchmark else []) + (["--again"] if again else []), folder)
        return planets_validation_benchmark(again, kepler or "toi") if benchmark else None
    socket.setdefaulttimeout(300)
    planets_validate_setup()
    # TRICERATOPS writes its files into the working directory: each process works in one of its own
    home, work = os.getcwd(), planets_path("validate_backgrounds", "work%d" % os.getpid())
    os.makedirs(work, exist_ok=True)
    os.chdir(work)
    likelihoods = "gpu" if gpu_DEVICE.type == "cuda" else "pytransit"
    if likelihoods == "gpu":
        planets_validate_gpu()
    usable = lambda r: all(planets_num(r[k]) > 0 for k in ("Period (days)", "Duration (hours)", "Depth (ppm)"))
    rows, counts = [], []
    for source in (("toi", "ctoi", "koi", "k2") if candidates else sources):
        got = [r for r in planets_candidates(source) if usable(r) and (not candidates or r["label"] in candidates)]
        if source in ("toi", "koi") and not candidates:
            got = [r for r in got if r["TFOPWG Disposition"] in dispositions and min_snr <= planets_num(r["Planet SNR"]) < (max_snr or float("inf"))]
        elif source == "k2" and not candidates:
            got = [r for r in got if r["TFOPWG Disposition"] in dispositions]
        elif not candidates:
            seen, kept = {}, []
            for t in planets_candidates("toi"):
                if planets_num(t["Period (days)"]) > 0:
                    seen.setdefault(t["TIC ID"], []).append(planets_num(t["Period (days)"]))
            for r in sorted(got, key=lambda r: float(r["TOI"])):
                P = planets_num(r["Period (days)"])
                if r["Promoted to TOI"].strip() or r["User Disposition"] != "PC" or r["TFOPWG Disposition"] not in ("", "PC") or \
                        any(abs(P / (Q * m) - 1.0) < 0.01 for Q in seen.get(r["TIC ID"], []) for m in (0.5, 1.0, 2.0)):
                    continue
                seen.setdefault(r["TIC ID"], []).append(P)
                kept.append(r)
            got = kept
        rows += got
        counts.append("%d %s" % (len(got), {"toi": "TOIs of %s with S/N %g or more%s" % ("/".join(dispositions), min_snr, " and below %g" % max_snr
                                                                                              if max_snr else ""), "ctoi": "community TOIs", "koi": "Kepler's candidates", "k2": "K2's candidates"}[source]))
    match = planets_catalogued(fresh or 1e9)
    todo = [r for r in rows if candidates or not match(*planets_radec(r), r["TIC ID"], (), planets_num(r["Period (days)"]))]
    # the TOIs by number, then the community TOIs by number
    todo.sort(key=lambda r: (("TOI", "CTOI", "KOI", "EPIC").index(r["label"].split("-")[0]), float(r["TOI"])))
    unlisted = len(todo)
    if part:
        k, n = (int(x) for x in part.split("/"))
        todo = todo[k::n]
    os.makedirs(folder, exist_ok=True)
    redo = redo or (bool(candidates) and not benchmark)
    print("%s, %d of them unlisted by the archive, %d in this share" % (" and ".join(counts) if not candidates else "%d named candidates" % len(rows), unlisted,
                                                                         len(todo)), flush=True)
    path_of = lambda r: os.path.join(folder, archive_tag(r["label"]) + ".json")
    cache_of = lambda r: planets_path("validate_cache", archive_tag(r["label"]))
    imaged = planets_imaged()

    def due(r):
        # a candidate is weighed where it has no record, and again where its record was made without the contrast curves of the imaging of its star
        # and a curve can now be read from that imaging; where none can, the record keeps its weighing and notes that none could be read, so that
        # weighing it again on the same evidence cannot move its decision
        if redo or not os.path.exists(path_of(r)):
            return True
        v = json.load(open(path_of(r)))
        if "fpp" in v and v.get("period") and abs(planets_num(r["Period (days)"]) / v["period"] - 1.0) > 0.01:
            return True
        # a record made without a light curve before QLP's were asked for is weighed once more
        if v.get("note") == "no light curve or aperture" and not v.get("qlp"):
            return True
        if planets_NO_FIELD in v.get("note", "") or "stellar" in v.get("note", "") and not v.get("gaia_read") or v.get("note", "").startswith(("OSError", "FileNotFoundError", "PermissionError")):
            return True
        if int(r["TIC ID"]) not in imaged or "fpp" not in v or "contrast_curves" in v:
            return False
        try:
            curves = planets_contrast_curves(int(r["TIC ID"]), os.path.join(cache_of(r), "imaging"))
        except Exception:
            return False
        finally:
            shutil.rmtree(cache_of(r), ignore_errors=True)
        if not curves:
            archive_save(path_of(r), json.dumps(dict(v, contrast_curves=[]), separators=(",", ":")).encode())
        return bool(curves)
    todo = [r for r in todo if due(r)]

    def fetch(r):
        # an archive that answers Too Many Requests asked again after 30, 60, 90 and 120 seconds
        for attempt in range(5):
            try:
                got = planets_validate_fetch(r, cache_of(r), stars=True)
                return (got or (None, None)) + (None,)
            except Exception as exc:
                if "429" not in str(exc) or attempt == 4:
                    return None, None, "%s: %s" % (type(exc).__name__, str(exc)[:200])
                time.sleep(30 * (attempt + 1))
    # each candidate's light curves, stars and background fetched on two threads up to three candidates ahead, while the one before is weighed
    started, ended, whole = time.time(), False, True
    with cf.ThreadPoolExecutor(2) as ex:
        ahead = [ex.submit(fetch, r) for r in todo[:3]]
        for i, r in enumerate(todo):
            ended = planets_search_ends()
            if ended or part and time.time() - started > planets_DR4_PASS:
                whole = False
                for f in ahead[i:]:
                    f.cancel()
                break
            if i + 3 < len(todo):
                ahead.append(ex.submit(fetch, todo[i + 3]))
            t_start = time.time()
            files, target, why = ahead[i].result()
            # sys.stdout set to the process's own stream before each candidate
            sys.stdout = sys.__stdout__
            # the target's Gaia background population, kept while it is weighed
            background = str(getattr(target, "trilegal_fname", None) or "")
            # a candidate another share has weighed since this one listed it is passed over
            if due(r):
                try:
                    rec = (planets_validate_one(r, draws, runs, cache=cache_of(r), files=files, target=target) if files else None) or \
                        dict(label=r["label"], toi=r["TOI"], tic=int(r["TIC ID"]), note=why or "no light curve or aperture", qlp=True)
                except Exception as exc:
                    rec = dict(label=r["label"], toi=r["TOI"], tic=int(r["TIC ID"]), note="%s: %s" % (type(exc).__name__, str(exc)[:200]))
                rec.update(seconds=round(time.time() - t_start), likelihoods=likelihoods)
                prior = json.load(open(path_of(r))) if os.path.exists(path_of(r)) else {}
                kept = planets_validate_record(prior, rec, redo)
                # each record written whole before it takes the old one's place
                if kept != prior:
                    archive_save(path_of(r), json.dumps(kept, separators=(",", ":")).encode())
                if kept is not rec:
                    print("%s: %s; its record kept" % (r["label"], "weighing failed (%s)" % rec.get("note") if "fpp" not in rec else "weighed again on the same evidence"),
                          file=sys.__stdout__, flush=True)
                rec = kept
            else:
                rec = dict(note="weighed meanwhile by another share", seconds=0)
            if background.startswith(planets_path("validate_backgrounds")) and os.path.exists(background):
                os.remove(background)
            shutil.rmtree(cache_of(r), ignore_errors=True)
            ahead[i] = None
            # the device memory each candidate cached handed back before the next
            if likelihoods == "gpu":
                torch.cuda.empty_cache()
            print("%4d/%d %-16s %s (%d s)" % (i + 1, len(todo), r["label"], "FPP %.4f NFPP %.5f" % (rec["fpp"], rec["nfpp"]) if "fpp" in rec else rec["note"],
                                               rec["seconds"]), file=sys.__stdout__, flush=True)
    os.chdir(home)
    shutil.rmtree(work, ignore_errors=True)
    if not whole:
        # what was fetched ahead for the next pass to fetch again
        for r in todo[i:i + 4]:
            shutil.rmtree(cache_of(r), ignore_errors=True)
        print("the pass ends at candidate %d of %d" % (i, len(todo)), file=sys.__stdout__, flush=True)
        if ended:
            sys.exit(3)
        return
    print("share done: %d candidates" % len(todo), file=sys.__stdout__, flush=True)
    if benchmark and part is None:
        planets_validation_benchmark(again)


# the least share of what a mission's benchmark passes at even odds that must be planets for its candidates to enter the decisions
planets_MISSION_PURITY = 0.9


def planets_mission_scored(source):
    """Whether the candidates of a mission's table enter the decisions: 90 per cent of its benchmark's settled candidates are weighed and the share it passes of its planets stands at planets_MISSION_PURITY or more of that share and the share it passes of its false positives together (planets_validation_benchmark)."""
    d = planets_load_json(os.path.join(planets_RESULTS, "validation_benchmark_%s.json" % source))
    if not d:
        return False
    p, f = d["planets"], d["false_positives"]
    drawn, weighed = p["drawn"] + f["drawn"], p["weighed"] + f["weighed"]
    if not drawn or weighed < 0.9 * drawn or not p["validated"]:
        return False
    return p["share"] / (p["share"] + f["share"]) >= planets_MISSION_PURITY


# the candidates of settled fate each control reads: its name, its source, the folders under RESULTS that hold their records and what marks its open candidates' labels
planets_CONTROL_POOLS = (("TOI", "toi", ("validate_benchmark", "validate_benchmark_again"), ("TOI-", "CTOI-")), ("Kepler", "koi", ("validate_benchmark_koi",), ("KOI-",)), ("K2", "k2", ("validate_benchmark_k2",), ("EPIC-",)))
planets_CONTROL_GROUPS = dict(CP="planets", KP="planets", FP="false_positives", FA="false_positives")
# the ways a dip may be another star's, by TRICERATOPS's scenarios
planets_SCENARIO_FAMILIES = dict(nearby=("NTP", "NEB", "NEBx2P"), companion=("SEB", "SEBx2P"), target=planets_TARGET_BINARIES, background=("DEB", "DEBx2P", "BEB", "BEBx2P"))
# the limits of a validation's two probabilities tried, and the bands of each column the settled candidates are read in
planets_CONTROL_LIMITS = ((0.015, 0.001), (0.03, 0.001), (0.05, 0.001), (0.1, 0.001), (0.2, 0.001), (0.015, 0.003), (0.05, 0.003), (0.1, 0.003), (0.1, 0.01))
planets_CONTROL_STRATA = (("signal-to-noise", "Planet SNR", (0.0, 10.0, 15.0, 20.0, 50.0, 1e9)), ("radius", "Planet Radius (R_Earth)", (0.0, 1.5, 2.5, 4.0, 8.0, 16.0, 1e9)), ("period", "Period (days)", (0.0, 1.0, 3.0, 10.0, 30.0, 1e9)), ("magnitude", "TESS Mag", (0.0, 9.0, 11.0, 12.0, 13.0, 99.0)))
# the floors of the fold's dip and of the noise ratio tried
planets_CONTROL_DIPS, planets_CONTROL_RATIOS = (5.0, 7.1, 10.0, 15.0, 20.0), (1.25, 1.5, 2.0, 2.5, 3.0, 4.0)


def planets_control_decision(v, x, events):
    """A validation record V of the candidate row X as the decision now stands on ten runs, its fold's floor beside it (planets_fold_fault): (status, reason)."""
    label = v.get("label") or "TOI-" + str(v.get("toi"))
    status, reason, _ = planets_validation_decision(dict(v, runs=10), x, None, events)
    fault = planets_fold_fault(v, label) if status in ("new", "likely") else ""
    return ("rejected", fault) if fault else (status, reason)


def planets_stratum(value, edges):
    """The band of EDGES a value falls in, as text; unknown where it is not a number within them."""
    return next(("%g-%g" % (a, b) for a, b in zip(edges, edges[1:]) if a <= value < b), "unknown")


def planets_controls():
    """What the decision does, read from the root's records with nothing weighed, to RESULTS/controls.json. For the settled candidates of each mission (planets_CONTROL_POOLS), by fate: what the decision makes of them on ten runs and why it turns them down; the same by band of signal-to-noise and of each column of planets_CONTROL_STRATA, each band beside what it makes of the open candidates there; what each of the decision's tests does to those whose probabilities pass; how many it passes at each floor of the fold's dip and of the noise ratio, and at each pair of limits of the two probabilities with every other test kept; and how many pass only because a planet on an unresolved star counts as a planet. For the open candidates of each kind: how many are weighed and pass, what becomes of them and how strongly their folds show their dips; and for those under two Jupiter radii that do not pass, which way of a dip being another star's holds the most and how many would pass without it. What the difference images let through among the settled TOIs at each limit of how far off the star they may place a source (planets_IMAGE_OFF). In a root of the TESS stage, what the search's own rules keep (planets_search_controls). Returns it."""
    exo = {x["label"]: x for x in planets_exofop()}
    labelled = lambda v: v.get("label") or "TOI-" + str(v.get("toi"))
    read = lambda folder: [v for v in (planets_load_json(p) for p in glob.glob(os.path.join(planets_RESULTS, folder, "*.json")) if not p.endswith("_half.json")) if v and "fpp" in v and v.get("tic")]
    opened = [v for v in read("validate") if exo.get(labelled(v), {}).get("TFOPWG Disposition", "").strip() not in planets_CONTROL_GROUPS]
    pools = {}
    for name, source, folders, marks in planets_CONTROL_POOLS:
        recs = {}
        for folder in folders:
            for v in read(folder):
                recs.setdefault(labelled(v), v)
        if recs:
            pools[name] = (recs, marks)
    out = dict(finished=time.strftime("%Y-%m-%d %H:%M:%S"), pools={}, open={})
    likely = lambda f, n: f < planets_FPP_LIKELY and n < planets_NFPP_LIKELY
    every = opened + [v for recs, _ in pools.values() for v in recs.values()]
    events = planets_tce({v["tic"] for v in every if planets_source_cleared(v)[0] < 0.3})
    add = lambda d, key, n=1: d.__setitem__(key, d.get(key, 0) + n)
    for name, (recs, marks) in pools.items():
        d = dict(read=0, decision={}, turned_down={}, tests={}, bands={}, dips={}, ratios={}, limits={}, on_unresolved=dict(planets=0, false_positives=0))
        for label, v in recs.items():
            x = exo.get(label, {})
            g = planets_CONTROL_GROUPS.get(x.get("TFOPWG Disposition", "").strip())
            if not g:
                continue
            d["read"] += 1
            status, reason = planets_control_decision(v, x, events)
            add(d["decision"].setdefault(g, {}), status)
            if status not in ("new", "likely"):
                add(d["turned_down"].setdefault(g, {}), reason or "waiting for its runs")
            f, n = planets_source_cleared(v)
            if f < planets_FPP_VALID and n < planets_NFPP_VALID:
                add(d["tests"].setdefault(g, {}), reason or status)
                if not (v["fpp"] < planets_FPP_VALID and n < planets_NFPP_VALID):
                    d["on_unresolved"][g] += 1
            for title, col, edges in planets_CONTROL_STRATA:
                band = d["bands"].setdefault(title, {}).setdefault(planets_stratum(planets_num(x.get(col)), edges), {}).setdefault(g, [0, 0])
                band[0] += 1
                band[1] += status == "new"
            # the floors read on what the decision passes without the fold's own floor
            if planets_validation_decision(dict(v, runs=10), x, None, events)[0] == "new":
                dips, ratios = d["dips"].setdefault(g, {}), d["ratios"].setdefault(g, {})
                add(dips, "passed")
                if "dip_sigma" not in v:
                    add(dips, "unread")
                for s in planets_CONTROL_DIPS:
                    add(dips, "%g" % s, (v.get("dip_sigma") or 0.0) >= s)
                for s in planets_CONTROL_RATIOS:
                    add(ratios, "%g" % s, (v.get("noise_ratio") or 0.0) >= s)
            for fl, nl in planets_CONTROL_LIMITS:
                if f < fl and n < nl:
                    w = dict(v, fpp=0.0, nfpp=0.0, scenarios=None)
                    add(d["limits"].setdefault("%g %g" % (fl, nl), {}), g, planets_control_decision(w, x, events)[0] == "new")
        for v in opened:
            if labelled(v).startswith(marks):
                x = exo.get(labelled(v), {})
                status = planets_control_decision(v, x, events)[0]
                for title, col, edges in planets_CONTROL_STRATA:
                    band = d["bands"].setdefault(title, {}).setdefault(planets_stratum(planets_num(x.get(col)), edges), {}).setdefault("open", [0, 0, 0])
                    band[0] += 1
                    band[1] += status == "new"
                    band[2] += status == "likely"
        out["pools"][name] = d
    for v in opened:
        x = exo.get(labelled(v), {})
        d = out["open"].setdefault(labelled(v).split("-")[0], dict(weighed=0, passing=0, within_likely=0, fold_unread=0, decision={}, turned_down={}, dips={}, held_most={}, without={}))
        f, n = planets_source_cleared(v)
        d["weighed"] += 1
        d["passing"] += f < planets_FPP_VALID and n < planets_NFPP_VALID
        d["within_likely"] += likely(f, n)
        d["fold_unread"] += "dip_sigma" not in v
        status, reason = planets_control_decision(v, x, events)
        add(d["decision"], status)
        if status == "rejected" and reason != "not validated":
            add(d["turned_down"], reason)
        for s in planets_CONTROL_DIPS:
            add(d["dips"], "%g" % s, likely(f, n) and (v.get("dip_sigma") or 0.0) >= s)
        scen = v.get("scenarios")
        if scen and planets_num(x.get("Planet Radius (R_Earth)")) < 22.4 and not (f < planets_FPP_VALID and n < planets_NFPP_VALID):
            planet = sum(scen.get(k, 0.0) for k in planets_PLANET_SCENARIOS)
            shares = {k: sum(scen.get(s, 0.0) for s in ks) for k, ks in planets_SCENARIO_FAMILIES.items()}
            add(d["held_most"], max(shares, key=shares.get))
            for family in shares:
                total = planet + sum(y for k, y in shares.items() if k != family)
                near = 0.0 if family == "nearby" else shares["nearby"]
                add(d["without"], family, total > 0 and 1.0 - planet / total < planets_FPP_VALID and near / total < planets_NFPP_VALID)
    clear = [v for v in read("validate_clear") if planets_CONTROL_GROUPS.get(exo.get(labelled(v), {}).get("TFOPWG Disposition", "").strip())]
    if clear:
        out["images"] = {}
        passed = lambda f, n: f < planets_FPP_VALID and n < planets_NFPP_VALID
        for limit in (None, 25.0, 16.0, 9.0, 4.0):
            t = out["images"].setdefault("any place" if limit is None else "off the star by %g" % limit, {})
            for v in clear:
                g = planets_CONTROL_GROUPS[exo[labelled(v)]["TFOPWG Disposition"].strip()]
                s = v.get("source") or {}
                off = (s.get("chi2", 0.0) - s.get("star_chi2", 0.0)) / (s.get("factor") or 1.0)
                now = (planets_not_planet(v), v["nfpp"]) if limit is not None and off > limit else planets_source_cleared(v)
                e = t.setdefault(g, dict(read=0, gained=0, lost=0))
                was = passed(planets_not_planet(v), v["nfpp"])
                e["read"] += 1
                e["gained"] += passed(*now) and not was
                e["lost"] += was and not passed(*now)
    if os.path.exists(planets_path("tess.json")):
        out["search"] = planets_search_controls()
    archive_save(os.path.join(planets_RESULTS, "controls.json"), json.dumps(out, separators=(",", ":")).encode())
    for name, d in out["pools"].items():
        print("%-7s %4d read; %s; floors of the fold's dip %s" % (name, d["read"], d["decision"], d["dips"]), flush=True)
    for name, d in out["open"].items():
        print("%-5s %5d open weighed, %4d passing the probabilities, %s; held most by %s" % (name, d["weighed"], d["passing"], d["decision"], d["held_most"]), flush=True)
    return out


def planets_search_controls():
    """What the search's own rules keep in a root of the TESS stage, from the stored searches of its calibrations: of the transits laid in (planets_inject_search), the light curves upside down (planets_null_search) and the same stars right way up, each signal's numbers with the rules on the highest upside down and on the strongest transit set aside, how many past the other tests stand at each multiple of that highest (planets_TRANSIT_CEILING, planets_TRANSIT_NEW) and at each share left without the strongest transit (planets_TRANSIT_LEFT), by transits; on the stars searched both ways, how their highest signals lie against each other and by band; and for each multiple, the signals of the root's decisions there against what noise alone would leave, the upside-down survivors scaled to all the root's stars: the share of them noise can account for."""
    def reading(rec, i, g):
        keep = planets_TRANSIT_LEFT, planets_TRANSIT_CEILING
        ceiling = planets_transit_ceiling(rec, g)
        globals().update(planets_TRANSIT_LEFT=0.0, planets_TRANSIT_CEILING=0.0)
        try:
            other = planets_transit_fault(dict(rec, inverted_snr=1.0, inverted_snr_long=1.0), i, g)
        finally:
            globals().update(planets_TRANSIT_LEFT=keep[0], planets_TRANSIT_CEILING=keep[1])
        h = (planets_transit_alias(g) if (g["odd_even_sigma"] or 0.0) >= 3.0 or planets_transit_scatter(g) < 7.1 else None) or g
        return dict(other=other, ratio=g["snr"] / ceiling if ceiling and math.isfinite(ceiling) else 0.0, left=planets_transit_left(h), transits=len(h["events"]))
    laid, noise, real, both, past = [], [], [], [], []
    folder = os.path.join(planets_RESULTS, "transitsearch_injected")
    if os.path.isdir(folder):
        with os.scandir(folder) as it:
            for e in it:
                rec = planets_load_json(e.path) if e.name.endswith(".json") else None
                hit = planets_inject_found(rec) if rec and rec.get("injected") and not rec.get("note") else None
                if hit:
                    laid.append(reading(rec, hit[0], hit[1]))
    folder = os.path.join(planets_RESULTS, "transitsearch_inverted")
    if os.path.isdir(folder):
        with os.scandir(folder) as it:
            for e in it:
                rec = planets_load_json(e.path) if e.name.endswith(".json") else None
                if not rec or "inverted_snr" not in rec:
                    continue
                noise += [reading(rec, i, g) for i, g in enumerate(rec.get("signals", []))]
                up = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", e.name))
                real += [reading(up, i, g) for i, g in enumerate((up or {}).get("signals", [])) if "inverted_snr" in up]
                top = [g["snr"] for g in rec.get("signals", []) if not g.get("long")]
                both.append((rec["inverted_snr"], max(top) if top else 0.0))
                past += [g["snr"] / rec["inverted_snr"] for i, g in enumerate(rec.get("signals", [])) if not planets_transit_hopeless(rec, i, g) and rec["inverted_snr"]]
    clean = lambda x: [r for r in x if not r["other"]]
    multiples = (1.0, 1.1, 1.25, 1.5, 1.75, 2.0, 2.5, 3.0, 4.0)
    rules = dict(signals=dict(laid=len(laid), noise=len(noise), real=len(real)), past_the_other_tests=dict(laid=len(clean(laid)), noise=len(clean(noise)), real=len(clean(real))),
                 ceiling=[dict(multiple=F, laid=sum(r["ratio"] >= F for r in clean(laid)), noise=sum(r["ratio"] >= F for r in clean(noise)), real=sum(r["ratio"] >= F for r in clean(real))) for F in multiples],
                 left=[dict(below=L, laid=sum(r["left"] < L for r in clean(laid)), noise=sum(r["left"] < L for r in clean(noise)), real=sum(r["left"] < L for r in clean(real))) for L in (0.95, 0.9, 0.85, 0.8, 0.75)])
    out = dict(rules=rules, stars_both_ways=len(both))
    if both:
        up, down = np.array([x[0] for x in both]), np.array([x[1] for x in both])
        out["highest"] = dict(right_way_up=np.percentile(up, [5, 25, 50, 75, 95, 99]).round(2).tolist(), upside_down=np.percentile(down, [5, 25, 50, 75, 95, 99]).round(2).tolist())
        out["multiples"] = [dict(multiple=F, upside_down_over=int((down >= F * up).sum()), right_way_up_over=int((up >= F * down).sum())) for F in multiples]
        out["bands"] = [dict(band="%g-%g" % (lo, hi), upside_down=int(((down >= lo) & (down < hi)).sum()), right_way_up=int(((up >= lo) & (up < hi)).sum())) for lo, hi in ((9, 10), (10, 12), (12, 15), (15, 20), (20, 30), (30, 60), (60, 1e9))]
        with os.scandir(os.path.join(planets_RESULTS, "transitsearch")) as it:
            stars = sum(1 for e in it if e.name.endswith(".json"))
        ratios = {}
        for r in planets_transit_kept({}, read_only=True) or []:
            rec = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", archive_tag(r["name"]) + ".json")) if r.get("object") == "planet" else None
            k = int(r["label"].split()[-1]) - 1
            if rec and rec.get("inverted_snr") and k < len(rec.get("signals", [])):
                ratios.setdefault(r["status"], []).append(rec["signals"][k]["snr"] / rec["inverted_snr"])
        kept = [x for v in ratios.values() for x in v]
        out["noise_share"] = [dict(multiple=F, noise_scaled=round(sum(x >= F for x in past) * stars / len(both), 1), signals=sum(x >= F for x in kept), share=round(sum(x >= F for x in past) * stars / len(both) / max(sum(x >= F for x in kept), 1), 3)) for F in multiples]
        out["stars"] = stars
    return out


def planets_validation_scores():
    """Every benchmark the root holds scored (planets_validation_benchmark): TESS's two and Kepler's and K2's, which their candidates' place in the decisions rests on (planets_mission_scored)."""
    for source, again, folder in (("toi", False, "validate_benchmark"), ("toi", True, "validate_benchmark_again"), ("koi", False, "validate_benchmark_koi"), ("k2", False, "validate_benchmark_k2")):
        if os.path.exists(os.path.join(planets_RESULTS, folder, "labels.csv")):
            print(folder, flush=True)
            planets_validation_benchmark(again, source)


def planets_indicator_control():
    """How often an activity indicator holds power at a known planet's period, the control on planets_INDICATOR_TOP, to RESULTS/indicator_control.json: for the archive's planets of the root's stars with thirty velocities or more, each indicator's power within 5 per cent of the planet's period, the chance of that power so near that one period rather than anywhere, and whether the indicator's own highest peak lies within planets_INDICATOR_TOP of it. Ends between stars where a long search would, with exit status 3."""
    known = {}
    for r in planets_read(os.path.join(planets_RESULTS, "signals.csv")):
        if r["kind"] == "known" and r["P"] and float(r["P"]) > 1.0:
            known.setdefault(r["name"], []).append(float(r["P"]))
    names = sorted(known)
    bank, raw, dace = planets_bank_series(set(names)), planets_bank_raw(set(names)), planets_dace_series(set(names))
    path = os.path.join(planets_RESULTS, "indicator_control.json")
    out = planets_load_json(path) or dict(stars={})
    for name in names:
        if name in out["stars"] or len(bank.get(name, [])) < 30:
            continue
        if planets_search_ends():
            sys.exit(3)
        try:
            res = planets_vet_star(name, known[name], bank.get(name, []), raw.get(name, []), dace.get(name, {}))
        except Exception as exc:
            print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:160]), flush=True)
            continue
        first = next(iter(res["sets"].values()))
        local = lambda z, P: min(1.0, max(1.0, 0.1 / P * first["span"]) * (1.0 - z) ** (0.5 * (first["n"] - 3)))
        out["stars"][name] = dict(nights=first["n"], span_d=first["span"], periods={"%g" % P: {k: dict(power=r["%g" % P]["power"], chance=local(r["%g" % P]["power"], P), top_d=r["top_d"], at_top=abs(r["top_d"] / P - 1.0) < planets_INDICATOR_TOP) for k, r in res["indicators"].items() if r and "%g" % P in r} for P in known[name]})
        archive_save(path, json.dumps(out, separators=(",", ":")).encode())
    rows = [x for s in out["stars"].values() for p in s["periods"].values() for x in p.values()]
    out["summary"] = dict(readings=len(rows), at_top=sum(x["at_top"] for x in rows), chance_below_01=sum(x["chance"] < 0.01 for x in rows))
    archive_save(path, json.dumps(out, separators=(",", ":")).encode())
    print(out["summary"], flush=True)


def planets_strict_test(t, y, e, g, P, others, draws=200, seed=5):
    """Whether a velocity signal is strictly periodic, as Hara et al. (2022) ask: the sinusoid at P in the velocities Y at the times T with errors E, offsets for each of G and sinusoids at OTHERS taken out, fitted with a Gaussian window over a grid of frequencies about its own, of centres and of widths, against the same sinusoid with no window: the chi-square the window gains, the sinusoid's own, the scale the fit leaves, and the gain's false-alarm level against DRAWS strict sinusoids of its amplitude in the same noise."""
    t = t - t.mean()
    rng = np.random.default_rng(seed)
    span = float(t.max() - t.min())
    base = [(g == k).astype(float) for k in np.unique(g)]
    for Q in others:
        base += [np.cos(2 * np.pi * t / Q), np.sin(2 * np.pi * t / Q)]
    q = np.linalg.qr(np.column_stack(base) / e[:, None])[0]
    white = y / e
    white = white - q @ (q.T @ white)
    freqs = 1.0 / P + np.linspace(-1.0, 1.0, 21) / span
    freqs = freqs[freqs > 0]
    W = np.exp(-0.5 * (t[None, None, :] - np.linspace(t.min(), t.max(), 15)[None, :, None]) ** 2 / (span * np.array([0.05, 0.08, 0.12, 0.18, 0.25, 0.35, 0.5, 0.7, 1.0]))[:, None, None] ** 2)

    def basis(window):
        C = np.array([window * np.cos(2 * np.pi * f * t)[None, None, :] / e for f in freqs]).reshape(-1, len(t))
        S = np.array([window * np.sin(2 * np.pi * f * t)[None, None, :] / e for f in freqs]).reshape(-1, len(t))
        C, S = C - (C @ q) @ q.T, S - (S @ q) @ q.T
        cc, ss, cs = (C * C).sum(1), (S * S).sum(1), (C * S).sum(1)
        return C, S, cc, ss, cs, np.maximum(cc * ss - cs * cs, 1e-12)
    win, plain = basis(W), basis(np.ones((1, 1, len(t))))

    def power(b, Y):
        a_, b_ = b[0] @ Y.T, b[1] @ Y.T
        return (b[3][:, None] * a_ * a_ - 2.0 * b[4][:, None] * a_ * b_ + b[2][:, None] * b_ * b_) / b[5][:, None]
    top = power(plain, white[None, :])[:, 0]
    i = int(np.argmax(top))
    C0, S0, cc0, ss0, cs0, det0 = plain
    a0, b0 = C0[i] @ white, S0[i] @ white
    A, B = (ss0[i] * a0 - cs0[i] * b0) / det0[i], (cc0[i] * b0 - cs0[i] * a0) / det0[i]
    resid = white - A * C0[i] - B * S0[i]
    scale = max(float(np.sum(resid ** 2)) / max(len(t) - q.shape[1] - 2, 1), 1.0)
    noise = rng.standard_normal((draws, len(t))) * math.sqrt(scale)
    noise = noise - (noise @ q) @ q.T
    Y = A * C0[i] + B * S0[i] + noise
    sim = power(win, Y).max(0) - power(plain, Y).max(0)
    gain = float(power(win, white[None, :]).max() - top[i])
    return dict(gain=round(gain, 1), strict=round(float(top[i]), 1), scale=round(scale, 2), level=round((1.0 + float((sim >= gain).sum())) / (1.0 + draws), 4), null_50=round(float(np.median(sim)), 1), null_99=round(float(np.percentile(sim, 99)), 1), nights=len(t))


def planets_strict(part=None):
    """The strict-periodicity test (planets_strict_test) tried on the archive's planets of the root's stars, on its new bodies of the velocities and on the signals rejected for activity, to RESULTS/strict/<star>.json. No decision reads it: over the census the planets and the activity it was tried on did not part far enough for it to judge. PART takes the share K/N; the pass ends between stars where a long search would, with exit status 3."""
    wanted = {}
    for r in planets_read(os.path.join(planets_RESULTS, "signals.csv")):
        if r["kind"] == "known" and r["P"] and float(r["P"]) > 1.0:
            wanted.setdefault(r["name"], []).append(("known", float(r["P"])))
        elif r["kind"] in ("found", "eccentric") and (r["status"] == "new" or r["reason"] in ("activity indicator", "starspots", "rotation")):
            wanted.setdefault(r["name"], []).append(("%s %s" % (r["status"], r["reason"]), float(r["P"])))
    names = sorted(wanted)
    if part:
        k, n = (int(x) for x in part.split("/"))
        names = names[k::n]
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
    bank, dace = planets_bank_series(set(names)), planets_dace_series(set(names))
    folder = os.path.join(planets_RESULTS, "strict")
    os.makedirs(folder, exist_ok=True)
    for name in names:
        kept = os.path.join(folder, archive_tag(name) + ".json")
        if os.path.exists(kept):
            continue
        if planets_search_ends():
            sys.exit(3)
        series, _ = planets_series(name, dace, bank, stars.get(name, {}).get("SpType"))
        x = planets_nightly(series) if series else np.zeros((0, 4))
        if len(x) < 30:
            continue
        t, y, e, g = x[:, 0], x[:, 1], x[:, 2], x[:, 3]
        periods = [p for _, p in wanted[name]]
        X = np.column_stack([(g == k).astype(float) for k in np.unique(g)] + [f(2 * np.pi * t / Q) for Q in periods for f in (np.cos, np.sin)])
        r_ = y - X @ np.linalg.lstsq(X / e[:, None], y / e, rcond=None)[0]
        s = np.hypot(e, math.sqrt(max(float(np.mean(r_ ** 2)) - float(np.mean(e ** 2)), 0.0)))
        line = dict(name=name, signals=[dict(planets_strict_test(t, y, s, g, P, [Q for Q in periods if abs(Q / P - 1.0) > 0.02]), kind=kind, P=P) for kind, P in wanted[name] if P <= 0.5 * float(t.max() - t.min())])
        archive_save(kept, json.dumps(line, separators=(",", ":")).encode())
        print("%-14s %s" % (name[:14], "; ".join("%s P %.3f gain %.1f level %.4f" % (x_["kind"][:12], x_["P"], x_["gain"], x_["level"]) for x_ in line["signals"])), flush=True)
    print("share done", flush=True)


# the false-alarm level and the most signals each search method of planets_sparse takes
planets_SPARSE_FAP, planets_SPARSE_MOST = 1e-3, 8


def planets_sparse_nights(s):
    """A star's nightly rows S (planets_nightly) as the census takes them, each series of three nights or more kept: the times, velocities, errors and series, the linear part with the indicators that correlate with the velocities, the outlying nights set aside."""
    from scipy.stats import pearsonr
    s = s.copy()
    inst = s[:, 3].astype(int)
    s = s[np.bincount(inst)[inst] >= 3]
    inst = s[:, 3].astype(int)
    t, v, e = s[:, 0], s[:, 1], s[:, 2]
    tt = (t - t.mean()) / 365.25
    cols = [np.ones_like(t)] + [(inst == k).astype(float) for k in np.unique(inst)[1:]]
    base = np.column_stack(cols + [tt] + ([tt ** 2] if float(t.max() - t.min()) >= 300 else []))
    r0 = v - base @ np.linalg.lstsq(base / e[:, None], v / e, rcond=None)[0]
    for j in range(s.shape[1] - 4):
        for k in np.unique(inst):
            m = inst == k
            x = s[m, 4 + j]
            sd = np.nanstd(x) if np.isfinite(x).sum() >= 3 else 0.0
            s[m, 4 + j] = (x - np.nanmedian(x)) / sd if sd > 0 else np.nan
    for j in range(s.shape[1] - 4):
        x = s[:, 4 + j]
        ok = np.isfinite(x)
        if ok.sum() >= max(0.5 * len(t), 12) and np.std(x[ok]) > 0 and pearsonr(r0[ok], x[ok])[1] < 0.01:
            cols.append(np.where(ok, x, 0.0))
    X = np.column_stack(cols)
    sig = np.hypot(e, 1.0)
    r_ = v - X @ np.linalg.lstsq(X / sig[:, None], v / sig, rcond=None)[0]
    Q = np.column_stack([np.ones_like(t), tt, tt ** 2])
    r_ = r_ - Q @ np.linalg.lstsq(Q / sig[:, None], r_ / sig, rcond=None)[0]
    dev = np.abs(r_ - np.median(r_))
    out = np.argsort(-dev)[:len(t) // 20]
    out = out[dev[out] > max(6.0 * 1.4826 * np.median(dev), 5.0 * np.median(e))]
    keep = np.setdiff1d(np.arange(len(t)), out)
    return t[keep], v[keep], e[keep], np.unique(inst[keep], return_inverse=True)[1], X[keep]


def planets_sparse_search(t, v, e, ii, X, freq, start=(), relax=False):
    """Sinusoids found one at a time in the residuals, from those of START, each at a false-alarm level below planets_SPARSE_FAP; with RELAX each new one followed by each looked for again with the others taken out, until none moves (Li and Stoica 1996). Returns the periods and the errors with their jitters."""
    span = float(t.max() - t.min())
    df = freq[1] - freq[0]
    design = lambda periods: [f(2 * np.pi * t / P) for P in periods for f in (np.cos, np.sin)]

    def resid(sig, periods):
        D = np.column_stack([X] + design(periods)) if periods else X
        return v - D @ np.linalg.lstsq(D / sig[:, None], v / sig, rcond=None)[0]

    def jitters(r):
        out = np.ones(int(ii.max()) + 1)
        for j in range(len(out)):
            m = ii == j
            if m.sum() >= 3:
                out[j] = max(math.sqrt(max(np.mean(r[m] ** 2) - np.mean(e[m] ** 2), 0.0)), 0.5)
        return np.hypot(e, out[ii])

    def peak(r, sig, periods):
        pw = gpu_host(gpu_gls(t, r, sig, freq))
        for Q in periods:
            pw[(np.abs(1.0 / freq / Q - 1.0) < 0.05) | (np.abs(freq - 1.0 / Q) < 1.0 / span)] = 0.0
        k = int(np.argmax(pw))
        grid = np.linspace(max(float(freq[k]) - df, 1e-5), float(freq[k]) + df, 41)
        return float(pw[k]), 1.0 / float(grid[int(np.argmax(gpu_host(gpu_gls(t, r, sig, grid))))])
    periods = list(start)
    sig = np.hypot(e, 1.0)
    while len(periods) < planets_SPARSE_MOST:
        sig = np.hypot(e, 1.0)
        for _ in range(2):
            sig = jitters(resid(sig, periods))
        r = resid(sig, periods)
        z, P = peak(r, sig, periods)
        if float(gpu_baluev(z, freq[-1], t, sig)) > planets_SPARSE_FAP:
            break
        periods.append(P)
        for _ in range(3 if relax else 0):
            moved = False
            for i in range(len(periods)):
                others = periods[:i] + periods[i + 1:]
                new = peak(resid(sig, others), sig, others)[1]
                moved = moved or abs(1.0 / new - 1.0 / periods[i]) > 1.0 / span
                periods[i] = new
            if not moved:
                break
    return periods, jitters(resid(np.hypot(e, 1.0), periods))


def planets_sparse_peaks(t, y, sig, X, freq, lam=4.5, iters=300):
    """The peaks of the l1 periodogram (Hara et al. 2017): the group lasso over the sinusoids at FREQ by accelerated proximal gradient on the device, offsets and indicators X taken out, its columns of unit size and its errors whitened, the penalty brought down to LAM in steps: the frequencies of its peaks, highest first, sixteen at most."""
    dev = gpu_DEVICE
    f32 = dict(dtype=torch.float32, device=dev)
    w = 1.0 / sig
    Q = torch.as_tensor(np.linalg.qr(X * w[:, None])[0], **f32)
    yw = torch.as_tensor(y * w, **f32)
    yw = yw - Q @ (Q.T @ yw)
    ph = 2 * math.pi * torch.as_tensor(freq, dtype=torch.float64, device=dev)[:, None] * torch.as_tensor(t - t.mean(), dtype=torch.float64, device=dev)[None, :]
    W = torch.as_tensor(w, **f32)
    C, S = torch.cos(ph).to(torch.float32) * W, torch.sin(ph).to(torch.float32) * W
    del ph
    C, S = C - (C @ Q) @ Q.T, S - (S @ Q) @ Q.T
    g = 1.0 / torch.sqrt(torch.clamp(0.5 * ((C * C).sum(1) + (S * S).sum(1)), min=1e-6))
    A = torch.cat([C * g[:, None], S * g[:, None]], 0)
    del C, S
    u = torch.randn(A.shape[1], generator=torch.Generator().manual_seed(3)).to(**f32)
    for _ in range(25):
        u = (u @ A.T) @ A
        u = u / u.norm()
    L = float(((u @ A.T) ** 2).sum()) * 1.02
    n = len(freq)
    x = torch.zeros(2 * n, **f32)
    z, tk = x.clone(), 1.0
    top = float(torch.sqrt(((A @ yw)[:n] ** 2 + (A @ yw)[n:] ** 2).max()))
    for lk in [lam * s for s in (8.0, 4.0, 2.0, 1.0) if lam * s < top] or [lam]:
        for _ in range(iters if lk == lam else iters // 3):
            step = z - (A @ (z @ A - yw)) / L
            mag = torch.sqrt(step[:n] ** 2 + step[n:] ** 2)
            shrink = torch.clamp(1.0 - (lk / L) / torch.clamp(mag, min=1e-12), min=0.0)
            new = torch.cat([step[:n] * shrink, step[n:] * shrink])
            tn = 0.5 * (1.0 + math.sqrt(1.0 + 4.0 * tk * tk))
            z = new + ((tk - 1.0) / tn) * (new - x)
            x, tk = new, tn
    amp = gpu_host(torch.sqrt(x[:n] ** 2 + x[n:] ** 2))
    if not (amp > 0).any():
        return []
    idx = np.where((amp[1:-1] >= amp[:-2]) & (amp[1:-1] >= amp[2:]) & (amp[1:-1] > 0.03 * float(amp.max())))[0] + 1
    return [float(freq[i]) for i in idx[np.argsort(-amp[idx])][:16]]


def planets_sparse_l1(t, v, e, ii, X, freq, sig0):
    """The l1 periodogram's peaks (planets_sparse_peaks), each kept where it stands at a false-alarm level below planets_SPARSE_FAP with the others taken out, the weakest dropped first, and the search one at a time over what is left: the periods, those the peaks gave and how many peaks there were."""
    span = float(t.max() - t.min())
    w = 1.0 / sig0
    y = v - X @ np.linalg.lstsq(X * w[:, None], v * w, rcond=None)[0]
    peaks = planets_sparse_peaks(t, y, sig0, X, np.arange(1.0 / (2.0 * span), 1.0 / 1.5, 1.0 / (4.0 * span)))
    kept = []
    for f in peaks:
        if all(abs(f - 1.0 / Q) >= 1.0 / span and abs(1.0 / f / Q - 1.0) >= 0.05 for Q in kept):
            kept.append(1.0 / f)
    design = lambda periods: [g(2 * np.pi * t / P) for P in periods for g in (np.cos, np.sin)]
    while kept:
        worst, level, moved = None, -1.0, []
        for i in range(len(kept)):
            others = kept[:i] + kept[i + 1:]
            D = np.column_stack([X] + design(others)) if others else X
            r = v - D @ np.linalg.lstsq(D / sig0[:, None], v / sig0, rcond=None)[0]
            near = np.abs(freq - 1.0 / kept[i]) < 1.0 / span
            pw = gpu_host(gpu_gls(t, r, sig0, freq[near])) if near.any() else np.zeros(1)
            k = int(np.argmax(pw))
            moved.append(1.0 / float(freq[near][k]) if near.any() else kept[i])
            fap = float(gpu_baluev(pw[k], freq[-1], t, sig0))
            if fap > level:
                worst, level = i, fap
        kept = moved
        if level <= planets_SPARSE_FAP:
            break
        kept.pop(worst)
    return planets_sparse_search(t, v, e, ii, X, freq, start=kept[:planets_SPARSE_MOST])[0], len(kept), len(peaks)


def planets_sparse(part=None):
    """The census's stars' sinusoids searched three ways, to RESULTS/sparse/stars[.partKofN].jsonl: one at a time in the residuals, the same relaxed after each new signal (RELAX, Li and Stoica 1996), and from the peaks of the l1 periodogram (Hara et al. 2017), then scored against the blind census on the archive's planets (planets_sparse_score). No decision reads it: over the census the three recover the same planets, and what the other methods add are the harmonics and aliases of known signals. PART takes the share K/N; the pass ends between stars where a long search would, with exit status 3."""
    names, stars, _, _ = planets_share(part)
    bank, dace = planets_bank_series(set(names)), planets_dace_series(set(names))
    folder = os.path.join(planets_RESULTS, "sparse")
    os.makedirs(folder, exist_ok=True)
    mark = (".part%sof%s" % tuple(part.split("/"))) if part else ""
    held = {r["name"] for f in glob.glob(os.path.join(folder, "stars*.jsonl")) for r in map(json.loads, open(f, encoding="utf-8"))}
    with open(os.path.join(folder, "stars%s.jsonl" % mark), "a", encoding="utf-8") as out:
        for name in names:
            if name in held:
                continue
            if planets_search_ends():
                sys.exit(3)
            rows, _ = planets_series(name, dace, bank, stars.get(name, {}).get("SpType"))
            if not rows:
                continue
            t, v, e, ii, X = planets_sparse_nights(planets_nightly(rows))
            if len(t) < 15 or float(t.max() - t.min()) < 100.0:
                continue
            freq = np.linspace(1.0 / (2.0 * float(t.max() - t.min())), 1.0 / 1.5, 40000)
            one, sig = planets_sparse_search(t, v, e, ii, X, freq)
            relax, _ = planets_sparse_search(t, v, e, ii, X, freq, relax=True)
            l1, n0, n1 = planets_sparse_l1(t, v, e, ii, X, freq, sig)
            line = dict(name=name, nights=len(t), span=float(t.max() - t.min()), one=[round(P, 4) for P in one], relax=[round(P, 4) for P in relax], l1=[round(P, 4) for P in l1], l1_kept=n0, l1_peaks=n1)
            out.write(json.dumps(line) + "\n")
            out.flush()
            print("%-14s %4d nights one %s relax %s l1 %s" % (name[:14], len(t), [round(P, 2) for P in one], [round(P, 2) for P in relax], [round(P, 2) for P in l1]), flush=True)
            if gpu_DEVICE.type == "cuda":
                torch.cuda.empty_cache()
    planets_sparse_score()


def planets_sparse_score():
    """The three search methods of planets_sparse scored on the archive's planets of the blind census's hosts against the blind census itself, each within 5 per cent or a resolution element of a planet's period, by the planet's expected signal-to-noise; the signals each finds that match none; to RESULTS/sparse/score.json."""
    folder = os.path.join(planets_RESULTS, "sparse")
    res = {r["name"]: r for f in glob.glob(os.path.join(folder, "stars*.jsonl")) for r in map(json.loads, open(f, encoding="utf-8"))}
    blind, found = {}, {}
    for f in glob.glob(os.path.join(planets_RESULTS, "census_blind", "stars*.jsonl")):
        blind.update({s["name"]: s for s in map(json.loads, open(f, encoding="utf-8"))})
    for f in glob.glob(os.path.join(planets_RESULTS, "census_blind", "signals*.csv")):
        for r in planets_read(f):
            if r["kind"] == "found":
                found.setdefault(r["name"], []).append(float(r["P"]))
    near = lambda P, Q, span: abs(P / Q - 1.0) < 0.05 or abs(1.0 / P - 1.0 / Q) < 1.0 / span
    methods = ("census", "one", "relax", "l1")
    score, extras, planets = {m: {} for m in methods}, dict.fromkeys(methods, 0), {}
    for name, r in res.items():
        b = blind.get(name)
        if not b:
            continue
        got = dict(census=found.get(name, []), one=r["one"], relax=r["relax"], l1=r["l1"])
        cat = b.get("catalogue", [])
        for c in cat:
            snr = c["K"] / (b["rms_resid"] * math.sqrt(2.0 / b["nights"])) if c["K"] == c["K"] and b["rms_resid"] > 0 else float("nan")
            if c["P"] < r["span"] and snr >= 5.0:
                band = "S/N 5-10" if snr < 10.0 else "S/N 10-20" if snr < 20.0 else "S/N 20+"
                planets[band] = planets.get(band, 0) + 1
                for m in methods:
                    score[m][band] = score[m].get(band, 0) + any(near(p, c["P"], r["span"]) for p in got[m])
        for m in methods:
            extras[m] += sum(not any(near(p, c["P"], r["span"]) for c in cat) for p in got[m])
    out = dict(stars=len(res), planets=planets, recovered=score, matching_none=extras)
    archive_save(os.path.join(folder, "score.json"), json.dumps(out, separators=(",", ":")).encode())
    print(out, flush=True)


def planets_recovery(pmin=None, pmax=None, stars=60, randoms=150, seed=3):
    """A range of periods tried before the search is carried over it, to RESULTS/recovery/<pmin>_<pmax>.json, in a folder of its own: the confirmed TOIs between PMIN and PMAX days that MAST's bucket holds light curves of, their own transits not set aside, searched over the range, how many it finds at their periods and how many pass its vetting; then RANDOMS random stars of each kind of light curve, right way up and upside down, how many signals past its vetting the range adds and how many of those noise alone gives, and the seconds it costs a star beside the search as it stands."""
    lo, hi = pmin or planets_TRANSIT_PMIN, pmax or 20.0
    kw = dict(pmin=min(lo, planets_TRANSIT_PMIN), pmax=20.0, longest=hi if hi > 20.0 else 0.0)
    folder = planets_path("recovery_cache")
    os.makedirs(folder, exist_ok=True)
    tics, _, kinds, _ = planets_tess_index()
    held = set(tics.tolist())
    rows = [r for r in planets_candidates("toi") if r["TFOPWG Disposition"].strip() in ("CP", "KP") and lo < planets_num(r["Period (days)"]) < hi and int(r["TIC ID"]) in held]
    random.Random(seed).shuffle(rows)
    out = dict(pmin=lo, pmax=hi, confirmed=dict(listed=len(rows), tried=0, found=0, set_aside=0, past_the_vetting=0), kinds={})
    into = "recovery_search"
    for r in rows[:stars]:
        tic, P = int(r["TIC ID"]), planets_num(r["Period (days)"])
        path, head = planets_tess_lightcurves(tic, folder, 0 if ((tics == tic) & (kinds == 0)).any() else 1)
        if not path:
            continue
        o = planets_transit_search("TIC %d" % tic, head.get("ra"), head.get("dec"), path=path, extra=dict(head, tic=tic), into=into, **kw)
        os.remove(path)
        got = [g for g in o["signals"] if abs(g["P"] / P - 1.0) < 0.01]
        out["confirmed"]["tried"] += 1
        out["confirmed"]["found"] += bool(got)
        out["confirmed"]["set_aside"] += any(abs(g["P"] / P - 1.0) < 0.01 for g in o["set_aside"])
        out["confirmed"]["past_the_vetting"] += bool(got) and not planets_transit_hopeless(o, o["signals"].index(got[0]), got[0])
    rng = random.Random(seed + 4)
    within = lambda g: g["P"] < planets_TRANSIT_PMIN or g["P"] >= 20.0
    for kind, label, least in ((0, "SPOC", 4), (1, "TESS-SPOC", 3)):
        ids, counts = np.unique(tics[kinds == kind], return_counts=True)
        d = out["kinds"].setdefault(label, dict(stars=0, right_way_up=0, upside_down=0, seconds_with=0.0, seconds_without=0.0))
        for tic in rng.sample(ids[counts >= least].tolist(), min(randoms, int((counts >= least).sum()))):
            path, head = planets_tess_lightcurves(int(tic), folder, kind)
            if not path:
                continue
            base = dict(path=path, mask=planets_transit_known(tic=int(tic)), extra=dict(head, tic=int(tic)), into=into)
            t0 = time.time()
            planets_transit_search("TIC %d" % tic, head.get("ra"), head.get("dec"), **base)
            t1 = time.time()
            o = planets_transit_search("TIC %d" % tic, head.get("ra"), head.get("dec"), **base, **kw)
            t2 = time.time()
            inv = planets_transit_search("TIC %d" % tic, head.get("ra"), head.get("dec"), invert=True, **base, **kw)
            os.remove(path)
            d["stars"] += 1
            d["seconds_without"] += t1 - t0
            d["seconds_with"] += t2 - t1
            d["right_way_up"] += sum(within(g) and not planets_transit_hopeless(o, i, g) for i, g in enumerate(o["signals"]))
            d["upside_down"] += sum(within(g) and not planets_transit_hopeless(inv, i, g) for i, g in enumerate(inv["signals"]))
    shutil.rmtree(folder, ignore_errors=True)
    shutil.rmtree(os.path.join(planets_RESULTS, into), ignore_errors=True)
    os.makedirs(os.path.join(planets_RESULTS, "recovery"), exist_ok=True)
    archive_save(os.path.join(planets_RESULTS, "recovery", "%g_%g.json" % (lo, hi)), json.dumps(out, separators=(",", ":")).encode())
    print(out, flush=True)


def planets_window_cost(stars=150, seed=5):
    """What the search's detrending costs a transit of each length, to RESULTS/window_cost.json: real light curves of the noise sample's stars (RESULTS/null_stars.json) given box transits at a signal-to-noise of 15, flattened by a running median over each window of days, the depth that survives, the scatter of means of a box's length at other times of the flattened flux, which holds its correlated noise, and the signal-to-noise those two give."""
    names = planets_load_json(os.path.join(planets_RESULTS, "null_stars.json")) or []
    folder = planets_path("window_cache")
    os.makedirs(folder, exist_ok=True)
    hours, windows = (2.0, 4.0, 6.0, 9.0, 12.0), (1.0, 1.5, 2.0, 3.0, 4.0)
    rng = np.random.default_rng(seed)
    table, done = {(h, w): [] for h in hours for w in windows}, 0
    for tag in names:
        if done >= stars:
            break
        rec = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", tag + ".json"))
        if not rec or rec.get("note") or not rec.get("tic") or (rec.get("rstar") or 1.0) > 2.0:
            continue
        path, _ = planets_tess_lightcurves(int(rec["tic"]), folder, 0 if rec.get("light_curves") == "SPOC" else 1)
        base = planets_transit_flux(path) if path else None
        if base is None:
            continue
        with np.load(path) as d:
            arrays = {k: d[k] for k in d.files}
        for h in hours:
            D, P = h / 24.0, float(rng.uniform(11.0, 19.0))
            c = float(arrays["time"].min()) + rng.uniform(0.0, P)
            inn = np.abs(((base[0] - c) / P + 0.5) % 1.0 * P - 0.5 * P) < 0.5 * D
            if inn.sum() < 6:
                continue
            depth = 15.0 * base[2] / math.sqrt(inn.sum())
            laid = os.path.join(folder, "laid.npz")
            np.savez(laid, **dict(arrays, flux=arrays["flux"] * np.where(np.abs(((arrays["time"] - c) / P + 0.5) % 1.0 * P - 0.5 * P) < 0.5 * D, 1.0 - depth, 1.0)))
            for w in windows:
                t, f = planets_transit_flux(laid, False, w)[:2]
                y = ((t - c) / P + 0.5) % 1.0 * P - 0.5 * P
                inside, far = np.abs(y) < 0.5 * D, np.abs(y) > 1.5 * D
                if inside.sum() < 3 or far.sum() < 50:
                    continue
                width = max(1, int(round(D / float(np.median(np.diff(t))))))
                means = np.convolve(f[far] - np.mean(f[far]), np.ones(width) / width, mode="valid")[::max(1, width // 2)]
                box = 1.4826 * float(np.median(np.abs(means - np.median(means))))
                kept = float(np.mean(f[far]) - np.mean(f[inside])) / depth
                table[(h, w)].append((kept, box, kept * depth / (box / math.sqrt(max(1.0, inside.sum() / width))) if box > 0 else 0.0))
        os.remove(path)
        done += 1
    shutil.rmtree(folder, ignore_errors=True)
    out = dict(stars=done, cost=[dict(hours=h, window_d=w, depth_kept=round(float(np.median([x[0] for x in table[(h, w)]])), 3), noise_ppm=round(1e6 * float(np.median([x[1] for x in table[(h, w)]])), 1), snr=round(float(np.median([x[2] for x in table[(h, w)]])), 1)) for h in hours for w in windows if table[(h, w)]])
    archive_save(os.path.join(planets_RESULTS, "window_cost.json"), json.dumps(out, separators=(",", ":")).encode())
    print(out, flush=True)


def planets_transit_figure(name, inverted=False):
    """Each signal past the search's vetting of the star NAME drawn from its light curves, to RESULTS/figures/<star>_<k>.png: each sector flattened by a running median over three durations or 0.75 days, folded whole and about the transit with its odd and even transits apart, and the flux as it was read; with INVERTED the stored search of the light curves upside down, their flux turned over as it read them. Returns the figures."""
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    from astropy.io import fits
    found = planets_load_json(os.path.join(planets_RESULTS, "transitsearch_inverted" if inverted else "transitsearch", archive_tag(name) + ".json"))
    if not found:
        print("%s: no stored search" % name, flush=True)
        return []
    folder = os.path.join(planets_RESULTS, "figures")
    os.makedirs(folder, exist_ok=True)

    def binned(ph, f, edges):
        i = np.digitize(ph, edges) - 1
        ok = (i >= 0) & (i < len(edges) - 1)
        n = np.bincount(i[ok], minlength=len(edges) - 1)
        m = np.bincount(i[ok], f[ok], len(edges) - 1) / np.maximum(n, 1)
        s = np.bincount(i[ok], f[ok] ** 2, len(edges) - 1) / np.maximum(n, 1)
        return 0.5 * (edges[1:] + edges[:-1]), np.where(n > 0, m, np.nan), np.sqrt(np.maximum(s - m ** 2, 0.0) / np.maximum(n, 1))
    out = []
    for i, g in enumerate(found.get("signals", [])):
        if planets_transit_hopeless(found, i, g):
            continue
        k = i + 1
        v = planets_load_json(os.path.join(planets_RESULTS, "validate_transits", archive_tag(name, k) + ".json")) or {}
        P, t0, dur = g["P"], g["t0_btjd"], g["duration_h"] / 24.0
        cand = planets_transit_candidate(found["name"], k, g, found.get("tic") or v.get("tic"), found.get("rstar") or v.get("star_radius"))
        cache = planets_path("validate_cache", archive_tag(name) + "_figure")
        try:
            files = planets_validate_fetch(cand, cache) or {}
            raw = []
            for s in sorted(files):
                with fits.open(files[s]) as h:
                    got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
                if got is not None:
                    raw.append((got[0], 2.0 - got[1] if inverted else got[1]))
        finally:
            shutil.rmtree(cache, ignore_errors=True)
        if not raw:
            continue
        fig, ax = plt.subplots(3, 1, figsize=(11, 9))
        tt, ff = [], []
        for t, f in raw:
            ax[2].plot(t, f, ".", ms=0.5, color="0.5")
            width = max(3, int(round(max(3.0 * dur, 0.75) / max(float(np.median(np.diff(t))), 1e-4))) | 1)
            tt.append(t)
            ff.append(f / gpu_host(gpu_running_median(f[None, :], width))[0])
        t, f = np.concatenate(tt), np.concatenate(ff)
        clip = np.abs(f - 1.0) < 6.0 * 1.4826 * np.median(np.abs(f - np.median(f)))
        t, f = t[clip], f[clip]
        ph = ((t - t0) / P + 0.5) % 1.0 - 0.5
        x, y, e = binned(ph, f, np.linspace(-0.5, 0.5, 201))
        ax[0].errorbar(x, (y - 1.0) * 1e6, e * 1e6, fmt=".", color="k", ms=3, lw=0.5)
        ax[0].set_xlim(-0.5, 0.5)
        ax[0].set_ylabel("ppm, whole orbit")
        for side in (-0.5, 0.5):
            ax[0].axvline(side * dur / P, color="r", lw=0.5)
        span = min(3.0 * dur / P, 0.5)
        epochs = np.round((t - t0) / P)
        for sel, c, lab in ((epochs % 2 == 0, "tab:blue", "even"), (epochs % 2 == 1, "tab:orange", "odd")):
            x, y, e = binned(ph[sel], f[sel], np.linspace(-span, span, 61))
            ax[1].errorbar(x * P * 24.0, (y - 1.0) * 1e6, e * 1e6, fmt=".-", color=c, ms=3, lw=0.5, label=lab)
        ax[1].legend()
        ax[1].set_ylabel("ppm about the transit")
        ax[1].set_xlabel("hours from mid-transit")
        ax[2].set_ylabel("flux, %s" % (found.get("light_curves") or v.get("light_curves", "")))
        ax[0].set_title("%s signal %d%s: P %.5f d, %.0f ppm, %.1f h, S/N %s (%.2f of the highest the other way up), %s transits, FPP %s NFPP %s" % (name, k, " upside down" if inverted else "", P, g["depth_ppm"], g["duration_h"], g["snr"], g["snr"] / (found.get("inverted_snr") or float("nan")), g["transits"], v.get("fpp"), v.get("nfpp")), fontsize=8)
        path = os.path.join(folder, archive_tag(name, k) + ("_upside_down" if inverted else "") + ".png")
        fig.tight_layout()
        fig.savefig(path, dpi=90)
        plt.close(fig)
        out.append(path)
        print(path, flush=True)
    return out


def planets_dip(name, T, tic=None):
    """One lone dip of the star NAME at T (BTJD) read closely, to RESULTS/dips/<star>_<T>.json and a figure beside it: each of the star's light curves of the sector holding it, SPOC's, TESS-SPOC's and QLP's, its corrected and aperture flux, background and centroids about the dip and their changes there against their scatter, its flagged points and its width; the TIC stars within two arcminutes with the eclipse each would need to give it; and where the star's orbits have been sampled, how far each planet's nearest conjunction lies from it in its own error. Returns the record."""
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    from astropy.io import fits
    tag = archive_tag(name)
    if tic is None:
        for folder in ("transitsearch", "singles"):
            tic = (planets_load_json(os.path.join(planets_RESULTS, folder, tag + ".json")) or {}).get("tic") or tic
    tic = int(tic)
    tics, secs, kinds, sectors = planets_tess_index()
    sector = next((s for s, v in sectors.items() if v.get("t0", 1e9) - 56999.5 - 1.0 <= T <= v.get("t1", -1e9) - 56999.5 + 1.0), None)
    a, b = int(np.searchsorted(tics, tic)), int(np.searchsorted(tics, tic, side="right"))
    held = {k for s, k in zip(secs[a:b].tolist(), kinds[a:b].tolist()) if s == sector}
    if sector in planets_qlp_sectors(tic):
        held.add(2)
    out = dict(name=name, tic=tic, T_btjd=T, sector=sector, products=[], conjunctions=[])
    folder = os.path.join(planets_RESULTS, "dips")
    os.makedirs(folder, exist_ok=True)
    head = {}
    for kind, label in ((0, "SPOC"), (1, "TESS-SPOC"), (2, "QLP")):
        if kind not in held:
            continue
        raw = archive_get(planets_TESS_BUCKET + planets_tess_key(tic, sector, kind, sectors), timeout=300, soft=True)
        if not raw:
            continue
        with fits.open(io.BytesIO(raw)) as h:
            d, H = h["LIGHTCURVE"].data, h[0].header
            head = head or dict(ra=archive_num(H.get("RA_OBJ")), dec=archive_num(H.get("DEC_OBJ")), tmag=archive_num(H.get("TESSMAG")))
            col = lambda c: np.asarray(d[c], float) if c in d.columns.names else np.full(len(d), np.nan)
            flux = col(next(c for c in ("PDCSAP_FLUX", "DET_FLUX", "KSPSAP_FLUX", "SAP_FLUX") if c in d.columns.names))
            t, sap, bkg, cx, cy, q = col("TIME"), col("SAP_FLUX"), col("SAP_BKG"), col("MOM_CENTR1"), col("MOM_CENTR2"), np.asarray(d["QUALITY"])
        win = np.isfinite(t) & (np.abs(t - T) < 1.5)
        good = win & np.isfinite(flux)
        inn, ring = good & (np.abs(t - T) < 0.1), good & (np.abs(t - T) > 0.3)
        if not (inn.sum() and ring.sum()):
            out["products"].append(dict(light_curve=label, note="no points at the dip"))
            continue
        sd = lambda x: 1.4826 * float(np.nanmedian(np.abs(x[ring] - np.nanmedian(x[ring]))))
        rel = lambda x: float((np.nanmedian(x[ring]) - np.nanmedian(x[inn])) / np.nanmedian(x[ring]))
        lo = good & (np.abs(t - T) < 0.6) & (flux < np.nanmedian(flux[ring]) - 3.0 * sd(flux))
        out["products"].append(dict(light_curve=label, cadence_min=round(float(np.nanmedian(np.diff(t))) * 1440.0, 1), points=int(inn.sum()), flagged=int((inn & (q != 0)).sum()), flags=sorted({int(x) for x in q[inn] if x}), depth_ppm=round(1e6 * rel(flux)), depth_aperture_ppm=round(1e6 * rel(sap)) if np.isfinite(sap[inn]).any() else None,
                                    noise_ppm=round(1e6 * sd(flux) / float(np.nanmedian(flux[ring]))), background_change=round(float(np.nanmedian(bkg[inn]) - np.nanmedian(bkg[ring])), 2) if np.isfinite(bkg[inn]).any() else None, background_scatter=round(sd(bkg), 2) if np.isfinite(bkg[ring]).any() else None,
                                    centroid_shift_px=[round(float(np.nanmedian(c[inn]) - np.nanmedian(c[ring])), 4) if np.isfinite(c[inn]).any() else None for c in (cx, cy)], centroid_scatter_px=[round(sd(c), 4) if np.isfinite(c[ring]).any() else None for c in (cx, cy)], width_h=round(float((t[lo].max() - t[lo].min()) * 24.0), 2) if lo.sum() >= 2 else None))
        fig, ax = plt.subplots(4, 1, figsize=(8, 8), sharex=True)
        for axis, y, title in zip(ax, (flux / np.nanmedian(flux[ring]), sap / np.nanmedian(sap[ring]), bkg), ("flux", "aperture flux", "background")):
            axis.plot(t[win] - T, y[win], ".", ms=2, color="k")
            axis.plot((t[win] - T)[q[win] != 0], y[win][q[win] != 0], "x", ms=4, color="C3")
            axis.set_ylabel(title, fontsize=8)
        ax[3].plot(t[win] - T, cx[win] - np.nanmedian(cx[ring]), ".", ms=2, label="column")
        ax[3].plot(t[win] - T, cy[win] - np.nanmedian(cy[ring]), ".", ms=2, label="row")
        ax[3].legend(fontsize=7)
        ax[3].set_ylabel("centroid (pixels)", fontsize=8)
        ax[3].set_xlabel("days from BTJD %.3f" % T)
        fig.suptitle("%s (TIC %d), sector %s, %s" % (name, tic, sector, label), fontsize=9)
        fig.tight_layout()
        fig.savefig(os.path.join(folder, "%s_%.2f_%s.png" % (tag, T, label)), dpi=110)
        plt.close(fig)
    depths = [p["depth_ppm"] for p in out["products"] if p.get("depth_ppm") is not None]
    try:
        cone = planets_tic_real(tic)
        me = [s for s in cone if str(s["ID"]) == str(tic)]
        tm = float(me[0]["Tmag"]) if me else head.get("tmag", float("nan"))
        near = []
        for s in cone:
            if str(s["ID"]) != str(tic) and np.isfinite(float(s["Tmag"])) and head:
                sep = math.hypot((float(s["ra"]) - head["ra"]) * math.cos(math.radians(head["dec"])), float(s["dec"]) - head["dec"]) * 3600.0
                if sep < 120.0:
                    near.append(dict(tic=int(s["ID"]), sep_arcsec=round(sep, 1), dtmag=round(float(s["Tmag"]) - tm, 2), eclipse_needed=round(max(depths or [0.0]) / 1e6 * 10 ** (0.4 * (float(s["Tmag"]) - tm)), 4)))
        out["neighbours"] = sorted(near, key=lambda x: x["eclipse_needed"])[:8]
    except Exception as exc:
        out["neighbours_error"] = "%s: %s" % (type(exc).__name__, str(exc)[:160])
    o = planets_load_json(os.path.join(planets_RESULTS, "orbits", tag + ".json"))
    for p in (o or {}).get("planets", []):
        if "tc_mjd" in p:
            P, sP, Tc, sT = p["P"][0], 0.5 * (p["P"][2] - p["P"][1]), p["tc_mjd"][0] - 56999.5, 0.5 * (p["tc_mjd"][2] - p["tc_mjd"][1])
            n = round((T - Tc) / P)
            error = math.hypot(sT, n * sP)
            out["conjunctions"].append(dict(P=P, nearest_btjd=round(Tc + n * P, 3), error_d=round(error, 3), sigma_off=round(abs(T - Tc - n * P) / error, 2) if error > 0 else None))
    archive_save(os.path.join(folder, "%s_%.2f.json" % (tag, T)), json.dumps(out, separators=(",", ":")).encode())
    print(json.dumps(out, indent=1), flush=True)
    return out


def planets_companions_read():
    """The root's new companions one by one, to RESULTS/companions_read.csv: how many cycles its span holds of each orbit and on how many nights, its period, K, eccentricity and least mass, Gaia DR3's marks and published orbits of the star, whether the spectroscopic binary catalogue SB9 or the Geneva-Copenhagen survey holds it, and the weighing its mass rests on, with that weighing's acceptance and the periods it allows. A list for reading: no decision takes it."""
    rows = [r for r in planets_read(os.path.join(planets_RESULTS, "signals.csv")) if r["kind"] == "companion" and r["status"] == "new"]
    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}

    def held(catalogue, ra, dec):
        text = archive_vizier_text("-source=%s&-c=%.5f%+.5f&-c.rs=10&-out.max=5&-out.form=|&-mime=csv" % (catalogue, ra, dec))
        return "" if text is None else max(len([x for x in text.splitlines() if x and not x.startswith("#")]) - 3, 0)
    out = []
    for r in rows:
        s = stars.get(r["name"], {})
        ra, dec = planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000"))
        P, span = planets_num(r["orbit_P"] or r["P"]), planets_num(r["span_d"])
        line = dict(name=r["name"], P_d=round(P, 3), P_lo=r["orbit_P_lo"], P_hi=r["orbit_P_hi"], cycles=round(span / P, 2) if P > 0 else "", nights=r["nights"], K_ms=r["K"], e=r["e"], msini_mearth=r["msini_mearth"], pma_snr=r.get("pma_snr", ""), second_test=r.get("second_test", ""))
        try:
            got = archive_tap("gaia", "SELECT source_id, phot_g_mean_mag, ruwe, non_single_star, rv_amplitude_robust, rv_nb_transits, rv_renormalised_gof, ipd_frac_multi_peak, parallax FROM gaiadr3.gaia_source WHERE CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', %.6f, %.6f, %.6f)) = 1 ORDER BY phot_g_mean_mag" % (ra, dec, 15.0 / 3600.0))
            g = got[0] if got else {}
            line.update({k: g.get(k, "") for k in ("ruwe", "non_single_star", "rv_amplitude_robust", "phot_g_mean_mag", "parallax")})
            if g.get("source_id"):
                line["gaia_orbits"] = "; ".join("%s %.1f d" % (x["nss_solution_type"], planets_num(x["period"])) for x in archive_tap("gaia", "SELECT nss_solution_type, period FROM gaiadr3.nss_two_body_orbit WHERE source_id = %s" % g["source_id"]))
        except Exception as exc:
            line["gaia_orbits"] = "unread: %s" % str(exc)[:80]
        line.update(sb9=held("B/sb9/main", ra, dec), gcs=held("V/130/gcs3", ra, dec))
        w = planets_load_json(os.path.join(planets_RESULTS, "weigh", archive_tag(r["name"]) + ".json"))
        if w:
            line.update(weigh_acceptance=round(w.get("acceptance", -1.0), 3), weigh_allowed=json.dumps(w.get("period_allowed")), weigh_mass_mjup=json.dumps([round(x, 1) for x in w["m2_mjup"]]), weigh_below_13=round(w["p_below_13mjup"], 2))
        out.append(line)
        print(line, flush=True)
    keys = list(dict.fromkeys(k for x in out for k in x))
    planets_write(os.path.join(planets_RESULTS, "companions_read.csv"), out, keys)


def planets_decision_dry(folder):
    """A whole decision of the root from its saved results with this file's code, the tables it writes written to FOLDER instead and set against the stored ones: the rows and decisions on either side and each decision that moves, to show what a change of the rules does before it counts."""
    os.makedirs(folder, exist_ok=True)
    real, written = planets_write, {}

    def write(path, rows, keys=None):
        written[os.path.basename(path)] = len(rows)
        return real(os.path.join(folder, os.path.basename(path)), rows, keys)
    globals()["planets_write"] = write
    try:
        planets_followup(1, True)
    finally:
        globals()["planets_write"] = real
    print("written", written, flush=True)
    key = lambda r: (r["name"], r["kind"], r["label"], r.get("P"))
    count = lambda rows: {k: sum(1 for r in rows if r.get("status") == k) for k in sorted({str(r.get("status")) for r in rows})}
    stored, again = (planets_read(os.path.join(x, "signals.csv")) for x in (planets_RESULTS, folder))
    print("stored: %d signals, %s" % (len(stored), count(stored)), flush=True)
    print("again: %d signals, %s" % (len(again), count(again)), flush=True)
    a, b = {key(r): r for r in stored}, {key(r): r for r in again}
    moved = [k for k in a if k in b and (a[k].get("status"), a[k].get("reason")) != (b[k].get("status"), b[k].get("reason"))]
    print("%d decisions moved, %d rows stored alone, %d rows again alone" % (len(moved), len(set(a) - set(b)), len(set(b) - set(a))), flush=True)
    for k in moved[:200]:
        print("  %s %s P %s: %s (%s) to %s (%s)" % (k[0], k[2], k[3], a[k].get("status"), a[k].get("reason"), b[k].get("status"), b[k].get("reason")), flush=True)


def planets_tess_progress():
    """The TESS stage's progress in a TESS root, read from the listing of its records and opening none: the stars its index holds by kind of light curve, those searched or noted, how many an hour over the last six hours, and the time left at that rate."""
    tics, _, kinds, _ = planets_tess_index()
    spoc = np.unique(tics[kinds == 0])
    ffi = np.setdiff1d(np.unique(tics[kinds == 1]), spoc)
    done, times = [], []
    with os.scandir(os.path.join(planets_RESULTS, "transitsearch")) as it:
        for e in it:
            if e.name.startswith("TIC_") and e.name.endswith(".json"):
                done.append(int(e.name[4:-5]))
                times.append(e.stat().st_mtime)
    done, times = np.array(done, np.int64), np.array(times)
    recent = done[times > time.time() - 6 * 3600]
    for label, ids in (("SPOC two-minute", spoc), ("full-frame alone", ffi)):
        n, rate = int(np.isin(done, ids).sum()), np.isin(recent, ids).sum() / 6.0
        print("%s: %d stars, %d searched or noted, %.0f an hour over the last six hours%s" % (label, len(ids), n, rate, ", %.1f days left at that rate" % ((len(ids) - n) / rate / 24.0) if rate else ""), flush=True)


def planets_validate_compare(label, draws=20000):
    """TRICERATOPS's probabilities of the candidate LABEL from its own code and from the device's (planets_validate_gpu), on the same light curves with the same draws, scenario by scenario with the time each took: the check on what that function puts in its place."""
    r = {x["label"]: x for x in planets_exofop()}[label]
    cache = planets_path("validate_cache", archive_tag(label) + "_compare")
    planets_validate_setup()
    try:
        files = planets_validate_fetch(r, cache)
        out = []
        for gpu in (False, True):
            if gpu:
                planets_validate_gpu()
            np.random.seed(5)
            t0 = time.time()
            out.append(planets_validate_one(r, draws, runs=1, cache=cache, files=files))
            print("%s: FPP %.3e NFPP %.3e in %.1f s" % ("the device's" if gpu else "TRICERATOPS's own", out[-1]["fpp"], out[-1]["nfpp"], time.time() - t0), flush=True)
    finally:
        shutil.rmtree(cache, ignore_errors=True)
    for s in out[0]["scenarios"]:
        print("   %-7s %.4e  %.4e" % (s, out[0]["scenarios"][s], out[1]["scenarios"][s]), flush=True)


# the sources of Gaia DR4's pre-release with published orbits: their names, their primaries' masses with errors, and those orbits
planets_DR4_KNOWN = {3937211745905473024: ("HD 114762", (0.83, 0.05), "P 83.9 d"), 1457486023639239296: ("Gaia-4", (0.644, 0.02), "P 571.3 d, e 0.36, 11.8 Jupiter masses"), 4318465066420528000: ("Gaia BH3", (0.76, 0.05), "P 4253 d, e 0.73, 34250 Jupiter masses")}


def planets_epochs_trial(path, reference=None):
    """The reading of Gaia DR4's epoch astrometry tried on ESA's pre-release, PATH its raw epoch table, to set its limits by before the release and to run again on it: each source's single-star parameters against ESA's fit where REFERENCE, a JSON file of them by source, is given; the orbit search on the sources with published orbits and on the others, which should hold none; the same table read a row a CCD; Gaia-4 b's published orbit in its own epochs, then turned half way, half an orbit on and at the wrong amplitude; orbits laid into the quiet sources at chosen significances and read with and without the orbit, for how often the verdicts come out wrong; each source with a published orbit weighed from its epochs, HD 114762 with velocities laid from its orbit; and Gaia-4's weighing held against velocities laid from its orbit, flat and weak."""
    from astropy.table import Table
    epochs = planets_epochs_read(path)
    print("%d sources" % len(epochs), flush=True)
    ref = json.load(open(reference)) if reference else {}
    name = lambda sid: planets_DR4_KNOWN[sid][0] if sid in planets_DR4_KNOWN else str(sid)
    print("source, transits; parallax and proper motions, ESA's beside where given; scatter, median error, reduced chi-square, excess noise", flush=True)
    for sid, d in epochs.items():
        c, _, r, chi = planets_epochs_star(d)
        p, er = ref.get(str(sid), {}).get("parameters"), ref.get(str(sid), {}).get("errors")
        print("%-20s %3d | %8.3f %s | %9.3f %s | %9.3f %s | %6.3f %6.3f | %8.2f | %.3f" % (name(sid), len(d["t"]), c[2], "%8.3f (%.3f)" % (p[2], er[2]) if p else "", c[3], "%9.3f" % p[3] if p else "", c[4], "%9.3f" % p[4] if p else "", np.std(r), np.median(d["e"]), chi / (len(r) - 5), d["excess_noise"]), flush=True)
    print("the orbit search", flush=True)
    rng = np.random.default_rng(11)
    for sid, d in epochs.items():
        c, _, r, chi = planets_epochs_star(d)
        o = planets_epochs_power(d)
        camp = planets_epochs_campbell(o, c[2], planets_DR4_KNOWN[sid][1][0] if sid in planets_DR4_KNOWN else None)
        null = [planets_epochs_power(d, shuffle=rng)["share"] for _ in range(20)]
        beta = max(float(np.std(null, ddof=1)) * math.sqrt(6.0) / math.pi, 1e-9)
        z = -(o["share"] - (float(np.mean(null)) - 0.5772 * beta)) / beta
        print("%-20s P %9.2f d e %.1f share %.3f (shuffled %.3f +- %.3f, false alarm %.1e) | a0 %7.3f mas, i %5.1f deg, %s | %s" % (name(sid), o["P"], o["e"], o["share"], float(np.mean(null)), float(np.std(null, ddof=1)), 1.0 if z > 700.0 else float(-math.expm1(-math.exp(z))), camp["a0_mas"], camp["incl_deg"], "%.1f Jupiter masses" % camp["m2_mjup"] if "m2_mjup" in camp else "", planets_DR4_KNOWN[sid][2] if sid in planets_DR4_KNOWN else ""), flush=True)
    t = Table.read(path, format="votable")
    flat = {c: [] for c in ("source_id", "transit_id", "obs_time_bary_corr", "parallax_factor_al", "agis_source_excess_noise", "centroid_pos_al", "centroid_pos_error_al", "scan_pos_angle", "obs_time_tcb", "used_by_agis_al")}
    for row in t:
        for k in range(len(np.atleast_1d(row["centroid_pos_al"]))):
            for c in flat:
                flat[c].append(row[c][k] if np.ndim(row[c]) else row[c])
    buf = io.BytesIO()
    Table({c: np.ma.array(flat[c]) for c in flat}).write(buf, format="votable")
    buf.seek(0)
    again = planets_epochs_read(buf)
    print("read a row a CCD: %d sources, the positions' largest difference %.2e mas" % (len(again), max(float(np.max(np.abs(np.sort(epochs[k]["w"]) - np.sort(again[k]["w"])))) for k in epochs)), flush=True)
    G4 = next(sid for sid, v in planets_DR4_KNOWN.items() if v[0] == "Gaia-4")
    P, tp, e, w, K = 571.3, 2457386.1 - 2400000.5, 0.338, math.radians(180.3), 368.0
    for label, draw in (("Gaia-4 b as published", (P, tp, e, w, K)), ("argument of periastron turned half way", (P, tp, e, w + math.pi, K)), ("periastron half an orbit on", (P, tp + 0.5 * P, e, w, K)), ("K a tenth", (P, tp, e, w, 0.1 * K)), ("K ten times", (P, tp, e, w, 10.0 * K))):
        x = planets_epochs_held(epochs[G4], np.array([draw]), 0.644)
        print("%-40s ln B %10.1f control %10.1f least orbit S/N %6.1f | mass %s, i %s, parallax %.3f | P(<13) %.2f | %s" % (label, x["ln_bayes"], x["control"], x["snr_least"], x["mass_mjup"], x["incl_deg"], x["parallax_mas"], x["p_below_13mjup"], x["verdict"]), flush=True)
    quiet = [k for k in epochs if k not in planets_DR4_KNOWN]
    rng = np.random.default_rng(3)
    verdict = lambda d, draw, ln_b: "held" if ln_b >= 5.0 and ln_b - max(planets_epochs_grid(d, np.array([[draw[0] * f, *draw[1:]]]), 1.0, 10.0)["ln_b"] for f in (0.71, 0.89, 1.26, 1.59)) >= 5.0 else "refuted" if ln_b <= -5.0 else "open"
    share = lambda v: " ".join("%s %.2f" % (k, v.count(k) / len(v)) for k in ("held", "open", "refuted"))
    print("orbits laid into the quiet sources, by the least orbit's S/N: the share of verdicts with no orbit there, and with the orbit at a random tilt", flush=True)
    for snr in (1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 10.0, 15.0, 25.0):
        none, laid = [], []
        for trial in range(40):
            d = epochs[quiet[trial % len(quiet)]]
            _, _, r, _ = planets_epochs_star(d)
            Pi, ei, wi = math.exp(rng.uniform(math.log(30.0), math.log(1500.0))), rng.uniform(0.0, 0.5), rng.uniform(0.0, 2.0 * math.pi)
            tpi = planets_DR4_MJD + rng.uniform(0.0, Pi)
            noise = dict(d, w=rng.permutation(r))
            Ki = snr / planets_epochs_grid(noise, np.array([[Pi, tpi, ei, wi, 1.0]]), 1.0, 10.0)["snr_least"]
            draw = (Pi, tpi, ei, wi, Ki)
            none.append(verdict(noise, draw, planets_epochs_grid(noise, np.array([draw]), 1.0, 10.0)["ln_b"]))
            ci, om = rng.uniform(-1.0, 1.0), rng.uniform(0.0, 2.0 * math.pi)
            a1 = Ki * Pi * 86400.0 * math.sqrt(1.0 - ei * ei) / (2.0 * math.pi * 1.495978707e11) / math.sqrt(1.0 - ci * ci) * 10.0
            cw, sw, cO, sO = math.cos(wi), math.sin(wi), math.cos(om), math.sin(om)
            A, B, F, G = a1 * (cw * cO - sw * sO * ci), a1 * (cw * sO + sw * cO * ci), a1 * (-sw * cO - cw * sO * ci), a1 * (-sw * sO + cw * cO * ci)
            E = gpu_host(gpu_anomaly(gpu_dev(planets_DR4_MJD + d["t"] * 365.25)[None, :], gpu_dev([[Pi]]), gpu_dev([[tpi]]), gpu_dev([[ei]])))[0]
            X, Y = np.cos(E) - ei, math.sqrt(1.0 - ei * ei) * np.sin(E)
            with_orbit = dict(noise, w=noise["w"] + (B * X + G * Y) * d["sin"] + (A * X + F * Y) * d["cos"])
            laid.append(verdict(with_orbit, draw, planets_epochs_grid(with_orbit, np.array([draw]), 1.0, 10.0)["ln_b"]))
        print("S/N %5.1f | no orbit: %s | orbit: %s" % (snr, share(none), share(laid)), flush=True)
    print("the weighings", flush=True)
    for sid, (label, m1, told) in planets_DR4_KNOWN.items():
        if label == "HD 114762":
            continue
        planets_epochs_weigh(label, epochs[sid], m1, pmin=10.0, pmax=20000.0)
        print("   published %s" % told, flush=True)
    rng = np.random.default_rng(3)
    times = np.sort(rng.uniform(45000.0, 60000.0, 60))
    sid = next(k for k, v in planets_DR4_KNOWN.items() if v[0] == "HD 114762")
    planets_epochs_weigh("HD 114762 with velocities", epochs[sid], planets_DR4_KNOWN[sid][1], velocities=(times, 612.0 * planets_kepler(times, 83.9, 57000.0, 0.34, math.radians(200.0)) + rng.normal(0.0, 5.0, 60), np.full(60, 5.0), np.zeros(60, int)), pmin=10.0, pmax=20000.0)
    print("   laid in P 83.9 d, K 612 m/s, e 0.34", flush=True)
    with np.load(os.path.join(planets_RESULTS, "epochs", "Gaia-4.draws.npz")) as z:
        draws = z["draws"]
    rng = np.random.default_rng(5)
    for label, nights, span, noise, amp, second in (("as laid, 60 nights over 15 years, 8 m/s", 60, 5500.0, 8.0, 1.0, 0.0), ("flat, 8 m/s", 60, 5500.0, 8.0, 0.0, 0.0), ("half the signal", 60, 5500.0, 8.0, 0.5, 0.0), ("a tenth of the signal, 30 m/s", 60, 5500.0, 30.0, 0.1, 0.0),
                                                    ("flat, 500 m/s", 60, 5500.0, 500.0, 0.0, 0.0), ("as laid, 500 m/s", 60, 5500.0, 500.0, 1.0, 0.0), ("as laid, 12 nights over a year, 8 m/s", 12, 365.0, 8.0, 1.0, 0.0), ("flat, 12 nights, 8 m/s", 12, 365.0, 8.0, 0.0, 0.0),
                                                    ("as laid, with a 40 d planet of 30 m/s", 60, 5500.0, 8.0, 1.0, 30.0)):
        times = np.sort(rng.uniform(60500.0 - span, 60500.0, nights))
        v = amp * K * planets_kepler(times, P, tp, e, w) + second * planets_kepler(times, 40.0, 57000.0, 0.0, 0.0) + rng.normal(0.0, noise, nights)
        print("%-42s %s" % (label, planets_epochs_velocities(times, v, np.full(nights, noise), (times > 58000.0).astype(int) if span > 1000 else np.zeros(nights, int), draws, [np.tile(np.array([[40.0, 57000.0, 0.0, 0.0, 30.0]]), (32, 1))] if second else [])), flush=True)


def planets_cli():
    archive_quiet_warnings()
    ap = argparse.ArgumentParser(prog="orbitlight.py planets", description=planets_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = ap.add_subparsers(dest="cmd", required=True)
    sub.add_parser("bank", help="the bank's stars and velocities and the archive's planets")
    s = sub.add_parser("dace", help="DACE's public velocities of the census's stars")
    s.add_argument("--threads", type=int, default=3)
    s.add_argument("--stars", nargs="*")
    s.add_argument("--timeout", type=float, default=120.0, help="seconds given each DACE call")
    s = sub.add_parser("rvcat", help="the stars of ESO's HARPS radial-velocity catalogue the bank does not hold, set up as a data root of their own")
    s.add_argument("out", help="the new data root")
    s.add_argument("--min-nights", type=int, default=4)
    s = sub.add_parser("tables", help="the stars of the published HIRES tables beyond the census, set up as a data root of their own")
    s.add_argument("out", help="the new data root")
    s.add_argument("--min-nights", type=int, default=4)
    s = sub.add_parser("peers", help="the root's stars given the other data roots' velocities of them")
    s.add_argument("sources", nargs="+", help="the other data roots")
    s = sub.add_parser("harpsn", help="the stars of the TNG archive's public HARPS-N spectra, set up as a data root of their own")
    s.add_argument("out", help="the new data root")
    s.add_argument("--min-nights", type=int, default=4)
    s = sub.add_parser("elodie", help="the stars of the ELODIE archive, set up as a data root of their own")
    s.add_argument("out", help="the new data root")
    s.add_argument("--min-nights", type=int, default=4)
    s = sub.add_parser("neid", help="the stars of NEID's archive, set up as a data root of their own")
    s.add_argument("out", help="the new data root")
    s.add_argument("--min-nights", type=int, default=4)
    s = sub.add_parser("sophie", help="the stars of the SOPHIE archive, set up as a data root of their own")
    s.add_argument("out", help="the new data root")
    s.add_argument("--min-nights", type=int, default=4)
    s = sub.add_parser("carmenes", help="the stars of CARMENES's first data release, set up as a data root of their own")
    s.add_argument("out", help="the new data root")
    s.add_argument("--min-nights", type=int, default=4)
    s = sub.add_parser("targets", help="the archive's HARPS targets beyond the census, set up as a data root of their own")
    s.add_argument("out", help="the new data root")
    s.add_argument("--min-nights", type=int, default=15)
    s.add_argument("--min-span", type=float, default=100.0)
    s.add_argument("--inst", default="HARPS", help="the spectrograph whose targets are set up: HARPS, ESPRESSO, FEROS, UVES")
    s = sub.add_parser("measure", help="a targets root's stars measured from their archived spectra, line by line and by cross-correlation")
    s.add_argument("--streams", type=int, default=12)
    s.add_argument("--least", type=int, default=4, help="the fewest spectra a star is measured from")
    s = sub.add_parser("census", help="the stars searched, merged where every star is; a share with --part")
    s.add_argument("--part", help="K/N: the stars whose rank by number of velocities is K modulo N")
    s.add_argument("--blind", action="store_true", help="the calibration's census, the archive's planets left out of the model and kept for scoring")
    s.add_argument("--hosts", action="store_true", help="only the stars the archive lists planets for")
    sub.add_parser("merge", help="the shares joined and the candidates' periods tested in the S index")
    s = sub.add_parser("transitsearch", help="the census stars' TESS light curves searched blind for transits; a share with --part")
    s.add_argument("--part", help="K/N: the census's share, or with --validate the candidates'")
    s.add_argument("--validate", action="store_true", help="the search's candidates validated statistically instead")
    s.add_argument("--first", action="store_true", help="with --validate, only the stars planets_validate_first names; exit 3 if the weighing ended early")
    s.add_argument("--backfill", action="store_true", help="the stored searches given their noise measures instead")
    s.add_argument("--tess", action="store_true", help="TESS's stars with SPOC two-minute light curves searched one at a time instead, into a TESS root")
    s.add_argument("--ffi", action="store_true", help="with --tess, the stars only TESS-SPOC's full-frame light curves hold")
    s.add_argument("--skip", type=int, default=0, help="with --tess, that many stars of the order passed over, for a second machine working far from the first")
    s.add_argument("--dossier", help="NAME: everything the root holds on that star's transit signals, printed (planets_transit_dossier)")
    s.add_argument("--setup", help="with --tess, the data root this one is set up from as a TESS root")
    s = sub.add_parser("eccentric", help="the census's residuals searched by a Keplerian periodogram, merged where every star is; a share with --part")
    s.add_argument("--part", help="K/N: the census's share")
    s.add_argument("--perms", type=int, default=50, help="permuted sets in the null of a star whose best orbit passes --min-dchi2")
    s.add_argument("--min-dchi2", type=float, default=25.0)
    s.add_argument("--merge", action="store_true", help="the shares joined into candidates.csv")
    s = sub.add_parser("calibrate", help="the blind census, run where it is missing, scored on the archive's planets")
    s.add_argument("--wobble", action="store_true", help="the weighing's wobble rule set on Gaia DR3's published orbits and accelerations instead (planets_wobble_calibration)")
    sub.add_parser("benchmark", help="the census on stars whose answers are known: Proxima, alpha Cen A and B, and the Sun")
    s = sub.add_parser("system", help="a planetary system's case: models, aliases, stability, limits and figures")
    s.add_argument("star")
    s.add_argument("periods", help="the planets' periods in days, comma-separated")
    s.add_argument("--sims", type=int, default=300)
    s.add_argument("--grid", type=int, default=40)
    s.add_argument("--trials", type=int, default=8)
    s.add_argument("--orbits", type=float, default=1e6, help="orbits of the innermost planet integrated")
    s.add_argument("--mstar", type=float)
    s.add_argument("--title", help="the star's name on the figures, by default the bank's")
    s = sub.add_parser("weigh", help="a long-period companion's mass from velocities and Hipparcos-Gaia astrometry")
    s.add_argument("star")
    s.add_argument("--steps", type=int, default=8000)
    s.add_argument("--pmin", type=float)
    s.add_argument("--pmax", type=float, default=36525.0)
    s.add_argument("--m1", help="the primary's mass and its error in solar masses, MASS,ERROR")
    s.add_argument("--extra", help="an .npz of additional nightly velocities (mjd, rv, rv_err) fitted with their own zero point")
    s = sub.add_parser("ledger", help="test each new body's predicted orbit against observations made after its discovery")
    s.add_argument("--workers", type=int, default=6, help="refits run in parallel")
    s.add_argument("--most", type=int, default=30, help="maximum number of post-discovery spectra measured per companion")
    s = sub.add_parser("validate", help="TESS's planet candidates validated statistically with TRICERATOPS")
    s.add_argument("--part", help="K/N: every Nth candidate from the Kth, the TOIs by number and then the community TOIs")
    s.add_argument("--workers", type=int, help="without --part, the shares weighed at once: by default half the processors, at most 16")
    s.add_argument("--candidates", nargs="+", help="labels (TOI-<number>, CTOI-<number>) of candidates weighed again, whatever their selection")
    s.add_argument("--source", nargs="+", choices=("toi", "ctoi", "koi", "k2"), default=["toi", "ctoi", "koi", "k2"], help="ExoFOP's TOIs, its community TOIs, the NASA Exoplanet Archive's Kepler objects of interest and K2 candidates, or any of them")
    s.add_argument("--draws", type=int, default=100000, help="Monte Carlo draws of each scenario in each run")
    s.add_argument("--runs", type=int, default=10, help="runs whose probabilities are averaged")
    s.add_argument("--dispositions", nargs="+", default=["PC", "APC"], help="toi: the TFOPWG dispositions taken")
    s.add_argument("--min-snr", type=float, default=7.1, help="toi: the least signal-to-noise ratio taken")
    s.add_argument("--max-snr", type=float, help="toi: the signal-to-noise ratio below which a candidate is taken")
    s.add_argument("--redo", action="store_true")
    s.add_argument("--benchmark", type=int, default=0, help="that many TOIs of each settled fate weighed and scored instead, into RESULTS/validate_benchmark")
    s.add_argument("--again", action="store_true", help="with --benchmark, a sample none of the first benchmark's, into RESULTS/validate_benchmark_again")
    s.add_argument("--refine", action="store_true", help="the candidates that did not pass measured for their own ephemeris and weighed again where it moves them, "
                                                          "instead (planets_validate_refine); with --part, that share")
    s.add_argument("--control", action="store_true", help="the decision rules tried on confirmed planets, instead (planets_control)")
    s.add_argument("--checks", action="store_true", help="the shape's harmonics, the dip's source and Gaia's RUWE and rotation added to the passing records, equal dips "
                                                          "weighed at half the period, instead (planets_validate_checks); with --part, that share")
    s.add_argument("--tess", action="store_true", help="the stars' TESS readings read again from each sector's detrended flux, instead (planets_tess_refresh); with --part, that share")
    s.add_argument("--orbits", action="store_true", help="the stars' orbits sampled again by their conjunctions, instead (planets_orbits_refresh); with --part, that share")
    s.add_argument("--second", action="store_true", help="the new planets' orbits tested in another spectrograph's archived spectra, instead (planets_second); with --part, that share")
    s.add_argument("--reduce", action="store_true", help="the signals one reduction holds given another from their stars' archived spectra, instead (planets_reduce); with --part, that share")
    s.add_argument("--activity", action="store_true", help="the signals an activity indicator alone sets aside tested with the star's activity modelled, and followed where they hold, instead (planets_activity); with --part, that share")
    s.add_argument("--epochs", action="store_true", help="each star's velocity orbits tested in Gaia DR4's epochs and the epochs searched for orbits, instead (planets_epochs_refresh); with --part, that share")
    s.add_argument("--null", action="store_true", help="a sample of the TESS root's stars searched with their light curves upside down, instead (planets_null_search); with --part, that share")
    s.add_argument("--singles", action="store_true", help="the census's stars searched for lone transits, each set against its velocities, instead (planets_singles); with --part, that share")
    s.add_argument("--scramble", action="store_true", help="the census and its vet tried with each star's nights moved to one another's dates, instead (planets_null_census)")
    s.add_argument("--fold", action="store_true", help="the records within reach of passing given how strongly their folds show their dips, their odd and even depths against the transits' own scatter and how far past the noise, instead (planets_validate_fold); with --part, that share")
    s.add_argument("--gaia", action="store_true", help="Gaia's marks of a double star added to the records and measured on the settled TOIs, instead (planets_validate_gaia); with --part, that share")
    s.add_argument("--multi", action="store_true", help="the records that pass, or that another candidate on their stars would make pass, weighed on ten runs, instead (planets_validate_multi); with --part, that share")
    s.add_argument("--clear", action="store_true", help="the records their nearby stars alone keep from passing given the place of the dip's source in their difference images and weighed again, instead (planets_validate_clear); with --part, that share")
    s.add_argument("--inject", action="store_true", help="a sample of the TESS root's stars searched with planets' transits laid into their light curves, instead (planets_inject_search); with --part, that share")
    s.add_argument("--score", action="store_true", help="every benchmark the root holds scored, nothing weighed, instead (planets_validation_scores)")
    s.add_argument("--compare", help="LABEL: that candidate's probabilities from TRICERATOPS's own code and from the device's set side by side, instead (planets_validate_compare)")
    s = sub.add_parser("controls", help="what the decision does to settled candidates and to open ones, read from the root's records with nothing weighed (planets_controls)")
    s.add_argument("--indicators", action="store_true", help="how often an activity indicator holds power at a known planet's period, instead (planets_indicator_control)")
    s = sub.add_parser("strict", help="the strict-periodicity test on the root's known and new signals and those rejected for activity (planets_strict)")
    s.add_argument("--part", help="K/N: that share of the stars")
    s = sub.add_parser("sparse", help="the census's stars' sinusoids searched three ways and scored against the blind census (planets_sparse)")
    s.add_argument("--part", help="K/N: the census's share")
    s.add_argument("--score", action="store_true", help="what has been searched scored, nothing searched")
    s = sub.add_parser("recovery", help="a range of periods tried before the search is carried over it (planets_recovery)")
    s.add_argument("--pmin", type=float)
    s.add_argument("--pmax", type=float)
    s.add_argument("--stars", type=int, default=60, help="confirmed TOIs tried")
    s.add_argument("--randoms", type=int, default=150, help="random stars of each kind of light curve")
    s = sub.add_parser("window", help="what the search's detrending costs a transit of each length (planets_window_cost)")
    s.add_argument("--stars", type=int, default=150)
    s = sub.add_parser("figure", help="each signal past the search's vetting of a star drawn from its light curves (planets_transit_figure)")
    s.add_argument("star")
    s.add_argument("--inverted", action="store_true", help="the stored search of its light curves upside down")
    s = sub.add_parser("dip", help="one lone dip of a star read closely (planets_dip)")
    s.add_argument("star")
    s.add_argument("T", type=float, help="the dip's time (BTJD)")
    s.add_argument("--tic", type=int)
    sub.add_parser("companions-read", help="the root's new companions one by one, for reading (planets_companions_read)")
    sub.add_parser("progress", help="the TESS stage's stars searched by kind of light curve, its rate and the time left (planets_tess_progress)")
    s = sub.add_parser("epochs-trial", help="the reading of Gaia DR4's epoch astrometry tried on ESA's pre-release (planets_epochs_trial)")
    s.add_argument("file", help="the pre-release's raw epoch table")
    s.add_argument("--reference", help="a JSON file of ESA's fit by source")
    s = sub.add_parser("tois", help="TESS's planet candidates weighed with archived velocities from every source")
    s.add_argument("--source", nargs="+", choices=("dace", "eso", "rvcat", "bank"), default=["dace", "eso", "rvcat"],
                   help="DACE's velocities, the archive's HARPS spectra measured line by line, ESO's catalogue of HARPS pipeline velocities and the root's own stars' velocities, each in turn")
    s.add_argument("--streams", type=int, default=4, help="eso: connections per star's spectra")
    s.add_argument("--tmag", type=float, default=12.0)
    s.add_argument("--threads", type=int, default=3)
    s.add_argument("--timeout", type=float, default=60.0, help="seconds given each DACE call")
    s.add_argument("--fit-only", action="store_true", help="fit the velocities already fetched")
    s = sub.add_parser("lbl", help="a star's line-by-line velocities")
    s.add_argument("star")
    s.add_argument("--per-night", type=int, default=1)
    s.add_argument("--streams", type=int, default=12)
    s.add_argument("--most", type=int, default=0)
    s.add_argument("--keep", action="store_true")
    s = sub.add_parser("followup", help="every signal decided: the census's, the companions' and TESS's, into signals.csv and planets.csv")
    s.add_argument("--workers", type=int, default=6, help="stars run side by side")
    s.add_argument("--star", help="one followed star's work alone, as each worker runs it")
    s.add_argument("--companion", help="one star's companion analysis alone, as each worker runs it")
    s.add_argument("--periods", default="", help="with --star, its followed periods, comma-separated")
    s.add_argument("--known", default="", help="with --star, its archive planets' periods, comma-separated")
    s.add_argument("--report", action="store_true", help="the followed stars' saved results tabulated again, the stars not run")
    s.add_argument("--into", help="with --report, the tables written to this folder and set against the stored ones, which stand (planets_decision_dry)")
    s = sub.add_parser("vet", help="signals across reductions, indicators, halves, other instruments and Gaia")
    s.add_argument("star", nargs="?")
    s.add_argument("periods", nargs="?", help="periods in days, comma-separated")
    s.add_argument("--list", help="a file of signals, a star and its comma-separated periods on each line")
    for cmd, help_ in (("orbits", "a star's Keplerians sampled"), ("tess", "a star's TESS light curves at its signals' periods")):
        s = sub.add_parser(cmd, help=help_)
        s.add_argument("star")
        s.add_argument("periods", help="periods in days, comma-separated")
        if cmd == "orbits":
            s.add_argument("--steps", type=int, default=30000)
            s.add_argument("--mstar", type=float)
            s.add_argument("--ebound", type=float, default=0.9)
            s.add_argument("--circular", action="store_true", help="every orbit circular, its eccentricity held at zero")
            s.add_argument("--extra", help="an .npz of additional nightly velocities (mjd, rv, rv_err) fitted as a separate series")
    a = ap.parse_args()
    if a.cmd == "bank":
        planets_bank()
    elif a.cmd == "dace":
        planets_dace(a.threads, names=a.stars, timeout=a.timeout)
    elif a.cmd == "rvcat":
        planets_rvcat(a.out, a.min_nights)
    elif a.cmd == "tables":
        planets_tables(a.out, a.min_nights)
    elif a.cmd == "carmenes":
        planets_carmenes(a.out, a.min_nights)
    elif a.cmd == "sophie":
        planets_sophie(a.out, a.min_nights)
    elif a.cmd == "harpsn":
        planets_harpsn(a.out, a.min_nights)
    elif a.cmd == "neid":
        planets_neid(a.out, a.min_nights)
    elif a.cmd == "elodie":
        planets_elodie(a.out, a.min_nights)
    elif a.cmd == "peers":
        planets_peers(a.sources)
    elif a.cmd == "targets":
        planets_targets(a.out, a.min_nights, a.min_span, inst=a.inst)
    elif a.cmd == "measure":
        planets_measure(a.streams, a.least)
    elif a.cmd == "census":
        planets_census(a.part, a.blind, a.hosts)
    elif a.cmd == "merge":
        planets_merge()
    elif a.cmd == "transitsearch":
        if a.dossier:
            planets_transit_dossier(a.dossier)
        elif a.tess:
            planets_tess_root(a.setup) if a.setup else planets_tess_search(a.part, a.ffi, a.skip)
        elif a.validate and a.first:
            first = planets_validate_first()
            if first:
                planets_validate_transits(part=a.part, names=first)
            sys.exit(3 if planets_search_ends() else 0)
        else:
            planets_transit_backfill(a.part) if a.backfill else planets_validate_transits(part=a.part) if a.validate else planets_transit_search_all(a.part)
    elif a.cmd == "eccentric":
        planets_eccentric_merge() if a.merge else planets_eccentric(a.part, a.perms, a.min_dchi2)
    elif a.cmd == "calibrate":
        planets_wobble_calibration() if a.wobble else planets_calibrate()
    elif a.cmd == "benchmark":
        planets_benchmark()
    elif a.cmd == "tois":
        for source in a.source:
            planets_tois(a.tmag, a.threads, a.timeout, a.fit_only, source, a.streams)
    elif a.cmd == "system":
        planets_system(a.star, [float(x) for x in a.periods.split(",")], a.sims, a.grid, a.trials, a.orbits, a.mstar, title=a.title)
    elif a.cmd == "weigh":
        planets_weigh(a.star, a.steps, a.pmin, a.pmax, [float(x) for x in a.m1.split(",")] if a.m1 else None, a.extra)
    elif a.cmd == "ledger":
        planets_ledger(a.workers, a.most)
    elif a.cmd == "validate" and a.refine:
        planets_validate_refine(a.part)
    elif a.cmd == "validate" and a.checks:
        planets_validate_checks(a.part)
    elif a.cmd == "validate" and a.control:
        planets_control()
    elif a.cmd == "validate" and a.tess:
        planets_tess_refresh(a.part)
    elif a.cmd == "validate" and a.orbits:
        planets_orbits_refresh(a.part)
    elif a.cmd == "validate" and a.second:
        planets_second(a.part)
    elif a.cmd == "validate" and a.reduce:
        planets_reduce(a.part)
    elif a.cmd == "validate" and a.activity:
        planets_activity(a.part)
    elif a.cmd == "validate" and a.epochs:
        planets_epochs_refresh(a.part)
    elif a.cmd == "validate" and a.null:
        planets_null_search(a.part)
    elif a.cmd == "validate" and a.singles:
        planets_singles(a.part)
    elif a.cmd == "validate" and a.scramble:
        planets_null_census()
    elif a.cmd == "validate" and a.fold:
        planets_validate_fold(a.part)
    elif a.cmd == "validate" and a.gaia:
        planets_validate_gaia(a.part)
    elif a.cmd == "validate" and a.multi:
        planets_validate_multi(a.part)
    elif a.cmd == "validate" and a.clear:
        planets_validate_clear(a.part)
    elif a.cmd == "validate" and a.inject:
        planets_inject_search(a.part)
    elif a.cmd == "validate" and a.score:
        planets_validation_scores()
    elif a.cmd == "validate" and a.compare:
        planets_validate_compare(a.compare, a.draws)
    elif a.cmd == "validate":
        planets_validate(a.part, a.draws, a.runs, tuple(a.source), tuple(a.dispositions), a.min_snr, a.max_snr, a.redo, a.workers, a.candidates, a.benchmark, a.again)
    elif a.cmd == "controls":
        planets_indicator_control() if a.indicators else planets_controls()
    elif a.cmd == "strict":
        planets_strict(a.part)
    elif a.cmd == "sparse":
        planets_sparse_score() if a.score else planets_sparse(a.part)
    elif a.cmd == "recovery":
        planets_recovery(a.pmin, a.pmax, a.stars, a.randoms)
    elif a.cmd == "window":
        planets_window_cost(a.stars)
    elif a.cmd == "figure":
        planets_transit_figure(a.star, a.inverted)
    elif a.cmd == "dip":
        planets_dip(a.star, a.T, a.tic)
    elif a.cmd == "companions-read":
        planets_companions_read()
    elif a.cmd == "progress":
        planets_tess_progress()
    elif a.cmd == "epochs-trial":
        planets_epochs_trial(a.file, a.reference)
    elif a.cmd == "lbl":
        planets_lbl(a.star, a.per_night, a.streams, a.keep, a.most)
    elif a.cmd == "followup":
        if a.companion:
            planets_companion(a.companion)
        elif a.star:
            planets_followup_star(a.star, [float(x) for x in a.periods.split(",") if x], [float(x) for x in a.known.split(",") if x])
        else:
            planets_decision_dry(a.into) if a.into else planets_followup(a.workers, a.report)
    elif a.cmd == "vet":
        jobs = {}
        for star, periods in ([line.split() for line in open(a.list, encoding="utf-8") if line.strip()] if a.list else [(a.star, a.periods)]):
            jobs.setdefault(star, []).extend(float(x) for x in periods.split(","))
        planets_vet(list(jobs.items()))
    else:
        periods = [float(x) for x in a.periods.split(",")]
        if a.cmd == "orbits":
            planets_orbits(a.star, periods, a.steps, a.mstar, a.ebound, circular=a.circular, extra=a.extra)
        else:
            planets_tess(a.star, periods)


solar_DOC = """The solar system as a calibration source: the archive's spectra of the Sun and of sunlight reflected by the Moon and the planets, read for the
Sun's own velocity about the solar system's barycentre, whose planets DE440 gives exactly. The pipeline puts each spectrum in the barycentric frame of a
star at infinity in the target's catalogue direction; that correction is undone and replaced by the light's path from the Sun, by way of the
reflecting body where there is one, to the observatory, with every body's barycentric motion from DE440 except the Sun's, so that what remains is the
Sun's own velocity along the line from it to the body or the observatory, as a distant observer in that direction would measure it, with the Sun's
surface variability. Each day's spectra are averaged in that frame and the days' velocities measured line by line against their median, with the
activity indicators, and DE440's barycentric velocity of the Sun is kept beside each day: the velocities less DE440's are the Sun's activity alone,
which calibrates the activity tests and, with planets laid into it, the searches; the velocities themselves test whether the searches find the solar
system's planets. The Galilean moons, Titan and the brighter asteroids take their positions from JPL Horizons, and with days --each a body that moves
within a night has each spectrum moved into the Sun's frame on its own.

    plan      a target's public spectra in the archive
    days      each day's spectra fetched, moved into the Sun's frame and averaged
    lbl       the days' velocities line by line, with the S and H alpha indices, and DE440's velocity of the Sun along each day's line
    fit       the velocities set against DE440's, and searched blind for circular orbits in the ecliptic
    reflected a planet's reflected light laid into the Sun's daily spectra and sought as the giants mode seeks it around other stars
    orbit     a moon's reflected light followed in its planet's frame, as a planet's is in its star's
    molecules a body's own molecules in the sunlight it reflects, at the velocity its atmosphere imposes
    eclipse   the Earth's atmosphere in transmission, the eclipsed Moon against the Moon outside the shadow

Without a step, every result is made for every body with public spectra, each again where newer days have arrived."""

solar_ROOT = archive_data("solar")
solar_RESULTS = archive_results("solar")

# the obliquity of the ecliptic at J2000
solar_OBLIQUITY = math.radians(23.4392911)

# the bodies DE440 carries, by the archive's target names
solar_BODIES = {"sun": "sun", "moon": "moon", "mercury": "mercury", "venus": "venus", "mars": "mars", "jupiter": "jupiter", "saturn": "saturn",
                "uranus": "uranus", "neptune": "neptune"}


def solar_plan(target="Sun", instrument="HARPS"):
    """Every public spectrum of TARGET (its name as given, in capitals or capitalised) from INSTRUMENT in the ESO archive, released by now, to
    ROOT/<tag>/plan.csv: product, start (MJD), exposure, signal to noise and programme. Returns their number."""
    names = ", ".join("'%s'" % t.replace("'", "''") for t in sorted({target, target.upper(), target.capitalize()}))
    q = ("SELECT dp_id, t_min, t_exptime, snr, proposal_id, obs_release_date FROM ivoa.ObsCore WHERE dataproduct_type = 'spectrum' AND "
         "instrument_name = '%s' AND target_name IN (%s)" % (instrument, names))
    now = time.strftime("%Y-%m-%d")
    rows = [r for r in archive_tap("eso", q) if (r.get("obs_release_date") or "")[:10] <= now]
    rows.sort(key=lambda r: float(r["t_min"]))
    folder = os.path.join(solar_ROOT, archive_tag(instrument, target))
    os.makedirs(folder, exist_ok=True)
    with open(os.path.join(folder, "plan.csv"), "w", newline="", encoding="utf-8") as fh:
        w = csv.DictWriter(fh, fieldnames=["dp_id", "t_min", "t_exptime", "snr", "proposal_id"], extrasaction="ignore")
        w.writeheader()
        w.writerows(rows)
    print("%d public spectra of %s from %s on %d days" % (len(rows), target, instrument, len({math.floor(float(r["t_min"]) + 0.3) for r in rows})), flush=True)
    return len(rows)


def solar_frame(mjd, body="sun", site="LaSilla", planet=False):
    """For times MJD (UTC, an array) at the observatory: the velocity B (km/s) that moves a spectrum of BODY from the observatory's frame into the Sun's,
    the wavelengths multiplied by 1 + B/c; the unit vector u from the Sun toward the body (toward the observatory for the Sun itself), in ICRS; and the
    Sun's barycentric velocity (km/s, ICRS). The light leaves the Sun, is reflected by the body and reaches the observatory, each position taken when the
    light passed it, and every velocity but the Sun's is DE440's, so that a spectrum moved by B carries -v_sun . u, the Sun's velocity as an observer
    far away along u would measure it. PLANET adds the Sun-frame velocity of lines formed in the body's atmosphere, -v_body . u."""
    import astropy.units as u_
    from astropy.coordinates import get_body_barycentric, get_body_barycentric_posvel, solar_system_ephemeris
    from astropy.time import Time
    t = Time(np.atleast_1d(np.asarray(mjd, float)), format="mjd", scale="utc")
    loc = archive_location(site)
    km, kms = u_.km, u_.km / u_.s
    with solar_system_ephemeris.set("de440s"):
        pe, ve = get_body_barycentric_posvel("earth", t)
        gp, gv = loc.get_gcrs_posvel(t)
        xo = pe.xyz.to(km).value + gp.xyz.to(km).value
        vo = ve.xyz.to(kms).value + gv.xyz.to(kms).value
        if body == "sun":
            te = t
            for _ in range(3):
                xs = get_body_barycentric("sun", te).xyz.to(km).value
                te = t - (np.linalg.norm(xs - xo, axis=0) / spectra_C) * u_.s
            vs = get_body_barycentric_posvel("sun", te)[1].xyz.to(kms).value
            u = (xo - xs) / np.linalg.norm(xo - xs, axis=0)
            # the observatory's own motion along the line, taken out; the Sun's left in
            return -np.sum(vo * u, axis=0), u.T, vs.T
        def state(tt):
            # DE440's bodies from astropy, the others from Horizons at the same TDB instants
            if body in solar_HORIZONS:
                return solar_horizons(body, tt.tdb.jd)
            p_, v_ = get_body_barycentric_posvel(body, tt)
            return p_.xyz.to(km).value, v_.xyz.to(kms).value
        tr = t
        for _ in range(2):
            xr = state(tr)[0]
            tr = t - (np.linalg.norm(xr - xo, axis=0) / spectra_C) * u_.s
        xr, vr = state(tr)
        ts = tr
        for _ in range(3):
            xs = get_body_barycentric("sun", ts).xyz.to(km).value
            ts = tr - (np.linalg.norm(xr - xs, axis=0) / spectra_C) * u_.s
        vs = get_body_barycentric_posvel("sun", ts)[1].xyz.to(kms).value
    u = (xr - xs) / np.linalg.norm(xr - xs, axis=0)
    n2 = (xo - xr) / np.linalg.norm(xo - xr, axis=0)
    # the body's motion away from the Sun and the observatory's away from the body, taken out; the Sun's left in
    out = (-(np.sum(vr * u, axis=0) + np.sum((vo - vr) * n2, axis=0)), u.T, vs.T)
    return out + (-np.sum(vr * u, axis=0),) if planet else out


# the bodies Horizons gives by number, for those DE440 does not carry
solar_HORIZONS = {"io": "501", "europa": "502", "ganymede": "503", "callisto": "504", "titan": "606", "ceres": "1;", "vesta": "4;", "pallas": "2;",
                  "juno": "3;", "iris": "7;", "hebe": "6;"}


def solar_horizons(body, jd_tdb):
    """A body's barycentric positions (km) and velocities (km/s) in ICRS at the TDB Julian dates JD_TDB, from JPL Horizons' vector tables, fifty dates
    to a request."""
    out = []
    for i in range(0, len(jd_tdb), 50):
        q = dict(format="text", COMMAND="'%s'" % solar_HORIZONS[body], OBJ_DATA="'NO'", MAKE_EPHEM="'YES'", EPHEM_TYPE="'VECTORS'", CENTER="'500@0'",
                 REF_PLANE="'FRAME'", VEC_TABLE="'2'", OUT_UNITS="'KM-S'", CSV_FORMAT="'YES'", VEC_LABELS="'NO'",
                 TLIST=" ".join("'%.9f'" % x for x in jd_tdb[i:i + 50]))
        text = archive_get("https://ssd.jpl.nasa.gov/api/horizons.api?" + urllib.parse.urlencode(q), timeout=120).decode()
        for line in text.split("$$SOE")[1].split("$$EOE")[0].strip().splitlines():
            f = [x.strip() for x in line.split(",") if x.strip()]
            out.append([float(x) for x in f[2:8]])
    a = np.array(out)
    return a[:, :3].T, a[:, 3:6].T


def solar_ecliptic(v):
    """ICRS vectors (n x 3) in ecliptic coordinates."""
    c, s = math.cos(solar_OBLIQUITY), math.sin(solar_OBLIQUITY)
    v = np.atleast_2d(v)
    return np.column_stack([v[:, 0], c * v[:, 1] + s * v[:, 2], -s * v[:, 1] + c * v[:, 2]])


def solar_day(target, t):
    """The day a spectrum belongs to: the UT date for the Sun, observed by day, and the night, split at local noon at La Silla, for the others."""
    return np.floor(np.asarray(t, float) + (0.0 if target.lower() == "sun" else 0.3)).astype(int)


# the solar grid's red end (A), where methane's bands near 0.9 um lie
solar_HI = 9500.0


def solar_grid(hi=solar_HI):
    """The solar mode's grid, uniform in log wavelength at 0.4 km/s from 3800 A to HI."""
    return 3800.0 * np.exp(np.arange(int(np.log(hi / 3800.0) * spectra_C / 0.4)) * 0.4 / spectra_C)


def solar_day_grid(d):
    """The grid a day of solar days was written on, the line-by-line grid for days that record none."""
    return solar_grid(float(d["grid_hi"])) if "grid_hi" in d.files else lbl_grid()


def solar_site(instrument):
    """The observatory of an instrument whose spectra the solar mode reads."""
    return "Paranal" if instrument in ("ESPRESSO", "UVES", "CRIRES", "XSHOOTER") else "LaSilla"


def solar_days(target="Sun", instrument="HARPS", per_day=16, streams=6, most_days=0, each=False):
    """Each day of a target's plan in the Sun's frame on the solar grid, the spectra averaged by inverse variance, to ROOT/<tag>/days/<day>.npz."""
    body = solar_BODIES.get(target.lower()) or (target.lower() if target.lower() in solar_HORIZONS else None)
    if body is None:
        raise SystemExit("%s: no ephemeris; the Sun, the Moon, the planets, the Galilean moons, Titan and the brighter asteroids are read" % target)
    folder = os.path.join(solar_ROOT, archive_tag(instrument, target))
    plan = list(csv.DictReader(open(os.path.join(folder, "plan.csv"), encoding="utf-8")))
    byday = {}
    # with EACH every spectrum a row of its own, keyed by its start in millionths of a day
    keys = ([int(round(float(r["t_min"]) * 1e6)) for r in plan] if each else solar_day(target, [float(r["t_min"]) for r in plan]))
    for r, d in zip(plan, keys):
        byday.setdefault(int(d), []).append(r)
    grid, site = solar_grid(), solar_site(instrument)
    os.makedirs(os.path.join(folder, "days"), exist_ok=True)
    done = 0
    # with EACH, every spectrum's frame at its mid-exposure from one batch of ephemeris requests
    pre = {}
    if each:
        mids = np.array([float(r["t_min"]) + float(r["t_exptime"] or 0.0) / 172800.0 for r in plan])
        bb, uu, vv = solar_frame(mids, body, site)
        pre = {r["dp_id"]: (bb[i:i + 1], uu[i:i + 1], vv[i:i + 1]) for i, r in enumerate(plan)}
    for day in sorted(byday):
        out = os.path.join(folder, "days", "%d.npz" % day)
        if os.path.exists(out):
            continue
        rows = sorted(byday[day], key=lambda r: float(r["t_min"]))
        rows = [rows[int(i)] for i in np.unique(np.linspace(0, len(rows) - 1, min(per_day, len(rows))).round())]
        spool = os.path.join(folder, "spectra", str(day))
        spectra = spectra_read(archive_eso_fetch(rows, spool, streams=streams))
        if not spectra:
            shutil.rmtree(spool, ignore_errors=True)
            continue
        mjd = np.array([s[3]["mjd"] for s in spectra])
        b, u, vs = pre[rows[0]["dp_id"]] if each else solar_frame(mjd, body, site)
        bp = [meta.get("berv") or 0.0 for w, f, e, meta in spectra]
        Fn, En, _ = spectra_onto([(w * (1.0 + bi / spectra_C) / (1.0 + b0 / spectra_C), f, e) for (w, f, e, meta), bi, b0 in zip(spectra, b, bp)], grid, 1001,
                                 clean_errors=True)
        acc, wsum = np.zeros(len(grid)), np.zeros(len(grid))
        for fn, en in zip(Fn, En):
            good = np.isfinite(fn) & np.isfinite(en) & (en > 0)
            wt = np.where(good, 1.0 / np.where(good, en, 1.0) ** 2, 0.0)
            acc += np.where(good, fn, 0.0) * wt
            wsum += wt
        with np.errstate(all="ignore"):
            F, E = acc / wsum, 1.0 / np.sqrt(wsum)
        np.savez_compressed(out, flux=F.astype(np.float32), err=E.astype(np.float32), n=len(spectra), mjd=float(mjd.mean()), b=float(b.mean()),
                            b_pipeline=float(np.mean(bp)), unit=u.mean(0), vsun=vs.mean(0), programme=rows[0]["proposal_id"],
                            dp_ids=np.array([r["dp_id"] for r in rows]), grid_hi=solar_HI)
        shutil.rmtree(spool, ignore_errors=True)
        done += 1
        print("%s day %d: %d of %d spectra, B %+.4f km/s against the pipeline's %+.4f, S/N per sample %.0f" % (
            target, day, len(spectra), len(byday[day]), b.mean(), np.mean(bp), float(np.nanmedian(F / E))), flush=True)
        if most_days and done >= most_days:
            break
    print("done: %d days written" % done, flush=True)


def solar_lbl(target="Sun", instrument="HARPS", min_spectra=4):
    """A target's days measured line by line, to RESULTS/<tag>/velocities.csv. The Ca II H and K index and the H alpha index are measured in each day's
    spectrum (lbl_indices); then, with the telluric bands and the sodium sky lines set aside, each programme's days of MIN_SPECTRA spectra or more are
    measured against their median (solar_measure), its velocities taken about their median and its line shifts kept in
    RESULTS/<tag>/lines_<programme>.npz. Each day carries DE440's velocity of the Sun along u, -v_sun . u, which the velocities hold if the frame is
    right."""
    tag = archive_tag(instrument, target)
    files = sorted(glob.glob(os.path.join(solar_ROOT, tag, "days", "*.npz")), key=lambda f: int(os.path.basename(f)[:-4]))
    grid, meta, F, E = None, [], [], []
    for f in files:
        d = np.load(f)
        if int(d["n"]) < min_spectra:
            continue
        # the days on the first day's grid
        g = solar_day_grid(d)
        grid = g if grid is None else grid
        on = (lambda x: x) if len(g) == len(grid) else (lambda x: np.interp(grid, g, x, left=np.nan, right=np.nan))
        F.append(on(d["flux"].astype(float)))
        E.append(on(d["err"].astype(float)))
        meta.append(dict(day=int(os.path.basename(f)[:-4]), mjd=float(d["mjd"]), n=int(d["n"]), b=float(d["b"]), b_pipeline=float(d["b_pipeline"]),
                         unit=d["unit"], vsun=d["vsun"], programme=str(d["programme"])))
    F, E = np.array(F), np.array(E)
    S, HA = lbl_indices(F, grid)
    for lo, hi in spectra_BANDS["optical"]["telluric"]:
        F[:, (grid > lo) & (grid < hi)] = np.nan
    for sky in spectra_SKY:
        F[:, np.abs(grid - sky) < 0.15] = np.nan
    b_day = np.array([m["b"] for m in meta])
    progs = np.array([m["programme"] for m in meta])
    rv, rv_err = np.full(len(F), np.nan), np.full(len(F), np.nan)
    out = os.path.join(solar_RESULTS, tag)
    os.makedirs(out, exist_ok=True)
    for prog in np.unique(progs):
        idx = np.where(progs == prog)[0]
        if len(idx) < 3:
            continue
        r_, e_, lam, V, SV, n_tell = solar_measure(F[idx], E[idx], b_day[idx], grid)
        rv[idx], rv_err[idx] = r_ - np.median(r_), e_
        np.savez_compressed(os.path.join(out, "lines_%s.npz" % re.sub(r"[^A-Za-z0-9.-]", "_", prog)), day=np.array([meta[i]["day"] for i in idx]),
                            line_lambda=lam, V=V.astype(np.float32), SV=SV.astype(np.float32))
        print("%s %s: %d days, %d lines, %d set aside as following the telluric lines; scatter %.2f m/s, median error %.2f m/s" % (
            tag, prog, len(idx), len(lam), n_tell, float(np.std(r_)), float(np.median(e_))), flush=True)
    keys = ["day", "mjd", "n", "programme", "rv", "rv_err", "de440", "S", "Halpha", "b", "b_pipeline", "unit_x", "unit_y", "unit_z", "vsun_x", "vsun_y",
            "vsun_z"]
    with open(os.path.join(out, "velocities.csv"), "w", newline="", encoding="utf-8") as fh:
        w = csv.writer(fh)
        w.writerow(keys)
        for i, m in enumerate(meta):
            if not np.isfinite(rv[i]):
                continue
            w.writerow([m["day"], round(m["mjd"], 5), m["n"], m["programme"], round(float(rv[i]), 3), round(float(rv_err[i]), 3),
                        round(-1000.0 * float(np.dot(m["vsun"], m["unit"])), 3), round(S[i], 6), round(HA[i], 6), round(m["b"], 6), round(m["b_pipeline"], 6)] +
                       [round(float(x), 9) for x in m["unit"]] + [round(float(x), 9) for x in m["vsun"]])


def solar_measure(F, E, bframe, grid=None):
    """Days' spectra on GRID measured line by line against their median, lines following the frame velocity BFRAME set aside as telluric."""
    grid = lbl_grid() if grid is None else grid
    lines, V, SV, s2 = lbl_velocities(F, E, robust=True)
    rv = np.nansum(V / s2, 1) / np.nansum(1.0 / s2, 1)
    tell = np.zeros(len(lines), bool)
    if len(bframe) >= 8 and np.std(bframe) > 0:
        tell = lbl_corr(V - rv[:, None], bframe, 8)[1] < 0.001
    s2 = np.where(tell[None, :], np.inf, s2)
    rv = np.nansum(V / s2, 1) / np.nansum(1.0 / s2, 1)
    rv_err = 1.0 / np.sqrt(np.nansum(1.0 / s2, 1))
    return rv, rv_err, grid[lines[:, 2]], V, SV, int(tell.sum())


def solar_fit(target="Sun", instrument="HARPS", pmin=300.0, pmax=30000.0):
    """A target's velocities against the planets' pull, to RESULTS/<tag>/fit.json. First DE440's velocity of the Sun along each day's line, scaled by a
    free factor beside an offset per programme and the S index, which tests the frame; then blind, a circular orbit in the ecliptic at every period from
    PMIN to PMAX days, the Sun's velocity A (-sin(theta), cos(theta), 0) projected on each day's line, its two linear terms solved with the same offsets
    and the S index: the improvement in chi-square at each period, and the best orbit's period, speed and the planet's mass it implies."""
    out = os.path.join(solar_RESULTS, archive_tag(instrument, target))
    rows = list(csv.DictReader(open(os.path.join(out, "velocities.csv"), encoding="utf-8")))
    t = np.array([float(r["mjd"]) for r in rows])
    v = np.array([float(r["rv"]) for r in rows])
    e = np.array([float(r["rv_err"]) for r in rows])
    S = np.array([float(r["S"]) for r in rows])
    truth = np.array([float(r["de440"]) for r in rows])
    prog = np.array([r["programme"] for r in rows])
    unit = solar_ecliptic(np.array([[float(r["unit_" + k]) for k in "xyz"] for r in rows]))
    base = [(prog == p).astype(float) for p in np.unique(prog)] + [(S - S.mean()) / S.std()]
    # days beyond 5 robust standard deviations of a first fit with DE440's term set aside
    X0 = np.column_stack(base + [truth])
    r_first = v - X0 @ np.linalg.lstsq(X0 / e[:, None], v / e, rcond=None)[0]
    keep = np.abs(r_first - np.median(r_first)) < 5.0 * 1.4826 * np.median(np.abs(r_first - np.median(r_first)))
    clipped = int((~keep).sum())
    t, v, e, S, truth, prog, unit = t[keep], v[keep], e[keep], S[keep], truth[keep], prog[keep], unit[keep]
    base = [(prog == p).astype(float) for p in np.unique(prog)] + [(S - S.mean()) / S.std()]

    def solve(cols, jit):
        s = np.hypot(e, jit)
        X = np.column_stack(cols)
        c, *_ = np.linalg.lstsq(X / s[:, None], v / s, rcond=None)
        r = v - X @ c
        return c, r, float(np.sum((r / s) ** 2)), np.linalg.inv((X / s[:, None]).T @ (X / s[:, None]))
    jit = 1.0
    for _ in range(5):
        c, r, _, cov = solve(base + [truth], jit)
        jit = math.sqrt(max(np.mean(r ** 2) - np.mean(e ** 2), 0.0))
    _, r0, chi0, _ = solve(base, jit)
    res = dict(target=target, instrument=instrument, days=len(t), clipped=clipped, first=round(float(t.min()), 1), last=round(float(t.max()), 1),
               programmes=[str(p) for p in np.unique(prog)], jitter=round(jit, 3),
               de440=dict(scale=round(float(c[-1]), 3), scale_err=round(float(math.sqrt(cov[-1, -1])), 3), range_ms=[round(float(truth.min()), 2),
                          round(float(truth.max()), 2)], rms_without=round(float(np.std(r0)), 3), rms_with=round(float(np.std(r)), 3)))
    periods = np.exp(np.linspace(math.log(pmin), math.log(pmax), 6000))
    dchi = np.empty(len(periods))
    best = None
    for i, P in enumerate(periods):
        th = 2.0 * np.pi * (t - 51544.5) / P
        # the Sun's velocity A (-sin th, cos th) in the ecliptic, its component along u entering the velocities with a minus sign
        ca = np.sin(th) * unit[:, 0] - np.cos(th) * unit[:, 1]
        cb = np.cos(th) * unit[:, 0] + np.sin(th) * unit[:, 1]
        cc, _, chi, _ = solve(base + [ca, cb], jit)
        dchi[i] = chi0 - chi
        if best is None or dchi[i] > best[0]:
            best = (float(dchi[i]), float(P), float(math.hypot(cc[-2], cc[-1])), float(math.degrees(math.atan2(cc[-1], cc[-2]))))
    res["blind"] = dict(period_d=round(best[1], 1), period_yr=round(best[1] / 365.25, 2), speed_ms=round(best[2], 3), phase_deg=round(best[3], 1),
                        dchi2=round(best[0], 1), planet_mass_mjup=round(planets_msini(best[1], best[2], 0.0, 1.0), 3))
    np.savez_compressed(os.path.join(out, "periodogram.npz"), period=periods, dchi2=dchi)
    json.dump(res, open(os.path.join(out, "fit.json"), "w"), separators=(",", ":"))
    print(json.dumps(res, indent=1), flush=True)


def solar_reflected(target="Sun", instrument="HARPS", programme="1102.D-0954(A)", contrasts=(1e-3, 3e-4, 1e-4, 3e-5, 1e-5), period=4.2308, kp=133.0,
                    components=5, draws=3, seed=17, sysrem=(10,), nulls=0):
    """Reflected light laid into a target's daily spectra and sought as the giants mode seeks it around other stars, to RESULTS/<tag>/reflected.json. The
    days of PROGRAMME, each on the giants mode's optical grid, carry a copy of the days' median spectrum at CONTRAST times Lambert's phase function, moved
    by K_P sin(2 pi phase) on an orbit of PERIOD days whose phase is drawn at random, DRAWS times for each contrast and NULLS times (DRAWS where NULLS is
    0) with no copy; the residuals over their median, with the telluric bands and the sodium sky lines set aside and a cubic taken out of each row, are
    cleaned by each count of SysRem passes in SYSREM and cross-correlated with the median's line depths, the star's pattern and COMPONENTS principal
    components taken out of the rows, and the rows summed in the planet's frame over K_p and rest velocity with Lambert's weights where the planet moves
    more than 25 km/s from the star (spectra_planet_frame): the map's value at the orbit against its scatter away from the star and the orbit, and for
    each contrast the share of draws above the runs without a copy by three of their standard deviations."""
    tag = archive_tag(instrument, target)
    files = sorted(glob.glob(os.path.join(solar_ROOT, tag, "days", "*.npz")), key=lambda f: int(os.path.basename(f)[:-4]))
    g = spectra_grid("optical")
    F, t = [], []
    for f in files:
        d = np.load(f)
        if str(d["programme"]) != programme or int(d["n"]) < 4:
            continue
        F.append(np.interp(g, solar_day_grid(d), d["flux"].astype(float), left=np.nan, right=np.nan))
        t.append(float(d["mjd"]))
    F, t = np.array(F), np.array(t)
    master = gpu_host(gpu_nanmedian(F, 0))
    T = spectra_depths(master)
    kp_grid, vrest = np.arange(0.0, 301.0, 5.0), np.arange(-100.0, 101.0, 1.0)
    quiet = (kp_grid >= 60.0)[:, None] & (np.abs(vrest) > 40.0)[None, :]
    i0, j0 = int(np.argmin(np.abs(kp_grid - kp))), int(np.argmin(np.abs(vrest)))
    rng = np.random.default_rng(seed)
    # the telluric bands and the sodium sky lines set aside
    Fd, Md, Td, G = gpu_dev(F), gpu_dev(master), gpu_dev(T), gpu_dev(g)
    aside = torch.zeros(len(g), dtype=torch.bool, device=gpu_DEVICE)
    for lo, hi in spectra_BANDS["optical"]["telluric"]:
        aside |= (G > lo) & (G < hi)
    for sky in spectra_SKY:
        aside |= (G - sky).abs() < 0.3

    def search(c, phi0):
        ph = ((t - t.min()) / period + phi0) % 1.0
        vp = kp * np.sin(2 * np.pi * ph)
        lam = spectra_lambert(ph)
        Fi = Fd
        if c > 0:
            lt = gpu_dev(lam)[:, None]
            Fi = (Fd + c * lt * gpu_interp(G[None, :] / (1.0 + gpu_dev(vp)[:, None] / spectra_C), G, Md)) / (1.0 + c * lt)
        R = Fi / gpu_nanmedian(Fi, 0) - 1.0
        R[:, aside] = gpu_NAN
        # a cubic in wavelength taken out of each row
        R = gpu_rowpoly(R + 1.0, 3) - 1.0
        sd = gpu_nanstd(R, 0)
        floor = gpu_nanmedian(sd, 0)
        sd = torch.where(torch.isfinite(sd) & (sd > 0), torch.maximum(sd, 0.1 * floor), floor)
        w = np.where(np.abs(vp) > 25.0, lam, 0.0)
        snr, done = {}, 0
        for n in settings:
            if n > done:
                R = gpu_sysrem(R, sd, n - done)
                done = n
            rows = spectra_components(spectra_unpattern(gpu_host(gpu_xcorr(R, Td, sd))), components)
            m = gpu_host(gpu_planet_frame(rows, np.sin(2 * np.pi * ph), w, kp_grid, vrest))
            noise = float(np.nanstd(m[quiet]))
            snr[n] = round(float(m[i0, j0] / noise) if noise > 0 else 0.0, 2)
        return snr
    settings = sorted({int(n) for n in np.atleast_1d(sysrem)})
    empty = [search(0.0, rng.uniform()) for _ in range(nulls or draws)]
    laid = {c: [search(c, rng.uniform()) for _ in range(draws)] for c in contrasts}
    res = dict(target=target, programme=programme, days=len(t), period=period, kp=kp, components=components, draws=draws, sysrem={})
    for n in settings:
        null = np.array([x[n] for x in empty])
        cut = float(null.mean() + 3.0 * null.std(ddof=1))
        res["sysrem"][str(n)] = dict(null=[x[n] for x in empty], null_mean=round(float(null.mean()), 2), null_sd=round(float(null.std(ddof=1)), 2),
                                     threshold=round(cut, 2), contrasts={"%g" % c: [x[n] for x in laid[c]] for c in contrasts},
                                     recovered={"%g" % c: round(float(np.mean([x[n] > cut for x in laid[c]])), 2) for c in contrasts})
        for c in contrasts:
            print("%s, %d SysRem passes: contrast %g at K_p %.0f km/s: S/N at the orbit %s, %.0f per cent above %.2f (no planet %.2f +- %.2f)" % (
                tag, n, c, kp, [x[n] for x in laid[c]], 100 * res["sysrem"][str(n)]["recovered"]["%g" % c], cut, null.mean(), null.std(ddof=1)), flush=True)
    out = os.path.join(solar_RESULTS, tag)
    os.makedirs(out, exist_ok=True)
    json.dump(res, open(os.path.join(out, "reflected.json"), "w"), separators=(",", ":"))


def solar_orbit(target="Europa", host="jupiter", instrument="HARPS", vrange=120):
    """A moon's reflected sunlight in its planet's frame, to RESULTS/<tag>/orbit.json: each spectrum of solar days --each moved by the host's frame
    velocity less the target's (solar_frame), cross-correlated with the target's line depths, and summed along the predicted track scaled from 0 to 2
    and offset within 50 km/s. A right frame puts the map's peak at 1 and 0 and each row's peak on the track."""
    tag = archive_tag(instrument, target)
    files = sorted(glob.glob(os.path.join(solar_ROOT, tag, "days", "*.npz")), key=lambda f: int(os.path.basename(f)[:-4]))
    g = spectra_grid("optical")
    rows, t, b = [], [], []
    for f in files:
        d = np.load(f)
        rows.append(np.interp(g, solar_day_grid(d), d["flux"].astype(float), left=np.nan, right=np.nan))
        t.append(float(d["mjd"]))
        b.append(float(d["b"]))
    t, b = np.array(t), np.array(b)
    track = solar_frame(t, solar_BODIES.get(host.lower(), host.lower()), solar_site(instrument))[0] - b
    F, G = gpu_dev(np.array(rows)), gpu_dev(g)
    for lo, hi in spectra_BANDS["optical"]["telluric"]:
        F[:, (G > lo) & (G < hi)] = gpu_NAN
    T = gpu_dev(spectra_depths(gpu_host(gpu_nanmedian(F, 0))))
    # each row moved along the track
    ccf = gpu_xcorr(gpu_shift_rows(F, -gpu_dev(track)) - 1.0, T, None, vrange)
    lag = np.arange(-vrange, vrange + 1, dtype=float)
    c = gpu_host(ccf)
    k = np.clip(np.argmax(c, 1), 1, len(lag) - 2)
    i = np.arange(len(c))
    a_, b_, c_ = c[i, k - 1], c[i, k], c[i, k + 1]
    den = a_ - 2 * b_ + c_
    peak = lag[k] + np.where(den < 0, 0.5 * (a_ - c_) / np.where(den < 0, den, -1.0), 0.0)
    amp = float(np.max(np.abs(track)))
    scale, vrest = np.arange(0.0, 2.0 + 1e-9, 0.005), np.arange(-50.0, 50.0 + 1e-9, 0.25)
    m = gpu_host(gpu_planet_frame(ccf, track / amp, np.ones(len(t)), scale * amp, vrest))
    a, j = np.unravel_index(int(np.argmax(m)), m.shape)
    far = (np.abs(scale[:, None] - 1.0) > 0.25) | (np.abs(vrest[None, :]) > 10.0)
    res = dict(target=target, host=host, spectra=len(t), nights=int(len(np.unique(np.floor(t + 0.3)))), first=round(float(t.min()), 4), last=round(float(t.max()), 4),
               track_kms=[round(float(track.min()), 3), round(float(track.max()), 3)], peak_scale=round(float(scale[a]), 3), peak_rest_kms=round(float(vrest[j]), 2),
               peak_snr=round(float((m[a, j] - np.median(m[far])) / np.std(m[far])), 1), rows_minus_track_kms=dict(
                   mean=round(float(np.mean(peak - track)), 3), rms=round(float(np.std(peak - track)), 3), median_abs=round(float(np.median(np.abs(peak - track))), 3)))
    out = os.path.join(solar_RESULTS, tag)
    os.makedirs(out, exist_ok=True)
    np.savez_compressed(os.path.join(out, "orbit_map.npz"), scale=scale, vrest=vrest, map=m, mjd=t, track=track, peak=peak)
    json.dump(res, open(os.path.join(out, "orbit.json"), "w"), separators=(",", ":"))
    print("%s about %s: %d spectra on %d nights, track %+.2f to %+.2f km/s; map peak at %.3f times the track and %+.2f km/s (S/N %.1f); rows' peaks less the track "
          "%+.3f +- %.3f km/s" % (target, host, len(t), res["nights"], track.min(), track.max(), res["peak_scale"], res["peak_rest_kms"], res["peak_snr"],
                                  res["rows_minus_track_kms"]["mean"], res["rows_minus_track_kms"]["rms"]), flush=True)


# the temperatures (K) at which the bodies' molecules absorb, on petitRADTRANS's grid
solar_TEMPS = {"venus": 270.0, "mars": 200.0, "jupiter": 148.0, "saturn": 148.0, "titan": 110.0, "uranus": 81.0, "neptune": 81.0}


def solar_molecules(target="Venus", instrument="ESPRESSO", species=("CO2",), temp=None, vmax=100.0):
    """A body's own molecules in its reflected sunlight, to RESULTS/<tag>/molecules.json: cross-correlations read at its atmosphere's velocity and at Earth's."""
    body = solar_BODIES.get(target.lower()) or target.lower()
    tag = archive_tag(instrument, target)
    files = sorted(glob.glob(os.path.join(solar_ROOT, tag, "days", "*.npz")), key=lambda f: int(os.path.basename(f)[:-4]))
    grid, rows, t, b = None, [], [], []
    for f in files:
        d = np.load(f)
        g = solar_day_grid(d)
        grid = g if grid is None else grid
        rows.append(d["flux"].astype(float) if len(g) == len(grid) else np.interp(grid, g, d["flux"].astype(float), left=np.nan, right=np.nan))
        t.append(float(d["mjd"]))
        b.append(float(d["b"]))
    t, b = np.array(t), np.array(b)
    vbody = solar_frame(t, body, solar_site(instrument), planet=True)[3]
    G = gpu_dev(grid)
    R = gpu_dev(np.array(rows)) - 1.0
    for lo, hi in spectra_BANDS["optical"]["telluric"]:
        R[:, (G > lo) & (G < hi)] = gpu_NAN
    for sky in spectra_SKY:
        R[:, (G - sky).abs() < 0.3] = gpu_NAN
    step = (grid[1] / grid[0] - 1.0) * spectra_C
    nlag = int(round(vmax / step))
    lag = np.arange(-nlag, nlag + 1) * step
    offs = np.arange(-(vmax - 20.0), vmax - 20.0 + step / 2.0, step)
    temp = temp or solar_TEMPS.get(body, 200.0)
    res = dict(target=target, instrument=instrument, spectra=len(t), nights=int(len(np.unique(np.floor(t + 0.3)))), temp=temp,
               body_kms=[round(float(vbody.min()), 3), round(float(vbody.max()), 3)], earth_kms=[round(float(b.min()), 3), round(float(b.max()), 3)], species={})
    curves = {}
    for sp in species:
        T = np.interp(grid, spectra_grid("visible"), giants_template(sp, temp, band="visible"), left=0.0, right=0.0)
        if not T.any():
            res["species"][sp] = dict(note="no lines on the grid")
            print("%s %s %s: no lines on the grid" % (target, instrument, sp), flush=True)
            continue
        c = gpu_host(gpu_xcorr(R, T, None, nlag))
        wt = np.array([1.0 / max(float(np.nanstd(c[i][np.abs(lag - vbody[i]) > 20.0])), 1e-12) ** 2 for i in range(len(c))])

        def curve(v0):
            """The rows' weighted mean read at V0 plus each offset."""
            m = np.array([np.interp(v0[i] + offs, lag, c[i], left=np.nan, right=np.nan) for i in range(len(c))])
            ok = np.isfinite(m)
            return (np.where(ok, m, 0.0) * wt[:, None]).sum(0) / np.maximum((ok * wt[:, None]).sum(0), 1e-30)
        # each curve less its median beyond 20 km/s, in units of its scatter there
        quiet = np.abs(offs) > 20.0
        z = lambda y: (y - np.median(y[quiet])) / max(float(np.std(y[quiet])), 1e-30)
        cb, ce = z(curve(vbody)), z(curve(b))
        sb = se = 1.0
        k0, kp = int(np.argmin(np.abs(offs))), int(np.argmax(cb))
        # each row's peak within 20 km/s of the body's velocity, refined by a parabola through the three highest samples
        peaks = []
        for i in range(len(c)):
            j = np.where(np.abs(lag - vbody[i]) < 20.0)[0]
            k = int(np.clip(j[int(np.argmax(c[i][j]))], 1, len(lag) - 2))
            a_, b_, c_ = c[i][k - 1], c[i][k], c[i][k + 1]
            den = a_ - 2 * b_ + c_
            peaks.append(lag[k] + (0.5 * (a_ - c_) / den * step if den < 0 else 0.0) - vbody[i])
        peaks = np.array(peaks)
        covered = float((T * gpu_host(torch.isfinite(R).all(0))).sum() / T.sum())
        res["species"][sp] = dict(snr_body=round(float(cb[k0] / sb), 1), peak_offset_kms=round(float(offs[kp]), 2), peak_snr=round(float(cb[kp] / sb), 1),
                                  snr_earth=round(float(ce[k0] / se), 1), template_covered=round(covered, 3),
                                  rows_peak_minus_body_kms=dict(median=round(float(np.median(peaks)), 3), rms=round(float(np.std(peaks)), 3)))
        curves[sp] = (cb, ce)
        x = res["species"][sp]
        print("%s %s %s: S/N %s at the body's velocity, the curve's peak %+.2f km/s from it (S/N %s), rows' peaks %+.3f +- %.3f km/s from it; S/N %s at the "
              "Earth's; %.0f per cent of the template covered" % (target, instrument, sp, x["snr_body"], x["peak_offset_kms"], x["peak_snr"],
                                                                 x["rows_peak_minus_body_kms"]["median"], x["rows_peak_minus_body_kms"]["rms"], x["snr_earth"],
                                                                 100 * covered), flush=True)
    out = os.path.join(solar_RESULTS, tag)
    os.makedirs(out, exist_ok=True)
    np.savez_compressed(os.path.join(out, "molecules.npz"), offsets=offs, species=np.array(list(curves)), body=np.array([x[0] for x in curves.values()]),
                        earth=np.array([x[1] for x in curves.values()]), mjd=t, body_kms=vbody, earth_kms=b)
    json.dump(res, open(os.path.join(out, "molecules.json"), "w"), separators=(",", ":"))


# the Earth's own lines: the oxygen B and gamma bands, water near H alpha and sodium
solar_EARTH_BANDS = {"O2 B": (6860.0, 6910.0), "O2 gamma": (6270.0, 6330.0), "H2O": (6470.0, 6555.0), "Na D": (5888.0, 5898.0)}


def solar_eclipse(programme="086.C-0448(A)", target="Moon", instrument="HARPS", streams=4, keep=False):
    """Measure the Earth's atmosphere in transmission during a lunar eclipse, writing RESULTS/<instrument>_eclipse/eclipse.json.

    Each spectrum is placed outside the shadow, in the penumbra or in the umbra from the point on the Moon its fibre observed. Its telluric optical depth
    is measured in the observatory frame. Over the spectra outside the shadow, the depth at each wavelength is fitted as a linear function of airmass;
    each spectrum's excess depth beyond that fit is reported in units of the depth per unit airmass, over all telluric lines and in each band of
    solar_EARTH_BANDS. Oxygen, which is well mixed, traces sunlight refracted through the Earth's limb; water varies during the night and traces the
    local atmosphere."""
    from astropy.coordinates import GCRS, SkyCoord, get_body, get_sun
    from astropy.io import fits
    from astropy.time import Time
    import astropy.units as u_
    q = ("SELECT dp_id, t_min, t_exptime, snr FROM ivoa.ObsCore WHERE dataproduct_type = 'spectrum' AND instrument_name = '%s' AND target_name = '%s' AND "
         "proposal_id = '%s'" % (instrument, target, programme))
    rows = sorted(archive_tap("eso", q), key=lambda r: float(r["t_min"]))
    tag = archive_tag(instrument, "eclipse")
    paths = archive_eso_fetch(rows, os.path.join(solar_ROOT, tag, "spectra"), streams=streams)
    loaded = [(p, s) for p, s in zip(paths, spectra_load_many(paths)) if s is not None]
    spectra, heads = [s for _, s in loaded], [fits.getheader(p) for p, _ in loaded]
    mjd = np.array([s[3]["mjd"] for s in spectra])
    airmass = np.array([0.5 * (archive_num(h.get("HIERARCH ESO TEL AIRM START"), np.nan) + archive_num(h.get("HIERARCH ESO TEL AIRM END"), np.nan)) for h in heads])
    rate = np.array([float(np.nanmedian(s[1])) / max(archive_num(h.get("EXPTIME"), 1.0), 1e-3) for s, h in zip(spectra, heads)])
    # The point on the Moon seen by the fibre: the telescope pointing projected to the Moon's distance from the observatory. Its angle from the antisolar
    # direction (the shadow's axis, seen from the Earth's centre) is compared with the umbra and penumbra radii, enlarged by 2% for the atmosphere.
    t = Time(mjd, format="mjd")
    loc = archive_location(solar_site(instrument))
    moon, sun = get_body("moon", t), get_sun(t)
    km = lambda c: c.cartesian.xyz.to(u_.km).value
    xm, xs, xo = km(moon), km(sun), loc.get_gcrs(t).cartesian.xyz.to(u_.km).value
    look = SkyCoord(ra=[archive_num(h.get("RA"), np.nan) for h in heads] * u_.deg, dec=[archive_num(h.get("DEC"), np.nan) for h in heads] * u_.deg,
                    frame="icrs").transform_to(GCRS(obstime=t)).cartesian.xyz.value
    point = xo + np.linalg.norm(xm - xo, axis=0) * look
    off_disc = np.linalg.norm(point - xm, axis=0) > 1737.4
    sep = np.degrees(np.arccos(np.clip(np.sum(point * -xs, 0) / (np.linalg.norm(point, axis=0) * np.linalg.norm(xs, axis=0)), -1.0, 1.0)))
    dm, ds = np.linalg.norm(xm, axis=0), np.linalg.norm(xs, axis=0)
    pm, ps, rs = (np.degrees(np.arcsin(x)) for x in (6378.0 / dm, 6378.0 / ds, 696000.0 / ds))
    umbra, penumbra = 1.02 * (pm + ps - rs), 1.02 * (pm + ps + rs)
    place = np.where(off_disc, "off the Moon", np.where(sep < umbra, "umbra", np.where(sep < penumbra, "penumbra", "outside")))
    if (place == "outside").sum() < 2:
        raise SystemExit("%s: %d spectra outside the shadow" % (programme, int((place == "outside").sum())))
    b = solar_frame(mjd, "moon", solar_site(instrument))[0]
    bp = np.array([meta.get("berv") or 0.0 for w, f, e, meta in spectra])
    grid = solar_grid()
    # each spectrum in the Sun's frame over the Sun's own spectrum, then in the observatory's frame, where its Earth lines stand still
    F = spectra_onto([(w * (1.0 + bi / spectra_C) / (1.0 + b0 / spectra_C), f, e) for (w, f, e, meta), bi, b0 in zip(spectra, b, bp)], grid, 1001)[0]
    sun_days = sorted(glob.glob(os.path.join(solar_ROOT, archive_tag(instrument, "Sun"), "days", "*.npz")))
    sun = gpu_host(gpu_nanmedian(gpu_dev(np.array([np.interp(grid, solar_day_grid(d), d["flux"].astype(float), left=np.nan, right=np.nan)
                                                   for d in (np.load(f) for f in sun_days)])), 0))
    # Divide each spectrum by the solar spectrum, shift it to the observatory frame, where telluric lines are at rest, and convert it to optical depth.
    trans = np.array([np.interp(grid * (1.0 + b[i] / spectra_C), grid, F[i] / sun, left=np.nan, right=np.nan) for i in range(len(spectra))])
    tau = -np.log(np.where(trans > 0.05, trans, np.nan))
    # Local atmosphere: the optical depth at each wavelength fitted as a linear function of airmass over the spectra outside the shadow.
    o = (place == "outside") & np.isfinite(airmass)
    good = np.isfinite(tau[o]).all(0)
    coef = np.linalg.lstsq(np.column_stack([np.ones(o.sum()), airmass[o]]), tau[o][:, good], rcond=None)[0]
    a0, Tz = np.full(len(grid), np.nan), np.full(len(grid), np.nan)
    a0[good], Tz[good] = coef
    lines = np.isfinite(Tz) & (Tz > 0.02) & (Tz < 2.0)
    out = []
    for i in range(len(spectra)):
        r = tau[i] - a0 - airmass[i] * Tz
        fit = lambda m: float(np.nansum((r * Tz)[m]) / max(float(np.sum((Tz ** 2)[m & np.isfinite(r)])), 1e-30))
        ok = lines & np.isfinite(r)
        out.append(dict(mjd=round(float(mjd[i]), 5), shadow_deg=round(float(sep[i]), 3), place=str(place[i]), airmass=round(float(airmass[i]), 3),
                        rate=float("%.4g" % rate[i]), excess=round(fit(ok), 3), bands={k: round(fit(ok & (grid > lo) & (grid < hi)), 3) for k, (lo, hi) in
                                                                                     solar_EARTH_BANDS.items()}))
    places = ("outside", "penumbra", "umbra", "off the Moon")
    res = dict(programme=programme, instrument=instrument, spectra=len(spectra), umbra_deg=round(float(np.mean(umbra)), 3), penumbra_deg=round(float(np.mean(penumbra)), 3),
               earth_line_samples=int(lines.sum()), by_place={p: dict(n=int((place == p).sum()), airmass=round(float(np.nanmean(airmass[place == p])), 3),
                                                                 excess=round(float(np.mean([x["excess"] for x in out if x["place"] == p])), 3),
                                                                 bands={k: round(float(np.mean([x["bands"][k] for x in out if x["place"] == p])), 3) for k in solar_EARTH_BANDS})
                                                         for p in places if (place == p).any()}, spectra_rows=out)
    os.makedirs(os.path.join(solar_RESULTS, tag), exist_ok=True)
    json.dump(res, open(os.path.join(solar_RESULTS, tag, "eclipse.json"), "w"), separators=(",", ":"))
    if not keep:
        shutil.rmtree(os.path.join(solar_ROOT, tag, "spectra"), ignore_errors=True)
    for p, x in res["by_place"].items():
        print("%s %s: %d spectra %s at airmass %.2f, telluric excess %+.3f in units of the local depth per airmass; %s" % (
            programme, instrument, x["n"], "outside the shadow" if p == "outside" else p if p == "off the Moon" else "in the " + p, x["airmass"], x["excess"],
            ", ".join("%s %+.3f" % kv for kv in x["bands"].items())), flush=True)


# the bodies whose own atmospheres the molecules step reads, each with its molecule, and the moons the orbit step follows, each with its planet
solar_ATMOSPHERES = {"Venus": "CO2", "Mars": "CO2", "Jupiter": "CH4", "Saturn": "CH4", "Uranus": "CH4", "Neptune": "CH4", "Titan": "CH4"}
solar_MOONS = {"Io": "jupiter", "Europa": "jupiter", "Ganymede": "jupiter", "Callisto": "jupiter", "Titan": "saturn"}


def solar_all(instruments=("HARPS", "ESPRESSO", "FEROS", "UVES")):
    """Every result of the solar mode for every body with public spectra from INSTRUMENTS, each made again where it is missing or older than the newest
    day it reads: the Sun's and the Moon's days from HARPS measured line by line and set against DE440 (plan, days, lbl, fit), reflected light laid into
    the Sun's days (reflected), each moon's reflected light followed in its planet's frame (orbit), each planet's and Titan's own molecule in the light it
    reflects (molecules), and the Earth's atmosphere through the lunar eclipse of 2010 December 21 (eclipse). A step that fails is reported and the rest
    go on."""
    def newer(result, target, instrument):
        days = glob.glob(os.path.join(solar_ROOT, archive_tag(instrument, target), "days", "*.npz"))
        return bool(days) and (not os.path.exists(result) or os.path.getmtime(result) < max(os.path.getmtime(d) for d in days))

    def step(call, *args, **kw):
        try:
            return call(*args, **kw)
        except Exception as exc:
            print("%s%s failed: %s: %s" % (call.__name__, args, type(exc).__name__, str(exc)[:200]), flush=True)
    for target in ("Sun", "Moon"):
        if step(solar_plan, target, "HARPS"):
            step(solar_days, target, "HARPS")
            out = os.path.join(solar_RESULTS, archive_tag("HARPS", target))
            if newer(os.path.join(out, "velocities.csv"), target, "HARPS"):
                step(solar_lbl, target, "HARPS")
            if newer(os.path.join(out, "fit.json"), target, "HARPS"):
                step(solar_fit, target, "HARPS")
    if newer(os.path.join(solar_RESULTS, "HARPS_Sun", "reflected.json"), "Sun", "HARPS"):
        step(solar_reflected)
    for target, host in solar_MOONS.items():
        for inst in instruments:
            if step(solar_plan, target, inst):
                step(solar_days, target, inst, each=True)
                if newer(os.path.join(solar_RESULTS, archive_tag(inst, target), "orbit.json"), target, inst):
                    step(solar_orbit, target, host, inst)
    for target, species in solar_ATMOSPHERES.items():
        for inst in instruments:
            if step(solar_plan, target, inst):
                step(solar_days, target, inst, each=True)
                if newer(os.path.join(solar_RESULTS, archive_tag(inst, target), "molecules.json"), target, inst):
                    step(solar_molecules, target, inst, (species,))
    if not os.path.exists(os.path.join(solar_RESULTS, archive_tag("HARPS", "eclipse"), "eclipse.json")):
        step(solar_eclipse)


def solar_cli():
    archive_quiet_warnings()
    ap = argparse.ArgumentParser(prog="orbitlight.py solar", description=solar_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = ap.add_subparsers(dest="cmd")
    for cmd, help_ in (("plan", "a target's public spectra in the archive"), ("days", "each day's spectra fetched, moved into the Sun's frame and averaged"),
                       ("lbl", "the days' velocities line by line"), ("fit", "the velocities set against DE440's and searched blind"),
                       ("reflected", "reflected light laid into the days' spectra and sought as around other stars"),
                       ("orbit", "a moon's reflected light followed in its planet's frame"),
                       ("molecules", "a body's own molecules in its reflected light, at the velocity its atmosphere imposes"),
                       ("eclipse", "the Earth's atmosphere in transmission through a lunar eclipse")):
        s = sub.add_parser(cmd, help=help_)
        s.add_argument("--target", default={"orbit": "Europa", "molecules": "Venus"}.get(cmd, "Sun"), help="the archive's target name: Sun, Moon, a planet or a moon")
        s.add_argument("--instrument", default="HARPS")
        if cmd == "eclipse":
            s.add_argument("--programme", default="086.C-0448(A)")
            s.add_argument("--keep", action="store_true", help="keep the downloaded spectra for later runs")
        if cmd == "molecules":
            s.add_argument("--species", nargs="+", default=["CO2"])
            s.add_argument("--temp", type=float, default=None, help="the molecules' temperature (K), the body's by default")
            s.add_argument("--vmax", type=float, default=100.0)
        if cmd == "orbit":
            s.add_argument("--host", default="jupiter", help="the planet the target orbits")
        if cmd == "days":
            s.add_argument("--per-day", type=int, default=16)
            s.add_argument("--streams", type=int, default=6)
            s.add_argument("--most-days", type=int, default=0)
            s.add_argument("--each", action="store_true", help="every spectrum a row of its own, for a body that moves within a night")
        if cmd == "lbl":
            s.add_argument("--min-spectra", type=int, default=4, help="days of fewer spectra left out")
        if cmd == "reflected":
            s.add_argument("--contrasts", type=float, nargs="+", default=[1e-3, 3e-4, 1e-4, 3e-5, 1e-5])
            s.add_argument("--components", type=int, default=5, help="principal components taken out of the cross-correlation rows")
            s.add_argument("--sysrem", type=int, nargs="+", default=[10], help="counts of SysRem passes over the residuals, read off one run")
            s.add_argument("--draws", type=int, default=3, help="orbital phases drawn for each contrast")
            s.add_argument("--nulls", type=int, default=0, help="runs with no planet, as many as --draws by default")
        if cmd == "fit":
            s.add_argument("--pmin", type=float, default=300.0)
            s.add_argument("--pmax", type=float, default=30000.0)
    a = ap.parse_args()
    if a.cmd is None:
        solar_all()
    elif a.cmd == "plan":
        solar_plan(a.target, a.instrument)
    elif a.cmd == "days":
        solar_days(a.target, a.instrument, a.per_day, a.streams, a.most_days, a.each)
    elif a.cmd == "lbl":
        solar_lbl(a.target, a.instrument, a.min_spectra)
    elif a.cmd == "reflected":
        solar_reflected(a.target, a.instrument, contrasts=tuple(a.contrasts), components=a.components, sysrem=tuple(a.sysrem), draws=a.draws, nulls=a.nulls)
    elif a.cmd == "orbit":
        solar_orbit(a.target, a.host, a.instrument)
    elif a.cmd == "molecules":
        solar_molecules(a.target, a.instrument, tuple(a.species), a.temp, a.vmax)
    elif a.cmd == "eclipse":
        solar_eclipse(a.programme, "Moon" if a.target == "Sun" else a.target, a.instrument, keep=a.keep)
    else:
        solar_fit(a.target, a.instrument, a.pmin, a.pmax)


giants_DOC = """The giant planets, the NASA Exoplanet Archive's and orbitlight's own new ones: their archived spectra placed on their orbits, the transit search for atoms and molecules in the planet's frame, reflected
starlight from the planets without a transit, and dayside emission. The atoms' templates come from Kurucz's gfall list (NIST's lines in its place),
the molecules' from petitRADTRANS's line-by-line cross-sections (HITRAN's lines in their place); each transit set's residuals are cross-correlated
with every template, the star's Doppler shadow is taken out, and the rows are summed in the planet's frame over K_p and rest velocity against a sham
of out-of-transit rows.

    plan      the giant planets with their archived spectra placed on their orbits
    fetch     the in-transit and eclipse spectra, with the same nights' others
    search    the transit search, each species' map and result kept
    record    the searches and the reflected-light limits written as the run's record
    reflected reflected starlight of the planets without a transit
    emission  dayside thermal emission in SPIRou's spectra"""

giants_ROOT = archive_data("giants")
# the run's record under the results root
giants_RUN = "giants_planet_frame"
giants_SPECIES =("Fe I", "Fe II", "Ti I", "V I", "Cr I", "Na I", "Ca I", "Mg I", "K I")
giants_MOLECULES = ("H2O", "CO")
giants_KURUCZ = os.path.join(giants_ROOT, "lines", "gfall08oct17.dat")

giants_CODES = {"Fe I": "26.00", "Fe II": "26.01", "Ti I": "22.00", "Ti II": "22.01", "V I": "23.00", "Cr I": "24.00", "Cr II": "24.01", "Mn I": "25.00",
                "Ni I": "28.00", "Co I": "27.00", "Na I": "11.00", "Ca I": "20.00", "Ca II": "20.01", "Mg I": "12.00", "K I": "19.00", "Sc II": "21.01",
                "Y II": "39.01", "Ba II": "56.01", "Sr II": "38.01", "Li I": "3.00", "Si I": "14.00", "Al I": "13.00"}


def giants_kurucz(species, band="optical"):
    """A species' records within a band's span from Kurucz's gfall list (air wavelengths above 200 nm): wavelengths (A); log gf with the record's hyperfine and isotopic fractions added, since a line split into components lists the whole line's gf on each; the lower level's energy (cm^-1), the lower of the record's two levels, since gfall lists the even-parity level first whichever lies lower; and the line each record belongs to, a line's components sharing its two levels; parsed once into ROOT/lines/<species>_<band>_gfall.npz."""
    cache = os.path.join(giants_ROOT, "lines", species.replace(" ", "_") + ("" if band == "optical" else "_" + band) + "_gfall.npz")
    if os.path.exists(cache):
        d = np.load(cache)
        return d["lam"], d["loggf"], d["elow"], d["line"]
    code = giants_CODES[species]
    lo, hi = spectra_BANDS[band]["lo"], spectra_BANDS[band]["hi"]
    lam, loggf, levels = [], [], []
    with open(giants_KURUCZ, encoding="ascii", errors="replace") as fh:
        for line in fh:
            if line[18:24].strip() != code:
                continue
            try:
                # a predicted level's energy is written negative; a blank fraction is a whole line's
                w, e1, e2 = float(line[0:11]) * 10.0, abs(float(line[24:36])), abs(float(line[52:64]))
                gf = float(line[11:18]) + float(line[109:115].strip() or 0.0) + float(line[118:124].strip() or 0.0)
            except ValueError:
                # a line of the list's other layouts
                continue
            if lo <= w <= hi:
                lam.append(w)
                loggf.append(gf)
                levels.append((min(e1, e2), max(e1, e2)))
    levels = np.array(levels, float).reshape(-1, 2)
    lam, loggf, elow = np.array(lam), np.array(loggf), levels[:, 0]
    ids = np.unique(levels, axis=0, return_inverse=True)[1].ravel() if len(levels) else np.zeros(0, int)
    os.makedirs(os.path.dirname(cache), exist_ok=True)
    np.savez(cache, lam=lam, loggf=loggf, elow=elow, line=ids)
    return lam, loggf, elow, ids


giants_WEIGHT = "log"
giants_HITRAN = "https://hitran.org/lbl/api"
giants_HITRAN_ISO = {"H2O": 1, "CO": 26, "CH4": 32, "CO2": 7, "NH3": 45, "HCN": 23}


def giants_hitran(gas, lo_a=9500.0, hi_a=25000.0, step=100.0):
    """A gas's HITRAN lines of its main isotopologue between two wavelengths (A): wavenumber (cm^-1), intensity at 296 K and lower-level energy (cm^-1), read page by page per wavenumber range until a page comes back empty, kept in ROOT/lines/<gas>_hitran.npz."""
    cache = os.path.join(giants_ROOT, "lines", gas + "_hitran.npz")
    if os.path.exists(cache):
        d = np.load(cache)
        return d["nu"], d["sw"], d["elow"]

    def page(lo, hi):
        url = giants_HITRAN + "?" + urllib.parse.urlencode(dict(iso_ids_list=giants_HITRAN_ISO[gas], numin="%.6f" % lo, numax="%.6f" % hi, request_params="nu,sw,elower"))
        for attempt in range(4):
            try:
                body = urllib.request.urlopen(urllib.request.Request(url, headers=archive_UA), timeout=300).read()
            except http.client.IncompleteRead as e:
                body = e.partial
            except urllib.error.HTTPError as e:
                if e.code == 404:
                    return np.zeros((0, 3))
                time.sleep(5 * (attempt + 1))
                continue
            except OSError:
                time.sleep(5 * (attempt + 1))
                continue
            rows = [r.split(",") for r in body.decode("ascii", "replace").split() if r.count(",") == 2]
            return np.array(rows[:-1] if len(rows) > 1 else rows, dtype=float).reshape(-1, 3)
        raise IOError("HITRAN did not answer for %s %g-%g" % (gas, lo, hi))

    def one(lo):
        hi, parts = lo + step, []
        while hi - lo > 1e-3:
            a = page(lo, hi)
            if not len(a):
                break
            parts.append(a)
            lo = a[-1, 0] + 1e-6
        return np.concatenate(parts) if parts else np.zeros((0, 3))
    starts = np.arange(1e8 / hi_a, 1e8 / lo_a, step)
    a = np.concatenate([x for x in archive_pmap(one, starts, 4) if len(x)])
    a = np.unique(a, axis=0)
    os.makedirs(os.path.dirname(cache), exist_ok=True)
    np.savez(cache, nu=a[:, 0], sw=a[:, 1], elow=a[:, 2])
    return a[:, 0], a[:, 1], a[:, 2]


giants_PRT = os.path.join(giants_ROOT, "opacities")
giants_PRT_NAMES = {"CO": "CO_main_iso", "H2O": "H2O_main_iso", "CH4": "CH4_main_iso", "CO2": "CO2_main_iso"}
giants_PRT_TEMPS = (81.14, 109.6, 148.0, 200.0, 270.0, 365.0, 493.0, 666.0, 900.0, 1215.0, 1641.0, 2217.0, 2995.0)


def giants_prt_array(path):
    """A petitRADTRANS line-by-line file as float64 values: a Fortran unformatted record's markers stripped where the size says there are some, else the raw array."""
    b = open(path, "rb").read()
    if (len(b) - 8) % 8 == 0 and len(b) % 8 != 0 or (len(b) >= 16 and int.from_bytes(b[:4], "little") == len(b) - 8):
        b = b[4:-4]
    return np.frombuffer(b, dtype="<f8")


giants_PRT_MIRROR = "phanerozoic/petitRADTRANS-lbl"
giants_PRT_SHARE = "https://keeper.mpdl.mpg.de/d/e627411309ba4597a343/files/?p=%s&dl=1"


def giants_opacities(species=("CO2", "CH4"), temps=(110.0, 148.0, 270.0), pressure="0.001000bar"):
    """petitRADTRANS cross-sections of SPECIES nearest TEMPS at PRESSURE, from its Hugging Face mirror or else its Keeper share, into ROOT/opacities/<name>/."""
    from huggingface_hub import hf_hub_download
    for sp in species:
        name = giants_PRT_NAMES[sp]
        folder = os.path.join(giants_PRT, name)
        os.makedirs(folder, exist_ok=True)

        def fetch(fname):
            path = os.path.join(folder, fname)
            if not os.path.exists(path):
                tmp = archive_tmp(path)
                try:
                    shutil.copy(hf_hub_download(giants_PRT_MIRROR, "%s/%s" % (name, fname), repo_type="dataset"), tmp)
                except Exception:
                    open(tmp, "wb").write(archive_get(giants_PRT_SHARE % urllib.parse.quote("/%s/%s" % (name, fname)), timeout=900))
                archive_place(tmp, path)
            return path
        ident = open(fetch("molparam_id.txt")).read().splitlines()[1].strip()
        fetch("wlen.dat")
        for T in temps:
            fetch("sigma_%s_%d.K_%s.dat" % (ident, round(min(giants_PRT_TEMPS, key=lambda x: abs(x - T))), pressure))
        print("%s: %s" % (name, ", ".join(sorted(os.listdir(folder)))), flush=True)


def giants_template_prt(gas, t_k, band="nir", pressure="0.001000bar"):
    """A molecule's transmission template on a band's grid from petitRADTRANS's line-by-line cross-sections (wavelengths in cm, sigma in cm2 at the grid temperature nearest T_K and PRESSURE): the cross-section binned to the grid, each sample within three decades of the strongest weighted by its decade, the strongest one; air wavelengths."""
    folder = os.path.join(giants_PRT, giants_PRT_NAMES[gas])
    t_grid = min(giants_PRT_TEMPS, key=lambda t: abs(t - t_k))
    sig_file = next((f for f in os.listdir(folder) if f.startswith("sigma_") and "_%d.K_" % round(t_grid) in f and pressure in f), None)
    if sig_file is None:
        return np.zeros(len(spectra_grid(band)))
    w = giants_prt_array(os.path.join(folder, "wlen.dat")) * 1e8
    s = giants_prt_array(os.path.join(folder, sig_file))
    n = min(len(w), len(s))
    w, s = archive_vac_to_air(w[:n]), s[:n]
    g = spectra_grid(band)
    lo, hi = spectra_BANDS[band]["lo"], spectra_BANDS[band]["hi"]
    keep = (w >= lo) & (w <= hi) & (s > 0)
    i = np.clip(np.round(np.log(w[keep] / g[0]) * spectra_C).astype(int), 0, len(g) - 1)
    binned = np.zeros(len(g))
    np.maximum.at(binned, i, s[keep])
    out = np.zeros(len(g))
    pos = binned > 0
    if not pos.any():
        return out
    out[pos] = np.clip(np.log10(binned[pos] / binned[pos].max()) + 3.0, 0.0, None) / 3.0
    return out


def giants_template(species, t_k, weight=None, band="optical"):
    """A species' transmission template on a band's grid at a temperature: an atom's lines from Kurucz's list where it is held (NIST's otherwise) weighted by gf exp(-E_low/kT), a molecule's from HITRAN's main isotopologue with its 296 K intensities carried to the temperature through the lower level's Boltzmann factor and the stimulated-emission term; each line's weight by decade of strength (log), its square root (sqrt) or capped at the 99.5th percentile (linear), the strongest one, shared among the line's hyperfine and isotopic components in proportion to their strengths, each component a Gaussian of 3 km/s; air wavelengths."""
    g = spectra_grid(band)
    lo, hi = spectra_BANDS[band]["lo"], spectra_BANDS[band]["hi"]
    out = np.zeros(len(g))
    # the lower level energy in cm^-1; Boltzmann's constant in eV/K, 1.2398e-4 eV per cm^-1 and the second radiation constant 1.4388 cm K
    k_ev = 8.617333e-5
    rows, line = [], None
    if species in giants_PRT_NAMES and os.path.isdir(os.path.join(giants_PRT, giants_PRT_NAMES[species])):
        return giants_template_prt(species, t_k, band)
    if species in giants_HITRAN_ISO:
        nu, sw, elow = giants_hitran(species, lo, hi)
        s = sw * np.exp(-1.4388 * elow * (1.0 / t_k - 1.0 / 296.0)) * (1.0 - np.exp(-1.4388 * nu / t_k)) / (1.0 - np.exp(-1.4388 * nu / 296.0))
        rows = list(zip(archive_vac_to_air(1e8 / nu), s))
    elif os.path.exists(giants_KURUCZ) and species in giants_CODES:
        lams, loggf, elow, line = giants_kurucz(species, band)
        rows = list(zip(lams, 10.0 ** loggf * np.exp(-elow * 1.2398e-4 / (k_ev * t_k))))
    else:
        for ln in archive_nist_lines(species, lo, hi):
            lam, aki, elow = archive_num(ln.get("lam")), archive_num(ln.get("aki")), archive_num(ln.get("ei"))
            if lam and aki and elow is not None:
                rows.append((archive_vac_to_air(np.array([lam]))[0], aki * lam ** 2 * np.exp(-elow * 1.2398e-4 / (k_ev * t_k))))
    if not rows:
        return out
    s = np.array([x for _, x in rows], float)
    line = np.arange(len(s)) if line is None else np.asarray(line)
    total = np.bincount(line, weights=s)
    weight = weight or giants_WEIGHT
    with np.errstate(divide="ignore", invalid="ignore"):
        if weight == "sqrt":
            per_line = np.sqrt(total)
        elif weight == "log":
            # each line within three decades of the strongest weighted by its decade, as saturation flattens depth
            per_line = np.clip(np.log10(total / total.max()) + 3.0, 0.0, None) / 3.0
        else:
            keep = total >= 1e-4 * total.max()
            per_line = np.minimum(total, np.percentile(total[keep], 99.5))
        share = np.where(total[line] > 0, per_line[line] * s / total[line], 0.0)
    top = float(per_line.max())
    lam = np.array([lam for lam, _ in rows], float)
    keep = share >= 1e-3 * top
    pos = np.log(lam[keep] / g[0]) * spectra_C
    idx = np.round(pos).astype(int)[:, None] + np.arange(-10, 11)[None, :]
    val = (share[keep] / top)[:, None] * np.exp(-0.5 * ((idx - pos[:, None]) / 3.0) ** 2)
    on = (idx >= 0) & (idx < len(g))
    np.add.at(out, idx[on], val[on])
    return out


def giants_residuals(spectra, vsys, whiten=True, band="optical"):
    """Each spectrum on the band's grid in the star's frame divided by its running median over 501 samples, then by the out-of-transit median spectrum, a cubic in wavelength taken out of each, the band's telluric regions, the samples beyond the spectrum and those across a gap half or more of the spectra share NaN: (residuals, errors, each wavelength's out-of-transit scatter)."""
    g = spectra_grid(band)
    F, E, used = spectra_onto([(w / (1.0 + vsys / spectra_C), f, e) for w, f, e, meta, inside in spectra], g)
    gaps = [spectra_gaps(g, u) for u in used]
    for row, (w, f, e, meta, inside) in zip(F, spectra):
        for sky in spectra_SKY:
            # the sky line's place in the star's frame, through this spectrum's barycentric correction
            lam = sky * (1.0 + meta.get("berv", 0.0) / spectra_C) / (1.0 + vsys / spectra_C)
            i = int(round(np.log(lam / g[0]) * spectra_C))
            if 0 <= i < len(g):
                row[max(i - 6, 0):i + 7] = np.nan
    # a gap most of the spectra share, as between two detectors, set aside
    common = np.mean(gaps, axis=0) >= 0.5
    F[:, common], E[:, common] = np.nan, np.nan
    outs = torch.as_tensor(~np.array([s[4] for s in spectra]), device=gpu_DEVICE)
    R, sd, ER, _ = spectra_normalise(gpu_dev(F), outs, band, gpu_dev(E))
    return gpu_host(R), gpu_host(ER), gpu_host(sd if whiten else torch.ones_like(sd))


def giants_shadow(ccf, vp_true, vsini, vmax=300):
    """The star's Doppler shadow taken out of each in-transit cross-correlation: a Gaussian fitted within the star's projected rotation (centre within
    +-VSINI, width from 3 km/s to half of it, 15 at least, amplitude within three times the window's largest value) with 12 km/s either side of the
    planet's own velocity left out of the fit, and subtracted; rows the fit cannot reach are left as they are."""
    from scipy.optimize import curve_fit
    v = np.arange(-vmax, vmax + 1, dtype=float)
    out = ccf.copy()
    wmax = max(15.0, vsini / 2.0)
    for k in range(ccf.shape[0]):
        fit = (np.abs(v) <= vsini + 20) & (np.abs(v - vp_true[k]) > 12)
        if fit.sum() < 10:
            continue
        y = ccf[k, fit]
        # the amplitude held within three times the fit window's largest value
        amax = 3.0 * max(float(np.abs(y).max()), 1e-6)
        try:
            popt, _ = curve_fit(lambda x, a, c, s: a * np.exp(-0.5 * ((x - c) / s) ** 2), v[fit], y, p0=(min(max(y.max(), -amax), amax), v[fit][np.argmax(y)], min(6.0, wmax)),
                                bounds=([-amax, -vsini - 5, 3.0], [amax, vsini + 5, wmax]), maxfev=2000)
            out[k] -= popt[0] * np.exp(-0.5 * ((v - popt[1]) / popt[2]) ** 2)
        except (RuntimeError, ValueError):
            pass
    return out


def giants_found(res, sigma):
    """Whether a species' result is a detection: at the threshold at the orbit's K_p, a sigma above anything the sham map reaches, with the map's own peak above 30 km/s in K_p and within 10 km/s of rest, and either inside the orbit's box or no more than a quarter above the orbit's value, as a short transit leaves K_p unresolved along a plateau; a shadow at the star's velocity leaking along the K_p axis passes neither, and a species whose template rests on one line, more than half of its weight within 10 km/s of one place, is left to the line tests, since a deep stellar line's own transit distortion sums along every trail."""
    peak = res["map_peak"]
    on_orbit = abs(peak["kp"] - res["kp_true"]) <= min(res.get("kp_half", 20.0), 60.0) or peak["snr"] <= 1.25 * res["snr"]
    many = res.get("top_line_share", 0.0) <= 0.5
    return bool(res["snr"] >= sigma and (res["sham"] is None or res["snr"] >= res["sham"] + 1.0) and peak["kp"] >= 30.0 and abs(peak["vrest"]) <= 10 and on_orbit and many)


def giants_top_line_share(T, sd=None, ok=None):
    """The share of a template's weight that lies within 10 km/s of its heaviest sample, each sample weighing as it does in the cross-correlation: (T / SD)^2 where the residuals are finite in every row (OK), nothing elsewhere."""
    t = np.asarray(T, float) / (sd if sd is not None else 1.0)
    w2 = np.where(ok if ok is not None else True, t, 0.0) ** 2
    tot = float(w2.sum())
    if tot <= 0:
        return 0.0
    i = int(np.argmax(w2))
    return float(w2[max(i - 10, 0):i + 11].sum() / tot)


def giants_new_planets(vmax=11.0):
    """orbitlight's own new transiting giants in giants_planets's form: the new TESS candidates of RESULTS/planets/signals.csv, validated or weighed in
    velocities, of 0.5 Jupiter radii and more around hosts brighter than VMAX in the TESS band, each named as planets.csv names it, with ExoFOP's
    ephemeris, depth, radius and star, its orbit's size from Kepler's law and its star's systemic velocity from the SIMBAD mirror's nearest star with one."""
    from astropy.coordinates import Angle
    signals, named = os.path.join(planets_RESULTS, "signals.csv"), os.path.join(planets_RESULTS, "planets.csv")
    if not (os.path.exists(signals) and os.path.exists(named)):
        return []
    exo = {x["label"]: x for x in planets_exofop()}
    listed, out = planets_read(named), []
    for r in planets_read(signals):
        x = exo.get(r["label"])
        if r["status"] != "new" or r["kind"] not in ("validated", "toi") or not x:
            continue
        P, R, tc, dur = (archive_num(v) for v in (r["P"], x.get("Planet Radius (R_Earth)"), x.get("Epoch (BJD)"), x.get("Duration (hours)")))
        if not (P and tc and R and R >= 0.5 * 11.209 and planets_num(x.get("TESS Mag")) < vmax):
            continue
        ra, dec = (Angle(x["RA"], unit="hourangle").deg, Angle(x["Dec"], unit="deg").deg) if r["label"].startswith("TOI-") else (planets_num(x["RA"]),
                                                                                                                                 planets_num(x["Dec"]))
        M, depth = archive_num(x.get("Stellar Mass (M_Sun)")), archive_num(x.get("Depth (ppm)"))
        out.append(dict(pl_name=next((p["planet"] for p in listed if p["bank_name"] == r["name"] and abs(planets_num(p["P_d"]) / P - 1.0) < 1e-3), r["label"]),
                        hostname=r["name"], ra=ra, dec=dec, sy_dist=archive_num(x.get("Stellar Distance (pc)")), st_teff=archive_num(x.get("Stellar Eff Temp (K)")),
                        st_rad=archive_num(x.get("Stellar Radius (R_Sun)")), st_mass=M, st_radv=archive_simbad_velocity_near(ra, dec), st_vsin=None, pl_bmassj=None,
                        pl_radj=R / 11.209, pl_ratror=math.sqrt(depth / 1e6) if depth and depth > 0 else None,
                        pl_orbsmax=(M * (P / 365.25) ** 2) ** (1.0 / 3.0) if M and M > 0 else None, pl_orbper=P, pl_orbeccen=None, pl_orblper=None, pl_orbtper=None,
                        pl_tranmid=tc, pl_trandur=dur, pl_eqt=archive_num(x.get("Planet Equil Temp (K)")), sy_vmag=None, sy_kmag=None, tran_flag=1))
    return out


def giants_planets(vmax=11.0):
    """The giant planets with their ephemerides: the NASA Exoplanet Archive's of 0.1 Jupiter masses or 0.5 Jupiter radii and more around hosts brighter
    than V VMAX, the time of inferior conjunction of a radial-velocity planet taken from its periastron and argument of periastron, and orbitlight's own
    new transiting giants (giants_new_planets)."""
    rows = archive_exoplanets("SELECT pl_name, hostname, ra, dec, sy_dist, st_teff, st_rad, st_mass, st_radv, st_vsin, pl_bmassj, pl_radj, pl_ratror, pl_orbsmax, "
                           "pl_orbper, pl_orbeccen, pl_orblper, pl_orbtper, pl_tranmid, pl_trandur, pl_eqt, sy_vmag, sy_kmag, tran_flag FROM pscomppars WHERE "
                           "(pl_bmassj >= 0.1 OR pl_radj >= 0.5) AND sy_vmag < %g AND pl_orbper IS NOT NULL ORDER BY sy_vmag" % vmax)
    out = []
    # hosts the archive lists without a systemic velocity take the SIMBAD mirror's
    simbad = archive_simbad_velocities(sorted({r["hostname"] for r in rows if archive_num(r["st_radv"]) is None}))
    for r in rows:
        p = {k: (r[k] if k in ("pl_name", "hostname") else archive_num(r[k])) for k in r}
        if p["st_radv"] is None:
            p["st_radv"] = simbad.get(p["hostname"])
        if p["pl_tranmid"] is None and p["pl_orbtper"] is not None and p["pl_orblper"] is not None:
            # inferior conjunction follows periastron by (90 - omega) degrees of mean anomaly on a near-circular orbit
            p["pl_tranmid"] = p["pl_orbtper"] + p["pl_orbper"] * ((90.0 - p["pl_orblper"]) % 360.0) / 360.0
        if p["pl_tranmid"] is None:
            continue
        if p["pl_trandur"] is None and p["st_rad"] and p["pl_orbsmax"]:
            # a central transit's duration from the star's radius and the orbit's size
            p["pl_trandur"] = 24.0 * p["pl_orbper"] / math.pi * math.asin(min(p["st_rad"] * 0.00465047 / p["pl_orbsmax"], 1.0))
        out.append(p)
    return out + [p for p in giants_new_planets(vmax) if p["pl_name"] not in {q["pl_name"] for q in out}]


def giants_place(p, rows):
    """A planet's archived spectra by instrument with each spectrum's orbital phase and place: transit, eclipse, day (phase 0.3-0.7) or other."""
    tc, per = p["pl_tranmid"] - 2400000.5, p["pl_orbper"]
    half = (p["pl_trandur"] or 3.0) / 48.0
    out = {}
    for r in rows:
        mid = 0.5 * (r["t0"] + r["t1"])
        phase = ((mid - tc) / per) % 1.0
        d = min(phase, 1.0 - phase) * per
        place = "transit" if d < half and p.get("tran_flag") else "eclipse" if abs(phase - 0.5) * per < half and p.get("tran_flag") else "day" if 0.3 < phase < 0.7 else "other"
        out.setdefault(r["inst"], []).append(dict(r, phase=round(phase, 4), place=place))
    return out


def giants_plan_summary(plan):
    """A giants plan as rows: each planet and instrument with its spectra counted by place on the orbit (transit, eclipse, day, other)."""
    return [dict(planet=p["pl_name"], host=p["hostname"], inst=inst, **{k: sum(1 for r in rows if r["place"] == k) for k in ("transit", "eclipse", "day", "other")})
            for p in plan for inst, rows in sorted(p["instruments"].items())]


def giants_plan(vmax=11.0):
    """The giant planets with their archived spectra placed on their orbits, into ROOT/plan.json with its counts in ROOT/plan_summary.csv
    (giants_plan_summary), the archive answers kept in ROOT/archives.json."""
    os.makedirs(giants_ROOT, exist_ok=True)
    planets = giants_planets(vmax)
    hosts = {}
    for p in planets:
        hosts.setdefault(p["hostname"], dict(ra=p["ra"], dec=p["dec"]))
    apath = os.path.join(giants_ROOT, "archives.json")
    arch = json.load(open(apath)) if os.path.exists(apath) else {}
    todo = sorted(h for h in hosts if h not in arch)

    def one(name):
        try:
            return name, archive_spectra(hosts[name]["ra"], hosts[name]["dec"]), None
        except Exception as e:
            return name, None, str(e)[:200]
    errors = {}
    with cf.ThreadPoolExecutor(4) as ex:
        # the answers saved as they arrive
        for i, (name, rows, err) in enumerate(ex.map(one, todo)):
            if rows is None:
                errors[name] = err
            else:
                arch[name] = rows
            if (i + 1) % 25 == 0:
                json.dump(arch, open(apath, "w"), separators=(",", ":"))
    json.dump(arch, open(apath, "w"), separators=(",", ":"))
    plan = []
    for p in planets:
        placed = giants_place(p, arch.get(p["hostname"], []))
        if placed:
            plan.append(dict(p, instruments=placed))
    json.dump(plan, open(os.path.join(giants_ROOT, "plan.json"), "w"), separators=(",", ":"))
    planets_write(os.path.join(giants_ROOT, "plan_summary.csv"), giants_plan_summary(plan), ["planet", "host", "inst", "transit", "eclipse", "day", "other"])
    print("%d giant planets of %d hosts brighter than V %g; %d hosts with archived spectra (%d archives not answering); %d planets with spectra"
          % (len(planets), len(hosts), vmax, sum(1 for h in hosts if arch.get(h)), len(errors), len(plan)))
    print("%-18s %-9s %7s %7s %5s %5s" % ("planet", "inst", "transit", "eclipse", "day", "other"))
    for p in plan:
        for inst, rows in sorted(p["instruments"].items()):
            c = {k: sum(1 for r in rows if r["place"] == k) for k in ("transit", "eclipse", "day", "other")}
            if c["transit"] or c["eclipse"] or c["day"] >= 5:
                print("%-18s %-9s %7d %7d %5d %5d" % (p["pl_name"], inst, c["transit"], c["eclipse"], c["day"], c["other"]))


def giants_search(planets=[], species=list(giants_SPECIES), sigma=4.0, temp=0.0, sysrem=0, weight="log", inject=0.0, whiten=True, shadow=True, redo=False, instruments=()):
    """Each planned transiting giant with four or more in-transit and out-of-transit spectra on disk from ESPRESSO, HARPS, SPIRou or NIRPS: residuals in
    the star's frame, each species' template cross-correlated with every spectrum, the in-transit sums over a K_p and rest-velocity map, and the peak at
    the orbit's K_p within 10 km/s of rest read against the map's scatter beyond 40 km/s and a sham map (giants_found); the strongest species per planet
    printed."""
    plan = json.load(open(os.path.join(giants_ROOT, "plan.json")))
    kp_grid = np.arange(0.0, 301.0, 5.0)
    vrest = np.arange(-100.0, 101.0, 1.0)
    for p in plan:
        if planets and p["pl_name"] not in planets:
            continue
        for inst in ("ESPRESSO", "HARPS", "SPIRou", "NIRPS"):
            if instruments and inst not in instruments:
                continue
            band = spectra_band(inst)
            # atoms in the optical, molecules in the near infrared
            pool = list(species) + (list(giants_MOLECULES) if species == list(giants_SPECIES) else [])
            wanted = [s for s in pool if (s in giants_HITRAN_ISO) == (band == "nir")]
            rows = p["instruments"].get(inst) or []
            tag = "%s.%s" % (archive_tag(p["pl_name"]), inst)
            rpath = os.path.join(giants_ROOT, "results", tag + ".json")
            if not wanted or not rows or (os.path.exists(rpath) and not redo):
                continue
            per, tc, dur, k = p["pl_orbper"], p["pl_tranmid"] - 2400000.5, (p["pl_trandur"] or 3.0) / 24.0, p["pl_ratror"] or 0.1
            spectra = []
            have = [(r, archive_path(os.path.join(giants_ROOT, "spectra", inst), r)) for r in rows]
            have = [(r, path) for r, path in have if os.path.exists(path)]
            for (r, _), s in zip(have, spectra_load_many([path for _, path in have])):
                if s is not None:
                    wt, epoch = transits_weight(r["t0"], r["t1"], tc, per, dur, k)
                    spectra.append((s[0], s[1], s[2], dict(s[3], weight=wt, epoch=epoch), wt > 0))
            n_in = sum(1 for s in spectra if s[4])
            if n_in < 4 or len(spectra) - n_in < 4:
                continue
            rvs = [s[3]["rv"] for s in spectra if s[3]["rv"] is not None]
            vsys = float(np.median(rvs)) if rvs else (p.get("st_radv") or 0.0)
            kp_true = spectra_kp(p)
            if inject:
                # the first species' lines laid into each in-transit spectrum at depth INJECT along the planet's velocity
                Tinj = giants_template(wanted[0], temp or p.get("pl_eqt") or 1500.0, weight, band)
                for i, (w, f, e, meta, inside) in enumerate(spectra):
                    if inside:
                        vp_i = kp_true * np.sin(2 * np.pi * (meta["mjd"] - meta["epoch"]) / per)
                        spectra[i] = (w, spectra_lay(w, f, Tinj, vsys + vp_i, inject * meta["weight"], band), e, meta, inside)
            R, ER, sd = giants_residuals(spectra, vsys, whiten, band)
            if sysrem:
                R = spectra_sysrem(R, sd, sysrem)
            ins = np.array([s[4] for s in spectra])
            phase = np.array([(s[3]["mjd"] - s[3]["epoch"]) / per for s in spectra])
            vp_unit = np.sin(2 * np.pi * phase)
            wts = np.array([s[3]["weight"] for s in spectra])
            best, results, maps, sham_maps = None, [], [], []
            for sp in wanted:
                T = giants_template(sp, temp or p.get("pl_eqt") or 1500.0, weight, band)
                if not T.any():
                    continue
                ccf = spectra_ccf(R, T, sd)
                # the star's own residual pattern, the median cross-correlation outside transit, taken out of every row
                ccf = ccf - np.median(ccf[~ins], axis=0)[None, :]
                # the sham: out-of-transit rows given the in-transit rows' phases and weights, and every step the in-transit rows get
                n_sh = min(int(ins.sum()), int((~ins).sum()))
                sham_rows = ccf[~ins][:n_sh].copy() if n_sh >= 4 else None
                # the Doppler shadow taken out in the optical band alone
                if shadow and band == "optical":
                    ccf[ins] = giants_shadow(ccf[ins], kp_true * vp_unit[ins], p.get("st_vsin") or 15.0)
                    if sham_rows is not None:
                        sham_rows = giants_shadow(sham_rows, kp_true * vp_unit[ins][:n_sh], p.get("st_vsin") or 15.0)
                m = spectra_planet_frame(ccf[ins], vp_unit[ins], wts[ins], kp_grid, vrest)
                m_out = spectra_planet_frame(sham_rows, vp_unit[ins][:n_sh], wts[ins][:n_sh], kp_grid, vrest) if sham_rows is not None else None
                far = np.abs(vrest) > 40
                # the noise: the map's scatter away from rest, or the sham map's over its whole extent where that is larger
                noise = float(np.nanstd(m[:, far]))
                if m_out is not None:
                    noise = max(noise, float(np.nanstd(m_out)))
                # the orbit's box: 10 km/s in rest velocity, and in K_p 20 to 60 km/s either side, above 30 km/s
                kp_half = min(max(20.0, 10.0 / max(float(np.abs(vp_unit[ins]).max()), 1e-3)), 60.0)
                near = (np.abs(kp_grid - kp_true) <= kp_half)[:, None] & (kp_grid >= 30.0)[:, None] & (np.abs(vrest) <= 10)[None, :]
                peak = float(np.nanmax(np.where(near, m, -np.inf)))
                i, j = np.unravel_index(int(np.nanargmax(m)), m.shape)
                res = dict(species=sp, snr=peak / noise if noise > 0 else 0.0, kp_true=kp_true, kp_half=kp_half, map_peak=dict(kp=float(kp_grid[i]), vrest=float(vrest[j]), snr=float(m[i, j] / noise) if noise > 0 else 0.0),
                           sham=float(np.nanmax(np.where(near, m_out, -np.inf)) / noise) if m_out is not None and noise > 0 else None,
                           top_line_share=giants_top_line_share(T, sd, np.isfinite(R).all(0)))
                res["found"] = giants_found(res, sigma)
                results.append(res)
                maps.append(m)
                sham_maps.append(m_out)
                if best is None or (res["found"], res["snr"]) > (best["found"], best["snr"]):
                    best = res
                print("  %-12s %-9s %-5s S/N %5.1f at K_p %.0f (map peak %5.1f at K_p %.0f, v %+.0f; sham %s; top line %.2f)" % (
                    p["pl_name"], inst, sp, res["snr"], kp_true, res["map_peak"]["snr"], res["map_peak"]["kp"], res["map_peak"]["vrest"],
                    "%.1f" % res["sham"] if res["sham"] is not None else "-", res["top_line_share"]), flush=True)
            if best:
                det = [r["species"] for r in results if r["found"]]
                print("%-12s %-9s %d in, %d out: %s" % (p["pl_name"], inst, n_in, len(spectra) - n_in,
                                                       "DETECTED " + ", ".join("%s %.1f sigma" % (r["species"], r["snr"]) for r in results if r["found"]) if det
                                                       else "strongest %s at %.1f sigma, nothing detected" % (best["species"], best["snr"])), flush=True)
            if results:
                os.makedirs(os.path.join(giants_ROOT, "results"), exist_ok=True)
                # every species' map and sham map kept beside the result
                np.savez_compressed(os.path.join(giants_ROOT, "results", tag + ".maps.npz"), kp=kp_grid, vrest=vrest, species=np.array([r["species"] for r in results]),
                                    maps=np.array(maps), shams=np.array([x if x is not None else np.full_like(maps[0], np.nan) for x in sham_maps]))
                # a host rotating faster than 40 km/s or hotter than 7500 K casts a shadow beyond the Gaussian model
                caveat = ("fast rotator" if (p.get("st_vsin") or 0) > 40 else "hot host" if (p.get("st_teff") or 0) > 7500 else None)
                json.dump(dict(planet=p["pl_name"], inst=inst, band=band, n_in=n_in, n_out=len(spectra) - n_in, vsys=vsys, kp=kp_true, sigma=sigma, weight=weight,
                               sysrem=sysrem, temp=temp or p.get("pl_eqt") or 1500.0, caveat=caveat, species=results), open(rpath, "w"), separators=(",", ":"))


def giants_fetch(streams=4, planets=(), night_per_in=2.0, instruments=(), min_in=4):
    """The in-transit and eclipse spectra of every planned giant (or the named ones, or the named instruments' sets of MIN_IN spectra or more) with the same nights' other spectra nearest them up to NIGHT_PER_IN times their number, from ESO and the CADC, on STREAMS connections."""
    plan = json.load(open(os.path.join(giants_ROOT, "plan.json")))
    want = []
    for p in plan:
        if planets and p["pl_name"] not in planets:
            continue
        for inst, rows in p["instruments"].items():
            if instruments and inst not in instruments:
                continue
            inside = [r for r in rows if r["src"] in ("ESO", "CADC") and r["place"] in ("transit", "eclipse")]
            if len(inside) < min_in:
                continue
            want += inside
            per, tc = p["pl_orbper"], p["pl_tranmid"] - 2400000.5
            for epoch in sorted({round((0.5 * (r["t0"] + r["t1"]) - tc) / per) for r in inside}):
                t_mid = tc + epoch * per
                n = sum(1 for r in inside if round((0.5 * (r["t0"] + r["t1"]) - tc) / per) == epoch)
                night = sorted((r for r in rows if r["src"] in ("ESO", "CADC") and r["place"] not in ("transit", "eclipse") and abs(0.5 * (r["t0"] + r["t1"]) - t_mid) < 0.5),
                               key=lambda r: abs(0.5 * (r["t0"] + r["t1"]) - t_mid))
                want += night[:max(int(night_per_in * n), 4)]
    seen, todo = set(), []
    for r in want:
        path = archive_path(os.path.join(giants_ROOT, "spectra", r["inst"]), r)
        if r["id"] not in seen and not os.path.exists(path):
            seen.add(r["id"])
            todo.append((r, path))
    got = sum(1 for ok in archive_pmap(lambda rp: archive_download(*rp), todo, streams) if ok)
    print("%d spectra wanted, %d already here, %d fetched, %d failed" % (len(want), len(want) - len(todo), got, len(todo) - got))


def giants_record(sigma=4.0):
    """The searched planets' results in ROOT/results written as the run's record under the results root: one row per planet and instrument, its target the planet's followed by # and the instrument, with its strongest species' significance at the orbit, the species detected, and a caveat where the host's rotation or heat left the star's shadow unmodelled or telluric residuals beyond the model; the reflected-light limits beside them, their targets followed by #reflected."""
    rows, found, transiting = [], [], set()
    for path in sorted(glob.glob(os.path.join(giants_ROOT, "results", "*.json"))):
        r = json.load(open(path))
        if ".reflected." in path or ".emission." in path or "species" not in r:
            continue
        det = [s["species"] for s in r["species"] if giants_found(s, sigma)]
        best = max(r["species"], key=lambda s: s["snr"]) if r["species"] else None
        if best is None:
            continue
        found += [(r["planet"], r["inst"], d) for d in det]
        # a sham map ten sigma below zero marks telluric residuals beyond the model
        caveat = (r["caveat"] + ", the star's shadow beyond the model") if r.get("caveat") else (
            "telluric residuals beyond the model" if any((s["sham"] or 0.0) < -10.0 for s in r["species"]) else None)
        transiting.add(r["planet"])
        rows.append(dict(target="planet:%s#%s" % (r["planet"], r["inst"]), stat=round(best["snr"], 1),
                         unit="sigma of the strongest species' cross-correlation at the orbit's K_p (%s, %d in-transit spectra)" % (r["inst"], r["n_in"]),
                         vet="not-measured" if caveat else None,
                         note="%s; %s; detected %s; species %s%s" % (r["inst"], r["band"], ", ".join(det) or "none",
                                                                     ", ".join("%s %.1f (sham %s)" % (s["species"], s["snr"], "%.1f" % s["sham"] if s["sham"] is not None else "-") for s in r["species"]),
                                                                     "; " + caveat if caveat else "")))
    # the reflected-light calibrations beside them, as limits on the planet-to-star contrast
    sets, reflected = len(rows), set()
    for path in sorted(glob.glob(os.path.join(giants_ROOT, "results", "*.reflected.json"))):
        r = json.load(open(path))
        if r.get("limit_3sigma") is None:
            continue
        reflected.add(r["planet"])
        rows.append(dict(target="planet:%s#reflected" % r["planet"], stat=round(r["snr"], 1), upper_limit=round(1e6 * r["limit_3sigma"], 1),
                         unit="ppm planet-to-star contrast at 3 sigma, reflected starlight (%d spectra, %.0f effective)" % (r["n"], r["n_eff"]),
                         vet="not-measured" if (r.get("retained") or 0) < 0.5 else None,
                         note="reflected light: %.1f sigma at the orbit (sham %.1f), map peak %.1f at K_p %.0f, v %+.0f; probe returned %.2f; contrast %+.0f ppm" % (
                             r["snr"], r["sham"], r["map_peak"]["snr"], r["map_peak"]["kp"], r["map_peak"]["vrest"], r.get("retained") or 0, 1e6 * (r.get("contrast") or 0))))
    archive_record_run(
        giants_RUN, "Planet-frame compositions of the giant planets",
        "ESO Phase 3 (HARPS, ESPRESSO, NIRPS, CRIRES, UVES), CADC (CFHT SPIRou), KOA (Keck NIRSPEC); Kurucz's gfall line list; HITRAN; NASA Exoplanet Archive pscomppars; SIMBAD",
        "every archived transit of the giant planets brighter than V 11 with four or more in-transit and out-of-transit spectra from one spectrograph",
        "giants", len(transiting | reflected), "planets", dict(sigma=sigma, weight=giants_WEIGHT),
        "the K_p and rest-velocity map's scatter away from rest and the sham map of out-of-transit rows given the transit's phases",
        "a species stands at %g sigma at the orbit's K_p, a sigma above the sham map, as the map's own peak" % sigma,
        "%d planet-instrument transit sets of %d planets and reflected light from %d; %d species detected in %d planet%s" % (
            sets, len(transiting), len(reflected), len(found), len({f[0] for f in found}), "" if len({f[0] for f in found}) == 1 else "s"), rows)
    print("%d planet-instrument transit sets of %d planets and %d reflected-light limits recorded; detections: %s" % (
        sets, len(transiting), len(reflected), ", ".join("%s %s %s" % f for f in found) or "none"))


def giants_reflected(planets=(), max_spectra=300, streams=4, instruments=("HARPS", "ESPRESSO"), components=5, probe=1e-4, redo=False):
    """Reflected starlight of the named planets (or every non-transiting giant of the plan with an orbit): up to MAX_SPECTRA archived spectra of the host spread over its span, each on the grid in the star's frame over its running median and the series' median, whitened; the star's own absorption pattern as the template, its residual pattern taken out of each cross-correlation row at its own strength and COMPONENTS principal components of the rows taken out after it; the rows summed in the planet's frame over K_p and rest velocity, weighted by the Lambert phase function and only where the planet moves more than 25 km/s from the star; the value at the orbit's K_p against the map's scatter away from the star and a sham of the rows with their phases shuffled; the gain measured by laying a copy of the star's lines at contrast PROBE, dimmed by the phase function, into the same spectra along the planet's velocity and reading the map's rise at the orbit through the same cleaning, so the value and the 3 sigma limit are stated as contrasts; results under ROOT/results/<planet>.reflected.json."""
    plan = json.load(open(os.path.join(giants_ROOT, "plan.json")))
    kp_grid = np.arange(0.0, 301.0, 5.0)
    vrest = np.arange(-100.0, 101.0, 1.0)
    quiet = (kp_grid >= 60.0)[:, None] & (np.abs(vrest) > 40.0)[None, :]
    os.makedirs(os.path.join(giants_ROOT, "results"), exist_ok=True)

    def cleaned(R, sd, master):
        T = spectra_depths(master)
        return spectra_components(spectra_unpattern(spectra_ccf(R, T, sd)), components), T
    for p in plan:
        if (planets and p["pl_name"] not in planets) or (not planets and p.get("tran_flag")):
            continue
        tag = archive_tag(p["pl_name"])
        rpath = os.path.join(giants_ROOT, "results", tag + ".reflected.json")
        if os.path.exists(rpath) and not redo:
            continue
        rows = [r for inst in instruments for r in (p["instruments"].get(inst) or []) if r["src"] == "ESO" and (r.get("snr") or 0) > 50]
        if len(rows) < 30:
            continue
        rows.sort(key=lambda r: r["t0"])
        pick = rows[::max(len(rows) // max_spectra, 1)][:max_spectra]
        folder = os.path.join(giants_ROOT, "reflected", tag)
        spectra = spectra_read([x for x in archive_pmap(lambda r: archive_download(r, archive_path(folder, r)), pick, streams) if x])
        if len(spectra) < 30:
            continue
        per, tc = p["pl_orbper"], p["pl_tranmid"] - 2400000.5
        kp_true = spectra_kp(p)
        vsys = spectra_vsys(spectra, p.get("st_radv"))
        band = spectra_band(instruments[0])
        phase = np.array([((s[3]["mjd"] - tc) / per) % 1.0 for s in spectra])
        vp_unit = np.sin(2 * np.pi * phase)
        # Lambert's phase function, the rows near the star's velocity left out
        lam = spectra_lambert(phase)
        w = np.where(np.abs(kp_true * vp_unit) > 25.0, lam, 0.0)
        if w.sum() <= 0:
            continue
        R, sd, master = spectra_residuals(spectra, vsys, band)
        ccf, T = cleaned(R, sd, master)
        m = spectra_planet_frame(ccf, vp_unit, w, kp_grid, vrest)
        # the probe: the star's own lines laid in at PROBE times the phase function, along the planet's velocity
        laid = [(wv, spectra_lay(wv, f, T, (meta["rv"] if meta.get("rv") is not None else vsys) + vp, probe * lam_k, band), e, meta)
                for (wv, f, e, meta), vp, lam_k in zip(spectra, kp_true * vp_unit, lam)]
        Rp, sdp, masterp = spectra_residuals(laid, vsys, band)
        ccfp, _ = cleaned(Rp, sdp, masterp)
        mp = spectra_planet_frame(ccfp, vp_unit, w, kp_grid, vrest)
        i0, j0 = int(np.argmin(np.abs(kp_grid - kp_true))), int(np.argmin(np.abs(vrest)))
        gain = float(mp[i0, j0] - m[i0, j0]) / probe
        # the gain with nothing lost: the whitened template's norm times the weighted phase function
        ok = np.isfinite(R).all(0)
        gain_white = float(np.sqrt(((T / sd) ** 2)[ok].sum())) * float((w * lam).sum() / w.sum())
        rng = np.random.default_rng(5)
        shams = [spectra_planet_frame(ccf, vp_unit[rng.permutation(len(vp_unit))], w, kp_grid, vrest) for _ in range(5)]
        noise = max(float(np.nanstd(m[quiet])), float(np.mean([np.nanstd(x[quiet]) for x in shams])))
        near = (np.abs(kp_grid - kp_true) <= 30)[:, None] & (kp_grid >= 30.0)[:, None] & (np.abs(vrest) <= 10)[None, :]
        val = float(np.nanmax(np.where(near, m, -np.inf)))
        above = np.where(kp_grid[:, None] >= 30.0, m, -np.inf)
        i, j = np.unravel_index(int(np.nanargmax(above)), m.shape)
        sham_max = float(np.mean([np.nanmax(np.where(near, x, -np.inf)) for x in shams]))
        res = dict(planet=p["pl_name"], n=len(spectra), n_eff=float(w.sum() ** 2 / (w ** 2).sum()), kp_true=kp_true, vsys=vsys, components=components, probe=probe,
                   snr=val / noise if noise > 0 else 0.0, sham=sham_max / noise if noise > 0 else 0.0,
                   map_peak=dict(kp=float(kp_grid[i]), vrest=float(vrest[j]), snr=float(m[i, j] / noise) if noise > 0 else 0.0), noise=noise, value=val,
                   orbit=float(m[i0, j0]), gain=gain, gain_white=gain_white, retained=gain / gain_white if gain_white > 0 else None,
                   contrast=float(m[i0, j0]) / gain if gain > 0 else None, limit_3sigma=3.0 * noise / gain if gain > 0 else None)
        json.dump(res, open(rpath, "w"), separators=(",", ":"))
        print("%-14s %3d spectra (%.0f effective): reflected light at K_p %.0f: %.1f sigma (sham %.1f); map peak %.1f at K_p %.0f, v %+.0f; contrast %+.0f ppm, 3 sigma limit %.0f ppm; probe retained %.2f" % (
            p["pl_name"], len(spectra), res["n_eff"], kp_true, res["snr"], res["sham"], res["map_peak"]["snr"], res["map_peak"]["kp"], res["map_peak"]["vrest"],
            1e6 * (res["contrast"] or 0), 1e6 * (res["limit_3sigma"] or 0), res["retained"] or 0), flush=True)


def giants_emission(planets=(), max_spectra=300, streams=4, species=("CO", "H2O"), sysrem=6, components=0, probe=3e-4, redo=False):
    """Dayside thermal emission of the named planets (or every giant of the plan hotter than 1000 K with thirty or more SPIRou spectra): up to MAX_SPECTRA telluric-corrected SPIRou spectra from the CADC, those at the phases where the planet's dayside faces us and it moves more than 25 km/s from its star first; each on the near-infrared grid in the star's frame over its running median and the series' median, SYSREM systematics taken out of the residuals, whitened; each molecule's petitRADTRANS cross-section at the planet's temperature as the template; the rows' cross-correlations with the static pattern taken out and COMPONENTS principal components after it, summed in the planet's frame over K_p and rest velocity with the Lambert weights; the peak within 10 km/s of rest between 30 km/s and the edge-on amplitude against the map's scatter away from the star and shams with the phases shuffled; the gain from a copy of the template laid into the same spectra at contrast PROBE along the edge-on orbit through the same cleaning; results under ROOT/results/<planet>.emission.json."""
    plan = json.load(open(os.path.join(giants_ROOT, "plan.json")))
    kp_grid = np.arange(0.0, 301.0, 5.0)
    vrest = np.arange(-100.0, 101.0, 1.0)
    band = "nir"
    os.makedirs(os.path.join(giants_ROOT, "results"), exist_ok=True)

    def cleaned(R, sd, T):
        return spectra_components(spectra_unpattern(spectra_ccf(R, T, sd)), components)
    for p in plan:
        if (planets and p["pl_name"] not in planets) or (not planets and (p.get("pl_eqt") or 0) < 1000):
            continue
        tag = archive_tag(p["pl_name"])
        rpath = os.path.join(giants_ROOT, "results", tag + ".emission.json")
        if os.path.exists(rpath) and not redo:
            continue
        rows = [r for r in (p["instruments"].get("SPIRou") or []) if r["src"] == "CADC" and r["id"].endswith("t") and r["place"] != "transit"]
        if len(rows) < 30:
            continue
        per, tc = p["pl_orbper"], p["pl_tranmid"] - 2400000.5
        kp_true = spectra_kp(p)
        for r in rows:
            ph = ((0.5 * (r["t0"] + r["t1"]) - tc) / per) % 1.0
            r["weight"] = float(spectra_lambert(ph)) if abs(kp_true * np.sin(2 * np.pi * ph)) > 25.0 else 0.0
        pick = sorted((r for r in rows if r["weight"] > 0), key=lambda r: -r["weight"])[:max_spectra]
        if len(pick) < 30:
            continue
        folder = os.path.join(giants_ROOT, "emission", tag)
        spectra = spectra_read([x for x in archive_pmap(lambda r: archive_download(r, archive_path(folder, r)), pick, streams) if x])
        if len(spectra) < 30:
            continue
        vsys = spectra_vsys(spectra, p.get("st_radv"))
        phase = np.array([((s[3]["mjd"] - tc) / per) % 1.0 for s in spectra])
        vp_unit = np.sin(2 * np.pi * phase)
        lam = spectra_lambert(phase)
        w = np.where(np.abs(kp_true * vp_unit) > 25.0, lam, 0.0)
        if w.sum() <= 0:
            continue
        t_k = p.get("pl_eqt") or 1500.0
        # the rows left unaligned, telluric residuals moving with the barycentric correction
        R, sd, master = spectra_residuals(spectra, vsys, band, align=False)
        if sysrem:
            R = spectra_sysrem(R, sd, sysrem)
        quiet = (kp_grid >= 30.0)[:, None] & (np.abs(vrest) > 40.0)[None, :]
        near = ((kp_grid >= 30.0) & (kp_grid <= kp_true + 30.0))[:, None] & (np.abs(vrest) <= 10)[None, :]
        i0, j0 = int(np.argmin(np.abs(kp_grid - kp_true))), int(np.argmin(np.abs(vrest)))
        rng = np.random.default_rng(5)
        perms = [rng.permutation(len(vp_unit)) for _ in range(5)]
        results = []
        for sp in species:
            T = giants_template(sp, t_k, band=band)
            if not T.any():
                continue
            ccf = cleaned(R, sd, T)
            m = spectra_planet_frame(ccf, vp_unit, w, kp_grid, vrest)
            shams = [spectra_planet_frame(ccf, vp_unit[q], w, kp_grid, vrest) for q in perms]
            noise = max(float(np.nanstd(m[quiet])), float(np.mean([np.nanstd(x[quiet]) for x in shams])))
            val = float(np.nanmax(np.where(near, m, -np.inf)))
            a, b = np.unravel_index(int(np.nanargmax(np.where(near, m, -np.inf))), m.shape)
            i, j = np.unravel_index(int(np.nanargmax(np.where(kp_grid[:, None] >= 30.0, m, -np.inf))), m.shape)
            sham_max = float(np.mean([np.nanmax(np.where(near, x, -np.inf)) for x in shams]))
            # the probe: the template's lines laid in at PROBE times the phase function, along the edge-on orbit
            laid = [(wv, spectra_lay(wv, f, T, (meta["rv"] if meta.get("rv") is not None else vsys) + vp, probe * lam_k, band), e, meta)
                    for (wv, f, e, meta), vp, lam_k in zip(spectra, kp_true * vp_unit, lam)]
            Rp, sdp, _ = spectra_residuals(laid, vsys, band, align=False)
            if sysrem:
                Rp = spectra_sysrem(Rp, sdp, sysrem)
            mp = spectra_planet_frame(cleaned(Rp, sdp, T), vp_unit, w, kp_grid, vrest)
            gain = float(mp[i0, j0] - m[i0, j0]) / probe
            res = dict(species=sp, snr=val / noise if noise > 0 else 0.0, sham=sham_max / noise if noise > 0 else 0.0, at=dict(kp=float(kp_grid[a]), vrest=float(vrest[b])),
                       map_peak=dict(kp=float(kp_grid[i]), vrest=float(vrest[j]), snr=float(m[i, j] / noise) if noise > 0 else 0.0), noise=noise, value=val,
                       gain=gain, contrast=val / gain if gain > 0 else None, limit_3sigma=3.0 * noise / gain if gain > 0 else None)
            results.append(res)
            print("  %-12s SPIRou %-4s S/N %5.1f at K_p %.0f, v %+.0f (edge-on K_p %.0f; sham %.1f; map peak %.1f at K_p %.0f, v %+.0f); contrast %+.0f ppm, 3 sigma limit %.0f ppm, probe gain %.0f" % (
                p["pl_name"], sp, res["snr"], kp_grid[a], vrest[b], kp_true, res["sham"], res["map_peak"]["snr"], kp_grid[i], vrest[j], 1e6 * (res["contrast"] or 0), 1e6 * (res["limit_3sigma"] or 0), gain), flush=True)
        if results:
            json.dump(dict(planet=p["pl_name"], inst="SPIRou", n=len(spectra), n_eff=float(w.sum() ** 2 / (w ** 2).sum()), kp_true=kp_true, vsys=vsys, temp=t_k, sysrem=sysrem,
                           components=components, probe=probe, species=results), open(rpath, "w"), separators=(",", ":"))


def giants_cli():
    archive_quiet_warnings()
    p = argparse.ArgumentParser(prog="orbitlight.py giants", description=giants_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("mode", choices=("plan", "fetch", "search", "record", "reflected", "emission", "opacities"))
    p.add_argument("--temps", type=float, nargs="*", default=[110.0, 148.0, 270.0], help="opacities: temperatures (K) to fetch")
    p.add_argument("--max-spectra", type=int, default=300)
    p.add_argument("--vmax", type=float, default=11.0)
    p.add_argument("--streams", type=int, default=4)
    p.add_argument("--planets", nargs="*", default=[])
    p.add_argument("--night-per-in", type=float, default=2.0)
    p.add_argument("--instruments", nargs="*", default=[])
    p.add_argument("--min-in", type=int, default=4)
    p.add_argument("--species", nargs="*", default=list(giants_SPECIES))
    p.add_argument("--sigma", type=float, default=4.0)
    p.add_argument("--temp", type=float, default=0.0)
    # the defaults differ by mode: search 0 SysRem passes; reflected 5 components and a probe of 1e-4; emission 6 passes, no components and 3e-4
    p.add_argument("--sysrem", type=int, default=None)
    p.add_argument("--weight", choices=("linear", "sqrt", "log"), default="log")
    p.add_argument("--inject", type=float, default=0.0)
    p.add_argument("--redo", action="store_true")
    p.add_argument("--components", type=int, default=None)
    p.add_argument("--probe", type=float, default=None)
    a = p.parse_args()
    pick = lambda value, default: default if value is None else value
    if a.mode == "plan":
        giants_plan(a.vmax)
    elif a.mode == "opacities":
        giants_opacities(tuple(a.species) if a.species != list(giants_SPECIES) else ("CO2", "CH4"), tuple(a.temps))
    elif a.mode == "fetch":
        giants_fetch(a.streams, a.planets, a.night_per_in, a.instruments, a.min_in)
    elif a.mode == "record":
        giants_record(a.sigma)
    elif a.mode == "reflected":
        giants_reflected(a.planets, a.max_spectra, a.streams, components=pick(a.components, 5), probe=pick(a.probe, 1e-4), redo=a.redo)
    elif a.mode == "emission":
        giants_emission(a.planets, a.max_spectra, a.streams, species=tuple(a.species) if a.species != list(giants_SPECIES) else ("CO", "H2O"),
                        sysrem=pick(a.sysrem, 6), components=pick(a.components, 0), probe=pick(a.probe, 3e-4), redo=a.redo)
    else:
        giants_search(a.planets, a.species, a.sigma, a.temp, pick(a.sysrem, 0), a.weight, a.inject, redo=a.redo, instruments=tuple(a.instruments))


transits_DOC = """The transits of the rocky planets of red dwarfs: every archived spectrum overlapping a transit of a planet below 1.8 Earth radii of a star
cooler than 4000 K within 50 pc, with the same nights' out-of-transit spectra, tested at He I 10830, H alpha and Na D in the planet's frame against
sham transits, random draws of out-of-transit spectra and the trail reversed; the Moon through the transit of Venus of 2012 June 6 is the control.

    plan      the planets with their archived spectra matched to their transits
    fetch     the in-transit spectra with the same nights' out-of-transit ones
    run       each line tested in the planet's frame, the default
    record    the same, written as the run's record"""

transits_ROOT = archive_data("shoreline")
# the run's record under the results root
transits_RUN = "rocky_dwarfs_shoreline"
transits_LINES ={"HeI": (10830.25, 10830.34), "Halpha": (6562.80,), "NaD": (5889.95, 5895.92)}
transits_SKY = spectra_SKY + (10832.10, 10834.33, 10828.05)
transits_VGRID = np.arange(-300.0, 300.001, 0.5)

transits_VENUS = dict(pl_name="Venus (Moon)", hostname="Moon", pl_tranmid=2456084.563, pl_orbper=224.701, pl_trandur=6.67, pl_ratror=0.0087, pl_orbsmax=0.7233,
                       st_radv=0.0, mjd_lo=56083.8, mjd_hi=56084.4)


def transits_planets():
    """The transiting planets below 1.8 Earth radii of stars cooler than 4000 K within 50 pc with their ephemerides, radius ratios, axes and systemic velocities."""
    rows = archive_exoplanets("SELECT pl_name, hostname, ra, dec, sy_dist, st_teff, st_rad, st_mass, st_radv, pl_rade, pl_ratror, pl_orbsmax, pl_orbper, "
                           "pl_tranmid, pl_trandur, pl_eqt, sy_vmag, sy_jmag FROM pscomppars WHERE tran_flag = 1 AND pl_rade < 1.8 AND st_teff < 4000 "
                           "AND sy_dist < 50 ORDER BY sy_dist")
    out = []
    for r in rows:
        p = {k: (r[k] if k in ("pl_name", "hostname") else archive_num(r[k])) for k in r}
        if p["pl_tranmid"] is None or p["pl_orbper"] is None or p["pl_trandur"] is None:
            continue
        if p["pl_ratror"] is None and p["pl_rade"] and p["st_rad"]:
            p["pl_ratror"] = p["pl_rade"] * 6371.0 / (p["st_rad"] * 695700.0)
        if p["pl_orbsmax"] is None and p["st_mass"]:
            p["pl_orbsmax"] = (p["st_mass"] * (p["pl_orbper"] / 365.25) ** 2) ** (1.0 / 3.0)
        out.append(p)
    return out


def transits_weight(t0, t1, tc, per, dur, k):
    """The fraction of the planet's disc in front of the star averaged over an exposure: a trapezoid of the transit's duration (d) with ingress k/(1+k) of it, at the exposure's nearest transit."""
    t = np.linspace(t0, t1, 24)
    n = np.round((0.5 * (t0 + t1) - tc) / per)
    x = np.abs(t - (tc + n * per))
    tau = dur * k / (1.0 + k)
    w = np.clip((dur / 2.0 - x) / max(tau, 1e-6), 0.0, 1.0)
    return float(w.mean()), float(tc + n * per)


def transits_match(p, rows):
    """A planet's archived spectra by instrument: those overlapping a transit with their weights and epochs, and those of the same nights outside it."""
    tc, per, dur, k = p["pl_tranmid"] - 2400000.5, p["pl_orbper"], p["pl_trandur"] / 24.0, p["pl_ratror"] or 0.05
    out = {}
    for r in rows:
        w, t = transits_weight(r["t0"], r["t1"], tc, per, dur, k)
        d = out.setdefault(r["inst"], dict(src=r["src"], inside=[], night=[]))
        if w > 0:
            d["inside"].append(dict(r, w=w, epoch=t))
        elif abs(0.5 * (r["t0"] + r["t1"]) - t) < 0.5:
            d["night"].append(dict(r, epoch=t))
    return {i: d for i, d in out.items() if d["inside"]}


def transits_plan_summary(plan):
    """A transits plan as rows: each planet and instrument with its transits covered and its in-transit and same-night spectra counted."""
    return [dict(planet=p["pl_name"], host=p["hostname"], inst=inst, transits=len({round(x["epoch"], 2) for x in d["inside"]}), inside=len(d["inside"]),
                 night=len(d["night"])) for p in plan for inst, d in sorted(p["instruments"].items())]


def transits_plan():
    """The planets with their archived spectra matched to their transits, into ROOT/plan.json with its counts in ROOT/plan_summary.csv
    (transits_plan_summary), with the archive answers kept in ROOT/archives.json."""
    os.makedirs(transits_ROOT, exist_ok=True)
    planets = transits_planets()
    hosts = {}
    for p in planets:
        hosts.setdefault(p["hostname"], dict(ra=p["ra"], dec=p["dec"]))
    apath = os.path.join(transits_ROOT, "archives.json")
    arch = json.load(open(apath)) if os.path.exists(apath) else {}
    today = time.strftime("%Y-%m-%d")
    for name in arch:
        arch[name] = [r for r in arch[name] if r["src"] != "CADC" or (r["id"].endswith("t") and (r.get("release") or "")[:10] <= today)]
    todo = sorted(h for h in hosts if h not in arch)

    def one(name):
        try:
            return name, archive_spectra(hosts[name]["ra"], hosts[name]["dec"]), None
        except Exception as e:
            return name, None, str(e)[:200]
    errors = {}
    for name, rows, err in archive_pmap(one, todo, 4):
        if rows is None:
            errors[name] = err
        else:
            arch[name] = rows
    # hosts whose kept answers hold no KOA frames asked KOA alone
    for name in [h for h in hosts if h in arch and not any(r["src"] == "KOA" for r in arch[h])]:
        try:
            arch[name] = arch[name] + archive_koa_spectra(hosts[name]["ra"], hosts[name]["dec"])
        except Exception as e:
            errors[name] = str(e)[:200]
    json.dump(arch, open(apath, "w"), separators=(",", ":"))
    plan = []
    for p in planets:
        m = transits_match(p, arch.get(p["hostname"], []))
        if m:
            plan.append(dict(p, instruments=m))
    venus = dict(transits_VENUS, instruments={})
    moon = [r for r in archive_tap("eso", "SELECT dp_id, instrument_name, t_min, t_max, t_exptime, snr FROM ivoa.ObsCore WHERE dataproduct_type = 'spectrum' AND "
                                       "target_name = 'Moon' AND t_min > %f AND t_min < %f" % (transits_VENUS["mjd_lo"], transits_VENUS["mjd_hi"]))]
    venus["instruments"] = transits_match(venus, [dict(src="ESO", inst=r["instrument_name"], id=r["dp_id"], t0=float(r["t_min"]), t1=float(r["t_max"]),
                                                        exp=archive_num(r["t_exptime"]), lo=None, hi=None, snr=archive_num(r["snr"])) for r in moon])
    plan.append(venus)
    json.dump(plan, open(os.path.join(transits_ROOT, "plan.json"), "w"), separators=(",", ":"))
    planets_write(os.path.join(transits_ROOT, "plan_summary.csv"), transits_plan_summary(plan), ["planet", "host", "inst", "transits", "inside", "night"])
    print("%d planets of %d stars; %d stars with archived spectra (%d archives not answering); %d planets with a transit covered"
          % (len(planets), len(hosts), sum(1 for h in hosts if arch.get(h)), len(errors), len(plan) - 1))
    print("%-16s %-9s %7s %6s %6s   %s" % ("planet", "inst", "transits", "in", "night", "mid-transit MJDs"))
    for p in plan:
        for inst, d in sorted(p["instruments"].items()):
            ep = sorted({round(x["epoch"], 2) for x in d["inside"]})
            print("%-16s %-9s %7d %6d %6d   %s" % (p["pl_name"], inst, len(ep), len(d["inside"]), len(d["night"]), " ".join("%.2f" % e for e in ep[:6])))


def transits_path(r):
    """Where a spectrum lives under ROOT/spectra."""
    return archive_path(os.path.join(transits_ROOT, "spectra", r["inst"]), r)


def transits_fetch(streams=2, planets=(), venus=True, night_per_in=2.0):
    """The in-transit spectra of every planned planet (or the named ones) with, per transit, the same night's out-of-transit spectra nearest the transit up to NIGHT_PER_IN times their number, from ESO and the CADC, SPIRou as its telluric-corrected product, on STREAMS connections; KOA frames are listed only."""
    plan = json.load(open(os.path.join(transits_ROOT, "plan.json")))
    want = []
    for p in plan:
        if (planets and p["pl_name"] not in planets) or (p["hostname"] == "Moon" and not venus):
            continue
        for inst, d in p["instruments"].items():
            inside = [r for r in d["inside"] if r["src"] in ("ESO", "CADC")]
            want += inside
            for epoch in sorted({r["epoch"] for r in inside}):
                n = sum(1 for r in inside if r["epoch"] == epoch)
                night = sorted((r for r in d["night"] if r["src"] in ("ESO", "CADC") and r["epoch"] == epoch), key=lambda r: abs(0.5 * (r["t0"] + r["t1"]) - epoch))
                want += night[:max(int(night_per_in * n), 4)]
    seen, todo = set(), []
    for r in want:
        if r["id"] not in seen and not os.path.exists(transits_path(r)):
            seen.add(r["id"])
            todo.append(r)
    got = sum(1 for ok in archive_pmap(lambda r: archive_download(r, transits_path(r)), todo, streams) if ok)
    print("%d spectra wanted, %d already here, %d fetched, %d failed" % (len(want), len(want) - len(todo), got, len(todo) - got))


def transits_window(w, f, e, line, vsys, berv=0.0):
    """A spectrum's flux and error around a line on the velocity grid in the star's frame, each normalised by its median, NaN where the spectrum has no sample and within 6 km/s of a sky emission line at the telescope's wavelength."""
    lam = line * (1.0 + vsys / spectra_C)
    wl = lam * (1.0 + transits_VGRID / spectra_C)
    j = (w > wl[0] - 1.0) & (w < wl[-1] + 1.0) & np.isfinite(f) & (f > 0)
    if j.sum() < 20:
        return None, None
    fi = np.interp(wl, w[j], f[j], left=np.nan, right=np.nan)
    ei = np.interp(wl, w[j], e[j], left=np.nan, right=np.nan)
    m = np.nanmedian(fi)
    if not np.isfinite(m) or m <= 0:
        return None, None
    for sky in transits_SKY:
        v = spectra_C * (sky * (1.0 + berv / spectra_C) / lam - 1.0)
        if abs(v) < 320.0:
            fi[np.abs(transits_VGRID - v) < 6.0] = np.nan
    return fi / m, ei / m


def transits_trail(R, E, v, half, picks=None):
    """The weighted mean of residual windows each shifted into a frame moving at v (km/s), the mean within +-half of the line, the mean of the side bands 30-80 km/s away, and their difference: absorption when positive. With PICKS (draws, rows), the rows of R and E each draw takes, the k-th of every draw moved by v[k] and weighted by half[1][k]: the trails (draws, grid) and differences (draws,)."""
    one = picks is None
    picks = np.arange(len(v))[None, :] if one else np.asarray(picks)
    D, n = picks.shape
    step = transits_VGRID[1] - transits_VGRID[0]
    Rd, Ed = gpu_dev(R)[torch.as_tensor(picks, device=gpu_DEVICE)], gpu_dev(E)[torch.as_tensor(picks, device=gpu_DEVICE)]
    shift = gpu_dev(np.tile(np.asarray(v, float) / step, D))
    s = gpu_shift_rows(Rd.reshape(D * n, -1), shift).reshape(D, n, -1)
    se = gpu_shift_rows(Ed.reshape(D * n, -1), shift).reshape(D, n, -1)
    ok = torch.isfinite(s) & torch.isfinite(se) & (se > 0)
    wt = torch.where(ok, gpu_dev(half[1])[None, :, None] / torch.where(ok, se, torch.ones_like(se)) ** 2, torch.zeros_like(se))
    T = (torch.where(ok, s, torch.zeros_like(s)) * wt).sum(1) / wt.sum(1)
    g = gpu_dev(transits_VGRID)
    core_ = g.abs() <= half[0]
    side = (g.abs() >= 30.0) & (g.abs() <= 80.0)
    diff = gpu_nanmean(T[:, side], 1) - gpu_nanmean(T[:, core_], 1)
    if one:
        return gpu_host(T[0]), float(diff[0])
    return gpu_host(T), gpu_host(diff)


def transits_planet(p, inst, d, half_kms, draws, inject, rng):
    """One planet and instrument: the absorption at each line in the planet's frame from its in-transit spectra against the night's (else the star's) out-of-transit ones, the null from sham transits and random draws, and the trail reversed."""
    per, kp = p["pl_orbper"], spectra_kp(p, 0.02)
    spectra = []
    have = [r for r in d["inside"] + d["night"] if os.path.exists(transits_path(r))]
    for r, s in zip(have, spectra_load_many([transits_path(r) for r in have])):
        if s is not None:
            spectra.append(dict(w=s[0], f=s[1], e=s[2], meta=s[3], inside="w" in r, weight=r.get("w", 0.0), epoch=r["epoch"]))
    n_in = sum(1 for s in spectra if s["inside"])
    n_out = len(spectra) - n_in
    if n_in < 4 or n_out < 4:
        return None, n_in, n_out
    rvs = [s["meta"]["rv"] for s in spectra if s["meta"]["rv"] is not None]
    vsys = float(np.median(rvs)) if rvs else (p.get("st_radv") or 0.0)
    out = {}
    for name, lines in transits_LINES.items():
        res = []
        for line in lines:
            W = [transits_window(s["w"], s["f"], s["e"], line, vsys, s["meta"].get("berv", 0.0)) for s in spectra]
            if any(x[0] is None for x in W):
                continue
            F = np.array([x[0] for x in W])
            E = np.array([x[1] for x in W])
            ins = np.array([s["inside"] for s in spectra])
            master = np.nanmedian(F[~ins], axis=0)
            with np.errstate(all="ignore"):
                R, ER = F / master, E / master
            # each night's slow drift, a line in time fitted per velocity bin to its out-of-transit residuals, taken out of every spectrum
            epochs = np.array([s["epoch"] for s in spectra])
            mjds = np.array([s["meta"]["mjd"] for s in spectra])
            for ep in np.unique(epochs):
                night, outs_n = epochs == ep, (epochs == ep) & ~ins
                if outs_n.sum() >= 4:
                    x = mjds[night] - ep
                    xo = mjds[outs_n] - ep
                    Ro = R[outs_n]
                    good = np.isfinite(Ro)
                    n_b = good.sum(0)
                    X0 = np.where(good, xo[:, None], 0.0)
                    Y0 = np.where(good, Ro, 0.0)
                    sx, sy, sxx, sxy = X0.sum(0), Y0.sum(0), (X0 * X0).sum(0), (X0 * Y0).sum(0)
                    with np.errstate(all="ignore"):
                        slope = (n_b * sxy - sx * sy) / (n_b * sxx - sx * sx)
                        trend = (sy - slope * sx) / n_b + slope * x[:, None]
                    trend = np.where((n_b > 2)[None, :], trend, 1.0)
                    R[night] = R[night] / np.where(np.isfinite(trend) & (trend > 0), trend, 1.0)
            phase = np.array([(s["meta"]["mjd"] - s["epoch"]) / per for s in spectra])
            vp = kp * np.sin(2 * np.pi * phase)
            wt = np.array([s["weight"] for s in spectra])
            if inject:
                # an absorption of depth INJECT at the line in the planet's frame laid into the in-transit residuals before the test
                for i in np.where(ins)[0]:
                    R[i] *= 1.0 - inject * wt[i] * np.exp(-0.5 * ((transits_VGRID - vp[i]) / 4.0) ** 2)
            T, a = transits_trail(R[ins], ER[ins], vp[ins], (half_kms, wt[ins]))
            _, a_rev = transits_trail(R[ins], ER[ins], -vp[ins], (half_kms, wt[ins]))
            span = float(vp[ins].max() - vp[ins].min())
            # the null: every block of consecutive out-of-transit spectra in the transit's number, a sham transit carrying the night's drifts, then random draws
            outs = np.where(~ins)[0]
            order = outs[np.argsort([spectra[i]["meta"]["mjd"] for i in outs])]
            blocks = np.array([order[j:j + n_in] for j in range(0, len(order) - n_in + 1)], int).reshape(-1, n_in)
            picks = np.array([rng.choice(outs, size=n_in, replace=len(outs) < n_in) for _ in range(draws)], int).reshape(-1, n_in)
            every = np.concatenate([blocks, picks])
            null = np.concatenate([transits_trail(R, ER, vp[ins], (half_kms, wt[ins]), every[b0:b0 + 64])[1] for b0 in range(0, len(every), 64)] or [np.zeros(0)])
            res.append(dict(line=line, a=a, a_rev=a_rev, span=span, null_sd=float(np.std(null)), null_mean=float(np.mean(null)), p=float(np.mean(null >= a))))
        if res:
            a = float(np.mean([r["a"] for r in res]))
            sd = float(np.sqrt(np.mean([r["null_sd"] ** 2 for r in res]) / len(res)))
            out[name] = dict(a=a, a_rev=float(np.mean([r["a_rev"] for r in res])), sd=sd, z=a / sd if sd > 0 else 0.0,
                             p=float(np.mean([r["p"] for r in res])), span=res[0]["span"], lines=res)
    return dict(vsys=vsys, kp=kp, n_in=n_in, n_out=n_out, lines=out), n_in, n_out


def transits_main(record=False, sigma=3.0, half_kms=12.0, inject=0.0, draws=200, planets=[]):
    """Every planned planet and instrument, or the named PLANETS, tested at each line (transits_planet) with a core of HALF_KMS, DRAWS random draws in
    each null and INJECT laid in where given; a line stands at SIGMA in the planet's frame and over the reversed trail; with RECORD the tests are written
    as the run's record."""
    plan = json.load(open(os.path.join(transits_ROOT, "plan.json")))
    rng = np.random.default_rng(1)
    rows, found, tested, controls = [], [], set(), 0
    print("%-16s %-9s %4s %4s  %s" % ("planet", "inst", "in", "out", "absorption (per cent) and sigma at each line; reversed trail in brackets"))
    for p in plan:
        if planets and p["pl_name"] not in planets:
            continue
        for inst, d in sorted(p["instruments"].items()):
            r, n_in, n_out = transits_planet(p, inst, d, half_kms, draws, inject, rng)
            if r is None:
                if n_in:
                    print("%-16s %-9s %4d %4d  fewer than four %s spectra" % (p["pl_name"], inst, n_in, n_out, "in-transit" if n_in < 4 else "out-of-transit"))
                continue
            cells, hits = [], []
            for name, x in r["lines"].items():
                cells.append("%s %+.3f +- %.3f (%+.3f) %.1f sigma" % (name, 100 * x["a"], 100 * x["sd"], 100 * x["a_rev"], x["z"]))
                # a claim also needs the reversed trail below the planet's by the threshold
                if x["z"] >= sigma and x["a"] - x["a_rev"] >= sigma * x["sd"]:
                    hits.append(name)
            print("%-16s %-9s %4d %4d  %s%s" % (p["pl_name"], inst, n_in, n_out, "; ".join(cells), "  HIT " + ",".join(hits) if hits else ""))
            k = p["pl_ratror"] or 0.05
            for name, x in r["lines"].items():
                # the reversed trail's residual added to the null's scatter as a systematic floor
                limit = max(x["a"], 0.0) + sigma * np.hypot(x["sd"], x["a_rev"])
                if p["hostname"] == "Moon":
                    controls += 1
                else:
                    tested.add(p["pl_name"])
                rows.append(dict(target="planet:%s#%s %s" % (p["pl_name"], inst, name), stat=x["z"], p=x["p"], upper_limit=100 * limit, unit="per cent absorption at %s in the planet's frame (%s, %d in-transit spectra)" % (name, inst, n_in),
                                 vet=None if name in hits else ("control" if p["hostname"] == "Moon" else None),
                                 note="%s: %+.3f +- %.3f per cent, trail reversed %+.3f; %d out-of-transit; effective radius below %.2f planet radii" % (
                                     inst, 100 * x["a"], 100 * x["sd"], 100 * x["a_rev"], n_out, np.sqrt(1.0 + limit / k ** 2))))
                if name in hits:
                    found.append((p["pl_name"], inst, name, x))
    print("%d planet-instrument-line tests; %d above %g sigma in the planet's frame and over the reversed trail" % (len(rows), len(found), sigma))
    if record:
        archive_record_run(
            transits_RUN, "Atmospheres of the rocky planets of red dwarfs",
            "ESO Phase 3 (HARPS, ESPRESSO, NIRPS, CRIRES, UVES), CADC (CFHT SPIRou), KOA (Keck NIRSPEC); NASA Exoplanet Archive pscomppars",
            "every archived spectrum overlapping a transit of a planet below 1.8 Earth radii of a star cooler than 4000 K within 50 pc, with the same nights' out-of-transit spectra; the Moon through the Venus transit of 2012 June 6",
            "shoreline", len(tested), "planets", dict(sigma=sigma, half_kms=half_kms, draws=draws, inject=inject),
            "out-of-transit spectra drawn in the in-transit spectra's number, shifted along the planet's trail and weighted as they are; the trail reversed",
            "the %g sigma limit on the absorption in the planet's frame at each line, per planet and instrument" % sigma,
            "%d tests of %d planets and %d of the Moon through the transit of Venus; %d above %g sigma" % (len(rows) - controls, len(tested), controls, len(found), sigma), rows)
        print("recorded")


def transits_cli():
    if len(sys.argv) > 1 and sys.argv[1] == "plan":
        archive_quiet_warnings()
        transits_plan()
    elif len(sys.argv) > 1 and sys.argv[1] == "fetch":
        archive_quiet_warnings()
        p = argparse.ArgumentParser(prog="orbitlight.py transits fetch", description=transits_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
        p.add_argument("--streams", type=int, default=2)
        p.add_argument("--planets", nargs="*", default=[])
        p.add_argument("--night-per-in", type=float, default=2.0)
        a = p.parse_args(sys.argv[2:])
        transits_fetch(a.streams, a.planets, night_per_in=a.night_per_in)
    else:
        archive_run_cli(transits_main, transits_DOC)


companions_DOC = """Companions read out of their stars' spectra with the orbit left free: each star's spectra cross-correlated with a template star's lines, the
star's own pattern and the rows' principal components taken out, and the rows summed along every circular orbit of a grid of periods, phases and
amplitudes against nulls with the epochs, whole nights and nights within their season shuffled.

    plan      the archive's best-observed stars per spectrograph
    test      GJ 486's own lines laid into its SPIRou spectra on an orbit and sought blind
    search    one star's spectra from a folder searched against a template
    survey    the plan's stars of one instrument searched, their cross-correlation rows kept
    reanalyse the kept rows searched again
    validate  the kept rows of named stars searched blind and with a companion laid into them"""

companions_ROOT = archive_data("companions")


def companions_trails(ccf, t, periods, phases=24, kgrid=np.arange(30.0, 155.0, 5.0), core_kms=25.0, tell=None, tell_kms=10.0, batch=256, m_max=None):
    """The trail sum over every orbit of the grid: for each period, phase and amplitude the mean of the cross-correlations read at K sin(2 pi (t/P + phase)), the readings within CORE_KMS of the star's own velocity left out, since the star's residual pattern lives there, and, given each row's telluric velocity TELL in the star's frame, those within TELL_KMS of it, since the sky's lines sweep through the star's frame once a year; with M_MAX (solar masses) each amplitude searched only up to the longest period a system of that mass allows it, 2 pi G M / K^3; BATCH periods at a time: the summit (period, phase, K, value) and the whole table over periods."""
    dev = gpu_DEVICE
    n, width = ccf.shape
    vmax = (width - 1) // 2
    ph = np.arange(phases) / phases
    Cf = torch.as_tensor(np.ascontiguousarray(ccf), dtype=torch.float32, device=dev).reshape(-1)
    tt = torch.as_tensor(np.asarray(t, float), dtype=torch.float64, device=dev)
    pht = torch.as_tensor(ph, dtype=torch.float64, device=dev)
    kt = torch.as_tensor(np.asarray(kgrid, float), dtype=torch.float32, device=dev)
    base = (torch.arange(n, device=dev) * width)[None, :, None, None]
    tv = None if tell is None else torch.as_tensor(np.asarray(tell, float), dtype=torch.float32, device=dev)[None, :, None, None]
    P_all = np.asarray(periods, float)
    # the longest period at which each amplitude is possible: v^3 = 2 pi G M / P, with G M_sun = 1.32712e20 m^3 s^-2
    pmax = None if m_max is None else torch.as_tensor(2 * np.pi * 1.32712e20 * m_max / (np.asarray(kgrid, float) * 1e3) ** 3 / 86400.0, dtype=torch.float64, device=dev)
    table = np.full(len(P_all), -np.inf)
    where = np.zeros(len(P_all), dtype=np.int64)
    for s0 in range(0, len(P_all), batch):
        P = torch.as_tensor(P_all[s0:s0 + batch], dtype=torch.float64, device=dev)
        s = torch.sin(2 * np.pi * (tt[None, :, None] / P[:, None, None] + pht[None, None, :])).float()
        vel = kt[None, None, None, :] * s[..., None]
        # every row read at once by linear interpolation on the one km/s grid
        x = (vel + vmax).clamp(0, 2 * vmax - 1)
        j = torch.floor(x)
        frac = x - j
        idx = base + j.long()
        vals = Cf[idx] * (1.0 - frac) + Cf[idx + 1] * frac
        use = vel.abs() > core_kms
        if tv is not None:
            use = use & ((vel - tv).abs() > tell_kms)
        tot = (vals * use).sum(1) / use.sum(1).clamp(min=1)
        # the periods at which the sampling stays near one phase set aside
        tot = tot.masked_fill((s.std(1) < 0.45)[..., None], float("-inf"))
        if pmax is not None:
            tot = tot.masked_fill((P[:, None] > pmax[None, :])[:, None, :], float("-inf"))
        m, a = tot.reshape(tot.shape[0], -1).max(1)
        table[s0:s0 + len(P)] = m.cpu().numpy()
        where[s0:s0 + len(P)] = a.cpu().numpy()
    i = int(np.argmax(table))
    a, b = divmod(int(where[i]), len(kgrid))
    return (float(P_all[i]), float(ph[a]), float(kgrid[b]), float(table[i])), table


def companions_periods(t):
    """The period grid for a series: uniform in frequency at a quarter of the span's resolution, as a periodogram is, from half the span (two cycles at least, since a longer period reads a slow drift of the star's pattern as an orbit) down to half a day."""
    span = max(float(t.max() - t.min()), 1.0)
    f = np.arange(2.0 / span, 2.0, 1.0 / (4 * span))
    return 1.0 / f[::-1]


def companions_inject(spectra, T, band, vsys, depth, period, k):
    """Spectra with the line depths T laid into each at DEPTH on a circular orbit of PERIOD days and K km/s about the star's velocity (the header's,
    else VSYS), its phase zero at the first epoch."""
    t0 = min(s[3]["mjd"] for s in spectra)
    return [(w, spectra_lay(w, f, T, (meta["rv"] if meta.get("rv") is not None else vsys) + k * np.sin(2 * np.pi * (meta["mjd"] - t0) / period), depth, band),
             e, meta) for w, f, e, meta in spectra]


def companions_search(spectra, template, band, periods=None, trials=20, vsys=0.0, components=5):
    """One star's spectra against a template: residuals, whitened cross-correlations with the static pattern removed and COMPONENTS principal components after it, the trail summit over the orbit grid, and the summits of TRIALS shufflings of the epochs as the null, their scatter the sample standard deviation: (summit, null mean, null scatter, significance)."""
    R, sd, _ = spectra_residuals(spectra, vsys, band)
    ccf = spectra_ccf(R, template, sd)
    ccf = spectra_components(spectra_unpattern(ccf), components)
    t = np.array([s[3]["mjd"] for s in spectra])
    t = t - t.min()
    if periods is None:
        periods = companions_periods(t)
    best, table = companions_trails(ccf, t, periods)
    rng = np.random.default_rng(3)
    # the null on the same grid at its full density
    null = np.array([companions_trails(ccf, rng.permutation(t), periods)[0][3] for _ in range(trials)])
    z = (best[3] - null.mean()) / max(null.std(ddof=1), 1e-12)
    return best, float(null.mean()), float(null.std(ddof=1)), float(z), periods, table


def companions_test(depth=0.001, period=7.3, k=40.0):
    """An injection of GJ 486's own lines at DEPTH, moving on a PERIOD-day orbit of amplitude K, into its SPIRou spectra from the rocky-planet search, then the blind search with the star's own spectrum as the template, before and after the injection."""
    plan = json.load(open(os.path.join(transits_ROOT, "plan.json")))
    p = next(p for p in plan if p["pl_name"] == "GJ 486 b")
    paths = [transits_path(r) for r in p["instruments"]["SPIRou"]["inside"] + p["instruments"]["SPIRou"]["night"]]
    spectra = spectra_read([x for x in paths if os.path.exists(x)])
    vsys = p.get("st_radv") or 19.1
    band = "nir"
    T = spectra_template(spectra, vsys, band)
    print("%d spectra; template samples above 0.1: %d" % (len(spectra), int((T > 0.1).sum())), flush=True)
    best, nm, ns, z, periods, table = companions_search(spectra, T, band, vsys=vsys)
    print("blind, no injection: summit P %.2f d, K %.0f km/s, %.4f; null %.4f +- %.4f -> %.1f sigma" % (best[0], best[2], best[3], nm, ns, z), flush=True)
    best, nm, ns, z, periods, table = companions_search(companions_inject(spectra, T, band, vsys, depth, period, k), T, band, vsys=vsys)
    print("injected depth %g at P %.2f d, K %.0f: summit P %.2f d, K %.0f km/s, %.4f; null %.4f +- %.4f -> %.1f sigma" % (depth, period, k, best[0], best[2], best[3], nm, ns, z), flush=True)


def companions_plan(min_spectra=100, min_span=365.0):
    """The archive's best-observed stars per spectrograph, those with MIN_SPECTRA spectra or more over MIN_SPAN days or more, into ROOT/plan.json: instrument, name, count and span."""
    out = []
    for inst in ("HARPS", "ESPRESSO", "NIRPS", "CRIRES", "UVES"):
        q = ("SELECT TOP 2000 target_name, COUNT(*) AS n, MIN(t_min) AS t0, MAX(t_max) AS t1, AVG(s_ra) AS ra, AVG(s_dec) AS dec FROM ivoa.ObsCore WHERE "
             "dataproduct_type = 'spectrum' AND instrument_name = '%s' GROUP BY target_name ORDER BY n DESC" % inst)
        for r in archive_tap("eso", q, method="POST"):
            n, span = int(r["n"]), float(r["t1"]) - float(r["t0"])
            if n >= min_spectra and span >= min_span and r["target_name"].strip().upper() not in ("SUN", "MOON", "SKY"):
                out.append(dict(inst=inst, name=r["target_name"], n=n, span=round(span, 1), ra=archive_num(r["ra"]), dec=archive_num(r["dec"])))
    os.makedirs(companions_ROOT, exist_ok=True)
    json.dump(out, open(os.path.join(companions_ROOT, "plan.json"), "w"), separators=(",", ":"))
    by = {}
    for o in out:
        by[o["inst"]] = by.get(o["inst"], 0) + 1
    print("%d star-instrument series: %s" % (len(out), ", ".join("%s %d" % kv for kv in sorted(by.items()))))


def companions_untellur(ccf, tell):
    """Each cross-correlation row less the sky's pattern: the rows moved into their telluric frames, their median there taken as the pattern, moved back to each row's frame, fitted to the row at its own strength by least squares and subtracted."""
    C, tv = gpu_dev(ccf), gpu_dev(tell)
    pattern = gpu_nanmedian(gpu_shift_rows(C, tv), 0)
    pattern = torch.where(torch.isfinite(pattern), pattern, torch.zeros_like(pattern))
    back = gpu_shift_rows(pattern[None, :].expand(C.shape[0], -1), -tv, 0.0, 0.0)
    scale = (C * back).sum(1) / torch.clamp((back * back).sum(1), min=1e-30)
    return gpu_host(C - scale[:, None] * back)


def companions_night_shuffle(t, rng):
    """The epochs with whole nights moved to other nights' dates, each night keeping its spectra's offsets from its start, so that what is tied to the hour of observing or to one night's conditions stays in the null."""
    night = np.floor(t + 0.3)
    bases, inv = np.unique(night, return_inverse=True)
    return bases[rng.permutation(len(bases))][inv] + (t - night)


def companions_season_shuffle(t, rng, width=20.0):
    """The epochs with whole nights moved only among nights within the same WIDTH days of the year, each night keeping its spectra's offsets from its start, so that what follows the season and the hour of observing stays in the null; a season with one night keeps it."""
    night = np.floor(t + 0.3)
    bases, inv = np.unique(night, return_inverse=True)
    season = np.floor((bases % 365.25) / width)
    moved = bases.copy()
    for s in np.unique(season):
        idx = np.where(season == s)[0]
        moved[idx] = bases[idx][rng.permutation(len(idx))]
    return moved[inv] + (t - night)


companions_KGRID = np.arange(40.0, 155.0, 5.0)
companions_CORE = 30.0
companions_MMAX = 2.0
companions_ALIASES = ((0.5, 0.02), (0.99727, 0.02), (1.0, 0.02), (2.0, 0.02), (4.0, 0.02), (182.6, 0.08), (365.25, 0.08), (730.5, 0.08))


def companions_off_aliases(periods):
    """The periods away from the sampling's own: the summit is taken only there, since the day's and the year's rhythms outweigh a companion's trail at those periods and a companion on them cannot be told from the observing."""
    keep = np.ones(len(periods), dtype=bool)
    for p, w in companions_ALIASES:
        keep &= np.abs(periods / p - 1.0) >= w
    return periods[keep]


def companions_trail_result(ccf, t, components, trials=20, tell=None):
    """The trail summit of cleaned cross-correlation rows over the series' period grid, amplitudes from 40 km/s and the star's core to 30 km/s left out: the sky's pattern removed in its own frame and each row's telluric velocity TELL masked where given, then the summit against three nulls of TRIALS draws each, the epochs shuffled, whole nights shuffled and nights shuffled within their season, each null's scatter its sample standard deviation and the lowest significance kept; a summit at the sampling's own periods marked as an alias: the result fields for a star."""
    rows = companions_untellur(ccf, tell) if tell is not None else ccf
    c = spectra_components(rows, components)
    tt = t - t.min()
    pmax = 2 * np.pi * 1.32712e20 * companions_MMAX / (companions_KGRID.min() * 1e3) ** 3 / 86400.0
    periods = companions_off_aliases(companions_periods(tt))
    periods = periods[periods <= pmax]
    run = lambda times: companions_trails(c, times, periods, kgrid=companions_KGRID, core_kms=companions_CORE, tell=tell, batch=512, m_max=companions_MMAX)
    best, table = run(tt)
    rng = np.random.default_rng(3)
    ep = np.array([run(rng.permutation(tt))[0][3] for _ in range(trials)])
    ni = np.array([run(companions_night_shuffle(tt, rng))[0][3] for _ in range(trials)])
    se = np.array([run(companions_season_shuffle(tt, rng))[0][3] for _ in range(trials)])
    zs = {name: (best[3] - x.mean()) / max(x.std(ddof=1), 1e-12) for name, x in (("epochs", ep), ("nights", ni), ("seasons", se))}
    z_ep, z_ni, z_se = zs["epochs"], zs["nights"], zs["seasons"]
    null = {"epochs": ep, "nights": ni, "seasons": se}[min(zs, key=zs.get)]
    alias = next(("%g d" % p for p, w in companions_ALIASES if abs(best[0] / p - 1.0) < w), None)
    return dict(span=float(tt.max()), period=best[0], phase=best[1], k=best[2], value=best[3], null_mean=float(null.mean()), null_sd=float(null.std(ddof=1)),
                z=float(min(z_ep, z_ni, z_se)), z_epochs=float(z_ep), z_nights=float(z_ni), z_seasons=float(z_se), nights=int(len(np.unique(np.floor(tt + 0.3)))),
                alias=alias, components=components, trials=trials, telluric_mask=tell is not None, method=6)


def companions_tell(name, mjd, vsys, berv=None, vstar=None, instrument="HARPS"):
    """Each row's telluric velocity in the star's frame, the barycentric correction less the velocity the spectrum was put at: the correction from the kept rows where they carry it, else computed from the plan's position for the instrument's site; the velocity per row (VSTAR) where kept, else VSYS."""
    if berv is None or not np.all(np.isfinite(berv)):
        # names compared without spaces and underscores
        key = lambda s: re.sub(r"[\s_]", "", str(s)).upper()
        plan = {key(p["name"]): p for p in json.load(open(os.path.join(companions_ROOT, "plan.json"))) if p["inst"] == instrument}
        p = plan.get(key(name))
        if p is None or p.get("ra") is None:
            return None
        site = "Paranal" if instrument in ("ESPRESSO", "UVES", "CRIRES") else "LaSilla"
        berv = np.atleast_1d(archive_barycentric_correction(p["ra"], p["dec"], np.asarray(mjd, float), site))
    return np.asarray(berv, float) - (np.asarray(vstar, float) if vstar is not None else float(vsys or 0.0))


def companions_reanalyse(components=5, instrument=None, part=None, trials=20):
    """Every star whose cross-correlation rows are kept under ROOT/ccf searched again from those rows with COMPONENTS principal components taken out and TRIALS draws in each null, the results under ROOT/results rewritten; PART (k, n) takes the stars whose tag hashes to k of n, so n searches can run side by side."""
    os.makedirs(os.path.join(companions_ROOT, "results"), exist_ok=True)
    n = 0
    for path in sorted(glob.glob(os.path.join(companions_ROOT, "ccf", "*.npz"))):
        tag = os.path.basename(path)[:-4]
        if instrument and not tag.startswith(instrument + "_"):
            continue
        if part and zlib.crc32(tag.encode()) % part[1] != part[0]:
            continue
        rpath = os.path.join(companions_ROOT, "results", tag + ".json")
        old = json.load(open(rpath)) if os.path.exists(rpath) else (json.load(open(path[:-4] + ".json")) if os.path.exists(path[:-4] + ".json") else {})
        # a star whose note is missing waits for the next pass
        if not old or (old.get("components") == components and old.get("trials") == trials and old.get("method") == 6 and "z" in old):
            continue
        try:
            with np.load(path) as d:
                rows, mjd = d["ccf"].astype(np.float64), d["mjd"]
                berv = d["berv"] if "berv" in d.files else None
                vstar = d["vstar"] if "vstar" in d.files else None
        except Exception:
            continue
        tell = companions_tell(old.get("name") or tag[len(instrument or "HARPS") + 1:], mjd, old.get("vsys"), berv, vstar, instrument or "HARPS")
        res = companions_trail_result(rows, mjd, components, trials, tell)
        out = dict(old, n=int(rows.shape[0]), **res)
        json.dump(out, open(rpath, "w"), separators=(",", ":"))
        print("%-20s %3d rows over %5.0f d on %d nights: summit P %8.2f d, K %3.0f km/s, %.2f; null %.2f +- %.2f -> %.1f sigma (epochs %.1f, nights %.1f, seasons %.1f)%s" % (
            out.get("name", tag), out["n"], out["span"], out["nights"], out["period"], out["k"], out["value"], out["null_mean"], out["null_sd"], out["z"],
            out["z_epochs"], out["z_nights"], out["z_seasons"], "; alias of %s" % out["alias"] if out["alias"] else ""), flush=True)
        n += 1
    print("%d stars searched again" % n)


def companions_plant(ccf, t, period, k, width, height):
    """Cross-correlation rows with a companion's trail laid into them: a Gaussian of WIDTH km/s and HEIGHT centred on K sin(2 pi (t - t0) / PERIOD), t0 the first epoch."""
    v = np.arange(ccf.shape[1], dtype=float) - (ccf.shape[1] - 1) // 2
    vt = k * np.sin(2 * np.pi * (np.asarray(t, float) - np.min(t)) / period)
    return ccf + height * np.exp(-0.5 * ((v[None, :] - vt[:, None]) / width) ** 2)


def companions_validate(stars, period=7.3, k=50.0, width=4.0, components=5, trials=20, instrument="HARPS"):
    """The kept rows of the named STARS (names or tags) searched as the re-search searches them, blind and again with a companion of PERIOD days and K km/s laid into them (companions_plant), its height one sample of the noise the trail sum meets, the scatter beyond 150 km/s of the star of the rows cleaned as the search cleans them: each summit with its significances against the three nulls, the planted summit counted on the orbit within 1 per cent in period and 5 km/s in amplitude; into RESULTS/companions/validation.json."""
    key = lambda s: re.sub(r"[\s_]", "", str(s)).upper()
    tags = [os.path.basename(p)[:-4] for p in sorted(glob.glob(os.path.join(companions_ROOT, "ccf", instrument + "_*.npz")))]
    out = dict(planted=dict(period_d=period, k_kms=k, width_kms=width, height="one sample of the cleaned rows' scatter beyond 150 km/s of the star"), components=components, trials=trials, stars=[])
    summary = lambda r: dict(period_d=round(r["period"], 2), k_kms=r["k"], sigma=round(r["z"], 1), z_epochs=round(r["z_epochs"], 1), z_nights=round(r["z_nights"], 1),
                             z_seasons=round(r["z_seasons"], 1), alias=r["alias"])
    for star in stars:
        tag = next((x for x in tags if key(star) in (key(x), key(x[len(instrument) + 1:]))), None)
        if tag is None:
            print("%s: no kept rows" % star, flush=True)
            continue
        note = json.load(open(os.path.join(companions_ROOT, "ccf", tag + ".json")))
        with np.load(os.path.join(companions_ROOT, "ccf", tag + ".npz")) as d:
            rows, mjd = d["ccf"].astype(np.float64), d["mjd"]
            berv = d["berv"] if "berv" in d.files else None
            vstar = d["vstar"] if "vstar" in d.files else None
        tell = companions_tell(note.get("name") or tag[len(instrument) + 1:], mjd, note.get("vsys"), berv, vstar, instrument)
        blind = companions_trail_result(rows, mjd, components, trials, tell)
        v = np.arange(rows.shape[1], dtype=float) - (rows.shape[1] - 1) // 2
        clean = spectra_components(companions_untellur(rows, tell) if tell is not None else rows, components)
        height = float(np.std(clean[:, np.abs(v) > 150.0]))
        planted = companions_trail_result(companions_plant(rows, mjd, period, k, width, height), mjd, components, trials, tell)
        on = bool(abs(planted["period"] / period - 1.0) < 0.01 and abs(planted["k"] - k) <= 5.0)
        out["stars"].append(dict(star=note.get("name") or tag, tag=tag, n=int(rows.shape[0]), nights=blind["nights"], span_d=round(blind["span"], 1), height=height,
                                 blind=summary(blind), planted=dict(summary(planted), on_orbit=on)))
        print("%-20s %3d rows on %3d nights: blind P %8.2f d, K %3.0f km/s, %.1f sigma; planted P %8.2f d, K %3.0f km/s, %.1f sigma%s" % (
            note.get("name") or tag, rows.shape[0], blind["nights"], blind["period"], blind["k"], blind["z"], planted["period"], planted["k"], planted["z"],
            ", on the orbit" if on else ""), flush=True)
        path = archive_results("companions", "validation.json")
        os.makedirs(os.path.dirname(path), exist_ok=True)
        json.dump(out, open(path, "w"), separators=(",", ":"))


def companions_survey(instrument="HARPS", per_star=300, max_stars=0, streams=4, template_dir=None, template_obj="GJ 367", template_vsys=47.9, keep=False, components=5, stars=(), ccf_only=False):
    """The plan's series of one instrument, most spectra first (or the named STARS in their order): up to PER_STAR spectra of each star spread over its span fetched from ESO, searched blind against the template with COMPONENTS principal components taken out of the cross-correlation rows, the summit, null and cross-correlation rows kept under ROOT/results and ROOT/ccf, and the spectra removed unless KEEP; a star with a result is passed over; with CCF_ONLY the rows are kept and the trail search left for later."""
    plan = [p for p in json.load(open(os.path.join(companions_ROOT, "plan.json"))) if p["inst"] == instrument]
    plan.sort(key=lambda p: -p["n"])
    if stars:
        order = {s.strip().upper().replace(" ", ""): i for i, s in enumerate(stars)}
        plan = sorted((p for p in plan if p["name"].strip().upper().replace(" ", "") in order), key=lambda p: order[p["name"].strip().upper().replace(" ", "")])
    band = spectra_band(instrument)
    tpl_dir = template_dir or os.path.join(transits_ROOT, "spectra", "HARPS")
    # a template kept as an array (.npy) read as it is
    T = np.load(tpl_dir) if str(tpl_dir).endswith(".npy") else spectra_template(spectra_read(companions_files(tpl_dir, template_obj)), template_vsys, band)
    os.makedirs(os.path.join(companions_ROOT, "results"), exist_ok=True)
    os.makedirs(os.path.join(companions_ROOT, "ccf"), exist_ok=True)
    done = 0
    for p in plan:
        tag = archive_tag(instrument, p["name"])
        rpath = os.path.join(companions_ROOT, "results", tag + ".json")
        if os.path.exists(rpath) or (ccf_only and os.path.exists(os.path.join(companions_ROOT, "ccf", tag + ".npz"))):
            continue
        # the stars ccf/done.txt lists passed over
        finished = os.path.join(companions_ROOT, "ccf", "done.txt")
        if os.path.exists(finished) and tag in set(open(finished, encoding="utf-8").read().split()):
            continue
        rows = [r for r in archive_spectra(p["ra"], p["dec"]) if r["inst"] == instrument and (r.get("snr") or 0) > 30]
        rows.sort(key=lambda r: r["t0"])
        pick = rows[::max(len(rows) // per_star, 1)][:per_star]
        folder = os.path.join(companions_ROOT, "spectra", tag)
        paths = [x for x in archive_pmap(lambda r: archive_download(r, archive_path(folder, r)), pick, streams) if x]
        spectra = spectra_read(paths)
        if len(spectra) < 30:
            json.dump(dict(name=p["name"], inst=instrument, n=len(spectra), note="too few spectra"), open(rpath, "w"), separators=(",", ":"))
            continue
        vsys = spectra_vsys(spectra)
        info = {}
        R, sd, _ = spectra_residuals(spectra, vsys, band, info=info)
        ccf = spectra_unpattern(spectra_ccf(R, T, sd))
        t = np.array([s[3]["mjd"] for s in spectra])
        berv = np.array([s[3].get("berv") if s[3].get("berv") is not None else np.nan for s in spectra], float)
        vstar = info.get("vstar", np.full(len(spectra), vsys))
        np.savez_compressed(os.path.join(companions_ROOT, "ccf", tag + ".npz"), ccf=ccf.astype(np.float32), mjd=t, berv=berv, vstar=vstar)
        if ccf_only:
            json.dump(dict(name=p["name"], inst=instrument, n=len(spectra), vsys=vsys), open(os.path.join(companions_ROOT, "ccf", tag + ".json"), "w"),
                      separators=(",", ":"))
            print("%-20s %3d spectra: rows kept" % (p["name"], len(spectra)), flush=True)
            if not keep:
                shutil.rmtree(folder, ignore_errors=True)
            done += 1
            if max_stars and done >= max_stars:
                break
            continue
        res = companions_trail_result(ccf, t, components, tell=berv - vstar if np.all(np.isfinite(berv)) else None)
        json.dump(dict(name=p["name"], inst=instrument, n=len(spectra), vsys=vsys, **res), open(rpath, "w"), separators=(",", ":"))
        print("%-20s %3d spectra over %5.0f d: summit P %8.2f d, K %3.0f km/s, %.2f; null %.2f +- %.2f -> %.1f sigma" % (
            p["name"], len(spectra), res["span"], res["period"], res["k"], res["value"], res["null_mean"], res["null_sd"], res["z"]), flush=True)
        if not keep:
            shutil.rmtree(folder, ignore_errors=True)
        done += 1
        if max_stars and done >= max_stars:
            break
    print("%d stars searched" % done)


def companions_files(folder, obj):
    """The FITS files of a folder whose OBJECT header holds OBJ (spaces ignored, case ignored), all of them without OBJ."""
    from astropy.io import fits
    out = []
    for f in sorted(glob.glob(os.path.join(folder, "*.fits"))):
        if not obj or obj.replace(" ", "").upper() in str(fits.getheader(f).get("OBJECT", "")).replace(" ", "").upper():
            out.append(f)
    return out


def companions_cli():
    archive_quiet_warnings()
    p = argparse.ArgumentParser(prog="orbitlight.py companions", description=companions_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("mode", choices=("plan", "test", "search", "survey", "reanalyse", "validate"))
    p.add_argument("--components", type=int, default=5)
    p.add_argument("--trials", type=int, default=20, help="draws in each null")
    p.add_argument("--stars", nargs="*", default=[])
    p.add_argument("--stars-file")
    p.add_argument("--part", help="k/n: the re-search's share, by the stars' tags")
    p.add_argument("--ccf-only", action="store_true")
    p.add_argument("--per-star", type=int, default=300)
    p.add_argument("--max-stars", type=int, default=0)
    p.add_argument("--streams", type=int, default=4)
    p.add_argument("--keep", action="store_true")
    p.add_argument("target", nargs="?")
    p.add_argument("--object", default="")
    p.add_argument("--vsys", type=float, default=None)
    p.add_argument("--template")
    p.add_argument("--template-object", default="")
    p.add_argument("--template-vsys", type=float, default=0.0)
    p.add_argument("--inst", default="SPIRou")
    p.add_argument("--max", type=int, default=0)
    p.add_argument("--inject", type=float, default=0.0)
    p.add_argument("--depth", type=float, default=0.001)
    p.add_argument("--period", type=float, default=7.3)
    # the planted amplitude defaults per mode: test and search 40 km/s, validate 50
    p.add_argument("--k", type=float, default=None)
    p.add_argument("--width", type=float, default=4.0)
    a = p.parse_args()
    if a.stars_file:
        a.stars = [s.strip() for s in open(a.stars_file, encoding="utf-8") if s.strip()]
    if a.k is None:
        a.k = 50.0 if a.mode == "validate" else 40.0
    if a.mode == "plan":
        companions_plan()
        return
    if a.mode == "survey":
        companions_survey(a.inst, a.per_star, a.max_stars, a.streams, a.template, a.template_object or "GJ 367", a.template_vsys or 47.9, a.keep, a.components, a.stars, a.ccf_only)
        return
    if a.mode == "reanalyse":
        companions_reanalyse(a.components, a.inst if a.inst != "SPIRou" else None, tuple(int(x) for x in a.part.split("/")) if a.part else None, a.trials)
        return
    if a.mode == "validate":
        companions_validate(a.stars, a.period, a.k, a.width, a.components, a.trials, a.inst if a.inst != "SPIRou" else "HARPS")
        return
    if a.mode == "test":
        companions_test(a.depth, a.period, a.k)
        return
    band = spectra_band(a.inst)
    files = companions_files(a.target, a.object)
    spectra = spectra_read(files[:a.max] if a.max else files)
    tpl = spectra_read(companions_files(a.template, a.template_object)) if a.template else spectra
    T = spectra_template(tpl, a.template_vsys, band)
    vsys = a.vsys if a.vsys is not None else spectra_vsys(spectra)
    print("%d spectra of %s at %.1f km/s, template from %d spectra of %s: template samples above 0.1: %d" % (len(spectra), a.object or a.target, vsys, len(tpl), a.template_object or "itself", int((T > 0.1).sum())), flush=True)
    if a.inject:
        spectra = companions_inject(spectra, T, band, vsys, a.inject, a.period, a.k)
    best, nm, ns, z, periods, table = companions_search(spectra, T, band, trials=a.trials, vsys=vsys, components=a.components)
    print("%s: summit P %.2f d, phase %.2f, K %.0f km/s, %.4f; null %.4f +- %.4f -> %.1f sigma" % (
        "injected %g at P %.2f d, K %.0f" % (a.inject, a.period, a.k) if a.inject else "blind", best[0], best[1], best[2], best[3], nm, ns, z), flush=True)


binaries_DOC = """Companions along known orbits: the M-dwarf companions of single-lined binaries read out of their archived spectra. The series of a target in
the ESO archive, the primary's orbit fitted to its own velocities (measured against a template star's line depths, then against the star's own,
twice), every spectrum's residual cross-correlated with a companion template and kept as rows, the rows summed along the companion's track over its
semi-amplitude K2 against nulls with the orbit's phase moved and whole nights shuffled, and a detection measured: the map over K2 and the companion's
systemic offset, the bootstrap over whole nights, the halves by date and alternate nights, and the profile in the companion's frame.

    series    the archive's series whose target names match a pattern, added to the targets
    orbit     each named target's orbit from its own spectra
    rows      each named target's cross-correlation rows kept
    search    the rows summed along the companion's track over K2
    measure   one target's detection measured
    depth     a companion's lines fitted along its track beside the pattern common to every row, their depth as a fraction of the template's
    template  a template star's line depths from its best spectra
    zero      where each template's lines sit against Kurucz's
    shift     a template moved in velocity"""

binaries_ROOT = archive_data("binaries")

# the companion template, GJ 367's optical line depths, in this repository's companions folder
binaries_TEMPLATE = "companions/GJ367_optical.npy"


def binaries_template_path():
    """The companion template's path: in the companions folder beside this file in a clone of the repository, else fetched from the repository on
    Hugging Face and kept in its cache."""
    here = os.path.join(os.path.dirname(os.path.abspath(__file__)), *binaries_TEMPLATE.split("/"))
    if os.path.exists(here):
        return here
    from huggingface_hub import hf_hub_download
    return hf_hub_download("phanerozoic/orbitlight", binaries_TEMPLATE, repo_type="dataset")

# Gaia DR3 counts its times of periastron from the reference epoch J2016.0, JD 2457389.0
binaries_J2016 = 2457389.0


def binaries_key(s):
    """A name compared without spaces or punctuation, in capitals."""
    return re.sub(r"[^A-Za-z0-9]", "", str(s)).upper()


def binaries_targets():
    """The targets' entries under ROOT/targets.json: name, instrument, position and, once fitted, the primary's orbit."""
    path = os.path.join(binaries_ROOT, "targets.json")
    return json.load(open(path)) if os.path.exists(path) else []


def binaries_save(entries):
    """The targets' entries written back to ROOT/targets.json."""
    os.makedirs(binaries_ROOT, exist_ok=True)
    json.dump(entries, open(os.path.join(binaries_ROOT, "targets.json"), "w"), separators=(",", ":"))


def binaries_target(name, inst):
    """One target's entry by name and instrument."""
    t = next((x for x in binaries_targets() if x["inst"] == inst and binaries_key(x["name"]) == binaries_key(name)), None)
    if t is None:
        raise KeyError("%s: no %s series among the targets" % (name, inst))
    return t


def binaries_radial(t, P, tp, e, w_deg):
    """The orbit's radial-velocity shape at MJD T, omega in degrees (planets_kepler)."""
    return planets_kepler(np.asarray(t, float), P, tp, e, np.radians(w_deg))


def binaries_orbit_of(target):
    """A target's orbit as (period, time of periastron in MJD, e, omega in degrees, K1, gamma), from Gaia DR3's convention, a Julian date or an MJD."""
    tp = target["t_peri"]
    if str(target.get("source", "")).startswith("Gaia"):
        tp = binaries_J2016 + tp
    elif tp < 1e5:
        tp = tp + 2400000.0
    return target["period"], tp - 2400000.5, target.get("e") or 0.0, target.get("omega") or 0.0, target["k1"], target.get("gamma") or 0.0


def binaries_series(pattern="%EBLM%", instruments=("HARPS", "ESPRESSO", "NIRPS"), min_spectra=15):
    """The ESO archive's series whose target names match PATTERN (an ADQL LIKE pattern), MIN_SPECTRA or more spectra per instrument, added to the targets with their mean positions, counts and spans; entries already there are kept."""
    entries = binaries_targets()
    have = {(x["inst"], binaries_key(x["name"])) for x in entries}
    added = 0
    for inst in instruments:
        q = ("SELECT target_name, COUNT(*) AS n, AVG(s_ra) AS ra, AVG(s_dec) AS dec, MIN(t_min) AS t0, MAX(t_min) AS t1 FROM ivoa.ObsCore WHERE "
             "dataproduct_type = 'spectrum' AND instrument_name = '%s' AND target_name LIKE '%s' GROUP BY target_name" % (inst, pattern.replace("'", "''")))
        for r in archive_tap("eso", q, method="POST"):
            n = int(r["n"])
            if n < min_spectra or (inst, binaries_key(r["target_name"])) in have:
                continue
            entries.append(dict(name=r["target_name"].strip(), inst=inst, n=n, ra=archive_num(r["ra"]), dec=archive_num(r["dec"]),
                                span=round(float(r["t1"]) - float(r["t0"]), 1), source="archive series"))
            have.add((inst, binaries_key(r["target_name"])))
            added += 1
    binaries_save(entries)
    print("%d series added; %d targets" % (added, len(entries)))


def binaries_fetch(target, inst, min_snr=10.0, most=300, streams=4):
    """A target's spectra from its instrument above MIN_SNR, MOST at most spread over the span, fetched into ROOT/spectra/<tag>: the loaded spectra and the number listed."""
    rows = archive_eso_listing(target["ra"], target["dec"], inst, min_snr)
    paths = archive_eso_fetch(rows, os.path.join(binaries_ROOT, "spectra", archive_tag(inst, target["name"])), streams, most)
    return spectra_read(paths), len(rows)


def binaries_onto(spectra, v=None, band="optical"):
    """Each spectrum on the band's grid, moved by its velocity V where given, over its running median of 501 samples, the telluric regions NaN."""
    g = spectra_grid(band)
    out = spectra_onto([(w / (1.0 + (0.0 if v is None else v[i]) / spectra_C), f, None) for i, (w, f, e, meta) in enumerate(spectra)], g)[0]
    for lo, hi in spectra_BANDS[band]["telluric"]:
        out[:, (g > lo) & (g < hi)] = np.nan
    return out


def binaries_line_depths(spectra, v, band="optical"):
    """A star's line depths on the band's grid: one minus the median of its spectra each put at its own velocity V, negative values zero."""
    return spectra_depths(gpu_host(gpu_nanmedian(binaries_onto(spectra, v, band), 0)))


def binaries_velocities(spectra, T, vmax=200, band="optical"):
    """Each spectrum's velocity in the barycentric frame (km/s): the peak of its cross-correlation with the line depths T over +-VMAX, refined by a parabola through the three highest samples, with the peak's height."""
    c = spectra_ccf(binaries_onto(spectra, None, band) - 1.0, T, None, vmax)
    v = np.arange(-vmax, vmax + 1, dtype=float)
    out, height = np.zeros(len(c)), np.zeros(len(c))
    for i, row in enumerate(c):
        k = int(np.argmax(row))
        if 0 < k < len(row) - 1:
            a, b, cc = row[k - 1], row[k], row[k + 1]
            den = a - 2 * b + cc
            out[i] = v[k] + (0.5 * (a - cc) / den if den < 0 else 0.0)
        else:
            out[i] = v[k]
        height[i] = row[k]
    return out, height


def binaries_keplerian(t, v, P=None):
    """A Keplerian orbit fitted to velocities V at MJD T: the period from a circular-orbit periodogram unless given, then least squares with a soft loss from three periods, three eccentricities, four arguments and eight phases: ((P, tp, e, omega, K1, gamma), robust scatter), with the periods tried."""
    span = float(t.max() - t.min())
    peaks = [P] if P else []
    if not P:
        freqs = np.arange(1.0 / (2.0 * span), 2.0, 0.1 / span)
        td, vd = gpu_dev(t), gpu_dev(v)
        chi = np.empty(len(freqs))
        for f0 in range(0, len(freqs), 4096):
            ph = 2 * np.pi * gpu_dev(freqs[f0:f0 + 4096])[:, None] * td[None, :]
            A = torch.stack([torch.ones_like(ph), torch.cos(ph), torch.sin(ph)], -1)
            coef = torch.linalg.lstsq(A, vd[None, :, None].expand(len(ph), -1, 1)).solution
            chi[f0:f0 + 4096] = gpu_host((((A @ coef)[..., 0] - vd[None, :]) ** 2).sum(1))
        for i in np.argsort(chi):
            if all(abs(1.0 / freqs[i] / p - 1.0) > 0.02 for p in peaks):
                peaks.append(1.0 / freqs[i])
            if len(peaks) == 3:
                break
    unpack = lambda x: (x[0], x[1], min(x[2] ** 2 + x[3] ** 2, 0.95), float(np.degrees(np.arctan2(x[3], x[2]))), abs(x[4]), x[5])
    x0, lo, hi = [], [], []
    for P0 in peaks:
        for e0 in (0.05, 0.3, 0.6):
            for w0 in (0.0, 90.0, 180.0, 270.0):
                for ph in np.arange(0.0, 1.0, 0.125):
                    x0.append([P0, t.min() + ph * P0, np.sqrt(e0) * np.cos(np.radians(w0)), np.sqrt(e0) * np.sin(np.radians(w0)), 0.5 * np.ptp(v), float(np.median(v))])
                    lo.append([P0 * 0.97, -np.inf, -0.97, -0.97, -np.inf, -np.inf])
                    hi.append([P0 * 1.03, np.inf, 0.97, 0.97, np.inf, np.inf])
    td, vd = gpu_dev(t), gpu_dev(v)

    def resid(x, idx):
        P_, tp_, c, s, K, g0 = (x[:, j:j + 1] for j in range(6))
        return g0 + K.abs() * gpu_keplerian(td[None, :], P_, tp_, torch.clamp(c * c + s * s, max=0.95), torch.atan2(s, c)) - vd[None, :]
    x, _ = gpu_lm(resid, np.array(x0), np.array(lo), np.array(hi), f_scale=0.5)
    # the start whose fit leaves the least robust scatter
    rms = 1.4826 * gpu_host(gpu_nanmedian(resid(x, None).abs(), 1))
    k = int(np.argmin(rms))
    return (unpack(gpu_host(x[k])), float(rms[k])), peaks


def binaries_refit(t, vstar, measured, P, tp, e, w, k1):
    """The orbit fitted to the velocities the rows were put at, on the rows MEASURED marks: a grid over period (within 0.4 per cent, in steps that move the last epoch by a fiftieth of an orbit), phase, e and omega with K1 and the offset solved at each point, then least squares with a soft loss: (P, tp, e, omega, K1, offset, robust scatter)."""
    tm, vm = t[measured], vstar[measured]
    span = max(float(tm.max() - tm.min()), P)
    step = 0.02 * P / span * P
    ph = np.arange(0.0, 1.0, 0.01)
    best = (np.inf, P, tp, e, w)
    Pgs = np.arange(P * 0.996, P * 1.004 + step / 2, step)
    wgs = np.arange(0.0, 360.0, 20.0)
    TM, VC = gpu_dev(tm), gpu_dev(vm - vm.mean())
    tpg = gpu_dev(tp + ph[None, :] * Pgs[:, None])
    Pt = gpu_dev(Pgs)[:, None, None]
    M = 2 * math.pi * torch.remainder((TM[None, None, :] - tpg[:, :, None]) / Pt, 1.0)
    for eg in np.arange(0.0, 0.61, 0.05):
        E = gpu_kepler_E(M, eg, 12)
        nu = 2 * torch.atan2(math.sqrt(1 + eg) * torch.sin(E / 2), math.sqrt(1 - eg) * torch.cos(E / 2))
        for wg in wgs:
            # the first least cost over the periods and phases, in that order
            s = torch.cos(nu + math.radians(wg)) + eg * math.cos(math.radians(wg))
            sc = s - s.mean(-1, keepdim=True)
            kk = (sc * VC).sum(-1) / torch.clamp((sc * sc).sum(-1), min=1e-12)
            r = VC - kk[..., None] * sc
            cost = torch.where(kk > 0, torch.log1p(r ** 2).sum(-1), torch.full_like(kk, float("inf")))
            b, c = np.unravel_index(int(torch.argmin(cost.reshape(-1))), cost.shape)
            if float(cost[b, c]) < best[0]:
                best = (float(cost[b, c]), float(Pgs[b]), float(tp + ph[c] * Pgs[b]), float(eg), float(wg))
    P, tp, e, w = best[1], best[2], max(best[3], 0.01), best[4]
    se = np.sqrt(max(e, 1e-4))
    x0 = [P, tp, se * np.cos(np.radians(w)), se * np.sin(np.radians(w)), k1, float(np.median(vm - k1 * binaries_radial(tm, P, tp, e, w)))]
    unpack = lambda x: (x[0], x[1], min(x[2] ** 2 + x[3] ** 2, 0.95), float(np.degrees(np.arctan2(x[3], x[2]))), x[4], x[5])
    vd = gpu_dev(vm)

    def resid(x, idx):
        P_, tp_, c, s, K, g0 = (x[:, j:j + 1] for j in range(6))
        return g0 + K * gpu_keplerian(TM[None, :], P_, tp_, torch.clamp(c * c + s * s, max=0.95), torch.atan2(s, c)) - vd[None, :]
    x, _ = gpu_lm(resid, np.array([x0]), np.array([P * 0.995, -np.inf, -0.97, -0.97, 0.3 * k1, -np.inf]),
                  np.array([P * 1.005, np.inf, 0.97, 0.97, 2.0 * k1, np.inf]), f_scale=1.0)
    return unpack(gpu_host(x[0])) + (float(1.4826 * np.median(np.abs(gpu_host(resid(x, None)[0])))),)


def binaries_orbit(names, inst="HARPS", template=None, min_spectra=15, most=300):
    """Each named target's orbit from its own spectra: every spectrum's velocity measured against TEMPLATE's line depths (the companion template unless given), a Keplerian fitted to them, the star's own line depths made at that orbit's velocities and the velocities measured again against them, twice, and the fit that leaves the least scatter kept; the entry updated with the orbit, its mass function and the companion's least mass, and the star's line depths and velocities kept under ROOT/templates and ROOT/velocities."""
    T0 = np.load(template or binaries_template_path())
    entries = binaries_targets()
    for name in names:
        target = next((x for x in entries if x["inst"] == inst and binaries_key(x["name"]) == binaries_key(name)), None)
        if target is None:
            print("%s: no %s series among the targets" % (name, inst), flush=True)
            continue
        spectra, listed = binaries_fetch(target, inst, 10.0, most)
        if len(spectra) < min_spectra:
            print("%s: %d spectra of %d listed; too few" % (name, len(spectra), listed), flush=True)
            continue
        band = spectra_band(inst)
        t = np.array([s[3]["mjd"] for s in spectra])
        v0, h0 = binaries_velocities(spectra, T0, band=band)
        (orb, rms), peaks = binaries_keplerian(t, v0)
        best = (orb, rms, T0, v0, h0, "the template")
        for it in range(2):
            P, tp, e, w, k1, gamma = best[0]
            T = binaries_line_depths(spectra, gamma + k1 * binaries_radial(t, P, tp, e, w), band)
            v1, h1 = binaries_velocities(spectra, T, band=band)
            (orb, rms), _ = binaries_keplerian(t, v1, P)
            if rms < best[1]:
                best = (orb, rms, T, v1, h1, "its own lines, pass %d" % (it + 1))
        orb, rms, T, v1, h1, src = best
        P, tp, e, w, k1, gamma = orb
        tag = archive_tag(inst, target["name"])
        for sub in ("templates", "velocities"):
            os.makedirs(os.path.join(binaries_ROOT, sub), exist_ok=True)
        np.save(os.path.join(binaries_ROOT, "templates", tag + "_own.npy"), T)
        np.savez(os.path.join(binaries_ROOT, "velocities", tag + ".npz"), mjd=t, v=v1, height=h1)
        f = 1.0361e-7 * (1 - e * e) ** 1.5 * k1 ** 3 * P
        m2 = planets_least_mass(f, 1.0)
        target.update(n=len(spectra), span=float(t.max() - t.min()), source="spectra fit", period=float(P), k1=float(k1), e=float(e), t_peri=float(tp + 2400000.5),
                      omega=float(w % 360.0), gamma=float(gamma), mass_function=float(f), m2_min=float(m2), k2_at_m2_min=float(k1 / m2) if m2 > 0 else None, rms_kms=float(rms))
        binaries_save(entries)
        print("%s: %d spectra of %d listed; against %s P %.5f d, K1 %.3f km/s, e %.3f, omega %.1f, gamma %.3f, scatter %.3f km/s; f(m) %.4g, companion >= %.3f Msun" % (
            name, len(spectra), listed, src, P, k1, e, w, gamma, rms, f, m2), flush=True)


def binaries_track(shape, k2, gamma, vstar):
    """The companion's velocity in each row's frame for every K2: its barycentric velocity, gamma - K2 times the orbit's shape (..., rows), less the velocity the row was put at: (..., K2, rows)."""
    shape = np.asarray(shape, float)
    return gamma - np.asarray(k2)[:, None] * shape[..., None, :] - vstar


def binaries_trail(c, dv, tell, core, tell_kms, least, centre=0.0, keep=None, wt=None):
    """The mean of the rows read at DV (..., K2, rows), weighted by WT per row where given, readings within CORE of CENTRE, where the star's own lines sit in the rows, within TELL_KMS of the row's telluric velocity, off the grid or outside KEEP left out; -inf where fewer than LEAST readings remain: (..., K2) means and counts."""
    C, dv, tv = gpu_dev(c), gpu_dev(dv), gpu_dev(tell)
    vmax = (C.shape[1] - 1) // 2
    x = dv + vmax
    inside = (x >= 0) & (x <= 2 * vmax - 1)
    xc = torch.clamp(x, 0, 2 * vmax - 1)
    j = torch.floor(xc).long()
    f = xc - j
    rows = torch.arange(C.shape[0], device=gpu_DEVICE)
    vals = C[rows, j] * (1 - f) + C[rows, j + 1] * f
    use = inside & ((dv - centre).abs() > core) & ((dv - tv).abs() > tell_kms)
    if keep is not None:
        use = use & torch.as_tensor(keep, device=gpu_DEVICE)
    n = use.sum(-1)
    if wt is None:
        out = torch.where(use, vals, torch.zeros_like(vals)).sum(-1) / torch.clamp(n, min=1)
    else:
        W = torch.where(use, gpu_dev(wt).expand_as(vals), torch.zeros_like(vals))
        out = (W * vals).sum(-1) / torch.clamp(W.sum(-1), min=1e-30)
    return gpu_host(torch.where(n >= least, out, torch.full_like(out, -float("inf")))), gpu_host(n)


def binaries_rows(names, inst="HARPS", template=None, min_spectra=20, most=300, rv_template=None, orbit_frames=False, align=True, fill_gaps=None, inject=None,
                  drop_spectra=False):
    """Each named target's rows: its spectra put at their velocities (measured against RV_TEMPLATE with the orbit fitted to them, or at the orbit's own with ORBIT_FRAMES, or at the series' with each aligned on the median), their residuals cross-correlated with the companion TEMPLATE (GJ 367's line depths unless given) and the star's pattern taken out, kept as ROOT/rows/<tag>.npz with the epochs, barycentric corrections, the velocities the rows were put at and the measured or predicted ones, and a note; FILL_GAPS counts a missing sample as zero residual where that fraction of the spectra have one, and INJECT (depth, K2) lays the template into every spectrum on the companion's orbit first."""
    T = np.load(template or binaries_template_path())
    os.makedirs(os.path.join(binaries_ROOT, "rows"), exist_ok=True)
    for name in names:
        target = binaries_target(name, inst)
        tag = archive_tag(inst, target["name"])
        P, tp, e, w, k1, gamma = binaries_orbit_of(target)
        band = spectra_band(inst)
        spectra, listed = binaries_fetch(target, inst, 10.0, most)
        if len(spectra) < min_spectra:
            print("%s: %d spectra of %d listed; too few" % (name, len(spectra), listed), flush=True)
            continue
        vsys = spectra_vsys(spectra, gamma)
        t = np.array([s[3]["mjd"] for s in spectra])
        vpred = None
        if rv_template:
            vmeas = binaries_velocities(spectra, np.load(rv_template), band=band)[0]
            P, tp, e, w, k1, gamma, rms = binaries_refit(t, vmeas, np.ones(len(t), bool), P, tp, e, w, k1)
            vpred, vsys = vmeas, gamma
            for s, v in zip(spectra, vmeas):
                s[3]["rv"] = float(v)
        elif orbit_frames:
            # each spectrum at the primary's velocity on the orbit
            vpred = gamma + k1 * binaries_radial(t, P, tp, e, w)
            for s, v in zip(spectra, vpred):
                s[3]["rv"] = float(v)
        if inject:
            depth, k2i = inject
            v2 = gamma - k2i * binaries_radial(t, P, tp, e, w)
            spectra = [(ws, spectra_lay(ws, fs, T, v, depth, band), es, meta) for (ws, fs, es, meta), v in zip(spectra, v2)]
        info = {}
        R, sd, _ = spectra_residuals(spectra, vsys, band, align=align and not orbit_frames, info=info)
        if "vstar" not in info:
            info["vstar"] = np.array([s[3]["rv"] if s[3].get("rv") is not None else vsys for s in spectra], float)
        if fill_gaps is not None:
            fill = np.isfinite(R).mean(0) >= fill_gaps
            R[:, fill] = np.where(np.isfinite(R[:, fill]), R[:, fill], 0.0)
        raw = spectra_ccf(R, T, sd)
        # rows with a non-finite value set aside with their spectra
        good = np.isfinite(raw).all(1)
        if good.sum() < min_spectra:
            print("%s: %d finite rows; too few" % (name, int(good.sum())), flush=True)
            continue
        ccf = spectra_unpattern(raw[good])
        spectra = [s for s, k in zip(spectra, good) if k]
        extra = dict(vpred=np.asarray(vpred, float)[good]) if vpred is not None else {}
        np.savez_compressed(os.path.join(binaries_ROOT, "rows", tag + ".npz"), ccf=ccf.astype(np.float32), mjd=t[good],
                            berv=np.array([s[3]["berv"] for s in spectra], float), vstar=np.asarray(info["vstar"], float)[good], **extra)
        json.dump(dict(name=target["name"], inst=inst, n=len(spectra), listed=listed, vsys=vsys, band=band, template=os.path.basename(template or binaries_TEMPLATE),
                       inject=list(inject) if inject else None), open(os.path.join(binaries_ROOT, "rows", tag + ".json"), "w"), separators=(",", ":"))
        if drop_spectra:
            shutil.rmtree(os.path.join(binaries_ROOT, "spectra", tag), ignore_errors=True)
        print("%s: %d rows of %d listed kept" % (name, len(spectra), listed), flush=True)


def binaries_load_rows(target, inst, ccf_shift=0.0):
    """A target's kept rows: (rows, epochs, barycentric corrections, velocities the rows were put at, measured or predicted velocities or None, the series' velocity), each row moved back by CCF_SHIFT km/s where the template's lines sit off the companion's."""
    tag = archive_tag(inst, target["name"])
    d = np.load(os.path.join(binaries_ROOT, "rows", tag + ".npz"))
    c = d["ccf"].astype(float)
    if ccf_shift:
        vv = np.arange(c.shape[1], dtype=float) - (c.shape[1] - 1) // 2
        c = np.array([np.interp(vv + ccf_shift, vv, row, left=0.0, right=0.0) for row in c])
    note = json.load(open(os.path.join(binaries_ROOT, "rows", tag + ".json")))
    return (c, d["mjd"].astype(float), d["berv"].astype(float), d["vstar"].astype(float), d["vpred"].astype(float) if "vpred" in d.files else None, float(note["vsys"]))


def binaries_search(names, inst="HARPS", components=5, core=30.0, draws=300, fit_orbit=True, ccf_shift=0.0, seed=7):
    """Each named target's rows summed along the companion's track over K2 from K1 to 250 km/s, each row weighted by the inverse square of its scatter away from the star: the summit against DRAWS draws with the orbit's phase moved by a tenth to nine tenths of a period and with whole nights shuffled, the lower of the two significances kept; with FIT_ORBIT the orbit is first fitted to the velocities the rows were put at; written to ROOT/results/<tag>.json."""
    os.makedirs(os.path.join(binaries_ROOT, "results"), exist_ok=True)
    for name in names:
        target = binaries_target(name, inst)
        c_raw, t, berv, vstar, vpred, vsys = binaries_load_rows(target, inst, ccf_shift)
        P, tp, e, w, k1, gamma = binaries_orbit_of(target)
        rng = np.random.default_rng(seed)
        tell = berv - vstar
        measured = (np.abs(vstar - vpred) < 19.5) if vpred is not None else (np.abs(vstar - vsys) >= 0.5) & (np.abs(vstar - vsys) < 19.5)
        shape = binaries_radial(t, P, tp, e, w)
        off, rms = gamma, float("nan")
        if measured.sum() >= 5:
            off = float(np.median(vstar[measured] - k1 * shape[measured]))
            rms = float(1.4826 * np.median(np.abs(vstar[measured] - k1 * shape[measured] - off)))
        if fit_orbit and vpred is None and measured.sum() >= 8:
            fit = binaries_refit(t, vstar, measured, P, tp, e, w, k1)
            # a fit leaving more than 2 km/s of scatter rejected for the entry's orbit
            if fit[6] <= 2.0:
                P, tp, e, w, k1, off, rms = fit
                shape = binaries_radial(t, P, tp, e, w)
        centre = gamma - off if np.isfinite(rms) else 0.0
        c = spectra_components(companions_untellur(c_raw, tell), components)
        k2 = np.arange(max(k1, 5.0), 250.5, 1.0)
        least = max(10, c.shape[0] // 5)
        vgrid = np.arange(c.shape[1], dtype=float) - (c.shape[1] - 1) // 2
        wt = 1.0 / np.maximum(1.4826 * np.median(np.abs(c[:, np.abs(vgrid - centre) > 50]), axis=1), 1e-6) ** 2
        val, n = binaries_trail(c, binaries_track(shape, k2, gamma, vstar), tell, core, 10.0, least, centre, None, wt)
        i = int(np.argmax(val))
        z = {}
        for kind in ("phase", "nights"):
            times = np.array([t + rng.uniform(0.1, 0.9) * P if kind == "phase" else companions_night_shuffle(t, rng) for _ in range(draws)])
            S = binaries_radial(times, P, tp, e, w)
            tops = np.concatenate([binaries_trail(c, binaries_track(S[b0:b0 + 50], k2, gamma, vstar), tell, core, 10.0, least, centre, None, wt)[0].max(-1)
                                   for b0 in range(0, draws, 50)])
            z[kind] = float((val[i] - tops.mean()) / max(tops.std(), 1e-12))
        f = 1.0361e-7 * (1 - e * e) ** 1.5 * P
        res = dict(name=target["name"], inst=inst, rows=int(c.shape[0]), nights=int(len(np.unique(np.floor(t + 0.3)))), span=float(t.max() - t.min()),
                   orbit=dict(period=P, t_peri_mjd=tp, e=e, omega=w, k1=k1, rms_kms=rms), star_lines_at=float(centre), k2=float(k2[i]), value=float(val[i]),
                   readings=int(n[i]), z_phase=z["phase"], z_nights=z["nights"], z=min(z.values()), ccf_shift=ccf_shift,
                   m1_sin3i=f * (k1 + k2[i]) ** 2 * k2[i], m2_sin3i=f * (k1 + k2[i]) ** 2 * k1)
        json.dump(res, open(os.path.join(binaries_ROOT, "results", archive_tag(inst, target["name"]) + ".json"), "w"), separators=(",", ":"))
        print("%-12s %3d rows on %3d nights over %5.0f d | P %.4f K1 %.2f e %.3f, rms %.2f km/s | summit K2 %.1f km/s, %.1f sigma (phases %.1f, nights %.1f); "
              "m sin^3 i %.3f + %.3f Msun" % (name, res["rows"], res["nights"], res["span"], P, k1, e, rms, res["k2"], res["z"], z["phase"], z["nights"],
                                              res["m1_sin3i"], res["m2_sin3i"]), flush=True)


def binaries_measure(name, inst="HARPS", draws=300, incl=90.0, k2_fixed=None, dv_fixed=0.0, ccf_shift=0.0, components=5, seed=23):
    """One target's rows measured: the orbit fitted to the velocities the rows were put at; the map over K2 and the companion's systemic offset from the primary's, its peak refined on a fine grid and bootstrapped over whole nights; the K2 curve at the peak's offset against moved phases and shuffled nights, and the same at zero offset; the peak from each half of the series by date and from alternate nights; the profile in the companion's frame; given K2_FIXED, the rows read there against the same nulls: ROOT/measure/<tag>.json with the curve and profile as CSV and the map as an array."""
    target = binaries_target(name, inst)
    tag = archive_tag(inst, target["name"])
    out_dir = os.path.join(binaries_ROOT, "measure")
    os.makedirs(out_dir, exist_ok=True)
    c_raw, t, berv, vstar, vpred, vsys = binaries_load_rows(target, inst, ccf_shift)
    P, tp, e, w, k1, gamma, rms = binaries_refit(t, vpred if vpred is not None else vstar, np.ones(len(t), bool), *binaries_orbit_of(target)[:5])
    shape = binaries_radial(t, P, tp, e, w)
    centre = gamma - float(np.median(vstar - k1 * shape))
    tell = berv - vstar
    v = np.arange(c_raw.shape[1], dtype=float) - (c_raw.shape[1] - 1) // 2
    night = np.floor(t + 0.3)
    grid = np.arange(max(k1, 5.0), 250.001, 0.25)
    rng = np.random.default_rng(seed)

    def clean(idx):
        cc = spectra_components(companions_untellur(c_raw[idx], tell[idx]), components)
        return cc, 1.0 / np.maximum(1.4826 * np.median(np.abs(cc[:, np.abs(v - centre) > 50]), axis=1), 1e-6) ** 2

    def curve(idx, cc, wt, s=None, k2=grid, dv0=0.0):
        """The trail along each K2 for the shape S of the rows IDX (one shape, or draws as rows), the companion's systemic offset DV0 one value or an
        array: (..., K2), with a leading axis for an array of offsets."""
        s = shape[idx] if s is None else np.asarray(s, float)
        dv0 = np.asarray(dv0, float)
        dv = (gamma + dv0)[..., None, None] - np.asarray(k2)[:, None] * s[..., None, :] - vstar[idx] if dv0.ndim else binaries_track(s, k2, gamma + float(dv0), vstar[idx])
        val = binaries_trail(cc, dv, tell[idx], 30.0, 10.0, max(10, len(idx) // 5), centre, None, wt)[0]
        return np.where(np.isfinite(val), val, -np.inf)

    def summit(idx, cc, wt, n_draws, dv0):
        val = curve(idx, cc, wt, dv0=dv0)
        i = int(np.argmax(val))
        nl = {}
        for kind in ("phase", "nights"):
            times = np.array([t[idx] + rng.uniform(0.1, 0.9) * P if kind == "phase" else companions_night_shuffle(t[idx], rng) for _ in range(n_draws)])
            S = binaries_radial(times, P, tp, e, w)
            nl[kind] = np.concatenate([curve(idx, cc, wt, S[b0:b0 + 50], grid, dv0).max(-1) for b0 in range(0, n_draws, 50)])
        z = {k: float((val[i] - x.mean()) / max(x.std(), 1e-12)) for k, x in nl.items()}
        return dict(k2=float(grid[i]), value=float(val[i]), z_phase=z["phase"], z_nights=z["nights"], z=min(z.values()), dv=dv0), val, nl

    def local(idx, cc, wt, k2c, dvc, half_k, half_v, step):
        for hk, hv, s in ((half_k, half_v, step), (0.5, 0.5, 0.05)):
            ks = np.arange(k2c - hk, k2c + hk + s / 2, s)
            vs = np.arange(dvc - hv, dvc + hv + s / 2, s)
            mm = curve(idx, cc, wt, k2=ks, dv0=vs)
            jj, ii = np.unravel_index(int(np.argmax(mm)), mm.shape)
            k2c, dvc = float(ks[ii]), float(vs[jj])
        return k2c, dvc

    allrows = np.arange(len(t))
    cc, wt = clean(allrows)
    k2m = np.arange(max(k1, 5.0), 160.001, 0.5)
    dvs = np.arange(-30.0, 30.001, 0.5)
    m = curve(allrows, cc, wt, k2=k2m, dv0=dvs)
    m = np.where(np.isfinite(m), m, np.nan)
    j, i = np.unravel_index(int(np.nanargmax(m)), m.shape)
    far = (np.abs(k2m[None, :] - k2m[i]) > 25) | (np.abs(dvs[:, None] - dvs[j]) > 15)
    ref = m[far & np.isfinite(m)]
    snr = (m - np.median(ref)) / (1.4826 * np.median(np.abs(ref - np.median(ref))))
    np.savez_compressed(os.path.join(out_dir, tag + "_map.npz"), k2=k2m, dv=dvs, snr=snr)
    k2p, dvp = local(allrows, cc, wt, float(k2m[i]), float(dvs[j]), 4.0, 3.0, 0.1)
    base, val, nl = summit(allrows, cc, wt, draws, dvp)
    zero = summit(allrows, cc, wt, draws, 0.0)[0]
    worst = min(nl, key=lambda k: (val.max() - nl[k].mean()) / max(nl[k].std(), 1e-12))
    zcurve = (val - nl[worst].mean()) / max(nl[worst].std(), 1e-12)
    ok = np.isfinite(zcurve)
    np.savetxt(os.path.join(out_dir, tag + "_k2curve.csv"), np.c_[grid[ok], zcurve[ok]], delimiter=",", header="k2,z", comments="", fmt="%.3f")
    nights = np.unique(night)
    boot = []
    for _ in range(draws):
        pick = rng.choice(nights, size=len(nights), replace=True)
        idx = np.concatenate([np.where(night == x)[0] for x in pick])
        c2, w2 = clean(idx)
        boot.append(local(idx, c2, w2, k2p, dvp, 6.0, 4.0, 0.25))
    boot = np.array(boot)
    f = 1.0361e-7 * (1 - e * e) ** 1.5 * P
    s3 = np.sin(np.radians(incl)) ** 3
    kb = boot[:, 0]
    pct = lambda x: [float(q) for q in np.percentile(x, [16, 50, 84])]
    order = np.argsort(t)
    half = len(t) // 2
    alt = np.isin(night, nights[::2])
    splits = {}
    for label, idx in (("first half by date", np.sort(order[:half])), ("second half by date", np.sort(order[half:])),
                       ("alternate nights, one set", np.where(alt)[0]), ("alternate nights, other set", np.where(~alt)[0])):
        c2, w2 = clean(idx)
        k2s, dv_s = local(idx, c2, w2, k2p, dvp, 6.0, 4.0, 0.25)
        splits[label] = dict(k2=k2s, dv=dv_s, z=summit(idx, c2, w2, max(draws // 3, 50), dvp)[0]["z"], rows=len(idx), nights=int(len(np.unique(night[idx]))))
    offs = np.arange(-100.0, 100.001, 1.0)
    prof = curve(allrows, cc, wt, k2=np.array([k2p]), dv0=dvp + offs)[:, 0]
    prof = np.where(np.isfinite(prof), prof, np.nan)
    side = np.abs(offs) > 30
    prof_n = (prof - np.nanmedian(prof[side])) / (1.4826 * np.nanmedian(np.abs(prof[side] - np.nanmedian(prof[side]))))
    ok = np.isfinite(prof_n)
    np.savetxt(os.path.join(out_dir, tag + "_profile.csv"), np.c_[offs[ok], prof_n[ok]], delimiter=",", header="offset,snr", comments="", fmt="%.3f")
    out = dict(name=target["name"], inst=inst, rows=len(t), nights=int(len(nights)), span_days=float(t.max() - t.min()), ccf_shift=ccf_shift,
               orbit=dict(period=P, t_peri_mjd=tp, e=e, omega=w, k1=k1, gamma=gamma, rms_kms=rms), star_lines_at=centre,
               peak=dict(k2=k2p, dv=dvp, map_snr=float(np.nanmax(snr))), summit=base, summit_zero_offset=zero,
               bootstrap=dict(draws=draws, k2_16_50_84=pct(kb), dv_16_50_84=pct(boot[:, 1])), incl=incl,
               m1_16_50_84=pct(f * (k1 + kb) ** 2 * kb / s3), m2_16_50_84=pct(f * (k1 + kb) ** 2 * k1 / s3), splits=splits,
               profile_peak=dict(offset=float(offs[int(np.nanargmax(prof_n))]), snr=float(np.nanmax(prof_n))))
    if k2_fixed:
        at = float(curve(allrows, cc, wt, k2=np.array([k2_fixed]), dv0=dv_fixed)[0])
        times = np.array([t + rng.uniform(0.1, 0.9) * P if i_ % 2 else companions_night_shuffle(t, rng) for i_ in range(2000)])
        S = binaries_radial(times, P, tp, e, w)
        fixed = np.concatenate([curve(allrows, cc, wt, S[b0:b0 + 200], k2=np.array([k2_fixed]), dv0=dv_fixed)[:, 0] for b0 in range(0, 2000, 200)])
        fixed = fixed[np.isfinite(fixed)]
        out["fixed"] = dict(k2=k2_fixed, dv=dv_fixed, value=at, z=float((at - fixed.mean()) / fixed.std()), as_high=int((fixed >= at).sum()), of=len(fixed))
    json.dump(out, open(os.path.join(out_dir, tag + ".json"), "w"), separators=(",", ":"))
    b, bv = out["bootstrap"]["k2_16_50_84"], out["bootstrap"]["dv_16_50_84"]
    print("%s %s: %d rows, %d nights; peak K2 %.2f (bootstrap %.2f-%.2f) at offset %+.2f (%+.2f to %+.2f); z %.1f (phases %.1f, nights %.1f); M1 sin^3 i %.3f, M2 sin^3 i %.3f; "
          "splits %s" % (inst, target["name"], len(t), len(nights), k2p, b[0], b[2], dvp, bv[0], bv[2], base["z"], base["z_phase"], base["z_nights"],
                         out["m1_16_50_84"][1] * s3, out["m2_16_50_84"][1] * s3, "; ".join("%s %.2f (%.1f)" % (k, s["k2"], s["z"]) for k, s in splits.items())), flush=True)


def binaries_depth(name, inst="HARPS", k2=None, template=None, perms=400, depths=(0.01, 0.02, 0.04), most=300, seed=43):
    """A companion's lines fitted along its track, to ROOT/depth/<tag>.json. The target's spectra are put at the primary's velocities on its orbit and
    divided by their median, cross-correlated with TEMPLATE's line depths (the companion template unless given), each wavelength weighted by the
    spectra's scatter smoothed over 501 km/s, and the sky's pattern taken out of every row in its own frame (companions_untellur). Each row is then the
    pattern common to every row plus alpha times the template's own cross-correlation at the companion's velocity against the primary, -(K1 + K2)
    times the orbit's shape, both solved by weighted least squares over the readings within 25 km/s of the track and beyond 5 km/s of the primary's lines
    and 8 km/s of the telluric lines, each row weighted by its scatter beyond 50 km/s: alpha is the depth of the companion's lines as a fraction of the
    template's, the part of the trail the median spectrum holds fitted with it. Its significance is set against PERMS permutations of the track among
    the rows, and the template laid into the spectra along the track at each of DEPTHS gives the recovery. The track mirrored about the primary's
    velocity and the telluric lines' own track are read the same way. K2 defaults to the entry's, else to K1 times the primary's mass over the
    companion's least mass at that mass."""
    target = binaries_target(name, inst)
    tag = archive_tag(inst, target["name"])
    P, tp, e, w, k1, gamma = binaries_orbit_of(target)
    k2 = k2 or target.get("k2") or target.get("k2_at_m2_min")
    T = np.load(template or binaries_template_path())
    spectra, listed = binaries_fetch(target, inst, 10.0, most)
    band, vmax = spectra_band(inst), 150
    t = np.array([s[3]["mjd"] for s in spectra])
    shape = binaries_radial(t, P, tp, e, w)
    v1 = gamma + k1 * shape
    tell = np.array([s[3]["berv"] for s in spectra]) - v1
    v = np.arange(-vmax, vmax + 1, dtype=float)
    grid = spectra_grid(band)

    def residuals(depth):
        laid = [(ws, spectra_lay(ws, fs, T, gamma - k2 * s_, depth, band) if depth else fs, es, dict(meta, rv=float(x)))
                for (ws, fs, es, meta), s_, x in zip(spectra, shape, v1)]
        return spectra_residuals(laid, gamma, band, align=False)[:2]
    R0, sd0 = residuals(0.0)
    weight = gpu_host(gpu_running_median(sd0[None, :], 501))[0]
    mask = np.isfinite(R0).all(0)

    def rows(R):
        c = companions_untellur(spectra_ccf(np.where(mask[None, :], R, np.nan), T, weight, vmax), tell)
        far = c[:, np.abs(v) > 50]
        return c, 1.0 / np.maximum(1.4826 * np.median(np.abs(far - np.median(far, 1)[:, None]), 1), 1e-9) ** 2

    def fit(c, wt, dv):
        model = spectra_ccf(np.array([np.where(mask, -np.interp(grid, grid * (1.0 + x / spectra_C), T, left=0.0, right=0.0), np.nan) for x in dv]), T, weight,
                            vmax)
        keep = (np.abs(v)[None, :] > 5.0) & (np.abs(v[None, :] - tell[:, None]) > 8.0) & (np.abs(v[None, :] - dv[:, None]) < 25.0)
        W = keep * wt[:, None]
        n = np.maximum(W.sum(0), 1e-30)
        cc, gg = c - (W * c).sum(0) / n, model - (W * model).sum(0) / n
        return float((W * cc * gg).sum() / (W * gg * gg).sum())
    rng = np.random.default_rng(seed)
    track = -(k1 + k2) * shape

    def read(c, wt, dv):
        a = fit(c, wt, dv)
        null = np.array([fit(c, wt, dv[rng.permutation(len(dv))]) for _ in range(perms)])
        return dict(alpha=a, perm_mean=float(null.mean()), perm_sd=float(null.std()), z=float((a - null.mean()) / null.std()))
    c0, w0 = rows(R0)
    out = dict(name=target["name"], inst=inst, rows=int(len(t)), listed=int(listed), k1=k1, k2=k2, track=[round(float(track.min()), 2), round(float(track.max()), 2)],
               template=os.path.basename(template or binaries_template_path()), observed=read(c0, w0, track), mirrored=read(c0, w0, -track),
               telluric=dict(alpha=fit(c0, w0, tell), correlation=float(np.corrcoef(track, tell)[0, 1])), laid={})
    for depth in depths:
        a = fit(*rows(residuals(depth)[0]), track)
        out["laid"]["%g" % depth] = dict(alpha=a, rise=a - out["observed"]["alpha"])
    os.makedirs(os.path.join(binaries_ROOT, "depth"), exist_ok=True)
    json.dump(out, open(os.path.join(binaries_ROOT, "depth", tag + ".json"), "w"), separators=(",", ":"))
    x = out["observed"]
    print("%s %s: %d rows, track %+.1f to %+.1f km/s; alpha %+.4f, permuted %+.4f +- %.4f, z %.1f; mirrored %+.4f; telluric track %+.4f (correlation %.2f); "
          "laid in %s" % (inst, target["name"], len(t), track.min(), track.max(), x["alpha"], x["perm_mean"], x["perm_sd"], x["z"], out["mirrored"]["alpha"],
                          out["telluric"]["alpha"], out["telluric"]["correlation"], ", ".join("%s rises %+.4f" % (k, d["rise"]) for k, d in out["laid"].items())),
          flush=True)


def binaries_template(name, ra, dec, inst="NIRPS", best=40, min_snr=50.0, vsys=None, out=None):
    """A template star's line depths from its best spectra: the MOST of highest signal to noise above MIN_SNR of a position, each at the velocity its header carries (else VSYS), their median on the instrument band's grid, one minus it, negative values zero; saved to OUT or ROOT/templates/<inst>_<name>.npy."""
    rows = archive_eso_listing(ra, dec, inst, min_snr)
    paths = archive_eso_fetch(rows, os.path.join(binaries_ROOT, "spectra", archive_tag(inst, name)), most=best, best=True)
    spectra = spectra_read(paths)
    band = spectra_band(inst)
    T = spectra_template(spectra, spectra_vsys(spectra, vsys), band)
    out = out or os.path.join(binaries_ROOT, "templates", archive_tag(inst, name) + ".npy")
    os.makedirs(os.path.dirname(os.path.abspath(out)), exist_ok=True)
    np.save(out, T)
    print("%s: line depths from %d spectra, %d samples above 0.1: %s" % (name, len(spectra), int((T > 0.1).sum()), out), flush=True)


def binaries_zero(paths, band="nir", teff=3500.0):
    """Where each template's lines sit against the laboratory's: cross-correlated with Kurucz's lines of Fe I, Si I, Mg I, Ti I, Al I, Ca I, K I and Na I at TEFF on the same grid, the peak within 30 km/s refined by a parabola."""
    lines = sum(giants_template(s, teff, band=band) for s in ("Fe I", "Si I", "Mg I", "Ti I", "Al I", "Ca I", "K I", "Na I"))
    lines = lines / max(float(lines.max()), 1e-30)
    v = np.arange(-30, 31)
    for path in paths:
        T = np.load(path)
        c = np.array([float(np.sum(np.roll(T, -k) * lines)) for k in v])
        k = int(np.argmax(c))
        den = c[k - 1] - 2 * c[k] + c[k + 1] if 0 < k < len(c) - 1 else 0.0
        off = v[k] + (0.5 * (c[k - 1] - c[k + 1]) / den if den < 0 else 0.0)
        print("%s: lines at %+.2f km/s from Kurucz's" % (path, off), flush=True)


def binaries_shift(path, out, v_kms, band="nir"):
    """A template moved by -V_KMS: resampled so that lines sitting at V_KMS from rest sit at rest, saved to OUT."""
    g = spectra_grid(band)
    np.save(out, np.interp(g * (1.0 + v_kms / spectra_C), g, np.load(path), left=0.0, right=0.0))
    print("%s moved by %+.2f km/s to %s" % (path, -v_kms, out))


def binaries_cli():
    archive_quiet_warnings()
    p = argparse.ArgumentParser(prog="orbitlight.py binaries", description=binaries_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("mode", choices=("series", "orbit", "rows", "search", "measure", "depth", "template", "zero", "shift"))
    p.add_argument("names", nargs="*")
    p.add_argument("--inst", default="HARPS")
    p.add_argument("--pattern", default="%EBLM%", help="series: the ADQL LIKE pattern of the archive's target names")
    p.add_argument("--min-spectra", type=int, default=20)
    p.add_argument("--most", type=int, default=300, help="the most spectra fetched, spread over the span")
    p.add_argument("--template", help="the companion's line depths (.npy); GJ 367's optical template unless given")
    p.add_argument("--rv-template", help="rows: line depths against which each spectrum's velocity is measured and the orbit fitted")
    p.add_argument("--orbit-frames", action="store_true", help="rows: each spectrum at the orbit's own velocity, left unaligned")
    p.add_argument("--no-align", action="store_true")
    p.add_argument("--fill-gaps", type=float, default=None)
    p.add_argument("--inject", default=None, help="rows: DEPTH:K2, the template laid into every spectrum on the companion's orbit")
    p.add_argument("--drop-spectra", action="store_true")
    p.add_argument("--draws", type=int, default=300)
    p.add_argument("--fixed-orbit", action="store_true", help="search: the entry's orbit as it stands, not refitted to the rows")
    p.add_argument("--ccf-shift", type=float, default=0.0, help="km/s by which the template's lines sit off the companion's")
    p.add_argument("--incl", type=float, default=90.0)
    p.add_argument("--k2-fixed", type=float, default=None)
    p.add_argument("--k2", type=float, default=None, help="depth: the companion's semi-amplitude, the entry's unless given")
    p.add_argument("--dv-fixed", type=float, default=0.0)
    p.add_argument("--ra", type=float)
    p.add_argument("--dec", type=float)
    p.add_argument("--best", type=int, default=40)
    p.add_argument("--vsys", type=float, default=None)
    p.add_argument("--out")
    p.add_argument("--kms", type=float, default=0.0, help="shift: where the template's lines sit from rest")
    a = p.parse_args()
    if a.mode == "series":
        binaries_series(a.pattern, tuple(a.names) or ("HARPS", "ESPRESSO", "NIRPS"), a.min_spectra)
    elif a.mode == "orbit":
        binaries_orbit(a.names, a.inst, a.template, a.min_spectra, a.most)
    elif a.mode == "rows":
        binaries_rows(a.names, a.inst, a.template, a.min_spectra, a.most, a.rv_template, a.orbit_frames, not a.no_align, a.fill_gaps,
                      tuple(float(x) for x in a.inject.split(":")) if a.inject else None, a.drop_spectra)
    elif a.mode == "search":
        binaries_search(a.names, a.inst, draws=a.draws, fit_orbit=not a.fixed_orbit, ccf_shift=a.ccf_shift)
    elif a.mode == "measure":
        for name in a.names:
            binaries_measure(name, a.inst, a.draws, a.incl, a.k2_fixed, a.dv_fixed, a.ccf_shift)
    elif a.mode == "depth":
        for name in a.names:
            binaries_depth(name, a.inst, a.k2, a.template, most=a.most)
    elif a.mode == "template":
        binaries_template(a.names[0], a.ra, a.dec, a.inst, a.best, vsys=a.vsys, out=a.out)
    elif a.mode == "zero":
        binaries_zero(a.names)
    else:
        binaries_shift(a.names[0], a.out, a.kms)


eclipses_DOC = """Masses and radii of double-lined eclipsing binaries from their TESS light curves: each sector's light curve at its shortest cadence from SPOC,
else TESS-SPOC, else QLP, and both eclipses modelled where the spectroscopic orbit places them. The transit is a dark disk of radius ratio k = R2/R1
over a quadratically limb-darkened primary diluted by the companion's share L2 of the light; the occultation removes L2 times the hidden fraction of
the companion's disk (its limb darkening held at 0.4 and 0.3); the occulted light is integrated over 250 annuli and each exposure over its length.
With e and omega held at the orbit's, the time of periastron, the period, k, a/R1, cos i, the primary's limb darkening (Kipping's q1 and q2) and L2
are fitted to the points within two durations of either conjunction, each event divided by a line through its own out-of-event points, from several
starts, small and grazing, by least squares, then sampled on the device, the primary's radius held to its TIC value within 7 per cent where it has one.
The inclination turns the minimum masses into masses, and a/R1 with a sin i = (K1 + K2) P sqrt(1 - e^2) / 2 pi gives both radii, K2 drawn from its
bootstrap range at each sample.

    fetch     a star's TESS light curves, by position or by its binaries entry
    fit       a binary of the binaries mode fitted
    table     every fit as one line"""

eclipses_ROOT = archive_data("eclipses")


def eclipses_fetch(name, ra, dec, radius_arcsec=10.0):
    """A star's TESS light curves within RADIUS_ARCSEC of a position: each sector's at its shortest cadence from SPOC, else TESS-SPOC, else QLP, its PDCSAP flux or QLP's detrended flux, DET_FLUX or in its first releases KSPSAP_FLUX, quality-flagged (for QLP, any flag) and non-finite points dropped, each sector divided by its median; ROOT/lightcurves/<name>.npz (time in BTJD, flux, error, sector, cadence in minutes, whether the flux is PDCSAP's)."""
    warnings.filterwarnings("ignore")
    import lightkurve as lk
    from astropy.coordinates import SkyCoord
    import astropy.units as u
    res = lk.search_lightcurve(SkyCoord(ra * u.deg, dec * u.deg), radius=radius_arcsec * u.arcsec, mission="TESS")
    T, F, E, S, C, D = [], [], [], [], [], []
    picked = {}
    for i in range(len(res)):
        rank = {"SPOC": 0, "TESS-SPOC": 1, "QLP": 2}.get(str(res.table["author"][i]))
        if rank is None:
            continue
        last = str(res.table["mission"][i]).split()[-1]
        sector = int(last) if last.isdigit() else -1
        key = (rank, float(res.table["exptime"][i]))
        if sector not in picked or key < picked[sector][0]:
            picked[sector] = (key, i)
    for sector, (key, i) in sorted(picked.items()):
        try:
            lc = res[i].download(quality_bitmask="default")
        except Exception:
            continue
        col = next((c for c in ("pdcsap_flux", "det_flux", "kspsap_flux") if c in lc.columns), "flux")
        t = np.asarray(lc.time.value, float)
        f = np.asarray(lc[col].value, float)
        e = np.asarray(lc[col + "_err"].value if col + "_err" in lc.columns else lc.flux_err.value, float)
        ok = np.isfinite(t) & np.isfinite(f) & np.isfinite(e) & (e > 0)
        # QLP flags its scattered-light cadences in bits lightkurve's default mask does not cover
        if key[0] == 2:
            ok &= np.asarray(lc.quality.value) == 0
        if ok.sum() < 100:
            continue
        med = np.median(f[ok])
        T.append(t[ok]), F.append(f[ok] / med), E.append(e[ok] / med), S.append(np.full(ok.sum(), sector)), C.append(np.full(ok.sum(), key[1] / 60.0)), D.append(np.full(ok.sum(), col == "pdcsap_flux"))
    if not T:
        print("%s: no TESS light curve" % name, flush=True)
        return None
    os.makedirs(os.path.join(eclipses_ROOT, "lightcurves"), exist_ok=True)
    path = os.path.join(eclipses_ROOT, "lightcurves", name + ".npz")
    np.savez_compressed(path, time=np.concatenate(T), flux=np.concatenate(F), err=np.concatenate(E), sector=np.concatenate(S), cadence=np.concatenate(C), pdcsap=np.concatenate(D))
    print("%s: %d sectors saved" % (name, len(T)), flush=True)
    return path


def eclipses_tic_radius(ra, dec):
    """The TIC's radius (Rsun) of the star nearest a position within 5 arcsec, or None."""
    rows = archive_tap("vizier", 'SELECT TOP 1 "Rad", DISTANCE(POINT(\'ICRS\', "RAJ2000", "DEJ2000"), POINT(\'ICRS\', %.6f, %.6f)) AS d FROM "IV/39/tic82" '
                                 'WHERE CONTAINS(POINT(\'ICRS\', "RAJ2000", "DEJ2000"), CIRCLE(\'ICRS\', %.6f, %.6f, %.6f)) = 1 ORDER BY d' % (ra, dec, ra, dec, 5.0 / 3600.0))
    return archive_num(rows[0]["Rad"]) if rows else None


def eclipses_hidden(z, k, u1, u2, nann=250):
    """The fraction of a limb-darkened unit disk's light hidden by a disk of radius K at separation Z (in the unit disk's radius): Z (b, m) with K, U1
    and U2 (b, 1) or numbers, integrated over NANN annuli."""
    r = (torch.arange(nann, dtype=gpu_F64, device=gpu_DEVICE) + 0.5) / nann
    mu = torch.sqrt(1.0 - r * r)
    k = k if isinstance(k, torch.Tensor) else torch.tensor(float(k), dtype=gpu_F64, device=gpu_DEVICE)
    wts = (1.0 - u1 * (1 - mu) - u2 * (1 - mu) ** 2) * 2 * math.pi * r / nann
    wts = wts.expand(z.shape[0], nann) if wts.dim() == 2 else wts[None, :].expand(z.shape[0], nann)
    zz, rr = z[..., None], r[None, None, :]
    kk = k[..., None] if k.dim() == 2 else k
    c = (rr * rr + zz * zz - kk * kk) / (2 * rr * zz)
    frac = torch.where(zz + rr <= kk, torch.ones_like(c), torch.where((zz - rr).abs() >= kk, torch.zeros_like(c), torch.acos(torch.clamp(c, -1.0, 1.0)) / math.pi))
    frac = torch.where(zz == 0, (rr <= kk).to(gpu_F64).expand_as(frac), frac)
    return (frac * wts[:, None, :]).sum(-1) / wts.sum(-1, keepdim=True)


def eclipses_fit(name, lc_path, period, t_peri_mjd, e, omega, k1, k2, k2_lo, k2_hi, r1_prior=None, steps=3000, ar_guess=15.0, seed=1):
    """Both eclipses of a double-lined binary fitted in its TESS light curve, with the orbit's period, time of periastron, e and omega (degrees, the primary's, in the convention v1 = K1 (cos(nu + omega) + e cos omega)), K1 and K2 with its 1-sigma range; ROOT/fits/<name>.json with the inclination, impact parameters, radius ratio, L2, masses and radii as medians with 16th and 84th percentiles."""
    d = np.load(lc_path)
    t_mjd = d["time"] + 56999.5
    f, ferr, cad = d["flux"], d["err"], d["cadence"]
    sw = np.sin(np.radians(omega))

    def conj_offset(angle):
        nu = np.radians(angle - omega)
        E = 2 * np.arctan2(np.sqrt(1 - e) * np.sin(nu / 2), np.sqrt(1 + e) * np.cos(nu / 2))
        return ((E - e * np.sin(E)) / (2 * np.pi)) % 1.0
    # the primary lies farthest at nu + omega = 90 degrees, where the companion crosses its disk, and nearest at 270, where it hides the companion
    f_tr, f_oc = conj_offset(90.0), conj_offset(270.0)

    def separation(tt, tp, P, ar, cosi):
        """The sky separation of the two centres (in the primary's radius) at times TT (m,) for parameter rows (b, 1), and the sine of the orbital
        angle from the line of nodes, positive where the companion is in front."""
        E = gpu_anomaly(tt[None, :], P, tp, torch.full_like(P, e))
        nu = 2 * torch.atan2(math.sqrt(1 + e) * torch.sin(E / 2), math.sqrt(1 - e) * torch.cos(E / 2))
        rr = ar * (1 - e * e) / (1 + e * torch.cos(nu))
        s = torch.sin(nu + math.radians(omega))
        return rr * torch.sqrt(torch.clamp(1.0 - s * s * (1.0 - cosi * cosi), min=0.0)), s

    def steps_of(t, exp_min):
        """The exposures at times T of EXP_MIN minutes grouped by their count of two-minute steps: each group's indices, its steps' times and the count, on
        the device."""
        nsub = np.maximum(1, np.ceil(exp_min / 2.0)).astype(int)
        out = []
        for ns in np.unique(nsub):
            sel = np.where(nsub == ns)[0]
            offs = ((np.arange(ns) + 0.5) / ns - 0.5) * (exp_min[sel][0] / 1440.0)
            out.append((torch.as_tensor(sel, device=gpu_DEVICE), gpu_dev((t[sel][:, None] + offs[None, :]).ravel()), int(ns)))
        return out

    def model(theta, groups, n):
        """The light curve at the N exposures of GROUPS (steps_of) for parameter rows THETA (b, 8), each exposure averaged over its two-minute steps:
        (b, N)."""
        th = gpu_dev(theta if isinstance(theta, torch.Tensor) else np.atleast_2d(theta))
        th = th[None, :] if th.dim() == 1 else th
        tp, P, k, ar, cosi, q1, q2, L2 = (th[:, j:j + 1] for j in range(8))
        u1, u2 = 2 * torch.sqrt(q1) * q2, torch.sqrt(q1) * (1 - 2 * q2)
        out = torch.empty((th.shape[0], n), dtype=gpu_F64, device=gpu_DEVICE)
        for sel, times, ns in groups:
            z, s = separation(times, tp, P, ar, cosi)
            tr, oc = (s > 0) & (z < 1.0 + k), (s < 0) & (z < 1.0 + k)
            fl = torch.ones_like(z)
            fl = torch.where(tr, 1.0 - (1.0 - L2) * eclipses_hidden(z, k, u1, u2), fl)
            fl = torch.where(oc, 1.0 - L2 * eclipses_hidden(z / k, 1.0 / k, 0.4, 0.3), fl)
            out[:, sel] = fl.reshape(th.shape[0], -1, ns).mean(2)
        return out
    tp0 = t_peri_mjd + np.round((np.median(t_mjd) - t_peri_mjd) / period) * period
    dur = period / (np.pi * ar_guess) * 1.5
    t, y, ey, ex, which = [], [], [], [], []
    for frac_c, label in ((f_tr, "transit"), (f_oc, "occultation")):
        tc = tp0 + frac_c * period
        ph = ((t_mjd - tc) / period + 0.5) % 1.0 - 0.5
        epoch = np.round((t_mjd - tc) / period)
        win = np.abs(ph * period) < 2.0 * dur
        for ep in np.unique(epoch[win]):
            sel = win & (epoch == ep)
            dt = t_mjd[sel] - (tc + ep * period)
            out = np.abs(dt) > 0.75 * dur
            if out.sum() < 10 or (~out).sum() < 5:
                continue
            coef = np.linalg.lstsq(np.vstack([np.ones(out.sum()), dt[out]]).T, f[sel][out], rcond=None)[0]
            base = coef[0] + coef[1] * dt
            t.append(t_mjd[sel]), y.append(f[sel] / base), ey.append(ferr[sel] / base), ex.append(cad[sel]), which.append(np.full(sel.sum(), label))
    os.makedirs(os.path.join(eclipses_ROOT, "fits"), exist_ok=True)
    out_path = os.path.join(eclipses_ROOT, "fits", name + ".json")
    if not t:
        json.dump(dict(name=name, note="no conjunction covered"), open(out_path, "w"), separators=(",", ":"))
        print("%s: no conjunction covered" % name, flush=True)
        return None
    t, y, ey, ex, which = (np.concatenate(x) for x in (t, y, ey, ex, which))

    def depth_at(label):
        sel = which == label
        if sel.sum() < 20:
            return 0.0, 0
        tc = tp0 + (f_tr if label == "transit" else f_oc) * period
        core = sel & (np.abs((((t - tc) / period + 0.5) % 1.0 - 0.5) * period) < 0.25 * dur)
        return (float(1.0 - np.median(y[core])) if core.sum() > 5 else 0.0), int(len(np.unique(np.round((t[sel] - tc) / period))))
    d_tr, n_tr = depth_at("transit")
    d_oc, n_oc = depth_at("occultation")
    lo = [tp0 - 0.3, period * (1 - 1e-4), 0.02, 2.0, 0.0, 0.0, 0.0, 0.0]
    hi = [tp0 + 0.3, period * (1 + 1e-4), 0.9, 200.0, 0.3, 1.0, 1.0, 0.3]
    Y, EY, groups = gpu_dev(y), gpu_dev(ey), steps_of(t, ex)
    starts = np.array([[tp0, period, kk, ar_guess, min(bb / ar_guess, 0.29), 0.4, 0.35, 0.02] for kk, bb in ((0.12, 0.3), (0.2, 0.8), (0.3, 1.05), (0.45, 1.25), (0.6, 1.4))])
    fits, costs = gpu_lm(lambda th, idx: (model(th, groups, len(t)) - Y[None, :]) / EY[None, :], starts, np.array(lo), np.array(hi))
    fits, costs = gpu_host(fits), gpu_host(costs)
    chi2 = float(costs.min() / max(len(y) - 8, 1))
    scale = math.sqrt(max(chi2, 1.0))
    LOt, HIt = gpu_dev(lo), gpu_dev(hi)

    def logp(th):
        """The log-posterior of parameter rows TH (b, 8) on the device: the light curve's chi-square scaled by the best fit's reduced chi-square, with the
        primary's radius held to R1_PRIOR within 7 per cent where given; -inf outside the bounds."""
        inside = ((th >= LOt) & (th <= HIt)).all(1)
        r = (model(th, groups, len(t)) - Y[None, :]) / EY[None, :] / scale
        val = -0.5 * (r * r).sum(1)
        if r1_prior:
            r1 = (k1 + k2) * th[:, 1] * 86400.0 * math.sqrt(1 - e * e) / (2 * math.pi * torch.sqrt((1.0 - th[:, 4] ** 2).clamp(min=1e-12))) / 695700.0 / th[:, 3]
            val = val - 0.5 * ((r1 - r1_prior) / (0.07 * r1_prior)) ** 2
        return torch.where(inside & torch.isfinite(val), val, torch.full_like(val, -float("inf")))
    start = fits[int(np.argmax(gpu_host(logp(gpu_dev(fits)))))]
    rng = np.random.default_rng(seed)
    spread = np.array([0.002, 1e-6, 0.01, 0.2, 0.0005, 0.02, 0.02, 0.002])
    p0 = np.clip(start[None, :] + spread[None, :] * rng.standard_normal((32, 8)), np.array(lo) + 1e-9, np.array(hi) - 1e-9)
    chain, accept = gpu_ensemble(logp, p0, steps, thin=1, seed=seed, graph=True)
    tps, Ps, ks, ars, cis, q1s, q2s, L2s = chain[len(chain) // 2:].reshape(-1, 8).T
    sini = np.sqrt(1.0 - cis ** 2)
    n = len(Ps)
    k2s = np.where(rng.random(n) < 0.5, k2 - np.abs(rng.standard_normal(n)) * (k2 - k2_lo), k2 + np.abs(rng.standard_normal(n)) * (k2_hi - k2))
    fm = 1.0361e-7 * (1 - e * e) ** 1.5 * Ps * (k1 + k2s) ** 2
    a_rsun = (k1 + k2s) * Ps * 86400.0 * np.sqrt(1 - e * e) / (2 * np.pi * sini) / 695700.0
    R1 = a_rsun / ars
    q = lambda x: [float(np.percentile(x, 50)), float(np.percentile(x, 16)), float(np.percentile(x, 84))]
    res = dict(name=name, transit_windows=n_tr, transit_depth=d_tr, occultation_windows=n_oc, occultation_depth=d_oc, points=int(len(y)), chi2_reduced=chi2,
               acceptance=float(np.mean(accept)), period=q(Ps), k=q(ks), a_over_r1=q(ars), incl_deg=q(np.degrees(np.arcsin(sini))),
               b_transit=q(ars * cis * (1 - e * e) / (1 + e * sw)), b_occultation=q(ars * cis * (1 - e * e) / (1 - e * sw)), L2=q(L2s), M1=q(fm * k2s / sini ** 3),
               M2=q(fm * k1 / sini ** 3), R1=q(R1), R2=q(ks * R1), a_rsun=q(a_rsun), k1=k1, k2=[k2, k2_lo, k2_hi], e=e, omega=omega, r1_prior=r1_prior)
    json.dump(res, open(out_path, "w"), separators=(",", ":"))
    fmt = lambda v: "%.4f (%.4f-%.4f)" % tuple(v)
    print("%s: transits %d, occultations %d; i %s deg, k %s, L2 %s; M1 %s, M2 %s Msun; R1 %s, R2 %s Rsun; reduced chi-square %.2f" % (
        name, n_tr, n_oc, fmt(res["incl_deg"]), fmt(res["k"]), fmt(res["L2"]), fmt(res["M1"]), fmt(res["M2"]), fmt(res["R1"]), fmt(res["R2"]), chi2), flush=True)
    return res


def eclipses_binary(name, inst="HARPS", steps=3000, prior=True):
    """A binary of the binaries mode fitted: its light curves fetched at its position, its orbit and K2 with the bootstrap's range taken from its measurement, and its TIC radius as the prior where PRIOR."""
    target = binaries_target(name, inst)
    m = json.load(open(os.path.join(binaries_ROOT, "measure", archive_tag(inst, target["name"]) + ".json")))
    o = m["orbit"]
    lc = os.path.join(eclipses_ROOT, "lightcurves", target["name"] + ".npz")
    if not os.path.exists(lc) and not eclipses_fetch(target["name"], target["ra"], target["dec"]):
        return None
    b = m["bootstrap"]["k2_16_50_84"]
    r1 = eclipses_tic_radius(target["ra"], target["dec"]) if prior else None
    return eclipses_fit(target["name"], lc, o["period"], o["t_peri_mjd"], o["e"], o["omega"], o["k1"], m["peak"]["k2"], b[0], b[2], r1, steps)


def eclipses_table():
    """Every fit under ROOT/fits as one line: windows, inclination, impact parameter, L2, masses and radii."""
    for path in sorted(glob.glob(os.path.join(eclipses_ROOT, "fits", "*.json"))):
        d = json.load(open(path))
        if "M1" not in d:
            continue
        f = lambda key, fmt: (fmt % d[key][0]) + " (" + (fmt % d[key][1]) + "-" + (fmt % d[key][2]) + ")"
        print("%-10s %2d, %2d | i %s | b %s | L2 %s | M1 %s M2 %s | R1 %s R2 %s | chi2 %.2f%s" % (
            d["name"], d["transit_windows"], d["occultation_windows"], f("incl_deg", "%.2f"), f("b_transit", "%.3f"), f("L2", "%.4f"), f("M1", "%.3f"), f("M2", "%.3f"),
            f("R1", "%.3f"), f("R2", "%.3f"), d["chi2_reduced"], ", R1 prior" if d.get("r1_prior") else ""))


def eclipses_cli():
    archive_quiet_warnings()
    p = argparse.ArgumentParser(prog="orbitlight.py eclipses", description=eclipses_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("mode", choices=("fetch", "fit", "table"))
    p.add_argument("names", nargs="*")
    p.add_argument("--inst", default="HARPS")
    p.add_argument("--ra", type=float)
    p.add_argument("--dec", type=float)
    p.add_argument("--steps", type=int, default=3000)
    p.add_argument("--no-prior", action="store_true", help="fit: the primary's radius left free of the TIC's")
    a = p.parse_args()
    if a.mode == "fetch":
        for name in a.names:
            if a.ra is not None:
                eclipses_fetch(name, a.ra, a.dec)
            else:
                t = binaries_target(name, a.inst)
                eclipses_fetch(t["name"], t["ra"], t["dec"])
    elif a.mode == "fit":
        for name in a.names:
            eclipses_binary(name, a.inst, a.steps, not a.no_prior)
    else:
        eclipses_table()


publish_DOC = """The repository's files, made from the results of one or more data roots, each given as LABEL=DATA in order of precedence with its results
under DATA/results; the solar, giants, transits and companions results are the first root's. Every root's planets tables are joined, each row led by its
root, a new body that an earlier root's body matches in host and kind and within 5 per cent in period listed once, under the earlier root, with every
root that found it. The new planets are planets.csv in OUT, the new planets and companions orbitlight itself found discoveries.csv, and each mode's other results are files in a folder of its own, a
.jsonl file holding one record a line and the .npz file of its name the records' numeric arrays, each under the key its record names.

    planets/      companions.csv, the new stellar and brown-dwarf companions; signals.csv, every signal with its decision and what orbitlight's
                  evidence contributes; validation.jsonl, every TESS candidate's statistical validation; followup.jsonl and
                  followup.npz, the records behind the decisions (the vet of each star with a signal that reached it, the sampled orbits, TESS light
                  curves and system analysis of each star whose signal was followed, the companion analysis, weighing and companion orbit of each
                  companion analysed, each new body's ledger) and figures.pdf, the systems' figures; stars.csv, ledger.csv, eccentric.csv and
                  calibration.json, the census's star models, the ledger's predictions, the eccentric search's candidates and the calibration with the controls
    solar/        velocities.csv, the daily velocities, and results.jsonl and results.npz, the other results
    giants/       results.jsonl and results.npz, the searches and their maps, and plan.json.gz and plan_counts.csv, the archive queries
    transits/     results.json, the run's record, and plan.json.gz and plan_counts.csv, the archive queries
    companions/   results.jsonl and results.npz, the rows' notes, searches and validation with the rows, and plan.json, the archive query

    python orbitlight.py publish OUT bank=DATA [LABEL=DATA ...]

Before a folder goes public, `scan` reads every file of it, or with --git every revision of a clone with its LFS objects and its commits' authors, for home paths, tokens, private addresses and e-mail addresses and what the file ORBITLIGHT_SCAN_NAMES adds (publish_scan_settings), through PDFs, .npz, .npy and .gz, and exits 1 on anything it does not expect; `check` sets a published folder against the public one: what entered and left its tables, why, and the validations whose decision no longer stands.

    python orbitlight.py publish scan FOLDER [--git]
    python orbitlight.py publish check FOLDER PUBLIC"""


# an absolute path in a JSON string, a drive's or a home's, its last part kept
publish_PATH = re.compile(r"(?<![A-Za-z0-9/])(?:[A-Za-z]:(?:\\\\|/)|(?<![A-Za-z0-9/])/(?:home|Users|root|mnt|tmp)/)(?:[^\"\s:;,()'/\\]+(?:\\\\|/))*([^\"\s:;,()'/\\]*)")


def publish_lines(path, rows):
    """ROWS, dicts, written to PATH as JSON Lines, a compact record a line, any absolute path in their text, as an error's message can hold, cut to its last part."""
    with open(path, "w", encoding="utf-8", newline="\n") as fh:
        for r in rows:
            fh.write(publish_PATH.sub(r"\1", json.dumps(r, separators=(",", ":"))) + "\n")


def publish_load(path):
    """A JSON file's record, read again two seconds on where a worker is still writing it."""
    for attempt in range(3):
        try:
            return json.load(open(path, encoding="utf-8"))
        except ValueError:
            if attempt == 2:
                raise
            time.sleep(2)


def publish_cell(x):
    """A CSV cell as the value written into it: an integer or a number where it reads as one, None where it is empty, else its text."""
    if x in ("", None):
        return None
    for kind in (int, float):
        try:
            return kind(x)
        except ValueError:
            pass
    return x


def publish_planets(out, pairs, save):
    """The planets mode's files from every root of PAIRS, (label, data root) in order of precedence: the tables joined, the records behind the
    decisions with their arrays and figures, every TESS candidate's validation, and the first root's calibration and benchmark. Returns the counts
    printed."""
    from pypdf import PdfWriter
    res = lambda data, *parts: os.path.join(data, "results", "planets", *parts)

    def gather(*parts):
        # one table of every root's, each row led by its root, the columns in the order the roots first give them, a root's decided signals where its census is running again and its table is not yet decided
        rows, keys = [], ["root"]
        for label, data in pairs:
            got = planets_read(res(data, *parts)) if os.path.exists(res(data, *parts)) else []
            if parts == ("signals.csv",) and got and "reason" not in got[0] and os.path.exists(res(data, "signals_decided.csv")):
                got = planets_read(res(data, "signals_decided.csv"))
            rows += [dict(r, root=label) for r in got]
            keys += [k for k in (got[0] if got else {}) if k not in keys]
        return rows, keys
    sig, sig_keys = gather("signals.csv")
    found, found_keys = gather("planets.csv")
    kept, twins = [], set()
    for r in found:
        twin = next((k for k in kept if k["host"] == r["host"] and k["kind"] == r["kind"] and abs(float(k["P_d"]) / float(r["P_d"]) - 1.0) < 0.05), None)
        if twin:
            twin["roots"] += ";" + r["root"]
            twins.add((r["root"], archive_tag(r["planet"])))
        else:
            kept.append(dict(r, roots=r["root"]))
    planets_write(os.path.join(out, "planets.csv"), [r for r in kept if r["kind"] == "planet"], found_keys + ["roots"])
    planets_write(os.path.join(out, "planets", "companions.csv"), [r for r in kept if r["kind"] != "planet"], found_keys + ["roots"])
    planets_write(os.path.join(out, "discoveries.csv"), [r for r in kept if r["contribution"] == "discovery"], found_keys + ["roots"])
    planets_write(os.path.join(out, "planets", "signals.csv"), sig, sig_keys)
    current = {(r["root"], archive_tag(r["planet"])) for r in found} - twins
    ledger, keys = gather("ledger.csv")
    planets_write(os.path.join(out, "planets", "ledger.csv"), [x for x in ledger if (x["root"], archive_tag(x["planet"])) in current], keys)
    planets_write(os.path.join(out, "planets", "stars.csv"), *gather("stars.csv"))
    planets_write(os.path.join(out, "planets", "eccentric.csv"), *gather("eccentric", "candidates.csv"))
    planets_write(os.path.join(out, "planets", "dr4_predictions.csv"), *gather("dr4_predictions.csv"))
    planets_write(os.path.join(out, "planets", "likely_planets.csv"), *gather("likely_planets.csv"))
    planets_write(os.path.join(out, "planets", "single_transits.csv"), *gather("single_transits.csv"))
    # each root's records behind its decisions: the vet of each star with a signal that reached it, past the triage or known after it for a
    # catalogued companion; the orbits, TESS light curves and system analysis of each star whose signal was followed; the companion analysis, weighing
    # and companion orbit of each companion analysed; and the ledger of each new body
    triage = {"flagged", "companion", "degenerate fit", "under two cycles", "year alias", "archive planet"}
    records, arrays, figures = [], {}, PdfWriter()

    def take(label, kind, ident, path, **extra):
        # a record with its arrays, those of the .draws.npz file its draws field names, kept under LABEL/KIND/IDENT
        rec = publish_load(path)
        line = dict(root=label, kind=kind, id=ident, **extra)
        npz = os.path.join(os.path.dirname(path), rec.pop("draws")) if isinstance(rec.get("draws"), str) else None
        if npz and os.path.exists(npz):
            line["arrays"] = "/".join((label, kind, ident))
            with np.load(npz) as d:
                arrays.update({line["arrays"] + "/" + k: d[k] for k in d.files})
        records.append(dict(line, record=rec))
    for label, data in pairs:
        rows = [r for r in sig if r["root"] == label]
        signal = lambda r: r["kind"] in ("found", "eccentric")
        vetted = {r["name"] for r in rows if signal(r) and (r["reason"] == "catalogued" or r["status"] != "known" and not set(r["reason"].split("; ")) & triage)}
        followed = {r["name"] for r in rows if signal(r) and any(r.get(k) for k in ("fap_serval", "fap_drs", "fap_lbl", "fap_hires", "fap_carmenes", "fap_sophie", "fap_harps-n", "fap_neid", "fap_elodie", "dbic"))}
        analysed = {r["name"] for r in rows if r["kind"] == "companion" and r["label"] == "orbit" and r["reason"] != "analysis failed"}
        wanted = {("vet", n, "") for n in vetted} | {(k, n, v) for n in followed for k, v in (("orbits", ""), ("orbits", ".circular"), ("tess", ""), ("second", ""), ("dr4", ""))} | \
            {(k, n, v) for n in analysed for k, v in (("orbits", ".companion"), ("weigh", ""), ("companion", ""), ("dr4", ""))} | \
            {(k, r["name"], "") for r in rows if r["kind"] == "astrometry" and r["status"] in ("new", "candidate", "known") for k in ("dr4", "epochs")}
        for kind, name, variant in sorted(wanted):
            if os.path.exists(res(data, kind, archive_tag(name) + variant + ".json")):
                take(label, kind, archive_tag(name) + variant, res(data, kind, archive_tag(name) + variant + ".json"))
        for name in sorted(followed):
            folder = res(data, "system", archive_tag(name))
            if os.path.exists(os.path.join(folder, "analysis.json")):
                pages = {}
                for fig in ("periodograms", "phased", "detection_limits"):
                    if os.path.exists(os.path.join(folder, fig + ".pdf")):
                        pages[fig] = len(figures.pages) + 1
                        figures.append(os.path.join(folder, fig + ".pdf"), outline_item="%s %s: %s" % (label, name, fig.replace("_", " ")))
                take(label, "system", archive_tag(name), os.path.join(folder, "analysis.json"), pages=pages)
        for path in sorted(glob.glob(res(data, "ledger", "*.json"))):
            if (label, os.path.basename(path)[:-5]) in current:
                take(label, "ledger", os.path.basename(path)[:-5], path)
    rank = {label: i for i, (label, _) in enumerate(pairs)}
    records.sort(key=lambda x: (rank[x["root"]], x["kind"], x["id"]))
    publish_lines(os.path.join(out, "planets", "followup.jsonl"), records)
    save(os.path.join(out, "planets", "followup.npz"), arrays)
    if len(figures.pages):
        figures.add_metadata({"/Title": "orbitlight: the planetary systems' periodograms, phased orbits and detection limits"})
        figures.write(os.path.join(out, "planets", "figures.pdf"))

    def order(v):
        # the TOIs, the community TOIs and the Kepler objects of interest, each by number
        head, _, number = (v.get("label") or "TOI-%s" % v.get("toi")).partition("-")
        try:
            n = float(number)
        except ValueError:
            n = float("inf")
        return ("TOI", "CTOI", "KOI").index(head) if head in ("TOI", "CTOI", "KOI") else 3, n
    valid = []
    for label, data in pairs:
        valid += sorted((dict(root=label, **publish_load(p)) for p in glob.glob(res(data, "validate", "*.json"))), key=order)
    publish_lines(os.path.join(out, "planets", "validation.jsonl"), valid)
    cal = {}
    for key, name in (("summary", "calibration.json"), ("planets", "calibration_planets.csv"), ("unmatched", "calibration_unmatched.csv"), ("benchmark", "benchmark.json"),
                      ("validation", "validation_benchmark.json"), ("validation_again", "validation_benchmark_again.json"), ("validation_koi", "validation_benchmark_koi.json"), ("validation_k2", "validation_benchmark_k2.json"), ("wobble", "wobble_calibration.json")):
        p = res(pairs[0][1], name)
        if os.path.exists(p):
            cal[key] = publish_load(p) if name.endswith(".json") else [{k: publish_cell(v) for k, v in r.items()} for r in planets_read(p)]
    for _, data in pairs:
        for name in ("null_search", "inject_search", "multi_boost", "source_clear", "gaia_marks", "indicator_control", "window_cost"):
            if os.path.exists(res(data, name + ".json")):
                cal[name] = publish_load(res(data, name + ".json"))
    for key, name in (("null_census", "null_census.json"), ("controls", "controls.json"), ("sparse", os.path.join("sparse", "score.json"))):
        by_root = {label: publish_load(res(data, name)) for label, data in pairs if os.path.exists(res(data, name))}
        if by_root:
            cal[key] = by_root
    recovery = {os.path.basename(p)[:-5]: publish_load(p) for _, data in pairs for p in glob.glob(res(data, "recovery", "*.json"))}
    if recovery:
        cal["recovery"] = recovery
    json.dump(cal, open(os.path.join(out, "planets", "calibration.json"), "w"), separators=(",", ":"))
    for label, _ in pairs:
        print("%-10s %5d signals, %3d new bodies, %3d records behind the decisions, %4d validations" % (
            label, sum(1 for r in sig if r["root"] == label), sum(1 for r in kept if r["root"] == label), sum(1 for x in records if x["root"] == label),
            sum(1 for v in valid if v["root"] == label)), flush=True)
    return dict(signals=len(sig), bodies=len(kept), planets=sum(1 for r in kept if r["kind"] == "planet"), twins=len(twins), records=len(records),
                pages=len(figures.pages), validations=len(valid))


def publish_modes(out, data, save):
    """The solar, giants, transits and companions modes' files from the data root DATA, with the archive queries behind them. Returns the counts
    printed."""
    load = publish_load
    # the solar mode's results, each target's under RESULTS/solar/<instrument>_<target>: its daily velocities as rows of one table, each other result
    # a record with the arrays written beside it, the fit's periodogram, the orbit's map and the molecules' curves
    beside = {"fit": "periodogram", "orbit": "orbit_map", "molecules": "molecules"}
    days, lines, arrays = [], [], {}
    for folder in sorted(glob.glob(os.path.join(data, "results", "solar", "*"))):
        tag = os.path.basename(folder)
        inst, _, target = tag.partition("_")
        if os.path.exists(os.path.join(folder, "velocities.csv")):
            days += [dict(target=target, instrument=inst, **r) for r in planets_read(os.path.join(folder, "velocities.csv"))]
        for path in sorted(glob.glob(os.path.join(folder, "*.json"))):
            kind = os.path.basename(path)[:-5]
            line = dict(kind=kind, target=target, instrument=inst)
            npz = os.path.join(folder, beside.get(kind, kind) + ".npz")
            if kind in beside and os.path.exists(npz):
                line["arrays"] = tag + "/" + kind
                with np.load(npz) as d:
                    arrays.update({line["arrays"] + "/" + k: d[k] for k in d.files})
            lines.append(dict(line, record=load(path)))
    planets_write(os.path.join(out, "solar", "velocities.csv"), days, ["target", "instrument"] + [k for k in (days[0] if days else {}) if k not in ("target", "instrument")])
    publish_lines(os.path.join(out, "solar", "results.jsonl"), lines)
    save(os.path.join(out, "solar", "results.npz"), arrays)
    counts = dict(solar_days=len(days), solar=len(lines))
    # the giants mode's results under DATA/giants/results, each a transit search of one instrument with its species' maps, reflected light or
    # emission, and the run's record
    insts = {i for b in spectra_BANDS.values() for i in b["instruments"]}
    lines, arrays = [], {}
    for path in sorted(glob.glob(os.path.join(data, "giants", "results", "*.json"))):
        stem = os.path.basename(path)[:-5]
        rest = stem.rpartition(".")[2]
        kind = "transit" if rest in insts else rest if rest in ("reflected", "emission") else None
        if kind is None:
            continue
        line = dict(kind=kind, id=stem)
        if os.path.exists(path[:-5] + ".maps.npz"):
            line["arrays"] = stem
            with np.load(path[:-5] + ".maps.npz") as d:
                arrays.update({stem + "/" + k: d[k] for k in d.files})
        lines.append(dict(line, record=load(path)))
    if os.path.exists(os.path.join(data, "results", giants_RUN + ".json")):
        lines.append(dict(kind="record", id=giants_RUN, record=load(os.path.join(data, "results", giants_RUN + ".json"))))
    publish_lines(os.path.join(out, "giants", "results.jsonl"), lines)
    save(os.path.join(out, "giants", "results.npz"), arrays)
    counts["giants"] = len(lines)
    if os.path.exists(os.path.join(data, "results", transits_RUN + ".json")):
        json.dump(load(os.path.join(data, "results", transits_RUN + ".json")), open(os.path.join(out, "transits", "results.json"), "w"), separators=(",", ":"))
    # the companions mode's kept rows with each star's note, its searches and its validation
    lines, arrays = [], {}
    for path in sorted(glob.glob(os.path.join(data, "companions", "ccf", "*.npz"))):
        tag = os.path.basename(path)[:-4]
        with np.load(path) as d:
            arrays.update({tag + "/" + k: d[k] for k in d.files})
        lines.append(dict(kind="rows", id=tag, arrays=tag, record=load(path[:-4] + ".json") if os.path.exists(path[:-4] + ".json") else {}))
    for path in sorted(glob.glob(os.path.join(data, "companions", "results", "*.json"))):
        lines.append(dict(kind="search", id=os.path.basename(path)[:-5], record=load(path)))
    if os.path.exists(os.path.join(data, "results", "companions", "validation.json")):
        lines.append(dict(kind="validation", id="validation", record=load(os.path.join(data, "results", "companions", "validation.json"))))
    publish_lines(os.path.join(out, "companions", "results.jsonl"), lines)
    save(os.path.join(out, "companions", "results.npz"), arrays)
    counts["companions"] = sum(1 for x in lines if x["kind"] == "rows")
    # each search's archive queries in its folder, as the mode keeps them: the giants' and the transits' gzipped without a name or a time, so that the
    # same plan gives the same bytes, with their spectra counted per planet and instrument
    for mode, folder, summary, keys in (("giants", "giants", giants_plan_summary, ["planet", "host", "inst", "transit", "eclipse", "day", "other"]),
                                        ("transits", "shoreline", transits_plan_summary, ["planet", "host", "inst", "transits", "inside", "night"])):
        if os.path.exists(os.path.join(data, folder, "plan.json")):
            plan = load(os.path.join(data, folder, "plan.json"))
            with open(os.path.join(out, mode, "plan.json.gz"), "wb") as raw, gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as gz:
                gz.write(json.dumps(plan, separators=(",", ":")).encode("utf-8"))
            planets_write(os.path.join(out, mode, "plan_counts.csv"), summary(plan), keys)
    if os.path.exists(os.path.join(data, "companions", "plan.json")):
        json.dump(load(os.path.join(data, "companions", "plan.json")), open(os.path.join(out, "companions", "plan.json"), "w"), separators=(",", ":"))
    return counts


def publish(out, roots):
    """The repository's files written into OUT from the data roots ROOTS, LABEL=DATA pairs in order of precedence (publish_DOC)."""
    pairs = [x.split("=", 1) for x in roots]
    for folder in ("planets", "solar", "giants", "transits", "companions"):
        os.makedirs(os.path.join(out, folder), exist_ok=True)
    # the NumPy archives compressed side by side, each in a thread of its own
    with cf.ThreadPoolExecutor(4) as pool:
        writes = []
        save = lambda path, arrays: writes.append(pool.submit(np.savez_compressed, path, **arrays))
        c = publish_planets(out, pairs, save)
        c.update(publish_modes(out, pairs[0][1], save))
        for w in writes:
            w.result()
    print("%d signals, %d new planets and %d new companions, %d found again in a later root; %d records behind the decisions with %d pages of figures; "
          "%d validations; %d solar days and %d other solar results; %d giants results; %d companions' rows" % (
              c["signals"], c["planets"], c["bodies"] - c["planets"], c["twins"], c["records"], c["pages"], c["validations"], c["solar_days"], c["solar"],
              c["giants"], c["companions"]), flush=True)


# what a public file must not hold, read through its binaries too: home paths, the tokens of the services this file uses, and what a machine's own settings add (publish_scan_settings)
publish_RAW = r"[\\/]Users[\\/]|[\\/]home[\\/]|[\\/]root[\\/]|[\\/]mnt[\\/][a-z][\\/]|App[D]ata|hf_[A-Za-z0-9]{20,}|gh[opsu]_[A-Za-z0-9]{20,}|sk-[A-Za-z0-9]{20,}"
# and what compressed bytes can throw up, so read in text alone: drive and share paths, private addresses and e-mail addresses
publish_TEXT = r"(?<![A-Za-z0-9\\])[A-Za-z]:[\\/]{1,2}[A-Za-z_]|\\\\[A-Za-z0-9_.-]+\\[A-Za-z0-9_$.-]+|(?<![\d.])192\.168\.\d+\.\d+(?![\d.])|(?<![\d.])10\.\d+\.\d+\.\d+(?![\d.])|(?<![\d.])172\.(?:1[6-9]|2\d|3[01])\.\d+\.\d+(?![\d.])|[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+\.[A-Za-z]{2,}"


def publish_scan_settings():
    """A machine's own additions to the scan, kept out of the repository in the JSON file ORBITLIGHT_SCAN_NAMES names: `names`, a regular expression of its account and host names, and `expected`, what the public side holds by design, each name found to a regular expression of the files it may lie in. Visual Studio's default home in this file is expected everywhere."""
    settings = json.load(open(os.environ["ORBITLIGHT_SCAN_NAMES"], encoding="utf-8")) if os.environ.get("ORBITLIGHT_SCAN_NAMES") else {}
    return settings.get("names"), dict({"c:" + chr(92) + "p": r"orbitlight\.py"}, **settings.get("expected", {}))


def publish_scan_text(text, raw=False):
    """Every match in TEXT of what a public file must not hold: match to its context. RAW keeps to what does not arise by chance in compressed or numeric bytes."""
    names = publish_scan_settings()[0]
    pattern = "|".join(x for x in (names, publish_RAW, None if raw else publish_TEXT) if x)
    out = {}
    for m in re.finditer(pattern, text, re.I):
        out.setdefault(m.group(0).lower(), []).append(text[max(0, m.start() - 70):m.end() + 70].replace("\n", " ").replace("\r", " "))
    return out


def publish_scan(target, git=False):
    """Every file of a folder TARGET, or with GIT every revision of the clone TARGET with its LFS objects and its commits' authors, scanned for what a public file must not hold (publish_scan_text): PDFs by metadata, page text and decompressed streams, .npz and .npy by member names and string arrays, .gz decompressed and everything else as text. Prints each match with its context, grouped by file and name, and returns whether nothing but what is expected was found."""
    import zipfile
    hits = {}
    seen = set()

    def scan(where, text, raw=False):
        for name, ctx in publish_scan_text(text, raw).items():
            hits.setdefault((where, name), []).extend(ctx)

    def scan_bytes(rel, name, data):
        ext = os.path.splitext(name)[1].lower()
        if ext == ".pdf":
            import pymupdf
            doc = pymupdf.open(stream=data, filetype="pdf")
            scan(rel + " (metadata)", " ".join(str(v) for v in doc.metadata.values()))
            for page in doc:
                scan(rel + " (page text)", page.get_text())
            for x in range(1, doc.xref_length()):
                scan(rel + " (object)", doc.xref_object(x), True)
                if doc.xref_is_stream(x):
                    try:
                        scan(rel + " (stream)", doc.xref_stream(x).decode("latin-1"), True)
                    except Exception:
                        pass
        elif ext == ".npz":
            with zipfile.ZipFile(io.BytesIO(data)) as z:
                scan(rel + " (zip comment)", z.comment.decode("latin-1"))
                for info in z.infolist():
                    scan(rel + " (member name)", info.filename)
                    scan(rel + " (member comment)", info.comment.decode("latin-1"))
                    if info.extra:
                        scan(rel + " (member extra)", info.extra.decode("latin-1"), True)
                    a = np.load(io.BytesIO(z.read(info)), allow_pickle=False) if info.filename.endswith(".npy") else None
                    if a is not None and a.dtype.kind in "USO":
                        scan(rel + " (strings of %s)" % info.filename, " ".join(str(x) for x in a.ravel()))
        elif ext == ".npy":
            a = np.load(io.BytesIO(data), allow_pickle=False)
            if a.dtype.kind in "USO":
                scan(rel + " (strings)", " ".join(str(x) for x in a.ravel()))
        elif ext == ".gz":
            with gzip.GzipFile(fileobj=io.BytesIO(data)) as gz:
                scan(rel + " (decompressed)", gz.read().decode("utf-8", "replace"))
            if data[3] & 8:
                scan(rel + " (gzip name)", data[10:data.index(b"\0", 10)].decode("latin-1"))
        else:
            scan(rel, data.decode("utf-8", "replace"))
    if git:
        run = lambda *a: subprocess.run(["git", "-C", target] + list(a), capture_output=True, check=True, stdin=subprocess.DEVNULL).stdout
        revisions = run("rev-list", "--all").decode().split()
        print("%d revisions" % len(revisions), flush=True)
        for line in run("log", "--all", "--format=%an <%ae> | %cn <%ce> | %s").decode("utf-8", "replace").splitlines():
            scan("commit metadata", line)
        for rev in revisions:
            for row in run("ls-tree", "-r", rev).decode().splitlines():
                head, path = row.split("\t", 1)
                blob = head.split()[2]
                if blob in seen:
                    continue
                seen.add(blob)
                data = run("cat-file", "blob", blob)
                m = re.match(rb"version https://git-lfs\S+\noid sha256:([0-9a-f]{64})\nsize (\d+)", data)
                if m:
                    oid = m.group(1).decode()
                    obj = os.path.join(target, ".git", "lfs", "objects", oid[:2], oid[2:4], oid)
                    if not os.path.exists(obj):
                        hits.setdefault((path + " @" + rev[:7], "LFS object absent"), []).append(oid)
                        continue
                    data = open(obj, "rb").read()
                try:
                    scan_bytes(path + " @" + rev[:7], path, data)
                except Exception as exc:
                    hits.setdefault((path + " @" + rev[:7], "unread"), []).append(repr(exc)[:150])
    else:
        for d, dirs, files in os.walk(target):
            dirs[:] = [x for x in dirs if x != ".git"]
            for f in files:
                p = os.path.join(d, f)
                rel = os.path.relpath(p, target)
                seen.add(rel)
                try:
                    scan_bytes(rel, f, open(p, "rb").read())
                except Exception as exc:
                    hits.setdefault((rel, "unread"), []).append(repr(exc)[:150])
    expected = publish_scan_settings()[1]
    allowed = {k for k in hits if k[1] in expected and re.match(expected[k[1]], k[0])}
    found = {k: v for k, v in hits.items() if k not in allowed}
    print("%d files read; by design: %s" % (len(seen), sorted({"%s (%d files)" % (n, sum(1 for k in allowed if k[1] == n)) for _, n in allowed})))
    for (where, name), ctx in sorted(found.items()):
        print("  %-46s %-28s %6d  e.g. %s" % (where, name[:28], len(ctx), ctx[0][:170].encode("ascii", "replace").decode()))
    print("nothing else" if not found else "%d kinds of match to judge" % len(found), flush=True)
    return not found


def publish_check(folder, against):
    """Whether the published files in FOLDER are fit to replace the public ones in the folder AGAINST: their planets by contribution and kind of candidate on each side, what left the table with its decision in signals.csv and what entered, the discoveries by kind, and the statistical validations whose candidate is a mission's or whose decision no longer stands. Prints it and returns the bodies that should not stand."""
    csv.field_size_limit(10 ** 8)
    read = lambda base, name: list(csv.DictReader(open(os.path.join(base, name), encoding="utf-8"))) if os.path.exists(os.path.join(base, name)) else []
    new, old, disc = read(folder, "planets.csv"), read(against, "planets.csv"), read(folder, "discoveries.csv")
    tally = lambda rows: sorted({(r["contribution"], r.get("candidate", "").split("-")[0]): sum(1 for q in rows if (q["contribution"], q.get("candidate", "").split("-")[0]) == (r["contribution"], r.get("candidate", "").split("-")[0])) for r in rows}.items())
    key = lambda r: r.get("candidate") or r["planet"]
    print("public %d %s" % (len(old), tally(old)))
    print("now %d %s" % (len(new), tally(new)))
    print("discoveries %d %s" % (len(disc), sorted({r["kind"]: sum(1 for q in disc if q["kind"] == r["kind"]) for r in disc}.items())))
    print("companions %d, public %d" % (len(read(folder, os.path.join("planets", "companions.csv"))), len(read(against, os.path.join("planets", "companions.csv")))))
    # each label's validation where it has one, since a TESS candidate weighed with velocities holds a row of its own beside it
    sig = {}
    for r in read(folder, os.path.join("planets", "signals.csv")):
        if r["label"] not in sig or r["kind"] == "validated":
            sig[r["label"]] = r
    now, was = {key(r) for r in new}, {key(r) for r in old}
    why = {}
    for k in sorted(was - now):
        r = sig.get(k)
        why.setdefault((k.split("-")[0], "%s: %s" % (r["status"], r["reason"]) if r else "not in signals"), []).append(k)
    print("%d left the public table, %d entered" % (len(was - now), len(now - was)))
    for k, v in sorted(why.items(), key=lambda x: -len(x[1])):
        print("  %s %d %s" % (k, len(v), v[:6]))
    bad = [(r.get("candidate"), sig[r["candidate"]]["status"]) for r in new if r["contribution"] == "statistical validation" and r.get("candidate") in sig and sig[r["candidate"]]["status"] != "new"]
    print("validations %d, whose decision no longer stands %s" % (sum(r["contribution"] == "statistical validation" for r in new), bad[:20]), flush=True)
    return bad


def publish_cli():
    archive_quiet_warnings()
    p = argparse.ArgumentParser(prog="orbitlight.py publish", description=publish_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("out", help="the folder the files are written into, or `scan` or `check`")
    p.add_argument("roots", nargs="+", help="LABEL=DATA pairs, each a data root with its results under DATA/results, in order of precedence; after `scan` the folder, after `check` the folder and the public one")
    p.add_argument("--git", action="store_true", help="with scan, the folder a clone, every revision read")
    a = p.parse_args()
    if a.out == "scan":
        sys.exit(0 if publish_scan(a.roots[0], a.git) else 1)
    if a.out == "check":
        publish_check(a.roots[0], a.roots[1])
    else:
        publish(a.out, a.roots)


pipeline_DOC = """Every data root kept current on one machine: searched, weighed, tried against its controls, decided and published, within a budget of processes, by itself and for as long as it runs.

Its home is the folder of this file or ORBITLIGHT_HOME: a folder of each data root, logs/ and publish/. A root's chain sets it up, searches, follows and decides it and then searches it for eccentric orbits; its first root's also runs the calibrations, and the first root's other modes follow as a chain of their own (`modes`). Once a root's chain has ended, or where it already holds decisions, it joins the rest: its stars searched for transits; a validator, two processes at a time, round after round weighing every candidate not yet weighed as it now would be, the benchmarks of settled candidates among them, measuring ephemerides, reading each record's checks, Gaia's marks, folds, ten runs and difference images, trying the rules on controls, reading the stars' light curves and orbits again where they were not read as they now would be, giving each signal another reduction, searching for lone transits, testing new orbits in another spectrograph's spectra and in Gaia DR4's epochs, measuring the search against noise and laid-in transits, scoring the benchmarks and writing the controls. One process at a time gives the stored searches their noise measures, decides each root on the CPU and publishes every root into publish/, written beside it first and put in its place whole, with what entered or left the tables in logs/news.log. Each velocity root is given the others' velocities once they have joined, and whenever another joins. The TESS stage takes every process the budget leaves: `transitsearch --tess`, the share given by --ffi-share on the stars only full-frame light curves hold.

A search ends between stars once this file is replaced, and the pipeline starts it again on the new code and itself once no decision or publication runs. A process that has used no processor and read or written nothing for half an hour leaves the budget and no step waits for it, noted in logs/pipeline.log: one stuck in the kernel does neither and only the machine's restart ends it. No search process is started while the disk has less than 2 GB free, until it has 3 GB. Logs are logs/pipeline.log and one for each step.

    run       the pipeline, in this process
    start     the pipeline started so that it outlives this session
    watch     the pipeline started where no process runs it, unless stopped, for a scheduled task
    stop      every process paused and the pipeline ended, until `resume`
    pause     every search and validation ended between its stars or candidates and nothing started
    resume    a pause or stop ended; the work starts again within a minute, or at the next `watch`
    toggle    a pause set where none holds, and otherwise ended
    decide    every root decided and the files published once on the CPU, whatever a pause holds, and nothing else
    publish   the files published from every root once
    chain     the named roots' chains, or `modes`
    peers     the velocity roots given one another's velocities
    status    what runs, by its place in the budget, with the disk, the card, the last publication and the log's last lines
    end       Ctrl+C sent to the consoles of the given process ids, so that each process on them ends through its own exit path
    deploy    orbitlight.py.new beside this file put in its place, and the file copied to the second machine

ORBITLIGHT_HANDS names a folder of scripts run by hand, each counted against the budget beside the pipeline's. ORBITLIGHT_PEER or --peer names an SSH host whose search in ~/orbitlight/tess is brought in before each decision of the TESS root and paused and resumed with this one."""

pipeline_HOME = os.path.abspath(os.environ.get("ORBITLIGHT_HOME") or os.path.dirname(os.path.abspath(__file__)))
pipeline_LOGS = os.path.join(pipeline_HOME, "logs")
pipeline_WORK = os.path.join(pipeline_LOGS, "work")
pipeline_PUBLISH = os.path.join(pipeline_HOME, "publish")
pipeline_PAUSE, pipeline_STOP = os.path.join(pipeline_LOGS, "paused"), os.path.join(pipeline_LOGS, "stopped")
pipeline_HANDS = os.path.abspath(os.environ["ORBITLIGHT_HANDS"]).lower() if os.environ.get("ORBITLIGHT_HANDS") else None
pipeline_LOCK = threading.Lock()
# what the pipeline is holding to and what it has come to
pipeline_STATE = dict(budget=16, reserve=3, ffi=2.0 / 3.0, threads=0, peer=None, roots={}, ended=False, low=False, paused=False, refined=False, seen={}, frozen=set())
# the GB free under which no search process is started and at which they are started again, and the seconds without processor time after which a process leaves the budget
pipeline_DISK_LOW, pipeline_DISK_RESUME, pipeline_FROZEN = 2.0, 3.0, 1800.0


def pipeline_targets(inst):
    """How a root of a spectrograph's measured targets is set up (planets_targets, planets_measure): its setup in the first root and its steps in its own."""
    return (("planets", "targets", "{root}", "--inst", inst, "--min-nights", "4", "--min-span", "0"),), (("planets", "dace"), ("planets", "measure"))


# each data root in order of precedence: its folder, its label in the published tables, what sets it up, run in the first root on the CPU with {root} its own folder, and what follows in its own
pipeline_ROOTS = (("data", "bank", (), (("planets", "bank"), ("planets", "dace"))),
                  ("rvcat", "rvcat", (("planets", "rvcat", "{root}"),), (("planets", "dace"),)),
                  ("espresso", "espresso") + pipeline_targets("ESPRESSO"), ("feros", "feros") + pipeline_targets("FEROS"), ("uves", "uves") + pipeline_targets("UVES"),
                  ("hires", "hires", (("planets", "tables", "{root}"),), ()),
                  ("carmenes", "carmenes", (("planets", "carmenes", "{root}"),), ()),
                  ("sophie", "sophie", (("planets", "sophie", "{root}"),), ()),
                  ("harpsn", "harpsn", (("planets", "harpsn", "{root}"),), ()),
                  ("neid", "neid", (("planets", "neid", "{root}"),), ()),
                  ("elodie", "elodie", (("planets", "elodie", "{root}"),), ()))
pipeline_TESS = ("tess", "tess")
# the roots that take the others' velocities, the last of them the first root
pipeline_TAKERS = ("espresso", "feros", "uves", "carmenes", "neid", "elodie", "harpsn", "sophie", "hires", "rvcat", "data")
# the first root's calibrations, after its census's decisions, and its other modes, each a step in turn
pipeline_CALIBRATIONS = (("planets", "calibrate"), ("planets", "benchmark"), ("planets", "calibrate", "--wobble"))
pipeline_MODES = (("solar",), ("giants", "plan"), ("giants", "fetch", "--streams", "2"), ("giants", "search"), ("giants", "reflected", "--streams", "2"), ("giants", "emission", "--streams", "2"), ("giants", "record"),
                  ("transits", "plan"), ("transits", "fetch"), ("transits", "record"),
                  ("companions", "plan"), ("companions", "survey", "--inst", "HARPS", "--streams", "2"), ("companions", "survey", "--inst", "ESPRESSO", "--streams", "2"), ("companions", "validate", "--inst", "HARPS"))


def pipeline_note(text):
    """A line in logs/pipeline.log."""
    with pipeline_LOCK, open(os.path.join(pipeline_LOGS, "pipeline.log"), "a", encoding="utf-8") as fh:
        fh.write("%s %s\n" % (time.strftime("%Y-%m-%d %H:%M:%S"), text))


def pipeline_log(name):
    """A step's log under logs/."""
    return os.path.join(pipeline_LOGS, name)


def pipeline_process(root, args, log, cpu=False, fit=False):
    """orbitlight run in the data root ROOT with ARGS at below-normal priority, its output appended to LOG, on the CPU on the pipeline's threads where CPU is set, once it fits the budget and no pause holds where FIT is set."""
    if fit:
        pipeline_wait_pause()
        pipeline_wait_budget(1)
    env = dict(os.environ, ORBITLIGHT_DATA=root, ORBITLIGHT_HOME=pipeline_HOME, ORBITLIGHT_PAUSE=pipeline_PAUSE, HF_HUB_DISABLE_PROGRESS_BARS="1", PYTHONWARNINGS="ignore")
    if cpu:
        env["ORBITLIGHT_DEVICE"] = "cpu"
    if cpu and pipeline_STATE["threads"]:
        env.update(OMP_NUM_THREADS=str(pipeline_STATE["threads"]), MKL_NUM_THREADS=str(pipeline_STATE["threads"]))
    kw = dict(creationflags=subprocess.BELOW_NORMAL_PRIORITY_CLASS) if os.name == "nt" else dict(preexec_fn=lambda: os.nice(10))
    with open(log, "a", encoding="utf-8") as fh:
        return subprocess.Popen([sys.executable, "-u", os.path.abspath(__file__)] + list(args), stdout=fh, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, env=env, cwd=pipeline_WORK, **kw)


def pipeline_paused():
    """Whether a pause is asked for."""
    return os.path.exists(pipeline_PAUSE)


def pipeline_wait_pause():
    """Until no pause holds."""
    while pipeline_paused():
        time.sleep(30)


def pipeline_activity(p):
    """What the process P has done so far, which stops moving only where it does nothing at all: its processor time and its reads, writes and other input and output."""
    import psutil
    t = p.cpu_times()
    try:
        io = p.io_counters()
        return t.user + t.system, io.read_count, io.write_count, getattr(io, "other_count", 0)
    except (psutil.Error, AttributeError):
        return t.user + t.system,


def pipeline_wait(p):
    """The exit status of the process P, or None once it has done nothing for pipeline_FROZEN seconds and is left behind, with a line in the log: one stuck in the kernel never ends."""
    import psutil
    seen, since = None, time.time()
    while True:
        try:
            return p.wait(timeout=60)
        except subprocess.TimeoutExpired:
            pass
        try:
            now = pipeline_activity(psutil.Process(p.pid))
        except psutil.Error:
            continue
        if now != seen:
            seen, since = now, time.time()
        elif time.time() - since > pipeline_FROZEN:
            pipeline_note("process %d has done nothing for %.0f minutes and is left behind" % (p.pid, pipeline_FROZEN / 60.0))
            return None


def pipeline_step(root, args, log, cpu=False, tries=40):
    """ARGS run in ROOT until they exit 0, started again a minute after a process ends between its stars with exit status 3 or fails, TRIES times at most: whether they ended well."""
    for _ in range(tries):
        pipeline_wait_pause()
        if pipeline_wait(pipeline_process(root, args, log, cpu)) == 0:
            return True
        time.sleep(60)
    return False


def pipeline_until(make, tries=3):
    """A step's processes, made by MAKE, run until each exits cleanly, TRIES times at most."""
    for _ in range(tries):
        if all(pipeline_wait(p) == 0 for p in make()):
            return True
    return False


def pipeline_running():
    """Every process of orbitlight's on the machine: (process, its arguments after orbitlight.py), the pipeline's own driver and tools left out; and a script run by hand from ORBITLIGHT_HANDS, as `by hand` and its path, with a shell keeping such a job going while it waits between passes."""
    import psutil
    out = []
    for p in psutil.process_iter(["cmdline"]):
        try:
            cmd = p.info["cmdline"] or []
            for i, x in enumerate(cmd):
                low = x.lower()
                if low.endswith("orbitlight.py"):
                    if cmd[i + 1:i + 2] != ["pipeline"] and cmd[i + 1:i + 2] != ["selftest"]:
                        out.append((p, " ".join(cmd[i + 1:])))
                    break
                if pipeline_HANDS and low.startswith(pipeline_HANDS) and low.endswith(".py"):
                    out.append((p, "by hand " + low))
                    break
                if pipeline_HANDS and low.startswith(pipeline_HANDS) and low.endswith((".cmd", ".sh")) and not any("python" in c.name().lower() for c in p.children(recursive=True)):
                    out.append((p, "by hand waiting " + low))
                    break
        except psutil.Error:
            continue
    return out


def pipeline_workers():
    """What each process that counts against the budget was asked (pipeline_running), those that have done nothing for pipeline_FROZEN seconds left out and noted once."""
    import psutil
    now, seen, out = time.time(), pipeline_STATE["seen"], []
    for p, args in pipeline_running():
        try:
            spent = pipeline_activity(p)
        except psutil.Error:
            continue
        last = seen.get(p.pid)
        if last is None or last[0] != spent:
            seen[p.pid] = (spent, now)
        elif now - last[1] > pipeline_FROZEN and not args.startswith("by hand waiting"):
            if p.pid not in pipeline_STATE["frozen"]:
                pipeline_STATE["frozen"].add(p.pid)
                pipeline_note("process %d has done nothing for %.0f minutes and leaves the budget: %s" % (p.pid, (now - last[1]) / 60.0, args))
            continue
        out.append(args)
    return out


def pipeline_kind(args):
    """A process's place in the budget: tess, step (the validator's, a noise measure, a decision or a publication), search (a census root's transit search) or other, a root's own chain among them."""
    if "transitsearch --tess" in args:
        return "tess"
    if any(flag in args for flag in ("planets validate", "planets controls", "--validate", "--backfill")) or args.startswith(("planets followup --report", "publish")):
        return "step"
    return "search" if "transitsearch --part" in args else "other"


def pipeline_wait_budget(n):
    """Until N more processes fit the budget."""
    while len(pipeline_workers()) + n > pipeline_STATE["budget"]:
        time.sleep(30)


def pipeline_joined():
    """The roots whose chains have ended or that already hold decisions, by label in order of precedence."""
    out = {}
    for folder, label, _, _ in pipeline_ROOTS:
        root = os.path.join(pipeline_HOME, folder)
        table = os.path.join(root, "results", "planets", "signals.csv")
        decided = os.path.exists(table) and "reason" in open(table, encoding="utf-8").readline().strip().split(",")
        if os.path.exists(pipeline_log(folder + ".done")) or decided:
            out[label] = root
    return out


def pipeline_tess():
    """The TESS root's folder, where it has been set up, else None."""
    root = os.path.join(pipeline_HOME, pipeline_TESS[0])
    return root if os.path.exists(os.path.join(root, "planets", "tess.json")) else None


def pipeline_chain(name):
    """One root's chain, or the first root's other modes under `modes`, each step logged to logs/<name>_<step>.log and stopping at the first that fails: the root's setup on the CPU and its own first steps; its census, followed and its ledger read and decided; logs/<name>.done, on which it joins the rest; its eccentric search, and its decisions again. Whether it ended well."""
    first = os.path.join(pipeline_HOME, pipeline_ROOTS[0][0])
    if name == "modes":
        for i, args in enumerate(pipeline_MODES):
            if not pipeline_step(first, args, pipeline_log("modes_%d_%s.log" % (i, args[0]))):
                pipeline_note("the modes' chain stops at %s" % " ".join(args))
                return False
        open(pipeline_log("modes.done"), "w").write("done\n")
        return True
    if name == pipeline_TESS[0]:
        root = os.path.join(pipeline_HOME, name)
        return pipeline_step(root, ("planets", "transitsearch", "--tess", "--setup", first), pipeline_log("tess_setup.log"), cpu=True)
    folder, _, setup, own = next(r for r in pipeline_ROOTS if r[0] == name)
    root = os.path.join(pipeline_HOME, folder)
    log = lambda step: pipeline_log("%s_%s.log" % (name, step))
    follow = ("planets", "followup", "--workers", "2")
    steps = [(first, tuple(root if a == "{root}" else a for a in args), log(args[1]), True) for args in setup] + [(root, args, log(args[1]), args[1] == "dace") for args in own]
    steps += [(root, ("planets", "census"), log("census"), False), (root, follow, log("followup"), False), (root, ("planets", "ledger", "--workers", "2"), log("ledger"), False), (root, follow + ("--report",), log("report"), False)]
    if name == pipeline_ROOTS[0][0]:
        steps += [(root, args, log("_".join(args[1:])), False) for args in pipeline_CALIBRATIONS]
    for where, args, path, cpu in steps:
        if not pipeline_step(where, args, path, cpu):
            pipeline_note("the %s chain stops at %s" % (name, " ".join(args)))
            return False
    open(pipeline_log(name + ".done"), "w").write("done\n")
    pipeline_note("the %s chain's decisions stand" % name)
    return pipeline_step(root, ("planets", "eccentric"), log("eccentric")) and pipeline_step(root, follow + ("--report",), log("eccentric_report"))


def pipeline_chains():
    """Each root whose chain has not run, one at a time, the first root's other modes after the first root's, then the TESS root's setup; a chain that fails is tried again an hour on."""
    while True:
        joined = pipeline_joined()
        names = [r[0] for r in pipeline_ROOTS if r[1] not in joined]
        if pipeline_ROOTS[0][1] in joined and not os.path.exists(pipeline_log("modes.done")):
            names.insert(0, "modes")
        if pipeline_tess() is None:
            names.append(pipeline_TESS[0])
        if not names:
            return
        if not pipeline_chain(names[0]):
            time.sleep(3600)


def pipeline_peers(only=None):
    """The velocity roots given one another's velocities (planets_peers) once every root has joined, and again whenever another has joined since logs/peers.done was written, or with ONLY those roots' folders alone: each in turn marked logs/<folder>.busy, which the decisions leave alone, its census run again, its new signals followed and its ledger read; each step in logs/peers_<folder>.log. Whether it ended well."""
    givers = [r[0] for r in pipeline_ROOTS if r[1] in pipeline_joined()]
    ok = True
    for folder in pipeline_TAKERS:
        if folder not in givers or only and folder not in only:
            continue
        root, log, busy = os.path.join(pipeline_HOME, folder), pipeline_log("peers_%s.log" % folder), pipeline_log(folder + ".busy")
        open(busy, "w").close()
        try:
            if pipeline_step(root, ("planets", "peers") + tuple(os.path.join(pipeline_HOME, g) for g in givers if g != folder), log):
                ok = pipeline_step(root, ("planets", "census"), log) and pipeline_step(root, ("planets", "followup", "--workers", "2", "--report"), log) and pipeline_step(root, ("planets", "ledger"), log) and ok
            else:
                ok = False
        finally:
            os.remove(busy)
        pipeline_note("%s given the others' velocities" % folder)
    if ok:
        open(pipeline_log("peers.done"), "w").write("\n".join(givers) + "\n")
    return ok


def pipeline_peers_loop():
    """pipeline_peers whenever every root has joined and the roots differ from those of logs/peers.done, looked at every ten minutes."""
    while True:
        joined = [r[0] for r in pipeline_ROOTS if r[1] in pipeline_joined()]
        done = open(pipeline_log("peers.done")).read().split() if os.path.exists(pipeline_log("peers.done")) else []
        if len(joined) == len(pipeline_ROOTS) and sorted(joined) != sorted(done):
            pipeline_peers()
        time.sleep(600)


def pipeline_validator():
    """Round after round, two processes at a time: the candidates not yet weighed as they now would be, with the settled ones of the benchmarks; those that did not pass measured for their own ephemeris and weighed again where it moves them; each record of every root given Gaia's marks, its fold, its checks, ten runs where they would make it pass and its difference images; the rules tried on settled candidates when they have changed, with what they reject noted, and the benchmarks scored; the census stars' readings made again where they were not made as they now would be, their signals given another reduction and their lone transits searched, new orbits tested in another spectrograph's spectra and Gaia DR4's epochs, the census tried with its nights moved; samples of the TESS root's stars searched upside down and with planets' transits laid in; the candidates no search process has weighed; and the controls written: a round every five minutes, every hour once the census search has ended."""
    while any("planets validate" in a or "--validate" in a for a in pipeline_workers()):
        time.sleep(30)

    def every():
        tess = pipeline_tess()
        return list(pipeline_STATE["roots"].items()) + ([(pipeline_TESS[1], tess)] if tess else [])

    def shares(root, args, log):
        pipeline_wait_pause()
        pipeline_wait_budget(2)
        return [pipeline_process(root, list(args) + ["--part", "%d/2" % k], pipeline_log(log % k)) for k in range(2)]

    def once(root, args, log, cpu=False):
        pipeline_wait_pause()
        pipeline_wait_budget(1)
        return [pipeline_process(root, args, pipeline_log(log), cpu)]
    tried = None
    while True:
        if not pipeline_STATE["roots"]:
            time.sleep(300)
            continue
        first = next(iter(pipeline_STATE["roots"].values()))
        pipeline_until(lambda: shares(first, ["planets", "validate"], "validate_tois_%d.log"), 20)
        for extra, tag in ((("--benchmark", "300"), "toi"), (("--benchmark", "300", "--again"), "again"), (("--benchmark", "300", "--source", "koi"), "koi"), (("--benchmark", "200", "--source", "k2"), "k2")):
            pipeline_until(lambda: shares(first, ("planets", "validate") + extra, "validate_benchmark_" + tag + "_%d.log"), 20)
        pipeline_until(lambda: shares(first, ["planets", "validate", "--refine"], "validate_refine_%d.log"), 20)
        for name, root in every():
            for flag in ("--gaia", "--fold", "--checks", "--multi", "--clear"):
                pipeline_until(lambda: shares(root, ["planets", "validate", flag], "validate_" + flag[2:] + "_" + name + "_%d.log"), 20)
        if not pipeline_STATE.get("refine_noted"):
            pipeline_STATE.update(refined=True, refine_noted=True)
            pipeline_note("the candidates measured for their own ephemeris, and the passing records given their checks")
        pipeline_until(lambda: once(first, ["planets", "validate", "--control"], "control.log", cpu=True), 5)
        result = planets_load_json(os.path.join(first, "results", "planets", "control.json")) or {}
        if result.get("digest") != tried and "planets" in result:
            tried = result.get("digest")
            pipeline_note("; ".join("the rules reject %s of %s %s: %s, each rule tripping on %s" % (result[k]["rejected"], result[k]["judged"], k.replace("_", " "), {r: len(v) for r, v in result[k]["by_reason"].items()}, {r: len(v) for r, v in result[k]["trips"].items()}) for k in ("planets", "false_positives")))
        pipeline_until(lambda: once(first, ["planets", "validate", "--score"], "score.log", cpu=True), 5)
        for flag in ("--tess", "--orbits", "--reduce", "--activity", "--singles", "--second", "--epochs"):
            for name, root in list(pipeline_STATE["roots"].items()):
                pipeline_until(lambda: shares(root, ["planets", "validate", flag], "validate_" + flag[2:] + "_" + name + "_%d.log"), 20)
        for name, root in list(pipeline_STATE["roots"].items()):
            pipeline_until(lambda: once(root, ["planets", "validate", "--scramble"], "validate_scramble_" + name + ".log"), 20)
        tess = pipeline_tess()
        if tess:
            for flag in ("--null", "--inject"):
                pipeline_until(lambda: shares(tess, ["planets", "validate", flag], "validate_" + flag[2:] + "_%d.log"), 20)
        for name, root in every():
            for p in shares(root, ["planets", "transitsearch", "--validate"], "validate_transits_" + name + "_%d.log"):
                pipeline_wait(p)
        for name, root in every():
            pipeline_until(lambda: once(root, ["planets", "controls"], "controls_" + name + ".log", cpu=True), 3)
        time.sleep(3600 if pipeline_STATE["ended"] else 300)


def pipeline_decide_census(noise=True):
    """Each census root decided again on the CPU, with NOISE after the stored searches are given their noise measures, a root whose own chain runs (logs/<folder>.busy) left for the next round."""
    if noise:
        for name, root in list(pipeline_STATE["roots"].items()):
            pipeline_until(lambda: [pipeline_process(root, ["planets", "transitsearch", "--backfill"], pipeline_log("backfill_%s.log" % name), fit=True)])
        pipeline_note("stored searches given their noise measures")
    for name, root in list(pipeline_STATE["roots"].items()):
        if os.path.exists(pipeline_log(os.path.basename(root) + ".busy")):
            continue
        code = pipeline_wait(pipeline_process(root, ["planets", "followup", "--report", "--workers", "1"], pipeline_log("pipeline_decide_%s.log" % name), cpu=True, fit=True))
        pipeline_note("%s decided again (exit %s)" % (name, code))


def pipeline_peer_sync():
    """The search records a second machine has made since the last copy brought into the TESS root, each written beside its place first and put there whole, so that the decision reads them; left for the next copy where it does not answer."""
    import tarfile
    host, tess = pipeline_STATE["peer"], pipeline_tess()
    if not host or not tess:
        return
    pack = pipeline_log("peer_sync.tar.gz")
    remote = ("test -e ~/orbitlight/sync.done || touch -d 2000-01-01 ~/orbitlight/sync.done; touch ~/orbitlight/sync.next; cd ~/orbitlight/tess/results/planets && "
              "find transitsearch validate_transits -type f -name '*.json' -newer ~/orbitlight/sync.done -print0 | tar czf - --null -T -")
    ssh = ["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", host]
    try:
        with open(pack, "wb") as fh:
            subprocess.run(ssh + [remote], stdout=fh, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL, timeout=1800, check=True)
        n = 0
        with tarfile.open(pack, "r:gz") as tar:
            for m in tar:
                parts = m.name.split("/")
                if not m.isfile() or len(parts) != 2 or parts[0] not in ("transitsearch", "validate_transits") or not parts[1].endswith(".json") or ".." in m.name:
                    continue
                dest = os.path.join(tess, "results", "planets", parts[0], parts[1])
                with open(dest + ".part", "wb") as out:
                    shutil.copyfileobj(tar.extractfile(m), out)
                os.replace(dest + ".part", dest)
                n += 1
        with open(os.devnull, "w") as null:
            subprocess.run(ssh + ["mv -f ~/orbitlight/sync.next ~/orbitlight/sync.done"], stdout=null, stderr=null, stdin=subprocess.DEVNULL, timeout=60, check=True)
        pipeline_note("%d records brought in from the second machine" % n)
    except Exception as exc:
        pipeline_note("the second machine's records left for the next copy: %s: %s" % (type(exc).__name__, str(exc)[:160]))
    finally:
        if os.path.exists(pack):
            os.remove(pack)


def pipeline_decide_tess():
    """The TESS root decided again on the CPU, a second machine's records brought in first."""
    pipeline_peer_sync()
    tess = pipeline_tess()
    if tess:
        code = pipeline_wait(pipeline_process(tess, ["planets", "followup", "--report", "--workers", "1"], pipeline_log("pipeline_decide_tess.log"), cpu=True, fit=True))
        pipeline_note("tess decided again (exit %s)" % code)


def pipeline_news(old, new):
    """The planets and companions that entered or left the published planets.csv and planets/companions.csv between the publications OLD and NEW, a line each in logs/news.log, a body that left with its decision in NEW's signals.csv."""
    def bodies(folder):
        rows = {}
        for f in ("planets.csv", os.path.join("planets", "companions.csv")):
            p = os.path.join(folder, f)
            if os.path.exists(p):
                rows.update({r["planet"]: r for r in csv.DictReader(open(p, encoding="utf-8"))})
        return rows
    before, after = bodies(old), bodies(new)
    if not before or not after:
        return
    signals = {}
    path = os.path.join(new, "planets", "signals.csv")
    if os.path.exists(path):
        for r in csv.DictReader(open(path, encoding="utf-8")):
            signals.setdefault((r["root"], r["name"]), []).append(r)
    body = lambda r: "planet" if r["kind"] == "planet" else "companion (%s)" % r["kind"]
    lines = ["new %s: %s, P %s d, %s, %s, %s, %s" % (body(after[n]), n, after[n]["P_d"], after[n]["host"], after[n]["found_by"], after[n]["contribution"], after[n]["discovered_by"]) for n in sorted(set(after) - set(before))]
    kinds = {"census": "found", "eccentric search": "eccentric", "companions": "companion", "TESS": "toi", "validation": "validated", "transit search": "transit", "astrometry": "astrometry"}
    for name in sorted(set(before) - set(after)):
        r = before[name]
        near = [s for s in signals.get((r["root"], r["bank_name"]), []) if s["P"] and min(abs(float(s[k]) / float(r["P_d"]) - 1.0) for k in ("P", "orbit_P") if s.get(k)) < 0.02]
        why = [s for s in near if s["kind"] == kinds.get(r.get("found_by"))] or near
        lines.append("left %s: %s, P %s d, %s" % (body(r), name, r["P_d"], "%s (%s)" % (why[0]["status"], why[0]["reason"]) if why else "renamed or no longer listed"))
    with open(pipeline_log("news.log"), "a", encoding="utf-8") as fh:
        for line in lines:
            fh.write("%s %s\n" % (time.strftime("%Y-%m-%d %H:%M:%S"), line))


def pipeline_publish():
    """The repository's files published from every root, written beside publish/ and put in its place whole, with the news."""
    every = dict(pipeline_STATE["roots"])
    tess = pipeline_tess()
    if tess and os.path.exists(os.path.join(tess, "results", "planets", "planets.csv")):
        every[pipeline_TESS[1]] = tess
    nxt = pipeline_PUBLISH + "_next"
    shutil.rmtree(nxt, ignore_errors=True)
    code = pipeline_wait(pipeline_process(next(iter(every.values())), ["publish", nxt] + ["%s=%s" % kv for kv in every.items()], pipeline_log("pipeline_publish.log"), cpu=True, fit=True))
    if code == 0:
        open(os.path.join(nxt, "published.txt"), "w").write(time.strftime("%Y-%m-%d %H:%M:%S") + "\n")
        try:
            pipeline_news(pipeline_PUBLISH, nxt)
        except Exception as exc:
            pipeline_note("news not written: %s: %s" % (type(exc).__name__, str(exc)[:200]))
        shutil.rmtree(pipeline_PUBLISH + "_old", ignore_errors=True)
        # a reader holding a file of the folder open holds its name: asked again for five minutes
        for attempt in range(10):
            try:
                if os.path.exists(pipeline_PUBLISH):
                    os.rename(pipeline_PUBLISH, pipeline_PUBLISH + "_old")
                os.rename(nxt, pipeline_PUBLISH)
                break
            except PermissionError:
                if attempt == 9:
                    raise
                time.sleep(30)
    pipeline_note("published from %s (exit %s)" % (", ".join(every), code))


def pipeline_busy():
    """Whether a step that takes one process at a time runs: a noise measure, a decision or a publication."""
    return any(pipeline_kind(a) == "step" and "planets validate" not in a and "--validate" not in a and "planets controls" not in a for a in pipeline_workers())


def pipeline_steps():
    """The steps one process at a time: the noise measures and each census root's decisions every ten minutes while the census search runs and every hour after it, the TESS root's every ten minutes, and the publication after any decision; a pause, or a decision started by hand, waited out."""
    while pipeline_busy():
        time.sleep(30)
    last_census, last_tess = 0.0, 0.0
    while True:
        while pipeline_paused() or pipeline_busy():
            time.sleep(30)
        decided = False
        if pipeline_STATE["roots"] and (pipeline_STATE["refined"] or time.time() - last_census > (3600 if pipeline_STATE["ended"] else 600)):
            pipeline_STATE["refined"] = False
            pipeline_decide_census()
            last_census, decided = time.time(), True
        if pipeline_tess() and time.time() - last_tess > 600:
            pipeline_decide_tess()
            last_tess, decided = time.time(), True
        if decided:
            pipeline_publish()
        time.sleep(60)


def pipeline_kept_going(step):
    """STEP, a loop of the pipeline's, started again a minute after it raises, with what it raised noted."""
    while True:
        try:
            step()
            return
        except Exception as exc:
            pipeline_note("%s stopped: %s: %s; started again" % (step.__name__, type(exc).__name__, str(exc)[:200]))
            time.sleep(60)


def pipeline_share_running(root, part):
    """Whether a search share PART of the data root ROOT is running, as one an earlier start of the pipeline left."""
    import psutil
    for p, args in pipeline_running():
        if args == "planets transitsearch --part " + part:
            try:
                if p.environ().get("ORBITLIGHT_DATA") == root:
                    return True
            except (psutil.Error, OSError):
                return True
    return False


def pipeline_run(argv):
    """The pipeline in this process, ARGV what starts it again once this file is replaced (pipeline_DOC)."""
    os.makedirs(pipeline_WORK, exist_ok=True)
    pipeline_STATE["roots"] = pipeline_joined()
    for step in (pipeline_validator, pipeline_steps, pipeline_chains, pipeline_peers_loop):
        threading.Thread(target=pipeline_kept_going, args=(step,), daemon=True).start()
    keep, started, shown = {}, 0, -1
    while True:
        if planets_code_changed() and not pipeline_busy():
            pipeline_note("the pipeline starts again on its new code")
            pipeline_detach(argv)
            os._exit(0)
        roots = pipeline_STATE["roots"]
        for name, root in pipeline_joined().items():
            if name not in roots:
                roots[name] = root
                pipeline_note("the %s root joins the census" % name)
            if not any(key[0] == name for key in keep) and name not in pipeline_STATE.setdefault("searched", set()):
                n = 4 if root == os.path.join(pipeline_HOME, pipeline_ROOTS[0][0]) else 1
                keep.update({(name, "%d/%d" % (k, n)): [None, 0] for k in range(n)})
                pipeline_STATE["searched"].add(name)
        args = pipeline_workers()
        kinds = [pipeline_kind(a) for a in args]
        pipeline_STATE["ended"] = "search" not in kinds and not keep
        room = min(pipeline_STATE["budget"] - pipeline_STATE["reserve"] - sum(k != "step" for k in kinds), pipeline_STATE["budget"] - len(kinds))
        free = shutil.disk_usage(pipeline_HOME).free / 1e9
        if free < pipeline_DISK_LOW or pipeline_STATE["low"] and free < pipeline_DISK_RESUME:
            if not pipeline_STATE["low"]:
                pipeline_note("the disk has %.1f GB free: no search process is started until it has %g GB" % (free, pipeline_DISK_RESUME))
            pipeline_STATE["low"], room = True, 0
        elif pipeline_STATE["low"]:
            pipeline_note("the disk has %.1f GB free: search processes are started again" % free)
            pipeline_STATE["low"] = False
        if pipeline_paused() != pipeline_STATE["paused"]:
            pipeline_STATE["paused"] = pipeline_paused()
            pipeline_note("paused: every process ends between its stars and none is started" if pipeline_STATE["paused"] else "resumed")
        if pipeline_STATE["paused"]:
            room = 0
        for (name, part), slot in list(keep.items()):
            p, tries = slot
            if p is not None and p.poll() is None:
                continue
            if p is not None and p.returncode == 0 or tries >= 20:
                del keep[(name, part)]
                pipeline_note("the %s root's search share %s ended" % (name, part))
                continue
            # a share an earlier start of the pipeline left running is left to end, and started then, ending at once where its stars are done
            if p is None and pipeline_share_running(roots[name], part):
                continue
            if room > 0:
                slot[:] = [pipeline_process(roots[name], ["planets", "transitsearch", "--part", part], pipeline_log("transitsearch_%s_%s.log" % (name, part.replace("/", "of")))), tries + 1]
                room -= 1
        tess = pipeline_tess()
        if tess:
            n, n_ffi = kinds.count("tess"), sum(k == "tess" and "--ffi" in a for k, a in zip(kinds, args))
            for _ in range(max(room, 0)):
                started += 1
                ffi = n_ffi < round(pipeline_STATE["ffi"] * (n + 1))
                pipeline_process(tess, ["planets", "transitsearch", "--tess"] + (["--ffi"] if ffi else []), pipeline_log("transitsearch_%s_%d.log" % ("ffi" if ffi else "tess", started % 40)))
                n, n_ffi = n + 1, n_ffi + ffi
            if (n, n_ffi) != shown:
                pipeline_note("the TESS stage runs %d process%s, %d on full-frame stars" % (n, "" if n == 1 else "es", n_ffi))
                shown = (n, n_ffi)
        time.sleep(60)


def pipeline_detach(argv):
    """orbitlight.py started with the arguments ARGV at below-normal priority so that it outlives this session and any job holding it: through WMI on Windows, in a session of its own elsewhere."""
    os.makedirs(pipeline_WORK, exist_ok=True)
    cmd = [sys.executable, "-u", os.path.abspath(__file__)] + list(argv)
    if os.name == "nt":
        script = ("$s = New-CimInstance -ClassName Win32_ProcessStartup -ClientOnly -Property @{PriorityClass = [uint32]16384}; "
                  "Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine = '%s'; CurrentDirectory = '%s'; ProcessStartupInformation = $s} | Out-Null" % (subprocess.list2cmdline(cmd).replace("'", "''"), pipeline_WORK.replace("'", "''")))
        with open(pipeline_log("detach.log"), "a") as fh:
            subprocess.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", script], stdout=fh, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, check=True)
    else:
        with open(pipeline_log("pipeline_out.log"), "a") as fh:
            subprocess.Popen(cmd, stdout=fh, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, cwd=pipeline_WORK, start_new_session=True, preexec_fn=lambda: os.nice(10))


def pipeline_driver():
    """The processes that run the pipeline."""
    import psutil
    out = []
    for p in psutil.process_iter(["cmdline"]):
        cmd = p.info["cmdline"] or []
        for i, x in enumerate(cmd):
            if x.lower().endswith("orbitlight.py"):
                if cmd[i + 1:i + 3] == ["pipeline", "run"] and p.pid != os.getpid():
                    out.append(p)
                break
    return out


def pipeline_remote(command):
    """COMMAND's output on the second machine, written to a file since OpenSSH can hang on a pipe's close; empty where it does not answer or there is none."""
    if not pipeline_STATE["peer"]:
        return ""
    path = pipeline_log("peer_out.txt")
    try:
        with open(path, "w") as fh:
            subprocess.run(["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=10", pipeline_STATE["peer"], command], stdout=fh, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL, timeout=40)
        return open(path).read().strip()
    except (OSError, subprocess.SubprocessError):
        return ""


def pipeline_status():
    """What runs, by its place in the budget, the two samples of each process's processor time five seconds apart marking those that used none; the disk, the card, the last publication and its tables; and the log's last lines."""
    import psutil
    now = pipeline_running()
    first = {}
    for p, _ in now:
        try:
            first[p.pid] = sum(p.cpu_times()[:2])
        except psutil.Error:
            pass
    time.sleep(5)
    rows = []
    for p, args in now:
        try:
            spent, threads = sum(p.cpu_times()[:2]), p.num_threads()
        except psutil.Error:
            continue
        rows.append((pipeline_kind(args), p.pid, threads, spent, spent == first.get(p.pid), time.strftime("%I:%M %p", time.localtime(p.create_time())), args))
    print("%s; the pipeline %s; %s" % (time.strftime("%Y-%m-%d %I:%M %p"), "runs" if pipeline_driver() else "does not run", "stopped" if os.path.exists(pipeline_STOP) else "paused" if pipeline_paused() else "not paused"))
    for k, pid, threads, spent, quiet, start, args in sorted(rows):
        print("%-6s %6d %3d threads %9.0f s  from %s%s  %s" % (k, pid, threads, spent, start, " quiet" if quiet else "", args[:90]))
    counts = {}
    for r in rows:
        counts[r[0]] = counts.get(r[0], 0) + 1
    print("%d of a budget of %d: %s" % (len(rows), pipeline_STATE["budget"], counts))
    print("disk: %.0f GB free" % (shutil.disk_usage(pipeline_HOME).free / 1e9))
    try:
        got = subprocess.run(["nvidia-smi", "--query-gpu=memory.used,memory.total,utilization.gpu", "--format=csv,noheader"], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL, text=True, timeout=30).stdout.strip()
        print("card: %s" % got)
    except (OSError, subprocess.SubprocessError):
        pass
    stamp = os.path.join(pipeline_PUBLISH, "published.txt")
    if os.path.exists(stamp):
        print("published %s" % open(stamp).read().strip())
        for f in ("planets.csv", "discoveries.csv", os.path.join("planets", "companions.csv")):
            path = os.path.join(pipeline_PUBLISH, f)
            if os.path.exists(path):
                print("  %s: %d rows" % (f, sum(1 for _ in csv.DictReader(open(path, encoding="utf-8")))))
    if pipeline_STATE["peer"]:
        print("second machine: %s" % (pipeline_remote("echo $(pgrep -f '[o]rbitlight.py planets' | wc -l) processes, $(test -e ~/orbitlight/paused && echo paused || echo running)") or "does not answer"))
    log = pipeline_log("pipeline.log")
    if os.path.exists(log):
        print("".join(open(log, encoding="utf-8", errors="replace").readlines()[-8:]), end="")


def pipeline_end(pids):
    """Ctrl+C sent to every process attached to the console of each process id of PIDS, this process ignoring the event it sends, so that each ends through its own exit path; elsewhere than Windows, SIGINT to each."""
    if os.name != "nt":
        import signal
        for pid in pids:
            os.kill(pid, signal.SIGINT)
        return
    import ctypes
    k = ctypes.WinDLL("kernel32", use_last_error=True)
    k.SetConsoleCtrlHandler(None, True)
    for pid in pids:
        k.FreeConsole()
        if not k.AttachConsole(pid):
            print("%d: no console to attach (error %d)" % (pid, ctypes.get_last_error()), file=sys.stderr, flush=True)
            continue
        k.SetConsoleCtrlHandler(None, True)
        print("%d: %s" % (pid, "Ctrl+C sent to its console" if k.GenerateConsoleCtrlEvent(0, 0) else "not sent (error %d)" % ctypes.get_last_error()), file=sys.stderr, flush=True)
        time.sleep(1.0)
    k.FreeConsole()


def pipeline_cli():
    p = argparse.ArgumentParser(prog="orbitlight.py pipeline", description=pipeline_DOC, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("mode", choices=("run", "start", "watch", "stop", "pause", "resume", "toggle", "decide", "publish", "chain", "peers", "status", "end", "deploy"))
    p.add_argument("names", nargs="*", help="chain: the roots' folders or modes; peers: the roots' folders given the others' velocities, every root's by default; end: the process ids")
    p.add_argument("--budget", type=int, default=int(os.environ.get("ORBITLIGHT_BUDGET") or 16), help="the most processes of orbitlight's that run at once")
    p.add_argument("--reserve", type=int, default=3, help="those of the budget kept for the pipeline's own steps")
    p.add_argument("--ffi-share", type=float, default=2.0 / 3.0, help="the share of the TESS stage's processes on the stars only full-frame light curves hold")
    p.add_argument("--threads", type=int, default=0, help="the threads of each step on the CPU, by default all")
    p.add_argument("--peer", default=os.environ.get("ORBITLIGHT_PEER"), help="an SSH host whose TESS search is brought in")
    a = p.parse_args()
    os.makedirs(pipeline_LOGS, exist_ok=True)
    os.makedirs(pipeline_WORK, exist_ok=True)
    pipeline_STATE.update(budget=a.budget, reserve=a.reserve, ffi=a.ffi_share, threads=a.threads, peer=a.peer)
    argv = ["pipeline", "run", "--budget", str(a.budget), "--reserve", str(a.reserve), "--ffi-share", repr(a.ffi_share)] + (["--threads", str(a.threads)] if a.threads else []) + (["--peer", a.peer] if a.peer else [])
    if a.mode == "toggle":
        a.mode = "resume" if pipeline_paused() else "pause"
    if a.mode == "run":
        pipeline_run(argv)
    elif a.mode == "start":
        if pipeline_driver():
            print("the pipeline already runs", flush=True)
        else:
            pipeline_detach(argv)
            print("started", flush=True)
    elif a.mode == "watch":
        if not os.path.exists(pipeline_STOP) and not pipeline_driver():
            pipeline_detach(argv)
            pipeline_note("the pipeline started again by its watch")
    elif a.mode == "stop":
        open(pipeline_STOP, "w").write(time.strftime("%Y-%m-%d %H:%M:%S") + "\n")
        open(pipeline_PAUSE, "w").write(time.strftime("%Y-%m-%d %H:%M:%S") + "\n")
        for d in pipeline_driver():
            d.kill()
        pipeline_remote("touch ~/orbitlight/paused ~/orbitlight/stop")
        print("stopped; each process ends with its current star or candidate", flush=True)
    elif a.mode == "pause":
        open(pipeline_PAUSE, "w").write(time.strftime("%Y-%m-%d %H:%M:%S") + "\n")
        pipeline_remote("touch ~/orbitlight/paused ~/orbitlight/stop")
        print("paused; each process ends with its current star or candidate", flush=True)
    elif a.mode == "resume":
        for path in (pipeline_PAUSE, pipeline_STOP):
            if os.path.exists(path):
                os.remove(path)
        pipeline_remote("rm -f ~/orbitlight/paused")
        print("resumed; the work starts again within a minute, or at the next watch where the pipeline was stopped", flush=True)
    elif a.mode in ("decide", "publish"):
        pipeline_STATE["roots"] = pipeline_joined()
        globals()["pipeline_paused"] = lambda: False
        if a.mode == "decide":
            pipeline_decide_census(noise=False)
            pipeline_decide_tess()
        pipeline_publish()
    elif a.mode == "chain":
        for name in a.names:
            pipeline_chain(name)
    elif a.mode == "peers":
        pipeline_peers(a.names or None)
    elif a.mode == "status":
        pipeline_status()
    elif a.mode == "end":
        pipeline_end([int(x) for x in a.names])
    else:
        here = os.path.abspath(__file__)
        if os.path.exists(here + ".new"):
            os.replace(here + ".new", here)
            print("deployed", flush=True)
        if pipeline_STATE["peer"]:
            with open(pipeline_log("peer_out.txt"), "w") as fh:
                copied = subprocess.run(["scp", "-q", "-o", "BatchMode=yes", "-o", "ConnectTimeout=10", here, pipeline_STATE["peer"] + ":orbitlight/orbitlight.py"], stdout=fh, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, timeout=300).returncode == 0
            print("copied to the second machine" if copied else "the second machine does not answer", flush=True)


# the most the transit model may differ from PyTransit's in flux
selftest_MODEL_LIMIT = 2e-3


def selftest_ledger():
    """planets_ledger on a synthetic root, ORBITLIGHT_DATA an empty folder, with the archive, the spectra and the refits stubbed: a body that holds, a weak sibling that stays pending, a sibling that failed before, a companion and a body no longer new; each check a line."""
    rng = np.random.default_rng(1)
    res = planets_RESULTS
    for sub in ("ledger", "orbits", "weigh"):
        os.makedirs(os.path.join(res, sub), exist_ok=True)
    os.makedirs(planets_path("lbl"), exist_ok=True)

    def draws(P, tp, K, n=256):
        return np.column_stack([P + 1e-4 * rng.standard_normal(n), tp + 1e-3 * rng.standard_normal(n), np.zeros(n), np.full(n, math.pi / 2), K + 0.01 * K * rng.standard_normal(n)]).tolist()
    curve = lambda t, d: planets_kepler_draws(t, d).mean(0)
    # STAR1: b holds (discovered at 60000, held once already, cutoff now 60050), c is weak and pending, d failed before
    b, c, d = draws(10.0, 60001.0, 20.0), draws(37.0, 60003.0, 0.5), draws(81.0, 60007.0, 5.0)
    nights = np.array([59990.1, 60011.3, 60017.8, 60026.4, 60033.9, 60047.2, 60101.7, 60104.2, 60112.9, 60118.4, 60127.6])
    rv = curve(nights, b) + curve(nights, c) + curve(nights, d) + rng.standard_normal(len(nights))
    np.savez(planets_path("lbl", "STAR1.lbl.npz"), mjd=nights, rv=rv, rv_err=np.ones(len(nights)), cal_age=np.zeros(len(nights)))
    test = lambda cutoff, pred, n=0, s=None, es=None: dict(date="2026-01-01", cutoff_mjd=cutoff, new_nights=n, scale=s, scale_err=es, prediction=pred)
    base = dict(host="STAR1", kind="planet", found_by="census", bank_name="STAR1", form="", jitter=1.0, tag="STAR1", source="HARPS line-by-line", ra=10.0, dec=-20.0)
    entries = {"STAR1 b": dict(base, planet="STAR1 b", cutoff_mjd=60050.1, tests=[test(60000.1, "pending"), test(60000.1, "held", 5, 1.0, 0.05)], draws=b, others=[c, d]),
               "STAR1 c": dict(base, planet="STAR1 c", cutoff_mjd=60000.1, tests=[test(60000.1, "pending", 10, 0.9, 1.1)], draws=c, others=[b, d]),
               "STAR9 b": dict(base, planet="STAR9 b", bank_name="STAR9", cutoff_mjd=60000.1, tests=[test(60000.1, "pending")], draws=c, others=[]),
               "STAR1 d": dict(base, planet="STAR1 d", cutoff_mjd=60000.1, tests=[test(60000.1, "failed", 5, 0.1, 0.1)], draws=d, others=[b, c])}
    # STAR2: a companion discovered at 60000, held once already, cutoff now 60050
    B = draws(500.0, 60020.0, 3000.0)
    entries["STAR2 B"] = dict(planet="STAR2 B", host="STAR2", kind="star", found_by="companions", bank_name="STAR2", form="", jitter=10.0, tag="STAR2", source="HARPS cross-correlation", ra=30.0, dec=-40.0, cutoff_mjd=60050.1, tests=[test(60000.1, "pending"), test(60000.1, "held", 5, 1.0, 0.01)], draws=B, others=[])

    def save(path, rec, **arrays):
        planets_draws_save(path, rec, **arrays)
        json.dump(rec, open(path, "w"))
    for name, e in entries.items():
        save(os.path.join(res, "ledger", archive_tag(name) + ".json"), {k: v for k, v in e.items() if k not in ("draws", "others")}, draws=e["draws"], others=np.reshape(np.asarray(e["others"], float), (-1, 256, 5)))
    save(os.path.join(res, "orbits", "STAR1.json"), dict(planets=[dict(P=[P, P, P]) for P in (10.0, 37.0, 81.0)], jitter=dict(HARPS=[1.0, 0.9, 1.1])), draws=np.array([b, c, d]))
    save(os.path.join(res, "weigh", "STAR2.json"), dict(last_mjd=60000.1), draws=np.array(B))
    with open(os.path.join(res, "planets.csv"), "w", newline="") as fh:
        w = csv.writer(fh)
        w.writerow(["planet", "host", "kind", "found_by", "bank_name", "P_d"])
        for name, e in entries.items():
            if name != "STAR9 b":
                w.writerow([name, e["host"], e["kind"], e["found_by"], e["bank_name"], float(np.median(np.asarray(e["draws"])[:, 0]))])
    open(os.path.join(res, "signals.csv"), "w").write("name,kind,label,P\n")
    open(planets_path("bank_stars.csv"), "w").write("Name,RAJ2000,DEJ2000\nSTAR1,10.0,-20.0\nSTAR2,30.0,-40.0\n")
    # the archive: STAR1's line-by-line nights, and STAR2's nights 60010-60050 (before its cutoff) and 60100-60140 (after it)
    star2 = np.array([60010, 60020, 60030, 60040, 60050, 60100, 60110, 60120, 60130, 60140]) + 0.1
    listing = {(10.0, -20.0): [dict(dp_id="S1_%d" % i, instrument_name="HARPS", t_min=float(t) - 0.01, snr=50.0) for i, t in enumerate(nights)],
               (30.0, -40.0): [dict(dp_id="S2_%d" % i, instrument_name="HARPS", t_min=float(t) - 0.01, snr=50.0) for i, t in enumerate(star2)]}
    remeasured, calls = [], []
    mjd_of = {x["dp_id"]: x["t_min"] + 0.01 for x in listing[(30.0, -40.0)]}

    def run_all(tasks, workers=6):
        for args in tasks:
            extra = np.load(args[args.index("--extra") + 1])
            calls.append((args[0], args[1], [round(float(x), 1) for x in extra["mjd"]], sorted({round(float(x), 1) for x in extra["rv_err"]})))
            path = os.path.join(res, args[0], args[1] + ".json")
            rec = json.load(open(path))
            refit = planets_draws_load(path, rec)["draws"]
            refit[..., 4] = 999.0
            save(path, rec, draws=refit)
        return []
    globals().update(archive_eso_listings=lambda positions, inst, min_snr=10.0, radius_deg=0.01: [listing[tuple(p)] for p in positions], planets_lbl=lambda *a, **k: remeasured.append(a), archive_eso_fetch=lambda rows, folder, streams=4, most=None, best=False: [r["dp_id"] for r in rows],
                     spectra_read=lambda paths: [(None, None, None, dict(mjd=mjd_of[p])) for p in paths], binaries_line_depths=lambda spectra, v, band="optical": None,
                     binaries_velocities=lambda spectra, T, vmax=200, band="optical": (np.array([curve(np.array([s[3]["mjd"]]), B)[0] / 1000.0 for s in spectra]), np.ones(len(spectra))), planets_run_all=run_all)
    planets_ledger(workers=1, most=6)
    after = {}
    for n in (x for x in entries if x != "STAR9 b"):
        path = os.path.join(res, "ledger", archive_tag(n) + ".json")
        after[n] = json.load(open(path))
        after[n]["draws"] = planets_draws_load(path, after[n])["draws"]
    K = lambda e: float(np.median(np.asarray(e["draws"])[:, 4]))
    of = lambda star: [x for x in calls if x[1] == star]
    for label, ok in (("a body that holds is held", after["STAR1 b"]["tests"][-1]["prediction"] == "held"),
                      ("and tested on the five nights after its cutoff", after["STAR1 b"]["tests"][-1]["new_nights"] == 5),
                      ("its star refitted with the ten nights since discovery", of("STAR1") and len(of("STAR1")[0][2]) == 10),
                      ("it takes the refitted orbit", K(after["STAR1 b"]) == 999.0),
                      ("its cutoff moves to the last night", after["STAR1 b"]["cutoff_mjd"] == 60127.6),
                      ("a weak sibling stays pending", after["STAR1 c"]["tests"][-1]["prediction"] == "pending"),
                      ("and keeps its orbit", abs(K(after["STAR1 c"]) - 0.5) < 0.05),
                      ("and its cutoff", after["STAR1 c"]["cutoff_mjd"] == 60000.1),
                      ("a sibling that failed is not tested again", len(after["STAR1 d"]["tests"]) == 1),
                      ("and keeps the orbit that failed", abs(K(after["STAR1 d"]) - 5.0) < 0.5),
                      ("and its cutoff", after["STAR1 d"]["cutoff_mjd"] == 60000.1),
                      ("a companion is held", after["STAR2 B"]["tests"][-1]["prediction"] == "held"),
                      ("on the five nights after its cutoff", after["STAR2 B"]["tests"][-1]["new_nights"] == 5),
                      ("refitted with one earlier night and the five later", [x[2] for x in of("STAR2")] == [[60010.1, 60100.1, 60110.1, 60120.1, 60130.1, 60140.1]]),
                      ("the refit's errors carry its jitter", [x[3] for x in of("STAR2")] == [[10.0]]),
                      ("it takes the refitted orbit", K(after["STAR2 B"]) == 999.0),
                      ("no spectra measured again", not remeasured),
                      ("a body no longer new leaves the ledger", not any(os.path.exists(os.path.join(res, "ledger", "STAR9_b" + x)) for x in (".json", ".draws.npz")))):
        print("%s %s" % ("ok" if ok else "FAIL", label), flush=True)


def selftest_triceratops(check):
    """What this file puts in TRICERATOPS's place against TRICERATOPS's own, where it is installed, on the device or the CPU: the transit model against PyTransit's as it evaluates it, the limb-darkening choice of every star at once against its loop star by star, the likelihoods in blocks against one draw at a time, and the separations in one call against star by star."""
    try:
        planets_validate_setup()
        import triceratops.likelihoods as L
        import triceratops.marginal_likelihoods as M
    except Exception as exc:
        print("     TRICERATOPS not read (%s): its checks left out" % type(exc).__name__, flush=True)
        return
    rng = np.random.default_rng(3)
    n, t = 500, np.linspace(-0.2, 0.2, 150)
    worst, parted, off = {}, 0, 0

    def exact_z(P, a, inc, e, w):
        ea = np.arctan2(np.sqrt(1 - e * e) * np.sin(np.pi / 2 - w), e + np.cos(np.pi / 2 - w))
        M = np.mod(ea - e * np.sin(ea) + 2 * np.pi * t / P, 2 * np.pi)
        E = M.copy()
        for _ in range(100):
            E = E - (E - e * np.sin(E) - M) / (1 - e * np.cos(E))
        ta = 2 * np.arctan2(np.sqrt(1 + e) * np.sin(E / 2), np.sqrt(1 - e) * np.cos(E / 2))
        sn = np.sin(w + ta)
        z = a * (1 - e * e) / (1 + e * np.cos(ta)) * np.sqrt(np.clip(1 - sn * sn * np.sin(inc) ** 2, 0, None))
        return np.where(sn > 0, z, -z)
    for label, k_lo, k_hi, ecc_hi in (("planets, circular", 0.01, 0.2, 0.0), ("planets, eccentric", 0.01, 0.2, 0.6), ("binaries", 0.2, 0.99, 0.5)):
        k, P, a = rng.uniform(k_lo, k_hi, n), rng.uniform(1.0, 20.0, n), rng.uniform(4.0, 30.0, n)
        inc = np.arccos(rng.uniform(0.0, 1.0 + k, n) / a)
        ecc, w, u1, u2 = rng.uniform(0.0, ecc_hi, n), rng.uniform(0.0, 2 * np.pi, n), rng.uniform(0.2, 0.6, n), rng.uniform(0.0, 0.3, n)
        for exptime, ns in ((0.0, 1), (0.01, 5), (0.00139, 20)):
            L.tm.set_data(t, exptimes=exptime, nsamples=ns)
            ref = L.tm.evaluate_pv(pvp=np.array([k, np.zeros(n), P, a, inc, ecc, w]).T, ldc=np.array([u1, u2]).T)
            got = gpu_host(gpu_transit(t, k, P, a, inc, ecc, w, u1, u2, exptime, ns))
            worst[label] = max(worst.get(label, 0.0), float(np.max(np.abs(got - ref))))
            if exptime == 0.0:
                for i in np.where(np.abs(got - ref).max(1) > selftest_MODEL_LIMIT)[0]:
                    z = exact_z(P[i], a[i], inc[i], ecc[i], w[i])
                    parted, off = parted + 1, max(off, int(abs(((z >= 0) & (z < 1 + k[i])).sum() - (got[i] < 1).sum())))
    check("the transit model against PyTransit's as TRICERATOPS evaluates it, on circular orbits and binaries", worst["planets, circular"] < selftest_MODEL_LIMIT and worst["binaries"] < selftest_MODEL_LIMIT, worst)
    check("where the two part, the model holds the eclipse the orbit itself places", off <= 2, "%d orbits, %d points at most" % (parted, off))

    def loop(Zs, Teffs, loggs, u1s, u2s, teff, logg, z):
        a, b = np.zeros(len(teff)), np.zeros(len(teff))
        for i in range(len(teff)):
            T, g = Teffs[np.argmin(np.abs(Teffs - teff[i]))], loggs[np.argmin(np.abs(loggs - logg[i]))]
            these = Zs[(Teffs == T) & (loggs == g)]
            m = (Zs == these[np.argmin(np.abs(these - z[i]))]) & (Teffs == T) & (loggs == g)
            a[i], b[i] = u1s[m].item(), u2s[m].item()
        return a, b
    for band in ("T", "K"):
        tab = [getattr(M, "ldc_%s_%s" % (band, k)) for k in ("Zs", "Teffs", "loggs", "u1s", "u2s")]
        Ts, gs, Zv = np.unique(tab[1]), np.unique(tab[2]), np.unique(tab[0])
        m = 1000
        teff = np.concatenate([rng.uniform(2300, 13500, m), 0.5 * (Ts[1:] + Ts[:-1]), Ts.astype(float)])
        logg = np.concatenate([rng.uniform(2.5, 5.7, m), rng.choice(0.5 * (gs[1:] + gs[:-1]), len(Ts) - 1), rng.choice(gs, len(Ts))])
        z = np.concatenate([np.where(rng.random(m) < 0.7, 0.0, rng.uniform(Zv.min() - 0.5, Zv.max() + 0.5, m)), rng.choice(Zv, 2 * len(Ts) - 1)])
        one, every = loop(*tab, teff, logg, z), planets_ld_nearest(*tab, teff, logg, z)
        check("limb darkening of every star at once against star by star, band %s" % band, np.array_equal(one[0], every[0]) and np.array_equal(one[1], every[1]))
    planets_validate_gpu()
    n = 3000
    time_ = np.linspace(-0.2, 0.2, 150)
    flux = 1.0 - 0.001 * (np.abs(time_) < 0.05) + 2e-4 * rng.standard_normal(150)
    Rs = rng.uniform(0.5, 1.5, n)
    common = [np.full(n, 5.0), rng.uniform(86.0, 90.0, n), rng.uniform(5.0, 20.0, n) * Rs * L.Rsun, Rs, np.full(n, 0.4), np.full(n, 0.2), rng.uniform(0.0, 0.5, n), rng.uniform(0.0, 360.0, n)]
    cfr = rng.uniform(0.0, 0.3, n)
    pick = rng.choice(n, 20, replace=False)
    for label, f, lead in (("a planet", M.lnL_TP_p, [rng.uniform(1.0, 15.0, n)]), ("a binary", M.lnL_EB_p, [rng.uniform(0.05, 0.3, n), rng.uniform(1e-5, 2e-4, n)])):
        args = lead + common
        full = f(time_, flux, 2e-4, *args, companion_fluxratio=cfr, exptime=0.00139, nsamples=5)
        one = np.array([f(time_, flux, 2e-4, *[x[i:i + 1] for x in args], companion_fluxratio=cfr[i:i + 1], exptime=0.00139, nsamples=5)[0] for i in pick])
        fin = np.isfinite(one)
        far = float(np.max(np.abs(full[pick][fin] - one[fin]) / np.maximum(np.abs(one[fin]), 1e-300))) if fin.any() else 0.0
        check("the likelihoods of %s in blocks against one draw at a time" % label, np.array_equal(np.isinf(full[pick]), np.isinf(one)) and far < 1e-6, "%.1e" % far)
    from astropy.coordinates import SkyCoord
    import astropy.units as u
    ra, dec = rng.uniform(0.0, 360.0, 100), rng.uniform(-80.0, 80.0, 100)
    target = SkyCoord(ra[0], dec[0], unit="deg")
    each = [(np.round(target.separation(SkyCoord(ra[i], dec[i], unit="deg")).to(u.arcsec).value, 3), np.round(target.position_angle(SkyCoord(ra[i], dec[i], unit="deg")).to(u.deg).value, 3)) for i in range(1, 100)]
    stars = SkyCoord(ra[1:], dec[1:], unit="deg")
    check("the separations in one call against star by star", np.array_equal(np.array(each)[:, 0], np.round(target.separation(stars).to(u.arcsec).value, 3)) and np.array_equal(np.array(each)[:, 1], np.round(target.position_angle(stars).to(u.deg).value, 3)))


def selftest_cli():
    """The file's own methods checked on synthetic data, on the CPU or the device, with nothing read from any archive, and what it puts in TRICERATOPS's place where that is installed: each check a line, exit status 1 where any fails."""
    if sys.argv[1:] == ["--ledger"]:
        return selftest_ledger()
    results = []

    def check(name, ok, detail=""):
        results.append(bool(ok))
        print("%-4s %s%s" % ("ok" if ok else "FAIL", name, "  " + str(detail) if detail != "" else ""), flush=True)
    rng = np.random.default_rng(11)
    # the Keplerian curve and the eccentric anomaly
    t = np.sort(rng.uniform(0.0, 300.0, 200))
    got = gpu_host(gpu_keplerian(t[None, :], np.array([[17.3]]), np.array([[4.1]]), np.array([[0.4]]), np.array([[1.1]])))[0]
    check("Keplerian on the device against the plain one", np.max(np.abs(got - planets_kepler(t, 17.3, 4.1, 0.4, 1.1))) < 1e-9)
    # interpolation, running median, robust statistics
    xp, fp = np.sort(rng.uniform(0.0, 10.0, 50)), rng.normal(size=50)
    x = np.linspace(xp[0], xp[-1], 300)
    check("interpolation of rows against numpy", np.nanmax(np.abs(gpu_host(gpu_interp_rows(x, [xp], [fp]))[0] - np.interp(x, xp, fp))) < 1e-12)
    y = rng.normal(size=500)
    from scipy.ndimage import median_filter
    check("running median against scipy", np.max(np.abs(gpu_host(gpu_running_median(y, 21))[20:-20] - median_filter(y, 21, mode="nearest")[20:-20])) < 1e-12)
    arr = rng.normal(size=(8, 40))
    arr[rng.random(arr.shape) < 0.1] = np.nan
    check("median over finite values against numpy", np.nanmax(np.abs(gpu_host(gpu_nanmedian(arr, 0)) - np.nanmedian(arr, 0))) < 1e-12)
    # the periodogram and its false-alarm level
    t = np.sort(rng.uniform(0.0, 1000.0, 120))
    v = 5.0 * np.sin(2 * np.pi * t / 23.7) + rng.normal(0.0, 1.0, 120)
    freq = np.linspace(1.0 / 2000.0, 1.0 / 1.5, 40000)
    pw = gpu_host(gpu_gls(t, v, np.ones(120), freq))
    k = int(np.argmax(pw))
    check("periodogram finds a sinusoid", abs(1.0 / freq[k] / 23.7 - 1.0) < 0.01, "%.3f d" % (1.0 / freq[k]))
    check("false-alarm level of that peak below 1e-3", float(gpu_baluev(pw[k], freq[-1], t, np.ones(120))) < 1e-3)
    check("false-alarm level inverted", abs(float(gpu_baluev(gpu_baluev_level(1e-3, freq[-1], t, np.ones(120)), freq[-1], t, np.ones(120))) / 1e-3 - 1.0) < 1e-3)
    # least squares and the sampler
    def resid(p, idx):
        return (p[:, :1] * gpu_dev(np.sin(0.3 * np.arange(50.0)))[None, :] + p[:, 1:2] - gpu_dev(2.5 * np.sin(0.3 * np.arange(50.0)) + 1.0)[None, :])
    p, _ = gpu_lm(resid, np.zeros((3, 2)))
    check("Levenberg-Marquardt reaches a line's parameters", np.max(np.abs(gpu_host(p) - np.array([2.5, 1.0]))) < 1e-4)
    chain, accept = gpu_ensemble(lambda q: -0.5 * ((q - 3.0) ** 2).sum(1), rng.normal(3.0, 1.0, (48, 2)), 3000, seed=3)
    tail = chain[len(chain) // 2:].reshape(-1, 2)
    check("ensemble sampler reaches a Gaussian's mean and width", np.max(np.abs(tail.mean(0) - 3.0)) < 0.2 and np.max(np.abs(tail.std(0) - 1.0)) < 0.2, "acceptance %.2f" % float(np.mean(accept)))
    A = np.array([[4.0, 1.0], [1.0, 3.0]])[None, :, :]
    check("positive-definite solve", np.max(np.abs(gpu_host(gpu_solve_spd(gpu_dev(A), gpu_dev([[1.0, 2.0]]))) - np.linalg.solve(A[0], [1.0, 2.0]))) < 1e-12)
    # the transit model: a small planet's depth, the fused kernel against the tensor path, and the box search
    time_ = np.linspace(-0.2, 0.2, 201)
    flux = gpu_host(gpu_transit(time_, np.array([0.1]), np.array([5.0]), np.array([12.0]), np.array([0.5 * math.pi]), np.array([0.0]), np.array([0.5 * math.pi]), np.array([0.0]), np.array([0.0])))[0]
    check("a dark disk's depth without limb darkening", abs(1.0 - float(flux.min()) - 0.01) < 1e-4, "%.5f" % (1.0 - float(flux.min())))
    k_, P_, a_ = rng.uniform(0.01, 0.9, 256), rng.uniform(0.5, 50.0, 256), rng.uniform(3.0, 60.0, 256)
    b_ = rng.uniform(0.0, 1.0, 256)
    args_ = (time_, k_, P_, a_, np.arccos(b_ / a_), rng.uniform(0.0, 0.6, 256), rng.uniform(0.0, 6.2, 256), rng.uniform(0.0, 0.8, 256), rng.uniform(0.0, 0.3, 256))
    if gpu_DEVICE.type == "cuda" and _gpu_kernels() is not None:
        check("fused transit kernel against the tensor path", np.max(np.abs(gpu_host(gpu_transit(*args_)) - gpu_host(gpu_transit(*args_, fused=False)))) < 1e-3)
    t = np.arange(0.0, 54.0, 1.0 / 144.0)
    P, t0, D, depth = 6.37, 2.11, 3.0 / 24.0, 1200e-6
    f = 1.0 + rng.normal(0.0, 400e-6, len(t))
    f[np.abs(((t - t0) / P + 0.5) % 1.0 * P - 0.5 * P) < 0.5 * D] -= depth
    periods = planets_transit_periods(float(t.max() - t.min()), 0.5, 20.0)
    snr, dep, dur, mid = gpu_bls(t, f, np.full(len(t), 400e-6), periods, planets_TRANSIT_DURATIONS)
    k = int(np.argmax(snr))
    check("box search finds a box", abs(periods[k] / P - 1.0) < 0.002 and abs(dep[k] / depth - 1.0) < 0.2, "P %.4f, %.0f ppm, S/N %.1f" % (periods[k], 1e6 * dep[k], snr[k]))
    out = dict(signals=[], set_aside=[])
    planets_transit_peaks(out, t, f, 400e-6, np.ones(len(t), bool), periods, planets_TRANSIT_DURATIONS, 10, 9.0, 5, 10)
    g = out["signals"][0] if out["signals"] else None
    check("the search's peaks hold the box with its transits", bool(g) and abs(g["P"] / P - 1.0) < 0.002 and g["transits"] >= 7)
    if g:
        check("transits alike keep their signal without the strongest", planets_transit_left(g) >= planets_TRANSIT_LEFT, "%.3f" % planets_transit_left(g))
        odd = dict(g, events=[dict(e, snr=(e["snr"] if e["epoch"] % 2 else 0.1), depth_ppm=(e["depth_ppm"] if e["epoch"] % 2 else 10.0)) for e in g["events"]])
        check("transits on every second epoch alone read at twice the period", (planets_transit_alias(odd) or {}).get("alias") == 2)
    lone = dict(snr=20.0, events=[dict(epoch=i, snr=40.0 if i == 0 else 1.0, depth_ppm=4000.0 if i == 0 else 100.0, points=18) for i in range(9)])
    check("one strong transit among weak ones leaves little", planets_transit_left(lone) < planets_TRANSIT_LEFT)
    # the fold's shape, the ephemeris and the lone dips
    shape = planets_transit_shape([(t, f)], P, t0, D)
    check("the fold reads a box as a box", (shape["shape_box_chi2"] or 0.0) > 49.0 and not planets_transit_smooth(dict(shape, period=P, duration_h=3.0)))
    sine = 1.0 + 800e-6 * np.cos(2 * np.pi * (t - t0) / P) + rng.normal(0.0, 400e-6, len(t))
    shape2 = planets_transit_shape([(t, sine)], P, t0, D)
    check("the fold reads a sinusoid as the star's variation", (shape2["shape_sine_chi2"] or 0.0) > (shape2["shape_box_chi2"] or 0.0))
    e = planets_ephemeris([(t, f)], P * 1.001, t0 + 0.02, D, 0.005)
    check("the ephemeris measure moves to the transits", bool(e) and abs(e["P"] / P - 1.0) < 3e-4, "%.5f" % (e or {}).get("P", 0.0))
    fdip = 1.0 + rng.normal(0.0, 400e-6, len(t))
    fdip[np.abs(t - 27.0) < 3.0 / 24.0] -= 2500e-6
    z = planets_single_dips(t, fdip)
    check("the lone-dip search finds a lone dip", abs(t[np.unravel_index(int(np.nanargmax(z)), z.shape)[1]] - 27.0) < 0.2 and np.nanmax(z) > 9.0, "%.1f sigma" % np.nanmax(z))
    # the decision's arithmetic
    v = dict(fpp=0.02, nfpp=0.0002, scenarios=dict(TP=0.98, STP=0.01, BTP=0.005, EB=0.005))
    check("a planet on an unresolved star counts as a planet", abs(planets_not_planet(v) - 0.005) < 1e-12)
    check("the probabilities with no image are the record's own", abs(planets_source_cleared(dict(v, nfpp=0.0))[0] - 0.005) < 1e-12)
    near = dict(v, nfpp=0.02, scenarios=dict(TP=0.97, NEB=0.02, EB=0.01), near_probs={"7": [30.0, 10.0, 0.02]}, source=dict(chi2=100.0, star_chi2=100.0, factor=1.0, at={"7": 60.0}))
    check("an image at the star clears its neighbour", planets_source_cleared(near)[1] < 1e-3)
    far = dict(near, source=dict(chi2=100.0, star_chi2=60.0, factor=1.0, at={"7": 100.0}))
    check("an image off the star clears nothing", planets_source_cleared(far)[1] >= 0.01)
    check("a TOI's fold under its floor has no dip", planets_fold_fault(dict(dip_sigma=5.0), "TOI-1.01") and not planets_fold_fault(dict(dip_sigma=8.0), "TOI-1.01"))
    check("a Kepler candidate's floor is higher", planets_fold_fault(dict(dip_sigma=12.0), "KOI-1.01") and not planets_fold_fault(dict(dip_sigma=16.0), "KOI-1.01"))
    check("a community TOI needs its noise ratio", planets_fold_fault(dict(dip_sigma=20.0, noise_ratio=1.5), "CTOI-1.01") == "near the noise")
    check("odd and even transits against their scatter", planets_odd_even(dict(odd_even_sigma=4.0, odd_even_z=3.5)) and not planets_odd_even(dict(odd_even_sigma=4.0, odd_even_z=1.0, depth_odd_ppm=100.0, depth_even_ppm=110.0)))
    check("Gaia's velocities that move", planets_rv_moving(dict(gaia_rv_gof=5.0, gaia_rv_p=0.001)) and not planets_rv_moving(dict(gaia_rv_gof=5.0, gaia_rv_p=0.5)))
    check("Gaia's scatter leaves a star no room", planets_no_room(dict(gaia_rv_scatter=0.3, period=3.0, star_mass=1.0)) and not planets_no_room(dict(gaia_rv_scatter=30.0, period=3.0, star_mass=1.0)))
    S, teq, zone = planets_sunlight(365.25, 5772.0, 1.0, 1.0)
    check("Earth's sunlight, temperature and place", abs(S - 1.0) < 1e-3 and abs(teq - 278.6) < 0.5 and zone == "inside")
    check("the mass-radius relation inverts", abs(planets_mass_of(planets_radius_of(5.0)) - 5.0) < 1e-6)
    check("least mass of a Jupiter's orbit about the Sun", abs(planets_msini(4332.6, 12.5, 0.05, 1.0) - 1.0) < 0.03)
    told = [dict(P="8238.3", P_median="32120.3", reading="star"), dict(P="23.7", P_median="", reading="activity")]
    check("a long companion is the star a survey read at another period", planets_survey_match("companion", 19660.0, told[:1]) is told[0] and planets_survey_match("found", 19660.0, told[:1]) is None)
    check("a signal is the one a survey read within 5 per cent", planets_survey_match("found", 24.0, told) is told[1] and planets_survey_match("found", 26.0, told) is None)
    told = dict(planets=dict(drawn=100, weighed=95, validated=50, share=0.5), false_positives=dict(drawn=100, weighed=95, validated=2, share=0.02))
    planets_load_json_ = globals()["planets_load_json"]
    globals()["planets_load_json"] = lambda path: told
    check("a mission enters on a benchmark that bears it out", planets_mission_scored("koi"))
    told["false_positives"].update(validated=20, share=0.2)
    check("and not on one that does not", not planets_mission_scored("koi"))
    told["false_positives"].update(validated=2, share=0.02, weighed=40)
    check("nor on one not yet weighed", not planets_mission_scored("koi"))
    globals()["planets_load_json"] = planets_load_json_
    # the velocities' tests
    t = np.sort(rng.uniform(0.0, 2000.0, 150))
    draws = np.column_stack([np.full(64, 40.0), np.full(64, 3.0), np.zeros(64), np.zeros(64), np.full(64, 10.0)])
    vel = planets_kepler_draws(t, draws)[0] + rng.normal(0.0, 1.0, 150)
    got, _, _ = planets_second_test(t, vel, np.ones(150), np.zeros(150, int), [draws])
    check("another spectrograph's velocities hold an orbit", got[0]["verdict"] == "held", got[0])
    got, _, _ = planets_second_test(t, rng.normal(0.0, 1.0, 150), np.ones(150), np.zeros(150, int), [draws])
    check("flat velocities fail it", got[0]["verdict"] == "failed", got[0])
    moved = planets_night_mover(t, np.random.default_rng(1))(t)
    check("nights moved keep their offsets", np.max(np.abs((moved - np.floor(moved + 0.3)) - (t - np.floor(t + 0.3)))) < 1e-9)
    power = planets_kepler_power(t, 10.0 * planets_kepler(t, 83.0, 11.0, 0.6, 1.0) + rng.normal(0.0, 1.0, 150), np.ones(150), np.zeros(150, int))
    check("the Keplerian periodogram finds an eccentric orbit", abs(power["P"] / 83.0 - 1.0) < 0.02, "%.2f d, e %.2f" % (power["P"], power["e"]))
    strict = planets_strict_test(t, 5.0 * np.sin(2 * np.pi * t / 40.0) + rng.normal(0.0, 1.0, 150), np.ones(150), np.zeros(150, int), 40.0, [], draws=100)
    check("a strict sinusoid gains little from a window", strict["level"] > 0.01, strict)
    fading = np.exp(-0.5 * ((t - 1000.0) / 150.0) ** 2) * 8.0 * np.sin(2 * np.pi * t / 40.0) + rng.normal(0.0, 1.0, 150)
    check("a signal that fades does", planets_strict_test(t, fading, np.ones(150), np.zeros(150, int), 40.0, [], draws=100)["level"] < 0.05)
    t = np.sort(rng.uniform(0.0, 1500.0, 150))
    v = 4.0 * np.sin(2 * np.pi * t / 19.0) + 3.0 * np.sin(2 * np.pi * t / 61.0) + rng.normal(0.0, 1.0, 150)
    peaks = planets_sparse_peaks(t, v, np.ones(150), np.ones((150, 1)), np.arange(1.0 / 3000.0, 1.0 / 1.5, 1.0 / 6000.0), iters=200)
    check("the l1 periodogram finds both sinusoids", any(abs(1.0 / f_ / 19.0 - 1.0) < 0.02 for f_ in peaks) and any(abs(1.0 / f_ / 61.0 - 1.0) < 0.05 for f_ in peaks), [round(1.0 / f_, 2) for f_ in peaks[:4]])
    # Gaia's epochs
    n = 70
    d = dict(t=np.sort(rng.uniform(-2.7, 2.7, n)), sin=np.sin(rng.uniform(0.0, 6.28, n)), f=rng.normal(0.0, 0.7, n), e=np.full(n, 0.05), excess_noise=0.0)
    d["cos"] = np.sqrt(1.0 - d["sin"] ** 2) * np.where(rng.random(n) < 0.5, 1.0, -1.0)
    Ea = gpu_host(gpu_anomaly(gpu_dev(d["t"] * 365.25)[None, :], gpu_dev([[300.0]]), gpu_dev([[10.0]]), gpu_dev([[0.2]])))[0]
    X_, Y_ = np.cos(Ea) - 0.2, math.sqrt(1.0 - 0.04) * np.sin(Ea)
    d["w"] = (0.5 * X_ - 0.3 * Y_) * d["sin"] + (0.2 * X_ + 0.6 * Y_) * d["cos"] + 2.0 * d["f"] + rng.normal(0.0, 0.05, n)
    got = planets_epochs_power(d)
    check("the epochs' periodogram finds an astrometric orbit", abs(got["P"] / 300.0 - 1.0) < 0.05 and got["share"] > 0.7, "%.1f d, share %.2f" % (got["P"], got["share"]))
    # a star's activity modelled: a planet beside a rotating star's activity, the activity alone, and a signal the indicator shares
    ra = np.random.default_rng(21)
    ta = np.sort(ra.uniform(0.0, 700.0, 160))
    act = np.linalg.cholesky(planets_qp_kernel(ta, 1.0, 45.0, 0.6, 27.0) + 1e-9 * np.eye(160)) @ ra.standard_normal(160)
    ind = act + ra.normal(0.0, 0.15, 160)
    planet, ea, ga = 2.5 * np.sin(2 * np.pi * ta / 11.7), np.ones(160), np.zeros(160, int)
    got = planets_activity_test(ta, 3.0 * act + planet + ra.normal(0.0, 1.0, 160), ea, ga, [("FWHM", ind)], 11.7, draws=100)
    check("a planet beside its star's activity holds once the activity is modelled", got["verdict"] == "held", planets_activity_text(got))
    got = planets_activity_test(ta, 3.0 * act + ra.normal(0.0, 1.0, 160), ea, ga, [("FWHM", ind)], 11.7, draws=100)
    check("the activity alone holds nothing there", got["verdict"] == "failed", planets_activity_text(got))
    got = planets_activity_test(ta, 3.0 * act + planet + ra.normal(0.0, 1.0, 160), ea, ga, [("FWHM", ind + 0.75 * np.sin(2 * np.pi * ta / 11.7))], 11.7, draws=100)
    check("nor a signal its indicator shares", got["verdict"] == "failed", planets_activity_text(got))
    check("a vet record's indicators read from their columns", [planets_indicator_column(k) for k in ("bank CRX", "DACE S", "line-by-line H alpha", "bank NaD1")] == [4, 0, 1, None])
    check("a small star's search tries the short transits", min(planets_transit_durations(0.3)) < 1.0 / 24.0 and min(planets_transit_durations(1.0)) >= 1.0 / 24.0)
    # the readers
    check("a star's name as SIMBAD knows it", "TOI-123" in planets_name_forms("TOI00123") and "GJ 876" in planets_name_forms("GL876"))
    check("a position from ExoFOP's row", np.allclose(planets_radec({"RA": "12:00:00", "Dec": "-30:30:00"}), (180.0, -30.5)))
    curve = planets_contrast_curve("sep contrast\n0.1 2.0\n0.2 3.5\n0.5 5.0\n1.0 6.0\n", "star-832-x.dat", set())
    check("a contrast curve's band and rows", curve is not None and curve[0] == "TESS" and len(curve[1]) == 4)
    check("the limb-darkening lookup", np.allclose(planets_ld_lookup(np.array([5000.0, 6000.0]), np.array([4.5, 4.0]), np.array([0.1, 0.2]), np.array([0.3, 0.4]), np.array([6000.0]), np.array([4.0])), ([0.2], [0.4])))
    check("the zero point's curve", np.nanmax(np.abs(planets_zero_curve(np.repeat(np.arange(40), 30), np.tile(np.linspace(0.0, 1000.0, 30), 40), rng.normal(0.0, 1.0, 1200) + np.tile(np.linspace(0.0, 1000.0, 30) * 0.01, 40), np.ones(1200))[1])) < 8.0)
    # what the publication leaves out
    windows, posix, address = chr(92).join(("C:", "Us" + "ers", "someone", "data", "a.fits")), "/".join(("", "ho" + "me", "someone", "b.fits")), ".".join(("192", "168", "1", "5"))
    text = json.dumps(dict(note="FileNotFoundError: %s and %s" % (windows, posix)))
    check("an absolute path cut to its last part", "someone" not in publish_PATH.sub(r"\1", text) and "a.fits" in publish_PATH.sub(r"\1", text))
    hits = publish_scan_text("a path %s, an address %s, a token hf_%s and nothing else" % (windows, address, "a" * 30))
    check("the scan finds a home path, an address and a token", len(hits) >= 3, len(hits))
    # the ledger in a process of its own, on a root of its own, since the root's paths are read on import
    import tempfile
    with tempfile.TemporaryDirectory() as folder:
        out = os.path.join(folder, "out.txt")
        with open(out, "w") as fh:
            subprocess.run([sys.executable, os.path.abspath(__file__), "selftest", "--ledger"], env=dict(os.environ, ORBITLIGHT_DATA=os.path.join(folder, "data"), ORBITLIGHT_RESULTS=os.path.join(folder, "data", "results")), stdout=fh, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL)
        lines = open(out, encoding="utf-8", errors="replace").read().splitlines()
    marks = [x for x in lines if x.startswith(("ok ", "FAIL "))]
    for x in marks:
        check("the ledger: " + x.split(" ", 1)[1], x.startswith("ok "))
    check("the ledger's checks all ran", len(marks) == 18, "" if len(marks) == 18 else "; ".join(lines[-4:])[:400])
    selftest_triceratops(check)
    failed = sum(1 for x in results if not x)
    print("%d checks, %d failed" % (len(results), failed), flush=True)
    sys.exit(1 if failed else 0)


def main():
    if len(sys.argv) < 2 or sys.argv[1] not in ("transits", "giants", "companions", "binaries", "eclipses", "planets", "solar", "publish", "pipeline", "selftest"):
        sys.exit(__doc__)
    mode, rest = sys.argv[1], sys.argv[2:]
    sys.argv = ["orbitlight.py " + mode] + rest
    if mode == "transits":
        transits_cli()
    elif mode == "giants":
        giants_cli()
    elif mode == "binaries":
        binaries_cli()
    elif mode == "eclipses":
        eclipses_cli()
    elif mode == "planets":
        planets_cli()
    elif mode == "solar":
        solar_cli()
    elif mode == "publish":
        publish_cli()
    elif mode == "pipeline":
        pipeline_cli()
    elif mode == "selftest":
        selftest_cli()
    else:
        companions_cli()


if __name__ == "__main__":
    main()