iapws-if97 2.1.1 → 2.1.5

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## 2.1.5
+
+- fix some issues
+
+## 2.1.2
+
+- fix some issues
+
 ## 2.1.1
 
 - fix some issues: enhance end-points process

package/dist/backward/hs.js

@@ -12,11 +12,14 @@ import { region1 } from '../regions/region1.js';
 import { region2 } from '../regions/region2.js';
 import { region3ByRhoT } from '../regions/region3.js';
 import { region5 } from '../regions/region5.js';
+import { assertFiniteNumber } from '../core/input-validation.js';
 import { detectRegionHS } from '../core/region-detector.js';
 import { newtonRaphson } from '../solvers/newton-raphson.js';
 import { nelderMead } from '../solvers/nelder-mead.js';
 import { solvePH } from './ph.js';
 import { validateBackwardState } from './solution-validation.js';
+import { sumNormalizedResiduals } from './objective-normalization.js';
+import { backwardConstraintTolerance } from './tolerances.js';
 import { tryRegion4HSState, } from '../saturation/region4-hs.js';
 import { assertCriticalRegion4HSInput, } from '../saturation/region4-boundaries.js';
 // ─── Backward Polynomial Evaluator ─────────────────────────────────────────
@@ -105,9 +108,11 @@ function r2cPhs(h, s) {
 }
 function r2Phs(h, s) {
     const hBound = b2abBoundary(s);
+    // Region 2 h-s subregion selection: 2a below the h(s) boundary,
+    // otherwise split 2b/2c at the published entropy crossover.
     if (h <= hBound)
         return r2aPhs(h, s);
-    if (s >= 5.85)
+    if (s >= C.R2_S_CRT)
         return r2bPhs(h, s);
     return r2cPhs(h, s);
 }
@@ -154,6 +159,33 @@ function r3Phs(h, s) {
         return r3aPhs(h, s);
     return r3bPhs(h, s);
 }
+const REGION5_HS_OUT_OF_DOMAIN_PENALTY = 1e18;
+function normalizedHsObjective(h, s, stateAt) {
+    const enthalpyTolerance = backwardConstraintTolerance('enthalpy', h);
+    const entropyTolerance = backwardConstraintTolerance('entropy', s);
+    return (pair) => {
+        const state = stateAt(pair);
+        return sumNormalizedResiduals([
+            { actual: state.enthalpy, expected: h, tolerance: enthalpyTolerance },
+            { actual: state.entropy, expected: s, tolerance: entropyTolerance },
+        ]);
+    };
+}
+function normalizedRegion5HsObjective(h, s) {
+    const enthalpyTolerance = backwardConstraintTolerance('enthalpy', h);
+    const entropyTolerance = backwardConstraintTolerance('entropy', s);
+    return (pair) => {
+        const [p, T] = pair;
+        if (p <= 0 || p > C.R5_P_MAX || T <= C.R5_T_MIN || T > C.R5_T_MAX) {
+            return REGION5_HS_OUT_OF_DOMAIN_PENALTY;
+        }
+        const state = region5(p, T);
+        return sumNormalizedResiduals([
+            { actual: state.enthalpy, expected: h, tolerance: enthalpyTolerance },
+            { actual: state.entropy, expected: s, tolerance: entropyTolerance },
+        ]);
+    };
+}
 // ─── Main HS Solver ─────────────────────────────────────────────────────────
 /**
  * Solve for thermodynamic state given H and S.
@@ -161,6 +193,8 @@ function r3Phs(h, s) {
  * @param s - Specific entropy [kJ/(kg·K)]
  */
 export function solveHS(h, s) {
+    assertFiniteNumber('Enthalpy', h);
+    assertFiniteNumber('Entropy', s);
     if (h < C.H_MIN || h > C.H_MAX) {
         throw new OutOfRangeError('Enthalpy', h, C.H_MIN, C.H_MAX);
     }
@@ -179,8 +213,8 @@ export function solveHS(h, s) {
     switch (region) {
         case Region.Region1: {
             const P0 = r1Phs(h, s);
-            const sol = nelderMead((pair) => Math.abs(region1(pair[0], pair[1]).enthalpy - h) +
-                Math.abs(region1(pair[0], pair[1]).entropy - s), [P0, 400]);
+            const objective = normalizedHsObjective(h, s, (pair) => region1(pair[0], pair[1]));
+            const sol = nelderMead(objective, [P0, 400], { maxIterations: 1000, minErrorDelta: 1e-8, minTolerance: 1e-9 });
             return validateBackwardState(region1(sol.x[0], sol.x[1]), [
                 { label: 'enthalpy', expected: h },
                 { label: 'entropy', expected: s },
@@ -189,8 +223,8 @@ export function solveHS(h, s) {
         case Region.Region2: {
             const P0 = r2Phs(h, s);
             const T0 = newtonRaphson((T) => region2(P0, T).enthalpy - h, 500);
-            const sol = nelderMead((pair) => Math.abs(region2(pair[0], pair[1]).enthalpy - h) +
-                Math.abs(region2(pair[0], pair[1]).entropy - s), [P0, T0]);
+            const objective = normalizedHsObjective(h, s, (pair) => region2(pair[0], pair[1]));
+            const sol = nelderMead(objective, [P0, T0], { maxIterations: 1000, minErrorDelta: 1e-8, minTolerance: 1e-9 });
             return validateBackwardState(region2(sol.x[0], sol.x[1]), [
                 { label: 'enthalpy', expected: h },
                 { label: 'entropy', expected: s },
@@ -201,8 +235,8 @@ export function solveHS(h, s) {
             const init = solvePH(P0, h);
             const rho0 = 1 / init.specificVolume;
             const T0 = init.temperature;
-            const sol = nelderMead((pair) => Math.abs(region3ByRhoT(pair[0], pair[1]).enthalpy - h) +
-                Math.abs(region3ByRhoT(pair[0], pair[1]).entropy - s), [rho0, T0]);
+            const objective = normalizedHsObjective(h, s, (pair) => region3ByRhoT(pair[0], pair[1]));
+            const sol = nelderMead(objective, [rho0, T0], { maxIterations: 1000, minErrorDelta: 1e-8, minTolerance: 1e-9 });
             return validateBackwardState(region3ByRhoT(sol.x[0], sol.x[1]), [
                 { label: 'enthalpy', expected: h },
                 { label: 'entropy', expected: s },
@@ -212,8 +246,8 @@ export function solveHS(h, s) {
             throw new IF97Error('solveHS identified Region 4 but failed to construct a valid saturation state');
         }
         case Region.Region5: {
-            const sol = nelderMead((pair) => Math.abs(region5(pair[0], pair[1]).enthalpy - h) +
-                Math.abs(region5(pair[0], pair[1]).entropy - s), [1, 1400]);
+            const objective = normalizedRegion5HsObjective(h, s);
+            const sol = nelderMead(objective, [1, 1400], { maxIterations: 1000, minErrorDelta: 1e-8, minTolerance: 1e-9 });
             return validateBackwardState(region5(sol.x[0], sol.x[1]), [
                 { label: 'enthalpy', expected: h },
                 { label: 'entropy', expected: s },

package/dist/backward/objective-normalization.d.ts

@@ -0,0 +1,7 @@
+export interface NormalizedResidual {
+    actual: number;
+    expected: number;
+    tolerance: number;
+}
+export declare function sumNormalizedResiduals(terms: readonly NormalizedResidual[]): number;
+//# sourceMappingURL=objective-normalization.d.ts.map

package/dist/backward/objective-normalization.js

@@ -0,0 +1,8 @@
+export function sumNormalizedResiduals(terms) {
+    let sum = 0;
+    for (const term of terms) {
+        sum += Math.abs(term.actual - term.expected) / term.tolerance;
+    }
+    return sum;
+}
+//# sourceMappingURL=objective-normalization.js.map

package/dist/backward/ph.js

@@ -13,10 +13,13 @@ import { region2 } from '../regions/region2.js';
 import { region3ByRhoT } from '../regions/region3.js';
 import { region5 } from '../regions/region5.js';
 import { saturationTemperature } from '../regions/region4.js';
+import { assertFiniteNumber } from '../core/input-validation.js';
 import { detectRegionPH } from '../core/region-detector.js';
 import { newtonRaphson } from '../solvers/newton-raphson.js';
 import { nelderMead } from '../solvers/nelder-mead.js';
 import { validateBackwardState } from './solution-validation.js';
+import { backwardConstraintTolerance } from './tolerances.js';
+import { sumNormalizedResiduals } from './objective-normalization.js';
 import { mixSaturationState, qualityFromSaturationProperty, saturationEndpointsAtPressure, } from '../saturation/common.js';
 import { assertCriticalRegion4PHInput, assertRegion4StateAllowed, } from '../saturation/region4-boundaries.js';
 // ─── Backward Polynomial Evaluator ─────────────────────────────────────────
@@ -40,6 +43,10 @@ function r1BackwardT(p, h) {
     return evalPoly(R1_PH, 0, -1, p, h / 2500);
 }
 // ─── Region 2 Backward T(P,H) ─────────────────────────────────────────────
+// Lowest pressure where Region 2c can appear in the P-H backward formulation.
+// For 4 < p <= 6.546699678 MPa the supplementary release selects subregion 2b
+// directly; above this threshold use the B2bc(h) boundary to discriminate 2b/2c.
+const R2_PH_B2BC_P_MIN = 6.546699678;
 // B2bc boundary (exported for future use)
 export function b2bc_H_P(h) {
     return 0.90584278514723e-3 - 0.67955786399241 * h + 0.12809002730136e-3 * h * h;
@@ -94,11 +101,11 @@ function r2BackwardT(p, h) {
     if (p <= C.R2_P_CRT) {
         T = r2aBackwardT(p, h);
     }
-    else if (p <= 6.546699678) {
+    else if (p <= R2_PH_B2BC_P_MIN) {
         T = r2bBackwardT(p, h);
     }
     else {
-        if (p < 905.84278514723 - 0.67955786399241 * h + 1.2809002730136e-4 * h * h) {
+        if (p < b2bc_H_P(h)) {
             T = r2bBackwardT(p, h);
         }
         else {
@@ -190,6 +197,8 @@ export function r4EnthalpyToPsat(h) {
  * @param h - Specific enthalpy [kJ/kg]
  */
 export function solvePH(p, h) {
+    assertFiniteNumber('Pressure', p);
+    assertFiniteNumber('Enthalpy', h);
     if (p < C.P_MIN || p > C.P_MAX) {
         throw new OutOfRangeError('Pressure', p, C.P_MIN, C.P_MAX);
     }
@@ -217,6 +226,8 @@ export function solvePH(p, h) {
         }
         case Region.Region3: {
             const hBound = b3ab_P_to_H(p);
+            const pressureTolerance = 1e-5 * Math.max(1, Math.abs(p));
+            const enthalpyTolerance = backwardConstraintTolerance('enthalpy', h);
             let T0, v0;
             if (h < hBound) {
                 T0 = 760 * evalPoly(R3A_PH_T, -0.240, 0.615, p / 100, h / 2300);
@@ -226,10 +237,15 @@ export function solvePH(p, h) {
                 T0 = 860 * evalPoly(R3B_PH_T, -0.298, 0.720, p / 100, h / 2800);
                 v0 = 0.0088 * evalPoly(R3B_PH_V, -0.0661, 0.720, p / 100, h / 2800);
             }
-            const sol = nelderMead((pair) => Math.abs(region3ByRhoT(1 / pair[0], pair[1]).enthalpy - h) +
-                Math.abs(region3ByRhoT(1 / pair[0], pair[1]).pressure - p), [v0, T0]);
+            const sol = nelderMead((pair) => {
+                const state = region3ByRhoT(1 / pair[0], pair[1]);
+                return sumNormalizedResiduals([
+                    { actual: state.enthalpy, expected: h, tolerance: enthalpyTolerance },
+                    { actual: state.pressure, expected: p, tolerance: pressureTolerance },
+                ]);
+            }, [v0, T0], { maxIterations: 1000, minErrorDelta: 1e-8, minTolerance: 1e-9 });
             return validateBackwardState(region3ByRhoT(1 / sol.x[0], sol.x[1]), [
-                { label: 'pressure', expected: p, tolerance: 1e-5 * Math.max(1, Math.abs(p)) },
+                { label: 'pressure', expected: p, tolerance: pressureTolerance },
                 { label: 'enthalpy', expected: h },
             ], { solverName: 'solvePH', expectedRegion: Region.Region3 });
         }

package/dist/backward/ps.js

@@ -9,10 +9,13 @@ import { region1 } from '../regions/region1.js';
 import { region2 } from '../regions/region2.js';
 import { region3ByRhoT } from '../regions/region3.js';
 import { region5 } from '../regions/region5.js';
+import { assertFiniteNumber } from '../core/input-validation.js';
 import { detectRegionPS } from '../core/region-detector.js';
 import { newtonRaphson } from '../solvers/newton-raphson.js';
 import { nelderMead } from '../solvers/nelder-mead.js';
 import { validateBackwardState } from './solution-validation.js';
+import { backwardConstraintTolerance } from './tolerances.js';
+import { sumNormalizedResiduals } from './objective-normalization.js';
 import { mixSaturationState, qualityFromSaturationProperty, saturationEndpointsAtPressure, } from '../saturation/common.js';
 import { assertCriticalRegion4PSInput, assertRegion4StateAllowed, } from '../saturation/region4-boundaries.js';
 function evalPoly(table, piShift, sigShift, pi, sig) {
@@ -149,6 +152,8 @@ const R3B_PS_V_TABLE = [
  * @param s - Specific entropy [kJ/(kg·K)]
  */
 export function solvePS(p, s) {
+    assertFiniteNumber('Pressure', p);
+    assertFiniteNumber('Entropy', s);
     if (p < C.P_MIN || p > C.P_MAX) {
         throw new OutOfRangeError('Pressure', p, C.P_MIN, C.P_MAX);
     }
@@ -175,6 +180,8 @@ export function solvePS(p, s) {
             ], { solverName: 'solvePS', expectedRegion: Region.Region2 });
         }
         case Region.Region3: {
+            const pressureTolerance = 1e-5 * Math.max(1, Math.abs(p));
+            const entropyTolerance = backwardConstraintTolerance('entropy', s);
             let T0, v0;
             if (s <= C.R3_S_CRT) {
                 T0 = 760 * evalPoly(R3A_PS_T_TABLE, -0.240, 0.703, p / 100, s / 4.4);
@@ -184,10 +191,15 @@ export function solvePS(p, s) {
                 T0 = 860 * evalPoly(R3B_PS_T_TABLE, -0.760, 0.818, p / 100, s / 5.3);
                 v0 = 0.0088 * evalPoly(R3B_PS_V_TABLE, -0.298, 0.816, p / 100, s / 5.3);
             }
-            const sol = nelderMead((pair) => Math.abs(region3ByRhoT(1 / pair[0], pair[1]).entropy - s) +
-                Math.abs(region3ByRhoT(1 / pair[0], pair[1]).pressure - p), [v0, T0]);
+            const sol = nelderMead((pair) => {
+                const state = region3ByRhoT(1 / pair[0], pair[1]);
+                return sumNormalizedResiduals([
+                    { actual: state.entropy, expected: s, tolerance: entropyTolerance },
+                    { actual: state.pressure, expected: p, tolerance: pressureTolerance },
+                ]);
+            }, [v0, T0], { maxIterations: 1000, minErrorDelta: 1e-8, minTolerance: 1e-9 });
             return validateBackwardState(region3ByRhoT(1 / sol.x[0], sol.x[1]), [
-                { label: 'pressure', expected: p, tolerance: 1e-5 * Math.max(1, Math.abs(p)) },
+                { label: 'pressure', expected: p, tolerance: pressureTolerance },
                 { label: 'entropy', expected: s },
             ], { solverName: 'solvePS', expectedRegion: Region.Region3 });
         }

package/dist/backward/th.js

@@ -1,5 +1,6 @@
 import * as C from '../constants.js';
 import { IF97Error, OutOfRangeError, Region } from '../types.js';
+import { assertFiniteNumber } from '../core/input-validation.js';
 import { detectRegionTH } from '../core/region-detector.js';
 import { solveRegion3PTBasic } from '../core/region3-pt.js';
 import { region1 } from '../regions/region1.js';
@@ -28,6 +29,8 @@ const extractH = (s) => s.enthalpy;
  * @throws {IF97Error} if T is within the critical exclusion band
  */
 export function solveTH(T, h) {
+    assertFiniteNumber('Temperature', T);
+    assertFiniteNumber('Enthalpy', h);
     if (T < C.T_MIN || T > C.T_MAX) {
         throw new OutOfRangeError('Temperature', T, C.T_MIN, C.T_MAX);
     }

package/dist/backward/tolerances.js

@@ -5,7 +5,7 @@ export function backwardConstraintTolerance(label, expected) {
         case 'temperature':
             return 1e-9 * Math.max(1, Math.abs(expected));
         case 'enthalpy':
-            return 1e-4 * Math.max(1, Math.abs(expected));
+            return 1e-6 * Math.max(1, Math.abs(expected));
         case 'entropy':
             return 1e-6 * Math.max(1, Math.abs(expected));
         default:

package/dist/backward/ts.js

@@ -1,5 +1,6 @@
 import * as C from '../constants.js';
 import { IF97Error, OutOfRangeError, Region } from '../types.js';
+import { assertFiniteNumber } from '../core/input-validation.js';
 import { detectRegionTS } from '../core/region-detector.js';
 import { solveRegion3PTBasic } from '../core/region3-pt.js';
 import { region1 } from '../regions/region1.js';
@@ -28,6 +29,8 @@ const extractS = (s) => s.entropy;
  * @throws {IF97Error} if T is within the critical exclusion band
  */
 export function solveTS(T, s) {
+    assertFiniteNumber('Temperature', T);
+    assertFiniteNumber('Entropy', s);
     if (T < C.T_MIN || T > C.T_MAX) {
         throw new OutOfRangeError('Temperature', T, C.T_MIN, C.T_MAX);
     }

package/dist/constants.d.ts

@@ -5,9 +5,13 @@
  * for the IAPWS Industrial Formulation 1997.
  */
 /** Specific gas constant for water [kJ/(kg·K)].
- *  IAPWS-IF97, §2 (Table 1). Fixed value for IF97 internal consistency;
- *  differs from the IAPWS-95 / CODATA value. */
+ *  IAPWS-IF97, §2 (Table 1). Fixed value for IF97 internal consistency.
+ *  Do not replace transport correlations with this value; thermal conductivity
+ *  critical enhancement intentionally uses `R_IAPWS_2011_THERMAL`. */
 export declare const R = 0.461526;
+/** Specific gas constant used by the IAPWS 2011 thermal conductivity λ₂ correlation [kJ/(kg·K)].
+ *  Intentionally differs from IF97's `R`; keep both constants distinct and named. */
+export declare const R_IAPWS_2011_THERMAL = 0.46151805;
 /** Critical temperature [K] */
 export declare const Tc = 647.096;
 /** Temperature exclusion half-band around the critical point [K] */

package/dist/constants.js

@@ -6,9 +6,13 @@
  */
 // ─── Fundamental Constants ──────────────────────────────────────────────────
 /** Specific gas constant for water [kJ/(kg·K)].
- *  IAPWS-IF97, §2 (Table 1). Fixed value for IF97 internal consistency;
- *  differs from the IAPWS-95 / CODATA value. */
+ *  IAPWS-IF97, §2 (Table 1). Fixed value for IF97 internal consistency.
+ *  Do not replace transport correlations with this value; thermal conductivity
+ *  critical enhancement intentionally uses `R_IAPWS_2011_THERMAL`. */
 export const R = 0.461526;
+/** Specific gas constant used by the IAPWS 2011 thermal conductivity λ₂ correlation [kJ/(kg·K)].
+ *  Intentionally differs from IF97's `R`; keep both constants distinct and named. */
+export const R_IAPWS_2011_THERMAL = 0.46151805;
 // ─── Critical Point ─────────────────────────────────────────────────────────
 /** Critical temperature [K] */
 export const Tc = 647.096;

package/dist/core/input-validation.d.ts

@@ -0,0 +1,2 @@
+export declare function assertFiniteNumber(parameter: string, value: unknown): asserts value is number;
+//# sourceMappingURL=input-validation.d.ts.map

package/dist/core/input-validation.js

@@ -0,0 +1,7 @@
+import { IF97Error } from '../types.js';
+export function assertFiniteNumber(parameter, value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new IF97Error(`${parameter} must be a finite number`);
+    }
+}
+//# sourceMappingURL=input-validation.js.map

package/dist/core/public-normalization.d.ts

@@ -1,5 +1,4 @@
 import type { BasicProperties, SteamState } from '../types.js';
-type PublicState = BasicProperties | SteamState;
-export declare function normalizePublicState<T extends PublicState>(state: T): T;
-export {};
+export declare function normalizePublicState(state: SteamState): SteamState;
+export declare function normalizePublicState(state: BasicProperties): BasicProperties;
 //# sourceMappingURL=public-normalization.d.ts.map

package/dist/core/public-normalization.js

@@ -17,15 +17,38 @@ function snapSimpleDecimal(value) {
     }
     return Object.is(value, -0) ? 0 : value;
 }
+function normalizeNullableNumber(value) {
+    return value === null ? null : snapSimpleDecimal(value);
+}
+function normalizeBasicProperties(state) {
+    return {
+        region: state.region,
+        pressure: snapSimpleDecimal(state.pressure),
+        temperature: snapSimpleDecimal(state.temperature),
+        specificVolume: snapSimpleDecimal(state.specificVolume),
+        internalEnergy: snapSimpleDecimal(state.internalEnergy),
+        entropy: snapSimpleDecimal(state.entropy),
+        enthalpy: snapSimpleDecimal(state.enthalpy),
+        cp: normalizeNullableNumber(state.cp),
+        cv: normalizeNullableNumber(state.cv),
+        speedOfSound: normalizeNullableNumber(state.speedOfSound),
+        quality: normalizeNullableNumber(state.quality),
+        isobaricExpansion: normalizeNullableNumber(state.isobaricExpansion),
+        isothermalCompressibility: normalizeNullableNumber(state.isothermalCompressibility),
+    };
+}
+function normalizeSteamState(state) {
+    return {
+        ...normalizeBasicProperties(state),
+        density: snapSimpleDecimal(state.density),
+        viscosity: normalizeNullableNumber(state.viscosity),
+        thermalConductivity: normalizeNullableNumber(state.thermalConductivity),
+        surfaceTension: normalizeNullableNumber(state.surfaceTension),
+        dielectricConstant: normalizeNullableNumber(state.dielectricConstant),
+        ionizationConstant: normalizeNullableNumber(state.ionizationConstant),
+    };
+}
 export function normalizePublicState(state) {
-    const normalized = { ...state };
-    for (const [key, value] of Object.entries(state)) {
-        // Preserve enum/null fields exactly; only normalize exposed numeric outputs.
-        if (key === 'region' || value === null || typeof value !== 'number') {
-            continue;
-        }
-        normalized[key] = snapSimpleDecimal(value);
-    }
-    return normalized;
+    return 'density' in state ? normalizeSteamState(state) : normalizeBasicProperties(state);
 }
 //# sourceMappingURL=public-normalization.js.map