@classytic/stage 0.2.0 → 0.4.0

package/dist/thermo/heat-transfer.d.mts

@@ -0,0 +1,164 @@
+//#region src/thermo/heat-transfer.d.ts
+/**
+ * Heat transfer: conduction, convection and radiation, as three rates with
+ * three different dependences on temperature.
+ *
+ * THE MODEL.
+ *
+ *   conduction   P = k·A·Δθ / L            linear in Δθ
+ *   convection   P = h·A·Δθ                linear in Δθ (Newton's law of cooling)
+ *   radiation    P = ε·σ·A·(T⁴ − T_s⁴)     FOURTH POWER of absolute temperature
+ *
+ * The fourth power is the one worth stopping on. Doubling the absolute
+ * temperature multiplies conduction by two and radiation by SIXTEEN, which is
+ * why a radiator is mostly convection, a fire is mostly radiation, and the only
+ * way the Earth loses heat at all is the third row.
+ *
+ * WHAT MAKES CONDUCTION A NETWORK. Δθ/L over a uniform slab generalises to a
+ * THERMAL RESISTANCE R = L/kA, and resistances in series add exactly as
+ * electrical ones do, because both are a flow driven by a potential difference
+ * against an opposition. `compositeWall` solves a layered wall that way and
+ * returns the interface temperatures, which is the part a single overall
+ * U-value throws away and the part that tells you where the condensation
+ * forms.
+ *
+ * RADIATION IS NET, NOT ONE-WAY. A body at T in surroundings at T_s emits εσAT⁴
+ * and absorbs εσAT_s⁴, and only the difference is a transfer. Modelling
+ * emission alone gives a body that cools below its surroundings, which is the
+ * second law violated by a missing term.
+ *
+ * UNITS: SI. Power in watts, area in m², thickness in m, conductivity in
+ * W/(m·K), temperatures in KELVIN for radiation (a fourth power of a Celsius
+ * reading is meaningless) and in either scale for conduction and convection,
+ * where only a difference appears.
+ */
+/** Stefan-Boltzmann constant, W/(m²·K⁴), under its physics name. */
+declare const SIGMA = 5.670374419e-8;
+/**
+ * Thermal conductivity k, W/(m·K).
+ *
+ * The span is the lesson: copper conducts about 25,000 times better than still
+ * air. That single ratio explains fur, feathers, double glazing, string vests
+ * and cavity walls, all of which work by trapping air so it cannot convect, and
+ * none of which would work if air were merely a middling conductor.
+ */
+declare const THERMAL_CONDUCTIVITY: Record<string, number>;
+/**
+ * Rate of conduction through a uniform slab, W: P = k·A·Δθ/L.
+ *
+ * `deltaT` may be in kelvin or Celsius: only a difference appears, and the two
+ * scales have the same degree size.
+ */
+declare function conductionRateW(conductivity: number, areaM2: number, deltaT: number, thicknessM: number): number;
+/** Thermal resistance of a slab, K/W: R = L/(k·A). The conduction analogue of ohms. */
+declare function thermalResistanceKPerW(thicknessM: number, conductivity: number, areaM2: number): number;
+/** One layer of a composite wall. */
+interface WallLayer {
+  label: string;
+  /** Thickness, m. */
+  thicknessM: number;
+  /** Thermal conductivity, W/(m·K). */
+  conductivity: number;
+}
+interface CompositeWallResult {
+  /** Heat flow through the whole wall, W. The same through every layer, in the steady state. */
+  rateW: number;
+  /** Total thermal resistance, K/W. */
+  totalResistanceKPerW: number;
+  /** Overall heat transfer coefficient (U-value), W/(m²·K). */
+  uValue: number;
+  /**
+   * Temperatures at every boundary, °C, from the hot face to the cold one:
+   * one more entry than there are layers.
+   */
+  boundaryTemperaturesC: number[];
+  /** Per-layer share of the total temperature drop. */
+  layers: {
+    label: string;
+    resistanceKPerW: number;
+    dropK: number;
+    shareOfDrop: number;
+  }[];
+}
+/**
+ * Steady-state conduction through a layered wall, with the interface
+ * temperatures.
+ *
+ * In the steady state the same power crosses every layer, so the temperature
+ * drop across each is in proportion to its resistance. That single sentence is
+ * the whole solve, and it is why the interface temperatures come out for free
+ * once the total resistance is known.
+ *
+ * The interface temperatures are the point. A wall's U-value tells you the heat
+ * loss; only the profile tells you whether the inside face of the insulation
+ * sits below the dew point, which is where a wall grows mould.
+ */
+declare function compositeWall(layers: readonly WallLayer[], areaM2: number, hotFaceC: number, coldFaceC: number): CompositeWallResult;
+/**
+ * Rate of convective loss, W: P = h·A·Δθ.
+ *
+ * `h` bundles everything about the fluid, the geometry and whether the flow is
+ * natural or forced into one empirical number, which is why it is a
+ * coefficient rather than a property: still air over a flat plate is about
+ * 5 W/(m²·K), the same air blown across it can be ten times that.
+ */
+declare function convectionRateW(coefficient: number, areaM2: number, deltaT: number): number;
+/**
+ * NET radiated power, W: P = ε·σ·A·(T⁴ − T_surr⁴).
+ *
+ * Negative when the surroundings are hotter, which is correct and is the whole
+ * reason the surroundings term is not optional: without it a body would radiate
+ * itself colder than its own oven.
+ *
+ * `emissivity` runs 0 to 1 and is the same number for absorbing as for
+ * emitting, by Kirchhoff's law. A good emitter is a good absorber, which is why
+ * a matt black surface both loses heat fastest and warms fastest in the sun.
+ */
+declare function radiatedPowerW(emissivity: number, areaM2: number, temperatureK: number, surroundingsK?: number): number;
+/**
+ * Wien's displacement law: the wavelength a black body radiates most strongly
+ * at, in metres, λ_max = b/T.
+ *
+ * Why hot things glow red and hotter things glow white, and how the temperature
+ * of a star is read off its colour without going there.
+ */
+declare function wienPeakWavelengthM(temperatureK: number): number;
+/**
+ * The equilibrium temperature of a body absorbing a radiant flux, K.
+ *
+ * Solves εσT⁴ = (1 − albedo)·flux·(absorbing area / radiating area). The
+ * default ratio of 1/4 is a SPHERE: it intercepts sunlight over its disc πr²
+ * but radiates from its whole surface 4πr², and that factor of four is why the
+ * Earth's effective temperature is 255 K rather than 279 K.
+ */
+declare function radiativeEquilibriumK(fluxWm2: number, albedo?: number, emissivity?: number, areaRatio?: number): number;
+/**
+ * Newton's law of cooling, solved: θ(t) = θ_env + (θ₀ − θ_env)·e^(−t/τ).
+ *
+ * The exponential is what you get when the rate of loss is proportional to the
+ * excess temperature, which is true for convection and for small excesses in
+ * general. τ is the time to fall to 1/e of the initial excess, and it bundles
+ * the mass, the specific heat and the surface into one measurable number.
+ *
+ * Note the body approaches the environment and never passes it, whichever side
+ * it started on: the same equation warms a cold drink and cools a hot one.
+ */
+declare function newtonCoolingC(startC: number, environmentC: number, timeConstantS: number, timeS: number): number;
+/**
+ * The time to cool from one temperature to another under Newton's law, s.
+ *
+ * Throws when the target is on the far side of the environment temperature,
+ * because that never happens and returning a NaN or a negative time would let
+ * it look as though it merely takes a while.
+ */
+declare function newtonCoolingTimeS(startC: number, environmentC: number, timeConstantS: number, targetC: number): number;
+/**
+ * The time constant of a body cooling by convection, s: τ = m·c / (h·A).
+ *
+ * Connects the empirical τ above to the physical properties behind it, which is
+ * what turns a fitted curve into a prediction: double the mass and the cooling
+ * takes twice as long, double the surface and it halves.
+ */
+declare function coolingTimeConstantS(massKg: number, specificHeat: number, coefficient: number, areaM2: number): number;
+//#endregion
+export { CompositeWallResult, SIGMA, THERMAL_CONDUCTIVITY, WallLayer, compositeWall, conductionRateW, convectionRateW, coolingTimeConstantS, newtonCoolingC, newtonCoolingTimeS, radiatedPowerW, radiativeEquilibriumK, thermalResistanceKPerW, wienPeakWavelengthM };

package/dist/thermo/heat-transfer.mjs

@@ -0,0 +1,217 @@
+import { STEFAN_BOLTZMANN, WIEN_DISPLACEMENT } from "../core/constants.mjs";
+
+//#region src/thermo/heat-transfer.ts
+/**
+* Heat transfer: conduction, convection and radiation, as three rates with
+* three different dependences on temperature.
+*
+* THE MODEL.
+*
+*   conduction   P = k·A·Δθ / L            linear in Δθ
+*   convection   P = h·A·Δθ                linear in Δθ (Newton's law of cooling)
+*   radiation    P = ε·σ·A·(T⁴ − T_s⁴)     FOURTH POWER of absolute temperature
+*
+* The fourth power is the one worth stopping on. Doubling the absolute
+* temperature multiplies conduction by two and radiation by SIXTEEN, which is
+* why a radiator is mostly convection, a fire is mostly radiation, and the only
+* way the Earth loses heat at all is the third row.
+*
+* WHAT MAKES CONDUCTION A NETWORK. Δθ/L over a uniform slab generalises to a
+* THERMAL RESISTANCE R = L/kA, and resistances in series add exactly as
+* electrical ones do, because both are a flow driven by a potential difference
+* against an opposition. `compositeWall` solves a layered wall that way and
+* returns the interface temperatures, which is the part a single overall
+* U-value throws away and the part that tells you where the condensation
+* forms.
+*
+* RADIATION IS NET, NOT ONE-WAY. A body at T in surroundings at T_s emits εσAT⁴
+* and absorbs εσAT_s⁴, and only the difference is a transfer. Modelling
+* emission alone gives a body that cools below its surroundings, which is the
+* second law violated by a missing term.
+*
+* UNITS: SI. Power in watts, area in m², thickness in m, conductivity in
+* W/(m·K), temperatures in KELVIN for radiation (a fourth power of a Celsius
+* reading is meaningless) and in either scale for conduction and convection,
+* where only a difference appears.
+*/
+/** Stefan-Boltzmann constant, W/(m²·K⁴), under its physics name. */
+const SIGMA = STEFAN_BOLTZMANN;
+const finite = (value, what) => {
+	if (!Number.isFinite(value)) throw new RangeError(`${what} must be a finite number.`);
+	return value;
+};
+const positive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive.`);
+	return value;
+};
+const kelvin = (value, what = "Temperature") => {
+	if (!Number.isFinite(value) || value < 0) throw new RangeError(`${what} must be a non-negative number of kelvin (got ${value}).`);
+	return value;
+};
+/**
+* Thermal conductivity k, W/(m·K).
+*
+* The span is the lesson: copper conducts about 25,000 times better than still
+* air. That single ratio explains fur, feathers, double glazing, string vests
+* and cavity walls, all of which work by trapping air so it cannot convect, and
+* none of which would work if air were merely a middling conductor.
+*/
+const THERMAL_CONDUCTIVITY = {
+	silver: 429,
+	copper: 401,
+	gold: 314,
+	aluminium: 237,
+	steel: 50,
+	ice: 2.2,
+	glass: 1.05,
+	concrete: .8,
+	brick: .72,
+	water: .6,
+	wood: .13,
+	fibreglass: .04,
+	polystyrene: .033,
+	air: .026
+};
+/**
+* Rate of conduction through a uniform slab, W: P = k·A·Δθ/L.
+*
+* `deltaT` may be in kelvin or Celsius: only a difference appears, and the two
+* scales have the same degree size.
+*/
+function conductionRateW(conductivity, areaM2, deltaT, thicknessM) {
+	return positive(conductivity, "Thermal conductivity") * positive(areaM2, "Area") * finite(deltaT, "A temperature difference") / positive(thicknessM, "Thickness");
+}
+/** Thermal resistance of a slab, K/W: R = L/(k·A). The conduction analogue of ohms. */
+function thermalResistanceKPerW(thicknessM, conductivity, areaM2) {
+	return positive(thicknessM, "Thickness") / (positive(conductivity, "Thermal conductivity") * positive(areaM2, "Area"));
+}
+/**
+* Steady-state conduction through a layered wall, with the interface
+* temperatures.
+*
+* In the steady state the same power crosses every layer, so the temperature
+* drop across each is in proportion to its resistance. That single sentence is
+* the whole solve, and it is why the interface temperatures come out for free
+* once the total resistance is known.
+*
+* The interface temperatures are the point. A wall's U-value tells you the heat
+* loss; only the profile tells you whether the inside face of the insulation
+* sits below the dew point, which is where a wall grows mould.
+*/
+function compositeWall(layers, areaM2, hotFaceC, coldFaceC) {
+	if (layers.length === 0) throw new RangeError("A wall needs at least one layer.");
+	const A = positive(areaM2, "Area");
+	const resistances = layers.map((l) => thermalResistanceKPerW(l.thicknessM, l.conductivity, A));
+	const totalResistanceKPerW = resistances.reduce((sum, r) => sum + r, 0);
+	const rateW = (finite(hotFaceC, "The hot face temperature") - finite(coldFaceC, "The cold face temperature")) / totalResistanceKPerW;
+	const boundaryTemperaturesC = [hotFaceC];
+	let running = hotFaceC;
+	for (const r of resistances) {
+		running -= rateW * r;
+		boundaryTemperaturesC.push(running);
+	}
+	return {
+		rateW,
+		totalResistanceKPerW,
+		uValue: 1 / (totalResistanceKPerW * A),
+		boundaryTemperaturesC,
+		layers: layers.map((l, i) => ({
+			label: l.label,
+			resistanceKPerW: resistances[i],
+			dropK: rateW * resistances[i],
+			shareOfDrop: resistances[i] / totalResistanceKPerW
+		}))
+	};
+}
+/**
+* Rate of convective loss, W: P = h·A·Δθ.
+*
+* `h` bundles everything about the fluid, the geometry and whether the flow is
+* natural or forced into one empirical number, which is why it is a
+* coefficient rather than a property: still air over a flat plate is about
+* 5 W/(m²·K), the same air blown across it can be ten times that.
+*/
+function convectionRateW(coefficient, areaM2, deltaT) {
+	return positive(coefficient, "The convection coefficient") * positive(areaM2, "Area") * finite(deltaT, "A temperature difference");
+}
+/**
+* NET radiated power, W: P = ε·σ·A·(T⁴ − T_surr⁴).
+*
+* Negative when the surroundings are hotter, which is correct and is the whole
+* reason the surroundings term is not optional: without it a body would radiate
+* itself colder than its own oven.
+*
+* `emissivity` runs 0 to 1 and is the same number for absorbing as for
+* emitting, by Kirchhoff's law. A good emitter is a good absorber, which is why
+* a matt black surface both loses heat fastest and warms fastest in the sun.
+*/
+function radiatedPowerW(emissivity, areaM2, temperatureK, surroundingsK = 0) {
+	if (emissivity < 0 || emissivity > 1) throw new RangeError("Emissivity runs from 0 to 1.");
+	return emissivity * SIGMA * positive(areaM2, "Area") * (kelvin(temperatureK) ** 4 - kelvin(surroundingsK, "The surroundings temperature") ** 4);
+}
+/**
+* Wien's displacement law: the wavelength a black body radiates most strongly
+* at, in metres, λ_max = b/T.
+*
+* Why hot things glow red and hotter things glow white, and how the temperature
+* of a star is read off its colour without going there.
+*/
+function wienPeakWavelengthM(temperatureK) {
+	return WIEN_DISPLACEMENT / positive(temperatureK, "Temperature");
+}
+/**
+* The equilibrium temperature of a body absorbing a radiant flux, K.
+*
+* Solves εσT⁴ = (1 − albedo)·flux·(absorbing area / radiating area). The
+* default ratio of 1/4 is a SPHERE: it intercepts sunlight over its disc πr²
+* but radiates from its whole surface 4πr², and that factor of four is why the
+* Earth's effective temperature is 255 K rather than 279 K.
+*/
+function radiativeEquilibriumK(fluxWm2, albedo = 0, emissivity = 1, areaRatio = .25) {
+	if (albedo < 0 || albedo >= 1) throw new RangeError("Albedo runs from 0 to just under 1.");
+	if (emissivity <= 0 || emissivity > 1) throw new RangeError("Emissivity runs from just above 0 to 1.");
+	return ((1 - albedo) * positive(fluxWm2, "The incident flux") * areaRatio / (emissivity * SIGMA)) ** .25;
+}
+/**
+* Newton's law of cooling, solved: θ(t) = θ_env + (θ₀ − θ_env)·e^(−t/τ).
+*
+* The exponential is what you get when the rate of loss is proportional to the
+* excess temperature, which is true for convection and for small excesses in
+* general. τ is the time to fall to 1/e of the initial excess, and it bundles
+* the mass, the specific heat and the surface into one measurable number.
+*
+* Note the body approaches the environment and never passes it, whichever side
+* it started on: the same equation warms a cold drink and cools a hot one.
+*/
+function newtonCoolingC(startC, environmentC, timeConstantS, timeS) {
+	return finite(environmentC, "The environment temperature") + (finite(startC, "The starting temperature") - environmentC) * Math.exp(-Math.max(0, finite(timeS, "A time")) / positive(timeConstantS, "The time constant"));
+}
+/**
+* The time to cool from one temperature to another under Newton's law, s.
+*
+* Throws when the target is on the far side of the environment temperature,
+* because that never happens and returning a NaN or a negative time would let
+* it look as though it merely takes a while.
+*/
+function newtonCoolingTimeS(startC, environmentC, timeConstantS, targetC) {
+	const excess0 = finite(startC, "The starting temperature") - finite(environmentC, "The environment temperature");
+	const excess = finite(targetC, "The target temperature") - environmentC;
+	if (excess0 === 0) throw new RangeError("The body already sits at the environment temperature.");
+	const ratio = excess / excess0;
+	if (ratio <= 0) throw new RangeError("That target is past the environment temperature, which Newton cooling never reaches.");
+	if (ratio > 1) throw new RangeError("That target is further from the environment than the start, so the body never reaches it.");
+	return -positive(timeConstantS, "The time constant") * Math.log(ratio);
+}
+/**
+* The time constant of a body cooling by convection, s: τ = m·c / (h·A).
+*
+* Connects the empirical τ above to the physical properties behind it, which is
+* what turns a fitted curve into a prediction: double the mass and the cooling
+* takes twice as long, double the surface and it halves.
+*/
+function coolingTimeConstantS(massKg, specificHeat, coefficient, areaM2) {
+	return positive(massKg, "Mass") * positive(specificHeat, "Specific heat capacity") / (positive(coefficient, "The convection coefficient") * positive(areaM2, "Area"));
+}
+
+//#endregion
+export { SIGMA, THERMAL_CONDUCTIVITY, compositeWall, conductionRateW, convectionRateW, coolingTimeConstantS, newtonCoolingC, newtonCoolingTimeS, radiatedPowerW, radiativeEquilibriumK, thermalResistanceKPerW, wienPeakWavelengthM };

package/dist/thermo/index.d.mts

@@ -1,82 +1,9 @@
-//#region src/thermo/index.d.ts
-/**
- * `thermo`, ideal-gas thermodynamic processes, as a PURE kernel (like `field`:
- * no React, no pixels, no time-stepping). A lab drives it with a slider/progress
- * fraction; the kernel returns the full P–V path of a quasi-static process plus the
- * first-law bookkeeping along it (work, heat, internal energy, entropy).
- *
- * Everything is one ideal gas, PV = nRT, with a degrees-of-freedom ratio γ = Cp/Cv
- * (monatomic 5/3, diatomic 7/5). The four canonical processes and the Carnot cycle
- * all compose from `runProcess`:
- *
- *   isothermal  T const   PV = const        W = nRT·ln(V₂/V₁),  Q = W,  ΔU = 0
- *   adiabatic   Q = 0     PVᵞ = const        W = (P₁V₁−P₂V₂)/(γ−1) = −ΔU,  ΔS = 0
- *   isobaric    P const   V/T = const        W = PΔV,  Q = nCpΔT,  ΔU = nCvΔT
- *   isochoric   V const   P/T = const        W = 0,    Q = ΔU = nCvΔT
- *
- * SI units throughout: P in pascals, V in m³, T in kelvin, energy in joules,
- * entropy in J/K. (Labs convert to kPa / litres for display.)
- */
-/** Universal gas constant, J/(mol·K). */
-declare const R = 8.314462618;
-type ProcessKind = 'isothermal' | 'adiabatic' | 'isobaric' | 'isochoric';
-interface GasState {
-  /** Pressure, Pa. */
-  P: number;
-  /** Volume, m³. */
-  V: number;
-  /** Temperature, K. */
-  T: number;
-  /** Amount, mol. */
-  n: number;
-}
-interface ProcessResult {
-  kind: ProcessKind;
-  start: GasState;
-  end: GasState;
-  /** Sampled states from start→end (for drawing the P–V curve). */
-  path: GasState[];
-  /** Work done BY the gas, J ( = ∫P dV, the area under the P–V curve). */
-  W: number;
-  /** Heat added TO the gas, J. */
-  Q: number;
-  /** Change in internal energy, J ( = nCvΔT). */
-  dU: number;
-  /** Change in entropy, J/K. */
-  dS: number;
-}
-/**
- * Run one quasi-static process from `start` to a target. Give exactly one target
- * coordinate that the process can reach (e.g. a target volume for an isothermal or
- * adiabatic expansion, a target temperature for isobaric/isochoric heating).
- */
-declare function runProcess(start: GasState, kind: ProcessKind, target: {
-  V?: number;
-  P?: number;
-  T?: number;
-}, gamma?: number, samples?: number): ProcessResult;
-interface CarnotResult {
-  /** The four legs in order: hot isothermal expansion, adiabatic expansion,
-   *  cold isothermal compression, adiabatic compression (back to start). */
-  legs: ProcessResult[];
-  Th: number;
-  Tc: number;
-  /** Heat absorbed from the hot reservoir, J (>0). */
-  Qh: number;
-  /** Heat rejected to the cold reservoir, J (>0). */
-  Qc: number;
-  /** Net work done by the engine over the cycle, J ( = Qh − Qc = enclosed P–V area). */
-  Wnet: number;
-  /** Thermal efficiency = 1 − Tc/Th = Wnet/Qh. */
-  efficiency: number;
-}
-/**
- * A Carnot cycle starting at `(V1, Th)`: isothermal expansion V1→V2 at Th, then
- * adiabatic expansion to Tc, isothermal compression at Tc, and adiabatic
- * compression back to the start. V3/V4 are fixed by the closure condition.
- */
-declare function carnotCycle(n: number, Th: number, Tc: number, V1: number, V2: number, gamma?: number): CarnotResult;
-declare const gammaMonatomic: number;
-declare const gammaDiatomic: number;
-//#endregion
-export { CarnotResult, GasState, ProcessKind, ProcessResult, R, carnotCycle, gammaDiatomic, gammaMonatomic, runProcess };
+import { FixedPointCalibration, ScaleDefinition, TEMPERATURE_SCALES, TemperatureScale, convertTemperature, convertTemperatureInterval, fromKelvin, fundamentalInterval, icePointOn, resistanceAtC, scaleReadingsAgree, steamPointOn, thermocoupleEmf, thermocoupleInversionTemperatureC, thermocoupleNeutralTemperatureC, thermometricTemperatureC, thermometricValue, toKelvin, triplePointTemperatureK } from "./temperature.mjs";
+import { MATERIALS, Material, MixtureBody, MixtureBodyResult, MixtureResult, PhaseName, caloriesToJoules, enthalpyJ, heatToChangeStateJ, heatToWarmJ, joulesToCalories, massMeltedFromDropKg, mixtureEquilibrium, phaseAt, specificHeatFromJ, temperatureRiseFromDropK, temperatureRiseFromSpeedK, temperatureRiseK, waterEquivalentKg } from "./calorimetry.mjs";
+import { GasStateSpec, MolarHeatCapacities, N_A, R, SolvedGasState, combinedGasLaw, gammaDiatomic, gammaFromDegreesOfFreedom, gammaMonatomic, gammaPolyatomic, internalEnergyJ, k_B, kineticPressurePa, maxwellBoltzmannPdf, meanFreePathM, meanSpeedMs, meanSquareSpeed, meanTranslationalEnergyJ, molarHeatCapacities, mostProbableSpeedMs, rmsOf, rmsSpeedMs, solveIdealGas, vanDerWaalsPressurePa } from "./gas.mjs";
+import { GasState, ProcessKind, ProcessResult, firstLawResidualJ, runProcess, workAlongPathJ } from "./processes.mjs";
+import { CarnotResult, CycleDirection, CycleSummary, carnotCycle, carnotEfficiency, cycleSummary, dieselEfficiency, efficiencyFromHeat, heatPumpCOP, ottoCycle, ottoEfficiency, refrigeratorCOP, stateInternalEnergyJ, stirlingCycle } from "./cycles.mjs";
+import { EntropyBalance, MixtureEntropyResult, entropyChangeIsothermalGasJPerK, entropyChangePhaseJPerK, entropyChangeReservoirJPerK, entropyChangeWarmingJPerK, heatTransferEntropy, mixtureEntropyChange } from "./entropy.mjs";
+import { BimetallicBend, LINEAR_EXPANSIVITY, WATER_DENSITY_PEAK_C, areaCoefficient, bimetallicBend, densityAfterExpansionKgM3, expandedAreaM2, expandedLengthM, expandedVolumeM3, lengthChangeM, realExpansivity, thermalStressPa, volumeCoefficient, waterDensityKgM3 } from "./expansion.mjs";
+import { CompositeWallResult, SIGMA, THERMAL_CONDUCTIVITY, WallLayer, compositeWall, conductionRateW, convectionRateW, coolingTimeConstantS, newtonCoolingC, newtonCoolingTimeS, radiatedPowerW, radiativeEquilibriumK, thermalResistanceKPerW, wienPeakWavelengthM } from "./heat-transfer.mjs";
+export { BimetallicBend, CarnotResult, CompositeWallResult, CycleDirection, CycleSummary, EntropyBalance, FixedPointCalibration, GasState, GasStateSpec, LINEAR_EXPANSIVITY, MATERIALS, Material, MixtureBody, MixtureBodyResult, MixtureEntropyResult, MixtureResult, MolarHeatCapacities, N_A, PhaseName, ProcessKind, ProcessResult, R, SIGMA, ScaleDefinition, SolvedGasState, TEMPERATURE_SCALES, THERMAL_CONDUCTIVITY, TemperatureScale, WATER_DENSITY_PEAK_C, WallLayer, areaCoefficient, bimetallicBend, caloriesToJoules, carnotCycle, carnotEfficiency, combinedGasLaw, compositeWall, conductionRateW, convectionRateW, convertTemperature, convertTemperatureInterval, coolingTimeConstantS, cycleSummary, densityAfterExpansionKgM3, dieselEfficiency, efficiencyFromHeat, enthalpyJ, entropyChangeIsothermalGasJPerK, entropyChangePhaseJPerK, entropyChangeReservoirJPerK, entropyChangeWarmingJPerK, expandedAreaM2, expandedLengthM, expandedVolumeM3, firstLawResidualJ, fromKelvin, fundamentalInterval, gammaDiatomic, gammaFromDegreesOfFreedom, gammaMonatomic, gammaPolyatomic, heatPumpCOP, heatToChangeStateJ, heatToWarmJ, heatTransferEntropy, icePointOn, internalEnergyJ, joulesToCalories, k_B, kineticPressurePa, lengthChangeM, massMeltedFromDropKg, maxwellBoltzmannPdf, meanFreePathM, meanSpeedMs, meanSquareSpeed, meanTranslationalEnergyJ, mixtureEntropyChange, mixtureEquilibrium, molarHeatCapacities, mostProbableSpeedMs, newtonCoolingC, newtonCoolingTimeS, ottoCycle, ottoEfficiency, phaseAt, radiatedPowerW, radiativeEquilibriumK, realExpansivity, refrigeratorCOP, resistanceAtC, rmsOf, rmsSpeedMs, runProcess, scaleReadingsAgree, solveIdealGas, specificHeatFromJ, stateInternalEnergyJ, steamPointOn, stirlingCycle, temperatureRiseFromDropK, temperatureRiseFromSpeedK, temperatureRiseK, thermalResistanceKPerW, thermalStressPa, thermocoupleEmf, thermocoupleInversionTemperatureC, thermocoupleNeutralTemperatureC, thermometricTemperatureC, thermometricValue, toKelvin, triplePointTemperatureK, vanDerWaalsPressurePa, volumeCoefficient, waterDensityKgM3, waterEquivalentKg, wienPeakWavelengthM, workAlongPathJ };

package/dist/thermo/index.mjs

@@ -1,133 +1,10 @@
-//#region src/thermo/index.ts
-/**
-* `thermo`, ideal-gas thermodynamic processes, as a PURE kernel (like `field`:
-* no React, no pixels, no time-stepping). A lab drives it with a slider/progress
-* fraction; the kernel returns the full P–V path of a quasi-static process plus the
-* first-law bookkeeping along it (work, heat, internal energy, entropy).
-*
-* Everything is one ideal gas, PV = nRT, with a degrees-of-freedom ratio γ = Cp/Cv
-* (monatomic 5/3, diatomic 7/5). The four canonical processes and the Carnot cycle
-* all compose from `runProcess`:
-*
-*   isothermal  T const   PV = const        W = nRT·ln(V₂/V₁),  Q = W,  ΔU = 0
-*   adiabatic   Q = 0     PVᵞ = const        W = (P₁V₁−P₂V₂)/(γ−1) = −ΔU,  ΔS = 0
-*   isobaric    P const   V/T = const        W = PΔV,  Q = nCpΔT,  ΔU = nCvΔT
-*   isochoric   V const   P/T = const        W = 0,    Q = ΔU = nCvΔT
-*
-* SI units throughout: P in pascals, V in m³, T in kelvin, energy in joules,
-* entropy in J/K. (Labs convert to kPa / litres for display.)
-*/
-/** Universal gas constant, J/(mol·K). */
-const R = 8.314462618;
-const cv = (gamma) => R / (gamma - 1);
-const cp = (gamma) => gamma * R / (gamma - 1);
-/** State completed from any two of (P,V,T) via PV = nRT. */
-const fromPV = (P, V, n) => ({
-	P,
-	V,
-	n,
-	T: P * V / (n * R)
-});
-/**
-* Run one quasi-static process from `start` to a target. Give exactly one target
-* coordinate that the process can reach (e.g. a target volume for an isothermal or
-* adiabatic expansion, a target temperature for isobaric/isochoric heating).
-*/
-function runProcess(start, kind, target, gamma = 5 / 3, samples = 64) {
-	const { n } = start;
-	const Cv = cv(gamma), Cp = cp(gamma);
-	let end;
-	if (kind === "isothermal") {
-		const T = start.T;
-		const V2 = target.V ?? (target.P != null ? n * 8.314462618 * T / target.P : start.V);
-		end = fromPV(n * R * T / V2, V2, n);
-	} else if (kind === "adiabatic") {
-		const K = start.P * start.V ** gamma;
-		const V2 = target.V ?? (target.T != null ? start.V * (start.T / target.T) ** (1 / (gamma - 1)) : start.V);
-		end = fromPV(K / V2 ** gamma, V2, n);
-	} else if (kind === "isobaric") {
-		const P = start.P;
-		end = fromPV(P, target.V ?? (target.T != null ? n * 8.314462618 * target.T / P : start.V), n);
-	} else {
-		const V = start.V;
-		end = fromPV(target.P ?? (target.T != null ? n * 8.314462618 * target.T / V : start.P), V, n);
-	}
-	const path = [];
-	for (let i = 0; i <= samples; i++) {
-		const u = i / samples;
-		let s;
-		if (kind === "isochoric") s = fromPV(start.P + (end.P - start.P) * u, start.V, n);
-		else {
-			const V = start.V + (end.V - start.V) * u;
-			if (kind === "isothermal") s = fromPV(n * R * start.T / V, V, n);
-			else if (kind === "adiabatic") s = fromPV(start.P * start.V ** gamma / V ** gamma, V, n);
-			else s = fromPV(start.P, V, n);
-		}
-		path.push(s);
-	}
-	const dU = n * Cv * (end.T - start.T);
-	let W, Q, dS;
-	if (kind === "isothermal") {
-		W = n * R * start.T * Math.log(end.V / start.V);
-		Q = W;
-		dS = n * R * Math.log(end.V / start.V);
-	} else if (kind === "adiabatic") {
-		W = (start.P * start.V - end.P * end.V) / (gamma - 1);
-		Q = 0;
-		dS = 0;
-	} else if (kind === "isobaric") {
-		W = start.P * (end.V - start.V);
-		Q = n * Cp * (end.T - start.T);
-		dS = n * Cp * Math.log(end.T / start.T);
-	} else {
-		W = 0;
-		Q = dU;
-		dS = n * Cv * Math.log(end.T / start.T);
-	}
-	return {
-		kind,
-		start,
-		end,
-		path,
-		W,
-		Q,
-		dU,
-		dS
-	};
-}
-/**
-* A Carnot cycle starting at `(V1, Th)`: isothermal expansion V1→V2 at Th, then
-* adiabatic expansion to Tc, isothermal compression at Tc, and adiabatic
-* compression back to the start. V3/V4 are fixed by the closure condition.
-*/
-function carnotCycle(n, Th, Tc, V1, V2, gamma = 5 / 3) {
-	const ratio = (Th / Tc) ** (1 / (gamma - 1));
-	const V3 = V2 * ratio;
-	const V4 = V1 * ratio;
-	const legHot = runProcess(fromPV(n * R * Th / V1, V1, n), "isothermal", { V: V2 }, gamma);
-	const legExp = runProcess(legHot.end, "adiabatic", { V: V3 }, gamma);
-	const legCold = runProcess(legExp.end, "isothermal", { V: V4 }, gamma);
-	const legComp = runProcess(legCold.end, "adiabatic", { V: V1 }, gamma);
-	const Qh = legHot.Q;
-	const Qc = -legCold.Q;
-	const Wnet = Qh - Qc;
-	return {
-		legs: [
-			legHot,
-			legExp,
-			legCold,
-			legComp
-		],
-		Th,
-		Tc,
-		Qh,
-		Qc,
-		Wnet,
-		efficiency: 1 - Tc / Th
-	};
-}
-const gammaMonatomic = 5 / 3;
-const gammaDiatomic = 7 / 5;
+import { MATERIALS, caloriesToJoules, enthalpyJ, heatToChangeStateJ, heatToWarmJ, joulesToCalories, massMeltedFromDropKg, mixtureEquilibrium, phaseAt, specificHeatFromJ, temperatureRiseFromDropK, temperatureRiseFromSpeedK, temperatureRiseK, waterEquivalentKg } from "./calorimetry.mjs";
+import { TEMPERATURE_SCALES, convertTemperature, convertTemperatureInterval, fromKelvin, fundamentalInterval, icePointOn, resistanceAtC, scaleReadingsAgree, steamPointOn, thermocoupleEmf, thermocoupleInversionTemperatureC, thermocoupleNeutralTemperatureC, thermometricTemperatureC, thermometricValue, toKelvin, triplePointTemperatureK } from "./temperature.mjs";
+import { N_A, R, combinedGasLaw, gammaDiatomic, gammaFromDegreesOfFreedom, gammaMonatomic, gammaPolyatomic, internalEnergyJ, k_B, kineticPressurePa, maxwellBoltzmannPdf, meanFreePathM, meanSpeedMs, meanSquareSpeed, meanTranslationalEnergyJ, molarHeatCapacities, mostProbableSpeedMs, rmsOf, rmsSpeedMs, solveIdealGas, vanDerWaalsPressurePa } from "./gas.mjs";
+import { firstLawResidualJ, runProcess, workAlongPathJ } from "./processes.mjs";
+import { carnotCycle, carnotEfficiency, cycleSummary, dieselEfficiency, efficiencyFromHeat, heatPumpCOP, ottoCycle, ottoEfficiency, refrigeratorCOP, stateInternalEnergyJ, stirlingCycle } from "./cycles.mjs";
+import { entropyChangeIsothermalGasJPerK, entropyChangePhaseJPerK, entropyChangeReservoirJPerK, entropyChangeWarmingJPerK, heatTransferEntropy, mixtureEntropyChange } from "./entropy.mjs";
+import { LINEAR_EXPANSIVITY, WATER_DENSITY_PEAK_C, areaCoefficient, bimetallicBend, densityAfterExpansionKgM3, expandedAreaM2, expandedLengthM, expandedVolumeM3, lengthChangeM, realExpansivity, thermalStressPa, volumeCoefficient, waterDensityKgM3 } from "./expansion.mjs";
+import { SIGMA, THERMAL_CONDUCTIVITY, compositeWall, conductionRateW, convectionRateW, coolingTimeConstantS, newtonCoolingC, newtonCoolingTimeS, radiatedPowerW, radiativeEquilibriumK, thermalResistanceKPerW, wienPeakWavelengthM } from "./heat-transfer.mjs";
 
-//#endregion
-export { R, carnotCycle, gammaDiatomic, gammaMonatomic, runProcess };
+export { LINEAR_EXPANSIVITY, MATERIALS, N_A, R, SIGMA, TEMPERATURE_SCALES, THERMAL_CONDUCTIVITY, WATER_DENSITY_PEAK_C, areaCoefficient, bimetallicBend, caloriesToJoules, carnotCycle, carnotEfficiency, combinedGasLaw, compositeWall, conductionRateW, convectionRateW, convertTemperature, convertTemperatureInterval, coolingTimeConstantS, cycleSummary, densityAfterExpansionKgM3, dieselEfficiency, efficiencyFromHeat, enthalpyJ, entropyChangeIsothermalGasJPerK, entropyChangePhaseJPerK, entropyChangeReservoirJPerK, entropyChangeWarmingJPerK, expandedAreaM2, expandedLengthM, expandedVolumeM3, firstLawResidualJ, fromKelvin, fundamentalInterval, gammaDiatomic, gammaFromDegreesOfFreedom, gammaMonatomic, gammaPolyatomic, heatPumpCOP, heatToChangeStateJ, heatToWarmJ, heatTransferEntropy, icePointOn, internalEnergyJ, joulesToCalories, k_B, kineticPressurePa, lengthChangeM, massMeltedFromDropKg, maxwellBoltzmannPdf, meanFreePathM, meanSpeedMs, meanSquareSpeed, meanTranslationalEnergyJ, mixtureEntropyChange, mixtureEquilibrium, molarHeatCapacities, mostProbableSpeedMs, newtonCoolingC, newtonCoolingTimeS, ottoCycle, ottoEfficiency, phaseAt, radiatedPowerW, radiativeEquilibriumK, realExpansivity, refrigeratorCOP, resistanceAtC, rmsOf, rmsSpeedMs, runProcess, scaleReadingsAgree, solveIdealGas, specificHeatFromJ, stateInternalEnergyJ, steamPointOn, stirlingCycle, temperatureRiseFromDropK, temperatureRiseFromSpeedK, temperatureRiseK, thermalResistanceKPerW, thermalStressPa, thermocoupleEmf, thermocoupleInversionTemperatureC, thermocoupleNeutralTemperatureC, thermometricTemperatureC, thermometricValue, toKelvin, triplePointTemperatureK, vanDerWaalsPressurePa, volumeCoefficient, waterDensityKgM3, waterEquivalentKg, wienPeakWavelengthM, workAlongPathJ };