From fef72abd30c91f096e694e43de14e8752fa7c5ee Mon Sep 17 00:00:00 2001 From: priyanshlunia <40486607+priyanshlunia@users.noreply.github.com> Date: Wed, 1 Jul 2026 15:33:47 -0400 Subject: [PATCH 1/4] fix(qs_fit): restore pairwise-difference basis for differential sensors The QS fit hardcoded `dp = None` and never differenced the basis for differential magnetic sensors (the MPID/ISLD/ESLD families), so a sensor that physically reports field(X) - field(pair) was fit against a single-location basis. This affected the default production fit: all 10 MPID66M* probes of Bp_LFS_midplane are paired. Restores the OMFIT fit_magnetics.py treatment (design-matrix column = (basis(X)/sigma - basis(pair)/sigma_pair) / 2), applied per-channel so mixed paired/unpaired arrays are handled. - qs_device.sensor_geometry: resolve each channel's pair in the full device table and emit pair_{phi,theta,z}_end1/2 vars (NaN when unpaired), riding the existing geometry-attach path to the fit. - qs_fit.fit: difference the basis where has_pair (main loop + ill-conditioned refit, with the x0/y0 shift on the pair too); psigma = sigma under the constant per-shot sigma; fix the n=0 warning to fire only when unpaired; emit an n_paired attr. Gaussian path gets the same treatment for parity. - synthetic_shot: make paired sensors differential (signal(X) = field(X) - field(pair)) so the fixture stays physically consistent with the fit. - tests/test_qs_pairdiff.py: unit test that the paired design column equals (basis(X) - basis(pair)) / 2 and the unpaired one equals basis(X); pipeline test that Bp_LFS_midplane reports n_paired == 10. Per-channel detection is identical to OMFIT's all-or-nothing on every real (uniformly paired/unpaired) DIII-D array. ruff/ty clean; 218 passed, 1 skipped. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/magnetics/core/qs_device.py | 24 +++++++++- src/magnetics/core/qs_fit.py | 52 +++++++++++++++++++-- tests/synthetic_shot.py | 16 ++++++- tests/test_qs_pairdiff.py | 80 +++++++++++++++++++++++++++++++++ 4 files changed, 167 insertions(+), 5 deletions(-) create mode 100644 tests/test_qs_pairdiff.py diff --git a/src/magnetics/core/qs_device.py b/src/magnetics/core/qs_device.py index 6e68411..4cf0119 100644 --- a/src/magnetics/core/qs_device.py +++ b/src/magnetics/core/qs_device.py @@ -132,7 +132,9 @@ def sensor_geometry(device="DIII-D", shot=None): Base fields (``r, z, phi, tilt, length, delta_phi, na``, plus ``pair``) come from the data layer's shot-aware resolver (:func:`devices.geometry_nearest`); this function adds the derived poloidal angle ``theta`` and the sensor-end coordinates - ``{r,z,phi,theta}_end1/2`` that the SLCONTOUR fit needs. A sensor is modelled as a + ``{r,z,phi,theta}_end1/2`` that the SLCONTOUR fit needs, plus the paired sensor's + ``pair_{phi,theta,z}_end1/2`` (for the pairwise-difference basis; NaN when unpaired). + A sensor is modelled as a straight segment of physical ``length`` centred at ``(r, z)`` tilted by ``tilt`` (degrees) in the poloidal plane and spanning ``delta_phi`` (degrees) toroidally; angles are measured about the magnetic axis at ``(R0, 0)``. @@ -169,6 +171,20 @@ def sensor_geometry(device="DIII-D", shot=None): theta_end1 = np.degrees(np.arctan2(z_end1, r_end1 - R0)) theta_end2 = np.degrees(np.arctan2(z_end2, r_end2 - R0)) + # ── paired-sensor ends (for the SLCONTOUR pairwise-difference basis) ────────── + # A differential sensor (pair != "None") reports field(X) - field(pair); the fit + # differences the basis at X and at its pair. Resolve each channel's pair to its + # row and gather the pair's *_end1/2 here (NaN when unpaired/unresolved) so the + # pair geometry rides the normal geometry-attach path into the fit. + name_to_row = {c: i for i, c in enumerate(channels)} + pair_row = np.array([name_to_row.get(str(p), -1) if str(p) != "None" else -1 for p in pairs]) + + def _by_pair(arr): + out = np.full(len(channels), np.nan) + valid = pair_row >= 0 + out[valid] = arr[pair_row[valid]] + return out + ds = xr.Dataset( { **{k: ("channel", cols[k]) for k in base}, @@ -181,6 +197,12 @@ def sensor_geometry(device="DIII-D", shot=None): "phi_end2": ("channel", phi_end2), "theta_end1": ("channel", theta_end1), "theta_end2": ("channel", theta_end2), + "pair_phi_end1": ("channel", _by_pair(phi_end1)), + "pair_phi_end2": ("channel", _by_pair(phi_end2)), + "pair_theta_end1": ("channel", _by_pair(theta_end1)), + "pair_theta_end2": ("channel", _by_pair(theta_end2)), + "pair_z_end1": ("channel", _by_pair(z_end1)), + "pair_z_end2": ("channel", _by_pair(z_end2)), }, coords={"channel": channels}, ) diff --git a/src/magnetics/core/qs_fit.py b/src/magnetics/core/qs_fit.py index 8aa6898..8e6f7b2 100644 --- a/src/magnetics/core/qs_fit.py +++ b/src/magnetics/core/qs_fit.py @@ -251,6 +251,23 @@ def _printv(*a): fill = np.nanmean(sigma) if np.isfinite(np.nanmean(sigma)) else 1.0 sigma[bad] = fill + # ── paired-sensor differencing (SLCONTOUR pairwise-difference basis) ──────── + # A differential sensor (pair != "None") reports field(X) - field(pair), so the + # design-matrix column is differenced at X and at its pair. The pair ends ride in + # on the geometry (qs_device.sensor_geometry); NaN marks an unpaired channel. + if f"pair_{xkey}_end1" in ds: + px1 = ds[f"pair_{xkey}_end1"].values + px2 = ds[f"pair_{xkey}_end2"].values + py1 = ds[f"pair_{ykey}_end1"].values + py2 = ds[f"pair_{ykey}_end2"].values + else: + px1 = px2 = py1 = py2 = np.full_like(x1, np.nan) + has_pair = np.isfinite(px1) + # OMFIT sources the pair's signal_sigma (fit_magnetics.py:136-141: all-NaN -> own + # sigma, then NaN -> nanmean). Our sigma is the constant per-shot value for every + # channel, so pair sigma == own sigma; revisit when real per-sensor sigma lands. + psigma = sigma + # ── basis-specific mode / centre setup ──────────────────────────────────── is_sinusoidal = fit_basis.startswith("sinusoidal") is_gaussian = fit_basis.startswith("gaussian") @@ -258,9 +275,8 @@ def _printv(*a): if is_sinusoidal: ms = np.atleast_1d(ms) ns = np.atleast_1d(ns) - dp = None # paired sensors not present in this dataset - if dp is None and 0 not in ns: - _printv("WARNING: Sensors are not paired! Consider including n=0.") + if (~has_pair).any() and 0 not in ns: + _printv("WARNING: Some sensors are not paired! Consider including n=0.") if not np.all(ms == 0) and not np.any(np.sign(ms) == helicity): ms = ms * -1 _printv(f"WARNING: Flipping sign of m to conform to helicity {helicity:+}") @@ -325,6 +341,9 @@ def _printv(*a): if is_sinusoidal: for n, m in nms: fmn = form_basis_function(n, m, x1, x2, y1, y2, fit_basis) / sigma + if has_pair.any(): + fmn_pair = form_basis_function(n, m, px1, px2, py1, py2, fit_basis) / psigma + fmn = np.where(has_pair, (fmn - fmn_pair) / 2.0, fmn) if np.allclose(fmn.imag, 0): A_cols.append(fmn.real) ncomp.append(1) @@ -345,6 +364,14 @@ def _printv(*a): form_basis_function(n, m, x1 + x0, x2 + x0, y1 + y0, y2 + y0, fit_basis) / sigma ) + if has_pair.any(): + fmn_pair = ( + form_basis_function( + n, m, px1 + x0, px2 + x0, py1 + y0, py2 + y0, fit_basis + ) + / psigma + ) + fmn = np.where(has_pair, (fmn - fmn_pair) / 2.0, fmn) A_cols = A_cols[:-2] + [fmn.real] ncomp[-1] = 1 else: # gaussian — basis functions are always real @@ -365,6 +392,24 @@ def _printv(*a): ) / sigma ) + if has_pair.any(): + fmn_pair = ( + form_basis_function( + n, + m, + px1, + px2, + py1, + py2, + fit_basis, + ncycle=_ncycle, + mcycle=_mcycle, + nepsilon=_nepsilon, + mepsilon=_mepsilon, + ) + / psigma + ) + fmn = np.where(has_pair, (fmn - fmn_pair) / 2.0, fmn) A_cols.append(fmn) ncomp.append(1) @@ -448,6 +493,7 @@ def _printv(*a): fit_mcycle=_mcycle, fit_neps=_nepsilon, fit_meps=_mepsilon, + n_paired=int(has_pair.sum()), ) _condition_warning(raw_cn) return ds diff --git a/tests/synthetic_shot.py b/tests/synthetic_shot.py index fb3edf4..3317ccf 100644 --- a/tests/synthetic_shot.py +++ b/tests/synthetic_shot.py @@ -86,13 +86,27 @@ def _channels(shot: int, *, include_qs: bool) -> list[Channel]: names += _MPID_POLOIDAL names = list(dict.fromkeys(names)) # dedup, keep order + from magnetics.data import devices + + dev = devices.load_device("diiid") + chans: list[Channel] = [] for nm in names: phi = diiid.phi_of(nm, shot) if phi is None: continue # not modeled at this shot → leave out (fetcher would skip it) theta = diiid.real_theta_of(nm, shot) or 0.0 - chans.append(Channel(nm, t_ms.copy(), _sensor_signal(t_s, phi, theta), ok=True)) + sig = _sensor_signal(t_s, phi, theta) + # Differential probes (MPID/ISLD/ESLD) physically report field(X) − field(pair); + # subtract the pair's field so the signal matches the pairwise-difference basis + # the QS fit builds for paired sensors (see qs_fit / qs_device). + pair = (devices.geometry_nearest(dev, nm, shot) or {}).get("pair") + if pair and str(pair) != "None": + pphi = diiid.phi_of(pair, shot) + if pphi is not None: + ptheta = diiid.real_theta_of(pair, shot) or 0.0 + sig = sig - _sensor_signal(t_s, pphi, ptheta) + chans.append(Channel(nm, t_ms.copy(), sig, ok=True)) # Plasma traces (routed to the plasma Dataset / κ path; not sensor channels). ip = (1.0e6 * t_s / t_s[-1]).astype(np.float32) # 0 → 1 MA ramp diff --git a/tests/test_qs_pairdiff.py b/tests/test_qs_pairdiff.py new file mode 100644 index 0000000..655d7b6 --- /dev/null +++ b/tests/test_qs_pairdiff.py @@ -0,0 +1,80 @@ +"""Pairwise-difference treatment in the QS fit (`qs_fit` + `qs_device`). + +A differential magnetic sensor (`pair != "None"` — the MPID/ISLD/ESLD families) reports +`field(X) − field(pair)`, so its design-matrix column must be `(basis(X) − basis(pair)) / 2` +(ported from OMFIT `fit_magnetics.py:340`). These tests pin that treatment: the unit test +checks the assembled design matrix column-by-column for a mixed paired/unpaired array, and +the pipeline test confirms detection flows end-to-end on the synthetic shot. +""" + +from __future__ import annotations + +import numpy as np +import xarray as xr + +from magnetics.core import qs_fit +from magnetics.service import nodes + + +def _min_prepared(): + """A minimal PREPARED-style Dataset: channel s0 is paired (pair ends set), s1 is + unpaired (pair ends NaN). Cylindrical geometry, constant σ.""" + t = np.linspace(0.0, 0.01, 8) + ds = xr.Dataset( + { + "signal": (("channel", "time"), np.ones((2, t.size))), + "signal_sigma": ("channel", np.full(2, 2.0e-5)), + "phi_end1": ("channel", np.array([10.0, 20.0])), + "phi_end2": ("channel", np.array([12.0, 22.0])), + "theta_end1": ("channel", np.array([0.0, 0.0])), + "theta_end2": ("channel", np.array([0.0, 0.0])), + # s0 paired to a sensor near φ=100°; s1 unpaired → NaN + "pair_phi_end1": ("channel", np.array([100.0, np.nan])), + "pair_phi_end2": ("channel", np.array([102.0, np.nan])), + "pair_theta_end1": ("channel", np.array([0.0, np.nan])), + "pair_theta_end2": ("channel", np.array([0.0, np.nan])), + }, + coords={"channel": ["s0", "s1"], "time": t}, + ) + ds.attrs.update(helicity=-1, device="DIII-D", sigma_type=2.0e-5) + return ds + + +def test_paired_column_is_differenced_unpaired_is_not(): + ds = _min_prepared() + fitds = qs_fit.fit(ds, ns=(1,), ms=(0,), fit_basis="sinusoidal-point", verbose=False) + + assert int(fitds.attrs["n_paired"]) == 1 # only s0 is paired + + # Rebuild the expected differenced design column from the public primitive. + fbf = qs_fit.form_basis_function + sigma = ds["signal_sigma"].values + x1, x2 = ds["phi_end1"].values, ds["phi_end2"].values + y1, y2 = ds["theta_end1"].values, ds["theta_end2"].values + px1, px2 = ds["pair_phi_end1"].values, ds["pair_phi_end2"].values + py1, py2 = ds["pair_theta_end1"].values, ds["pair_theta_end2"].values + has_pair = np.isfinite(px1) + + fmn = fbf(1, 0, x1, x2, y1, y2, "sinusoidal-point") / sigma + fmn_pair = fbf(1, 0, px1, px2, py1, py2, "sinusoidal-point") / sigma + expected = np.where(has_pair, (fmn - fmn_pair) / 2.0, fmn) # [2] complex + + # n=1,m=0 point basis is complex → the design matrix carries a (real, imag) column + # pair; reconstruct the complex column and compare per channel. + basis = fitds["basis"].values # (n_channels, n_cols) + assert basis.shape == (2, 2) + complex_col = basis[:, 0] + 1j * basis[:, 1] + np.testing.assert_allclose(complex_col, expected, rtol=1e-6, atol=1e-9) + + # Sanity: the paired channel's column actually differs from the plain single-sensor + # basis (i.e. the differencing is not a no-op), while the unpaired one matches it. + plain = fmn + assert not np.isclose(complex_col[0], plain[0]) + assert np.isclose(complex_col[1], plain[1]) + + +def test_pipeline_reports_all_midplane_channels_paired(synthetic_shot): + """The default Bp_LFS_midplane fit is the 10 MPID66M* probes — all paired.""" + run = nodes._prep_qs_ds(synthetic_shot, {}) + assert run.fit.attrs["n_paired"] == 10 + assert run.fit.sizes["channel"] == 10 From dedb0b563548b0030414fcd7bda09f3880a5d4cc Mon Sep 17 00:00:00 2001 From: priyanshlunia <40486607+priyanshlunia@users.noreply.github.com> Date: Wed, 1 Jul 2026 16:16:04 -0400 Subject: [PATCH 2/4] minor edits to example_magnetics notebook --- examples/example_magnetics.ipynb | 421 +++++++++++++++++++++++++++---- uv.lock | 6 +- 2 files changed, 377 insertions(+), 50 deletions(-) diff --git a/examples/example_magnetics.ipynb b/examples/example_magnetics.ipynb index 10f5f93..f805794 100644 --- a/examples/example_magnetics.ipynb +++ b/examples/example_magnetics.ipynb @@ -4,15 +4,56 @@ "cell_type": "markdown", "id": "0", "metadata": {}, - "source": "# 3D magnetics spatial fit — DIII-D (configurable shot)\n\nA worked example of the **SLCONTOUR-style quasi-stationary spatial fit** (VISION.md §4.1),\nrun **locally** — off MDSplus — with the `magnetics.core.qs_*` pipeline. It reads the per-shot\nsignals from `data/datafile/shot_.h5` and the device geometry from `data/device/diiid.json`.\n\n**Pipeline:** `load → prep → fit → plot`:\n\n| module | role |\n|---|---|\n| `qs_io_data.load_shot` | read `shot_.h5` signals + join the device-JSON geometry (derived `*_end1/2` ends) |\n| `qs_prep.prepare` | trim, integrate, causal band-pass, detrend, SVD-condition |\n| `qs_fit.fit` | build the basis matrix + SVD-conditioned least-squares modal fit |\n| `qs_run.run_steps` | the load → prep → fit orchestrator |\n| `qs_plots.*` | sensor map, signals, SVD diagnostics, fit quality, mode amp/phase, φ-vs-time contour |\n\n(The production/GUI path adapts the same `qs_fit` Dataset through `qs_bridge`; `qs_plots` here is\nthe standalone-matplotlib view.)\n\nThe run is driven entirely by the **Parameters** cell below — change `SHOT`, `CHANNEL_FILTER`,\n`TIME_TRIM`, or the mode lists to analyse a different shot or array. The default analyses the\nLFS-midplane toroidal Bp array (`Bp_LFS_midplane`) of shot **199749** for toroidal mode numbers\nn = 1, 2, 3." + "source": [ + "# 3D magnetics spatial fit — DIII-D (configurable shot)\n", + "\n", + "A worked example of the **SLCONTOUR-style quasi-stationary spatial fit** (VISION.md §4.1),\n", + "run **locally** — off MDSplus — with the `magnetics.core.qs_*` pipeline. It reads the per-shot\n", + "signals from `data/datafile/shot_.h5` and the device geometry from `data/device/diiid.json`.\n", + "\n", + "**Pipeline:** `load → prep → fit → plot`:\n", + "\n", + "| module | role |\n", + "|---|---|\n", + "| `qs_io_data.load_shot` | read `shot_.h5` signals + join the device-JSON geometry (derived `*_end1/2` ends) |\n", + "| `qs_prep.prepare` | trim, integrate, causal band-pass, detrend, SVD-condition |\n", + "| `qs_fit.fit` | build the basis matrix + SVD-conditioned least-squares modal fit |\n", + "| `qs_run.run_steps` | the load → prep → fit orchestrator |\n", + "| `qs_plots.*` | sensor map, signals, SVD diagnostics, fit quality, mode amp/phase, φ-vs-time contour |\n", + "\n", + "(The production/GUI path adapts the same `qs_fit` Dataset through `qs_bridge`; `qs_plots` here is\n", + "the standalone-matplotlib view.)\n", + "\n", + "The run is driven entirely by the **Parameters** cell below — change `SHOT`, `CHANNEL_FILTER`,\n", + "`TIME_TRIM`, or the mode lists to analyse a different shot or array. The default analyses the\n", + "LFS-midplane toroidal Bp array (`Bp_LFS_midplane`) of shot **199749** for toroidal mode numbers\n", + "n = 1, 2, 3." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "1", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:13.730419Z", + "iopub.status.busy": "2026-07-01T19:56:13.730229Z", + "iopub.status.idle": "2026-07-01T19:56:15.022611Z", + "shell.execute_reply": "2026-07-01T19:56:15.021818Z" + } + }, "outputs": [], - "source": "import numpy as np\nimport matplotlib.pyplot as plt\n\nfrom magnetics.core.qs_io_data import load_shot, valid_channels, available_subsets\nfrom magnetics.core.qs_device import resolve_channel_filter\nfrom magnetics.core.qs_run import run_steps\nfrom magnetics.core import qs_plots as plots\n\n%matplotlib inline" + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from magnetics.core.qs_io_data import load_shot, valid_channels, available_subsets\n", + "from magnetics.core.qs_device import resolve_channel_filter\n", + "from magnetics.core.qs_run import run_steps\n", + "from magnetics.core import qs_plots as plots\n", + "\n", + "%matplotlib inline" + ] }, { "cell_type": "markdown", @@ -27,24 +68,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:15.024741Z", + "iopub.status.busy": "2026-07-01T19:56:15.024491Z", + "iopub.status.idle": "2026-07-01T19:56:15.027381Z", + "shell.execute_reply": "2026-07-01T19:56:15.026888Z" + } + }, "outputs": [], "source": [ "# ── Run parameters — change these to analyse a different shot/array ──\n", "SHOT = 199749 # data/datafile/shot_.h5\n", - "CHANNEL_FILTER = \"Bp_LFS_midplane\" # friendly name (see available_subsets) or a regex\n", - "TIME_TRIM = (3.3, 3.5) # seconds; must lie inside the shot file's window\n", + "CHANNEL_FILTER = \"Bp_HFS_Sensors\" # friendly name (see available_subsets) or a regex\n", + "TIME_TRIM = (3.2, 3.48) # seconds; must lie inside the shot file's window\n", "NS, MS = (1, 2, 3), (0,) # toroidal / poloidal mode numbers\n", "\n", "# detrend: 'none' | 'baseline' | 'linear' | 'endpoints'. DETREND_BAND is the\n", "# sub-window used to estimate the trend — here the first 0.01 s of TIME_TRIM.\n", "DETREND_TYPE = \"baseline\"\n", - "DETREND_BAND = (TIME_TRIM[0], TIME_TRIM[0] + 0.01)\n", + "DETREND_BAND = (3.23, 3.25)\n", "\n", "PREP_KWARGS = dict(\n", - " cutoff_hz=(5, 250), energy=0.98, detrend_type=DETREND_TYPE, detrend_band=DETREND_BAND\n", + " cutoff_hz=(5, 1000), energy=1.0, detrend_type=DETREND_TYPE, detrend_band=DETREND_BAND\n", ")" ] }, @@ -52,14 +100,50 @@ "cell_type": "markdown", "id": "4", "metadata": {}, - "source": "## 1. Load the shot\n\n`load_shot` reads the raw sensor signals from `data/datafile/shot_.h5` and joins the\nper-channel geometry — including the derived sensor-end coordinates (`*_end1/2`) — from\n`data/device/diiid.json`. All sensor channels are interpolated onto a single common time axis\n(in seconds); the global `ip`/`bt` traces become the `plasma` Dataset. The new files carry no\nDC-coupling matrix, so `coupling` is `None`." + "source": [ + "## 1. Load the shot\n", + "\n", + "`load_shot` reads the raw sensor signals from `data/datafile/shot_.h5` and joins the\n", + "per-channel geometry — including the derived sensor-end coordinates (`*_end1/2`) — from\n", + "`data/device/diiid.json`. All sensor channels are interpolated onto a single common time axis\n", + "(in seconds); the global `ip`/`bt` traces become the `plasma` Dataset. The new files carry no\n", + "DC-coupling matrix, so `coupling` is `None`." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "5", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:15.028847Z", + "iopub.status.busy": "2026-07-01T19:56:15.028741Z", + "iopub.status.idle": "2026-07-01T19:56:16.632789Z", + "shell.execute_reply": "2026-07-01T19:56:16.632288Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Channel 'kappa' has no geometry in DIII-D device file -> skipping\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shot 199749 device DIII-D\n", + "RAW channels: 155 time samples: 799993\n", + "file window: 1.0000–5.0000 s\n", + "helicity: -1\n", + "\n", + "Bp_HFS_Sensors: 19 valid sensors -> resolves |n| <= 9\n", + "[np.str_('MPID1A049'), np.str_('MPID1A109'), np.str_('MPID1A139'), np.str_('MPID1A199'), np.str_('MPID1A244'), np.str_('MPID1B049'), np.str_('MPID1B109'), np.str_('MPID1B139'), np.str_('MPID1B199'), np.str_('MPID1B244'), np.str_('MPID1B274'), np.str_('MPID2A199'), np.str_('MPID2B199'), np.str_('MPID3A199'), np.str_('MPID3B199'), np.str_('MPID4A199'), np.str_('MPID4B199'), np.str_('MPID5A199'), np.str_('MPID5B199')]\n" + ] + } + ], "source": [ "sd = load_shot(SHOT)\n", "print(f\"shot {sd.shot} device {sd.device}\")\n", @@ -90,10 +174,52 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "7", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:16.634605Z", + "iopub.status.busy": "2026-07-01T19:56:16.634498Z", + "iopub.status.idle": "2026-07-01T19:56:16.637090Z", + "shell.execute_reply": "2026-07-01T19:56:16.636453Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bp LFS midplane ['MPID66M020', 'MPID66M067', 'MPID66M097', 'MPID66M127', 'MPID66M157', 'MPID66M200', 'MPID66M247', 'MPID66M277', 'MPID66M307', 'MPID66M340']\n", + "Bp LFS midplane bdot ['MPI66M020D', 'MPI66M067D', 'MPI66M097D', 'MPI66M127D', 'MPI66M132D', 'MPI66M137D', 'MPI66M157D', 'MPI66M200D', 'MPI66M247D', 'MPI66M277D', 'MPI66M307D', 'MPI66M312D', 'MPI66M322D', 'MPI66M340D']\n", + "Bp LFS R+1 ['MPID67A022', 'MPID67A037', 'MPID67A052', 'MPID67A097', 'MPID67A157', 'MPID67A217', 'MPID67A277', 'MPID67A337']\n", + "Bp LFS R+2 ['MPID79A072', 'MPID79A147', 'MPID79A222', 'MPID79A272']\n", + "Bp LFS R-1 ['MPID67B022', 'MPID67B037', 'MPID67B052', 'MPID67B097', 'MPID67B157', 'MPID67B217', 'MPID67B277', 'MPID67B337']\n", + "Bp LFS R-2 ['MPID79B067', 'MPID79B142', 'MPID79B217', 'MPID79B277']\n", + "Bp LFS Sensors ['MPID66M020', 'MPID66M067', 'MPID66M097', 'MPID66M127', 'MPID66M157', 'MPID66M200', 'MPID66M247', 'MPID66M277', 'MPID66M307', 'MPID66M340', 'MPID67A022', 'MPID67A037', 'MPID67A052', 'MPID67A097', 'MPID67A157', 'MPID67A217', 'MPID67A277', 'MPID67A337', 'MPID67B022', 'MPID67B037', 'MPID67B052', 'MPID67B097', 'MPID67B157', 'MPID67B217', 'MPID67B277', 'MPID67B337', 'MPID79A072', 'MPID79A147', 'MPID79A222', 'MPID79A272', 'MPID79B067', 'MPID79B142', 'MPID79B217', 'MPID79B277']\n", + "Bp HFS +midplane ['MPID1A199', 'MPID1A011', 'MPID1A049', 'MPID1A109', 'MPID1A139', 'MPID1A244', 'MPID1A274', 'MPID1A341']\n", + "Bp HFS -midplane ['MPID1B011', 'MPID1B049', 'MPID1B109', 'MPID1B139', 'MPID1B199', 'MPID1B244', 'MPID1B274', 'MPID1B341']\n", + "Bp HFS Sensors ['MPID5A199', 'MPID4A199', 'MPID3A199', 'MPID2A199', 'MPID1A199', 'MPID2B199', 'MPID3B199', 'MPID4B199', 'MPID5B199', 'MPID1A011', 'MPID1A049', 'MPID1A109', 'MPID1A139', 'MPID1A244', 'MPID1A274', 'MPID1A341', 'MPID1B011', 'MPID1B049', 'MPID1B109', 'MPID1B139', 'MPID1B199', 'MPID1B244', 'MPID1B274', 'MPID1B341']\n", + "Bp All ['MPID66M020', 'MPID66M067', 'MPID66M097', 'MPID66M127', 'MPID66M157', 'MPID66M200', 'MPID66M247', 'MPID66M277', 'MPID66M307', 'MPID66M340', 'MPID67A022', 'MPID67A037', 'MPID67A052', 'MPID67A097', 'MPID67A157', 'MPID67A217', 'MPID67A277', 'MPID67A337', 'MPID67B022', 'MPID67B037', 'MPID67B052', 'MPID67B097', 'MPID67B157', 'MPID67B217', 'MPID67B277', 'MPID67B337', 'MPID79A072', 'MPID79A147', 'MPID79A222', 'MPID79A272', 'MPID79B067', 'MPID79B142', 'MPID79B217', 'MPID79B277', 'MPID5A199', 'MPID4A199', 'MPID3A199', 'MPID2A199', 'MPID1A199', 'MPID2B199', 'MPID3B199', 'MPID4B199', 'MPID5B199', 'MPID1A011', 'MPID1A049', 'MPID1A109', 'MPID1A139', 'MPID1A244', 'MPID1A274', 'MPID1A341', 'MPID1B011', 'MPID1B049', 'MPID1B109', 'MPID1B139', 'MPID1B199', 'MPID1B244', 'MPID1B274', 'MPID1B341']\n", + "Br LFS midplane ['ISLD66M017', 'ISLD66M042', 'ISLD66M072', 'ISLD66M102', 'ISLD66M132', 'ISLD66M197', 'ISLD66M252', 'ISLD66M312']\n", + "Br LFS R+1 ['ISLD67A017', 'ISLD67A052', 'ISLD67A072', 'ISLD67A112', 'ISLD67A132', 'ISLD67A197', 'ISLD67A252', 'ISLD67A312']\n", + "Br LFS R+2 ['ISLD79A072', 'ISLD79A147', 'ISLD79A222', 'ISLD79A272']\n", + "Br LFS R-1 ['ISLD67B017', 'ISLD67B052', 'ISLD67B072', 'ISLD67B112', 'ISLD67B132', 'ISLD67B197', 'ISLD67B252', 'ISLD67B312']\n", + "Br LFS R-2 ['ISLD79B067', 'ISLD79B142', 'ISLD79B217', 'ISLD79B277']\n", + "Br LFS Sensors ['ISLD66M017', 'ISLD66M042', 'ISLD66M072', 'ISLD66M102', 'ISLD66M132', 'ISLD66M197', 'ISLD66M252', 'ISLD66M312', 'ISLD67A017', 'ISLD67A052', 'ISLD67A072', 'ISLD67A112', 'ISLD67A132', 'ISLD67A197', 'ISLD67A252', 'ISLD67A312', 'ISLD67B017', 'ISLD67B052', 'ISLD67B072', 'ISLD67B112', 'ISLD67B132', 'ISLD67B197', 'ISLD67B252', 'ISLD67B312', 'ISLD79A072', 'ISLD79A147', 'ISLD79A222', 'ISLD79A272', 'ISLD79B067', 'ISLD79B142', 'ISLD79B217', 'ISLD79B277']\n", + "Br HFS +midplane ['ISLD1A011', 'ISLD1A049', 'ISLD1A109', 'ISLD1A139', 'ISLD1A199', 'ISLD1A244', 'ISLD1A274', 'ISLD1A341']\n", + "Br HFS -midplane ['ISLD1B011', 'ISLD1B049', 'ISLD1B109', 'ISLD1B139', 'ISLD1B199', 'ISLD1B244', 'ISLD1B274', 'ISLD1B341']\n", + "Br HFS Sensors ['ISLD5A199', 'ISLD4A199', 'ISLD3A199', 'ISLD2A199', 'ISLD2B199', 'ISLD3B199', 'ISLD4B199', 'ISLD5B199', 'ISLD1A011', 'ISLD1A049', 'ISLD1A109', 'ISLD1A139', 'ISLD1A199', 'ISLD1A244', 'ISLD1A274', 'ISLD1A341', 'ISLD1B011', 'ISLD1B049', 'ISLD1B109', 'ISLD1B139', 'ISLD1B199', 'ISLD1B244', 'ISLD1B274', 'ISLD1B341']\n", + "Bp and Bp Dot All ['MPID66M020', 'MPID66M067', 'MPID66M097', 'MPID66M127', 'MPID66M157', 'MPID66M200', 'MPID66M247', 'MPID66M277', 'MPID66M307', 'MPID66M340', 'MPID67A022', 'MPID67A037', 'MPID67A052', 'MPID67A097', 'MPID67A157', 'MPID67A217', 'MPID67A277', 'MPID67A337', 'MPID67B022', 'MPID67B037', 'MPID67B052', 'MPID67B097', 'MPID67B157', 'MPID67B217', 'MPID67B277', 'MPID67B337', 'MPID79A072', 'MPID79A147', 'MPID79A222', 'MPID79A272', 'MPID79B067', 'MPID79B142', 'MPID79B217', 'MPID79B277', 'MPID5A199', 'MPID4A199', 'MPID3A199', 'MPID2A199', 'MPID1A199', 'MPID2B199', 'MPID3B199', 'MPID4B199', 'MPID5B199', 'MPID1A011', 'MPID1A049', 'MPID1A109', 'MPID1A139', 'MPID1A244', 'MPID1A274', 'MPID1A341', 'MPID1B011', 'MPID1B049', 'MPID1B109', 'MPID1B139', 'MPID1B199', 'MPID1B244', 'MPID1B274', 'MPID1B341', 'MPI66M020D', 'MPI66M067D', 'MPI66M097D', 'MPI66M127D', 'MPI66M132D', 'MPI66M137D', 'MPI66M157D', 'MPI66M200D', 'MPI66M247D', 'MPI66M277D', 'MPI66M307D', 'MPI66M312D', 'MPI66M322D', 'MPI66M340D']\n", + "Br All ['ISLD66M017', 'ISLD66M042', 'ISLD66M072', 'ISLD66M102', 'ISLD66M132', 'ISLD66M197', 'ISLD66M252', 'ISLD66M312', 'ISLD67A017', 'ISLD67A052', 'ISLD67A072', 'ISLD67A112', 'ISLD67A132', 'ISLD67A197', 'ISLD67A252', 'ISLD67A312', 'ISLD67B017', 'ISLD67B052', 'ISLD67B072', 'ISLD67B112', 'ISLD67B132', 'ISLD67B197', 'ISLD67B252', 'ISLD67B312', 'ISLD79A072', 'ISLD79A147', 'ISLD79A222', 'ISLD79A272', 'ISLD79B067', 'ISLD79B142', 'ISLD79B217', 'ISLD79B277', 'ISLD5A199', 'ISLD4A199', 'ISLD3A199', 'ISLD2A199', 'ISLD2B199', 'ISLD3B199', 'ISLD4B199', 'ISLD5B199', 'ISLD1A011', 'ISLD1A049', 'ISLD1A109', 'ISLD1A139', 'ISLD1A199', 'ISLD1A244', 'ISLD1A274', 'ISLD1A341', 'ISLD1B011', 'ISLD1B049', 'ISLD1B109', 'ISLD1B139', 'ISLD1B199', 'ISLD1B244', 'ISLD1B274', 'ISLD1B341']\n", + "Upper I-coils ['IU30', 'IU90', 'IU150', 'IU210', 'IU270', 'IU330']\n", + "Lower I-coils ['IL30', 'IL90', 'IL150', 'IL210', 'IL270', 'IL330']\n", + "C-coils ['C19', 'C79', 'C139', 'C199', 'C259', 'C319']\n", + "All 3D Coils ['C19', 'C79', 'C139', 'C199', 'C259', 'C319', 'IL30', 'IL90', 'IL150', 'IL210', 'IL270', 'IL330', 'IU30', 'IU90', 'IU150', 'IU210', 'IU270', 'IU330']\n", + "All LFS Bp Arrays ['MPID79B067', 'MPID79B142', 'MPID79B217', 'MPID79B277', 'MPID67B022', 'MPID67B037', 'MPID67B052', 'MPID67B097', 'MPID67B157', 'MPID67B217', 'MPID67B277', 'MPID67B337', 'MPID66M020', 'MPID66M067', 'MPID66M097', 'MPID66M127', 'MPID66M157', 'MPID66M200', 'MPID66M247', 'MPID66M277', 'MPID66M307', 'MPID66M340', 'MPID67A022', 'MPID67A037', 'MPID67A052', 'MPID67A097', 'MPID67A157', 'MPID67A217', 'MPID67A277', 'MPID67A337', 'MPID79A072', 'MPID79A147', 'MPID79A222', 'MPID79A272']\n", + "All LFS Br Arrays ['ISLD79B067', 'ISLD79B142', 'ISLD79B217', 'ISLD79B277', 'ISLD67B017', 'ISLD67B052', 'ISLD67B072', 'ISLD67B112', 'ISLD67B132', 'ISLD67B197', 'ISLD67B252', 'ISLD67B312', 'ISLD66M017', 'ISLD66M042', 'ISLD66M072', 'ISLD66M102', 'ISLD66M132', 'ISLD66M197', 'ISLD66M252', 'ISLD66M312', 'ISLD67A017', 'ISLD67A052', 'ISLD67A072', 'ISLD67A112', 'ISLD67A132', 'ISLD67A197', 'ISLD67A252', 'ISLD67A312', 'ISLD79A072', 'ISLD79A147', 'ISLD79A222', 'ISLD79A272']\n" + ] + } + ], "source": [ "for name, sensors in available_subsets(sd.device).items():\n", " print(f\"{name:24s} {sensors}\")" @@ -111,10 +237,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "9", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:16.639188Z", + "iopub.status.busy": "2026-07-01T19:56:16.639062Z", + "iopub.status.idle": "2026-07-01T19:56:16.829471Z", + "shell.execute_reply": "2026-07-01T19:56:16.828872Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(1, 2, figsize=(12, 5))\n", "plots.plot_sensors(sd.raw, ARRAY_REGEX, geometry=\"rz\", ax=ax[0])\n", @@ -139,10 +283,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "11", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:16.831349Z", + "iopub.status.busy": "2026-07-01T19:56:16.831234Z", + "iopub.status.idle": "2026-07-01T19:56:17.064835Z", + "shell.execute_reply": "2026-07-01T19:56:17.064298Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sets = [\"Bp_LFS_midplane\", \"Bp_LFS_R+1\", \"Bp_LFS_R-1\", \"Bp_LFS_R+2\", \"Bp_LFS_R-2\", \"Bp_HFS_Sensors\"]\n", "colors = plt.cm.tab10.colors\n", @@ -179,10 +341,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "13", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:17.066526Z", + "iopub.status.busy": "2026-07-01T19:56:17.066366Z", + "iopub.status.idle": "2026-07-01T19:56:18.386019Z", + "shell.execute_reply": "2026-07-01T19:56:18.385501Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Channel 'kappa' has no geometry in DIII-D device file -> skipping\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "condition number K = 9.14\n", + "mean reduced chi^2 = 26.9\n", + "data-matrix SVD effective rank (98% energy) = 19 of 19 sensors\n" + ] + } + ], "source": [ "r = run_steps(\n", " SHOT,\n", @@ -212,10 +399,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "15", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:18.387431Z", + "iopub.status.busy": "2026-07-01T19:56:18.387325Z", + "iopub.status.idle": "2026-07-01T19:56:18.571750Z", + "shell.execute_reply": "2026-07-01T19:56:18.571274Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plots.plot_signal(r.raw, r.prepared, ARRAY_REGEX)\n", "plt.gcf().set_size_inches(9, 4)" @@ -235,10 +440,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "17", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:18.573212Z", + "iopub.status.busy": "2026-07-01T19:56:18.573127Z", + "iopub.status.idle": "2026-07-01T19:56:18.732451Z", + "shell.execute_reply": "2026-07-01T19:56:18.732008Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([,\n", + " ],\n", + " dtype=object)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plots.plot_svds(r.fit)" ] @@ -257,10 +492,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "19", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:18.733871Z", + "iopub.status.busy": "2026-07-01T19:56:18.733761Z", + "iopub.status.idle": "2026-07-01T19:56:19.093388Z", + "shell.execute_reply": "2026-07-01T19:56:19.092887Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([,\n", + " ,\n", + " ], dtype=object)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plots.plot_fit(r.fit)" ] @@ -280,10 +545,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "21", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:19.094951Z", + "iopub.status.busy": "2026-07-01T19:56:19.094845Z", + "iopub.status.idle": "2026-07-01T19:56:19.243720Z", + "shell.execute_reply": "2026-07-01T19:56:19.243186Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([,\n", + " ], dtype=object)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plots.plot_fit_modes(r.fit)" ] @@ -303,10 +597,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "23", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-01T19:56:19.245382Z", + "iopub.status.busy": "2026-07-01T19:56:19.245282Z", + "iopub.status.idle": "2026-07-01T19:56:19.401420Z", + "shell.execute_reply": "2026-07-01T19:56:19.400937Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# fix_value is the poloidal angle of the slice; the LFS-midplane array sits at theta ~ 0\n", "plots.plot_slice(r.fit, fix_coord=\"theta\", fix_value=0.0)" @@ -316,14 +638,23 @@ "cell_type": "markdown", "id": "24", "metadata": {}, - "source": "---\n### Recap\n\nWe reproduced the VISION §4.1 SLCONTOUR outputs locally with the `magnetics.core.qs_*` pipeline,\ndriven off the `data/datafile/shot_.h5` signals and `data/device/diiid.json` geometry: sensor\nmap, conditioned signals, data/design-matrix SVD diagnostics, fit quality, **amplitude & phase of\neach (n, m) mode vs time**, and the **phi-vs-time contour**. To analyse a different shot or array,\nedit the **Parameters** cell (`SHOT`, `CHANNEL_FILTER`, `TIME_TRIM`, `NS`/`MS`)." + "source": [ + "---\n", + "### Recap\n", + "\n", + "We reproduced the VISION §4.1 SLCONTOUR outputs locally with the `magnetics.core.qs_*` pipeline,\n", + "driven off the `data/datafile/shot_.h5` signals and `data/device/diiid.json` geometry: sensor\n", + "map, conditioned signals, data/design-matrix SVD diagnostics, fit quality, **amplitude & phase of\n", + "each (n, m) mode vs time**, and the **phi-vs-time contour**. To analyse a different shot or array,\n", + "edit the **Parameters** cell (`SHOT`, `CHANNEL_FILTER`, `TIME_TRIM`, `NS`/`MS`)." + ] } ], "metadata": { "kernelspec": { - "display_name": "Magnetics (uv 3.14)", + "display_name": "magnetics (3.14.x)", "language": "python", - "name": "magnetics-uv" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -340,4 +671,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/uv.lock b/uv.lock index 555990f..b562fbf 100644 --- a/uv.lock +++ b/uv.lock @@ -7,10 +7,6 @@ resolution-markers = [ "sys_platform != 'emscripten' and sys_platform != 'win32'", ] -[options] -exclude-newer = "2026-06-24T04:49:47.509798Z" -exclude-newer-span = "P1W" - [[package]] name = "annotated-doc" version = "0.0.4" @@ -1319,7 +1315,7 @@ name = "pexpect" version = "4.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "ptyprocess" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } wheels = [ From 1f26645609e2e1ec761954eacc5473cf66648c86 Mon Sep 17 00:00:00 2001 From: priyanshlunia <40486607+priyanshlunia@users.noreply.github.com> Date: Wed, 1 Jul 2026 16:44:09 -0400 Subject: [PATCH 3/4] refactor(qs): drop hardcoded device alias + DIII-D coil warning from core Two device-specific bits removed from the QS core (issue #40 device-agnostic goal), without touching data/device/*.json or the data layer: - qs_device: delete the hardcoded `_DEVICE_ALIAS = {"DIII-D": "diiid"}` and `_device_key`; `load_device` now delegates to `devices.resolve_device_id`, which derives the config id from each device JSON's `name` field. - qs_fit: remove the advisory `is_device("DIII-D")` + `C.*/IL.*/IU.*` coil-basis warning and its now-unused `is_device` import. The 2019 ESLD wiring swap in qs_prep is intentionally kept for now (migrating it needs a JSON `corrections` block + reader, deferred). ruff/ty clean; 290 passed. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/magnetics/core/qs_device.py | 22 ++++++++-------------- src/magnetics/core/qs_fit.py | 7 ------- 2 files changed, 8 insertions(+), 21 deletions(-) diff --git a/src/magnetics/core/qs_device.py b/src/magnetics/core/qs_device.py index 6e68411..45d7e44 100644 --- a/src/magnetics/core/qs_device.py +++ b/src/magnetics/core/qs_device.py @@ -32,22 +32,16 @@ from ..data import devices as _devices from ..data import diiid_geometry as _diiid_geo -# ``data.devices.load_device`` resolves ``.json`` by lowercasing the name; a few -# display names don't slugify by lowercasing alone (``"DIII-D"`` → ``diiid.json``, not -# ``diii-d.json``). Preserve the alias the old shim carried. -_DEVICE_ALIAS = {"DIII-D": "diiid"} - - -def _device_key(device: str) -> str: - """Map a device display name to its ``data/device/.json`` stem.""" - if device in _DEVICE_ALIAS: - return _DEVICE_ALIAS[device] - return re.sub(r"[^a-z0-9]", "", str(device).lower()) - def load_device(device: str = "DIII-D") -> dict: - """The parsed device JSON dict, via the data layer (with QS name aliasing).""" - return _devices.load_device(_device_key(device)) + """The parsed device JSON dict, via the data layer's name/id resolver. + + ``devices.resolve_device_id`` maps a display name (e.g. ``"DIII-D"``) or a config + id to the JSON file stem using each device file's ``name`` field — so no device + alias is hardcoded here. Falls back to a slugified name if it can't be resolved. + """ + dev_id = _devices.resolve_device_id(device) or re.sub(r"[^a-z0-9]", "", str(device).lower()) + return _devices.load_device(dev_id) # ── device-name comparison ───────────────────────────────────────────────────── diff --git a/src/magnetics/core/qs_fit.py b/src/magnetics/core/qs_fit.py index e6f8b92..2584e5f 100644 --- a/src/magnetics/core/qs_fit.py +++ b/src/magnetics/core/qs_fit.py @@ -33,8 +33,6 @@ import numpy as np import xarray as xr -from .qs_device import is_device - logger = logging.getLogger(__name__) @@ -264,11 +262,6 @@ def _printv(*a): _ncycle = _mcycle = 0 _nepsilon = _mepsilon = np.inf - if is_device(ds.attrs.get("device", ""), "DIII-D"): - if any(re.match(k, c) for k in ("C.*", "IL.*", "IU.*") for c in channels): - if fit_basis != "sinusoidal-point": - logger.warning("sinusoidal-point basis is used by DIII-D 3D coil operators") - elif is_gaussian: # Derive RBF centres from sensor extent (mirrors OMFIT gaussian setup block) x_all = np.hstack((x1, x2)) From da784cce8852c4b73759ee0f507e42f43c47a2a5 Mon Sep 17 00:00:00 2001 From: priyanshlunia <40486607+priyanshlunia@users.noreply.github.com> Date: Wed, 1 Jul 2026 17:26:23 -0400 Subject: [PATCH 4/4] feat(qs): compute helicity from Ip/Bt instead of a hardcoded default MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Out of this branch's original (pairwise-difference) scope — an opportunistic fidelity fix spotted while investigating the example notebook. qs_io_data hardcoded the plasma `helicity` attr to -1, even though it loads the shot's `ip`/`bt` traces. helicity sets the fitted poloidal-mode (m) sign convention, so a blanket -1 is silently wrong for reversed-Bt/Ip shots. Now `_compute_helicity` derives it as sign(median Bt)/sign(median Ip) (matching OMFIT init_magnetics); the `helicity=-1` argument is kept only as a fallback for shots missing those traces. - core/qs_io_data.py: add `_compute_helicity`, wire into `_build_plasma`, clarify the fallback-only role of the parameter. - tests: unit coverage of the sign logic + a pipeline check that the synthetic shot's helicity is the computed +1, not the fallback. - docs (quasistationary-mode-analysis.md, CLAUDE.md): helicity is no longer an open item; the remaining QS-fidelity gap is per-sensor sigma. No effect on the default ms=(0,) fits (helicity only flips non-zero m). ruff/ty clean; 301 passed, 5 skipped. Co-Authored-By: Claude Opus 4.8 (1M context) --- CLAUDE.md | 8 +++--- docs/specs/quasistationary-mode-analysis.md | 7 +++--- src/magnetics/core/qs_io_data.py | 28 +++++++++++++++++---- tests/test_qs_pipeline.py | 22 ++++++++++++++++ 4 files changed, 53 insertions(+), 12 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index ab874fb..945f7f8 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -39,7 +39,7 @@ DIII-D shots: - **QS live (Day-3 night):** `qs_fit` / `phi_t` / `fit_quality` / `chi_sq_t` / sensor-map / signal nodes serve the **real** SLCONTOUR fit. Shots pulled rotating-only (no Bp LFS midplane array) return a clean 422 and the QS tab shows a "no quasi-stationary array" banner. Remaining fidelity - gap: the data layer's per-sensor σ / helicity (fit currently uses a constant σ). + gap: the data layer's per-sensor σ (the fit uses a constant σ; helicity is computed from Ip·Bt). - **Geometry shot-indexed (Day-3 night):** `data/device/diiid.json` sensor availability + positions are now segmented back to shot 124400 (legacy dense set) / 151593 (3D-upgrade). The Sensors tab renders wall + vacuum vessel + perturbation coils + saddle loops (2D honoring each loop's tilt). @@ -71,13 +71,13 @@ rather than fabricating data in the GUI. Keep `contracts.py` and `contract.ts` i label → live via `usingLiveBackend()`; build the Sensors geometry view). - **Slow Rollers + Meg (quasi-stationary):** the real `qs_fit` node (K / χ² / modes) + the QS GUI tab are **live** (Day-3 night). Remaining: finish the pure `core/quasistationary.py` port and - wire it in place of the `_slcontour` reference pipeline (#40); consume real per-sensor σ + - helicity once the data layer provides them (the fit currently uses a constant σ). + wire it in place of the `_slcontour` reference pipeline (#40); consume real per-sensor σ once the + data layer provides it (the fit currently uses a constant σ; helicity is computed from Ip·Bt). - **Data Streamers:** the DIII-D geometry table is now **shot-indexed** (`diiid.json` segmented to 124400 / 151593; the cosmetic θ in `magnetics/data/diiid.py` — now a thin shim over the device-agnostic `data/device_geom.py` — is superseded by the real device table). NSTX/NSTX-U fetch + node rendering landed on `feature/nstxu-data-fetch` (see the NSTX status bullet above). - Remaining: give `h5source` per-sensor σ + helicity (last QS-fidelity gap); a `DataSource` + Remaining: give `h5source` per-sensor σ (last QS-fidelity gap; helicity now computed from Ip·Bt); a `DataSource` abstraction with an array cache; populate the shot-segmented legacy-NSTX tree/wall from the `config_hf/hn.mm` files; import other-device geometry the same way. - **Structural cleanup (LANDED — PR #41, Day-2 night):** the project was hoisted to the repo root diff --git a/docs/specs/quasistationary-mode-analysis.md b/docs/specs/quasistationary-mode-analysis.md index b273f30..c032cc5 100644 --- a/docs/specs/quasistationary-mode-analysis.md +++ b/docs/specs/quasistationary-mode-analysis.md @@ -52,7 +52,8 @@ include `device`, `shot`, `tmin`/`tmax` (ms). per-channel geometry joined from the device JSON, including the derived `*_end1/2` coordinates. All sensor channels are interpolated onto one common time axis (the densest native grid, clipped to the window they share). -- `plasma` — `Ip`, `Bt` from the `ip`/`bt` channels (time in **ms**), `helicity` attr (default −1). +- `plasma` — `Ip`, `Bt` from the `ip`/`bt` channels (time in **ms**), and a `helicity` attr computed + as sign(Bt·Ip) from those traces (−1 fallback when they're absent). - `coupling` — `None`; the new files carry no DC vacuum-coupling matrix, so `qs_prep`'s DC compensation (`dc_comp=True`) is unavailable. @@ -108,8 +109,8 @@ flips helicity. A regression test in `tests/test_qs_bridge.py` pins this. ## Notes & limitations - Reduced χ² typically runs above 1 because the constant 2e-5 T sensor σ is optimistic relative to - higher-n structure not in the basis; residuals stay small versus the signals. Per-sensor σ / - helicity from the data layer is an open item. + higher-n structure not in the basis; residuals stay small versus the signals. Per-sensor σ from the + data layer is an open item (helicity is now computed from the shot's Ip·Bt in `qs_io_data`). - The pure-numpy relatives of `qs_fit` (a device-agnostic `core` port) and the `data/`-layer set-flattening dedup are open follow-ups. - Out of scope for this path: the rotating-mode spectrogram/MODESPEC analysis, 3D coil-current fits, diff --git a/src/magnetics/core/qs_io_data.py b/src/magnetics/core/qs_io_data.py index ab5c23e..7b03272 100644 --- a/src/magnetics/core/qs_io_data.py +++ b/src/magnetics/core/qs_io_data.py @@ -82,8 +82,10 @@ def load_shot(shot, data_root=DATAFILE_ROOT, helicity=-1): :param shot: shot number (int/str) or a path to a ``shot_.h5`` file. :param data_root: directory holding the ``shot_.h5`` files. - :param helicity: field/current helicity convention used to orient mode signs - (default ``-1``; the new data files do not store it). + :param helicity: **fallback** helicity only. The real value (sign of Bt·Ip, used + to orient the poloidal-mode sign) is computed from the shot's own ``ip``/``bt`` + traces; the default ``-1`` is used only when those are missing (the data files + do not store helicity directly). :return: :class:`ShotData` (``coupling`` is ``None`` — the new files carry no DC vacuum-coupling matrix). """ @@ -160,11 +162,27 @@ def _build_raw(names, sigs, times, geo, shot_no, device): return raw +def _compute_helicity(sigs, fallback=-1): + """Field/current helicity = sign(median Bt) / sign(median Ip) (±1), from the shot's + own ``bt``/``ip`` traces (matches OMFIT ``init_magnetics``) — it orients the fitted + poloidal-mode sign. Returns ``fallback`` when either trace is absent or its median + sign is 0 (indeterminate).""" + if "bt" in sigs and "ip" in sigs: + sbt = np.sign(np.nanmedian(np.asarray(sigs["bt"], dtype=float))) + sip = np.sign(np.nanmedian(np.asarray(sigs["ip"], dtype=float))) + if sbt != 0 and sip != 0: + return int(sbt / sip) + return int(fallback) + + def _build_plasma(sigs, times, helicity): - """Assemble the ``plasma`` Dataset (Ip/Bt on a shared ms time base).""" + """Assemble the ``plasma`` Dataset (Ip/Bt on a shared ms time base). + + The ``helicity`` attr is computed from the ``ip``/``bt`` medians + (:func:`_compute_helicity`); the ``helicity`` argument is only the fallback.""" if not sigs: plasma = xr.Dataset(coords={"time": np.array([], dtype=float)}) - plasma.attrs["helicity"] = int(helicity) + plasma.attrs["helicity"] = _compute_helicity(sigs, helicity) return plasma base = "ip" if "ip" in times else next(iter(times)) @@ -181,7 +199,7 @@ def _build_plasma(sigs, times, helicity): data_vars[var] = ("time", y) plasma = xr.Dataset(data_vars, coords={"time": t_ms}) - plasma.attrs["helicity"] = int(helicity) + plasma.attrs["helicity"] = _compute_helicity(sigs, helicity) return plasma diff --git a/tests/test_qs_pipeline.py b/tests/test_qs_pipeline.py index cdc3214..2394805 100644 --- a/tests/test_qs_pipeline.py +++ b/tests/test_qs_pipeline.py @@ -20,6 +20,28 @@ def _all_finite_grid(node): return np.all(np.isfinite(z)) +def test_compute_helicity_from_ip_bt(): + """Helicity = sign(median Bt)/sign(median Ip); fallback when a trace is missing or + its median sign is indeterminate.""" + from magnetics.core.qs_io_data import _compute_helicity + + assert _compute_helicity({"bt": np.array([-2.0, -2.1]), "ip": np.array([1e6, 1.1e6])}) == -1 + assert _compute_helicity({"bt": np.array([2.0]), "ip": np.array([1e6])}) == 1 + assert _compute_helicity({"bt": np.array([-2.0]), "ip": np.array([-1e6])}) == 1 + assert _compute_helicity({}, fallback=-1) == -1 + assert _compute_helicity({"ip": np.array([1e6])}, fallback=-1) == -1 + assert _compute_helicity({"bt": np.array([0.0]), "ip": np.array([1e6])}, fallback=-1) == -1 + + +def test_pipeline_helicity_is_computed_not_defaulted(synthetic_shot): + """The synthetic shot has +Bt / +Ip, so the loaded plasma helicity is the computed + +1 — not the -1 fallback.""" + from magnetics.core.qs_io_data import load_shot + + sd = load_shot(synthetic_shot) + assert sd.plasma.attrs["helicity"] == 1 + + def test_qs_fit_returns_a_finite_contour(synthetic_shot): node = nodes.build_node(synthetic_shot, "qs_fit") assert node["kind"] == "contour"