3017 lines
128 KiB
JavaScript
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
|
|
};
|
|
}
|