drag to zoom · double-click to reset · scores follow the view
Scores against climatology
Climatology is the slot climatology of the last 28 days, built from the same run's inputs. Ratio = our score ÷ climatology on the days both have; below 1 beats it. Coverage target is 80%. Lower is better for every other metric.
Predico's official scores
How Predico scored our submissions and where we ranked among all forecasters on that challenge. Only our own results are shown.
Submission record
One square per target day (${m.city}). Click a day to show it in the chart.
Latest run ${esc(T.last_run.slice(0, 16).replace("T", " "))} UTC · ${T.runs} run${T.runs === 1 ? "" : "s"} published
${esc(T.env)}
${esc(T.model)}: t0-gamma (The Forecasting Company, Apache-2.0), zero-shot, 90 days of context, with covariates. D+2 to D+10 fall back to slot climatology. Backtest results
${(T.features.length ? T.features : ["(feature list arrives with the first published run)"]).map(f => `${esc(f)}`).join("")}
Daily scores
Every target day, newest first. Click a row to show it in the chart.
`;
}
summary(main.inst.scales.x.min, main.inst.scales.x.max);
// Official scores: one column per variable and metric, value with our rank among N.
const off = T.official ?? [], offEl = root.querySelector("#lv-off");
if (!off.length) offEl.innerHTML = `
No official scores yet. Predico scores a day once its measurements are in, usually a day or two after delivery.
`;
else {
const cols = [...new Set(off.map(r => `${r.variable} ${r.metric}`))].sort();
const byDay = new Map();
for (const r of off) (byDay.get(r.day) ?? byDay.set(r.day, {}).get(r.day))[`${r.variable} ${r.metric}`] = r;
const days = [...byDay.keys()].sort().reverse();
const rankCell = r => (r ? `
`;
}
// Daily table, newest first; days without measurements still show their status.
const scoredDay = new Map(model.map(d => [d.key, d]));
const cell = (d, b, m, f) => {
const v = d?.[m], c = b?.[m], r = m === "coverage" || v == null || c == null ? null : v / c;
return `
Test year 1 Nov 2025 – 31 Oct 2026. Each forecast is made at 14:00 ${m.city} on D-1 from data published before then, and scored per local day as Predico does. Lower is better. ${m.missingTruth}
Leaderboard
Scores relative to ${esc(meta.baseline)} (= 1.000) on the days both are scored. Highlighted: the live config.
Coverage: share of quarter-hours inside [q10, q90]; a calibrated model gets 80%.
Score: geometric mean of the ${targets.length > 1 ? "four normalised values (RMSE and Winkler, both targets)" : "two normalised values (RMSE and Winkler)"}; rank sorts by it.
Configs in the charts below
Same colour = same model family; dash = variant.
Day viewer
q50 per config, interval of the first selected config, truth in black. Times in UTC.
`;
let range = "90", kind = "miss";
const ts = mount(root.querySelector("#tg-ts"), (w, h) => new uPlot({
width: w, height: h, tzDate: tzUTC, legend: { show: false }, scales: { x: { time: true } },
cursor: { drag: { x: true, y: false }, points: { size: 6, width: 2, fill: css("--surface") }, bind: { dblclick: () => () => { setR(range); return null; } } },
series: [{}, line(LABEL[t], css("--accent-ink"), { width: 1.25 })],
axes: axes(`${LABEL[t]} (${meta.units[t]})`),
plugins: [tooltip(seriesRows(fmtUTC))],
}, [x, target[t]], root.querySelector("#tg-ts")), chartHeight);
ts.keepX = true;
const setR = r => { range = r; ts.inst.setScale("x", { min: r === "all" ? x[0] : x[n - 1] - +r * 86400, max: x[n - 1] }); };
onSeg(root, "tg-r", setR);
function quant(a, q) { if (!a.length) return null; const s = Float64Array.from(a).sort(); const p = (s.length - 1) * q, lo = Math.floor(p); return s[lo] + (s[Math.min(lo + 1, s.length - 1)] - s[lo]) * (p - lo); }
function profile(keyFn, keys) {
const g = new Map(keys.map(k => [k, []]));
target[t].forEach((v, i) => { if (v != null) g.get(keyFn(i))?.push(v); });
return { mean: keys.map(k => mean(g.get(k))), q10: keys.map(k => quant(g.get(k), 0.1)), q90: keys.map(k => quant(g.get(k), 0.9)) };
}
const months = [...new Set(cal.map(c => c.month))];
const monthIdx = new Map(months.map((m, i) => [m, i]));
const monthName = i => `${MON[+months[i].slice(5) - 1]} ${months[i].slice(0, 4)}`;
const PROFILES = [
["tg-p1", "Quarter-hour of day", i => cal[i].hour * 4 + Math.floor((x[i] % 3600) / 900), Array.from({ length: 96 }, (_, i) => i), i => `${pad(i / 4)}:00`, i => `${pad(Math.floor(i / 4))}:${pad((i % 4) * 15)}`, 16],
["tg-p2", "Weekday", i => cal[i].wd, [0, 1, 2, 3, 4, 5, 6], i => WEEKDAYS[i], i => WEEKDAYS[i], 1],
["tg-p3", "Month", i => monthIdx.get(cal[i].month), months.map((_, i) => i), i => `${MON[+months[i].slice(5) - 1]}\n${months[i].slice(2, 4)}`, monthName, 3],
];
const profCharts = PROFILES.map(([id, title, keyFn, keys, tick, ttl, step]) => mount(root.querySelector(`#${id}`), (w, h) => {
const p = profile(keyFn, keys);
return new uPlot({ width: w, height: h, title, legend: { show: false }, scales: { x: { time: false } }, cursor: { points: { size: 5, width: 2, fill: css("--surface") } },
series: [{}, { stroke: css("--accent"), width: 1, points: { show: false } }, { stroke: css("--accent"), width: 1, points: { show: false } }, line("Mean", css("--accent-ink"), { width: 2 })],
bands: [{ series: [2, 1], fill: css("--band") }],
axes: axes("", (u, s) => s.map(i => (Number.isInteger(i) && i in keys ? tick(i) : "")), { space: 20, incrs: [step] }),
plugins: [tooltip((u, i) => ttHTML(ttl(i), [[css("--accent-ink"), "Mean", f1(p.mean[i])], [css("--accent"), "q10–q90", `${f1(p.q10[i])} … ${f1(p.q90[i])}`]]))],
}, [keys, p.q10, p.q90, p.mean], root.querySelector(`#${id}`));
}, 230));
function stats() {
const v = target[t].filter(a => a != null), s = Float64Array.from(v).sort(), m = mean(v);
const sd = Math.sqrt(mean(v.map(a => (a - m) ** 2)));
root.querySelector("#tg-k").innerHTML = kpi("Mean", f1(m), meta.units[t]) + kpi("Std", f1(sd)) +
kpi("Exact zeros", pct(v.filter(a => a === 0).length / v.length)) + kpi("Negative", pct(v.filter(a => a < 0).length / v.length)) +
kpi("Min / max", `${minus(Math.round(s[0]))} / ${Math.round(s[s.length - 1])}`);
return s;
}
const hist = mount(root.querySelector("#tg-h"), (w, h) => {
const s = stats(), lo = quant(s, 0.005), hi = quant(s, 0.995), bins = 80, width = (hi - lo) / bins;
const counts = new Array(bins).fill(0);
for (const v of s) counts[Math.min(bins - 1, Math.max(0, Math.floor((Math.min(Math.max(v, lo), hi) - lo) / width)))]++;
const centers = counts.map((_, i) => lo + (i + 0.5) * width);
return new uPlot({ width: w, height: h, legend: { show: false }, scales: { x: { time: false } }, cursor: { points: { show: false } },
series: [{}, { label: "Quarter-hours", stroke: css("--accent-ink"), fill: css("--band"), paths: uPlot.paths.bars({ size: [0.92, 100] }), points: { show: false } }],
axes: axes("Quarter-hours", (u, sp) => sp.map(v => minus(Math.round(v))), { space: 50 }),
plugins: [tooltip((u, i) => ttHTML(`${f1(centers[i] - width / 2)} … ${f1(centers[i] + width / 2)}`, [[css("--accent-ink"), "Quarter-hours", counts[i].toLocaleString("en-GB")]]))],
}, [centers, counts], root.querySelector("#tg-h"));
}, 280);
// Scatter on a plain canvas (5,000 points; static). Spain only: price vs energy.
const scEl = root.querySelector("#tg-sc");
const pairs = []; if (scatter) for (let i = 0; i < n; i++) if (target.energy[i] != null && target.price[i] != null) pairs.push([target.energy[i], target.price[i]]);
let seed = 1; const rnd = () => ((seed = (seed * 16807) % 2147483647) / 2147483647);
const sample = Array.from({ length: Math.min(5000, pairs.length) }, () => pairs[Math.floor(rnd() * pairs.length)]);
const drawScatter = w => {
const dpr = devicePixelRatio || 1, h = 360; scEl.width = w * dpr; scEl.height = h * dpr;
const ctx = scEl.getContext("2d"); ctx.scale(dpr, dpr); ctx.clearRect(0, 0, w, h);
const xs = sample.map(p => p[0]), ys = sample.map(p => p[1]);
const qx = [quant(xs, 0.002), quant(xs, 0.998)], qy = [quant(ys, 0.002), quant(ys, 0.998)];
const L = 58, B = 40, X = v => L + ((v - qx[0]) / (qx[1] - qx[0])) * (w - L - 12), Y = v => h - B - ((v - qy[0]) / (qy[1] - qy[0])) * (h - B - 10);
ctx.font = `11px ${css("--mono")}`; ctx.fillStyle = css("--ink-soft"); ctx.strokeStyle = css("--grid");
for (let k = 0; k <= 4; k++) {
const vx = qx[0] + ((qx[1] - qx[0]) * k) / 4, vy = qy[0] + ((qy[1] - qy[0]) * k) / 4;
ctx.beginPath(); ctx.moveTo(X(vx), 10); ctx.lineTo(X(vx), h - B); ctx.stroke(); ctx.fillText(minus(Math.round(vx)), X(vx) - 14, h - B + 16);
ctx.beginPath(); ctx.moveTo(L, Y(vy)); ctx.lineTo(w - 12, Y(vy)); ctx.stroke(); ctx.fillText(minus(Math.round(vy)), 8, Y(vy) + 4);
}
ctx.font = `12px ${css("--sans")}`;
ctx.fillText("Net mFRR energy (MWh)", L, h - 6);
ctx.fillStyle = css("--accent-ink"); ctx.globalAlpha = 0.28;
for (const [a, b] of sample) if (a >= qx[0] && a <= qx[1] && b >= qy[0] && b <= qy[1]) ctx.fillRect(X(a) - 1.2, Y(b) - 1.2, 2.4, 2.4);
ctx.globalAlpha = 1; ctx.fillStyle = css("--ink-soft"); ctx.fillText("Price (EUR/MWh) ↑", L + 6, 22);
};
if (scatter) mount(scEl, w => { drawScatter(w); return { destroy() {}, setSize: ({ width }) => drawScatter(width) }; }, 360);
function heat() {
const per = new Map();
target[t].forEach((v, i) => { const k = cal[i].day; per.set(k, (per.get(k) ?? 0) + (kind === "miss" ? v == null : v === 0)); });
const max = Math.max(1, ...per.values()), total = [...per.values()].reduce((a, b) => a + b, 0);
root.querySelector("#tg-ms").textContent = `${kind === "miss" ? "Missing" : "Exactly zero"} quarter-hours per day: ${total.toLocaleString("en-GB")} of ${n.toLocaleString("en-GB")} (${pct(total / n)}).${t === "energy" && kind === "miss" ? " Energy gaps were filled with 0 upstream: use Exact zeros to see them." : ""}`;
let html = `${Array.from({ length: 31 }, (_, d) => `${d % 5 === 0 ? d + 1 : ""}`).join("")}`;
for (const m of months) {
html += `${MON[+m.slice(5) - 1]} ${m.slice(2, 4)}`;
for (let d = 1; d <= 31; d++) {
const k = `${m}-${pad(d)}`, v = per.get(k);
html += v == null ? `` : ``;
}
}
root.querySelector("#tg-heat").innerHTML = html;
}
heat();
setR(range);
onSeg(root, "tg-mk", v => { kind = v; heat(); });
onSeg(root, "tg-t", v => {
t = v; heat();
rebuild(ts); setR(range);
profCharts.forEach(rebuild); rebuild(hist);
});
}
// --- Input features ----------------------------------------------------------------------
async function renderInputs(root) {
const cat = await json("catalog.json"), used = await liveFeatures(mk());
const groups = new Set(cat.flatMap(r => (r.group ? r.group.split(", ") : [])));
const cats = [...new Set(cat.map(r => r.category))].map(c => ({ c, n: cat.filter(r => r.category === c).length, used: cat.filter(r => r.category === c && r.used).length })).sort((a, b) => b.used - a.used || b.n - a.n);
root.innerHTML = `
Input features
Every series we could feed a model. ESIOS serves indicators (time series), offer indicators (bid curves) and archives (bulk files). Calendar columns are computed. Used marks series in a feature group of configs/groups.toml; availability future = known for the target day before the gate, past = only known up to the forecast origin. Categories come from keyword rules on the English name, so a few rows may sit in the wrong bucket.
${used.size ? `
Used by the live model
The ${used.size} input columns of the latest live run (besides the target's own history).
`;
};
["in-c", "in-u"].forEach(id => root.querySelector(`#${id}`).addEventListener("change", draw));
root.querySelector("#in-q").addEventListener("input", draw);
root.querySelector("#in-more").addEventListener("click", () => { limit = Infinity; draw(); });
draw();
}
// Feature columns the latest live run of each of the market's targets used (live.json).
async function liveFeatures(m) {
const [live, meta] = await Promise.all([json("live.json").catch(() => null), json("meta.json")]), out = new Set();
for (const t of shortsOf(m, meta)) for (const f of live?.targets?.[t]?.features ?? []) out.add(f);
return out;
}
// Outside Spain: the market's feature columns from configs/groups.toml (build.py writes them),
// and a map of the weather points with their weights where the market reads Open-Meteo.
async function renderFeatures(root) {
const m = mk(), rows = (await json("features.json"))[m.id], used = await liveFeatures(m);
const geo = (await json("geo.json").catch(() => ({})))[m.id];
root.innerHTML = `
Input features
The columns the ${esc(m.name)} models see, one line each in configs/groups.toml. Availability future = known for the target day before the gate, past = only known up to the forecast origin. Live marks the columns the latest live run used.
${geo ? `
Weather sampling
${geo.sets.map(s => `${s.points.length} points (${s.weighted ? "weighted by PV capacity; dot size = weight" : "plain mean"}): ${s.runs.join(" and ")} run of D-1`).join(" · ")}. Outline: ${esc(geo.label)}.