gnss-js 0.1.2 → 1.0.1

package/dist/chunk-SO3POWWR.js

@@ -0,0 +1,502 @@
+import {
+  parseRinexStream
+} from "./chunk-HBLU2EJ4.js";
+import {
+  ARC_GAP_FACTOR,
+  BAND_LABELS,
+  C_LIGHT,
+  DUAL_FREQ_PAIRS,
+  FREQ,
+  SYSTEM_NAMES,
+  buildGloChannelMap,
+  buildObsIndices,
+  getFreq
+} from "./chunk-LWNTWBHB.js";
+
+// src/analysis/multipath.ts
+var MIN_ARC_LENGTH = 10;
+var MultipathAccumulator = class {
+  state = /* @__PURE__ */ new Map();
+  results = [];
+  interval;
+  obsIndices;
+  gloChannels;
+  constructor(header) {
+    this.interval = header.interval ?? 30;
+    this.obsIndices = buildObsIndices(header);
+    this.gloChannels = buildGloChannelMap(header.glonassSlots);
+  }
+  /** Observation callback — wire this into parseRinexStream. */
+  onObservation = (time, prn, _codes, values) => {
+    const sys = prn[0];
+    const bandMap = this.obsIndices.get(sys) ?? this.obsIndices.get("_v2");
+    if (!bandMap) return;
+    const bandData = /* @__PURE__ */ new Map();
+    for (const [band, { C, L }] of bandMap) {
+      if (C === null) continue;
+      const cVal = values[C];
+      const lVal = values[L];
+      const freq = getFreq(this.gloChannels, prn, band);
+      if (cVal != null && cVal !== 0 && lVal != null && lVal !== 0 && freq) {
+        bandData.set(band, { C: cVal, L: lVal, f: freq });
+      }
+    }
+    if (bandData.size < 2) return;
+    const pairs = DUAL_FREQ_PAIRS[sys] ?? [];
+    for (const [bi, bj] of pairs) {
+      const di = bandData.get(bi);
+      const dj = bandData.get(bj);
+      if (!di || !dj) continue;
+      const \u03BBi = C_LIGHT / di.f;
+      const \u03BBj = C_LIGHT / dj.f;
+      const \u03B1 = di.f * di.f / (dj.f * dj.f);
+      const coeff = 2 / (\u03B1 - 1);
+      const mp = di.C - (1 + coeff) * di.L * \u03BBi + coeff * dj.L * \u03BBj;
+      this.pushMp(prn, bi, bj, time, mp);
+    }
+  };
+  pushMp(prn, band, refBand, time, mp) {
+    if (!isFinite(mp)) return;
+    const pairKey = `${band}-${refBand}`;
+    let satStates = this.state.get(prn);
+    if (!satStates) {
+      satStates = /* @__PURE__ */ new Map();
+      this.state.set(prn, satStates);
+    }
+    let bandState = satStates.get(pairKey);
+    if (!bandState) {
+      bandState = { arc: { times: [], rawMp: [] }, lastTime: 0 };
+      satStates.set(pairKey, bandState);
+    }
+    const gap = bandState.lastTime > 0 ? (time - bandState.lastTime) / 1e3 : 0;
+    if (bandState.lastTime > 0 && gap > this.interval * ARC_GAP_FACTOR) {
+      this.closeArc(prn, band, refBand, bandState);
+    }
+    bandState.arc.times.push(time);
+    bandState.arc.rawMp.push(mp);
+    bandState.lastTime = time;
+  }
+  /** External cycle-slip notification — close affected arcs for this PRN. */
+  notifySlip(_time, prn, bands) {
+    const satStates = this.state.get(prn);
+    if (!satStates) return;
+    for (const [pairKey, bandState] of satStates) {
+      const [band, refBand] = pairKey.split("-");
+      if (bands.has(band) || bands.has(refBand)) {
+        this.closeArc(prn, band, refBand, bandState);
+      }
+    }
+  }
+  closeArc(prn, band, refBand, state) {
+    const arc = state.arc;
+    if (arc.times.length >= MIN_ARC_LENGTH) {
+      const mean = arc.rawMp.reduce((a, b) => a + b, 0) / arc.rawMp.length;
+      const sys = prn[0];
+      const bLabel = BAND_LABELS[sys]?.[band] ?? band;
+      const rLabel = BAND_LABELS[sys]?.[refBand] ?? refBand;
+      const label = `${prn} MP ${bLabel}-${rLabel}`;
+      const points = arc.times.map((t, i) => ({
+        time: t,
+        mp: arc.rawMp[i] - mean
+      }));
+      const rms = Math.sqrt(
+        points.reduce((s, p) => s + p.mp * p.mp, 0) / points.length
+      );
+      this.results.push({
+        prn,
+        system: sys,
+        band,
+        refBand,
+        label,
+        points,
+        rms
+      });
+    }
+    state.arc = { times: [], rawMp: [] };
+  }
+  /** Finalize: close remaining arcs and compute statistics. */
+  finalize() {
+    for (const [prn, satStates] of this.state) {
+      for (const [pairKey, bandState] of satStates) {
+        const [band, refBand] = pairKey.split("-");
+        this.closeArc(prn, band, refBand, bandState);
+      }
+    }
+    const signalGroups = /* @__PURE__ */ new Map();
+    for (const series of this.results) {
+      const key = `${series.system}-${series.band}-${series.refBand}`;
+      if (!signalGroups.has(key)) signalGroups.set(key, []);
+      signalGroups.get(key).push(series);
+    }
+    const signalStats = [];
+    for (const [, seriesList] of signalGroups) {
+      const { system, band, refBand } = seriesList[0];
+      let sumSq = 0;
+      let count = 0;
+      for (const s of seriesList) {
+        for (const p of s.points) {
+          sumSq += p.mp * p.mp;
+          count++;
+        }
+      }
+      const rms = count > 0 ? Math.sqrt(sumSq / count) : 0;
+      const bLabel = BAND_LABELS[system]?.[band] ?? band;
+      const rLabel = BAND_LABELS[system]?.[refBand] ?? refBand;
+      const sysName = SYSTEM_NAMES[system] ?? system;
+      signalStats.push({
+        label: `MP ${bLabel}-${rLabel} (${sysName})`,
+        system,
+        band,
+        refBand,
+        rms,
+        count,
+        satellites: seriesList.length
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.band.localeCompare(b.band);
+    });
+    return { series: this.results, signalStats };
+  }
+};
+
+// src/analysis/cycle-slip.ts
+var MW_MIN_THRESHOLD = 0.5;
+var MW_SIGMA_FACTOR = 4;
+var MW_MIN_EPOCHS = 3;
+var GF_THRESHOLD_M = 0.15;
+var SF_THRESHOLD_M = 3;
+function mwSmoothInit(value) {
+  return { mean: value, m2: 0, n: 1 };
+}
+function mwSmoothUpdate(s, value) {
+  const n = s.n + 1;
+  const delta = value - s.mean;
+  const mean = s.mean + delta / n;
+  const delta2 = value - mean;
+  return { mean, m2: s.m2 + delta * delta2, n };
+}
+function mwSmoothStddev(s) {
+  return s.n > 1 ? Math.sqrt(s.m2 / (s.n - 1)) : Infinity;
+}
+var CycleSlipAccumulator = class {
+  obsIndices;
+  prev = /* @__PURE__ */ new Map();
+  events = [];
+  interval;
+  /** GLONASS PRN → channel k for FDMA frequency computation. */
+  gloChannels;
+  onSlip;
+  // Per-signal epoch/slip counting
+  signalEpochs = /* @__PURE__ */ new Map();
+  signalSlips = /* @__PURE__ */ new Map();
+  signalSats = /* @__PURE__ */ new Map();
+  constructor(header, onSlip) {
+    this.interval = header.interval ?? 30;
+    this.obsIndices = buildObsIndices(header);
+    this.gloChannels = buildGloChannelMap(header.glonassSlots);
+    this.onSlip = onSlip;
+  }
+  recordSlip(sigKey, time, prn, signal, magnitude, bands) {
+    this.events.push({ time, prn, signal, magnitude });
+    this.signalSlips.set(sigKey, (this.signalSlips.get(sigKey) ?? 0) + 1);
+    if (!this.signalSats.has(sigKey)) this.signalSats.set(sigKey, /* @__PURE__ */ new Set());
+    this.signalSats.get(sigKey).add(prn);
+    this.onSlip?.(time, prn, bands);
+  }
+  countEpoch(sigKey) {
+    this.signalEpochs.set(sigKey, (this.signalEpochs.get(sigKey) ?? 0) + 1);
+  }
+  /** Resolve frequency for a given PRN + band. Handles GLONASS FDMA. */
+  getFreqForPrn(prn, band) {
+    return getFreq(this.gloChannels, prn, band);
+  }
+  onObservation = (time, prn, _codes, values) => {
+    const sys = prn[0];
+    const idxMap = this.obsIndices.get(sys) ?? this.obsIndices.get("_v2");
+    if (!idxMap) return;
+    if (sys !== "R" && !FREQ[sys]) return;
+    const phaseM = /* @__PURE__ */ new Map();
+    const codeM = /* @__PURE__ */ new Map();
+    for (const [band, { L, C }] of idxMap) {
+      const freq = this.getFreqForPrn(prn, band);
+      if (!freq) continue;
+      const lVal = values[L];
+      if (lVal != null && lVal !== 0) phaseM.set(band, lVal * (C_LIGHT / freq));
+      if (C !== null) {
+        const cVal = values[C];
+        if (cVal != null && cVal !== 0) codeM.set(band, cVal);
+      }
+    }
+    if (phaseM.size === 0) return;
+    const prev = this.prev.get(prn);
+    const gap = prev ? (time - prev.time) / 1e3 : 0;
+    const isArcBreak = !prev || gap > this.interval * ARC_GAP_FACTOR;
+    const mwSmooth = /* @__PURE__ */ new Map();
+    const gfMap = /* @__PURE__ */ new Map();
+    const pairs = DUAL_FREQ_PAIRS[sys] ?? [];
+    for (const [b1, b2] of pairs) {
+      const l1 = phaseM.get(b1);
+      const l2 = phaseM.get(b2);
+      const f1 = this.getFreqForPrn(prn, b1);
+      const f2 = this.getFreqForPrn(prn, b2);
+      if (!f1 || !f2) continue;
+      const pairKey = `${b1}-${b2}`;
+      if (l1 !== void 0 && l2 !== void 0) {
+        gfMap.set(pairKey, l1 - l2);
+      }
+      const c1 = codeM.get(b1);
+      const c2 = codeM.get(b2);
+      if (l1 !== void 0 && l2 !== void 0 && c1 !== void 0 && c2 !== void 0) {
+        const lambda_wl = C_LIGHT / (f1 - f2);
+        const phi_wl = (f1 * l1 - f2 * l2) / C_LIGHT;
+        const P_nl = (f1 * c1 + f2 * c2) / ((f1 + f2) * lambda_wl);
+        const mw = phi_wl - P_nl;
+        const prevSmooth = isArcBreak ? void 0 : prev?.mwSmooth.get(pairKey);
+        if (prevSmooth && prevSmooth.n >= MW_MIN_EPOCHS) {
+          const lbl1 = BAND_LABELS[sys]?.[b1] ?? b1;
+          const lbl2 = BAND_LABELS[sys]?.[b2] ?? b2;
+          const signal = `MW ${lbl1}-${lbl2}`;
+          const sigKey = `${sys}:${signal}`;
+          this.countEpoch(sigKey);
+          const stddev = mwSmoothStddev(prevSmooth);
+          const threshold = Math.max(
+            MW_MIN_THRESHOLD,
+            MW_SIGMA_FACTOR * stddev
+          );
+          const deviation = Math.abs(mw - prevSmooth.mean);
+          if (deviation > threshold) {
+            this.recordSlip(
+              sigKey,
+              time,
+              prn,
+              signal,
+              deviation,
+              /* @__PURE__ */ new Set([b1, b2])
+            );
+            mwSmooth.set(pairKey, mwSmoothInit(mw));
+          } else {
+            mwSmooth.set(pairKey, mwSmoothUpdate(prevSmooth, mw));
+          }
+        } else if (prevSmooth) {
+          mwSmooth.set(pairKey, mwSmoothUpdate(prevSmooth, mw));
+        } else {
+          mwSmooth.set(pairKey, mwSmoothInit(mw));
+        }
+      }
+    }
+    if (!isArcBreak && prev) {
+      const dualChecked = /* @__PURE__ */ new Set();
+      for (const [b1, b2] of pairs) {
+        const pairKey = `${b1}-${b2}`;
+        const lbl1 = BAND_LABELS[sys]?.[b1] ?? b1;
+        const lbl2 = BAND_LABELS[sys]?.[b2] ?? b2;
+        if (mwSmooth.has(pairKey)) {
+          dualChecked.add(b1);
+          dualChecked.add(b2);
+          continue;
+        }
+        const curGf = gfMap.get(pairKey);
+        const prevGf = prev.gf.get(pairKey);
+        if (curGf !== void 0 && prevGf !== void 0) {
+          const signal = `GF ${lbl1}-${lbl2}`;
+          const sigKey = `${sys}:${signal}`;
+          this.countEpoch(sigKey);
+          const jump = Math.abs(curGf - prevGf);
+          if (jump > GF_THRESHOLD_M) {
+            this.recordSlip(sigKey, time, prn, signal, jump, /* @__PURE__ */ new Set([b1, b2]));
+          }
+          dualChecked.add(b1);
+          dualChecked.add(b2);
+        }
+      }
+      for (const [band, lm] of phaseM) {
+        if (dualChecked.has(band)) continue;
+        const prevLm = prev.phase.get(band);
+        if (prevLm === void 0) continue;
+        const cm = codeM.get(band);
+        const prevCm = prev.code.get(band);
+        if (cm === void 0 || prevCm === void 0) continue;
+        const dPhase = lm - prevLm;
+        const dCode = cm - prevCm;
+        const jumpM = Math.abs(dPhase - dCode);
+        const lbl = BAND_LABELS[sys]?.[band] ?? band;
+        const sigKey = `${sys}:${lbl}`;
+        this.countEpoch(sigKey);
+        if (jumpM > SF_THRESHOLD_M) {
+          this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+        }
+      }
+    }
+    this.prev.set(prn, {
+      time,
+      mwSmooth,
+      gf: gfMap,
+      phase: phaseM,
+      code: codeM
+    });
+  };
+  finalize() {
+    const satSlipCounts = {};
+    for (const ev of this.events) {
+      satSlipCounts[ev.prn] = (satSlipCounts[ev.prn] ?? 0) + 1;
+    }
+    const signalStats = [];
+    const allKeys = /* @__PURE__ */ new Set([
+      ...this.signalEpochs.keys(),
+      ...this.signalSlips.keys()
+    ]);
+    for (const sigKey of allKeys) {
+      const [sys, ...rest] = sigKey.split(":");
+      const signal = rest.join(":");
+      const totalEpochs = this.signalEpochs.get(sigKey) ?? 0;
+      const totalSlips = this.signalSlips.get(sigKey) ?? 0;
+      const sysName = SYSTEM_NAMES[sys] ?? sys;
+      signalStats.push({
+        label: `${signal} (${sysName})`,
+        system: sys,
+        totalSlips,
+        satellites: this.signalSats.get(sigKey)?.size ?? 0,
+        totalEpochs,
+        slipRate: totalEpochs > 0 ? totalSlips / totalEpochs * 1e3 : 0
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.label.localeCompare(b.label);
+    });
+    return { events: this.events, signalStats, satSlipCounts };
+  }
+};
+
+// src/analysis/completeness.ts
+var CompletenessAccumulator = class {
+  // PRN → code → { seen, expected, present }
+  // "seen" gates counting: expected only increments after a satellite has transmitted
+  // the signal at least once (avoids inflating expected for signals a sat doesn't have,
+  // e.g. L5 on GPS Block IIR).
+  data = /* @__PURE__ */ new Map();
+  header;
+  constructor(header) {
+    this.header = header;
+  }
+  onObservation = (_time, prn, codes, values) => {
+    let satMap = this.data.get(prn);
+    if (!satMap) {
+      satMap = /* @__PURE__ */ new Map();
+      this.data.set(prn, satMap);
+    }
+    for (let i = 0; i < codes.length; i++) {
+      const code = codes[i];
+      const hasValue = values[i] != null && values[i] !== 0;
+      let cell = satMap.get(code);
+      if (!cell) {
+        cell = { seen: false, expected: 0, present: 0 };
+        satMap.set(code, cell);
+      }
+      if (hasValue) cell.seen = true;
+      if (cell.seen) cell.expected++;
+      if (hasValue) cell.present++;
+    }
+  };
+  finalize() {
+    const cells = [];
+    const systemSet = /* @__PURE__ */ new Set();
+    for (const [prn, satMap] of this.data) {
+      const sys = prn[0];
+      systemSet.add(sys);
+      for (const [code, { seen, expected, present }] of satMap) {
+        if (!seen) continue;
+        const band = code[1] ?? "?";
+        cells.push({
+          prn,
+          system: sys,
+          code,
+          band,
+          expected,
+          present,
+          percent: expected > 0 ? present / expected * 100 : 0
+        });
+      }
+    }
+    const sigAgg = /* @__PURE__ */ new Map();
+    for (const c of cells) {
+      const key = `${c.system}:${c.code}`;
+      let agg = sigAgg.get(key);
+      if (!agg) {
+        agg = { expected: 0, present: 0, sats: /* @__PURE__ */ new Set() };
+        sigAgg.set(key, agg);
+      }
+      agg.expected += c.expected;
+      agg.present += c.present;
+      agg.sats.add(c.prn);
+    }
+    const signalStats = [];
+    for (const [key, agg] of sigAgg) {
+      const [sys, code] = key.split(":");
+      const band = code[1] ?? "?";
+      const bandLabel = BAND_LABELS[sys]?.[band] ?? `Band ${band}`;
+      const sysName = SYSTEM_NAMES[sys] ?? sys;
+      signalStats.push({
+        code,
+        system: sys,
+        label: `${code} (${sysName} ${bandLabel})`,
+        expected: agg.expected,
+        present: agg.present,
+        percent: agg.expected > 0 ? agg.present / agg.expected * 100 : 0,
+        satellites: agg.sats.size
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.code.localeCompare(b.code);
+    });
+    const systems = [...systemSet].sort((a, b) => {
+      return (sysOrder.indexOf(a) === -1 ? 99 : sysOrder.indexOf(a)) - (sysOrder.indexOf(b) === -1 ? 99 : sysOrder.indexOf(b));
+    });
+    return { cells, signalStats, systems };
+  }
+};
+
+// src/analysis/quality-analysis.ts
+async function analyzeQuality(file, header, onProgress, signal) {
+  const mpAccum = new MultipathAccumulator(header);
+  const csAccum = new CycleSlipAccumulator(header, (time, prn, bands) => {
+    mpAccum.notifySlip(time, prn, bands);
+  });
+  const compAccum = new CompletenessAccumulator(header);
+  await parseRinexStream(
+    file,
+    onProgress,
+    signal,
+    (time, prn, codes, values) => {
+      csAccum.onObservation(time, prn, codes, values);
+      mpAccum.onObservation(time, prn, codes, values);
+      compAccum.onObservation(time, prn, codes, values);
+    },
+    true
+    /* workerMode: skip EpochSummary construction */
+  );
+  return {
+    cycleSlips: csAccum.finalize(),
+    completeness: compAccum.finalize(),
+    multipath: mpAccum.finalize()
+  };
+}
+
+export {
+  MultipathAccumulator,
+  CycleSlipAccumulator,
+  CompletenessAccumulator,
+  analyzeQuality
+};