gnsskit 0.4.0__py3-none-any.whl

gnsskit/rtklib/config.py

@@ -0,0 +1,313 @@
+"""Typed configuration of RTKLIB rnx2rtkp: `RtkConfig` and the GNSS system masks."""
+# ruff: noqa: RUF009  (`_opt(...)` in dataclass defaults is intentional)
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field, fields, replace
+from pathlib import Path
+from typing import Any, Literal, get_args, get_origin, get_type_hints
+
+# Bit values of the `pos1-navsys` mask; the mask is the sum over the chosen systems.
+NAVSYS_BITS = {"G": 1, "S": 2, "R": 4, "E": 8, "J": 16, "C": 32, "I": 64}
+
+
+def navsys_mask(systems: str) -> int:
+    """RTKLIB navsys bitmask from system letters, e.g. 'GEC' -> 41.
+
+    Args:
+        systems: Letters from G (GPS), S (SBAS), R (GLONASS), E (Galileo), J (QZSS),
+            C (BeiDou), I (NavIC); case-insensitive.
+
+    Returns:
+        Sum of the bit values of the chosen systems.
+
+    Raises:
+        ValueError: If a letter is not a known system.
+    """
+    try:
+        return sum(NAVSYS_BITS[s] for s in set(systems.upper()))
+    except KeyError as e:
+        raise ValueError(
+            f"unknown GNSS system {e}; use letters from {''.join(NAVSYS_BITS)}"
+        ) from None
+
+
+# Allowed values of the enum-like options (checked in RtkConfig.__post_init__)
+PosMode = Literal["single", "dgps", "kinematic", "static", "static-start", "fixed"]
+Frequency = Literal["l1", "l1+l2", "l1+l2+l5", "l1+l2+l5+l6"]
+SolType = Literal["forward", "backward", "combined", "combined-nophasereset"]
+IonoOpt = Literal["off", "brdc", "sbas", "dual-freq", "est-stec", "ionex-tec", "qzs-brdc"]
+TropOpt = Literal["off", "saas", "sbas", "est-ztd", "est-ztdgrad"]
+SatEph = Literal["brdc", "precise", "brdc+sbas", "brdc+ssrapc", "brdc+ssrcom"]
+ArMode = Literal["off", "continuous", "instantaneous", "fix-and-hold"]
+GloArMode = Literal["off", "on", "autocal", "fix-and-hold"]
+PosType = Literal["llh", "xyz", "single", "posfile", "rinexhead", "rtcm"]
+SolFormat = Literal["llh", "xyz", "enu", "nmea"]
+TimeSys = Literal["gpst", "utc", "jst"]
+OutStat = Literal["off", "state", "residual"]
+TimeForm = Literal["tow", "hms"]
+DegForm = Literal["deg", "dms"]
+HeightType = Literal["ellipsoidal", "geodetic"]
+GeoidModel = Literal["internal", "egm96", "egm08_2.5", "egm08_1", "gsi2000"]
+
+# Tuple-valued options expand to three RTKLIB keys (ant1 = rover, ant2 = base)
+Triple = tuple[float, float, float]
+_ROVER_POS = ("ant1-pos1", "ant1-pos2", "ant1-pos3")
+_BASE_POS = ("ant2-pos1", "ant2-pos2", "ant2-pos3")
+_ROVER_ANTDEL = ("ant1-antdele", "ant1-antdeln", "ant1-antdelu")
+_BASE_ANTDEL = ("ant2-antdele", "ant2-antdeln", "ant2-antdelu")
+
+
+def _opt(key: str | tuple[str, ...], default: object = None) -> Any:
+    """Config field mapped to one RTKLIB key, or to several for tuple values."""
+    return field(default=default, metadata={"key": key})
+
+
+def _literal_values(hint: Any) -> tuple[str, ...]:
+    """Allowed strings of a (possibly Optional) Literal type hint; empty otherwise."""
+    if get_origin(hint) is Literal:
+        return get_args(hint)
+    return sum((_literal_values(a) for a in get_args(hint)), ())
+
+
+def _render(value: object) -> str:
+    """Value as written in a .conf file (bools become on/off)."""
+    return "on" if value is True else "off" if value is False else str(value)
+
+
+@dataclass(frozen=True)
+class RtkConfig:
+    """Typed rnx2rtkp options. `None` leaves the option at RTKLIB's default (not written).
+
+    Defaults are a static, dual-frequency, short-baseline setup (GPS+Galileo). Make
+    variants with `.updated(elmask=10)`; options without a field go in `extra` as raw
+    RTKLIB keys (e.g. `extra={"stats-eratio1": "300"}`) and override the fields.
+    """
+
+    # --- processing (pos1) ---
+    posmode: PosMode | None = _opt("pos1-posmode", "static")
+    frequency: Frequency | None = _opt("pos1-frequency", "l1+l2")
+    soltype: SolType | None = _opt("pos1-soltype", "forward")
+    elmask: float | None = _opt("pos1-elmask", 15.0)  # deg
+    dynamics: bool | None = _opt("pos1-dynamics", False)  # receiver dynamics model
+    ionoopt: IonoOpt | None = _opt("pos1-ionoopt", "brdc")
+    tropopt: TropOpt | None = _opt("pos1-tropopt", "saas")
+    sateph: SatEph | None = _opt("pos1-sateph", "brdc")
+    sat_pcv: bool | None = _opt("pos1-posopt1", True)  # satellite antenna PCO/PCV
+    rcv_pcv: bool | None = _opt("pos1-posopt2", True)  # receiver antenna PCO/PCV
+    phase_windup: bool | None = _opt("pos1-posopt3")
+    exclude_eclipse: bool | None = _opt("pos1-posopt4")  # drop eclipsing satellites
+    exclsats: str | None = _opt("pos1-exclsats")  # e.g. "G04 +E11" (+ = force include)
+    snrmask_r: bool | None = _opt("pos1-snrmask_r")  # rover SNR mask
+    snrmask_b: bool | None = _opt("pos1-snrmask_b")  # base SNR mask
+    # System letters (see NAVSYS_BITS) or an integer bitmask
+    navsys: str | int | None = _opt("pos1-navsys", "GE")
+
+    # --- ambiguity resolution and filter (pos2) ---
+    armode: ArMode | None = _opt("pos2-armode", "continuous")
+    gloarmode: GloArMode | None = _opt("pos2-gloarmode", "off")
+    bdsarmode: bool | None = _opt("pos2-bdsarmode")
+    arthres: float | None = _opt("pos2-arthres", 3.0)  # ratio-test threshold
+    arelmask: float | None = _opt("pos2-arelmask", 15.0)  # deg, min elevation for AR
+    arlockcnt: int | None = _opt("pos2-arlockcnt")
+    arminfix: int | None = _opt("pos2-arminfix")  # consecutive fixes before hold
+    minfixsats: int | None = _opt("pos2-minfixsats", 4)
+    minholdsats: int | None = _opt("pos2-minholdsats")
+    mindropsats: int | None = _opt("pos2-mindropsats")
+    slipthres: float | None = _opt("pos2-slipthres")  # m, cycle-slip threshold
+    maxage: float | None = _opt("pos2-maxage")  # s, max base-rover time difference
+    syncsol: bool | None = _opt("pos2-syncsol")
+    timeinterp: bool | None = _opt("misc-timeinterp")  # interpolate base obs to rover epochs
+
+    # --- observation and process noise (stats) ---
+    eratio1: float | None = _opt("stats-eratio1")  # code/phase error ratio, L1
+    eratio2: float | None = _opt("stats-eratio2")  # code/phase error ratio, L2
+    errphase: float | None = _opt("stats-errphase")  # m, phase error, constant term
+    errphaseel: float | None = _opt("stats-errphaseel")  # m, elevation-dependent term
+    errphasebl: float | None = _opt("stats-errphasebl")  # m/10km, baseline term
+    prnbias: float | None = _opt("stats-prnbias")  # ambiguity process noise
+    prniono: float | None = _opt("stats-prniono")
+    prntrop: float | None = _opt("stats-prntrop")
+
+    # --- antennas and positions ---
+    rover_anttype: str | None = _opt("ant1-anttype", "*")  # "*" = from RINEX header
+    base_anttype: str | None = _opt("ant2-anttype", "*")
+    rover_postype: PosType | None = _opt("ant1-postype")
+    rover_pos: Triple | None = _opt(_ROVER_POS)
+    base_postype: PosType | None = _opt("ant2-postype", "rinexhead")
+    base_pos: Triple | None = _opt(_BASE_POS)
+    # Marker -> ARP offset (E, N, U) in m; "*" antenna types read it from the RINEX header
+    rover_antdel: Triple | None = _opt(_ROVER_ANTDEL)
+    base_antdel: Triple | None = _opt(_BASE_ANTDEL)
+    satantfile: str | None = _opt("file-satantfile")  # ANTEX files
+    rcvantfile: str | None = _opt("file-rcvantfile")
+
+    # --- output ---
+    solformat: SolFormat | None = _opt("out-solformat", "xyz")
+    outhead: bool | None = _opt("out-outhead", True)
+    outopt: bool | None = _opt("out-outopt")  # also print the options in the header
+    timesys: TimeSys | None = _opt("out-timesys", "gpst")
+    timeform: TimeForm | None = _opt("out-timeform")
+    timendec: int | None = _opt("out-timendec")  # decimals of the time
+    degform: DegForm | None = _opt("out-degform")
+    height: HeightType | None = _opt("out-height")
+    geoid: GeoidModel | None = _opt("out-geoid")
+    outstat: OutStat | None = _opt("out-outstat")
+    # "on": write the single-point solution at epochs where the RTK solution fails (outage)
+    outsingle: Literal["on", "off"] | None = _opt("out-outsingle", "off")
+    # static modes: "all" epochs (cumulative solution) or "single", only the final solution (one line, time-tagged at the first epoch of the processed span)
+    solstatic: Literal["all", "single"] | None = _opt("out-solstatic")
+
+    # --- anything else, as raw RTKLIB keys ---
+    extra: Mapping[str, str] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Reject values outside a field's Literal choices."""
+        hints = get_type_hints(type(self))
+        for f in fields(self):
+            allowed = _literal_values(hints[f.name])
+            value = getattr(self, f.name)
+            if allowed and value is not None and value not in allowed:
+                raise ValueError(f"{f.name}={value!r}: expected one of {allowed}")
+
+    # --- construction ---
+
+    @classmethod
+    def empty(cls) -> RtkConfig:
+        """Config with every field unset: only what is added to it is written.
+
+        Returns:
+            The empty config.
+        """
+        unset: dict[str, Any] = {f.name: None for f in fields(cls) if f.name != "extra"}
+        return cls(**unset)
+
+    @classmethod
+    def kinematic(cls) -> RtkConfig:
+        """Defaults for a moving rover: kinematic mode, forward+backward combined.
+
+        Returns:
+            The config.
+        """
+        return cls(posmode="kinematic", soltype="combined", timeinterp=True)
+
+    @classmethod
+    def from_file(cls, path: Path | str, defaults: RtkConfig | None = None) -> RtkConfig:
+        """Load an RTKLIB .conf file into `extra`, on top of `defaults`.
+
+        Args:
+            path: RTKLIB .conf file; `#` comments are ignored.
+            defaults: Config to start from. `RtkConfig()` if None; pass `RtkConfig.empty()`
+                to get only the keys of the file.
+
+        Returns:
+            The config; keys of the file override the same keys already in `defaults.extra`.
+        """
+        extra = {}
+        for line in Path(path).read_text().splitlines():
+            line = line.split("#", 1)[0].strip()
+            if "=" in line:
+                key, value = line.split("=", 1)
+                extra[key.strip()] = value.strip()
+        base = cls() if defaults is None else defaults
+        return replace(base, extra={**base.extra, **extra})
+
+    def updated(self, **changes: Any) -> RtkConfig:
+        """Copy with some fields changed.
+
+        Raw keys in `extra` (e.g. loaded by `from_file`) that map to a changed field are dropped,
+        so the new value wins over them.
+
+        Args:
+            **changes: Field names and new values.
+
+        Returns:
+            The new config.
+
+        Raises:
+            ValueError: If a value is not allowed for its field.
+        """
+        keys: set[str] = set()
+        for f in fields(self):
+            if f.name in changes:
+                key = f.metadata["key"]
+                keys.update([key] if isinstance(key, str) else key)
+        extra = {k: v for k, v in self.extra.items() if k not in keys}
+        return replace(self, **changes, extra=extra)
+
+    def with_options(self, options: Mapping[str, object]) -> RtkConfig:
+        """Copy with raw RTKLIB keys set (they override the fields).
+
+        Args:
+            options: RTKLIB key -> value, e.g. {"pos2-armode": "fix-and-hold"}.
+
+        Returns:
+            The new config.
+        """
+        extra = {**self.extra, **{k: _render(v) for k, v in options.items()}}
+        return replace(self, extra=extra)
+
+    def with_base_llh(
+        self, lat: float, lon: float, h: float, antenna_h: float | None = None
+    ) -> RtkConfig:
+        """Copy with the base at the given geodetic position.
+
+        Args:
+            lat: Latitude [deg].
+            lon: Longitude [deg].
+            h: Ellipsoidal height [m].
+            antenna_h: Vertical offset marker -> ARP [m]. It has no effect with
+                `base_anttype="*"`, where RTKLIB reads it from the RINEX header.
+
+        Returns:
+            The new config.
+        """
+        changes: dict[str, Any] = {"base_postype": "llh", "base_pos": (lat, lon, h)}
+        if antenna_h is not None:
+            changes["base_antdel"] = (0.0, 0.0, antenna_h)
+        return self.updated(**changes)
+
+    @property
+    def has_base_position(self) -> bool:
+        """Whether the base coordinates are set, via `base_pos` or raw `ant2-pos*` keys."""
+        return self.base_pos is not None or all(
+            k in self.extra for k in ("ant2-pos1", "ant2-pos2", "ant2-pos3")
+        )
+
+    # --- output ---
+
+    @property
+    def options(self) -> dict[str, str]:
+        """RTKLIB `key -> value` strings: set fields in declaration order, then `extra`."""
+        opts: dict[str, str] = {}
+        for f in fields(self):
+            value = getattr(self, f.name)
+            if f.name == "extra" or value is None:
+                continue
+            key = f.metadata["key"]
+            if isinstance(key, tuple):
+                opts.update({k: _render(v) for k, v in zip(key, value, strict=True)})
+            elif key == "pos1-navsys" and isinstance(value, str):
+                opts[key] = str(navsys_mask(value))
+            else:
+                opts[key] = _render(value)
+        return {**opts, **self.extra}
+
+    def to_text(self) -> str:
+        """The .conf file content, one `key =value` line per option."""
+        return "".join(f"{k:<19}={v}\n" for k, v in self.options.items())
+
+    def write(self, path: Path | str) -> Path:
+        """Write the .conf file (creating parent directories).
+
+        Args:
+            path: Output file.
+
+        Returns:
+            The output path.
+        """
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(self.to_text())
+        return path

gnsskit/rtklib/pos.py

@@ -0,0 +1,158 @@
+"""Reading RTKLIB .pos solution files."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from ..refsys import GPST_UTC_OFFSET_S, gps_seconds, utc_to_gpst
+
+# .pos output formats (`out-solformat`). Column names for the coordinates and for the
+# 6 covariance terms (3 standard deviations + 3 covariances), as printed by RTKLIB.
+POS_COORD_COLS = {
+    "llh": ["lat", "lon", "h"],
+    "xyz": ["x", "y", "z"],
+    "enu": ["e", "n", "u"],
+}
+POS_SD_COLS = {
+    "llh": ["sdn", "sde", "sdu", "sdne", "sdeu", "sdun"],
+    "xyz": ["sdx", "sdy", "sdz", "sdxy", "sdyz", "sdzx"],
+    "enu": ["sde", "sdn", "sdu", "sden", "sdnu", "sdue"],
+}
+# First coordinate label in the .pos column header -> format
+POS_FORMAT_BY_HEADER = {
+    "latitude(deg)": "llh",
+    "x-ecef(m)": "xyz",
+    "e-baseline(m)": "enu",
+}
+
+
+def _pos_header(path: Path) -> tuple[str, str]:
+    """Time system ('GPST' or 'UTC') and coordinate format ('llh', 'xyz', 'enu') of a .pos.
+
+    Raises ValueError for unsupported formats (e.g. degrees-minutes-seconds, JST). Without
+    a column header line (out-outhead=off) the RTKLIB default is assumed: GPST, llh in deg.
+    """
+    with path.open() as f:
+        for line in f:
+            if not line.startswith("%"):
+                break
+            tokens = line.lstrip("% ").split()
+            # The column header is the only comment line that starts with a time system
+            if len(tokens) < 2 or tokens[0].upper() not in ("GPST", "UTC", "JST"):
+                continue
+            tsys = tokens[0].upper()
+            if tsys == "JST":
+                raise ValueError(f"{path}: unsupported time system JST, use GPST or UTC")
+            if tokens[1] not in POS_FORMAT_BY_HEADER:
+                raise ValueError(
+                    f"{path}: unsupported coordinate format '{tokens[1]}', "
+                    "use llh (deg), xyz or enu"
+                )
+            return tsys, POS_FORMAT_BY_HEADER[tokens[1]]
+    return "GPST", "llh"
+
+
+def read_pos(
+    paths: Path | str | Sequence[Path | str], leap_s: int = GPST_UTC_OFFSET_S
+) -> pd.DataFrame:
+    """Read one or more RTKLIB .pos files into a time-sorted DataFrame.
+
+    The coordinate format is detected from the header: llh (lat, lon, h), xyz (x, y, z) or
+    enu (e, n, u), with the matching covariance columns (see POS_SD_COLS), and stored in
+    `df.attrs["format"]`. Only `out-timeform=hms` is supported. Files with no solution rows
+    are skipped.
+
+    Args:
+        paths: One .pos file or a sequence of them.
+        leap_s: GPST - UTC [s], used to shift UTC files to GPST.
+
+    Returns:
+        DataFrame with the coordinates, Q, ns, the covariance columns, age and ratio, plus
+        `t` (GPST timestamp) and `gps_s` (seconds since the GPS epoch). May be empty.
+
+    Raises:
+        ValueError: If the files mix coordinate formats, or use dms or JST.
+    """
+    files = [Path(paths)] if isinstance(paths, (str, Path)) else [Path(p) for p in paths]
+    headers = {p: _pos_header(p) for p in files}
+    formats = {fmt for _, fmt in headers.values()}
+    if len(formats) > 1:
+        raise ValueError(f"cannot mix .pos coordinate formats: {sorted(formats)}")
+    fmt = formats.pop() if formats else "llh"
+    names = [
+        "date", "time", *POS_COORD_COLS[fmt], "Q", "ns", *POS_SD_COLS[fmt], "age", "ratio"
+    ]  # fmt: skip
+
+    frames = []
+    for p, (tsys, _) in headers.items():
+        try:
+            df = pd.read_csv(p, comment="%", sep=r"\s+", header=None, names=names)
+        except pd.errors.EmptyDataError:
+            continue
+        df["t"] = pd.to_datetime(df.date + " " + df.time)
+        if tsys == "UTC":
+            df["t"] = utc_to_gpst(df["t"], leap_s)
+        frames.append(df)
+    if frames:
+        out = pd.concat(frames, ignore_index=True).sort_values("t").reset_index(drop=True)
+        out["gps_s"] = gps_seconds(out["t"])
+    else:
+        out = pd.DataFrame(columns=[*names, "t", "gps_s"])
+    out.attrs["format"] = fmt
+    return out
+
+
+def read_header(path: Path | str) -> list[str]:
+    """The `%` header lines of a .pos file.
+
+    Args:
+        path: RTKLIB .pos file.
+
+    Returns:
+        The header lines, without line endings.
+    """
+    return [ln.rstrip("\r\n") for ln in Path(path).read_text().splitlines() if ln.startswith("%")]
+
+
+def read_ref_pos(path: Path | str) -> np.ndarray:
+    """Base position printed in the `% ref pos` header line of an xyz .pos file.
+
+    Args:
+        path: RTKLIB .pos file written with `out-outhead=on`.
+
+    Returns:
+        (3,) ECEF coordinates [m]; for a baseline run these are the base coordinates.
+
+    Raises:
+        ValueError: If there is no `% ref pos` header line.
+    """
+    with Path(path).open() as f:
+        for line in f:
+            if not line.startswith("%"):
+                break
+            if line.startswith("% ref pos"):
+                return np.array(line.split(":", 1)[1].split(), dtype=float)
+    raise ValueError(f"{path}: no '% ref pos' header line (needs out-outhead=on)")
+
+
+def pos_covariance(row: pd.Series | Mapping[str, float], fmt: str = "xyz") -> np.ndarray:
+    """3x3 covariance of one .pos solution epoch from its standard-deviation columns.
+
+    RTKLIB prints each off-diagonal term as sign(cov) * sqrt(|cov|), so it is squared back
+    here. The axes follow the coordinate columns of the format: X, Y, Z for xyz; N, E, U for
+    llh; E, N, U for enu.
+
+    Args:
+        row: One epoch of a `read_pos` table (any mapping with the `POS_SD_COLS[fmt]` keys).
+        fmt: .pos format, "xyz", "llh" or "enu".
+
+    Returns:
+        (3, 3) covariance [m^2].
+    """
+    s1, s2, s3, s12, s23, s31 = (float(row[c]) for c in POS_SD_COLS[fmt])
+    c12, c23, c31 = (np.sign(v) * v**2 for v in (s12, s23, s31))
+    return np.array([[s1**2, c12, c31], [c12, s2**2, c23], [c31, c23, s3**2]])

gnsskit/rtklib/runner.py

@@ -0,0 +1,146 @@
+"""Running the RTKLIB rnx2rtkp executable: locate it, build the command line, run it."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections.abc import Sequence
+from pathlib import Path
+
+import pandas as pd
+
+from .config import RtkConfig
+
+RTKLIB_URL = "https://github.com/rtklibexplorer/RTKLIB"
+
+
+def install_hint() -> str:
+    """How to install rnx2rtkp on the current platform."""
+    if sys.platform == "win32":
+        return (
+            f"Download an RTKLIB release (demo5 recommended: {RTKLIB_URL}/releases), "
+            "unzip it, and add the folder containing rnx2rtkp.exe to your PATH, "
+            "or pass --exe C:\\path\\to\\rnx2rtkp.exe."
+        )
+    return (
+        f"Build it from source (demo5 recommended):\n"
+        f"  git clone {RTKLIB_URL}\n"
+        "  cd RTKLIB/app/consapp/rnx2rtkp/gcc && make && sudo make install\n"
+        "or copy the binary to a folder on your PATH. Debian/Ubuntu may also offer an "
+        "older build (sudo apt install rtklib). Alternatively pass --exe /path/to/rnx2rtkp."
+    )
+
+
+def find_rnx2rtkp(exe: str = "rnx2rtkp") -> str:
+    """Resolve the rnx2rtkp executable on PATH.
+
+    Args:
+        exe: Executable name or path.
+
+    Returns:
+        Absolute path of the executable.
+
+    Raises:
+        FileNotFoundError: If the executable is not found (the message has install hints).
+    """
+    path = shutil.which(exe)
+    if path is None:
+        raise FileNotFoundError(f"'{exe}' not found on PATH. {install_hint()}")
+    return path
+
+
+def _fmt_time(t: pd.Timestamp) -> list[str]:
+    """Timestamp as the [date, time] argument pair rnx2rtkp expects."""
+    return [t.strftime("%Y/%m/%d"), t.strftime("%H:%M:%S")]
+
+
+def build_command(
+    conf: Path | str,
+    rover: Path | str,
+    base: Path | str,
+    nav: Sequence[Path | str],
+    out: Path | str,
+    start: pd.Timestamp | None = None,
+    end: pd.Timestamp | None = None,
+    exe: str = "rnx2rtkp",
+    tint: float | None = None,
+) -> list[str]:
+    """Build the rnx2rtkp command line.
+
+    Argument order is rover observations, base observations, then navigation files.
+
+    Args:
+        conf: RTKLIB configuration file (`-k`).
+        rover: Rover RINEX observation file.
+        base: Base RINEX observation file.
+        nav: Navigation, precise orbit (SP3) and clock (CLK) files; rnx2rtkp tells them
+            apart by file extension.
+        out: Output .pos file (`-o`).
+        start: Processing start time, GPST (`-ts`). None for the start of the data.
+        end: Processing end time, GPST (`-te`). None for the end of the data.
+        exe: rnx2rtkp executable.
+        tint: Processing interval [s] (`-ti`). None for every epoch.
+
+    Returns:
+        The command as a list of arguments.
+    """
+    cmd = [exe, "-k", str(conf)]
+    if start is not None:
+        cmd += ["-ts", *_fmt_time(start)]
+    if end is not None:
+        cmd += ["-te", *_fmt_time(end)]
+    if tint is not None:
+        cmd += ["-ti", str(tint)]
+    return cmd + ["-o", str(out), str(rover), str(base), *map(str, nav)]
+
+
+def run_rnx2rtkp(
+    rover: Path | str,
+    base: Path | str,
+    nav: Sequence[Path | str],
+    config: RtkConfig,
+    out: Path | str,
+    *,
+    start: pd.Timestamp | None = None,
+    end: pd.Timestamp | None = None,
+    tint: float | None = None,
+    exe: str = "rnx2rtkp",
+) -> Path:
+    """Run rnx2rtkp on a rover/base pair and return the output .pos path.
+
+    The config is written to a temporary file for the run. A zero exit code does not
+    guarantee a solution: with e.g. missing precise products rnx2rtkp may write a .pos file
+    with no epochs, which `read_pos` returns as an empty DataFrame.
+
+    Args:
+        rover: Rover RINEX observation file.
+        base: Base RINEX observation file.
+        nav: Navigation files (broadcast), and precise orbit (SP3) and clock (CLK) files when
+            `config.sateph` is "precise".
+        config: RTKLIB processing options.
+        out: Output .pos file; parent directories are created.
+        start: Processing start time, GPST. None for the start of the data.
+        end: Processing end time, GPST. None for the end of the data.
+        tint: Processing interval [s]; decimates the processing, needed when rover and base
+            sampling differ. None for every epoch.
+        exe: rnx2rtkp executable name or path.
+
+    Returns:
+        Path of the written .pos file (`out`).
+
+    Raises:
+        FileNotFoundError: If the executable is not found.
+        RuntimeError: If rnx2rtkp exits with a non-zero code.
+    """
+    exe = find_rnx2rtkp(exe)
+    out = Path(out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory() as tmp:
+        conf = config.write(Path(tmp) / "rtk.conf")
+        cmd = build_command(conf, rover, base, nav, out, start, end, exe, tint)
+        proc = subprocess.run(cmd, check=False, capture_output=True, text=True)
+    if proc.returncode != 0:
+        raise RuntimeError(f"rnx2rtkp failed ({proc.returncode}): {proc.stderr.strip()[-500:]}")
+    return out

gnsskit/static/__init__.py

@@ -0,0 +1,31 @@
+"""Static processing: single solutions over a window, baselines and their network adjustment.
+
+The least-squares adjustment lives in `gnsskit.static.network` and is not imported here,
+because it needs the `network` extra (scipy, pyproj).
+"""
+
+from .baseline import (
+    BaselineResult,
+    baseline_from_solution,
+    baselines_to_df,
+    df_to_baselines,
+    extract_baseline,
+    process_baseline,
+    read_baselines,
+    write_baselines,
+)
+from .closure import loop_closures
+from .solve import solve_static
+
+__all__ = [
+    "BaselineResult",
+    "baseline_from_solution",
+    "baselines_to_df",
+    "df_to_baselines",
+    "extract_baseline",
+    "loop_closures",
+    "process_baseline",
+    "read_baselines",
+    "solve_static",
+    "write_baselines",
+]