Overlaid data sets show which physical state each scan represents instead of just a file name: the legend tag is derived from the data set's own scan variable, tagging an energy scan with its constant temperature, a temperature scan with its constant energy (LE-µSR) or field (bulk µSR), and a field scan with its temperature. Legend entries renamed directly in the plot are remembered and survive Refresh instead of being rebuilt from the smart defaults. The Histograms field on the Runs tab gains a hover note documenting the forward/backward pair syntax and the slash-separated multi-group asymmetry option.
2921 lines
124 KiB
JavaScript
2921 lines
124 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,
|
|
|
|
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;
|
|
// 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 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))";
|
|
|
|
// 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() {
|
|
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 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") {
|
|
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);
|
|
}
|
|
|
|
function cleanupParameterPlot() {
|
|
saveParameterPlotStateNow();
|
|
closeParameterStylePicker();
|
|
if (keyTarget && typeof keyTarget.removeEventListener === "function") {
|
|
keyTarget.removeEventListener("keydown", handleParameterPlotKeydown);
|
|
}
|
|
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
|
|
};
|
|
}
|