@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/engineering/EyeDiagram.js

@@ -0,0 +1,270 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart } from "./EngineeringChart.js";
+import { bin, blur2, contours, geoPath, geoTransform, max, min, scaleLinear, sum } from "d3";
+// src/charts/engineering/EyeDiagram.ts
+var EyeRender = /* @__PURE__ */ function(EyeRender) {
+	EyeRender["Traces"] = "traces";
+	EyeRender["Density"] = "density";
+	EyeRender["Contours"] = "contours";
+	return EyeRender;
+}({});
+var COLUMNS = 120;
+var ROWS = 70;
+var TRACE_LIMIT = 300;
+function sampleWaveform(seed) {
+	const bits = SampleData.distribution(seed, 200, 1).map((row) => +row.value > 40 ? 1 : 0);
+	const noise = SampleData.distribution(seed + 1, 397, 1).map((row) => (+row.value - 40) / 8);
+	const perBit = 24;
+	let level = 0;
+	return bits.flatMap((bit, b) => Array.from({ length: perBit }, (_, i) => {
+		const n = b * perBit + i;
+		level += (bit - level) * .14;
+		return {
+			time: +((n + noise[b] * .8) / perBit).toFixed(4),
+			value: +(level + noise[n % 397] * .018).toFixed(4)
+		};
+	}));
+}
+/** Judge a serial link: overlays every symbol of a waveform to show noise and jitter margins. */
+var EyeDiagram = class extends EngineeringChart {
+	static meta = {
+		id: "eye-diagram",
+		name: "Eye diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Folds a digital waveform onto one symbol period to reveal eye opening, noise and timing jitter.",
+		tags: [
+			"signal integrity",
+			"serdes",
+			"jitter",
+			"mask test",
+			"oscilloscope"
+		],
+		sample: sampleWaveform,
+		variants: {
+			render: [
+				"traces",
+				"density",
+				"contours"
+			],
+			span: [
+				2,
+				1,
+				3
+			],
+			mask: [true, false],
+			jitter: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			time: "time",
+			value: "value",
+			unitInterval: 1,
+			render: "traces",
+			span: 2,
+			mask: true,
+			jitter: true,
+			maskHeight: .5
+		};
+	}
+	/** Waveform cut into one trace per window, in unit intervals. */
+	fold() {
+		const { time, value, unitInterval, span } = this.options;
+		const shift = span % 2 === 0 ? .5 : 0;
+		const traces = /* @__PURE__ */ new Map();
+		const samples = this.rows.map((row) => [this.num(row, time) / unitInterval, this.num(row, value)]).filter((p) => p.every(Number.isFinite)).sort((a, b) => a[0] - b[0]);
+		samples.forEach(([t, v], i) => {
+			const window = Math.floor((t + shift) / span), local = t + shift - window * span;
+			const trace = traces.get(window) ?? [];
+			if (!trace.length && i) {
+				const [before, level] = samples[i - 1], back = t - before;
+				trace.push(local >= back ? [local - back, level] : [0, level + (v - level) * (back - local) / back]);
+			}
+			trace.push([local, v]);
+			traces.set(window, trace);
+			const previous = traces.get(window - 1);
+			if (previous && trace.length === 1) previous.push([span, v]);
+		});
+		return [...traces.values()].slice(1, -1);
+	}
+	crossings(traces, threshold) {
+		return traces.flatMap((trace) => trace.flatMap(([t, v], i) => {
+			if (!i) return [];
+			const [s, u] = trace[i - 1];
+			return (u - threshold) * (v - threshold) < 0 ? [{ at: s + (threshold - u) * (t - s) / (v - u) }] : [];
+		}));
+	}
+	/** Crossings repeat every UI, so a circular mean finds them; the eye sits half a UI later. */
+	eyeCenter(cross, span) {
+		if (!cross.length) return span / 2;
+		const angles = cross.map((c) => 2 * Math.PI * c.at);
+		const eye = Math.atan2(sum(angles, Math.sin), sum(angles, Math.cos)) / (2 * Math.PI) + .5;
+		return eye + Math.round(span / 2 - eye);
+	}
+	grid(traces, span, [low, high]) {
+		const cells = /* @__PURE__ */ new Float64Array(8400);
+		for (const trace of traces) for (let i = 1; i < trace.length; i++) {
+			const [s, u] = trace[i - 1], [t, v] = trace[i];
+			for (let step = 0; step < 8; step++) {
+				const c = Math.floor((s + (t - s) * step / 8) / span * COLUMNS);
+				const r = Math.floor((1 - (u + (v - u) * step / 8 - low) / (high - low)) * ROWS);
+				if (c >= 0 && c < COLUMNS && r >= 0 && r < ROWS) cells[r * COLUMNS + c] += 1;
+			}
+		}
+		return cells;
+	}
+	draw(ctx) {
+		const { render, span, mask, jitter, maskHeight, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const traces = this.fold();
+		const strip = jitter ? Math.min(34, height * .22) : 0;
+		const eyeHeight = height - strip - (strip ? 6 : 0);
+		const x = scaleLinear([0, span], [0, width]);
+		const y = scaleLinear(this.span(traces.flat().map((p) => p[1]), { pad: .08 }), [eyeHeight, 0]);
+		const threshold = (y.domain()[0] + y.domain()[1]) / 2;
+		this.frame(ctx.nest("translate(0,0)", "eye"), {
+			x,
+			y,
+			hideX: jitter,
+			xTitle: xLabel ?? "Time (UI)",
+			yTitle: yLabel ?? "Amplitude"
+		});
+		const eye = ctx.nest("translate(0,0)", "eye-marks");
+		const color = ctx.palette.color("Signal");
+		const at = (p) => [x(p[0]), y(p[1])];
+		if (render === "traces") this.traces(eye, "traces", traces.filter((_, i) => i % Math.ceil(traces.length / TRACE_LIMIT) === 0).map((trace, i) => ({
+			key: `t${i}`,
+			color,
+			width: 1,
+			opacity: .22,
+			points: trace.map(at)
+		})));
+		else {
+			const cells = this.grid(traces, span, y.domain());
+			blur2({
+				data: cells,
+				width: COLUMNS,
+				height: ROWS
+			}, render === "contours" ? 1.4 : .6);
+			const top = max(cells) ?? 1;
+			const tint = (value) => ctx.palette.sequential(.15 + .85 * Math.sqrt(value / top));
+			if (render === "density") {
+				const pixels = Array.from(cells, (value, i) => ({
+					value,
+					i
+				})).filter((cell) => cell.value > 0);
+				const w = width / COLUMNS, h = eyeHeight / ROWS;
+				const marks = ctx.marks("density", "rect", pixels, (d) => d.i, eye.root).attr("fill", (d) => tint(d.value));
+				ctx.set(marks, {
+					x: (d) => d.i % COLUMNS * w,
+					y: (d) => Math.floor(d.i / COLUMNS) * h,
+					width: w + .4,
+					height: h + .4
+				}, {
+					x: (d) => d.i % COLUMNS * w,
+					y: (d) => Math.floor(d.i / COLUMNS) * h,
+					width: w + .4,
+					height: 0
+				});
+				ctx.hover(marks, (d) => ({
+					title: "Trace density",
+					rows: [["Hits", d.value]]
+				}));
+			} else {
+				const bands = contours().size([COLUMNS, ROWS]).thresholds(Array.from({ length: 7 }, (_, i) => top * (i + 1) ** 2 / 64))(Array.from(cells));
+				const scale = geoPath(geoTransform({ point(px, py) {
+					this.stream.point(px * width / COLUMNS, py * eyeHeight / ROWS);
+				} }));
+				this.shapes(eye, "contours", bands.map((band) => ({
+					key: `c${band.value}`,
+					d: scale(band) ?? "",
+					fill: tint(band.value)
+				})));
+			}
+		}
+		const cross = this.crossings(traces, threshold);
+		const center = this.eyeCenter(cross, span);
+		const atCenter = traces.flatMap((trace) => {
+			const hit = trace.find(([t], i) => i && t >= center);
+			return hit ? [hit[1]] : [];
+		});
+		const upper = atCenter.filter((v) => v > threshold), lower = atCenter.filter((v) => v <= threshold);
+		const floorOfOnes = min(upper) ?? 0, ceilingOfZeros = max(lower) ?? 0;
+		const opening = upper.length && lower.length ? floorOfOnes - ceilingOfZeros : 0;
+		if (mask && opening > 0) {
+			const half = .3, rise = opening / 2 * maskHeight, mid = (floorOfOnes + ceilingOfZeros) / 2;
+			const polygon = [
+				[center - half, mid],
+				[center - half / 2, mid + rise],
+				[center + half / 2, mid + rise],
+				[center + half, mid],
+				[center + half / 2, mid - rise],
+				[center - half / 2, mid - rise]
+			];
+			const inside = (t, v) => Math.abs(t - center) < half && Math.abs(v - mid) < rise * (1 - Math.max(0, Math.abs(t - center) - half / 2) / (half / 2));
+			const hits = traces.flat().filter(([t, v]) => inside(t, v)).length;
+			this.shapes(eye, "mask", [{
+				key: "mask",
+				fill: hits ? ctx.theme.critical : ctx.theme.good,
+				opacity: .28,
+				d: `M${polygon.map(at).join("L")}Z`
+			}]);
+			this.annotate(eye, "mask-note", [{
+				key: "m",
+				text: hits ? `${hits} mask hits` : "Mask clear",
+				x: x(center),
+				y: y(mid) + 4,
+				anchor: "middle",
+				tone: "ink",
+				size: 10
+			}], {
+				width,
+				height: eyeHeight
+			});
+		}
+		this.annotate(eye, "eye-note", opening > 0 ? [{
+			key: "h",
+			text: `Opening ${opening.toPrecision(2)}`,
+			x: x(center),
+			y: y(threshold) + (mask ? 30 : 4),
+			anchor: "middle",
+			tone: "ink"
+		}] : [], {
+			width,
+			height: eyeHeight
+		});
+		if (jitter) {
+			const axis = ctx.nest(`translate(0,${eyeHeight + 6})`, "jitter");
+			const bins = bin().value((d) => d.at).domain([0, span]).thresholds(span * 36)(cross);
+			const tallest = max(bins, (b) => b.length) || 1;
+			const bars = ctx.marks("jitter-bars", "rect", bins.filter((b) => b.length), (d) => d.x0, axis.root).attr("fill", color).attr("rx", 1);
+			const bottom = strip, scale = (n) => n / tallest * (strip - 2);
+			ctx.set(bars, {
+				x: (d) => x(d.x0),
+				width: (d) => Math.max(1, x(d.x1) - x(d.x0) - 1),
+				y: (d) => bottom - scale(d.length),
+				height: (d) => scale(d.length)
+			}, {
+				x: (d) => x(d.x0),
+				width: (d) => Math.max(1, x(d.x1) - x(d.x0) - 1),
+				y: bottom,
+				height: 0
+			});
+			ctx.hover(bars, (d) => ({
+				title: "Threshold crossings",
+				rows: [["Time", `${d.x0.toFixed(2)} UI`], ["Count", d.length]]
+			}));
+			this.frame(axis, {
+				x,
+				y: scaleLinear([0, tallest], [strip, 0]),
+				name: "jitter-frame",
+				yValues: [],
+				xTitle: xLabel ?? "Time (UI)"
+			});
+		}
+	}
+};
+export { EyeDiagram, EyeRender };

package/dist/charts/engineering/FatigueSNCurve.js

@@ -0,0 +1,231 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart } from "./EngineeringChart.js";
+// src/charts/engineering/FatigueSNCurve.ts
+var FatigueFit = /* @__PURE__ */ function(FatigueFit) {
+	FatigueFit["None"] = "test-points";
+	FatigueFit["Mean"] = "mean-curve";
+	FatigueFit["Band"] = "scatter-band";
+	return FatigueFit;
+}({});
+var REGIMES = [
+	{
+		key: "Low cycle",
+		from: 0,
+		to: 1e4
+	},
+	{
+		key: "High cycle",
+		from: 1e4,
+		to: 1e7
+	},
+	{
+		key: "Very high",
+		from: 1e7,
+		to: Infinity
+	}
+];
+function sampleTests(seed) {
+	const levels = [
+		1,
+		.85,
+		.72,
+		.6,
+		.5,
+		.42,
+		.36,
+		.3
+	];
+	return SampleData.points(seed, 48, 2).map((row, i) => {
+		const steel = i % 2 === 0, top = steel ? 720 : 420, strength = steel ? 1200 : 780, slope = steel ? -.1 : -.12;
+		const stress = top * levels[(i >> 1) % 8];
+		const life = (stress / strength) ** (1 / slope) * 10 ** ((+row.y - +row.x * .8 - 10) / 9 * .22);
+		return {
+			material: steel ? "Steel 4340" : "Al 7075",
+			stress: +stress.toFixed(0),
+			cycles: Math.round(Math.min(life, 1e7)),
+			runout: life >= 1e7 ? 1 : 0
+		};
+	});
+}
+/** Predict fatigue life: fits a Basquin line through test specimens, with optional endurance limit. */
+var FatigueSNCurve = class extends EngineeringChart {
+	static meta = {
+		id: "fatigue-sn-curve",
+		name: "Fatigue S-N curve",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Fits stress against cycles to failure on log axes, with scatter bands, runouts and endurance limit.",
+		tags: [
+			"wohler",
+			"fatigue",
+			"basquin",
+			"endurance limit",
+			"materials",
+			"reliability"
+		],
+		sample: sampleTests,
+		variants: {
+			stressScale: [ScaleKind.Log, ScaleKind.Linear],
+			fit: [
+				"scatter-band",
+				"mean-curve",
+				"test-points"
+			],
+			endurance: [true, false],
+			runoutArrows: [true, false],
+			regimes: [true, false]
+		},
+		valid: (v) => !(v.fit === "test-points" && v.endurance)
+	};
+	defaults() {
+		return {
+			cycles: "cycles",
+			stress: "stress",
+			material: "material",
+			runout: "runout",
+			stressScale: ScaleKind.Log,
+			fit: "scatter-band",
+			endurance: true,
+			kneeCycles: 1e6,
+			runoutArrows: true,
+			regimes: true,
+			xLabel: "Cycles to failure",
+			yLabel: "Stress amplitude (MPa)"
+		};
+	}
+	fits() {
+		const { cycles, stress, material, runout } = this.options;
+		return this.series(material).map(([name, rows]) => {
+			const specimens = rows.map((row) => ({
+				material: name,
+				cycles: this.num(row, cycles),
+				stress: this.num(row, stress),
+				runout: !!row[runout]
+			})).filter((s) => s.cycles > 0 && s.stress > 0);
+			const broken = specimens.filter((s) => !s.runout);
+			const xs = broken.map((s) => Math.log10(s.cycles)), ys = broken.map((s) => Math.log10(s.stress));
+			const mx = xs.reduce((a, b) => a + b, 0) / (xs.length || 1), my = ys.reduce((a, b) => a + b, 0) / (ys.length || 1);
+			const spread = xs.reduce((sum, x) => sum + (x - mx) ** 2, 0);
+			const slope = spread ? xs.reduce((sum, x, i) => sum + (x - mx) * (ys[i] - my), 0) / spread : 0;
+			const intercept = my - slope * mx;
+			return {
+				material: name,
+				intercept,
+				slope,
+				scatter: Math.sqrt(ys.reduce((sum, y, i) => sum + (y - intercept - slope * xs[i]) ** 2, 0) / Math.max(1, ys.length - 2)),
+				specimens
+			};
+		}).filter((fit) => fit.specimens.length);
+	}
+	draw(ctx) {
+		const { stressScale, fit, endurance, kneeCycles, runoutArrows, regimes, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const fits = this.fits();
+		const all = fits.flatMap((f) => f.specimens);
+		const [low, high] = this.span(all.map((s) => s.cycles), { log: true });
+		const x = Scales.continuous(ScaleKind.Log).domain([low / 2, high * 4]).range([0, width]);
+		const logStress = stressScale === ScaleKind.Log;
+		const limits = fit !== "test-points" && endurance ? fits.map((f) => 10 ** (f.intercept + f.slope * Math.log10(kneeCycles))) : [];
+		const y = Scales.continuous(stressScale).domain(this.span([...all.map((s) => s.stress), ...limits], logStress ? {
+			log: true,
+			pad: .04
+		} : {
+			zero: true,
+			pad: .04
+		})).range([height, 0]);
+		this.frame(ctx, {
+			x,
+			y,
+			xTitle: xLabel,
+			yTitle: yLabel
+		});
+		const at = (n, s) => [x(n), y(s)];
+		const [xLeft, xRight] = x.domain();
+		if (regimes) {
+			const bands = REGIMES.map((r) => ({
+				...r,
+				a: Math.max(r.from, xLeft),
+				b: Math.min(r.to, xRight)
+			})).filter((r) => r.b > r.a);
+			this.shapes(ctx, "regimes", bands.filter((_, i) => i % 2 === 0).map((r) => ({
+				key: r.key,
+				fill: ctx.theme.grid,
+				opacity: .45,
+				d: `M${x(r.a)},0H${x(r.b)}V${height}H${x(r.a)}Z`
+			})));
+			this.annotate(ctx, "regime-notes", bands.map((r) => ({
+				key: r.key,
+				text: r.key,
+				x: (x(r.a) + x(r.b)) / 2,
+				y: height - 6,
+				anchor: "middle",
+				tone: "muted",
+				size: 10
+			})));
+		}
+		if (fit !== "test-points") {
+			const sweep = Array.from({ length: 60 }, (_, i) => xLeft * (xRight / xLeft) ** (i / 59));
+			const curve = (f, shift) => sweep.map((n) => {
+				const life = endurance ? Math.min(n, kneeCycles) : n;
+				return this.within([at(n, 10 ** (f.intercept + f.slope * Math.log10(life) + shift))], width, height)[0];
+			});
+			if (fit === "scatter-band") this.shapes(ctx, "bands", fits.map((f) => {
+				const rim = [...curve(f, 2 * f.scatter), ...curve(f, -2 * f.scatter).reverse()].filter((p) => Number.isFinite(p[0]));
+				return {
+					key: f.material,
+					fill: ctx.palette.color(f.material),
+					opacity: .14,
+					d: rim.length ? `M${rim.join("L")}Z` : ""
+				};
+			}));
+			this.traces(ctx, "fits", fits.map((f) => ({
+				key: f.material,
+				color: ctx.palette.color(f.material),
+				points: curve(f, 0)
+			})));
+			const tipFit = fits.map((f) => ({
+				f,
+				at: curve(f, 0)[30]
+			}));
+			this.probes(ctx, "fit-probes", tipFit, (d) => d.at, (d) => ({
+				title: `${d.f.material} fit`,
+				color: ctx.palette.color(d.f.material),
+				rows: [["Basquin exponent", d.f.slope.toFixed(3)], ["Fatigue strength coefficient", (10 ** d.f.intercept).toFixed(0)]]
+			}));
+			if (endurance) this.annotate(ctx, "endurance-notes", fits.map((f) => {
+				const limit = 10 ** (f.intercept + f.slope * Math.log10(kneeCycles));
+				return {
+					key: f.material,
+					text: `Se ${limit.toFixed(0)}`,
+					x: width - 2,
+					y: y(limit) - 6,
+					anchor: "end",
+					tone: "ink",
+					size: 10
+				};
+			}));
+		}
+		const tip = (s) => ({
+			title: s.material,
+			color: ctx.palette.color(s.material),
+			rows: [
+				["Stress", `${s.stress} MPa`],
+				["Cycles", s.cycles.toLocaleString("en")],
+				["Result", s.runout ? "Runout" : "Failed"]
+			]
+		});
+		const arrows = runoutArrows ? all.filter((s) => s.runout) : [];
+		this.dots(ctx, "specimens", arrows.length ? all.filter((s) => !s.runout) : all, (s) => at(s.cycles, s.stress), (s) => ctx.palette.color(s.material), tip, 3.5);
+		const marks = ctx.marks("runouts", "path", arrows).attr("fill", "none").attr("stroke", (s) => ctx.palette.color(s.material)).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+		const glyph = (s) => {
+			const [px, py] = at(s.cycles, s.stress);
+			return `M${px - 3},${py}H${px + 9}M${px + 5},${py - 4}L${px + 9},${py}L${px + 5},${py + 4}`;
+		};
+		ctx.set(marks, { d: glyph }, { d: glyph });
+		ctx.hover(marks, tip);
+	}
+};
+export { FatigueFit, FatigueSNCurve };

package/dist/charts/engineering/FrequencyResponseChart.js

@@ -0,0 +1,46 @@
+import { EngineeringChart } from "./EngineeringChart.js";
+// src/charts/engineering/FrequencyResponseChart.ts
+/** Bode, Nyquist and Nichols all read the same frequency-response table. */
+var FrequencyResponseChart = class extends EngineeringChart {
+	defaults() {
+		return {
+			frequency: "frequency",
+			magnitude: "magnitude",
+			phase: "phase",
+			system: "system"
+		};
+	}
+	responses() {
+		const { frequency, magnitude, phase, system } = this.options;
+		return this.series(system).map(([name, rows]) => ({
+			system: name,
+			points: rows.map((row) => ({
+				frequency: this.num(row, frequency),
+				magnitude: this.num(row, magnitude),
+				phase: this.num(row, phase),
+				system: name
+			})).filter((point) => point.frequency > 0 && Number.isFinite(point.magnitude) && Number.isFinite(point.phase)).sort((a, b) => a.frequency - b.frequency)
+		})).filter((loop) => loop.points.length);
+	}
+	/** Where the loop crosses 0 dB and -180 degrees, interpolated on log frequency. */
+	margins({ points }) {
+		return {
+			gainCross: this.crossing(points, (p) => p.magnitude),
+			phaseCross: this.crossing(points, (p) => p.phase + 180)
+		};
+	}
+	crossing(points, level) {
+		for (let i = 1; i < points.length; i++) {
+			const a = points[i - 1], b = points[i], u = level(a), v = level(b);
+			if (u < 0 || v >= 0 || u === v) continue;
+			const t = u / (u - v), mix = (from, to) => from + (to - from) * t;
+			return {
+				system: a.system,
+				frequency: Math.exp(mix(Math.log(a.frequency), Math.log(b.frequency))),
+				magnitude: mix(a.magnitude, b.magnitude),
+				phase: mix(a.phase, b.phase)
+			};
+		}
+	}
+};
+export { FrequencyResponseChart };