Files
muSRFlow/muSRFitParameterPlot.js
T

3017 lines
128 KiB
JavaScript

// Copyright (C) 2026 Zaher Salman
// SPDX-License-Identifier: GPL-3.0-or-later
// Floating parameter plots for muSRFlow.
//
// The input is the whitespace-separated table produced by
// `msr2data ... data -o <file>`. This file deliberately contains no fitting
// logic: both Electron and the web runner only pass the generated table path.
let musrfitParameterPlotSequence = 0;
function musrfitParameterPlotPlatform() {
let platform = window.MusrfitParameterPlotPlatform || {};
return platform;
}
function parseMusrfitParameterData(contents) {
// Preserve msr2data column names exactly. Only the leading '%' comment
// marker used by some versions is removed from the header line.
let lines = String(contents || "").split(/\r?\n/);
let columns = [];
let rows = [];
for (let rawLine of lines) {
let line = rawLine.trim();
if (!line || line.startsWith("#")) {
continue;
}
if (!columns.length) {
if (line.startsWith("%")) {
line = line.substring(1).trim();
}
columns = line.split(/\s+/).filter(Boolean).map(function(column) {
return column.replace(/,+$/, "");
});
continue;
}
// A second comment/header line is not numerical data.
if (line.startsWith("%") || line.startsWith("#")) {
continue;
}
let fields = line.split(/\s+/);
if (fields.length < columns.length) {
continue;
}
let row = [];
let hasNumber = false;
for (let i = 0; i < columns.length; i++) {
let value = Number(fields[i]);
if (Number.isFinite(value)) {
row.push(value);
hasNumber = true;
} else {
// Plotly treats null as a missing point; NaN would leak into JSON
// operations and makes tests/export less predictable.
row.push(null);
}
}
if (hasNumber) {
rows.push(row);
}
}
return { columns: columns, rows: rows };
}
function musrfitParameterColumnIndex(dataset, name) {
let requested = String(name || "").toLowerCase();
for (let i = 0; i < dataset.columns.length; i++) {
if (String(dataset.columns[i]).toLowerCase() === requested) {
return i;
}
}
return -1;
}
function musrfitParameterColumnValues(dataset, columnIndex) {
return dataset.rows.map(function(row) {
return row[columnIndex];
});
}
function musrfitParameterColumnVaries(dataset, columnIndex) {
let values = new Set();
for (let row of dataset.rows) {
let value = row[columnIndex];
if (Number.isFinite(value)) {
values.add(value);
if (values.size > 1) return true;
}
}
return false;
}
function defaultMusrfitParameterXColumn(dataset) {
return detectMusrfitScanVariable(dataset).column;
}
const musrfitScanCandidateOrder = ["dataT", "dataB", "dataE", "dataSpinRot", "RUN"];
// Determine the scan variable for a finished multi-run parameter table. A scan
// description reports the selected column plus its coverage, distinct-value
// count, numeric range, confidence, and any alternative varying metadata. The
// candidate column is chosen only when it clearly dominates: it must cover all
// rows with more than one distinct value, and no other candidate may also vary
// strongly. Otherwise the result is ambiguous and the highest-coverage
// candidate is returned as a safe fallback.
function detectMusrfitScanVariable(dataset) {
let registry = {};
for (let name of musrfitScanCandidateOrder) {
let column = musrfitParameterColumnIndex(dataset, name);
let scan = { name: name, column: column, label: musrfitParameterAxisLabel(name) };
if (column < 0) {
scan.ranged = 0;
scan.distinct = 0;
scan.coverage = 0;
scan.score = 0;
} else {
let finite = musrfitParameterColumnValues(dataset, column)
.filter(function(value) { return Number.isFinite(value); });
scan.coverage = dataset.rows.length ? finite.length / dataset.rows.length : 0;
let distinct = new Set(finite);
scan.distinct = distinct.size;
if (distinct.size === 0) {
scan.ranged = 0;
scan.score = 0;
} else {
let min = Infinity;
let max = -Infinity;
for (let value of distinct) {
if (value < min) min = value;
if (value > max) max = value;
}
scan.ranged = max - min;
let floors = { dataT: 1, dataB: 10, dataE: 1, dataSpinRot: 1, RUN: 0 };
let floor = floors[scan.name] !== undefined ? floors[scan.name] : 0;
scan.score = scan.coverage === 1 && distinct.size > 1
&& scan.ranged > floor ? 1 : 0;
}
}
registry[name] = scan;
}
// Only genuine metadata scan variables (temperature, field, energy, spin
// rotation) decide which variable is being scanned. The run number always
// advances between serial runs, so it is never treated as a competing scan
// variable; it is only used as a fallback when nothing else varies.
let metadataCandidates = musrfitScanCandidateOrder.filter(function(name) {
return name !== "RUN";
});
let varying = [];
for (let name of metadataCandidates) {
let scan = registry[name];
if (scan.score === 1) varying.push(scan.name);
}
// Choose the candidate with the largest numeric range among the metadata
// scan variables that look like a genuine varying scan (full coverage,
// multiple distinct values).
let winner = null;
for (let name of metadataCandidates) {
let scan = registry[name];
if (scan.score !== 1) continue;
if (!winner || scan.ranged > winner.ranged) winner = scan;
}
let resolution = "low";
if (varying.length === 1) {
resolution = "high";
} else if (varying.length > 1) {
resolution = "ambiguous";
}
// With no clearly varying metadata scan, fall back to the run-number column
// (which always advances), or to the highest-coverage metadata column.
if (!winner) {
let runIndex = musrfitParameterColumnIndex(dataset, "RUN");
if (runIndex >= 0) {
winner = registry["RUN"];
} else {
for (let name of metadataCandidates) {
let scan = registry[name];
if (scan.column < 0) continue;
if (!winner || scan.coverage > winner.coverage) winner = scan;
}
}
}
let alternatives = [];
for (let name of musrfitScanCandidateOrder) {
if (!winner || registry[name].name !== winner.name) {
alternatives.push(registry[name].name);
}
}
return {
column: winner ? winner.column : dataset.columns.length ? 0 : -1,
name: winner ? winner.name : (dataset.columns.length ? dataset.columns[0] : ""),
label: winner ? winner.label : "",
coverage: winner ? winner.coverage : 0,
distinct: winner ? winner.distinct : 0,
ranged: winner ? winner.ranged : 0,
confidence: resolution,
alternatives: alternatives,
varying: varying
};
}
// A compact "fixed-coordinate" legend tag for an overlaid scan, derived from
// the data set's own scan variable: an energy scan is tagged with its constant
// temperature, a temperature scan with its constant energy (LE-µSR) or field
// (bulk µSR), a field scan with its constant temperature or energy. This makes
// the legend say which physical state each curve represents instead of just a
// file name. Returns "" when no unambiguous fixed coordinate is present.
function musrfitParameterFixedCoordinateLegend(dataset) {
if (!dataset || !dataset.columns || !dataset.rows || !dataset.rows.length) return "";
let scanName = detectMusrfitScanVariable(dataset).name;
let priorities = [];
if (scanName === "dataE") {
priorities = ["dataT", "dataB"];
} else if (scanName === "dataT") {
priorities = ["dataE", "dataB"];
} else if (scanName === "dataB") {
priorities = ["dataT", "dataE"];
} else {
priorities = ["dataT", "dataB", "dataE"];
}
let shortNames = { dataT: "T", dataB: "B", dataE: "E", dataSpinRot: "SR" };
let units = { dataT: "K", dataB: "G", dataE: "keV", dataSpinRot: "\u00b0" };
for (let name of priorities) {
let column = musrfitParameterColumnIndex(dataset, name);
if (column < 0) continue;
let distinct = new Set(musrfitParameterColumnValues(dataset, column)
.filter(function(value) { return Number.isFinite(value); }));
if (distinct.size !== 1) continue;
let value = distinct.values().next().value;
let base = shortNames[name] || name;
let magnitude = Math.abs(value);
let digits = magnitude >= 100 ? 0 : (magnitude >= 10 ? 1 : (magnitude >= 1 ? 2 : 4));
let number = Number(value.toFixed(digits));
return base + " = " + number + (units[name] ? " " + units[name] : "");
}
return "";
}
// The default legend prefix for one data set in overlay mode: the data set's
// plain file label plus the fixed-coordinate tag when available (so curves are
// told apart by their physical state too), for example "514_par.dat (T = 4 K)".
function musrfitParameterOverlayPrefix(entry, dataset) {
let label = (entry && entry.label) ? entry.label : "data set";
let fixed = musrfitParameterFixedCoordinateLegend(dataset);
return fixed ? label + " (" + fixed + ")" : label;
}
function musrfitParameterLegendOverrideKey(dataSetKey, yName) {
return dataSetKey + "\u0000" + (yName || "");
}
// Built-in parameter-plot templates are declarative data: a stable identifier,
// a human name, the compatible X-variable names, the panel layout, shared-X
// behavior, and per-panel semantic parameter roles. Templates are applied by
// initializing the existing multi-panel plot state rather than by creating new
// plotting code per experiment type.
const MUSRFIT_PARAMETER_PLOT_TEMPLATES = [
{
id: "tf-scan",
name: "TF scan",
compatibleX: ["dataB", "dataE", "dataT"],
sharedX: true,
layout: "3x1",
panels: [
{
role: "amplitude",
title: "Amplitude",
params: ["A0", "Asy", "Alpha", "Pini"]
},
{
role: "damping",
title: "Damping",
params: ["Lam", "Sgm"]
},
{
role: "frequency",
title: "Frequency",
params: ["Frq", "Omega", "Nu"]
}
]
}
];
// Templates are consumed by this same script in the app, but also need to be
// reachable from the global object so host-side tools (tests, the web shell,
// the Electron shell) can inspect the declarative data.
if (typeof globalThis !== "undefined") {
globalThis.MUSRFIT_PARAMETER_PLOT_TEMPLATES = MUSRFIT_PARAMETER_PLOT_TEMPLATES;
}
// Parameter-plot layout modes offered by the axis dialog. "auto" lays one
// parameter per panel and picks a near-square grid that adapts to the number of
// selected parameters; the explicit row/column modes force the arrangement.
const MUSRFIT_PARAMETER_PLOT_LAYOUT_MODES = [
{ value: "auto", label: "Auto" },
{ value: "row", label: "Single row" },
{ value: "col", label: "Single column" }
];
if (typeof globalThis !== "undefined") {
globalThis.MUSRFIT_PARAMETER_PLOT_LAYOUT_MODES = MUSRFIT_PARAMETER_PLOT_LAYOUT_MODES;
}
var parameterPlotLayoutStorageKey = "musrflow.parameterPlotLayout";
function rememberedParameterPlotLayoutMode() {
try {
if (typeof window !== "undefined" && window.localStorage) {
let stored = window.localStorage.getItem(parameterPlotLayoutStorageKey);
if (stored === "row" || stored === "col" || stored === "auto") return stored;
}
} catch (error) {
/* Storage can be unavailable; fall back to Auto. */
}
return "auto";
}
function rememberParameterPlotLayoutMode(mode) {
if (mode !== "row" && mode !== "col" && mode !== "auto") return;
try {
if (typeof window !== "undefined" && window.localStorage) {
window.localStorage.setItem(parameterPlotLayoutStorageKey, mode);
}
} catch (error) {
/* Ignore persistence failures; the choice still applies for this plot. */
}
}
// Resolve a layout mode to a concrete "rows x columns" grid for the given
// number of parameters. Auto keeps up to three parameters in a single column
// (they all share the X axis) and beyond that grows toward a square grid:
// 4 -> 2x2, 5-6 -> 2x3, 9 -> 3x3, 10 -> 3x4, 12 -> 3x4, 16 -> 4x4, ...
function musrfitParameterLayoutFromMode(mode, count) {
let n = Math.max(1, Math.floor(Number(count) || 1));
if (mode === "row") return "1x" + n;
if (mode === "col") return n + "x1";
if (n <= 1) return "1x1";
if (n <= 3) return n + "x1";
let columns = Math.ceil(Math.sqrt(n));
let rows = Math.ceil(n / columns);
return rows + "x" + columns;
}
// Resolve a template's semantic parameter roles against the actual columns in a
// parameter table. Each panel may accept several equivalent names (for example
// the damping panel can take `Lam` or `Sgm`); the first name present in the
// table is used and unmatched roles are omitted rather than guessed. Run-scoped
// parameter names such as `Lam_2255` are matched by their base name.
function musrfitParameterTemplatePanelNames(dataset, params) {
let names = [];
let used = new Set();
let yCandidates = musrfitParameterYCandidates(dataset, -1);
for (let requested of params) {
let wanted = String(requested).toLowerCase();
for (let i = 0; i < dataset.columns.length; i++) {
let column = dataset.columns[i];
if (!yCandidates.includes(i)) continue;
let base = String(column).replace(/_\d+$/, "").toLowerCase();
if ((base.toLowerCase() === wanted || base === wanted) && !used.has(i)) {
names.push(column);
used.add(i);
break;
}
}
}
return names;
}
// Apply a declarative template to a parameter table, returning the panels and
// shared-X column that initialize the existing plot state. When the table's
// detected scan variable is not compatible with the template, the template is
// still applied but the X column falls back to the detected variable.
function applyMusrfitParameterTemplate(templateId, dataset, xColumnName) {
let template = MUSRFIT_PARAMETER_PLOT_TEMPLATES.find(function(item) {
return item.id === templateId;
});
if (!template || !dataset || !dataset.columns.length) {
return { panels: [], xName: xColumnName || "", layout: "1x1", sharedX: false, template: template || null };
}
let panels = template.panels.map(function(panel) {
return {
role: panel.role,
title: panel.title,
params: panel.params,
yNames: musrfitParameterTemplatePanelNames(dataset, panel.params)
};
});
return {
panels: panels,
xName: xColumnName || "",
layout: template.layout,
sharedX: !!template.sharedX,
template: template
};
}
function musrfitParameterAbsoluteColumnValues(dataset, columnIndex) {
return musrfitParameterColumnValues(dataset, columnIndex).map(function(value) {
return Number.isFinite(value) ? Math.abs(value) : null;
});
}
function musrfitParameterErrorColumns(dataset, valueIndex) {
if (valueIndex < 0 || valueIndex >= dataset.columns.length) {
return { positive: -1, negative: -1, symmetric: -1 };
}
let name = dataset.columns[valueIndex];
// msr2data versions use both Asy_PosErr and AsyPosErr. Run-qualified
// parameters similarly appear as Asy_2255_PosErr or Asy_2255PosErr.
let positive = -1;
let negative = -1;
for (let candidate of [name + "_PosErr", name + "PosErr"]) {
positive = musrfitParameterColumnIndex(dataset, candidate);
if (positive >= 0) break;
}
for (let candidate of [name + "_NegErr", name + "NegErr"]) {
negative = musrfitParameterColumnIndex(dataset, candidate);
if (negative >= 0) break;
}
if (positive >= 0 || negative >= 0) {
return { positive: positive, negative: negative, symmetric: -1 };
}
// Experimental-temperature errors are written as dataTErr by msr2data.
if (String(name).toLowerCase() === "datat") {
let temperatureError = musrfitParameterColumnIndex(dataset, "dataTErr");
if (temperatureError >= 0) {
return { positive: -1, negative: -1, symmetric: temperatureError };
}
}
for (let candidate of ["d" + name, name + "Err", name + "Error"]) {
let index = musrfitParameterColumnIndex(dataset, candidate);
if (index >= 0) return { positive: -1, negative: -1, symmetric: index };
}
return { positive: -1, negative: -1, symmetric: -1 };
}
function defaultMusrfitParameterErrorColumn(dataset, yIndex) {
let errorColumns = musrfitParameterErrorColumns(dataset, yIndex);
if (errorColumns.symmetric >= 0) return errorColumns.symmetric;
if (errorColumns.positive >= 0) return errorColumns.positive;
return errorColumns.negative;
}
function isMusrfitParameterErrorColumn(dataset, columnIndex) {
let name = String(dataset.columns[columnIndex] || "");
let asymmetric = /^(.*?)(?:_)?(?:PosErr|NegErr)$/i.exec(name);
if (asymmetric) {
return musrfitParameterColumnIndex(dataset, asymmetric[1]) >= 0;
}
if (/^dataTErr$/i.test(name)) {
return musrfitParameterColumnIndex(dataset, "dataT") >= 0;
}
if (/^d./i.test(name)) {
return musrfitParameterColumnIndex(dataset, name.substring(1)) >= 0;
}
let generic = /^(.*)(Err|Error)$/i.exec(name);
return !!generic && musrfitParameterColumnIndex(dataset, generic[1]) >= 0;
}
function musrfitParameterPlotlyError(dataset, valueIndex) {
let columns = musrfitParameterErrorColumns(dataset, valueIndex);
if (columns.positive >= 0 && columns.negative >= 0) {
return {
type: "data",
symmetric: false,
array: musrfitParameterAbsoluteColumnValues(dataset, columns.positive),
arrayminus: musrfitParameterAbsoluteColumnValues(dataset, columns.negative),
visible: true
};
}
let oneSided = columns.positive >= 0 ? columns.positive : columns.negative;
if (oneSided >= 0) {
return {
type: "data",
array: musrfitParameterAbsoluteColumnValues(dataset, oneSided),
visible: true
};
}
if (columns.symmetric >= 0) {
return {
type: "data",
array: musrfitParameterAbsoluteColumnValues(dataset, columns.symmetric),
visible: true
};
}
return null;
}
function buildMusrfitParameterTrace(dataset, xIndex, yIndex, mode, style) {
let trace = {
x: musrfitParameterColumnValues(dataset, xIndex),
y: musrfitParameterColumnValues(dataset, yIndex),
mode: mode,
name: musrfitParameterAxisLabel(dataset.columns[yIndex]),
type: "scatter"
};
let xError = musrfitParameterPlotlyError(dataset, xIndex);
let yError = musrfitParameterPlotlyError(dataset, yIndex);
let capWidth = style && style.cap ? 4 : 0;
if (xError) { xError.width = capWidth; trace.error_x = xError; }
if (yError) { yError.width = capWidth; trace.error_y = yError; }
if (style && typeof style === "object") {
let color = style.color || null;
let opacity = style.opacity === undefined || style.opacity === null
? 1 : Math.max(0, Math.min(1, Number(style.opacity)));
let size = style.size === undefined || style.size === null
? 8 : Math.max(1, Number(style.size));
let showsMarkers = mode === "markers" || mode === "lines+markers";
let showsLines = mode === "lines" || mode === "lines+markers";
if (showsMarkers && (color || style.symbol || style.size !== undefined)) {
let marker = { size: size };
if (color) marker.color = color;
if (style.symbol) marker.symbol = style.symbol;
if (opacity < 1) marker.opacity = opacity;
trace.marker = marker;
}
if (showsLines && (color || opacity < 1)) {
let line = {};
if (color) line.color = color;
if (opacity < 1) line.opacity = opacity;
trace.line = line;
}
}
return trace;
}
// Marker-symbol names follow Plotly's scatter symbol vocabulary so the style
// picker and overlay traces share one source of truth.
const MUSRFIT_PARAMETER_PLOT_MARKER_SYMBOLS = [
"circle", "square", "diamond", "cross", "x",
"triangle-up", "triangle-down", "triangle-left", "triangle-right",
"star", "hexagon", "pentagon", "octagon", "hexagram",
"diamond-tall", "diamond-wide", "hourglass", "bowtie",
"circle-cross", "circle-x", "square-cross", "square-x",
"diamond-cross", "diamond-x", "asterisk", "hash"
];
// Color palettes for per-data-set / per-trace default styling. The default
// palette mirrors Plotly's classic sequence so nothing changes until a user
// edits a style. All values are CSS hex / rgb() colors accepted by SVG.
const MUSRFIT_PARAMETER_PLOT_PALETTES = {
default: ["#1f77b4", "#d62728", "#2ca02c", "#9467bd", "#ff7f0e",
"#17becf", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22"],
bold: ["#004c6d", "#b2182b", "#008837", "#762a83", "#e08214",
"#5e3c99", "#1b7837", "#d6604d", "#4393c3", "#f46d43"],
pastel: ["#aec7e8", "#ff9896", "#98df8a", "#c5b0d5", "#ffbb78",
"#9edae5", "#c7c7c7", "#f7b6d2", "#dbdb8d", "#ffd92f"],
mono: ["#111111", "#444444", "#777777", "#aaaaaa", "#cccccc",
"#333333", "#555555", "#888888", "#bbbbbb", "#dddddd"]
};
function musrfitParameterPaletteColor(paletteId, index) {
let palette = MUSRFIT_PARAMETER_PLOT_PALETTES[paletteId || "default"];
if (!palette) palette = MUSRFIT_PARAMETER_PLOT_PALETTES.default;
return palette[Math.max(0, Number(index) || 0) % palette.length];
}
// A data set is identified by its origin so that the same file picked in two
// panels (or the same uploaded blob) maps to one registry entry and keeps one
// user-adjusted style across every panel that shows it.
function parameterDataSetKey(source) {
source = source || {};
if (source.kind === "path" && source.path) return "path:" + source.path;
if (source.kind === "file" && source.file) {
let file = source.file;
return "file:" + (file.name || source.label || "file")
+ ":" + (file.lastModified || 0) + ":" + (file.size || 0);
}
if (source.kind === "inline") {
return "inline:" + (source.label || "data") + ":" + String(source.text || "").length;
}
if (source.label) return "source:" + source.label;
return "source:" + String(source || "unknown");
}
// ---------------------------------------------------------------------------
// Remembered parameter-plot configurations.
//
// The window state (style registry, panels, layout, palette, overlays) is too
// useful to lose on close, so a per-source snapshot is kept in shared storage
// (web and Electron use the same default-session localStorage). Keys store the
// *identity* of a data set, not a file handle, so the remembered style of
// scanA_par.dat reapplies the next time scanA_par.dat is plotted, while other
// data sets keep their own states. The same map will later ride along in the
// configuration share link: the snapshot is plain JSON, and the schema version
// lives inside the stanza so the shared-config version can stay at 1.
// ---------------------------------------------------------------------------
var MUSRFIT_PARAMETER_PLOT_STATE_VERSION = 1;
var parameterPlotStatesStorageKey = "musrflow.parameterPlotStates";
var MAX_REMEMBERED_PARAMETER_PLOT_STATES = 8;
// Each data source may keep one remembered configuration per distinct
// parameter-Y-set (the newest wins for a set); this caps how many such
// configurations a single source can accumulate.
var MAX_PARAMETER_PLOT_CONFIGS_PER_SOURCE = 8;
// Project a data source to JSON so it can be stored or shared. Path and inline
// sources round-trip completely; uploaded-file sources keep only their identity
// markers (name/size/stamp) so the data-set key stays stable -- the blob itself
// cannot be re-read on another machine, and restore handles that gracefully.
function portableParameterSource(source) {
if (!source || typeof source !== "object") return null;
let portable = { kind: source.kind || "source" };
if (source.label) portable.label = source.label;
if (source.kind === "path") {
portable.path = source.path || "";
} else if (source.kind === "inline") {
portable.text = String(source.text || "");
} else if (source.kind === "file" && source.file) {
portable.file = {
name: source.file.name || "",
lastModified: source.file.lastModified || 0,
size: source.file.size || 0
};
}
return portable;
}
function restorePortableParameterSource(portable) {
if (!portable || typeof portable !== "object" || !portable.kind) return null;
if (portable.kind === "path") {
return { kind: "path", path: portable.path || "", label: portable.label || "" };
}
if (portable.kind === "inline") {
return { kind: "inline", text: portable.text || "", label: portable.label || "" };
}
if (portable.kind === "file" && portable.file) {
// Identity-only: the file blob is not stored, but the same key is
// produced so overlaid styles remain attached if the file is reloaded.
return { kind: "file", file: { name: portable.file.name || "", lastModified: portable.file.lastModified || 0, size: portable.file.size || 0 }, label: portable.label || "" };
}
return { kind: "source", label: portable.label || "" };
}
function isPlainObjectValue(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
// A snapshot must be structurally sound before it is written back to the GUI or
// carried in a shared configuration link. Unknown fields are ignored; malformed
// fields reject the whole snapshot so crafted or corrupted data cannot make the
// plot window misbehave.
function validateParameterPlotState(snapshot) {
if (!isPlainObjectValue(snapshot)) return false;
if (snapshot.v !== MUSRFIT_PARAMETER_PLOT_STATE_VERSION) return false;
if (typeof snapshot.mainSourceKey !== "string" || !snapshot.mainSourceKey) return false;
if (!Array.isArray(snapshot.panelStates) || !Array.isArray(snapshot.registeredDataSets)) return false;
if (!isPlainObjectValue(snapshot.styleRegistry)) return false;
if (snapshot.legendNameOverrides !== undefined && !isPlainObjectValue(snapshot.legendNameOverrides)) return false;
for (let style of Object.keys(snapshot.styleRegistry)) {
if (typeof style !== "string" || !isPlainObjectValue(snapshot.styleRegistry[style])) return false;
}
return true;
}
function parameterPlotStateStorage() {
try {
if (typeof window !== "undefined" && window.localStorage) return window.localStorage;
} catch (error) {
// Storage may be disabled; persistence then silently does nothing.
}
return null;
}
// The ordered, unique set of Y parameters plotted by a snapshot: configurations
// for one data source are told apart by this set (order-insensitive), so a
// saved three-parameter plot only ever reappears for the same three parameters.
function parameterPlotStateParameterSignature(snapshot) {
if (!snapshot || !Array.isArray(snapshot.panelStates)) return "";
let names = [];
for (let panel of snapshot.panelStates) {
for (let name of (panel.yNames || [])) {
if (names.indexOf(name) === -1) names.push(name);
}
}
return names.sort().join(",");
}
// A short human-readable label for a remembered configuration, helping the
// Choose X axis dialog tell saved configurations apart (for example the TF-scan
// template vs a plain single-column layout with the same parameters).
function parameterPlotConfigurationLabel(snapshotConfig) {
if (!snapshotConfig) return "From scratch";
let panelCount = Array.isArray(snapshotConfig.panelStates) ? snapshotConfig.panelStates.length : 0;
if (typeof snapshotConfig.templateId === "string" && snapshotConfig.templateId) {
for (let template of MUSRFIT_PARAMETER_PLOT_TEMPLATES) {
if (template.id === snapshotConfig.templateId) {
return template.name + (panelCount ? " (" + panelCount + " panels)" : "");
}
}
}
let layout = snapshotConfig.layout || "";
if (layout) {
return "Layout " + layout + (panelCount ? " (" + panelCount + " panels)" : "");
}
return panelCount ? panelCount + " panel" + (panelCount > 1 ? "s" : "") : "Saved configuration";
}
// Each data source keeps a list of remembered configurations, most recent
// first, with at most one entry per parameter-Y-set. Values written by older
// versions (a single snapshot per source) are upgraded on read.
function readRememberedParameterPlotStates(storage) {
if (!storage || typeof storage.getItem !== "function") return {};
let states = {};
try {
let raw = storage.getItem(parameterPlotStatesStorageKey);
if (raw) {
let parsed = JSON.parse(raw);
for (let key of Object.keys(parsed || {})) {
let value = parsed[key];
let list = Array.isArray(value) && value.some(validateParameterPlotState)
? value.filter(validateParameterPlotState)
: (validateParameterPlotState(value) ? [value] : []);
if (list.length) states[key] = list;
}
}
} catch (error) {
// Corrupted storage is ignored: the user simply starts unremembered.
}
return states;
}
// Remember one window state, keyed by its main data-set identity. The newest
// entries win and supersede any older configuration for the same parameter set
// on the same source; the map is capped so it cannot grow without bound.
function rememberParameterPlotState(storage, snapshot) {
if (!storage || !validateParameterPlotState(snapshot) || !snapshot.mainSourceKey) return;
let states = readRememberedParameterPlotStates(storage);
let signature = parameterPlotStateParameterSignature(snapshot);
let list = states[snapshot.mainSourceKey] || [];
list = list.filter(function(existing) {
return parameterPlotStateParameterSignature(existing) !== signature;
});
list.unshift(snapshot);
if (list.length > MAX_PARAMETER_PLOT_CONFIGS_PER_SOURCE) list.length = MAX_PARAMETER_PLOT_CONFIGS_PER_SOURCE;
delete states[snapshot.mainSourceKey];
states[snapshot.mainSourceKey] = list;
let keys = Object.keys(states);
while (keys.length > MAX_REMEMBERED_PARAMETER_PLOT_STATES) {
delete states[keys.shift()];
}
try {
storage.setItem(parameterPlotStatesStorageKey, JSON.stringify(states));
} catch (error) {
// Quota or storage failures must never break the plot window.
}
}
// The most recent remembered configuration for a source, or null. This
// maintains the original single-snapshot contract, so callers that embed the
// current configuration in a share link keep working unchanged.
function readRememberedParameterPlotState(storage, sourceKey) {
if (!sourceKey) return null;
let states = readRememberedParameterPlotStates(storage);
let list = states[sourceKey];
return list && list.length ? list[0] : null;
}
// Every remembered configuration for a source, most recent first. The dialog
// uses this to offer a matching saved configuration to the user.
function readRememberedParameterPlotConfigurations(storage, sourceKey) {
if (!sourceKey) return [];
let states = readRememberedParameterPlotStates(storage);
let list = states[sourceKey];
return list ? list.slice() : [];
}
function forgetParameterPlotState(storage, sourceKey) {
if (!storage || !sourceKey) return;
let states = readRememberedParameterPlotStates(storage);
if (!(sourceKey in states)) return;
delete states[sourceKey];
try {
storage.setItem(parameterPlotStatesStorageKey, JSON.stringify(states));
} catch (error) {
// Ignored, same as every other persistence failure.
}
}
// A shared configuration link can carry the actual parameter-data rows (the
// whole msr2data "_par.dat" table, scan variable and error columns included) so
// the receiving web page or desktop can draw the identical plot without a local
// fit or server copy of the data. This turns a path/file-keyed snapshot into a
// self-contained inline snapshot: the main panel source becomes an inline text
// source holding the table. Overlay files keep their identities -- they are
// user-chosen local files that cannot be re-read from the sender's page.
async function hydratedParameterPlotSnapshot(snapshot) {
if (!snapshot || typeof snapshot !== "object") return snapshot;
if (typeof musrfitParameterPlotPlatform !== "function") return snapshot;
let platform = musrfitParameterPlotPlatform();
if (typeof platform.readDataSource !== "function") return snapshot;
if (!Array.isArray(snapshot.panelStates) || !snapshot.panelStates.length) return snapshot;
let mainSource = snapshot.panelStates[0].source;
if (!mainSource || typeof mainSource !== "object") return snapshot;
if (mainSource.kind === "inline" && typeof mainSource.text === "string"
&& mainSource.text.length > 0) {
// Already self-contained.
return snapshot;
}
let text;
try {
text = await platform.readDataSource(mainSource);
} catch (error) {
// The file may have been deleted or the server copy is gone; share the
// remembered state without data, which restores gracefully.
return snapshot;
}
if (!text) return snapshot;
let pathValue = mainSource.path || "";
let pathClean = String(pathValue).split(/[?#]/)[0];
let pathPieces = pathClean.split(/[\\/]/);
let label = mainSource.label || pathPieces[pathPieces.length - 1] || "Parameter data";
let inlineSource = { kind: "inline", text: String(text), label: label };
let inlineKey = parameterDataSetKey(inlineSource);
let hydrated = JSON.parse(JSON.stringify(snapshot));
hydrated.mainSourceKey = inlineKey;
for (let i = 0; i < hydrated.panelStates.length; i++) {
let panel = hydrated.panelStates[i];
if (panel && panel.dataSetKey === snapshot.mainSourceKey) {
panel.source = inlineSource;
panel.dataSetKey = inlineKey;
}
}
if (Array.isArray(hydrated.registeredDataSets)) {
for (let entry of hydrated.registeredDataSets) {
if (entry.key === snapshot.mainSourceKey) {
entry.key = inlineKey;
entry.source = inlineSource;
entry.label = label;
}
}
}
if (hydrated.styleRegistry && typeof hydrated.styleRegistry === "object"
&& snapshot.mainSourceKey) {
let remapped = {};
let dataOld = "data!" + snapshot.mainSourceKey;
let traceOld = "trace!" + snapshot.mainSourceKey + "!";
for (let key of Object.keys(hydrated.styleRegistry)) {
let newKey = key;
if (key === dataOld) {
newKey = "data!" + inlineKey;
} else if (key.indexOf(traceOld) === 0) {
newKey = "trace!" + inlineKey + key.substring(traceOld.length - 1);
}
remapped[newKey] = hydrated.styleRegistry[key];
}
hydrated.styleRegistry = remapped;
}
return hydrated;
}
// The most recent shared configuration's parameter-plot stanza. It is consumed
// once: the first time a parameter plot is opened after a restore, the shared
// window state (with its embedded data) is used instead of the source-keyed
// remembered state, which cannot match a remote data source by identity.
var pendingSharedParameterPlotSnapshot = null;
function setPendingSharedParameterPlot(snapshot) {
pendingSharedParameterPlotSnapshot =
validateParameterPlotState(snapshot) ? snapshot : null;
}
function consumePendingSharedParameterPlot() {
let snapshot = pendingSharedParameterPlotSnapshot;
pendingSharedParameterPlotSnapshot = null;
return snapshot;
}
// The parameters a snapshot plotted, as a flat name list (used to pre-select
// the parameter-plot chips after a shared-configuration restore, both from
// muSRFitlib.js and when a pending shared plot opens here).
function parameterPlotNamesFromSnapshot(snapshot) {
let names = [];
for (let panel of Array.isArray(snapshot && snapshot.panelStates) ? snapshot.panelStates : []) {
for (let name of Array.isArray(panel.yNames) ? panel.yNames : []) {
if (typeof name === "string" && !names.includes(name)) names.push(name);
}
}
return names;
}
// Open the parameter plot from a pending shared snapshot. Returns whether the
// plot was opened. Consumes the pending snapshot either way, so a restore does
// not re-hijack later plot opens.
function openPendingSharedParameterPlot() {
let snapshot = typeof consumePendingSharedParameterPlot === "function"
? consumePendingSharedParameterPlot() : null;
if (!snapshot) return false;
let platform = musrfitParameterPlotPlatform();
if (typeof platform.openPlot !== "function") return false;
let mainSource = snapshot.panelStates && snapshot.panelStates[0]
? snapshot.panelStates[0].source : null;
platform.openPlot({
parameterPath: mainSource || { kind: "inline", text: "", label: "Shared plot" },
jobName: snapshot.jobName || "",
preferredParameters: parameterPlotNamesFromSnapshot(snapshot),
preferredXColumn: "",
preferredTemplate: snapshot.templateId || "",
preferredLayoutMode: snapshot.layout || "",
savedState: snapshot
});
return true;
}
// Style registry keys. Styles are stored in a plain object shared by the whole
// parameter-plot window. "data!" styles apply to every trace of a data set;
// "trace!" styles apply only to one (data set, panel, parameter) combination.
function parameterDataSetStyleKey(dataSetKey) {
return "data!" + dataSetKey;
}
function parameterTraceStyleKey(dataSetKey, panelId, yName) {
return "trace!" + dataSetKey + "!" + panelId + "!" + yName;
}
// Resolve the effective style for one series: a trace-level override wins over
// a data-set-level override, and both win over the caller's fallback.
function musrfitParameterTraceStyle(styles, styleKey, dataSetKey, fallback) {
let effective = null;
if (styles && styleKey && styles[styleKey]) {
effective = styles[styleKey];
} else if (styles && dataSetKey && styles[parameterDataSetStyleKey(dataSetKey)]) {
effective = styles[parameterDataSetStyleKey(dataSetKey)];
}
fallback = fallback || {};
let size = (effective && effective.size !== undefined) ? Number(effective.size)
: (fallback.size !== undefined ? Number(fallback.size) : 8);
let opacity = (effective && effective.opacity !== undefined) ? Number(effective.opacity)
: (fallback.opacity !== undefined ? Number(fallback.opacity) : 1);
let cap = (effective && effective.cap !== undefined) ? effective.cap
: (fallback.cap !== undefined ? fallback.cap : false);
return {
color: (effective && effective.color) || fallback.color || null,
symbol: (effective && effective.symbol) || fallback.symbol || null,
size: size,
opacity: opacity,
cap: !!cap
};
}
function parameterStyleScopeKeys(panel, yName, scope) {
if (scope === "dataset") return parameterDataSetStyleKey(panel.dataSetKey);
return parameterTraceStyleKey(panel.dataSetKey, panel.stableId, yName);
}
// The effective style a picker should prefill for a given edit scope: the
// dataset scope shows only the data set's own override (or the fallback);
// the trace scope falls back through trace, data set, and caller defaults.
function parameterCurrentStyle(styles, panel, yName, scope, fallback) {
let key = scope === "dataset"
? parameterDataSetStyleKey(panel.dataSetKey)
: parameterTraceStyleKey(panel.dataSetKey, panel.stableId, yName);
return musrfitParameterTraceStyle(styles, key, panel.dataSetKey, fallback);
}
// Record or clear a style override. Overrides merge into any entry already
// stored under the key, so editing a single property never erases the others.
function recordParameterStyle(styles, key, override, reset) {
if (reset) {
delete styles[key];
return;
}
let entry = styles[key] ? Object.assign({}, styles[key]) : {};
if (override.color) entry.color = override.color;
if (override.symbol) entry.symbol = override.symbol;
if (override.size !== undefined && override.size !== null && override.size !== "") {
entry.size = Number(override.size);
}
if (override.opacity !== undefined && override.opacity !== null && override.opacity !== "") {
entry.opacity = Number(override.opacity);
}
if (override.cap !== undefined && override.cap !== null) {
entry.cap = !!override.cap;
}
styles[key] = entry;
}
// Applying a style at data-set scope means "restyle this whole data set": any
// per-panel trace overrides left from earlier edits would otherwise shadow the
// new data-set level style on those panels and make the choice appear to have
// no effect there. Clearing the data set's trace entries keeps "This data set"
// a unify operation. The "trace!" + key + "!" prefix terminates on the key's own
// delimiter, so it never matches a sibling data set whose key merely extends
// this one (e.g. later file timestamps).
function clearParameterDataSetTraceStyles(styles, dataSetKey) {
if (!styles || !dataSetKey) return;
let prefix = "trace!" + dataSetKey + "!";
for (let key of Object.keys(styles)) {
if (key.indexOf(prefix) === 0) delete styles[key];
}
}
// A plotly_click event reduces to a trace identity for the shared window: the
// clicked data set, the parameter column, and the pixel position for the picker.
function parameterClickedSeries(panel, yName, event) {
return {
dataSetKey: panel.dataSetKey,
datasetLabel: panel.source && panel.source.label ? panel.source.label : "",
yName: yName,
clientX: event && Number.isFinite(event.clientX) ? event.clientX : 0,
clientY: event && Number.isFinite(event.clientY) ? event.clientY : 0
};
}
// Window-level registry of data sets that may be overlaid onto panels. The
// registry is a plain insertion-ordered array, so the same file picked twice
// maps to one entry (and keeps one user-adjusted style). Each entry carries
// the parsed dataset plus a stable color index for default styling.
function findRegisteredDataSet(registry, key) {
if (!registry || !Array.isArray(registry) || !key) return null;
for (let entry of registry) {
if (entry.key === key) return entry;
}
return null;
}
function registerParameterDataSet(registry, source, colorIndex) {
let key = parameterDataSetKey(source);
let existing = findRegisteredDataSet(registry, key);
if (existing) return existing;
let label = (source && source.label) ? source.label : "";
if (!label && source && source.kind === "path" && source.path) {
let pieces = String(source.path).split(/[\\/]/);
label = pieces[pieces.length - 1] || "";
}
if (!label) label = "Parameter data";
let entry = {
key: key,
source: source,
label: label,
dataset: null,
error: null,
colorIndex: Number.isFinite(colorIndex) ? colorIndex : registry.length
};
registry.push(entry);
return entry;
}
// Resolve the data sets a panel plots: its primary set first, then every
// registered overlay, in overlay order. Entries for missing or unloaded sets
// are still present so buildMusrfitParameterOverlayTraces can report them.
function parameterOverlayEntries(panel, registry) {
let entries = [];
if (!panel) return entries;
if (panel.dataset) {
entries.push({
key: panel.dataSetKey,
dataSetKey: panel.dataSetKey,
label: (panel.source && panel.source.label) || "Parameter data",
dataset: panel.dataset,
colorIndex: 0
});
}
let overlays = panel.overlays || [];
for (let key of overlays) {
let entry = findRegisteredDataSet(registry, key);
if (!entry) continue;
entries.push({
key: entry.key,
dataSetKey: entry.key,
label: entry.label,
dataset: entry.dataset || null,
colorIndex: entry.colorIndex
});
}
return entries;
}
// Build the traces for a panel that overlays several data sets. The X axis is
// aligned across data sets by column name (each data set is skipped, with a
// note, when it lacks the panel's X column). Traces get the data set's label
// prefixed into their name so the legend disambiguates in overlay mode.
function buildMusrfitParameterOverlayTraces(dataSets, xName, yNames, mode, options) {
options = options || {};
let traces = [];
let traceMeta = [];
let skipped = [];
let paletteId = options.paletteId || "default";
// In overlay mode every trace of a data set shares the data set's color so
// scans compare across panels; with a single data set the palette cycles per
// parameter, keeping the original look.
let overlayMode = dataSets.length > 1;
for (let i = 0; i < dataSets.length; i++) {
let entry = dataSets[i] || {};
let dataset = entry.dataset;
if (!dataset || !dataset.columns || !dataset.rows) {
skipped.push({ label: entry.label || "data set", reason: "no data" });
continue;
}
let xIndex = musrfitParameterColumnIndex(dataset, xName);
if (xIndex < 0) {
skipped.push({ label: entry.label || "data set", reason: "missing X column " + xName });
continue;
}
let entryColorIndex = Number.isFinite(entry.colorIndex) ? entry.colorIndex : i;
let dataSetKey = entry.dataSetKey || entry.key || "";
let defaultPrefix = musrfitParameterOverlayPrefix(entry, dataset);
let nameOffset = 0;
for (let name of yNames) {
let yIndex = musrfitParameterColumnIndex(dataset, name);
if (yIndex < 0 || yIndex === xIndex) continue;
let colorIndex = overlayMode ? entryColorIndex : nameOffset;
let fallbackColor = entry.color || musrfitParameterPaletteColor(paletteId, colorIndex);
let style = { color: fallbackColor };
if (options.styleRegistry && dataSetKey) {
style = musrfitParameterTraceStyle(
options.styleRegistry, options.styleKeyOf && options.styleKeyOf(dataSetKey, name) || "", dataSetKey, style);
}
let trace = buildMusrfitParameterTrace(dataset, xIndex, yIndex, mode, style);
if (overlayMode) {
let defaultName = defaultPrefix + ": " + trace.name;
let override = options.legendNameOf && typeof options.legendNameOf === "function"
? options.legendNameOf(dataSetKey, name) : "";
trace.name = override ? override : defaultName;
}
traces.push(trace);
traceMeta.push({
dataSetKey: dataSetKey,
name: name,
defaultName: trace.name
});
nameOffset++;
}
}
return { traces: traces, skipped: skipped, traceMeta: traceMeta };
}
function musrfitParameterYCandidates(dataset, xIndex) {
let candidates = [];
for (let i = 0; i < dataset.columns.length; i++) {
let name = dataset.columns[i];
let normalized = String(name || "").toLowerCase();
if (i === xIndex || normalized === "run" || normalized === "datat"
|| normalized === "datab" || normalized === "datae"
|| normalized === "dataspinrot") continue;
if (isMusrfitParameterErrorColumn(dataset, i)) continue;
candidates.push(i);
}
return candidates;
}
function musrfitParameterAxisLabel(name) {
if (name === undefined || name === null) return "";
// Metadata and statistic columns: conventional text, never subscripted.
let metadataLabels = {
RUN: "Run",
dataT: "T (K)",
dataB: "B (G)",
dataE: "E (keV)",
dataSpinRot: "SR (°)",
CHISQ: "χ²",
NDF: "NDF",
CHISQred: "χ²/NDF"
};
if (metadataLabels[name] !== undefined) return metadataLabels[name];
// Known fit-parameter bases carry conventional symbols; units are kept only
// where they are standard for the quantity. The GUI appends a numeric suffix
// for the second and later components (Lam1, Sgm2, ...), so any such base is
// translated with the component number as a subscript. Unknown or custom
// parameter names, and run-qualified export columns such as Asy_2274, do not
// match and stay exactly as they are.
let symbolLabels = {
Asy: "A₀",
Alpha: "α",
Lam: "λ (μs⁻¹)",
Lambda: "λ (μs⁻¹)",
Gam: "Γ",
Bet: "β",
Del: "Δ",
Sgm: "σ (μs⁻¹)",
Frq: "ν (MHz)",
Phi: "φ (°)"
};
let base = String(name);
let suffix = "";
let match = /^([A-Za-z]+?)([0-9]+)$/.exec(base);
if (match) {
base = match[1];
suffix = match[2];
}
let label = symbolLabels[base];
if (label === undefined) return name;
if (!suffix) return label;
let subscript = suffix.replace(/[0-9]/g, function(d) {
return "\u2080\u2081\u2082\u2083\u2084\u2085\u2086\u2087\u2088\u2089"[Number(d)];
});
// Insert the subscript directly after the leading symbol run, before any
// space or parenthetical unit, so "λ (μs⁻¹)" with a suffix becomes "λ₂ (μs⁻¹)".
let space = label.indexOf(" ");
let paren = label.indexOf("(");
let cut = (space >= 0 && (paren < 0 || space < paren)) ? space
: (paren >= 0 ? paren : label.length);
return label.slice(0, cut) + subscript + label.slice(cut);
}
async function readMusrfitParameterData(parameterPath) {
let platform = musrfitParameterPlotPlatform();
if (typeof platform.readDataSource !== "function") {
throw new Error("No parameter-data reader is available for this platform");
}
let source = normalizeParameterSource(parameterPath);
return await platform.readDataSource(source);
}
// A parameter-data source is normally an on-disk file path string, but it may
// also be a structured source object with kind "path" or "inline". Normalize
// either form into a source object so the platforms and panels can consume it
// uniformly.
function normalizeParameterSource(parameterPath) {
if (parameterPath && typeof parameterPath === "object" && parameterPath.kind) {
return parameterPath;
}
let clean = String(parameterPath || "").split(/[?#]/)[0];
let pieces = clean.split(/[\\/]/);
return {
kind: "path",
path: parameterPath,
label: pieces[pieces.length - 1] || "Parameter data"
};
}
function fillMusrfitParameterSelect(select, dataset, indices, selectedIndex, noneLabel) {
select.textContent = "";
if (noneLabel !== undefined) {
let none = document.createElement("option");
none.value = "-1";
none.textContent = noneLabel;
select.appendChild(none);
}
for (let index of indices) {
let option = document.createElement("option");
option.value = String(index);
// textContent is intentional: column names originate from a data file.
option.textContent = dataset.columns[index];
select.appendChild(option);
}
select.value = String(selectedIndex);
}
function showMusrfitParameterAxisDialog(parameterPath, jobName = "", preferredParameters = []) {
if (!parameterPath || !preferredParameters.length) return;
parameterPath = normalizeParameterSource(parameterPath);
let dialog = document.createElement("dialog");
let form = document.createElement("form");
let title = document.createElement("strong");
let label = document.createElement("label");
let xSelect = document.createElement("select");
let layoutLabel = document.createElement("label");
let layoutSelect = document.createElement("select");
let message = document.createElement("div");
let actions = document.createElement("div");
let cancelButton = document.createElement("button");
let plotButton = document.createElement("button");
dialog.className = "parameter-axis-dialog";
dialog.setAttribute("aria-label", "Choose parameter plot X axis");
form.method = "dialog";
form.className = "parameter-axis-form";
title.textContent = "Choose X axis";
label.className = "settings-field";
label.appendChild(document.createTextNode("X axis"));
label.appendChild(xSelect);
layoutLabel.className = "settings-field";
layoutLabel.appendChild(document.createTextNode("Layout"));
for (let layout of MUSRFIT_PARAMETER_PLOT_LAYOUT_MODES) {
let option = document.createElement("option");
option.value = layout.value;
option.textContent = layout.label;
layoutSelect.appendChild(option);
}
layoutSelect.value = rememberedParameterPlotLayoutMode();
layoutLabel.appendChild(layoutSelect);
message.className = "parameter-axis-message";
message.textContent = "Loading parameter data...";
actions.className = "parameter-axis-actions";
cancelButton.type = "button";
cancelButton.textContent = "Cancel";
plotButton.type = "button";
plotButton.textContent = "Plot";
plotButton.disabled = true;
actions.appendChild(cancelButton);
actions.appendChild(plotButton);
form.appendChild(title);
form.appendChild(label);
form.appendChild(layoutLabel);
form.appendChild(message);
form.appendChild(actions);
dialog.appendChild(form);
document.body.appendChild(dialog);
function closeDialog() {
if (typeof dialog.close === "function" && dialog.open) dialog.close();
dialog.remove();
}
cancelButton.addEventListener("click", closeDialog);
layoutSelect.addEventListener("change", function() {
rememberParameterPlotLayoutMode(layoutSelect.value);
});
dialog.addEventListener("cancel", function(event) {
event.preventDefault();
closeDialog();
});
readMusrfitParameterData(parameterPath).then(function(contents) {
let dataset = parseMusrfitParameterData(contents);
if (!dataset.columns.length || !dataset.rows.length) {
throw new Error("The parameter-data file contains no plottable rows");
}
let selectedYIndices = [];
let missingParameters = [];
let yCandidates = musrfitParameterYCandidates(dataset, -1);
for (let name of preferredParameters) {
let index = musrfitParameterColumnIndex(dataset, name);
if (yCandidates.includes(index) && !selectedYIndices.includes(index)) {
selectedYIndices.push(index);
} else {
missingParameters.push(name);
}
}
if (missingParameters.length > 0) {
throw new Error("Selected parameter(s) not found: " + missingParameters.join(", "));
}
let xColumns = dataset.columns.map(function(column, index) { return index; }).filter(function(index) {
return !isMusrfitParameterErrorColumn(dataset, index) && !selectedYIndices.includes(index);
});
if (!xColumns.length) throw new Error("No X-axis column is available");
// A shared configuration restores a self-contained plot (the sender's
// parameter-data rows are embedded, plus panel/layout/style state). It
// cannot be matched to this machine's data sources by identity, so a
// restored configuration opens its plot directly the first time
// "Plot parameters..." is used -- even without a local fit.
if (typeof consumePendingSharedParameterPlot === "function"
&& typeof openPendingSharedParameterPlot === "function"
&& pendingSharedParameterPlotSnapshot) {
if (openPendingSharedParameterPlot()) {
closeDialog();
return;
}
}
// Remembered plot configurations are never restored silently: the dialog
// always appears, and a "Configuration" dropdown offers every saved
// configuration whose panel Y parameters match this selection exactly
// (order-insensitive), so a three-parameter plot never bleeds into a
// one-parameter request. The most recent matching configuration is
// preselected; "From scratch" starts a new window.
let sourceKey = parameterDataSetKey(parameterPath);
let storage = parameterPlotStateStorage();
let selectedNames = selectedYIndices.map(function(index) { return dataset.columns[index]; });
let selectionSignature = parameterPlotStateParameterSignature({
panelStates: [{ yNames: selectedNames }]
});
let savedConfigs = readRememberedParameterPlotConfigurations(storage, sourceKey).filter(function(existing) {
return parameterPlotStateParameterSignature(existing) === selectionSignature;
});
let configLabel = null;
let configSelect = null;
if (savedConfigs.length) {
configLabel = document.createElement("label");
configLabel.className = "settings-field";
configLabel.appendChild(document.createTextNode("Configuration"));
configSelect = document.createElement("select");
let scratchOption = document.createElement("option");
scratchOption.value = "";
scratchOption.textContent = "From scratch";
configSelect.appendChild(scratchOption);
savedConfigs.forEach(function(config, index) {
let option = document.createElement("option");
option.value = String(index + 1);
option.textContent = parameterPlotConfigurationLabel(config);
configSelect.appendChild(option);
});
configSelect.value = "1";
configSelect.addEventListener("change", function() {
message.textContent = configSelect.value !== ""
? "Y: " + preferredParameters.join(", ") + " — will restore the saved configuration"
: "Y: " + preferredParameters.join(", ");
});
configLabel.appendChild(configSelect);
form.insertBefore(configLabel, message);
}
let xIndex = defaultMusrfitParameterXColumn(dataset);
if (!xColumns.includes(xIndex)) xIndex = xColumns[0];
fillMusrfitParameterSelect(xSelect, dataset, xColumns, xIndex);
message.textContent = configSelect
? "Y: " + preferredParameters.join(", ") + " — will restore the saved configuration"
: "Y: " + preferredParameters.join(", ");
plotButton.disabled = false;
plotButton.addEventListener("click", function() {
let platform = musrfitParameterPlotPlatform();
if (typeof platform.openPlot !== "function") {
throw new Error("No parameter-plot window opener is available for this platform");
}
if (configSelect && configSelect.value !== "") {
let config = savedConfigs[Number(configSelect.value) - 1];
let configXColumn = (config.panelStates && config.panelStates.length && config.panelStates[0].xName)
? config.panelStates[0].xName : "";
closeDialog();
platform.openPlot({
parameterPath: parameterPath,
jobName: jobName,
preferredParameters: preferredParameters,
preferredXColumn: configXColumn,
preferredTemplate: config.templateId || "",
preferredLayoutMode: config.layout || "",
savedState: config
});
return;
}
let selectedIndex = Number(xSelect.value);
if (!xColumns.includes(selectedIndex)) return;
let xName = dataset.columns[selectedIndex];
closeDialog();
platform.openPlot({
parameterPath: parameterPath,
jobName: jobName,
preferredParameters: preferredParameters,
preferredXColumn: xName,
preferredLayoutMode: layoutSelect.value
});
});
}).catch(function(error) {
message.className = "parameter-axis-message web-root-error";
message.textContent = error && error.message ? error.message : String(error);
});
if (typeof dialog.showModal === "function") dialog.showModal();
else dialog.setAttribute("open", "");
}
function showMusrfitParameterPlotWindow(parameterPath, jobName = "", preferredParameters = [], preferredXColumn = "", preferredTemplate = "", preferredLayoutMode = "", savedState) {
if (!parameterPath) return;
parameterPath = normalizeParameterSource(parameterPath);
let platform = musrfitParameterPlotPlatform();
if (typeof platform.createPlotWindow !== "function") {
throw new Error("No parameter-plot window shell is available for this platform");
}
musrfitParameterPlotSequence++;
let shell = platform.createPlotWindow({
title: jobName ? "Parameters: " + jobName : "Parameter plot",
sequence: musrfitParameterPlotSequence
});
if (!shell || !shell.content) {
throw new Error("The parameter-plot window shell did not provide a content container");
}
let plotWindow = shell.root || shell.content;
let content = shell.content;
let keyTarget = shell.keyTarget || plotWindow;
let toolbar = document.createElement("div");
let refreshButton = document.createElement("button");
let dataButton = document.createElement("button");
let optionsButton = document.createElement("button");
let optionsPanel = document.createElement("div");
let layoutLabel = document.createElement("label");
let layoutSelect = document.createElement("select");
let panelIndicator = document.createElement("span");
let dataSourceLabel = document.createElement("span");
let dataSourceValue = document.createElement("span");
let xLabel = document.createElement("label");
let xSelect = document.createElement("select");
let addLabel = document.createElement("label");
let addSelect = document.createElement("select");
let addButton = document.createElement("button");
let modeLabel = document.createElement("label");
let modeSelect = document.createElement("select");
let seriesList = document.createElement("div");
let panelGrid = document.createElement("div");
let message = document.createElement("div");
toolbar.className = "parameter-plot-toolbar";
refreshButton.type = "button";
refreshButton.className = "parameter-plot-refresh";
refreshButton.textContent = "Refresh";
refreshButton.title = "Reload all visible panels from their parameter-data files";
dataButton.type = "button";
dataButton.className = "parameter-plot-data-button";
dataButton.textContent = "Data...";
dataButton.title = "Load a parameter-data file into the selected panel";
let addAllDataSetButton = document.createElement("button");
addAllDataSetButton.type = "button";
addAllDataSetButton.className = "parameter-plot-add-data-set parameter-plot-add-all-data-sets";
addAllDataSetButton.textContent = "Add data set...";
addAllDataSetButton.title = "Overlay a parameter-data file onto every panel, one colour per data set";
optionsButton.type = "button";
optionsButton.className = "view-settings-toggle parameter-plot-options-toggle";
optionsButton.textContent = "Plot options";
optionsButton.setAttribute("aria-expanded", "false");
optionsButton.title = "Show layout, axes, style, and parameter controls";
optionsPanel.className = "parameter-plot-options-panel";
optionsPanel.id = "parameterPlotOptionsPanel" + musrfitParameterPlotSequence;
optionsPanel.hidden = true;
optionsButton.setAttribute("aria-controls", optionsPanel.id);
layoutLabel.className = "parameter-plot-control";
layoutLabel.appendChild(document.createTextNode("Layout "));
for (let layout of ["1x1", "1x2", "2x1", "2x2", "2x3", "3x1", "3x2", "3x3"]) {
let option = document.createElement("option");
option.value = layout;
option.textContent = layout.replace("x", " x ");
layoutSelect.appendChild(option);
}
layoutLabel.appendChild(layoutSelect);
panelIndicator.className = "parameter-plot-panel-indicator";
panelIndicator.textContent = "Panel 1/1";
dataSourceLabel.className = "parameter-plot-data-source";
dataSourceLabel.appendChild(document.createTextNode("Data set "));
dataSourceValue.className = "parameter-plot-data-source-value";
dataSourceValue.textContent = "No data";
dataSourceLabel.appendChild(dataSourceValue);
xLabel.className = "parameter-plot-control";
xLabel.appendChild(document.createTextNode("X "));
xLabel.appendChild(xSelect);
let xOrigin = document.createElement("span");
xOrigin.className = "parameter-plot-x-origin";
xOrigin.textContent = "";
xLabel.appendChild(xOrigin);
addLabel.className = "parameter-plot-control";
addLabel.appendChild(document.createTextNode("Parameter "));
addLabel.appendChild(addSelect);
addButton.type = "button";
addButton.className = "parameter-plot-add";
addButton.textContent = "+";
addButton.title = "Add parameter to selected panel";
modeLabel.className = "parameter-plot-control";
modeLabel.appendChild(document.createTextNode("Style "));
for (let mode of [["markers", "Scatter"], ["lines+markers", "Lines + markers"], ["lines", "Lines"]]) {
let option = document.createElement("option");
option.value = mode[0];
option.textContent = mode[1];
modeSelect.appendChild(option);
}
modeLabel.appendChild(modeSelect);
let paletteLabel = document.createElement("label");
let paletteSelect = document.createElement("select");
paletteLabel.className = "parameter-plot-control";
paletteLabel.appendChild(document.createTextNode("Palette "));
for (let palette of [["default", "Default"], ["bold", "Bold"], ["pastel", "Pastel"], ["mono", "Monochrome"]]) {
let option = document.createElement("option");
option.value = palette[0];
option.textContent = palette[1];
paletteSelect.appendChild(option);
}
paletteLabel.appendChild(paletteSelect);
let xTitleLabel = document.createElement("label");
let xTitleInput = document.createElement("input");
xTitleLabel.className = "parameter-plot-control";
xTitleLabel.appendChild(document.createTextNode("X title "));
xTitleInput.type = "text";
xTitleInput.placeholder = "auto";
xTitleInput.title = "Axis title for the active panel; empty uses the automatic label";
xTitleLabel.appendChild(xTitleInput);
let yTitleLabel = document.createElement("label");
let yTitleInput = document.createElement("input");
yTitleLabel.className = "parameter-plot-control";
yTitleLabel.appendChild(document.createTextNode("Y title "));
yTitleInput.type = "text";
yTitleInput.placeholder = "auto";
yTitleInput.title = "Axis title for the active panel; empty uses the automatic label";
yTitleLabel.appendChild(yTitleInput);
let templateLabel = document.createElement("label");
let templateSelect = document.createElement("select");
templateLabel.className = "parameter-plot-control";
templateLabel.appendChild(document.createTextNode("Template "));
let autoOption = document.createElement("option");
autoOption.value = "";
autoOption.textContent = "Auto";
templateSelect.appendChild(autoOption);
for (let template of MUSRFIT_PARAMETER_PLOT_TEMPLATES) {
let option = document.createElement("option");
option.value = template.id;
option.textContent = template.name;
templateSelect.appendChild(option);
}
templateSelect.value = preferredTemplate || "";
templateLabel.appendChild(templateSelect);
let dataSetsSection = document.createElement("section");
let dataSetsHeading = document.createElement("div");
let dataSetsTitle = document.createElement("span");
let addDataSetButton = document.createElement("button");
let dataSetsList = document.createElement("div");
dataSetsSection.className = "parameter-plot-data-sets";
dataSetsHeading.className = "parameter-plot-data-sets-heading";
dataSetsTitle.className = "parameter-plot-data-sets-title";
dataSetsTitle.textContent = "Overlay data sets";
addDataSetButton.type = "button";
addDataSetButton.className = "parameter-plot-add-data-set";
addDataSetButton.textContent = "Add file...";
addDataSetButton.title = "Add more parameter-data files to overlay onto this panel";
dataSetsHeading.appendChild(dataSetsTitle);
dataSetsHeading.appendChild(addDataSetButton);
dataSetsList.className = "parameter-plot-data-sets-list";
dataSetsSection.appendChild(dataSetsHeading);
dataSetsSection.appendChild(dataSetsList);
let forgetButton = document.createElement("button");
forgetButton.type = "button";
forgetButton.className = "parameter-plot-forget";
forgetButton.textContent = "Forget plot configuration";
forgetButton.title = "Clear the remembered style, layout, and overlay settings for this data source";
seriesList.className = "parameter-plot-summary parameter-plot-series-list";
panelGrid.className = "parameter-plot-grid";
message.className = "web-root-message parameter-plot-message";
message.textContent = "Loading parameter data...";
for (let control of [refreshButton, dataButton, addAllDataSetButton, optionsButton]) toolbar.appendChild(control);
for (let control of [layoutLabel, panelIndicator, dataSourceLabel, xLabel, addLabel, addButton,
modeLabel, paletteLabel, xTitleLabel, yTitleLabel, templateLabel, dataSetsSection, forgetButton, seriesList]) optionsPanel.appendChild(control);
content.appendChild(toolbar);
content.appendChild(optionsPanel);
content.appendChild(panelGrid);
content.appendChild(message);
let plotly = null;
let resizeObserver = null;
let panelStates = [];
let activePanelIndex = 0;
let visiblePanelCount = 1;
let templatePanels = [];
let templateSharedX = false;
// Style registry shared by every panel of this window. Keys are built by
// parameterDataSetStyleKey / parameterTraceStyleKey; values are plain
// {color, symbol, size, opacity} objects edited from the marker picker.
let styleRegistry = {};
// User-renamed legend entries, keyed by musrfitParameterLegendOverrideKey.
// They override the smart default (file prefix or fixed-coordinate tag) so a
// Refresh does not throw away legend labels the user edited.
let legendNameOverrides = {};
let panelSequence = 0;
let windowPaletteId = "default";
let stylePicker = null;
let applyParameterStyleAndRedraw = null;
// Data sets available for overlay, in the order they were loaded.
let registeredDataSets = [];
let dataSetColorCounter = 0;
// The remembered-plot infrastructure. A debounced save writes the full window
// state (palette, layout, style registry, panels, overlays) into the shared
// session storage under the identity of the primary data source. The same map
// will later be carried by the configuration share link without structural
// changes: the snapshot is plain JSON and keyed by mainSourceKey, so two
// independent windows can remember their own data sets without collision.
let saveParameterPlotStateDebounce = null;
function scheduleParameterPlotStateSave() {
if (saveParameterPlotStateDebounce) clearTimeout(saveParameterPlotStateDebounce);
saveParameterPlotStateDebounce = setTimeout(saveParameterPlotStateNow, 400);
}
function saveParameterPlotStateNow() {
if (saveParameterPlotStateDebounce) { clearTimeout(saveParameterPlotStateDebounce); saveParameterPlotStateDebounce = null; }
try {
let storage = parameterPlotStateStorage();
let snapshot = collectParameterPlotStateDescriptor();
if (validateParameterPlotState(snapshot)) rememberParameterPlotState(storage, snapshot);
} catch (error) {
// Persistence is best-effort; never break the window on failure.
}
}
function collectParameterPlotStateDescriptor() {
return {
v: MUSRFIT_PARAMETER_PLOT_STATE_VERSION,
mainSourceKey: source ? parameterDataSetKey(source) : "",
jobName: jobName,
windowPaletteId: windowPaletteId,
panelSequence: panelSequence,
dataSetColorCounter: dataSetColorCounter,
templateId: templateSelect && templateSelect.value ? templateSelect.value : "",
templatePanels: templatePanels.map(function(panel) {
return { role: panel.role || "", title: panel.title || "", params: panel.params ? panel.params.slice() : [] };
}),
templateSharedX: !!templateSharedX,
layout: layoutSelect && layoutSelect.value ? layoutSelect.value : "1x1",
activePanelIndex: activePanelIndex,
panelStates: panelStates.map(function(panel) {
return {
stableId: panel.stableId,
source: portableParameterSource(panel.source),
yNames: panel.yNames.slice(),
xName: panel.xName,
xAuto: !!panel.xAuto,
mode: panel.mode,
dataSetKey: panel.dataSetKey,
overlays: (panel.overlays || []).slice(),
paletteId: panel.paletteId,
xTitle: panel.xTitle || "",
yTitle: panel.yTitle || "",
xScale: panel.xScale || "linear",
yScale: panel.yScale || "linear"
};
}),
registeredDataSets: registeredDataSets.map(function(entry) {
return { key: entry.key, source: portableParameterSource(entry.source), label: entry.label, colorIndex: entry.colorIndex };
}),
legendNameOverrides: JSON.parse(JSON.stringify(legendNameOverrides)),
styleRegistry: typeof styleRegistry === "object" && styleRegistry ? JSON.parse(JSON.stringify(styleRegistry)) : {}
};
}
function applySavedParameterPlotState(snapshot) {
if (!validateParameterPlotState(snapshot)) return;
if (typeof snapshot.windowPaletteId === "string") windowPaletteId = snapshot.windowPaletteId;
if (typeof snapshot.panelSequence === "number" && snapshot.panelSequence > 0) panelSequence = snapshot.panelSequence;
if (typeof snapshot.dataSetColorCounter === "number" && snapshot.dataSetColorCounter > 0) dataSetColorCounter = snapshot.dataSetColorCounter;
// Overlays registered in the snapshot are restored as skeleton entries --
// their data is reloaded during refreshVisiblePanels so the window never
// carries a stale or unserialised dataset object.
registeredDataSets = [];
for (let savedEntry of snapshot.registeredDataSets || []) {
let entrySource = restorePortableParameterSource(savedEntry.source);
if (!entrySource) continue;
let entry = registerParameterDataSet(registeredDataSets, entrySource, savedEntry.colorIndex);
if (entry) { entry.dataset = null; entry.error = null; }
}
dataSetColorCounter = Math.max(
Number.isFinite(snapshot.dataSetColorCounter) ? snapshot.dataSetColorCounter : 0,
registeredDataSets.length);
// Style registry comes in as plain JSON; no need for a structured clone.
styleRegistry = snapshot.styleRegistry || {};
legendNameOverrides = snapshot.legendNameOverrides
&& typeof snapshot.legendNameOverrides === "object" ? snapshot.legendNameOverrides : {};
// Rebuild every panel in the saved order. StableIds are read from the
// snapshot so style registry keys stay aligned across sessions.
let savedPanels = snapshot.panelStates || [];
panelStates = [];
for (let savedPanel of savedPanels) {
let panelSource = restorePortableParameterSource(savedPanel.source);
let panel = createPanelState(
panelSource,
null,
Array.isArray(savedPanel.yNames) ? savedPanel.yNames.slice() : [],
savedPanel.xName || "",
savedPanel.mode || "markers");
panel.stableId = savedPanel.stableId || panel.stableId;
panel.xAuto = !!savedPanel.xAuto;
panel.overlays = Array.isArray(savedPanel.overlays) ? savedPanel.overlays.slice() : [];
panel.paletteId = savedPanel.paletteId || windowPaletteId;
panel.xTitle = savedPanel.xTitle || "";
panel.yTitle = savedPanel.yTitle || "";
panel.xScale = savedPanel.xScale === "log" ? "log" : "linear";
panel.yScale = savedPanel.yScale === "log" ? "log" : "linear";
panel.dataSetKey = panel.source ? parameterDataSetKey(panel.source) : savedPanel.dataSetKey || "";
panelStates.push(panel);
}
// The counter continues from the saved value so future grows keep
// predictable stableIds.
panelSequence = Number.isFinite(snapshot.panelSequence) ? snapshot.panelSequence : panelSequence;
activePanelIndex = Math.min(
Number.isFinite(snapshot.activePanelIndex) && snapshot.activePanelIndex > 0
? snapshot.activePanelIndex : 0,
Math.max(0, panelStates.length - 1));
templatePanels = Array.isArray(snapshot.templatePanels)
? snapshot.templatePanels.map(function(p) { return { role: p.role || "", title: p.title || "", params: Array.isArray(p.params) ? p.params.slice() : [] }; })
: [];
templateSharedX = !!snapshot.templateSharedX;
if (templateSelect) templateSelect.value = snapshot.templateId || "";
let layout = /^\d+x\d+$/.test(snapshot.layout || "") ? snapshot.layout : "1x1";
applyLayout(layout);
}
function sourceLabelFromPath(pathValue) {
let clean = String(pathValue || "").split(/[?#]/)[0];
let pieces = clean.split(/[\\/]/);
return pieces[pieces.length - 1] || "Parameter data";
}
async function readPanelSource(source) {
if (!source) throw new Error("No parameter-data source is selected");
let platform = musrfitParameterPlotPlatform();
if (typeof platform.readDataSource !== "function") {
throw new Error("No parameter-data reader is available for this platform");
}
return await platform.readDataSource(source);
}
function createPanelState(source, dataset, yNames, xName, mode = "markers", xAuto = true) {
panelSequence++;
return {
source: source || null,
dataset: dataset || null,
yNames: Array.isArray(yNames) ? yNames.slice() : [],
xName: xName || "",
xAuto: !!xAuto,
mode: mode || "markers",
stableId: "pp" + panelSequence,
dataSetKey: source ? parameterDataSetKey(source) : "",
overlays: [],
paletteId: windowPaletteId,
xTitle: "",
yTitle: "",
// Axis scale survives a Refresh: redrawPanel applies it to layout and
// the Plotly toggle buttons write it back here.
xScale: "linear",
yScale: "linear",
wrapper: null,
chart: null,
emptyMessage: null,
note: null
};
}
function panelXCandidateIndices(panel) {
if (!panel || !panel.dataset) return [];
return panel.dataset.columns.map(function(column, index) { return index; }).filter(function(index) {
return !isMusrfitParameterErrorColumn(panel.dataset, index)
&& !panel.yNames.some(function(name) {
return musrfitParameterColumnIndex(panel.dataset, name) === index;
});
});
}
function normalizePanelSelection(panel) {
if (!panel || !panel.dataset) return;
let allYCandidates = musrfitParameterYCandidates(panel.dataset, -1);
panel.yNames = panel.yNames.filter(function(name, position, names) {
let index = musrfitParameterColumnIndex(panel.dataset, name);
return allYCandidates.includes(index) && names.indexOf(name) === position;
});
let xCandidates = panelXCandidateIndices(panel);
let xIndex = panel.xName ? musrfitParameterColumnIndex(panel.dataset, panel.xName) : -1;
if (!xCandidates.includes(xIndex)) xIndex = defaultMusrfitParameterXColumn(panel.dataset);
if (!xCandidates.includes(xIndex)) xIndex = xCandidates.length ? xCandidates[0] : -1;
panel.xName = xIndex >= 0 ? panel.dataset.columns[xIndex] : "";
}
function ensurePanelDOM(index) {
let panel = panelStates[index];
if (!panel || panel.wrapper) return;
let wrapper = document.createElement("section");
let chart = document.createElement("div");
let emptyMessage = document.createElement("div");
let note = document.createElement("div");
wrapper.className = "parameter-plot-panel";
wrapper.tabIndex = 0;
wrapper.dataset.panelIndex = String(index);
chart.className = "parameter-plot-canvas";
emptyMessage.className = "parameter-plot-panel-empty";
emptyMessage.textContent = "Select this panel, then add a parameter, load another data file, or click a marker to restyle it.";
note.className = "parameter-plot-note";
note.hidden = true;
wrapper.appendChild(chart);
wrapper.appendChild(emptyMessage);
wrapper.appendChild(note);
panelGrid.appendChild(wrapper);
panel.wrapper = wrapper;
panel.chart = chart;
panel.emptyMessage = emptyMessage;
panel.note = note;
wrapper.addEventListener("pointerdown", function() { setActivePanel(index); });
wrapper.addEventListener("focus", function() { setActivePanel(index); });
}
function setActivePanel(index) {
if (index < 0 || index >= visiblePanelCount) return;
activePanelIndex = index;
for (let i = 0; i < panelStates.length; i++) {
if (panelStates[i].wrapper) panelStates[i].wrapper.classList.toggle("active", i === index);
}
syncToolbarFromActivePanel();
}
function renderDataSetsSection(panel) {
dataSetsList.textContent = "";
if (!panel) {
let empty = document.createElement("span");
empty.className = "parameter-plot-no-series";
empty.textContent = "No data set is selected.";
dataSetsList.appendChild(empty);
return;
}
if (!registeredDataSets.length) {
let empty = document.createElement("span");
empty.className = "parameter-plot-no-series";
empty.textContent = "No overlay files loaded. Add a file to compare scans side by side.";
dataSetsList.appendChild(empty);
return;
}
let activeKey = panel.dataSetKey;
for (let entry of registeredDataSets) {
let row = document.createElement("label");
row.className = "parameter-plot-data-set-row";
row.title = "Overlay " + entry.label + " onto this panel";
let checkbox = document.createElement("input");
checkbox.type = "checkbox";
checkbox.checked = entry.key === activeKey
|| (panel.overlays && panel.overlays.includes(entry.key));
checkbox.disabled = entry.key === activeKey || !panel.dataset;
checkbox.setAttribute("aria-label", "Overlay " + entry.label);
let swatch = document.createElement("span");
swatch.className = "parameter-plot-data-set-swatch";
swatch.style.background = musrfitParameterPaletteColor(windowPaletteId, entry.colorIndex);
swatch.title = "Default color for this data set";
let name = document.createElement("span");
name.className = "parameter-plot-data-set-name";
name.textContent = entry.label;
checkbox.addEventListener("change", function() {
if (checkbox.checked) {
if (!panel.overlays.includes(entry.key)) panel.overlays.push(entry.key);
} else {
panel.overlays = panel.overlays.filter(function(existing) { return existing !== entry.key; });
}
redrawPanel(activePanelIndex);
syncToolbarFromActivePanel();
scheduleParameterPlotStateSave();
});
row.appendChild(checkbox);
row.appendChild(swatch);
row.appendChild(name);
dataSetsList.appendChild(row);
}
}
async function loadDataSetEntry(entry) {
let contents = await readPanelSource(entry.source);
let nextDataset = parseMusrfitParameterData(contents);
if (!nextDataset.columns.length || !nextDataset.rows.length) {
throw new Error(entry.label + " contains no plottable rows");
}
entry.dataset = nextDataset;
entry.error = null;
return entry;
}
function renderSeriesChips(panel) {
seriesList.textContent = "";
if (!panel || !panel.yNames.length) {
let empty = document.createElement("span");
empty.className = "parameter-plot-no-series";
empty.textContent = "Y: none";
seriesList.appendChild(empty);
return;
}
for (let name of panel.yNames) {
let chip = document.createElement("button");
chip.type = "button";
chip.className = "parameter-plot-series-chip";
chip.textContent = name + " \u00d7";
chip.title = "Remove " + name + " from this panel";
chip.addEventListener("click", function(event) {
event.stopPropagation();
panel.yNames = panel.yNames.filter(function(item) { return item !== name; });
normalizePanelSelection(panel);
redrawPanel(activePanelIndex);
syncToolbarFromActivePanel();
scheduleParameterPlotStateSave();
});
seriesList.appendChild(chip);
}
}
function syncToolbarFromActivePanel() {
let panel = panelStates[activePanelIndex];
panelIndicator.textContent = "Panel " + (activePanelIndex + 1) + "/" + visiblePanelCount;
let overlayCount = panel && panel.overlays ? panel.overlays.length : 0;
dataSourceValue.textContent = panel && panel.source
? panel.source.label + (overlayCount ? " + " + overlayCount + " overlay" : "") : "No data";
dataSourceValue.title = panel && panel.source && panel.source.path ? panel.source.path : "";
renderDataSetsSection(panel);
xSelect.textContent = "";
addSelect.textContent = "";
modeSelect.value = panel && panel.mode ? panel.mode : "markers";
paletteSelect.value = windowPaletteId;
xTitleInput.value = panel && panel.xTitle ? panel.xTitle : "";
yTitleInput.value = panel && panel.yTitle ? panel.yTitle : "";
if (!panel || !panel.dataset) {
xSelect.disabled = true;
addSelect.disabled = true;
addButton.disabled = true;
xOrigin.textContent = "";
xOrigin.title = "";
renderSeriesChips(panel);
return;
}
normalizePanelSelection(panel);
let xColumns = panelXCandidateIndices(panel);
let xIndex = musrfitParameterColumnIndex(panel.dataset, panel.xName);
fillMusrfitParameterSelect(xSelect, panel.dataset, xColumns, xIndex);
xSelect.disabled = !xColumns.length;
let scan = detectMusrfitScanVariable(panel.dataset);
let auto = panel.xAuto && scan.column >= 0
&& musrfitParameterColumnIndex(panel.dataset, panel.xName) === scan.column;
if (scan.confidence === "ambiguous") {
xOrigin.textContent = " (auto, mixed " + scan.varying.join(" + ") + ")";
} else if (auto) {
xOrigin.textContent = " (auto)";
} else {
xOrigin.textContent = scan.column >= 0 && xIndex === scan.column ? " (auto)" : "";
}
xOrigin.title = scan.column >= 0
? "Detected scan variable: " + scan.label + " (" + scan.confidence + ")"
: "";
let yCandidates = musrfitParameterYCandidates(panel.dataset, xIndex).filter(function(index) {
return !panel.yNames.some(function(name) {
return musrfitParameterColumnIndex(panel.dataset, name) === index;
});
});
fillMusrfitParameterSelect(addSelect, panel.dataset, yCandidates,
yCandidates.length ? yCandidates[0] : -1);
addSelect.disabled = !yCandidates.length;
addButton.disabled = !yCandidates.length;
renderSeriesChips(panel);
}
function redrawPanel(index) {
let panel = panelStates[index];
if (!panel || !panel.chart || !plotly) return;
normalizePanelSelection(panel);
if (!panel.dataset || !panel.yNames.length || !panel.xName) {
if (panel.chart.data) plotly.purge(panel.chart);
panel.chart.textContent = "";
panel.emptyMessage.hidden = false;
return;
}
let xIndex = musrfitParameterColumnIndex(panel.dataset, panel.xName);
let entries = parameterOverlayEntries(panel, registeredDataSets);
let overlayResult = buildMusrfitParameterOverlayTraces(entries, panel.xName, panel.yNames,
panel.mode, {
paletteId: windowPaletteId,
styleRegistry: styleRegistry,
styleKeyOf: function(key, name) {
return parameterTraceStyleKey(key, panel.stableId, name);
},
legendNameOf: function(dataSetKey, name) {
return legendNameOverrides[musrfitParameterLegendOverrideKey(dataSetKey, name)] || "";
}
});
let traces = overlayResult.traces;
panel.traceMeta = overlayResult.traceMeta || [];
if (panel.note) {
panel.note.textContent = overlayResult.skipped.map(function(skipped) {
return skipped.label + ": " + skipped.reason;
}).join("; ");
panel.note.hidden = !overlayResult.skipped.length;
}
if (!traces.length) {
panel.emptyMessage.hidden = false;
return;
}
panel.emptyMessage.hidden = true;
let compact = visiblePanelCount > 1;
let xAxisTitle = panel.xTitle && panel.xTitle.trim()
? panel.xTitle.trim() : musrfitParameterAxisLabel(panel.dataset.columns[xIndex]);
let yAxisTitle = panel.yTitle && panel.yTitle.trim()
? panel.yTitle.trim()
: (traces.length === 1
? traces[0].name
: musrfitParameterAxisLabel(panel.yNames[0] || ""));
let layout = {
autosize: true,
margin: compact ? { l: 58, r: 14, t: 10, b: 48 } : { l: 75, r: 24, t: 24, b: 65 },
font: { family: "Times New Roman, Times, serif", size: compact ? 12 : 14 },
showlegend: traces.length > 1,
legend: { x: 0.98, xanchor: "right", y: 0.98, yanchor: "top" },
xaxis: {
title: { text: xAxisTitle, font: { size: compact ? 15 : 20 } },
tickfont: { size: compact ? 11 : 14 }, showline: true, mirror: true, automargin: true
},
yaxis: {
title: { text: yAxisTitle, font: { size: compact ? 15 : 20 } },
tickfont: { size: compact ? 11 : 14 }, showline: true, mirror: true, automargin: true
}
};
// plotly.react with a fresh layout resets xaxis.type/yaxis.type to the
// default linear. Reapply the panel's persisted scale so a Refresh does
// not silently switch a log axis back to linear.
if (panel.xScale === "log") layout.xaxis.type = "log";
if (panel.yScale === "log") layout.yaxis.type = "log";
plotly.react(panel.chart, traces, layout, {
responsive: true,
editable: true,
edits: { titleText: false, legendText: true },
displaylogo: false,
// Keep the toolbar mounted so a deliberate tap can reveal it on
// mouse, pen and touch devices without relying on hover support.
displayModeBar: true,
modeBarButtonsToAdd: [
{
name: "Toggle X linear/log",
icon: plotly.Icons.pencil,
click: function(gd) {
let current = gd.layout.xaxis.type || "linear";
let next = current === "log" ? "linear" : "log";
plotly.relayout(gd, {
"xaxis.type": next
});
if (panel.xScale !== next) {
panel.xScale = next;
scheduleParameterPlotStateSave();
}
}
},
{
name: "Toggle Y linear/log",
icon: plotly.Icons.pencil,
click: function(gd) {
let current = gd.layout.yaxis.type || "linear";
let next = current === "log" ? "linear" : "log";
plotly.relayout(gd, {
"yaxis.type": next
});
if (panel.yScale !== next) {
panel.yScale = next;
scheduleParameterPlotStateSave();
}
}
}
]
});
if (!panel.clickAttached && typeof panel.chart.on === "function") {
panel.clickAttached = true;
let toolbarPointer = null;
panel.chart.addEventListener("pointerdown", function(event) {
if (event.target && event.target.closest && event.target.closest(".modebar")) return;
toolbarPointer = {
id: event.pointerId,
x: event.clientX,
y: event.clientY
};
});
panel.chart.addEventListener("pointerup", function(event) {
if (!toolbarPointer || toolbarPointer.id !== event.pointerId) return;
let movedX = event.clientX - toolbarPointer.x;
let movedY = event.clientY - toolbarPointer.y;
toolbarPointer = null;
if ((movedX * movedX) + (movedY * movedY) > 64) return;
if (event.target && event.target.closest && event.target.closest(".modebar")) return;
let wasOpen = panel.chart.classList.contains("modebar-open");
hideParameterModeBars();
if (!wasOpen) panel.chart.classList.add("modebar-open");
});
panel.chart.addEventListener("pointercancel", function() {
toolbarPointer = null;
});
// Map a click on a plotted marker back to its (data set, parameter)
// series and offer style editing in a small popover near the pointer.
panel.chart.on("plotly_click", function(clickEvent) {
let points = clickEvent && clickEvent.points;
if (!points || !points.length) return;
let clicked = points[0];
if (!clicked) return;
let yName = (clicked.curveNumber >= 0 && clicked.curveNumber < panel.yNames.length)
? panel.yNames[clicked.curveNumber] : panel.yNames[0];
if (!yName) return;
openParameterStylePicker(panel, yName, clicked.event);
});
// Capture legend-entry renames (Plotly allows editing legend text while
// the plot is editable) so a Refresh keeps the user's labels instead of
// rebuilding the smart defaults. The rename arrives as a plotly_restyle
// whose data carries the new name; we only record names that actually
// differ from the values we just rendered.
panel.chart.on("plotly_restyle", function(restyleEvent) {
let changes = restyleEvent && restyleEvent.data;
if (!changes || !Array.isArray(changes) || !panel.traceMeta) return;
let indices = restyleEvent.traceIndices;
for (let c = 0; c < changes.length; c++) {
let names = changes[c] && changes[c].name;
if (names === undefined || names === null) continue;
let updated = Array.isArray(names) ? names : [names];
let traceIndex = indices && Array.isArray(indices) ? indices[c] : c;
if (typeof traceIndex !== "number" || traceIndex < 0) continue;
let meta = panel.traceMeta[traceIndex];
if (!meta || !meta.dataSetKey) continue;
let newName = panel.chart.data[traceIndex] && panel.chart.data[traceIndex].name;
if (typeof newName !== "string" || !newName.trim()) continue;
if (meta.defaultName === newName) continue;
let key = musrfitParameterLegendOverrideKey(meta.dataSetKey, meta.name);
if (legendNameOverrides[key] === newName) continue;
legendNameOverrides[key] = newName;
meta.defaultName = newName;
scheduleParameterPlotStateSave();
}
});
}
}
function closeParameterStylePicker() {
if (stylePicker) {
if (stylePicker.remove) stylePicker.remove();
stylePicker = null;
}
}
// The popover lets the user restyle one (data set, parameter) series or every
// trace of the clicked data set, with color, marker symbol, size, and opacity.
function openParameterStylePicker(panel, yName, pointerEvent) {
closeParameterStylePicker();
let fallbackColor = musrfitParameterPaletteColor(windowPaletteId, 0);
let datasetStyleKey = parameterDataSetStyleKey(panel.dataSetKey);
let fallback = { color: fallbackColor, size: 8, opacity: 1, cap: false };
if (styleRegistry[datasetStyleKey]) fallback = styleRegistry[datasetStyleKey];
let current = parameterCurrentStyle(styleRegistry, panel, yName, "trace", fallback);
let picker = document.createElement("div");
picker.className = "parameter-style-popover";
picker.setAttribute("role", "dialog");
picker.setAttribute("aria-label", "Style " + yName);
let title = document.createElement("strong");
title.className = "parameter-style-title";
title.textContent = (panel.source && panel.source.label ? panel.source.label + ": " : "")
+ musrfitParameterAxisLabel(yName);
picker.appendChild(title);
let scopeHelp = document.createElement("div");
scopeHelp.className = "parameter-style-scope";
for (let scope of [["trace", "This trace"], ["dataset", "This data set"]]) {
let label = document.createElement("label");
let radio = document.createElement("input");
radio.type = "radio";
radio.name = "parameterStyleScope" + panel.stableId;
radio.value = scope[0];
radio.checked = scope[0] === "trace";
label.appendChild(radio);
label.appendChild(document.createTextNode(scope[1]));
label.className = "parameter-style-scope-option";
picker.appendChild(label);
}
let swatches = document.createElement("div");
swatches.className = "parameter-style-swatches";
let usedColors = [];
for (let paletteId of Object.keys(MUSRFIT_PARAMETER_PLOT_PALETTES)) {
for (let color of MUSRFIT_PARAMETER_PLOT_PALETTES[paletteId]) {
if (usedColors.includes(color)) continue;
usedColors.push(color);
let swatch = document.createElement("button");
swatch.type = "button";
swatch.className = "parameter-style-swatch" + (color === current.color ? " selected" : "");
swatch.style.background = color;
swatch.value = color;
swatch.title = color;
swatch.addEventListener("click", function() {
picker.dataset.color = color;
for (let other of swatches.querySelectorAll(".parameter-style-swatch")) {
other.classList.toggle("selected", other === swatch);
}
});
swatches.appendChild(swatch);
}
}
picker.appendChild(swatches);
let controls = document.createElement("div");
controls.className = "parameter-style-controls";
let symbolLabel = document.createElement("label");
symbolLabel.className = "parameter-style-control";
symbolLabel.appendChild(document.createTextNode("Symbol "));
let symbolSelect = document.createElement("select");
for (let symbol of MUSRFIT_PARAMETER_PLOT_MARKER_SYMBOLS) {
let option = document.createElement("option");
option.value = symbol;
option.textContent = symbol;
symbolSelect.appendChild(option);
}
symbolSelect.value = current.symbol || "";
symbolSelect.addEventListener("change", function() {
picker.dataset.symbol = symbolSelect.value;
});
symbolLabel.appendChild(symbolSelect);
controls.appendChild(symbolLabel);
let sizeLabel = document.createElement("label");
sizeLabel.className = "parameter-style-control";
sizeLabel.appendChild(document.createTextNode("Size "));
let sizeInput = document.createElement("input");
sizeInput.type = "number";
sizeInput.min = "1";
sizeInput.max = "24";
sizeInput.step = "1";
sizeInput.value = String(current.size);
sizeInput.addEventListener("input", function() {
picker.dataset.size = sizeInput.value;
});
sizeLabel.appendChild(sizeInput);
controls.appendChild(sizeLabel);
let opacityLabel = document.createElement("label");
opacityLabel.className = "parameter-style-control parameter-style-opacity";
opacityLabel.appendChild(document.createTextNode("Opacity "));
let opacityInput = document.createElement("input");
opacityInput.type = "range";
opacityInput.min = "0.1";
opacityInput.max = "1";
opacityInput.step = "0.05";
opacityInput.value = String(current.opacity);
let opacityValue = document.createElement("span");
opacityValue.className = "parameter-style-opacity-value";
opacityValue.textContent = opacityInput.value;
opacityInput.addEventListener("input", function() {
opacityValue.textContent = opacityInput.value;
picker.dataset.opacity = opacityInput.value;
});
opacityLabel.appendChild(opacityInput);
opacityLabel.appendChild(opacityValue);
controls.appendChild(opacityLabel);
let capLabel = document.createElement("label");
capLabel.className = "parameter-style-control parameter-style-cap";
capLabel.appendChild(document.createTextNode("Error-bar caps "));
let capInput = document.createElement("input");
capInput.type = "checkbox";
capInput.checked = !!current.cap;
capInput.addEventListener("change", function() {
picker.dataset.cap = capInput.checked ? "1" : "0";
});
capLabel.appendChild(capInput);
controls.appendChild(capLabel);
picker.appendChild(controls);
let actions = document.createElement("div");
actions.className = "parameter-style-actions";
let closeButton = document.createElement("button");
closeButton.type = "button";
closeButton.textContent = "Close";
closeButton.addEventListener("click", closeParameterStylePicker);
actions.appendChild(closeButton);
let resetButton = document.createElement("button");
resetButton.type = "button";
resetButton.textContent = "Reset";
resetButton.addEventListener("click", function() {
let scope = picker.querySelector('input[type="radio"]:checked');
let scopeValue = scope && scope.value === "dataset" ? "dataset" : "trace";
if (scopeValue === "dataset") {
clearParameterDataSetTraceStyles(styleRegistry, panel.dataSetKey);
}
recordParameterStyle(styleRegistry, parameterStyleScopeKeys(panel, yName, scopeValue), {}, true);
redrawParameterStyleTargets(panel, scopeValue);
syncToolbarFromActivePanel();
closeParameterStylePicker();
scheduleParameterPlotStateSave();
});
actions.appendChild(resetButton);
let applyButton = document.createElement("button");
applyButton.type = "button";
applyButton.className = "parameter-style-apply";
applyButton.textContent = "Apply";
applyButton.addEventListener("click", function() {
applyParameterStyleAndRedraw(panel, yName);
});
actions.appendChild(applyButton);
picker.appendChild(actions);
let scopeRadios = picker.querySelectorAll('input[type="radio"]');
for (let radio of scopeRadios) {
radio.addEventListener("change", function() {
let scope = radio.value === "dataset" ? "dataset" : "trace";
let prefill = parameterCurrentStyle(styleRegistry, panel, yName, scope, fallback);
picker.dataset.color = prefill.color || "";
for (let swatch of swatches.querySelectorAll(".parameter-style-swatch")) {
swatch.classList.toggle("selected", swatch.value === prefill.color);
}
if (prefill.symbol) symbolSelect.value = prefill.symbol;
if (prefill.size !== undefined) sizeInput.value = String(prefill.size);
if (prefill.opacity !== undefined) {
opacityInput.value = String(prefill.opacity);
opacityValue.textContent = String(prefill.opacity);
}
if (prefill.cap !== undefined) {
capInput.checked = !!prefill.cap;
picker.dataset.cap = prefill.cap ? "1" : "0";
}
});
}
// The popover stages edits in its dataset attributes; Apply commits the
// staged choices to the style registry and redraws the affected panels.
applyParameterStyleAndRedraw = function(panel, yName) {
let scope = picker.querySelector('input[type="radio"]:checked');
let scopeValue = scope && scope.value === "dataset" ? "dataset" : "trace";
let override = {};
if (picker.dataset.color) override.color = picker.dataset.color;
if (picker.dataset.symbol) override.symbol = picker.dataset.symbol;
if (picker.dataset.size !== undefined && picker.dataset.size !== "") override.size = picker.dataset.size;
if (picker.dataset.opacity !== undefined && picker.dataset.opacity !== "") override.opacity = picker.dataset.opacity;
if (picker.dataset.cap !== undefined) override.cap = picker.dataset.cap === "1";
if (Object.keys(override).length) {
if (scopeValue === "dataset") {
clearParameterDataSetTraceStyles(styleRegistry, panel.dataSetKey);
}
recordParameterStyle(styleRegistry, parameterStyleScopeKeys(panel, yName, scopeValue), override, false);
redrawParameterStyleTargets(panel, scopeValue);
}
scheduleParameterPlotStateSave();
};
content.appendChild(picker);
let bounds = content.getBoundingClientRect();
let contentWidth = bounds.width || (typeof window.innerWidth === "number" ? window.innerWidth : 800);
let contentHeight = bounds.height || (typeof window.innerHeight === "number" ? window.innerHeight : 600);
let sizeX = pointerEvent && Number.isFinite(pointerEvent.clientX) ? pointerEvent.clientX - bounds.left : 16;
let sizeY = pointerEvent && Number.isFinite(pointerEvent.clientY) ? pointerEvent.clientY - bounds.top : 16;
picker.style.left = Math.max(8, Math.min(sizeX, contentWidth - 328)) + "px";
picker.style.top = Math.max(8, Math.min(sizeY, contentHeight - 328)) + "px";
// The title bar is a drag handle: the picker moves within the parameter-plot
// window itself rather than the OS viewport, so web and Electron place and
// move it identically wherever that window sits.
let dragState = null;
title.addEventListener("pointerdown", function(event) {
if (picker.dataset.dragging) return;
dragState = {
pointerX: event.clientX,
pointerY: event.clientY,
left: parseFloat(picker.style.left) || 0,
top: parseFloat(picker.style.top) || 0
};
picker.dataset.dragging = "1";
title.setPointerCapture(event.pointerId);
event.preventDefault();
});
title.addEventListener("pointermove", function(event) {
if (!dragState) return;
let maximumX = Math.max(0, contentWidth - picker.offsetWidth - 8);
let maximumY = Math.max(0, contentHeight - picker.offsetHeight - 8);
let nextLeft = dragState.left + event.clientX - dragState.pointerX;
let nextTop = dragState.top + event.clientY - dragState.pointerY;
picker.style.left = Math.min(maximumX, Math.max(0, nextLeft)) + "px";
picker.style.top = Math.min(maximumY, Math.max(0, nextTop)) + "px";
});
title.addEventListener("pointerup", function(event) {
dragState = null;
if (picker.dataset.dragging) {
picker.dataset.dragging = "";
if (title.hasPointerCapture(event.pointerId)) title.releasePointerCapture(event.pointerId);
}
});
stylePicker = picker;
// One-shot outside click / focus elsewhere closes the picker.
setTimeout(function() {
document.addEventListener("pointerdown", function(event) {
if (!stylePicker || !stylePicker.parentNode) return;
if (stylePicker.contains(event.target)) return;
closeParameterStylePicker();
}, { once: true, capture: true });
}, 0);
}
function redrawParameterStyleTargets(panel, scope) {
if (scope === "dataset") {
redrawVisiblePanels();
} else {
for (let i = 0; i < visiblePanelCount; i++) {
if (panelStates[i] === panel) {
redrawPanel(i);
return;
}
}
}
}
function redrawVisiblePanels() {
for (let i = 0; i < visiblePanelCount; i++) redrawPanel(i);
}
async function refreshPanel(index, initialLoad = false) {
let panel = panelStates[index];
if (!panel || !panel.source) return;
let oldYNames = panel.yNames.slice();
let oldXName = panel.xName;
let contents = await readPanelSource(panel.source);
let nextDataset = parseMusrfitParameterData(contents);
if (!nextDataset.columns.length || !nextDataset.rows.length) {
throw new Error(panel.source.label + " contains no plottable rows");
}
panel.dataset = nextDataset;
panel.dataSetKey = parameterDataSetKey(panel.source);
panel.paletteId = windowPaletteId;
let yCandidates = musrfitParameterYCandidates(nextDataset, -1);
panel.yNames = oldYNames.filter(function(name) {
return yCandidates.includes(musrfitParameterColumnIndex(nextDataset, name));
});
if (templatePanels && index < templatePanels.length && !panel.yNames.length) {
panel.yNames = musrfitParameterTemplatePanelNames(nextDataset, templatePanels[index].params);
} else if (initialLoad && index === 0 && !panel.yNames.length) {
panel.yNames = preferredParameters.filter(function(name) {
return yCandidates.includes(musrfitParameterColumnIndex(nextDataset, name));
});
}
if (!panel.yNames.length && initialLoad && index === 0 && yCandidates.length
&& !(templatePanels && index < templatePanels.length)) {
panel.yNames = [nextDataset.columns[yCandidates[0]]];
}
panel.xName = oldXName || (initialLoad && index === 0 ? preferredXColumn : "");
panel.xAuto = !oldXName && !(initialLoad && index === 0 && preferredXColumn);
if (initialLoad && index === 0 && !panel.xName) {
panel.xName = detectMusrfitScanVariable(nextDataset).name;
}
// Refresh each overlaid data set too; one faulty overlay must not bring
// down the whole panel, so its error is reported in the panel note.
for (let key of panel.overlays.slice()) {
let entry = findRegisteredDataSet(registeredDataSets, key);
if (!entry) continue;
try {
await loadDataSetEntry(entry);
} catch (error) {
entry.dataset = null;
entry.error = error && error.message ? error.message : String(error);
}
}
normalizePanelSelection(panel);
redrawPanel(index);
}
async function refreshVisiblePanels(initialLoad = false) {
refreshButton.disabled = true;
message.className = "web-root-message parameter-plot-message";
message.textContent = initialLoad ? "Loading parameter data..." : "Refreshing parameter data...";
try {
if (!plotly) {
if (window.Plotly) {
plotly = window.Plotly;
} else {
let platform = musrfitParameterPlotPlatform();
if (typeof platform.loadPlotly !== "function") {
throw new Error("No Plotly loader is available for this platform");
}
plotly = await platform.loadPlotly();
if (!plotly) throw new Error("The platform Plotly loader returned no Plotly instance");
window.Plotly = plotly;
}
}
let tasks = [];
for (let i = 0; i < visiblePanelCount; i++) {
if (panelStates[i] && panelStates[i].source) tasks.push(refreshPanel(i, initialLoad));
}
await Promise.all(tasks);
syncToolbarFromActivePanel();
message.textContent = "";
} catch (error) {
message.className = "web-root-message web-root-error parameter-plot-message";
message.textContent = error && error.message ? error.message : String(error);
} finally {
refreshButton.disabled = false;
scheduleParameterPlotStateSave();
}
}
async function chooseParameterDataSource(panel) {
let platform = musrfitParameterPlotPlatform();
if (typeof platform.chooseDataSource !== "function") {
throw new Error("No parameter-data chooser is available for this platform");
}
let source = await platform.chooseDataSource(panel ? panel.source : null);
if (source && source.kind === "path" && !source.label) {
source.label = sourceLabelFromPath(source.path);
}
return source;
}
// Pick one or more data files for a panel overlay. Platforms that support
// multi-selection expose chooseDataSources; the fallback asks for a single
// file so the feature still works on minimal platform adapters.
async function chooseParameterDataSources(panel) {
let platform = musrfitParameterPlotPlatform();
if (typeof platform.chooseDataSources === "function") {
let picked = await platform.chooseDataSources(panel ? panel.source : null);
if (!Array.isArray(picked)) return [];
return picked.filter(function(source) {
return !!source;
}).map(function(source) {
if (source.kind === "path" && !source.label) {
source.label = sourceLabelFromPath(source.path);
}
return source;
});
}
let source = await chooseParameterDataSource(panel);
return source ? [source] : [];
}
function updateParameterPlotWindowSize(rows, columns) {
try {
var win = shell.root || plotWindow;
if (!win || !win.style) return;
var vw = (typeof window !== "undefined" && window.innerWidth) ? window.innerWidth : 1200;
var vh = (typeof window !== "undefined" && window.innerHeight) ? window.innerHeight : 800;
var statusH = 38;
if (typeof getComputedStyle === "function") {
var cs = getComputedStyle(document.documentElement);
var sv = cs && cs.getPropertyValue ? cs.getPropertyValue("--mu-status-height") : "";
if (sv) statusH = parseFloat(sv) || statusH;
}
var maxWinH = Math.max(320, vh - statusH - 24);
var maxWinW = Math.max(360, vw - 24);
var chromeH = 0;
if (content && content.getBoundingClientRect) {
var cb = content.getBoundingClientRect();
var wb = win.getBoundingClientRect();
if (wb && cb) chromeH = Math.max(0, wb.height - cb.height);
}
if (!chromeH || chromeH < 60) chromeH = 110;
var contentW = Math.max(280, maxWinW - 24);
var panelW = (contentW - (Math.max(0, columns - 1) * 7)) / Math.max(1, columns);
var targetPanelH = panelW * 0.75;
var minPanelH = 160;
if (rows <= 1) {
win.style.height = "";
win.style.maxHeight = maxWinH + "px";
return;
}
var gaps = Math.max(0, rows - 1) * 7;
var idealH = chromeH + (rows * Math.max(minPanelH, Math.min(targetPanelH, 420))) + gaps + 12;
var winH = Math.min(maxWinH, Math.max(320, idealH));
// If constrained by viewport, 4:3 is not forced; grid uses 1fr rows.
win.style.height = Math.round(winH) + "px";
win.style.maxHeight = maxWinH + "px";
} catch (e) {}
}
function applyLayout(layoutValue) {
let match = /^(\d+)x(\d+)$/.exec(layoutValue);
let rows = match ? Number(match[1]) : 1;
let columns = match ? Number(match[2]) : 1;
visiblePanelCount = rows * columns;
panelGrid.style.gridTemplateColumns = "repeat(" + columns + ", minmax(0, 1fr))";
panelGrid.style.gridTemplateRows = "repeat(" + rows + ", minmax(0, 1fr))";
updateParameterPlotWindowSize(rows, columns);
// The fixed options list may not cover the resolved auto grid, so make the
// active layout selectable and visible in the Plot options panel.
let hasOption = Array.from(layoutSelect.options).some(function(option) {
return option.value === layoutValue;
});
if (!hasOption) {
let option = document.createElement("option");
option.value = layoutValue;
option.textContent = layoutValue.replace("x", " x ");
layoutSelect.appendChild(option);
}
layoutSelect.value = layoutValue;
let cloneFrom = panelStates[activePanelIndex] || panelStates[0];
while (panelStates.length < visiblePanelCount) {
let cloned = createPanelState(
cloneFrom ? cloneFrom.source : null,
cloneFrom ? cloneFrom.dataset : null,
[],
cloneFrom ? cloneFrom.xName : "",
cloneFrom ? cloneFrom.mode : "markers"
);
if (cloneFrom && cloneFrom.overlays) cloned.overlays = cloneFrom.overlays.slice();
panelStates.push(cloned);
}
for (let i = 0; i < panelStates.length; i++) {
ensurePanelDOM(i);
panelStates[i].wrapper.hidden = i >= visiblePanelCount;
}
if (activePanelIndex >= visiblePanelCount) activePanelIndex = 0;
setActivePanel(activePanelIndex);
redrawVisiblePanels();
}
// Rebuild the visible panel states from a declarative template (or from the
// default single auto panel when no template is selected). Any existing
// charts are purged first so the layout is rebuilt cleanly.
function applyTemplateToPanelStates(templateId, source, initialLoad) {
for (let panel of panelStates) {
if (panel && panel.chart && plotly && plotly.purge) plotly.purge(panel.chart);
}
panelStates = [];
templatePanels = [];
templateSharedX = false;
let template = templateId ? MUSRFIT_PARAMETER_PLOT_TEMPLATES.find(function(item) {
return item.id === templateId;
}) : null;
if (template) {
templatePanels = template.panels.map(function(panel) {
return { role: panel.role, title: panel.title, params: panel.params.slice() };
});
templateSharedX = !!template.sharedX;
for (let i = 0; i < templatePanels.length; i++) {
panelStates.push(createPanelState(source, null, [], preferredXColumn));
}
applyLayout(template.layout || "1x1");
} else if (preferredLayoutMode) {
// The axis dialog's layout choice seeds the initial window layout.
// Each selected parameter gets its own panel, arranged per the mode.
let count = Math.max(1, preferredParameters.length);
let layout = musrfitParameterLayoutFromMode(preferredLayoutMode, count);
for (let i = 0; i < count; i++) {
let yNames = preferredParameters[i] ? [preferredParameters[i]] : [];
panelStates.push(createPanelState(source, null, yNames, preferredXColumn));
}
applyLayout(layout);
} else {
panelStates.push(createPanelState(source, null, preferredParameters, preferredXColumn));
applyLayout("1x1");
}
}
optionsButton.addEventListener("click", function() {
let open = optionsButton.getAttribute("aria-expanded") === "true";
optionsButton.setAttribute("aria-expanded", open ? "false" : "true");
optionsPanel.hidden = open;
if (!open) syncToolbarFromActivePanel();
});
layoutSelect.addEventListener("change", function() {
applyLayout(layoutSelect.value);
scheduleParameterPlotStateSave();
});
xSelect.addEventListener("change", function() {
let panel = panelStates[activePanelIndex];
if (!panel || !panel.dataset) return;
let index = Number(xSelect.value);
if (index < 0 || index >= panel.dataset.columns.length) return;
panel.xName = panel.dataset.columns[index];
panel.xAuto = false;
redrawPanel(activePanelIndex);
syncToolbarFromActivePanel();
scheduleParameterPlotStateSave();
});
addButton.addEventListener("click", function() {
let panel = panelStates[activePanelIndex];
if (!panel || !panel.dataset) return;
let index = Number(addSelect.value);
if (index < 0 || index >= panel.dataset.columns.length) return;
let name = panel.dataset.columns[index];
if (!panel.yNames.includes(name)) panel.yNames.push(name);
normalizePanelSelection(panel);
redrawPanel(activePanelIndex);
syncToolbarFromActivePanel();
scheduleParameterPlotStateSave();
});
modeSelect.addEventListener("change", function() {
let panel = panelStates[activePanelIndex];
if (!panel) return;
panel.mode = modeSelect.value;
redrawPanel(activePanelIndex);
scheduleParameterPlotStateSave();
});
paletteSelect.addEventListener("change", function() {
windowPaletteId = paletteSelect.value;
for (let state of panelStates) state.paletteId = windowPaletteId;
redrawVisiblePanels();
syncToolbarFromActivePanel();
scheduleParameterPlotStateSave();
});
xTitleInput.addEventListener("input", function() {
let panel = panelStates[activePanelIndex];
if (!panel) return;
panel.xTitle = xTitleInput.value;
redrawPanel(activePanelIndex);
scheduleParameterPlotStateSave();
});
yTitleInput.addEventListener("input", function() {
let panel = panelStates[activePanelIndex];
if (!panel) return;
panel.yTitle = yTitleInput.value;
redrawPanel(activePanelIndex);
scheduleParameterPlotStateSave();
});
templateSelect.addEventListener("change", function() {
applyTemplateToPanelStates(templateSelect.value, source, false);
refreshVisiblePanels(false);
scheduleParameterPlotStateSave();
});
forgetButton.addEventListener("click", function() {
let storage = parameterPlotStateStorage();
if (source) {
forgetParameterPlotState(storage, parameterDataSetKey(source));
message.className = "web-root-message parameter-plot-message";
message.textContent = "The remembered plot configuration for this data source was cleared.";
}
});
refreshButton.addEventListener("click", function() { refreshVisiblePanels(false); });
dataButton.addEventListener("click", async function() {
let panel = panelStates[activePanelIndex];
dataButton.disabled = true;
try {
let source = await chooseParameterDataSource(panel);
if (!source) return;
panel.source = source;
await refreshPanel(activePanelIndex, false);
syncToolbarFromActivePanel();
message.textContent = "";
scheduleParameterPlotStateSave();
} catch (error) {
message.className = "web-root-message web-root-error parameter-plot-message";
message.textContent = error && error.message ? error.message : String(error);
} finally {
dataButton.disabled = false;
}
});
addDataSetButton.addEventListener("click", async function() {
let panel = panelStates[activePanelIndex];
if (!panel) return;
addDataSetButton.disabled = true;
try {
let sources = await chooseParameterDataSources(panel);
for (let source of sources) {
let entry = registerParameterDataSet(registeredDataSets, source, dataSetColorCounter++);
if (!panel.overlays.includes(entry.key)) panel.overlays.push(entry.key);
try {
await loadDataSetEntry(entry);
} catch (error) {
entry.dataset = null;
entry.error = error && error.message ? error.message : String(error);
}
}
redrawPanel(activePanelIndex);
syncToolbarFromActivePanel();
message.textContent = "";
scheduleParameterPlotStateSave();
} catch (error) {
message.className = "web-root-message web-root-error parameter-plot-message";
message.textContent = error && error.message ? error.message : String(error);
} finally {
addDataSetButton.disabled = false;
}
});
// Toolbar-level "Add data set..." overlays the picked files onto every
// panel at once. Each file gets one colour from the palette and every panel
// plots the same parameters it already shows, so adding a scan compares it
// against the current one across the whole window with a distinct colour.
addAllDataSetButton.addEventListener("click", async function() {
let panel = panelStates[activePanelIndex];
if (!panel) return;
addAllDataSetButton.disabled = true;
try {
let sources = await chooseParameterDataSources(panel);
for (let source of sources) {
let entry = registerParameterDataSet(registeredDataSets, source, dataSetColorCounter++);
for (let state of panelStates) {
if (!state.overlays.includes(entry.key)) state.overlays.push(entry.key);
}
try {
await loadDataSetEntry(entry);
} catch (error) {
entry.dataset = null;
entry.error = error && error.message ? error.message : String(error);
}
}
redrawVisiblePanels();
syncToolbarFromActivePanel();
message.textContent = "";
scheduleParameterPlotStateSave();
} catch (error) {
message.className = "web-root-message web-root-error parameter-plot-message";
message.textContent = error && error.message ? error.message : String(error);
} finally {
addAllDataSetButton.disabled = false;
}
});
let source = parameterPath;
if (source.kind === "path" && !source.label) {
source = {
kind: "path",
path: source.path,
label: jobName || sourceLabelFromPath(source.path)
};
}
// The axis dialog can pass a validated snapshot to reopen a remembered plot
// directly, skipping the "Choose X axis" dialog. Panel sources are resolved
// and data reloaded by refreshVisiblePanels below, so there is no async
// mismatch in this path.
if (savedState && validateParameterPlotState(savedState)) {
applySavedParameterPlotState(savedState);
} else {
applyTemplateToPanelStates(preferredTemplate || "", source, true);
}
refreshVisiblePanels(true);
if (typeof ResizeObserver !== "undefined") {
resizeObserver = new ResizeObserver(function() {
try {
var match = /^(\d+)x(\d+)$/.exec(layoutSelect.value || "1x1");
updateParameterPlotWindowSize(match ? Number(match[1]) : 1, match ? Number(match[2]) : 1);
} catch (e) {}
if (!plotly || !plotly.Plots) return;
for (let i = 0; i < visiblePanelCount; i++) {
let panel = panelStates[i];
if (panel && panel.chart && panel.chart.isConnected) plotly.Plots.resize(panel.chart);
}
});
resizeObserver.observe(panelGrid);
}
function hideParameterModeBars() {
for (let panel of panelStates) {
if (panel.chart) panel.chart.classList.remove("modebar-open");
}
}
function dismissParameterModeBar(event) {
let target = event.target;
if (target && target.closest && target.closest(".parameter-plot-canvas")) return;
hideParameterModeBars();
}
function handleParameterPlotKeydown(event) {
let target = event.target;
let editableTarget = target && target.tagName
&& (target.tagName.toLowerCase() === "input"
|| target.tagName.toLowerCase() === "select"
|| target.tagName.toLowerCase() === "textarea"
|| target.isContentEditable);
if (event.altKey || event.ctrlKey || event.metaKey || editableTarget) return;
let shortcut = event.key.length === 1 ? event.key.toLowerCase() : event.key;
if (shortcut === "u" && plotly) {
event.preventDefault();
let panel = panelStates[activePanelIndex];
if (panel && panel.chart) {
plotly.relayout(panel.chart, { "xaxis.autorange": true, "yaxis.autorange": true });
}
} else if (shortcut === "q" || shortcut === "Escape") {
let openModeBar = plotWindow.querySelector
? plotWindow.querySelector(".modebar-open") : null;
if (shortcut === "Escape" && openModeBar) {
event.preventDefault();
hideParameterModeBars();
return;
}
if (stylePicker) {
event.preventDefault();
closeParameterStylePicker();
return;
}
event.preventDefault();
if (typeof shell.close === "function") shell.close();
}
}
if (keyTarget && typeof keyTarget.addEventListener === "function") {
keyTarget.addEventListener("keydown", handleParameterPlotKeydown);
}
if (document && typeof document.addEventListener === "function") {
document.addEventListener("pointerdown", dismissParameterModeBar, true);
}
function cleanupParameterPlot() {
saveParameterPlotStateNow();
closeParameterStylePicker();
if (keyTarget && typeof keyTarget.removeEventListener === "function") {
keyTarget.removeEventListener("keydown", handleParameterPlotKeydown);
}
if (document && typeof document.removeEventListener === "function") {
document.removeEventListener("pointerdown", dismissParameterModeBar, true);
}
if (resizeObserver) resizeObserver.disconnect();
if (plotly) {
for (let panel of panelStates) {
if (panel.chart && panel.chart.data) plotly.purge(panel.chart);
}
}
}
if (typeof shell.onClose === "function") shell.onClose(cleanupParameterPlot);
if (typeof shell.show === "function") shell.show();
return {
close: typeof shell.close === "function" ? shell.close : function() {},
destroy: cleanupParameterPlot,
root: plotWindow
};
}