@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/engineering/GoodmanDiagram.js

@@ -0,0 +1,250 @@
+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/GoodmanDiagram.ts
+var GoodmanCriterion = /* @__PURE__ */ function(GoodmanCriterion) {
+	GoodmanCriterion["Goodman"] = "goodman";
+	GoodmanCriterion["Soderberg"] = "soderberg";
+	GoodmanCriterion["Gerber"] = "gerber";
+	GoodmanCriterion["Morrow"] = "morrow";
+	GoodmanCriterion["Asme"] = "asme-elliptic";
+	return GoodmanCriterion;
+}({});
+var GoodmanLayout = /* @__PURE__ */ function(GoodmanLayout) {
+	GoodmanLayout["Haigh"] = "haigh";
+	GoodmanLayout["Smith"] = "smith";
+	return GoodmanLayout;
+}({});
+var sampleLoads = (seed) => SampleData.points(seed, 9, 3).map((row, i) => ({
+	series: [
+		"Static bias",
+		"Cyclic",
+		"Shock"
+	][i % 3],
+	mean: +(+row.x * (2.6 + i % 3)).toFixed(0),
+	amplitude: +(+row.y * (1 + .5 * (i % 3)) + 40).toFixed(0)
+}));
+/** Check a part under fluctuating load: how much mean stress eats the fatigue allowance. */
+var GoodmanDiagram = class extends EngineeringChart {
+	static meta = {
+		id: "goodman-diagram",
+		name: "Goodman diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots mean against alternating stress under a chosen failure criterion to give the factor of safety.",
+		tags: [
+			"fatigue",
+			"haigh",
+			"smith diagram",
+			"soderberg",
+			"gerber",
+			"mean stress"
+		],
+		sample: sampleLoads,
+		variants: {
+			criterion: Object.values(GoodmanCriterion),
+			layout: ["haigh", "smith"],
+			safeRegion: [true, false],
+			langer: [true, false],
+			loadLines: [true, false]
+		},
+		valid: (v) => {
+			if (v.layout !== "smith") return true;
+			return !v.loadLines && !(v.criterion === "soderberg" && !v.langer);
+		}
+	};
+	defaults() {
+		return {
+			mean: "mean",
+			amplitude: "amplitude",
+			series: "series",
+			criterion: "goodman",
+			layout: "haigh",
+			safeRegion: true,
+			langer: true,
+			loadLines: true,
+			xLabel: "Mean stress (MPa)"
+		};
+	}
+	draw(ctx) {
+		const { mean, amplitude, series, criterion, layout, safeRegion, langer, loadLines, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const raw = this.rows.map((row) => ({
+			name: String(row[series] ?? "Load"),
+			mean: this.num(row, mean),
+			amplitude: Math.abs(this.num(row, amplitude))
+		})).filter((d) => Number.isFinite(d.mean) && Number.isFinite(d.amplitude));
+		const worst = Math.max(1, ...raw.map((d) => d.mean + d.amplitude));
+		const su = this.options.ultimate ?? worst * 1.5;
+		const sy = this.options.yieldStrength ?? su * .8;
+		const se = this.options.endurance ?? su * .45;
+		const sf = this.options.fracture ?? su * 1.4;
+		/** Largest amplitude allowed at a mean stress. */
+		const allowed = (m) => {
+			const tension = Math.max(0, m);
+			switch (criterion) {
+				case "soderberg": return se * (1 - tension / sy);
+				case "gerber": return se * (1 - (tension / su) ** 2);
+				case "morrow": return se * (1 - tension / sf);
+				case "asme-elliptic": return se * Math.sqrt(Math.max(0, 1 - (tension / sy) ** 2));
+				default: return se * (1 - tension / su);
+			}
+		};
+		const safety = (m, a) => {
+			if (a === 0 && m <= 0) return Infinity;
+			let low = 0, high = 1;
+			while (allowed(m * high) > a * high && high < 1e4) {
+				low = high;
+				high *= 2;
+			}
+			for (let i = 0; i < 40; i++) {
+				const middle = (low + high) / 2;
+				if (allowed(m * middle) > a * middle) low = middle;
+				else high = middle;
+			}
+			return low;
+		};
+		const loads = raw.map((d) => ({
+			...d,
+			safety: safety(d.mean, d.amplitude)
+		}));
+		const end = criterion === "soderberg" || criterion === "asme-elliptic" ? sy : criterion === "morrow" ? sf : su;
+		const left = Math.min(0, ...loads.map((d) => d.mean * 1.1));
+		const sweep = Array.from({ length: 60 }, (_, i) => end * i / 59);
+		const smith = layout === "smith";
+		const x = scaleLinear([left, Math.max(end, su, ...loads.map((d) => d.mean)) * 1.04], [0, width]);
+		const peak = Math.max(se * 1.15, ...loads.map((d) => d.amplitude * 1.1));
+		const y = scaleLinear(smith ? [Math.min(-peak, left - peak), Math.max(sy, su) * 1.1] : [0, peak], [height, 0]).nice();
+		this.frame(ctx, {
+			x,
+			y,
+			xTitle: xLabel,
+			yTitle: yLabel ?? (smith ? "Stress (MPa)" : "Stress amplitude (MPa)")
+		});
+		const at = (m, s) => [x(m), y(s)];
+		const limit = (m) => Math.max(0, allowed(m));
+		const capped = (m) => langer ? Math.min(limit(m), Math.max(0, sy - Math.max(0, m))) : limit(m);
+		if (smith) {
+			this.guides(ctx, "mean-line", [{
+				key: "m",
+				dash: "4 4",
+				points: [at(x.domain()[0], x.domain()[0]), at(x.domain()[1], x.domain()[1])]
+			}]);
+			const upper = [left, ...sweep.filter((m) => m > left)].map((m) => at(m, m + capped(m)));
+			const lower = [left, ...sweep.filter((m) => m > left)].map((m) => at(m, m - capped(m)));
+			if (safeRegion) this.shapes(ctx, "safe", [{
+				key: "s",
+				fill: ctx.theme.good,
+				opacity: .12,
+				d: `M${[...upper, ...[...lower].reverse()].join("L")}Z`
+			}]);
+			this.traces(ctx, "limit", [{
+				key: "u",
+				color: ctx.theme.ink,
+				points: upper
+			}, {
+				key: "l",
+				color: ctx.theme.ink,
+				points: lower
+			}]);
+			const span = ctx.marks("load-spans", "line", loads, (_, i) => i).attr("stroke", (d) => ctx.palette.color(d.name)).attr("stroke-width", 2);
+			ctx.set(span, {
+				x1: (d) => x(d.mean),
+				x2: (d) => x(d.mean),
+				y1: (d) => y(d.mean + d.amplitude),
+				y2: (d) => y(d.mean - d.amplitude)
+			});
+			this.dots(ctx, "loads", loads.flatMap((d) => [{
+				d,
+				s: d.mean + d.amplitude
+			}, {
+				d,
+				s: d.mean - d.amplitude
+			}]), (p) => at(p.d.mean, p.s), (p) => ctx.palette.color(p.d.name), (p) => this.tipFor(ctx, p.d), 3.5);
+			return;
+		}
+		const ceiling = this.within([...left < 0 ? [left, 0] : [], ...sweep].map((m) => at(m, limit(m))), width, height);
+		if (safeRegion) {
+			const rim = [...left < 0 ? [left, 0] : [], ...sweep].map((m) => at(m, capped(m)));
+			this.shapes(ctx, "safe", [{
+				key: "s",
+				fill: ctx.theme.good,
+				opacity: .12,
+				d: `M${rim.join("L")}V${height}H${rim[0][0]}Z`
+			}]);
+		}
+		if (langer) this.traces(ctx, "langer", [{
+			key: "y",
+			color: ctx.theme.serious,
+			width: 1.5,
+			dash: "6 4",
+			points: this.within([at(0, sy), at(sy, 0)], width, height)
+		}]);
+		this.traces(ctx, "limit", [{
+			key: "c",
+			color: ctx.theme.ink,
+			points: ceiling
+		}]);
+		if (loadLines) this.traces(ctx, "load-lines", loads.map((d, i) => {
+			const reach = Math.min(d.safety, 8);
+			return {
+				key: `l${i}`,
+				color: ctx.palette.color(d.name),
+				width: 1,
+				dash: "2 3",
+				points: [at(0, 0), at(d.mean * reach, d.amplitude * reach)]
+			};
+		}));
+		const failing = ctx.marks("failing", "circle", loads.filter((d) => d.safety < 1)).attr("fill", "none").attr("stroke", ctx.theme.critical).attr("stroke-width", 2);
+		ctx.set(failing, {
+			cx: (d) => x(d.mean),
+			cy: (d) => y(d.amplitude),
+			r: 8
+		}, {
+			cx: (d) => x(d.mean),
+			cy: (d) => y(d.amplitude),
+			r: 0
+		});
+		this.dots(ctx, "loads", loads, (d) => at(d.mean, d.amplitude), (d) => ctx.palette.color(d.name), (d) => this.tipFor(ctx, d));
+		const least = loads.reduce((low, d) => !low || d.safety < low.safety ? d : low, null);
+		this.annotate(ctx, "notes", [
+			...least ? [{
+				key: "n",
+				text: `n = ${least.safety.toFixed(2)}`,
+				x: x(least.mean) + 8,
+				y: y(least.amplitude) - 7,
+				tone: "ink"
+			}] : [],
+			{
+				key: "se",
+				text: `Se ${se.toFixed(0)}`,
+				x: x(0) + 4,
+				y: y(se) - 5,
+				tone: "ink",
+				size: 10
+			},
+			{
+				key: "su",
+				text: `${criterion === "morrow" ? "σf" : criterion === "soderberg" || criterion === "asme-elliptic" ? "Sy" : "Su"} ${end.toFixed(0)}`,
+				x: x(end) + 6,
+				y: height - 6,
+				tone: "ink",
+				size: 10
+			}
+		]);
+	}
+	tipFor(ctx, d) {
+		return {
+			title: d.name,
+			color: ctx.palette.color(d.name),
+			rows: [
+				["Mean", `${d.mean} MPa`],
+				["Amplitude", `${d.amplitude} MPa`],
+				["Factor of safety", d.safety.toFixed(2)]
+			]
+		};
+	}
+};
+export { GoodmanCriterion, GoodmanDiagram, GoodmanLayout };

package/dist/charts/engineering/HysteresisLoopChart.js

@@ -0,0 +1,236 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart, engineeringTick } from "./EngineeringChart.js";
+// src/charts/engineering/HysteresisLoopChart.ts
+var MU0 = 4e-7 * Math.PI;
+function sampleLoops(seed) {
+	const trims = SampleData.categories(seed, 2, 1).map((row) => .9 + (+row.value - 20) / 400);
+	return [[
+		"Silicon steel",
+		1.7,
+		90,
+		110,
+		900
+	], [
+		"Ferrite",
+		.42,
+		28,
+		45,
+		900
+	]].flatMap(([material, saturation, coercive, knee, top], m) => {
+		const hc = coercive * trims[m], branch = (h, side) => saturation * Math.tanh((h + side * hc) / knee) + MU0 * h;
+		const sweep = Array.from({ length: 121 }, (_, i) => -top * Math.sign(60 - i || 1) * (Math.abs(60 - i) / 60) ** 2.2);
+		return [...sweep.map((h) => [-h, 1]), ...sweep.map((h) => [h, -1])].map(([field, side]) => ({
+			material,
+			field: +field.toFixed(2),
+			flux: +branch(field, side).toFixed(7)
+		}));
+	});
+}
+/** Size a magnetic core: B-H loop with remanence, coercivity and core loss per cycle. */
+var HysteresisLoopChart = class extends EngineeringChart {
+	static meta = {
+		id: "hysteresis-loop-chart",
+		name: "Hysteresis loop",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots a B-H loop to read remanence, coercivity, saturation and loss per cycle.",
+		tags: [
+			"b-h curve",
+			"magnetics",
+			"transformer",
+			"core loss",
+			"ferromagnetic"
+		],
+		sample: sampleLoops,
+		variants: {
+			fieldScale: [ScaleKind.Linear, ScaleKind.Symlog],
+			landmarks: [true, false],
+			loss: [true, false],
+			anhysteretic: [false, true],
+			permeability: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			field: "field",
+			flux: "flux",
+			material: "material",
+			fieldScale: ScaleKind.Linear,
+			landmarks: true,
+			loss: true,
+			anhysteretic: false,
+			permeability: false,
+			xLabel: "Field H (A/m)",
+			yLabel: "Flux density B (T)"
+		};
+	}
+	loops() {
+		return this.series(this.options.material).map(([name, rows]) => ({
+			name,
+			readings: rows.map((row) => ({
+				name,
+				field: this.num(row, this.options.field),
+				flux: this.num(row, this.options.flux)
+			})).filter((r) => Number.isFinite(r.field) && Number.isFinite(r.flux))
+		})).filter((loop) => loop.readings.length > 2);
+	}
+	zeroCrossings(readings, value, other) {
+		return readings.flatMap((r, i) => {
+			const last = readings[i - 1];
+			if (!last || value(last) * value(r) > 0 || value(last) === value(r)) return [];
+			const t = value(last) / (value(last) - value(r));
+			return [other(last) + (other(r) - other(last)) * t];
+		});
+	}
+	/** Average of ascending and descending flux at each field. */
+	middle(readings) {
+		const turn = readings.reduce((best, r, i) => r.field > readings[best].field ? i : best, 0);
+		const [one, two] = [readings.slice(0, turn + 1), readings.slice(turn)];
+		const lookup = (branch, h) => {
+			const i = branch.findIndex((r, j) => j > 0 && (branch[j - 1].field - h) * (r.field - h) <= 0);
+			if (i < 1) return NaN;
+			const a = branch[i - 1], b = branch[i];
+			return a.flux + (b.flux - a.flux) * (h - a.field) / (b.field - a.field || 1);
+		};
+		return one.map((r) => [r.field, (r.flux + lookup(two, r.field)) / 2]).filter((p) => p.every(Number.isFinite)).sort((a, b) => a[0] - b[0]);
+	}
+	fieldScale(reach, width) {
+		const scale = Scales.continuous(this.options.fieldScale).domain([-reach, reach]).range([0, width]);
+		if (this.options.fieldScale === ScaleKind.Symlog) scale.constant(reach / 100);
+		return scale;
+	}
+	draw(ctx) {
+		const { landmarks, loss, anhysteretic, permeability, fieldScale, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const loops = this.loops();
+		const panel = permeability ? Math.round(height * .3) : 0;
+		const gap = permeability ? 16 : 0;
+		const main = height - panel - gap;
+		const reach = Math.max(1, ...loops.flatMap((l) => l.readings.map((r) => Math.abs(r.field))));
+		const tall = Math.max(1e-6, ...loops.flatMap((l) => l.readings.map((r) => Math.abs(r.flux)))) * 1.08;
+		const x = this.fieldScale(reach, width);
+		const y = Scales.continuous(ScaleKind.Linear).domain([-tall, tall]).range([main, 0]).nice();
+		const symlog = fieldScale === ScaleKind.Symlog;
+		const decade = 10 ** Math.floor(Math.log10(reach));
+		const xValues = symlog ? [
+			-decade,
+			-decade / 10,
+			0,
+			decade / 10,
+			decade
+		] : void 0;
+		const top = ctx.nest("translate(0,0)", "loop");
+		this.frame(top, {
+			x,
+			y,
+			xValues,
+			hideX: permeability,
+			xTitle: xLabel,
+			yTitle: permeability ? "B (T)" : yLabel
+		});
+		const at = (r) => [x(r.field), y(r.flux)];
+		if (loss) {
+			this.shapes(top, "loss", loops.map((l) => ({
+				key: l.name,
+				fill: ctx.palette.color(l.name),
+				opacity: .12,
+				d: `M${l.readings.map(at).join("L")}Z`
+			})));
+			const lead = loops[0];
+			if (lead) {
+				const area = Math.abs(lead.readings.reduce((sum, r, i, list) => {
+					const n = list[(i + 1) % list.length];
+					return sum + r.field * n.flux - n.field * r.flux;
+				}, 0)) / 2;
+				this.annotate(top, "loss-note", [{
+					key: "l",
+					text: `Loss ${engineeringTick(+area.toPrecision(3))} J/m³`,
+					x: width - 4,
+					y: main - 8,
+					anchor: "end",
+					tone: "ink",
+					size: 10
+				}], {
+					width,
+					height: main
+				});
+			}
+		}
+		this.traces(top, "loops", loops.map((l) => ({
+			key: l.name,
+			color: ctx.palette.color(l.name),
+			points: l.readings.map(at)
+		})));
+		if (anhysteretic) this.traces(top, "anhysteretic", loops.map((l) => ({
+			key: l.name,
+			color: ctx.palette.color(l.name),
+			width: 1.5,
+			dash: "5 4",
+			points: this.middle(l.readings).map((p) => [x(p[0]), y(p[1])])
+		})));
+		const tip = (r) => ({
+			title: r.name,
+			color: ctx.palette.color(r.name),
+			rows: [["Field", `${r.field.toFixed(1)} A/m`], ["Flux density", `${r.flux.toFixed(3)} T`]]
+		});
+		loops.forEach((l, i) => this.probes(top, `probe-${i}`, l.readings, at, tip));
+		if (landmarks) {
+			const marks = loops.flatMap((l) => [...this.zeroCrossings(l.readings, (r) => r.field, (r) => r.flux).filter((v) => v > 0).slice(0, 1).map((flux) => ({
+				key: `${l.name}b`,
+				label: `Br ${flux.toFixed(2)} T`,
+				point: [0, flux],
+				name: l.name
+			})), ...this.zeroCrossings(l.readings, (r) => r.flux, (r) => r.field).filter((v) => v > 0).slice(0, 1).map((field) => ({
+				key: `${l.name}h`,
+				label: `Hc ${field.toFixed(0)} A/m`,
+				point: [field, 0],
+				name: l.name
+			}))]);
+			const seat = (m) => [x(m.point[0]), y(m.point[1])];
+			this.dots(top, "landmarks", marks, seat, (m) => ctx.palette.color(m.name), (m) => ({
+				title: m.name,
+				color: ctx.palette.color(m.name),
+				rows: [["Reading", m.label]]
+			}), 4);
+			this.annotate(top, "landmark-notes", marks.slice(0, 2).map((m) => ({
+				key: m.key,
+				text: m.label,
+				x: seat(m)[0] + 8,
+				y: seat(m)[1] + (m.point[0] === 0 ? -6 : 14),
+				tone: "ink",
+				size: 10
+			})), {
+				width,
+				height: main
+			});
+		}
+		if (permeability) {
+			const lower = ctx.nest(`translate(0,${main + gap})`, "permeability");
+			const slopes = loops.map((l) => ({
+				name: l.name,
+				points: l.readings.slice(1).flatMap((r, i) => {
+					const last = l.readings[i], step = r.field - last.field;
+					return step > 0 ? [[r.field, Math.abs((r.flux - last.flux) / step) / MU0]] : [];
+				})
+			}));
+			const m = Scales.continuous(ScaleKind.Log).domain(this.span(slopes.flatMap((s) => s.points.map((p) => p[1])), { log: true })).range([panel, 0]);
+			this.frame(lower, {
+				x,
+				y: m,
+				xValues,
+				xTitle: xLabel,
+				yTitle: "µr"
+			});
+			this.traces(lower, "permeability-curves", slopes.map((s) => ({
+				key: s.name,
+				color: ctx.palette.color(s.name),
+				width: 1.5,
+				points: s.points.map((p) => [x(p[0]), m(Math.max(m.domain()[0], p[1]))])
+			})));
+		}
+	}
+};
+export { HysteresisLoopChart };

package/dist/charts/engineering/IVCurveChart.js

@@ -0,0 +1,197 @@
+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/IVCurveChart.ts
+var IVQuadrant = /* @__PURE__ */ function(IVQuadrant) {
+	IVQuadrant["Generator"] = "generator";
+	IVQuadrant["Load"] = "load-convention";
+	return IVQuadrant;
+}({});
+function sampleCell(seed) {
+	const trims = SampleData.categories(seed, 4, 1).map((row) => .97 + (+row.value - 20) / 1300);
+	return [
+		1e3,
+		800,
+		500,
+		200
+	].flatMap((irradiance, c) => {
+		const light = 9.2 * (irradiance / 1e3) * trims[c], saturation = 2e-9, thermal = 1.8504, series = .25, shunt = 280;
+		return Array.from({ length: 81 }, (_, i) => {
+			const voltage = i * .5;
+			let current = light;
+			for (let k = 0; k < 40; k++) {
+				const diode = saturation * Math.expm1((voltage + current * series) / thermal);
+				current += .3 * (light - diode - (voltage + current * series) / shunt - current);
+			}
+			return {
+				voltage,
+				current: +current.toFixed(4),
+				series: `${irradiance} W/m²`
+			};
+		}).filter((row) => row.current > -.5);
+	});
+}
+/** Characterise a solar cell, diode or other two-terminal device from a current-voltage sweep. */
+var IVCurveChart = class extends EngineeringChart {
+	static meta = {
+		id: "iv-curve-chart",
+		name: "I-V curve",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots device current against voltage and extracts open-circuit, short-circuit and maximum-power points.",
+		tags: [
+			"diode",
+			"solar",
+			"photovoltaic",
+			"mpp",
+			"fill factor",
+			"semiconductor"
+		],
+		sample: sampleCell,
+		variants: {
+			currentScale: [ScaleKind.Linear, ScaleKind.Log],
+			quadrant: ["generator", "load-convention"],
+			normalized: [false, true],
+			power: [true, false],
+			fillFactor: [false, true]
+		},
+		valid: (v) => v.currentScale === ScaleKind.Linear || v.quadrant === "generator" && !v.power && !v.fillFactor
+	};
+	defaults() {
+		return {
+			voltage: "voltage",
+			current: "current",
+			series: "series",
+			currentScale: ScaleKind.Linear,
+			quadrant: "generator",
+			normalized: false,
+			power: true,
+			fillFactor: false
+		};
+	}
+	plotMargin() {
+		return {
+			...super.plotMargin(),
+			right: this.options.power ? 58 : 18
+		};
+	}
+	devices() {
+		const { voltage, current, series, normalized } = this.options;
+		return this.series(series).flatMap(([name, rows]) => {
+			const raw = rows.map((row) => ({
+				voltage: this.num(row, voltage),
+				current: this.num(row, current)
+			})).filter((r) => Number.isFinite(r.voltage) && Number.isFinite(r.current)).sort((a, b) => a.voltage - b.voltage);
+			if (!raw.length) return [];
+			const isc = raw.reduce((best, r) => Math.abs(r.voltage) < Math.abs(best.voltage) ? r : best).current || 1;
+			const crossing = raw.findIndex((r, i) => i > 0 && raw[i - 1].current > 0 && r.current <= 0);
+			const voc = crossing > 0 ? raw[crossing - 1].voltage + raw[crossing - 1].current * (raw[crossing].voltage - raw[crossing - 1].voltage) / (raw[crossing - 1].current - raw[crossing].current) : raw[raw.length - 1].voltage || 1;
+			const readings = raw.map((r) => {
+				const scaledV = normalized ? r.voltage / voc : r.voltage, scaledI = normalized ? r.current / isc : r.current;
+				return {
+					name,
+					voltage: scaledV,
+					current: scaledI,
+					power: scaledV * scaledI
+				};
+			});
+			const peak = readings.reduce((best, r) => r.power > best.power ? r : best);
+			return [{
+				name,
+				readings,
+				voc: normalized ? 1 : voc,
+				isc: normalized ? 1 : isc,
+				peak
+			}];
+		});
+	}
+	draw(ctx) {
+		const { currentScale, quadrant, normalized, power, fillFactor, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const devices = this.devices();
+		const log = currentScale === ScaleKind.Log;
+		const sign = quadrant === "load-convention" ? -1 : 1;
+		const shown = (r) => log ? Math.abs(r.current) : sign * r.current;
+		const readings = devices.flatMap((d) => d.readings);
+		const x = Scales.continuous(ScaleKind.Linear).domain([0, this.span(readings.map((r) => r.voltage), { zero: true })[1] * (normalized ? 1.02 : 1)]).range([0, width]);
+		const positive = readings.map((r) => Math.abs(r.current)).filter((v) => v > 0);
+		const y = log ? Scales.continuous(ScaleKind.Log).domain([Math.max(1e-4 * Math.max(...positive, 1), Math.min(...positive, 1)), Math.max(...positive, 1) * 1.6]).range([height, 0]) : Scales.continuous(ScaleKind.Linear).domain(this.span(readings.map(shown), {
+			zero: true,
+			pad: .05
+		})).range([height, 0]);
+		if (!log) y.domain(sign > 0 ? [0, y.domain()[1]] : [y.domain()[0], 0]).nice();
+		this.frame(ctx, {
+			x,
+			y,
+			xTitle: xLabel ?? (normalized ? "V / Voc" : "Voltage (V)"),
+			yTitle: yLabel ?? (normalized ? "I / Isc" : log ? "|Current| (A)" : sign > 0 ? "Current (A)" : "Current, load sign (A)")
+		});
+		const at = (r) => this.within([[x(r.voltage), log ? r.current > 0 ? y(r.current) : NaN : y(shown(r))]], width, height)[0];
+		if (fillFactor) {
+			const box = (a, b) => `M${x(0)},${y(0)}H${x(a)}V${y(b * sign)}H${x(0)}Z`;
+			const lead = devices[0];
+			if (lead) {
+				this.shapes(ctx, "fill-factor", [{
+					key: "ideal",
+					fill: ctx.theme.grid,
+					opacity: .6,
+					d: box(lead.voc, lead.isc)
+				}, {
+					key: "peak",
+					fill: ctx.palette.color(lead.name),
+					opacity: .16,
+					d: box(lead.peak.voltage, lead.peak.current)
+				}]);
+				this.annotate(ctx, "fill-note", [{
+					key: "f",
+					text: `FF ${(lead.peak.voltage * lead.peak.current * 100 / (lead.voc * lead.isc)).toFixed(0)}%`,
+					x: x(lead.peak.voltage / 2),
+					y: y(lead.peak.current * sign / 2),
+					anchor: "middle",
+					tone: "ink"
+				}]);
+			}
+		}
+		this.traces(ctx, "curves", devices.map((d) => ({
+			key: d.name,
+			color: ctx.palette.color(d.name),
+			points: d.readings.map(at)
+		})));
+		const tip = (r) => ({
+			title: r.name,
+			color: ctx.palette.color(r.name),
+			rows: [
+				["Voltage", r.voltage.toFixed(2)],
+				["Current", r.current.toFixed(3)],
+				["Power", r.power.toFixed(2)]
+			]
+		});
+		devices.forEach((d, i) => this.probes(ctx, `probe-${i}`, d.readings, at, tip));
+		if (power) {
+			const p = Scales.continuous(ScaleKind.Linear).domain([0, Math.max(1e-9, ...devices.map((d) => d.peak.power)) * 1.1]).range([height, 0]).nice();
+			this.rightAxis(ctx, p, width, normalized ? "Normalised power" : "Power (W)");
+			const seat = (r) => this.within([[x(r.voltage), r.power >= 0 ? p(r.power) : NaN]], width, height)[0];
+			this.traces(ctx, "power-curves", devices.map((d) => ({
+				key: d.name,
+				color: ctx.palette.color(d.name),
+				width: 1.5,
+				dash: "5 4",
+				opacity: .8,
+				points: d.readings.map(seat)
+			})));
+			this.dots(ctx, "mpp", devices.map((d) => d.peak), seat, (r) => ctx.palette.color(r.name), tip, 4);
+			const lead = devices[0];
+			if (lead) this.annotate(ctx, "mpp-note", [{
+				key: "m",
+				text: normalized ? "MPP" : `MPP ${lead.peak.power.toFixed(0)} W`,
+				x: seat(lead.peak)[0] - 8,
+				y: seat(lead.peak)[1] - 7,
+				anchor: "end",
+				tone: "ink"
+			}]);
+		} else this.dots(ctx, "mpp", devices.map((d) => d.peak), at, (r) => ctx.palette.color(r.name), tip, 4);
+	}
+};
+export { IVCurveChart, IVQuadrant };