"""Generate the sparam-conformance corpus. A labelled set of S-parameter networks with ground-truth physical verdicts. Every case is synthesised from a closed-form model, so the label is derived from construction rather than asserted -- we know a network is non-passive because we built it that way, not because a checker said so. Run: python generate.py [--out data] """ from __future__ import annotations import argparse import hashlib import json from dataclasses import dataclass, field from pathlib import Path import numpy as np FREQ = np.linspace(1e9, 40e9, 64) # The five laws, in the order every checker should report them. LAWS = ("passivity", "reciprocity", "energy_conservation", "positive_real_z0", "group_delay_nonneg") @dataclass class Case: name: str s: np.ndarray freq: np.ndarray z0: float expect: dict[str, bool] # law -> should_pass physical: bool # is this a realizable passive device? note: str tags: list[str] = field(default_factory=list) def _line(loss_db=0.5, delay_s=20e-12, refl=0.05): amp = 10.0 ** (-abs(loss_db) / 20.0) s21 = amp * np.exp(-1j * 2 * np.pi * FREQ * delay_s) s = np.zeros((len(FREQ), 2, 2), dtype=complex) s[:, 0, 0] = s[:, 1, 1] = refl s[:, 0, 1] = s[:, 1, 0] = s21 return s def _resonator(f0=20e9, q=30.0, delay_s=10e-12): """A passive shunt resonator: sharp phase, still causal and passive.""" x = (FREQ / f0) - (f0 / FREQ) denom = 1.0 + 1j * q * x s21 = (1.0 / denom) * np.exp(-1j * 2 * np.pi * FREQ * delay_s) s11 = 1.0 - 1.0 / denom s = np.zeros((len(FREQ), 2, 2), dtype=complex) s[:, 0, 0] = s[:, 1, 1] = s11 s[:, 0, 1] = s[:, 1, 0] = s21 # A resonator built naively from these closed forms is NOT passive -- the # 2x2 spectral norm exceeds 1 near resonance. Normalise by the worst # singular value so the network genuinely satisfies the law its label # claims. A corpus whose "passive" case is not passive is worse than no # corpus at all. worst = max(np.linalg.svd(m, compute_uv=False)[0] for m in s) return s * (0.98 / worst) def _attenuator(db=10.0): a = 10.0 ** (-db / 20.0) s = np.zeros((len(FREQ), 2, 2), dtype=complex) s[:, 0, 1] = s[:, 1, 0] = a return s def _matched_load(): return np.zeros((len(FREQ), 2, 2), dtype=complex) def _marginal_passive(): """sigma_max just below 1 -- a lossless line. Must PASS.""" s21 = np.exp(-1j * 2 * np.pi * FREQ * 15e-12) * (1.0 - 1e-12) s = np.zeros((len(FREQ), 2, 2), dtype=complex) s[:, 0, 1] = s[:, 1, 0] = s21 return s def _thru_4port(): """Two independent thru paths: 1-2 and 3-4. Passive and reciprocal.""" n = len(FREQ) s = np.zeros((n, 4, 4), dtype=complex) a = 0.9 * np.exp(-1j * 2 * np.pi * FREQ * 12e-12) s[:, 0, 1] = s[:, 1, 0] = a s[:, 2, 3] = s[:, 3, 2] = a return s def build_cases() -> list[Case]: ok = {law: True for law in LAWS} cases: list[Case] = [] # ---------- physically realizable: everything must pass ---------- cases.append(Case( "passive_line", _line(), FREQ, 50.0, dict(ok), True, "Lossy 20 ps delay line, 0.5 dB insertion loss. The baseline sane case.", ["passive", "2port"])) cases.append(Case( "passive_resonator", _resonator(), FREQ, 50.0, dict(ok), True, "Shunt resonator, Q=30 at 20 GHz. Sharp phase slope near resonance -- " "the case where a group-delay check without phase unwrapping fails.", ["passive", "2port", "sharp_phase"])) cases.append(Case( "passive_attenuator", _attenuator(), FREQ, 50.0, dict(ok), True, "Ideal 10 dB matched attenuator.", ["passive", "2port"])) cases.append(Case( "matched_load", _matched_load(), FREQ, 50.0, dict(ok), True, "All-zero S: perfectly matched, fully absorbing. A degenerate but " "legal network; checkers that divide by |S| must not blow up.", ["passive", "2port", "degenerate"])) cases.append(Case( "marginal_lossless", _marginal_passive(), FREQ, 50.0, dict(ok), True, "Lossless line with sigma_max = 1 - 1e-12. Sits on the passivity " "boundary; a checker with a too-tight tolerance false-alarms here.", ["passive", "2port", "boundary"])) cases.append(Case( "passive_4port", _thru_4port(), FREQ, 50.0, dict(ok), True, "Four-port with two independent thru paths. Exercises N>2 handling.", ["passive", "4port"])) # ---------- non-physical: exactly one law must fail ---------- s = _line() s[:, 0, 1] *= 3.0 s[:, 1, 0] *= 3.0 cases.append(Case( "active_gain", s, FREQ, 50.0, {**ok, "passivity": False, "energy_conservation": False}, False, "Delay line with 3x through-path gain. Creates energy: fails both the " "spectral-norm and the row-power tests.", ["nonphysical", "2port"])) s = _line() s[:, 0, 0] = s[:, 1, 1] = 0.9 s[:, 0, 1] = s[:, 1, 0] = 0.9 cases.append(Case( "energy_row_violation", s, FREQ, 50.0, {**ok, "passivity": False, "energy_conservation": False}, False, "Row power > 1 when port 1 is driven.", ["nonphysical", "2port"])) s = _line() s[:, 0, 0] = s[:, 1, 1] = -1.6 cases.append(Case( "negative_resistance", s, FREQ, 50.0, {**ok, "passivity": False, "positive_real_z0": False, "energy_conservation": False}, False, "|S11| > 1 gives Re(Z_in) < 0: negative resistance at the port. It " "unavoidably breaks energy conservation too -- a reflection " "coefficient above unity returns more power than arrives -- so this " "case cannot isolate a single law, and the label says so.", ["nonphysical", "2port"])) s = _line() amp = np.abs(s[:, 0, 1]) s[:, 0, 1] = s[:, 1, 0] = amp * np.exp(+1j * 2 * np.pi * FREQ * 20e-12) cases.append(Case( "noncausal_advance", s, FREQ, 50.0, {**ok, "group_delay_nonneg": False}, False, "Phase advances with frequency: the output precedes the input. " "Passive and reciprocal, so ONLY the causality check should fire.", ["nonphysical", "2port", "isolates_one_law"])) # ---------- real device that legitimately fails a law ---------- s = _line() s[:, 0, 1] = s[:, 1, 0] * 0.02 # 34 dB isolation one way cases.append(Case( "ferrite_isolator", s, FREQ, 50.0, {**ok, "reciprocity": False}, True, "A ferrite isolator. NON-RECIPROCAL BY DESIGN and entirely realizable " "-- the medium is not reciprocal. The reciprocity check correctly " "fires, and that is a true positive for the law but NOT a defect in " "the device. Any tool reporting this must let the user say so.", ["physical", "2port", "expected_law_failure"])) return cases def write_touchstone(path: Path, c: Case) -> None: n = c.s.shape[1] lines = [f"! {c.name}", f"! {c.note}", f"# HZ S RI R {c.z0:g}"] for fi, f in enumerate(c.freq): m = c.s[fi] if n == 2: # Touchstone 2-port: S11 S21 S12 S22 vals = [m[0, 0], m[1, 0], m[0, 1], m[1, 1]] else: # N>=3: row-major vals = list(m.reshape(-1)) lines.append(f"{f:.12g} " + " ".join( f"{v.real:.12g} {v.imag:.12g}" for v in vals)) path.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n") def main() -> int: ap = argparse.ArgumentParser() ap.add_argument("--out", default="data") args = ap.parse_args() out = Path(__file__).resolve().parent / args.out out.mkdir(parents=True, exist_ok=True) cases = build_cases() manifest = { "corpus": "sparam-conformance", "version": "1.0.0", "license": "CC-BY-4.0", "n_cases": len(cases), "laws": list(LAWS), "freq_hz": {"start": float(FREQ[0]), "stop": float(FREQ[-1]), "n": int(len(FREQ))}, "note": ( "Every network is synthesised from a closed-form model, so each " "label is derived from construction rather than from a checker's " "opinion. 'physical' marks whether the device is realizable; a " "device can be physical AND legitimately fail a law -- see " "ferrite_isolator." ), "cases": [], } for c in cases: n = c.s.shape[1] fname = f"{c.name}.s{n}p" write_touchstone(out / fname, c) digest = hashlib.sha256((out / fname).read_bytes()).hexdigest() manifest["cases"].append({ "name": c.name, "file": fname, "n_ports": n, "z0_ohm": c.z0, "physical": c.physical, "expect": c.expect, "expect_all_pass": all(c.expect.values()), "note": c.note, "tags": c.tags, "sha256": digest, }) (out / "manifest.json").write_text( json.dumps(manifest, indent=2) + "\n", encoding="utf-8", newline="\n") print(f"wrote {len(cases)} cases + manifest.json to {out}") return 0 if __name__ == "__main__": raise SystemExit(main())