iapws-if97 2.2.0 → 2.8.0

package/dist/regions/region4.js

@@ -6,8 +6,9 @@
  *
  * Reference: IAPWS-IF97, Section 8 (Equations for Region 4)
  */
-import { Tc, Pc, P_MIN } from '../constants.js';
+import { Tc, Pc, Tt, Pt, T_MIN, P_MIN } from '../constants.js';
 import { OutOfRangeError } from '../types.js';
+import { addExtended, divideExtended, multiplyExtended, sqrtExtended, subtractExtended, } from '../solvers/extended-arithmetic.js';
 import { normalizeRegion4Pressure, normalizeRegion4Temperature, } from '../saturation/region4-boundaries.js';
 // ─── Saturation Line Coefficients (Table 34, IAPWS-IF97) ───────────────────
 const n = [
@@ -32,14 +33,30 @@ const n = [
  * @throws {OutOfRangeError} if T is outside valid range
  */
 export function saturationPressure(T) {
+    const pressure = saturationPressurePair(T)[0];
+    if (T === T_MIN)
+        return P_MIN;
+    // The fitted equation reaches the rounded triple-point pressure just below Tt.
+    if (T <= Tt && pressure >= Pt)
+        return Pt;
+    if (T === Tc)
+        return Pc;
+    return normalizeRegion4Pressure(pressure);
+}
+/** Internal unrounded target: near criticality, one pressure ULP changes endpoint density. */
+export function saturationPressurePair(T) {
     if (T < 273.15 || T > Tc) {
         throw new OutOfRangeError('Temperature', T, 273.15, Tc);
     }
-    const theta = T + n[9] / (T - n[10]);
-    const A = theta * theta + n[1] * theta + n[2];
-    const B = n[3] * theta * theta + n[4] * theta + n[5];
-    const C = n[6] * theta * theta + n[7] * theta + n[8];
-    return normalizeRegion4Pressure(Math.pow(2 * C / (-B + Math.sqrt(B * B - 4 * A * C)), 4));
+    const theta = addExtended([T, 0], divideExtended([n[9], 0], subtractExtended([T, 0], [n[10], 0])));
+    const thetaSquared = multiplyExtended(theta, theta);
+    const A = addExtended(addExtended(thetaSquared, multiplyExtended([n[1], 0], theta)), [n[2], 0]);
+    const B = addExtended(addExtended(multiplyExtended([n[3], 0], thetaSquared), multiplyExtended([n[4], 0], theta)), [n[5], 0]);
+    const C = addExtended(addExtended(multiplyExtended([n[6], 0], thetaSquared), multiplyExtended([n[7], 0], theta)), [n[8], 0]);
+    const discriminant = subtractExtended(multiplyExtended(B, B), multiplyExtended(multiplyExtended([4, 0], A), C));
+    const root = divideExtended(multiplyExtended([2, 0], C), addExtended([-B[0], -B[1]], sqrtExtended(discriminant)));
+    const squared = multiplyExtended(root, root);
+    return multiplyExtended(squared, squared);
 }
 /**
  * Saturation temperature for a given pressure.
@@ -55,10 +72,20 @@ export function saturationTemperature(p) {
     if (p < P_MIN || p > Pc) {
         throw new OutOfRangeError('Pressure', p, P_MIN, Pc);
     }
-    const beta = Math.pow(p, 0.25);
-    const E = beta * beta + n[3] * beta + n[6];
-    const F = n[1] * beta * beta + n[4] * beta + n[7];
-    const G = n[2] * beta * beta + n[5] * beta + n[8];
-    const D = 2 * G / (-F - Math.sqrt(F * F - 4 * E * G));
-    return normalizeRegion4Temperature((n[10] + D - Math.sqrt(Math.pow(n[10] + D, 2) - 4 * (n[9] + n[10] * D))) / 2);
+    if (p === P_MIN)
+        return T_MIN;
+    if (p === Pt)
+        return Tt;
+    if (p === Pc)
+        return Tc;
+    const beta = sqrtExtended(sqrtExtended([p, 0]));
+    const betaSquared = multiplyExtended(beta, beta);
+    const E = addExtended(addExtended(betaSquared, multiplyExtended([n[3], 0], beta)), [n[6], 0]);
+    const F = addExtended(addExtended(multiplyExtended([n[1], 0], betaSquared), multiplyExtended([n[4], 0], beta)), [n[7], 0]);
+    const G = addExtended(addExtended(multiplyExtended([n[2], 0], betaSquared), multiplyExtended([n[5], 0], beta)), [n[8], 0]);
+    const discriminant = subtractExtended(multiplyExtended(F, F), multiplyExtended(multiplyExtended([4, 0], E), G));
+    const D = divideExtended(multiplyExtended([2, 0], G), subtractExtended([-F[0], -F[1]], sqrtExtended(discriminant)));
+    const difference = subtractExtended([n[10], 0], D);
+    const temperature = divideExtended(subtractExtended(addExtended([n[10], 0], D), sqrtExtended(subtractExtended(multiplyExtended(difference, difference), [4 * n[9], 0]))), [2, 0]);
+    return p >= Pt && temperature[0] < Tt ? Tt : normalizeRegion4Temperature(temperature[0]);
 }

package/dist/regions/region5.d.ts

@@ -6,7 +6,8 @@
  *
  * Reference: IAPWS-IF97, Section 9 (Equations for Region 5)
  */
-import type { BasicProperties } from '../types.js';
+import type { BasicProperties, CoefficientTable } from '../types.js';
+export declare const RESIDUAL_COEFFICIENTS: CoefficientTable;
 /**
  * Compute Region 5 thermodynamic properties from pressure and temperature.
  *

package/dist/regions/region5.js

@@ -6,7 +6,7 @@
  *
  * Reference: IAPWS-IF97, Section 9 (Equations for Region 5)
  */
-import { R } from '../constants.js';
+import { R } from '../gas-constant.js';
 import { Region } from '../types.js';
 // ─── Ideal Part Coefficients (Table 37) ─────────────────────────────────────
 const IDEAL_COEFFICIENTS = [
@@ -18,7 +18,7 @@ const IDEAL_COEFFICIENTS = [
     [2, -0.32961626538917],
 ];
 // ─── Residual Part Coefficients (Table 38) ──────────────────────────────────
-const RESIDUAL_COEFFICIENTS = [
+export const RESIDUAL_COEFFICIENTS = [
     [1, 1, 1.5736404855259e-3],
     [1, 2, 9.0153761673944e-4],
     [1, 3, -5.0270077677648e-3],

package/dist/saturation/common.d.ts

@@ -5,14 +5,8 @@
  * two-phase boundary, and provides helpers for quality interpolation
  * and two-phase mixing.
  */
-import type { BasicProperties } from '../types.js';
-/** Saturated liquid and vapour properties at a given saturation state. */
-export interface SaturationEndpoints {
-    pressure: number;
-    temperature: number;
-    liquid: BasicProperties;
-    vapor: BasicProperties;
-}
+import type { BasicProperties, SaturationEndpoints } from '../types.js';
+export type { SaturationEndpoints } from '../types.js';
 export declare function rawQualityFromSaturationProperty(liquidValue: number, vaporValue: number, mixtureValue: number): number;
 /**
  * Compute saturated liquid and vapour properties at a given pressure.

package/dist/saturation/common.js

@@ -1,15 +1,18 @@
 import { IF97Error, Region } from '../types.js';
-import { Pc, R2_T_MIN, RHOc, Tt } from '../constants.js';
+import { SaturationEndpointError } from '../errors.js';
+import { Pc, Pt, P_MIN, R2_T_MIN, RHOc, T_MIN, Tc, Tt } from '../constants.js';
 import { region1 } from '../regions/region1.js';
 import { region2 } from '../regions/region2.js';
 import { region3ByRhoT } from '../regions/region3.js';
-import { saturationPressure, saturationTemperature } from '../regions/region4.js';
+import { saturationPressure, saturationPressurePair, saturationTemperature } from '../regions/region4.js';
 import { region3SatVolume } from '../regions/region3-subregions.js';
 import { solveRegion3StateAtPressure } from '../core/region3-pt.js';
+import { nextPositiveFloat } from '../core/floating-point.js';
 import { normalizeRegion4Pressure, normalizeRegion4Temperature, } from './region4-boundaries.js';
+const REGION12_SATURATION_PRESSURE = saturationPressure(R2_T_MIN);
 /** Tag a single-phase state as Region 4 with the given vapour quality. */
-function withRegion4Metadata(state, quality) {
-    return { ...state, region: Region.Region4, quality };
+function withRegion4Metadata(state, quality, saturation) {
+    return { ...state, region: Region.Region4, quality, saturation };
 }
 /**
  * Solve for the Region 3 saturation endpoint state.
@@ -18,8 +21,8 @@ function withRegion4Metadata(state, quality) {
  * @param T - Saturation temperature [K]
  * @param x - Phase indicator: 0 = liquid, 1 = vapour
  */
-function solveR3Endpoint(p, T, x) {
-    return solveRegion3StateAtPressure(p, T, 1 / region3SatVolume(p, T, x));
+function solveR3Endpoint(p, T, x, pressureLow) {
+    return solveRegion3StateAtPressure(p, T, 1 / region3SatVolume(p, T, x), pressureLow);
 }
 /** Clamp vapour quality to [0, 1], snapping near-zero/one values to the boundary. */
 function clampQuality(x) {
@@ -44,6 +47,48 @@ export function rawQualityFromSaturationProperty(liquidValue, vaporValue, mixtur
     }
     return (mixtureValue - liquidValue) / span;
 }
+function buildSaturationEndpoints(pressure, temperature) {
+    // Both caller coordinates must use the same native saturation EOS pair.
+    const pressurePair = saturationPressurePair(temperature);
+    const eosPressure = temperature === T_MIN ? P_MIN
+        : temperature <= Tt && pressurePair[0] >= Pt ? Pt : normalizeRegion4Pressure(pressurePair[0]);
+    const pressureLow = eosPressure === pressurePair[0] ? pressurePair[1] : 0;
+    let liquid;
+    let vapor;
+    if (pressure === Pc && temperature === Tc) {
+        liquid = vapor = region3ByRhoT(RHOc, temperature);
+    }
+    else if (pressure > REGION12_SATURATION_PRESSURE) {
+        // Inverse-temperature rounding must not change formula ownership at 623.15 K.
+        const inconsistency = `Region 4 numerical inconsistency at p=${pressure} MPa, T=${temperature} K: cannot construct distinct stable liquid and vapor EOS endpoints`;
+        try {
+            liquid = solveR3Endpoint(eosPressure, temperature, 0, pressureLow);
+            vapor = solveR3Endpoint(eosPressure, temperature, 1, pressureLow);
+        }
+        catch (error) {
+            if (!(error instanceof IF97Error))
+                throw error;
+            throw new SaturationEndpointError(`${inconsistency}: ${error.message}`);
+        }
+        if (!(1 / liquid.specificVolume > RHOc && 1 / vapor.specificVolume < RHOc &&
+            vapor.specificVolume > liquid.specificVolume && vapor.enthalpy > liquid.enthalpy &&
+            vapor.entropy > liquid.entropy && [liquid, vapor].every((state) => Number.isFinite(state.pressure) && Math.abs(state.pressure - pressure) / pressure <= 1e-6 &&
+            [state.cp, state.cv, state.isothermalCompressibility, state.speedOfSound]
+                .every((value) => value !== null && Number.isFinite(value) && value > 0)))) {
+            throw new SaturationEndpointError(inconsistency);
+        }
+    }
+    else {
+        liquid = region1(eosPressure, temperature);
+        vapor = region2(eosPressure, temperature);
+    }
+    return {
+        pressure,
+        temperature,
+        liquid: { ...liquid, pressure, temperature },
+        vapor: { ...vapor, pressure, temperature },
+    };
+}
 /**
  * Compute saturated liquid and vapour properties at a given pressure.
  *
@@ -54,25 +99,15 @@ export function rawQualityFromSaturationProperty(liquidValue, vaporValue, mixtur
  */
 export function saturationEndpointsAtPressure(p) {
     const pressure = normalizeRegion4Pressure(p);
-    const temperature = normalizeRegion4Temperature(saturationTemperature(pressure));
-    if (pressure === Pc) {
-        const state = region3ByRhoT(RHOc, temperature);
-        return { pressure, temperature, liquid: state, vapor: state };
-    }
-    if (temperature > R2_T_MIN) {
-        return {
-            pressure,
-            temperature,
-            liquid: solveR3Endpoint(pressure, temperature, 0),
-            vapor: solveR3Endpoint(pressure, temperature, 1),
-        };
+    let temperature = pressure === REGION12_SATURATION_PRESSURE
+        ? R2_T_MIN
+        : normalizeRegion4Temperature(saturationTemperature(pressure));
+    if ((pressure > REGION12_SATURATION_PRESSURE && temperature <= R2_T_MIN) ||
+        (pressure < REGION12_SATURATION_PRESSURE && temperature >= R2_T_MIN)) {
+        // Keep a rounded derived temperature on the pressure's formula side.
+        temperature = nextPositiveFloat(R2_T_MIN, pressure > REGION12_SATURATION_PRESSURE ? 1 : -1);
     }
-    return {
-        pressure,
-        temperature,
-        liquid: region1(pressure, temperature),
-        vapor: region2(pressure, temperature),
-    };
+    return buildSaturationEndpoints(pressure, temperature);
 }
 /**
  * Compute saturated liquid and vapour properties at a given temperature.
@@ -80,16 +115,8 @@ export function saturationEndpointsAtPressure(p) {
  */
 export function saturationEndpointsAtTemperature(T) {
     const temperature = normalizeRegion4Temperature(T);
-    const pressure = normalizeRegion4Pressure(saturationPressure(temperature));
-    if (temperature < Tt) {
-        return {
-            pressure,
-            temperature,
-            liquid: region1(pressure, temperature),
-            vapor: region2(pressure, temperature),
-        };
-    }
-    return saturationEndpointsAtPressure(pressure);
+    const pressure = saturationPressure(temperature);
+    return buildSaturationEndpoints(pressure, temperature);
 }
 /**
  * Compute vapour quality from any extensive saturation property.
@@ -123,10 +150,10 @@ export function mixSaturationState(endpoints, qualityInput) {
     }
     const { liquid, vapor, pressure, temperature } = endpoints;
     if (quality === 0) {
-        return withRegion4Metadata(liquid, 0);
+        return withRegion4Metadata(liquid, 0, endpoints);
     }
     if (quality === 1) {
-        return withRegion4Metadata(vapor, 1);
+        return withRegion4Metadata(vapor, 1, endpoints);
     }
     return {
         region: Region.Region4,
@@ -140,6 +167,7 @@ export function mixSaturationState(endpoints, qualityInput) {
         cv: null,
         speedOfSound: null,
         quality,
+        saturation: endpoints,
         isobaricExpansion: null,
         isothermalCompressibility: null,
     };

package/dist/saturation/region4-boundaries.js

@@ -1,20 +1,16 @@
 import * as C from '../constants.js';
 import { IF97Error, OutOfRangeError } from '../types.js';
 export function normalizeRegion4Pressure(p) {
-    if (Math.abs(p - C.P_MIN) <= C.REGION4_PRESSURE_TOLERANCE)
+    if (p < C.P_MIN && C.P_MIN - p <= C.REGION4_PRESSURE_TOLERANCE * C.P_MIN)
         return C.P_MIN;
-    if (Math.abs(p - C.Pt) <= C.REGION4_PRESSURE_TOLERANCE)
-        return C.Pt;
-    if (Math.abs(p - C.Pc) <= C.REGION4_PRESSURE_TOLERANCE)
+    if (p > C.Pc && p - C.Pc <= C.REGION4_PRESSURE_TOLERANCE * C.Pc)
         return C.Pc;
     return p;
 }
 export function normalizeRegion4Temperature(T) {
-    if (Math.abs(T - C.T_MIN) <= C.REGION4_TEMPERATURE_TOLERANCE)
+    if (T < C.T_MIN && C.T_MIN - T <= C.REGION4_TEMPERATURE_TOLERANCE)
         return C.T_MIN;
-    if (Math.abs(T - C.Tt) <= C.REGION4_TEMPERATURE_TOLERANCE)
-        return C.Tt;
-    if (Math.abs(T - C.Tc) <= C.REGION4_TEMPERATURE_TOLERANCE)
+    if (T > C.Tc && T - C.Tc <= C.REGION4_TEMPERATURE_TOLERANCE)
         return C.Tc;
     return T;
 }
@@ -31,7 +27,7 @@ function criticalPointMessage(solverName) {
     return `${solverName} does not support the critical point P=${C.Pc} MPa, T=${C.Tc} K as a Region 4 saturation state`;
 }
 export function assertRegion4PressureStateInput(p, solverName) {
-    const pressure = normalizeRegion4Pressure(p);
+    const pressure = p < C.Pt && C.Pt - p <= 8 * Number.EPSILON * C.Pt ? C.Pt : normalizeRegion4Pressure(p);
     if (pressure < C.Pt || pressure > C.Pc) {
         throw new OutOfRangeError('Pressure', p, C.Pt, C.Pc);
     }
@@ -41,9 +37,13 @@ export function assertRegion4PressureStateInput(p, solverName) {
     return pressure;
 }
 export function assertRegion4TemperatureStateInput(T, solverName) {
-    const temperature = normalizeRegion4Temperature(T);
+    const temperature = T < C.Tt && C.Tt - T <= 8 * Number.EPSILON * C.Tt ? C.Tt : normalizeRegion4Temperature(T);
     if (temperature < C.Tt || temperature > C.Tc) {
-        throw new OutOfRangeError('Temperature', T, C.Tt, C.Tc);
+        const error = new OutOfRangeError('Temperature', T, C.Tt, C.Tc);
+        if (temperature < C.Tt) {
+            error.message += `; ${solverName} saturation states start at the triple point (${C.Tt} K). 0 °C = 273.15 K is 0.01 K lower; low-level saturationPressure accepts 273.15 K.`;
+        }
+        throw error;
     }
     if (temperature === C.Tc) {
         throw new IF97Error(criticalPointMessage(solverName));
@@ -62,12 +62,12 @@ function isCriticalRegion4Entropy(s) {
     return Math.abs(s - C.R3_S_CRT) <= C.REGION4_CRITICAL_HS_TOLERANCE;
 }
 export function assertCriticalRegion4PHInput(p, h, solverName) {
-    if (isRegion4CriticalPressure(p) && isCriticalRegion4Enthalpy(h)) {
+    if (p === C.Pc && isCriticalRegion4Enthalpy(h)) {
         throw new IF97Error(criticalPointMessage(solverName));
     }
 }
 export function assertCriticalRegion4PSInput(p, s, solverName) {
-    if (isRegion4CriticalPressure(p) && isCriticalRegion4Entropy(s)) {
+    if (p === C.Pc && isCriticalRegion4Entropy(s)) {
         throw new IF97Error(criticalPointMessage(solverName));
     }
 }