@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/engineering/LoadLineChart.js

@@ -0,0 +1,247 @@
+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/LoadLineChart.ts
+var LoadLineSet = /* @__PURE__ */ function(LoadLineSet) {
+	LoadLineSet["Dc"] = "dc-load";
+	LoadLineSet["DcAc"] = "dc-ac-load";
+	return LoadLineSet;
+}({});
+function sampleCurves(seed) {
+	const trims = SampleData.categories(seed, 5, 1).map((row) => .92 + (+row.value - 20) / 500);
+	return [
+		2.5,
+		3,
+		3.5,
+		4,
+		4.5
+	].flatMap((vgs, c) => Array.from({ length: 61 }, (_, i) => {
+		const voltage = i * .25, drive = vgs - 2, saturated = voltage >= drive;
+		return {
+			voltage,
+			current: +(12 * trims[c] * (saturated ? drive * drive : 2 * drive * voltage - voltage * voltage) * (1 + .012 * voltage)).toFixed(2),
+			curve: `${vgs} V`
+		};
+	}));
+}
+/** Pick an amplifier bias: a load line laid over device curves, solving the operating point. */
+var LoadLineChart = class extends EngineeringChart {
+	static meta = {
+		id: "load-line-chart",
+		name: "Load line chart",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Overlays a load line on device output curves to find the quiescent point and signal swing.",
+		tags: [
+			"transistor",
+			"amplifier",
+			"bias",
+			"q-point",
+			"electronics"
+		],
+		sample: sampleCurves,
+		variants: {
+			lines: ["dc-load", "dc-ac-load"],
+			power: [true, false],
+			swing: [true, false],
+			ohmic: [true, false],
+			operatingPoints: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			voltage: "voltage",
+			current: "current",
+			curve: "curve",
+			lines: "dc-load",
+			acShare: .5,
+			power: true,
+			swing: true,
+			ohmic: true,
+			operatingPoints: false,
+			xLabel: "Voltage (V)",
+			yLabel: "Current (mA)"
+		};
+	}
+	families() {
+		return this.series(this.options.curve).map(([name, rows]) => ({
+			name,
+			points: rows.map((row) => ({
+				voltage: this.num(row, this.options.voltage),
+				current: this.num(row, this.options.current),
+				name
+			})).filter((p) => Number.isFinite(p.voltage) && Number.isFinite(p.current)).sort((a, b) => a.voltage - b.voltage)
+		})).filter((family) => family.points.length > 1);
+	}
+	meet(family, load) {
+		for (let i = 1; i < family.points.length; i++) {
+			const a = family.points[i - 1], b = family.points[i];
+			const u = a.current - load(a.voltage), v = b.current - load(b.voltage);
+			if (u * v > 0 || u === v) continue;
+			const t = u / (u - v);
+			return {
+				curve: family.name,
+				voltage: a.voltage + (b.voltage - a.voltage) * t,
+				current: a.current + (b.current - a.current) * t
+			};
+		}
+		return null;
+	}
+	/** The knee is where a curve's slope has fallen to a sixth of its start. */
+	knee({ points }) {
+		const first = (points[1].current - points[0].current) / (points[1].voltage - points[0].voltage);
+		const hit = points.find((p, i) => i > 0 && (p.current - points[i - 1].current) / (p.voltage - points[i - 1].voltage) < first / 6);
+		return hit ? [hit.voltage, hit.current] : null;
+	}
+	draw(ctx) {
+		const { lines, acShare, power, swing, ohmic, operatingPoints, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const families = this.families();
+		const voltages = families.flatMap((f) => f.points.map((p) => p.voltage)), currents = families.flatMap((f) => f.points.map((p) => p.current));
+		const [, supplyAuto] = this.span(voltages);
+		const [, peak] = this.span(currents, { zero: true });
+		const supply = this.options.supply ?? supplyAuto;
+		const short = this.options.resistance ? supply / this.options.resistance : peak * .75;
+		const load = (voltage) => short * (1 - voltage / supply);
+		const limit = this.options.powerLimit ?? supply * peak * .2;
+		const x = scaleLinear([0, supplyAuto], [0, width]);
+		const y = scaleLinear([0, peak * 1.06], [height, 0]).nice();
+		this.frame(ctx, {
+			x,
+			y,
+			xTitle: xLabel,
+			yTitle: yLabel
+		});
+		const at = (p) => [x(p[0]), y(p[1])];
+		if (ohmic && families.length) {
+			const knees = families.map((f) => this.knee(f)).filter((p) => p !== null).sort((a, b) => a[1] - b[1]);
+			if (knees.length) {
+				const edge = [[0, 0], ...knees].map(at);
+				const last = edge[edge.length - 1];
+				this.shapes(ctx, "ohmic", [{
+					key: "ohmic",
+					fill: ctx.theme.grid,
+					opacity: .5,
+					d: `M${edge.join("L")}L${last[0]},0H0V${height}Z`
+				}]);
+				this.annotate(ctx, "ohmic-note", [{
+					key: "o",
+					text: "Ohmic",
+					x: 4,
+					y: 14,
+					tone: "muted",
+					size: 10
+				}]);
+			}
+		}
+		if (power) {
+			const curve = Array.from({ length: 120 }, (_, i) => {
+				const voltage = supplyAuto * ((i + 2) / 121);
+				return at([voltage, limit / voltage]);
+			});
+			this.traces(ctx, "power-limit", [{
+				key: "p",
+				color: ctx.theme.serious,
+				width: 1.5,
+				dash: "6 4",
+				points: this.within(curve, width, height)
+			}]);
+			this.annotate(ctx, "power-note", [{
+				key: "p",
+				text: `${limit.toPrecision(3)} mW limit`,
+				x: width - 2,
+				y: y(limit / supplyAuto) - 6,
+				anchor: "end",
+				tone: "muted",
+				size: 10
+			}]);
+		}
+		this.traces(ctx, "curves", families.map((f) => ({
+			key: f.name,
+			color: ctx.palette.color(f.name),
+			points: f.points.map((p) => this.within([at([p.voltage, p.current])], width, height)[0])
+		})));
+		families.forEach((f, i) => this.probes(ctx, `probe-${i}`, f.points, (p) => at([p.voltage, p.current]), (p) => ({
+			title: p.name,
+			color: ctx.palette.color(p.name),
+			rows: [
+				["Voltage", p.voltage.toFixed(2)],
+				["Current", p.current.toFixed(2)],
+				["Power", (p.voltage * p.current).toFixed(1)]
+			]
+		})));
+		this.traces(ctx, "dc-load", [{
+			key: "dc",
+			color: ctx.theme.ink,
+			points: this.within(Array.from({ length: 2 }, (_, i) => at([i * supply, load(i * supply)])), width, height)
+		}]);
+		const meets = families.map((f) => this.meet(f, load)).filter((p) => p !== null);
+		const bias = meets[Math.floor(meets.length / 2)];
+		if (bias && lines === "dc-ac-load") {
+			const slope = short / supply / acShare;
+			const ends = [[Math.max(0, bias.voltage - (y.domain()[1] - bias.current) / slope), 0], [bias.voltage + bias.current / slope, 0]];
+			ends[0][1] = bias.current + (bias.voltage - ends[0][0]) * slope;
+			this.traces(ctx, "ac-load", [{
+				key: "ac",
+				color: ctx.theme.ink,
+				dash: "6 4",
+				points: ends.map(at)
+			}]);
+		}
+		if (bias && swing && meets.length > 1) {
+			const first = meets[0], last = meets[meets.length - 1];
+			const low = Math.min(first.voltage, last.voltage), high = Math.max(first.voltage, last.voltage);
+			const projection = [
+				at([first.voltage, first.current]),
+				[x(first.voltage), height],
+				[NaN, 0],
+				at([last.voltage, last.current]),
+				[x(last.voltage), height]
+			];
+			this.traces(ctx, "swing-drops", [{
+				key: "s",
+				color: ctx.theme.inkMuted,
+				width: 1,
+				dash: "2 3",
+				points: projection
+			}]);
+			this.traces(ctx, "swing-span", [{
+				key: "v",
+				color: ctx.theme.ink,
+				width: 3,
+				points: [[x(low), height - 2], [x(high), height - 2]]
+			}]);
+			this.annotate(ctx, "swing-note", [{
+				key: "v",
+				text: `Swing ${(high - low).toFixed(1)} V`,
+				x: (x(low) + x(high)) / 2,
+				y: height - 8,
+				anchor: "middle",
+				tone: "ink",
+				size: 10
+			}]);
+		}
+		const tip = (p) => ({
+			title: `Operating point, ${p.curve}`,
+			rows: [
+				["Voltage", p.voltage.toFixed(2)],
+				["Current", p.current.toFixed(2)],
+				["Dissipation", (p.voltage * p.current).toFixed(1)]
+			]
+		});
+		if (operatingPoints) this.dots(ctx, "operating-points", meets.filter((p) => p !== bias), (p) => at([p.voltage, p.current]), (p) => ctx.palette.color(p.curve), tip, 4);
+		if (bias) {
+			this.dots(ctx, "q-point", [bias], (p) => at([p.voltage, p.current]), () => ctx.theme.ink, tip, 5.5);
+			this.annotate(ctx, "q-note", [{
+				key: "q",
+				text: "Q",
+				x: at([bias.voltage, bias.current])[0] + 8,
+				y: at([bias.voltage, bias.current])[1] - 7,
+				tone: "ink"
+			}]);
+		}
+	}
+};
+export { LoadLineChart, LoadLineSet };

package/dist/charts/engineering/MohrCircle.js

@@ -0,0 +1,256 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart } from "./EngineeringChart.js";
+// src/charts/engineering/MohrCircle.ts
+var MohrState = /* @__PURE__ */ function(MohrState) {
+	MohrState["Plane"] = "plane-stress";
+	MohrState["Triaxial"] = "triaxial";
+	return MohrState;
+}({});
+var MohrFailure = /* @__PURE__ */ function(MohrFailure) {
+	MohrFailure["None"] = "no-envelope";
+	MohrFailure["Tresca"] = "tresca";
+	MohrFailure["Coulomb"] = "mohr-coulomb";
+	return MohrFailure;
+}({});
+var MohrShearAxis = /* @__PURE__ */ function(MohrShearAxis) {
+	MohrShearAxis["Up"] = "shear-up";
+	MohrShearAxis["Down"] = "shear-down";
+	return MohrShearAxis;
+}({});
+var sampleStresses = (seed) => SampleData.points(seed, 2, 2).map((row, i) => ({
+	element: i ? "Weld toe" : "Fillet",
+	sigmaX: +(+row.x * (i ? .8 : 1.6)).toFixed(1),
+	sigmaY: +(+row.y * (i ? -.5 : .4) - 10).toFixed(1),
+	tauXY: +(12 + +row.size * 1.1).toFixed(1),
+	sigmaZ: i ? 10 : 0
+}));
+/** Transform a stress state graphically to find principal stresses and maximum shear. */
+var MohrCircle = class extends EngineeringChart {
+	static meta = {
+		id: "mohr-circle",
+		name: "Mohr's circle",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Draws stress states as circles to read principal stresses, maximum shear and failure margin.",
+		tags: [
+			"stress",
+			"solid mechanics",
+			"principal stress",
+			"tresca",
+			"geotechnical"
+		],
+		sample: sampleStresses,
+		variants: {
+			state: ["plane-stress", "triaxial"],
+			failure: [
+				"no-envelope",
+				"tresca",
+				"mohr-coulomb"
+			],
+			shearAxis: ["shear-up", "shear-down"],
+			construction: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			sigmaX: "sigmaX",
+			sigmaY: "sigmaY",
+			tauXY: "tauXY",
+			sigmaZ: "sigmaZ",
+			element: "element",
+			state: "plane-stress",
+			failure: "no-envelope",
+			shearAxis: "shear-up",
+			construction: true,
+			friction: 25,
+			xLabel: "Normal stress σ (MPa)",
+			yLabel: "Shear stress τ (MPa)"
+		};
+	}
+	elements() {
+		const { sigmaX, sigmaY, tauXY, sigmaZ, element } = this.options;
+		return this.rows.map((row, i) => {
+			const sx = this.num(row, sigmaX), sy = this.num(row, sigmaY), txy = this.num(row, tauXY) || 0;
+			const center = (sx + sy) / 2, radius = Math.hypot((sx - sy) / 2, txy);
+			return {
+				name: String(row[element] ?? `Element ${i + 1}`),
+				sx,
+				sy,
+				sz: this.num(row, sigmaZ) || 0,
+				txy,
+				center,
+				radius,
+				s1: center + radius,
+				s2: center - radius
+			};
+		}).filter((e) => Number.isFinite(e.center));
+	}
+	draw(ctx) {
+		const { state, failure, shearAxis, construction, shearLimit, cohesion, friction, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const elements = this.elements();
+		const triaxial = state === "triaxial";
+		const stresses = elements.flatMap((e) => [
+			e.s1,
+			e.s2,
+			...triaxial ? [e.sz] : []
+		]);
+		const reach = Math.max(1, ...elements.map((e) => triaxial ? (Math.max(e.s1, e.sz) - Math.min(e.s2, e.sz)) / 2 : e.radius));
+		const limit = shearLimit ?? reach * 1.3;
+		const span = this.span(stresses, { pad: .12 });
+		const { x, y: base } = this.equalScales(width, height, span, [-(failure === "no-envelope" ? reach : limit) * 1.12, (failure === "no-envelope" ? reach : limit) * 1.12]);
+		const flip = shearAxis === "shear-down" ? -1 : 1;
+		const y = flip > 0 ? base : base.copy().domain([...base.domain()].reverse());
+		const shearTicks = base.ticks(Math.max(3, Math.floor(height / 40)));
+		this.frame(ctx, {
+			x,
+			y,
+			xTitle: xLabel,
+			yTitle: yLabel,
+			yValues: shearTicks
+		});
+		const at = (p) => [x(p[0]), y(p[1])];
+		const circle = (center, radius) => Array.from({ length: 121 }, (_, i) => at([center + radius * Math.cos(i * Math.PI / 60), radius * Math.sin(i * Math.PI / 60)]));
+		if (failure === "tresca") {
+			this.traces(ctx, "envelope", [1, -1].map((sign) => ({
+				key: `t${sign}`,
+				color: ctx.theme.critical,
+				width: 1.5,
+				dash: "6 4",
+				points: [at([x.domain()[0], sign * limit]), at([x.domain()[1], sign * limit])]
+			})));
+			this.annotate(ctx, "envelope-note", [{
+				key: "n",
+				text: `Tresca τ = ${limit.toPrecision(3)}`,
+				x: 6,
+				y: Math.min(y(limit), y(-limit)) + 14,
+				tone: "muted",
+				size: 10
+			}]);
+		}
+		if (failure === "mohr-coulomb") {
+			const slope = Math.tan(friction * Math.PI / 180), c = cohesion ?? (reach * 1.15 + slope * (span[0] + span[1]) * .5) * 1.05;
+			const [a, b] = x.domain();
+			const shear = (sigma) => c - sigma * slope;
+			this.traces(ctx, "envelope", [1, -1].map((sign) => ({
+				key: `c${sign}`,
+				color: ctx.theme.critical,
+				width: 1.5,
+				dash: "6 4",
+				points: this.within(Array.from({ length: 80 }, (_, i) => {
+					const sigma = a + (b - a) * i / 79;
+					return at([sigma, sign * shear(sigma)]);
+				}), width, height)
+			})));
+			this.annotate(ctx, "envelope-note", [{
+				key: "n",
+				text: `Mohr-Coulomb φ = ${friction}°`,
+				x: 6,
+				y: 14,
+				tone: "muted",
+				size: 10
+			}]);
+		}
+		const tints = elements.map((e) => {
+			return {
+				e,
+				circles: triaxial ? [
+					[(Math.max(e.s1, e.sz) + Math.min(e.s2, e.sz)) / 2, (Math.max(e.s1, e.sz) - Math.min(e.s2, e.sz)) / 2],
+					[(e.s1 + e.sz) / 2, Math.abs(e.s1 - e.sz) / 2],
+					[(e.s2 + e.sz) / 2, Math.abs(e.s2 - e.sz) / 2]
+				] : [[e.center, e.radius]],
+				color: ctx.palette.color(e.name)
+			};
+		});
+		this.shapes(ctx, "discs", tints.map(({ e, circles, color }) => ({
+			key: e.name,
+			fill: color,
+			opacity: .1,
+			d: circles.map(([c, r]) => `M${circle(c, r).join("L")}Z`).join("")
+		})));
+		ctx.group("discs").selectAll("path").attr("fill-rule", "evenodd");
+		this.traces(ctx, "circles", tints.flatMap(({ e, circles, color }) => circles.map(([c, r], i) => ({
+			key: `${e.name}${i}`,
+			color,
+			width: i ? 1.5 : 2,
+			points: circle(c, r)
+		}))));
+		const tip = (e) => ({
+			title: e.name,
+			color: ctx.palette.color(e.name),
+			rows: [
+				["σ1", e.s1.toFixed(1)],
+				["σ2", e.s2.toFixed(1)],
+				["τ max", e.radius.toFixed(1)],
+				["Principal angle", `${(Math.atan2(2 * e.txy, e.sx - e.sy) * 90 / Math.PI).toFixed(1)}°`]
+			]
+		});
+		if (construction) {
+			this.traces(ctx, "diameters", elements.map((e) => ({
+				key: e.name,
+				color: ctx.palette.color(e.name),
+				width: 1.5,
+				dash: "4 3",
+				points: [at([e.sx, e.txy]), at([e.sy, -e.txy])]
+			})));
+			const arcs = elements.map((e) => {
+				const start = 0, end = Math.atan2(e.txy, (e.sx - e.sy) / 2), r = e.radius * .28;
+				return {
+					key: e.name,
+					color: ctx.palette.color(e.name),
+					width: 1.5,
+					points: Array.from({ length: 24 }, (_, i) => {
+						const a = start + (end - start) * i / 23;
+						return at([e.center + r * Math.cos(a), r * Math.sin(a)]);
+					})
+				};
+			});
+			this.traces(ctx, "rotation-arcs", arcs);
+			this.dots(ctx, "faces", elements.flatMap((e) => [{
+				e,
+				p: [e.sx, e.txy]
+			}, {
+				e,
+				p: [e.sy, -e.txy]
+			}]), (d) => at(d.p), (d) => ctx.palette.color(d.e.name), (d) => tip(d.e), 4);
+			this.dots(ctx, "principal", elements.flatMap((e) => [{
+				e,
+				p: [e.s1, 0],
+				t: "σ1"
+			}, {
+				e,
+				p: [e.s2, 0],
+				t: "σ2"
+			}]), (d) => at(d.p), () => ctx.theme.ink, (d) => tip(d.e), 4);
+			const lead = elements[0];
+			if (lead) this.annotate(ctx, "principal-notes", [
+				{
+					key: "s1",
+					text: `σ1 ${lead.s1.toFixed(0)}`,
+					x: x(lead.s1) + 6,
+					y: y(0) - 7,
+					tone: "ink"
+				},
+				{
+					key: "s2",
+					text: `σ2 ${lead.s2.toFixed(0)}`,
+					x: x(lead.s2) - 6,
+					y: y(0) - 7,
+					anchor: "end",
+					tone: "ink"
+				},
+				{
+					key: "tm",
+					text: `τmax ${lead.radius.toFixed(0)}`,
+					x: x(lead.center),
+					y: y(lead.radius) + (flip > 0 ? -6 : 14),
+					anchor: "middle",
+					tone: "ink"
+				}
+			]);
+		} else this.probes(ctx, "probes", elements, (e) => at([e.center, e.radius]), tip);
+	}
+};
+export { MohrCircle, MohrFailure, MohrShearAxis, MohrState };