@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/engineering/SteamModel.js

@@ -0,0 +1,154 @@
+// src/charts/engineering/SteamModel.ts
+var TABLE = [
+	[
+		10,
+		.01228,
+		42,
+		2519,
+		.151,
+		8.9
+	],
+	[
+		25,
+		.0317,
+		104.8,
+		2546.5,
+		.367,
+		8.557
+	],
+	[
+		50,
+		.1235,
+		209.3,
+		2591.3,
+		.704,
+		8.075
+	],
+	[
+		100,
+		1.014,
+		419.2,
+		2675.6,
+		1.307,
+		7.354
+	],
+	[
+		150,
+		4.762,
+		632.2,
+		2745.9,
+		1.842,
+		6.837
+	],
+	[
+		200,
+		15.55,
+		852.3,
+		2792,
+		2.33,
+		6.43
+	],
+	[
+		250,
+		39.76,
+		1085.7,
+		2800.9,
+		2.794,
+		6.07
+	],
+	[
+		300,
+		85.88,
+		1345,
+		2749.6,
+		3.255,
+		5.706
+	],
+	[
+		320,
+		112.8,
+		1462.6,
+		2700.6,
+		3.449,
+		5.537
+	],
+	[
+		340,
+		146,
+		1594.5,
+		2621.8,
+		3.66,
+		5.336
+	],
+	[
+		360,
+		186.7,
+		1761.7,
+		2481.5,
+		3.917,
+		5.054
+	],
+	[
+		370,
+		210.4,
+		1890.7,
+		2334.5,
+		4.111,
+		4.801
+	],
+	[
+		374.14,
+		220.9,
+		2099.3,
+		2099.3,
+		4.43,
+		4.43
+	]
+];
+var CP = 2.2;
+var lerp = (a, b, t) => a + (b - a) * t;
+/** Compact steam properties for chart backdrops: table lookup in the dome, constant-cp vapour above it. */
+var SteamModel = class SteamModel {
+	static critical = TABLE[TABLE.length - 1];
+	static temperatures = TABLE.map((row) => row[0]);
+	static row(temperature) {
+		const t = Math.max(TABLE[0][0], Math.min(374.14, temperature));
+		const i = Math.max(1, TABLE.findIndex((row) => row[0] >= t));
+		const a = TABLE[i - 1], b = TABLE[i], u = (t - a[0]) / (b[0] - a[0]);
+		return {
+			t,
+			p: Math.exp(lerp(Math.log(a[1]), Math.log(b[1]), u)),
+			hf: lerp(a[2], b[2], u),
+			hg: lerp(a[3], b[3], u),
+			sf: lerp(a[4], b[4], u),
+			sg: lerp(a[5], b[5], u)
+		};
+	}
+	static saturationTemperature(pressure) {
+		const p = Math.max(TABLE[0][1], Math.min(220.9, pressure));
+		const i = Math.max(1, TABLE.findIndex((row) => row[1] >= p));
+		const a = TABLE[i - 1], b = TABLE[i];
+		return lerp(a[0], b[0], (Math.log(p) - Math.log(a[1])) / (Math.log(b[1]) - Math.log(a[1])));
+	}
+	/** Wet state at quality `x`, from 0 (saturated liquid) to 1 (saturated vapour). */
+	static wet(temperature, x) {
+		const { t, p, hf, hg, sf, sg } = SteamModel.row(temperature);
+		return {
+			entropy: lerp(sf, sg, x),
+			enthalpy: lerp(hf, hg, x),
+			temperature: t,
+			pressure: p
+		};
+	}
+	static superheated(pressure, temperature) {
+		const tsat = SteamModel.saturationTemperature(pressure);
+		const { hg, sg } = SteamModel.row(tsat);
+		return {
+			entropy: sg + CP * Math.log((temperature + 273.15) / (tsat + 273.15)),
+			enthalpy: hg + CP * (temperature - tsat),
+			temperature,
+			pressure
+		};
+	}
+};
+export { SteamModel };

package/dist/charts/engineering/StepResponseChart.js

@@ -0,0 +1,201 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart } from "./EngineeringChart.js";
+import { curveStepAfter, scaleLinear } from "d3";
+// src/charts/engineering/StepResponseChart.ts
+var StepHold = /* @__PURE__ */ function(StepHold) {
+	StepHold["Continuous"] = "continuous";
+	StepHold["ZeroOrderHold"] = "zero-order-hold";
+	return StepHold;
+}({});
+function sampleSteps(seed) {
+	const rows = SampleData.points(seed, 4, 2).map((row) => (+row.size - 3) / 30);
+	return [[
+		.22 + .12 * rows[0],
+		1.8 + rows[1],
+		"Underdamped"
+	], [
+		.55 + .2 * rows[2],
+		1.6 + rows[3],
+		"Tuned"
+	]].flatMap(([zeta, wn, system]) => {
+		const z = zeta, w = wn, wd = w * Math.sqrt(1 - z * z);
+		return Array.from({ length: 161 }, (_, i) => {
+			const time = i * .05;
+			return {
+				system,
+				time,
+				value: +(1 - Math.exp(-z * w * time) * (Math.cos(wd * time) + z / Math.sqrt(1 - z * z) * Math.sin(wd * time))).toFixed(4)
+			};
+		});
+	});
+}
+/** Tune a controller in the time domain: rise time, overshoot and settling of a step response. */
+var StepResponseChart = class extends EngineeringChart {
+	static meta = {
+		id: "step-response-chart",
+		name: "Step response",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows how a system follows a step command, with rise time, overshoot and settling band.",
+		tags: [
+			"control",
+			"pid",
+			"overshoot",
+			"settling time",
+			"transient"
+		],
+		sample: sampleSteps,
+		variants: {
+			hold: ["continuous", "zero-order-hold"],
+			band: [
+				2,
+				5,
+				0
+			],
+			metrics: [true, false],
+			input: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			time: "time",
+			value: "value",
+			system: "system",
+			hold: "continuous",
+			band: 2,
+			metrics: true,
+			input: true,
+			holdEvery: 6,
+			xLabel: "Time (s)",
+			yLabel: "Output"
+		};
+	}
+	responses() {
+		const { time, value, system, band } = this.options;
+		return this.series(system).flatMap(([name, rows]) => {
+			const points = rows.map((row) => [this.num(row, time), this.num(row, value)]).filter((p) => p.every(Number.isFinite)).sort((a, b) => a[0] - b[0]);
+			if (!points.length) return [];
+			const start = points[0][1], final = points[points.length - 1][1], swing = final - start;
+			const level = (share) => points.find((p) => (p[1] - start) / (swing || 1) >= share)?.[0];
+			const low = level(.1), high = level(.9);
+			const tolerance = Math.abs(swing) * ((band || 2) / 100);
+			const outside = points.findLastIndex((p) => Math.abs(p[1] - final) > tolerance);
+			return [{
+				system: name,
+				points,
+				final,
+				start,
+				rise: low !== void 0 && high !== void 0 ? [low, high] : void 0,
+				peak: points.reduce((best, p) => p[1] > best[1] ? p : best),
+				settle: outside >= 0 ? points[Math.min(points.length - 1, outside + 1)][0] : points[0][0]
+			}];
+		});
+	}
+	draw(ctx) {
+		const { hold, band, metrics, input, holdEvery, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const responses = this.responses();
+		const lead = responses[0];
+		const x = scaleLinear(this.span(responses.flatMap((r) => r.points.map((p) => p[0]))), [0, width]);
+		const y = scaleLinear(this.span(responses.flatMap((r) => [...r.points.map((p) => p[1]), r.final]), {
+			pad: .08,
+			zero: true
+		}), [height, 0]).nice();
+		this.frame(ctx, {
+			x,
+			y,
+			xTitle: xLabel,
+			yTitle: yLabel
+		});
+		const at = (p) => [x(p[0]), y(p[1])];
+		if (band && lead) {
+			const margin = Math.abs(lead.final - lead.start) * (band / 100);
+			this.shapes(ctx, "settling-band", [{
+				key: "b",
+				fill: ctx.palette.color(lead.system),
+				opacity: .12,
+				d: `M0,${y(lead.final + margin)}H${width}V${y(lead.final - margin)}H0Z`
+			}]);
+			this.annotate(ctx, "band-note", [{
+				key: "b",
+				text: `±${band}%`,
+				x: width - 4,
+				y: y(lead.final + margin) - 5,
+				anchor: "end",
+				tone: "muted",
+				size: 10
+			}]);
+		}
+		if (input && lead) this.traces(ctx, "command", [{
+			key: "u",
+			color: ctx.theme.inkMuted,
+			width: 1.5,
+			dash: "5 4",
+			points: [
+				[0, y(lead.start)],
+				[x(lead.points[0][0]), y(lead.final)],
+				[width, y(lead.final)]
+			]
+		}]);
+		const held = hold === "zero-order-hold";
+		const shown = (r) => held ? r.points.filter((_, i) => i % holdEvery === 0) : r.points;
+		this.traces(ctx, "curves", responses.map((r) => ({
+			key: r.system,
+			color: ctx.palette.color(r.system),
+			curve: held ? curveStepAfter : void 0,
+			points: shown(r).map(at)
+		})));
+		const tip = (name) => (p) => ({
+			title: name,
+			color: ctx.palette.color(name),
+			rows: [["Time", p[0].toFixed(2)], ["Output", p[1].toFixed(3)]]
+		});
+		responses.forEach((r, i) => this.probes(ctx, `probe-${i}`, shown(r), at, tip(r.system)));
+		if (metrics && lead) {
+			const overshoot = (lead.peak[1] - lead.final) / (Math.abs(lead.final - lead.start) || 1) * 100;
+			if (lead.rise) {
+				const lane = y(lead.start + (lead.final - lead.start) * .5);
+				this.traces(ctx, "rise-span", [{
+					key: "r",
+					color: ctx.theme.ink,
+					width: 2,
+					points: [[x(lead.rise[0]), lane], [x(lead.rise[1]), lane]]
+				}]);
+				this.annotate(ctx, "rise-note", [{
+					key: "r",
+					text: `Rise ${(lead.rise[1] - lead.rise[0]).toFixed(2)} s`,
+					x: x(lead.rise[1]) + 8,
+					y: lane + 4,
+					tone: "ink",
+					size: 10
+				}]);
+			}
+			if (lead.settle !== void 0) this.traces(ctx, "settle-drop", [{
+				key: "s",
+				color: ctx.theme.inkMuted,
+				width: 1,
+				dash: "2 3",
+				points: [[x(lead.settle), y(lead.final)], [x(lead.settle), height]]
+			}]);
+			this.dots(ctx, "peak", overshoot > .5 ? [lead.peak] : [], at, () => ctx.theme.ink, tip(lead.system), 4);
+			this.annotate(ctx, "metric-notes", [...overshoot > .5 ? [{
+				key: "o",
+				text: `Overshoot ${overshoot.toFixed(0)}%`,
+				x: at(lead.peak)[0] + 8,
+				y: at(lead.peak)[1] - 4,
+				tone: "ink",
+				size: 10
+			}] : [], ...lead.settle !== void 0 ? [{
+				key: "s",
+				text: `Settles ${lead.settle.toFixed(1)} s`,
+				x: x(lead.settle) + 5,
+				y: height - 6,
+				tone: "ink",
+				size: 10
+			}] : []]);
+		}
+	}
+};
+export { StepHold, StepResponseChart };

package/dist/charts/engineering/StressStrainChart.js

@@ -0,0 +1,243 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart } from "./EngineeringChart.js";
+import { scaleLinear } from "d3";
+// src/charts/engineering/StressStrainChart.ts
+var StressMeasure = /* @__PURE__ */ function(StressMeasure) {
+	StressMeasure["Engineering"] = "engineering";
+	StressMeasure["True"] = "true-stress";
+	StressMeasure["Both"] = "true-and-engineering";
+	return StressMeasure;
+}({});
+var StressEnergy = /* @__PURE__ */ function(StressEnergy) {
+	StressEnergy["None"] = "no-energy";
+	StressEnergy["Resilience"] = "resilience";
+	StressEnergy["Toughness"] = "toughness";
+	return StressEnergy;
+}({});
+var StressRange = /* @__PURE__ */ function(StressRange) {
+	StressRange["Full"] = "full-range";
+	StressRange["Elastic"] = "elastic-zoom";
+	return StressRange;
+}({});
+var MATERIALS = [
+	[
+		"Alloy steel",
+		205e3,
+		620,
+		800,
+		.11,
+		.17
+	],
+	[
+		"Mild steel",
+		2e5,
+		300,
+		440,
+		.2,
+		.32
+	],
+	[
+		"Al 6061-T6",
+		69e3,
+		275,
+		315,
+		.09,
+		.15
+	]
+];
+function sampleTensile(seed) {
+	const trims = SampleData.categories(seed, 3, 1).map((row) => .96 + (+row.value - 20) / 1e3);
+	return MATERIALS.flatMap(([material, modulus, yieldStress, ultimate, uniform, fracture], m) => {
+		const trim = trims[m], yieldStrain = yieldStress * trim / modulus;
+		return Array.from({ length: 180 }, (_, i) => {
+			const strain = fracture * (i / 179) ** 2.6;
+			const hardened = yieldStress + (ultimate - yieldStress) * (1 - Math.exp(-(Math.max(0, strain - yieldStrain) * 4) / uniform));
+			const stress = strain < yieldStrain ? modulus * strain : strain < uniform ? hardened * trim : hardened * trim * (1 - .32 * ((strain - uniform) / (fracture - uniform)) ** 2);
+			return {
+				material,
+				strain: +strain.toFixed(6),
+				stress: +stress.toFixed(1)
+			};
+		});
+	});
+}
+/** Compare tensile tests: stiffness, yield, strength, ductility and energy absorbed. */
+var StressStrainChart = class extends EngineeringChart {
+	static meta = {
+		id: "stress-strain-chart",
+		name: "Stress-strain chart",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots tensile test curves with offset yield, ultimate strength, fracture and absorbed energy.",
+		tags: [
+			"tensile test",
+			"materials",
+			"yield",
+			"modulus",
+			"toughness"
+		],
+		sample: sampleTensile,
+		variants: {
+			measure: [
+				"engineering",
+				"true-stress",
+				"true-and-engineering"
+			],
+			energy: [
+				"no-energy",
+				"resilience",
+				"toughness"
+			],
+			range: ["full-range", "elastic-zoom"],
+			landmarks: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			strain: "strain",
+			stress: "stress",
+			material: "material",
+			measure: "engineering",
+			energy: "no-energy",
+			range: "full-range",
+			landmarks: true,
+			offset: .002,
+			xLabel: "Strain",
+			yLabel: "Stress (MPa)"
+		};
+	}
+	tests() {
+		const { strain, stress, material, offset } = this.options;
+		return this.series(material).flatMap(([name, rows]) => {
+			const readings = rows.map((row) => ({
+				strain: this.num(row, strain),
+				stress: this.num(row, stress)
+			})).filter((r) => Number.isFinite(r.strain) && Number.isFinite(r.stress)).sort((a, b) => a.strain - b.strain);
+			if (readings.length < 2) return [];
+			const early = readings.filter((r) => r.strain > 0).slice(0, 3);
+			const modulus = early.length ? Math.max(...early.map((r) => r.stress / r.strain)) : 0;
+			const line = (r) => r.stress - modulus * (r.strain - offset);
+			const crossing = readings.findIndex((r, i) => i > 0 && line(readings[i - 1]) > 0 && line(r) <= 0);
+			const ultimateIndex = readings.reduce((best, r, i) => r.stress > readings[best].stress ? i : best, 0);
+			return [{
+				name,
+				readings,
+				modulus,
+				yieldPoint: crossing > 0 ? readings[crossing] : null,
+				ultimate: readings[ultimateIndex],
+				ultimateIndex,
+				fracture: readings[readings.length - 1]
+			}];
+		});
+	}
+	draw(ctx) {
+		const { measure, energy, range, landmarks, offset, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const tests = this.tests();
+		const zoom = range === "elastic-zoom";
+		const lead = tests[0];
+		const convert = (r) => ({
+			strain: Math.log1p(r.strain),
+			stress: r.stress * (1 + r.strain)
+		});
+		const valid = (t) => t.readings.slice(0, t.ultimateIndex + 1).map(convert);
+		const primary = (t) => measure === "engineering" ? t.readings : valid(t);
+		const peakStrain = Math.max(.01, ...tests.flatMap((t) => t.yieldPoint ? [t.yieldPoint.strain] : []));
+		const everything = tests.flatMap((t) => [...t.readings, ...primary(t)]);
+		const x = scaleLinear(zoom ? [0, peakStrain * 2] : [0, this.span(everything.map((r) => r.strain), { pad: .02 })[1]], [0, width]);
+		const yTop = zoom ? Math.max(...tests.flatMap((t) => t.yieldPoint ? [t.yieldPoint.stress] : [t.ultimate.stress])) * 1.25 : this.span(everything.map((r) => r.stress), { pad: .04 })[1];
+		const y = scaleLinear([0, yTop], [height, 0]).nice();
+		const percent = (value) => `${+(value * 100).toFixed(2)}%`;
+		this.frame(ctx, {
+			x,
+			y,
+			xFormat: percent,
+			xTitle: xLabel,
+			yTitle: yLabel
+		});
+		const at = (r) => this.within([[x(r.strain), y(r.stress)]], width, height)[0];
+		if (energy !== "no-energy" && lead) {
+			const limit = energy === "resilience" ? lead.yieldPoint?.strain ?? lead.ultimate.strain : Infinity;
+			const under = lead.readings.filter((r) => r.strain <= limit).map(at).filter((p) => Number.isFinite(p[0]));
+			if (under.length) {
+				const joules = lead.readings.filter((r) => r.strain <= limit).reduce((sum, r, i, list) => i ? sum + (r.stress + list[i - 1].stress) / 2 * (r.strain - list[i - 1].strain) : 0, 0);
+				const last = under[under.length - 1];
+				this.shapes(ctx, "energy", [{
+					key: "energy",
+					fill: ctx.palette.color(lead.name),
+					opacity: .16,
+					d: `M${under.join("L")}V${height}H${under[0][0]}Z`
+				}]);
+				this.annotate(ctx, "energy-note", [{
+					key: "e",
+					text: `${energy === "resilience" ? "Resilience" : "Toughness"} ${joules.toFixed(joules < 10 ? 2 : 0)} MJ/m³`,
+					x: Math.min(width - 4, last[0] / 2 + 4),
+					y: height - 10,
+					anchor: "middle",
+					tone: "ink"
+				}]);
+			}
+		}
+		if (measure === "true-and-engineering") this.traces(ctx, "engineering-curves", tests.map((t) => ({
+			key: t.name,
+			color: ctx.palette.color(t.name),
+			width: 1.5,
+			dash: "5 4",
+			points: t.readings.map(at)
+		})));
+		this.traces(ctx, "curves", tests.map((t) => ({
+			key: t.name,
+			color: ctx.palette.color(t.name),
+			points: primary(t).map(at)
+		})));
+		const tip = (name, label) => (r) => ({
+			title: label ? `${name}: ${label}` : name,
+			color: ctx.palette.color(name),
+			rows: [["Strain", r.strain.toFixed(4)], ["Stress", `${r.stress.toFixed(0)} MPa`]]
+		});
+		tests.forEach((t, i) => this.probes(ctx, `probe-${i}`, primary(t), at, tip(t.name, "")));
+		if (landmarks) {
+			const offsetLine = lead?.yieldPoint ? [at({
+				strain: offset,
+				stress: 0
+			}), at(lead.yieldPoint)] : [];
+			this.traces(ctx, "offset-line", offsetLine.length ? [{
+				key: "o",
+				color: ctx.theme.inkMuted,
+				width: 1,
+				dash: "3 3",
+				points: offsetLine
+			}] : []);
+			const points = tests.flatMap((t) => [
+				...t.yieldPoint ? [{
+					t,
+					label: "Yield",
+					r: t.yieldPoint
+				}] : [],
+				{
+					t,
+					label: "Ultimate",
+					r: t.ultimate
+				},
+				{
+					t,
+					label: "Fracture",
+					r: t.fracture
+				}
+			]);
+			const placed = (d) => at(measure === "true-stress" && d.label !== "Fracture" ? convert(d.r) : d.r);
+			this.dots(ctx, "landmarks", points.filter((d) => !(measure === "true-stress" && d.label === "Fracture")), placed, (d) => ctx.palette.color(d.t.name), (d) => tip(d.t.name, d.label)(d.r), 4);
+			this.annotate(ctx, "landmark-notes", points.filter((d) => d.t === lead).filter((d) => Number.isFinite(placed(d)[0]) && !(measure === "true-stress" && d.label === "Fracture")).map((d) => ({
+				key: d.label,
+				text: `${d.label} ${d.r.stress.toFixed(0)}`,
+				x: placed(d)[0] + 7,
+				y: placed(d)[1] - 7,
+				tone: "ink",
+				size: 10
+			})));
+		}
+	}
+};
+export { StressEnergy, StressMeasure, StressRange, StressStrainChart };