MagNet / assets /app.js
minjiechen's picture
Update MagNet static website
b440e64 verified
Raw History Blame Contribute Delete
24.5 kB
const state = {
catalog: null,
datasetFilter: "all",
datasetQuery: "",
modelFilter: "all",
modelQuery: "",
route: "home",
neuralPredictor: null,
predictionRunning: false,
};
const staticMode = document.documentElement.dataset.magnetStatic === "true";
const el = (id) => document.getElementById(id);
const escapeHtml = (value) => String(value).replace(/[&<>'"]/g, (character) => ({
"&": "&amp;",
"<": "&lt;",
">": "&gt;",
"'": "&#39;",
'"': "&quot;",
})[character]);
const labels = {
"migration-required": "Being prepared",
"publication-blocked": "Publication blocked",
planned: "Planned",
available: "Available",
raw: "Raw",
processed: "Training ready",
"steady-state-loss": "Steady-state loss",
"transient-sequence": "Transient sequence",
unvalidated: "Not yet validated",
"parity-validated": "Numerically checked",
baseline: "Baseline",
preparing: "Preparing release",
published: "Published",
"review-required": "Under review",
};
const routes = new Set(["home", "data", "models", "predict", "documentation"]);
const legacyRoutes = { data: "data", models: "models", predict: "predict", learn: "documentation", home: "home" };
const pageTitles = {
home: "Princeton MagNet",
data: "Data · Princeton MagNet",
models: "Models · Princeton MagNet",
predict: "Predict · Princeton MagNet",
documentation: "Documentation · Princeton MagNet",
};
function routeFromHash() {
const rawHash = window.location.hash.slice(1);
const rawRoute = rawHash.startsWith("/") ? rawHash.slice(1) : rawHash;
const token = rawRoute.split("/")[0];
const route = token ? (legacyRoutes[token] || token) : "home";
if (!routes.has(route)) {
window.history.replaceState(null, "", "#/");
return "home";
}
if (rawHash && !rawHash.startsWith("/")) {
window.history.replaceState(null, "", route === "home" ? "#/" : `#/${route}`);
}
return route;
}
function showRoute({ focus = true } = {}) {
const route = routeFromHash();
state.route = route;
document.querySelectorAll("[data-view]").forEach((view) => {
view.hidden = view.dataset.view !== route;
});
document.querySelectorAll("nav [data-route]").forEach((link) => {
if (link.dataset.route === route) link.setAttribute("aria-current", "page");
else link.removeAttribute("aria-current");
});
document.title = pageTitles[route];
window.scrollTo({ top: 0, behavior: "auto" });
const view = document.querySelector(`[data-view="${route}"]`);
if (focus) {
const heading = view.querySelector("h1");
heading.setAttribute("tabindex", "-1");
heading.focus({ preventScroll: true });
}
if (route === "predict" && state.catalog) requestAnimationFrame(updateWaveform);
}
function humanize(value) {
return labels[value] || String(value ?? "—").replaceAll("-", " ");
}
function formatBytes(bytes) {
if (!Number.isFinite(bytes)) return "Not reported";
const units = ["B", "KB", "MB", "GB", "TB"];
let value = bytes;
let unit = 0;
while (value >= 1000 && unit < units.length - 1) {
value /= 1000;
unit += 1;
}
return `${value >= 10 || unit === 0 ? value.toFixed(0) : value.toFixed(1)} ${units[unit]}`;
}
function isPublished(item) {
const release = item.release;
return Boolean(
release
&& release.status === "published"
&& release.repo_id
&& release.revision
&& Array.isArray(release.files)
&& release.files.length
&& item.license !== "review-required"
);
}
function huggingFaceRepoUrl(release) {
const prefix = release.repo_type === "dataset" ? "datasets/" : "";
const releasePath = release.path_prefix
? `/${release.path_prefix.split("/").map(encodeURIComponent).join("/")}`
: "";
return `https://huggingface.co/${prefix}${release.repo_id}/tree/${encodeURIComponent(release.revision)}${releasePath}`;
}
function huggingFaceFileUrl(release, file) {
const prefix = release.repo_type === "dataset" ? "datasets/" : "";
const path = file.path.split("/").map(encodeURIComponent).join("/");
return `https://huggingface.co/${prefix}${release.repo_id}/resolve/${encodeURIComponent(release.revision)}/${path}?download=true`;
}
function searchText(item) {
return [
item.id,
item.title,
item.summary,
item.task,
item.stage,
item.format,
item.framework,
item.license,
...(item.materials || []),
...(item.tags || []),
].filter(Boolean).join(" ").toLocaleLowerCase();
}
function libraryActions(item, kind) {
const release = item.release || {};
const onlineAction = kind === "model" && item.inference_available
&& (staticMode || item.id === "igse-v1")
? '<a class="library-action secondary" href="#/predict">Try online</a>'
: "";
if (!isPublished(item)) {
return `<div class="library-actions"><span class="release-state">${escapeHtml(release.status === "planned" ? "Planned for Hugging Face" : "Publishing pending")}</span><small>${escapeHtml(release.repo_id || "Repository not assigned")}</small>${onlineAction}</div>`;
}
const fileLinks = release.files.map((file) => `<li><a href="${escapeHtml(huggingFaceFileUrl(release, file))}" download>${escapeHtml(file.label || file.path)} <span>${escapeHtml(formatBytes(file.size_bytes))}</span></a></li>`).join("");
let command;
if (kind !== "dataset" || item.stage === "raw") {
const patterns = release.path_prefix ? `, allow_patterns=\"${release.path_prefix}/**\"` : "";
command = `snapshot_download(repo_id=\"${release.repo_id}\", repo_type=\"${release.repo_type}\", revision=\"${release.revision}\"${patterns})`;
} else {
const names = item.task === "steady-state-loss"
? ["steady-state-scalar", "steady-state-sequence"]
: ["transient-sequences"];
command = names.map((name) => `load_dataset(\"${release.repo_id}\", name=\"${name}\", split=\"full\", revision=\"${release.revision}\")`).join("; ");
}
return `<div class="library-actions"><a class="library-action primary" href="${escapeHtml(huggingFaceRepoUrl(release))}" target="_blank" rel="noopener">View on Hugging Face <span aria-hidden="true">↗</span></a>${onlineAction}<details class="file-downloads"><summary>Download files (${release.files.length})</summary><ul>${fileLinks}</ul></details><code>${escapeHtml(command)}</code></div>`;
}
function card(item, kind) {
const materials = Array.isArray(item.materials) ? item.materials : [];
const materialCount = materials.length;
const details = kind === "dataset"
? [["Task", humanize(item.task)], ["Stage", humanize(item.stage)], ["Format", item.format], ["License", humanize(item.license)]]
: [["Version", item.version], ["Task", humanize(item.task)], ["Framework", item.framework], ["Materials", materialCount], ["Validation", humanize(item.certification)], ["License", humanize(item.license)]];
const tags = (item.tags || []).slice(0, 4).map((tag) => `<span>${escapeHtml(humanize(tag))}</span>`).join("");
const materialList = kind === "dataset"
? `<div class="dataset-materials"><strong>Available materials (${materialCount})</strong><p>${materials.map(escapeHtml).join(", ")}</p></div>`
: "";
return `<article class="catalog-card"><div class="library-description"><header><h3>${escapeHtml(item.title)}</h3><span class="status">${escapeHtml(humanize(item.status))}</span></header><p>${escapeHtml(item.summary || "MagNet library release.")}</p>${materialList}<div class="tag-list">${tags}</div></div><dl>${details.map(([key, value]) => `<dt>${escapeHtml(key)}</dt><dd>${escapeHtml(value ?? "—")}</dd>`).join("")}<dt>Release size</dt><dd>${escapeHtml(formatBytes(item.release?.total_size_bytes))}</dd></dl>${libraryActions(item, kind)}</article>`;
}
function renderDatasets() {
const query = state.datasetQuery.toLocaleLowerCase();
const items = state.catalog.datasets.filter((item) => {
const filterMatch = state.datasetFilter === "all"
|| item.task === state.datasetFilter
|| item.stage === state.datasetFilter
|| (state.datasetFilter === "published" && isPublished(item));
return filterMatch && (!query || searchText(item).includes(query));
});
el("dataset-result-count").textContent = `${items.length} ${items.length === 1 ? "dataset" : "datasets"}`;
el("dataset-grid").innerHTML = items.map((item) => card(item, "dataset")).join("") || '<p class="loading">No datasets match these filters.</p>';
}
function renderModels() {
const query = state.modelQuery.toLocaleLowerCase();
const items = state.catalog.models.filter((item) => {
const filterMatch = state.modelFilter === "all"
|| item.task === state.modelFilter
|| (state.modelFilter === "published" && isPublished(item))
|| (state.modelFilter === "inference" && item.inference_available);
return filterMatch && (!query || searchText(item).includes(query));
});
el("model-result-count").textContent = `${items.length} ${items.length === 1 ? "model" : "models"}`;
el("model-grid").innerHTML = items.map((item) => card(item, "model")).join("") || '<p class="loading">No models match these filters.</p>';
}
function waveform(kind, peakMilliTesla, dutyRatio = 0.5, count = 200) {
const peak = peakMilliTesla / 1000;
const riseDuty = Math.min(0.99, Math.max(0.01, dutyRatio));
return Array.from({ length: count }, (_, index) => {
const phase = index / count;
if (kind === "triangle") {
if (phase < riseDuty) return -peak + 2 * peak * phase / riseDuty;
return peak - 2 * peak * (phase - riseDuty) / (1 - riseDuty);
}
return peak * Math.sin(2 * Math.PI * phase);
});
}
function drawWaveform(values) {
const canvas = el("waveform-chart");
const cssWidth = Math.max(canvas.clientWidth, 320);
const cssHeight = cssWidth * (260 / 760);
const scale = window.devicePixelRatio || 1;
canvas.width = Math.round(cssWidth * scale);
canvas.height = Math.round(cssHeight * scale);
const context = canvas.getContext("2d");
context.setTransform(scale, 0, 0, scale, 0, 0);
const width = cssWidth;
const height = cssHeight;
const padding = Math.min(34, width * 0.08);
context.clearRect(0, 0, width, height);
context.strokeStyle = "#d8d8d4";
context.lineWidth = 1;
context.beginPath();
context.moveTo(padding, height / 2);
context.lineTo(width - padding, height / 2);
context.stroke();
context.strokeStyle = "#e77500";
context.lineWidth = 3;
context.lineJoin = "round";
const maxAbs = Math.max(...values.map(Math.abs), 1e-9);
context.beginPath();
values.forEach((value, index) => {
const x = padding + index / (values.length - 1) * (width - 2 * padding);
const y = height / 2 - value / maxAbs * (height / 2 - padding);
if (index) context.lineTo(x, y); else context.moveTo(x, y);
});
context.stroke();
context.fillStyle = "#5f5f5f";
context.font = "13px system-ui";
context.fillText(`+${(maxAbs * 1000).toFixed(0)} mT`, padding, 18);
context.fillText(`−${(maxAbs * 1000).toFixed(0)} mT`, padding, height - 8);
}
function currentWaveform() {
const kind = el("waveform").value;
const duty = Number(el("duty").value);
const values = waveform(kind, Number(el("flux").value), duty, 128);
if (kind !== "triangle") return values;
const shift = Math.trunc((duty <= 0.5 ? 0.5 - duty / 2 : -duty / 2) * 128);
return values.map((_, index) => values[((index - shift) % 128 + 128) % 128]);
}
function syncPredictionMaterials() {
const selectedMaterial = el("material").value;
const baseline = state.catalog.models.find((item) => item.id === "igse-v1");
const neural = state.catalog.models.find((item) => item.id === "legacy-transformer-v1");
const supported = state.catalog.materials.filter((item) =>
(item.igse && baseline?.materials?.includes(item.id)) || neural?.materials?.includes(item.id));
el("material").innerHTML = supported.map((item) =>
`<option value="${escapeHtml(item.id)}">${escapeHtml(item.manufacturer)} ${escapeHtml(item.id)}</option>`).join("");
if (supported.some((item) => item.id === selectedMaterial)) el("material").value = selectedMaterial;
el("predict-button").disabled = !supported.length;
resetPrediction();
if (!supported.length) {
el("neural-prediction-note").textContent = "No material has an online iGSE or Transformer prediction.";
}
updateWaveform();
}
function resetPrediction() {
el("igse-loss-result").textContent = "—";
el("neural-loss-result").textContent = "—";
el("igse-prediction-note").textContent = "Uses waveform, frequency, and material; ignores temperature and DC bias.";
el("neural-prediction-note").textContent = "Experimental legacy model. First run downloads the browser runtime and material model.";
el("bh-loop-section").hidden = true;
el("bh-loop-path").setAttribute("d", "");
}
function formatLoss(loss) {
if (!Number.isFinite(loss)) throw new Error("Model returned a non-finite volumetric loss.");
return `${(loss / 1000).toLocaleString(undefined, { maximumFractionDigits: 1 })} kW/m³`;
}
function drawBhLoop(b, h) {
if (!Array.isArray(b) || !Array.isArray(h) || b.length !== 128 || h.length !== b.length
|| !b.every(Number.isFinite) || !h.every(Number.isFinite)) {
throw new Error("Transformer returned an invalid 128-point B–H loop.");
}
const maxH = Math.max(...h.map(Math.abs), 1e-9);
const maxB = Math.max(...b.map(Math.abs), 1e-9);
const left = 74; const right = 728; const top = 40; const bottom = 300;
const centerX = (left + right) / 2;
const centerY = (top + bottom) / 2;
const path = h.map((field, index) => {
const x = centerX + field / maxH * (right - left) / 2;
const y = centerY - b[index] / maxB * (bottom - top) / 2;
return `${index ? "L" : "M"}${x.toFixed(2)} ${y.toFixed(2)}`;
}).join(" ");
el("bh-loop-path").setAttribute("d", path);
el("bh-loop-start").setAttribute("cx", (centerX + h[0] / maxH * (right - left) / 2).toFixed(2));
el("bh-loop-start").setAttribute("cy", (centerY - b[0] / maxB * (bottom - top) / 2).toFixed(2));
const fieldLabel = maxH >= 10 ? maxH.toFixed(1) : maxH.toPrecision(2);
const fluxLabel = (maxB * 1000).toFixed(0);
el("bh-h-negative").textContent = `−${fieldLabel}`;
el("bh-h-positive").textContent = `+${fieldLabel}`;
el("bh-b-positive").textContent = `+${fluxLabel}`;
el("bh-b-negative").textContent = `−${fluxLabel}`;
el("bh-loop-section").hidden = false;
}
function updateDutyVisibility() {
const triangular = el("waveform").value === "triangle";
el("duty-control").hidden = !triangular;
}
function updateWaveform() {
drawWaveform(currentWaveform());
const waveformName = el("waveform").selectedOptions[0].textContent;
const dutySummary = el("waveform").value === "triangle"
? `, ${Math.round(Number(el("duty").value) * 100)}% rising / ${Math.round((1 - Number(el("duty").value)) * 100)}% falling`
: "";
const phaseSummary = el("waveform").value === "triangle"
? " Phase-aligned for the legacy model." : "";
el("waveform-summary").textContent = `${waveformName} waveform, ${el("flux").value} mT peak${dutySummary}. Both methods receive the same 128 B samples.${phaseSummary}`;
}
function errorMessage(detail) {
if (typeof detail === "string") return detail;
if (Array.isArray(detail)) return detail.map((item) => item.msg || JSON.stringify(item)).join("; ");
if (detail && typeof detail === "object") return detail.msg || JSON.stringify(detail);
return "Prediction failed.";
}
async function predict(event) {
event.preventDefault();
if (state.predictionRunning) return;
state.predictionRunning = true;
const values = currentWaveform();
updateWaveform();
resetPrediction();
el("igse-loss-result").textContent = "Calculating…";
el("neural-loss-result").textContent = "Waiting…";
el("predict-button").disabled = true;
const controls = Array.from(el("prediction-form").querySelectorAll("input, select"));
controls.forEach((control) => { control.disabled = true; });
const request = {
model_id: "igse-v1",
material_id: el("material").value,
frequency_hz: Number(el("frequency").value) * 1000,
temperature_c: Number(el("temperature").value),
b_waveform_t: values,
};
try {
const baseline = state.catalog.models.find((item) => item.id === "igse-v1");
if (!baseline?.materials?.includes(request.material_id)
|| !state.catalog.materials.find((item) => item.id === request.material_id)?.igse) {
throw new Error("No iGSE coefficients are available for this material.");
}
let result;
if (staticMode) {
if (!window.MagNetStaticPredictor?.predictLoss) {
throw new Error("iGSE browser predictor unavailable. Please refresh the page.");
}
result = await window.MagNetStaticPredictor.predictLoss(request, state.catalog);
} else {
const response = await fetch("/api/v1/predict/loss", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(request),
});
result = await response.json();
if (!response.ok) throw new Error(errorMessage(result.detail));
}
el("igse-loss-result").textContent = formatLoss(result.loss_w_per_m3);
el("igse-prediction-note").textContent = [
...(result.warnings || []),
"iGSE does not model temperature or DC bias.",
].join(" ");
} catch (error) {
el("igse-loss-result").textContent = "Unavailable";
el("igse-prediction-note").textContent = error.message;
}
try {
el("neural-loss-result").textContent = "Loading model…";
const neural = state.catalog.models.find((item) => item.id === "legacy-transformer-v1");
if (!neural?.materials?.includes(request.material_id)) {
throw new Error("No Transformer checkpoint is available for this material.");
}
if (!staticMode || !window.MagNetNeuralPredictor) {
throw new Error("Transformer browser inference is available in the static MagNet Space, not this server deployment.");
}
const material = encodeURIComponent(request.material_id);
const modelBase = `./assets/neural/${material}/`;
const normResponse = await fetch(`${modelBase}norm.json`);
if (!normResponse.ok) throw new Error(`Neural model normalization unavailable (${normResponse.status}).`);
const norm = await normResponse.json();
if (!state.neuralPredictor) {
state.neuralPredictor = new window.MagNetNeuralPredictor({
workerUrl: "./assets/neural-worker.js",
ortScriptUrl: "./assets/ort.wasm.min.js",
wasmBaseUrl: "./assets/",
});
}
const duty = el("waveform").value === "triangle" ? Number(el("duty").value) : 0.5;
const domainCheck = window.MagNetNeuralDomain
? window.MagNetNeuralDomain.check(request.material_id, [
request.frequency_hz, Number(el("flux").value) / 1000,
Number(el("bias").value), request.temperature_c, duty,
]).catch((error) => ({ error: error.message }))
: Promise.resolve({ error: "domain checker unavailable" });
const result = await state.neuralPredictor.predict({
materialId: request.material_id,
b_waveform_t: values,
frequency_hz: request.frequency_hz,
temperature_c: request.temperature_c,
bias_a_per_m: Number(el("bias").value),
norm,
encoderUrl: `${modelBase}encoder.onnx`,
decoderUrl: `${modelBase}decoder.onnx`,
}, {
onProgress(progress) {
el("neural-loss-result").textContent = progress.stage === "loading"
? "Loading model…" : progress.stage === "decoding"
? `Calculating ${Math.min(progress.completedSteps, 128)}/128…` : "Finishing…";
},
});
drawBhLoop(values, result.h_waveform_a_per_m);
el("neural-loss-result").textContent = formatLoss(result.loss_w_per_m3);
const domain = await domainCheck;
const notes = [...(result.warnings || [])];
if (domain?.error) notes.push("Operating-domain check unavailable; use caution.");
else if ((typeof domain === "boolean" ? domain : domain?.inDomain) === false) {
notes.push("Outside the legacy model's measured operating domain; this is an extrapolation.");
}
notes.push("Legacy neural model; numerical port parity checked, independent accuracy not certified. Calculated in your browser.");
el("neural-prediction-note").textContent = notes.join(" ");
} catch (error) {
el("neural-loss-result").textContent = "Unavailable";
el("neural-prediction-note").textContent = error.message;
el("bh-loop-section").hidden = true;
el("bh-loop-path").setAttribute("d", "");
} finally {
state.predictionRunning = false;
el("predict-button").disabled = !el("material").options.length;
controls.forEach((control) => { control.disabled = false; });
}
}
async function init() {
const response = await fetch(staticMode ? "./catalog.json" : "/api/v1/catalog");
if (!response.ok) throw new Error(`Catalog request failed (${response.status}).`);
state.catalog = await response.json();
el("material-count").textContent = state.catalog.materials.length;
el("dataset-count").textContent = state.catalog.datasets.length;
el("model-count").textContent = state.catalog.models.length;
renderDatasets();
renderModels();
updateDutyVisibility();
syncPredictionMaterials();
}
function configureStaticLinks() {
if (!staticMode) return;
const guide = document.querySelector("[data-api-reference]");
guide.href = "https://huggingface.co/datasets/minjiechen/MagNet";
guide.target = "_blank";
guide.rel = "noopener";
guide.querySelector("strong").textContent = "Dataset guide";
guide.querySelector("span").textContent = "Published data and download instructions ↗";
const footer = document.querySelector("[data-api-footer]");
footer.href = "#/documentation";
footer.textContent = "Documentation";
}
document.querySelectorAll("[data-dataset-filter]").forEach((button) => button.addEventListener("click", () => {
document.querySelectorAll("[data-dataset-filter]").forEach((peer) => {
const active = peer === button;
peer.classList.toggle("active", active);
peer.setAttribute("aria-pressed", String(active));
});
state.datasetFilter = button.dataset.datasetFilter;
renderDatasets();
}));
document.querySelectorAll("[data-model-filter]").forEach((button) => button.addEventListener("click", () => {
document.querySelectorAll("[data-model-filter]").forEach((peer) => {
const active = peer === button;
peer.classList.toggle("active", active);
peer.setAttribute("aria-pressed", String(active));
});
state.modelFilter = button.dataset.modelFilter;
renderModels();
}));
el("dataset-search").addEventListener("input", () => {
state.datasetQuery = el("dataset-search").value.trim();
renderDatasets();
});
el("model-search").addEventListener("input", () => {
state.modelQuery = el("model-search").value.trim();
renderModels();
});
[["frequency", "frequency-output"], ["flux", "flux-output"], ["temperature", "temperature-output"]].forEach(([input, output]) => el(input).addEventListener("input", () => {
el(output).value = el(input).value;
resetPrediction();
if (input === "flux") updateWaveform();
}));
el("material").addEventListener("change", resetPrediction);
el("waveform").addEventListener("change", () => { resetPrediction(); updateWaveform(); });
el("waveform").addEventListener("change", updateDutyVisibility);
el("duty").addEventListener("input", () => {
el("duty-output").value = `${Math.round(Number(el("duty").value) * 100)}%`;
resetPrediction();
updateWaveform();
});
el("bias").addEventListener("input", () => { el("bias-output").value = el("bias").value; resetPrediction(); });
el("prediction-form").addEventListener("submit", predict);
window.addEventListener("resize", () => {
if (state.catalog && state.route === "predict") updateWaveform();
});
window.addEventListener("hashchange", () => showRoute({ focus: true }));
document.querySelector(".skip-link").addEventListener("click", (event) => {
event.preventDefault();
const heading = document.querySelector(`[data-view="${state.route}"] h1`);
heading.setAttribute("tabindex", "-1");
heading.focus();
});
configureStaticLinks();
showRoute({ focus: !["", "#/", "#home"].includes(window.location.hash) });
init().catch((error) => {
el("dataset-grid").innerHTML = `<p class="catalog-error">Catalog unavailable: ${escapeHtml(error.message)}</p>`;
el("model-grid").innerHTML = `<p class="catalog-error">Catalog unavailable: ${escapeHtml(error.message)}</p>`;
el("predict-button").disabled = true;
});