iapws-if97 2.1.2 → 2.2.0

package/dist/backward/ph.d.ts

@@ -7,15 +7,18 @@
  * Reference: IAPWS-IF97 Supplementary Release on Backward Equations
  */
 import type { BasicProperties } from '../types.js';
+export declare function r1BackwardT(p: number, h: number): number;
+/** B2bc boundary: h → p, discriminating subregions 2b and 2c.
+ *  Ref: IAPWS-IF97, Eq. 20. Check point: h = 3516.004323 → p = 100 MPa. */
 export declare function b2bc_H_P(h: number): number;
-/** B3ab boundary: P → H */
-export declare function b3ab_P_to_H(p: number): number;
-/** R4: enthalpy → saturation pressure for PH boundary detection */
-export declare function r4EnthalpyToPsat(h: number): number;
+export declare function r2BackwardT(p: number, h: number): number;
+export declare function r3BackwardPHInitial(p: number, h: number): {
+    rho: number;
+    T: number;
+};
 /**
  * Solve for thermodynamic state given P and H.
  * @param p - Pressure [MPa]
  * @param h - Specific enthalpy [kJ/kg]
  */
 export declare function solvePH(p: number, h: number): BasicProperties;
-//# sourceMappingURL=ph.d.ts.map

package/dist/backward/ph.js

@@ -16,10 +16,9 @@ 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 { dampedNewton2D } from '../solvers/damped-newton-2d.js';
 import { validateBackwardState } from './solution-validation.js';
-import { backwardConstraintTolerance } from './tolerances.js';
-import { sumNormalizedResiduals } from './objective-normalization.js';
+import { helmholtzPropertyDerivatives } from './thermodynamic-derivatives.js';
 import { mixSaturationState, qualityFromSaturationProperty, saturationEndpointsAtPressure, } from '../saturation/common.js';
 import { assertCriticalRegion4PHInput, assertRegion4StateAllowed, } from '../saturation/region4-boundaries.js';
 // ─── Backward Polynomial Evaluator ─────────────────────────────────────────
@@ -39,7 +38,7 @@ const R1_PH = [
     [3, 10, 6.6456186191635e-8], [3, 32, 8.0670734103027e-11], [4, 32, -9.3477771213947e-13],
     [5, 32, 5.8265442020601e-15], [6, 32, -1.5020185953503e-17],
 ];
-function r1BackwardT(p, h) {
+export function r1BackwardT(p, h) {
     return evalPoly(R1_PH, 0, -1, p, h / 2500);
 }
 // ─── Region 2 Backward T(P,H) ─────────────────────────────────────────────
@@ -47,9 +46,10 @@ function r1BackwardT(p, h) {
 // 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)
+/** B2bc boundary: h → p, discriminating subregions 2b and 2c.
+ *  Ref: IAPWS-IF97, Eq. 20. Check point: h = 3516.004323 → p = 100 MPa. */
 export function b2bc_H_P(h) {
-    return 0.90584278514723e-3 - 0.67955786399241 * h + 0.12809002730136e-3 * h * h;
+    return 0.90584278514723e3 - 0.67955786399241 * h + 0.12809002730136e-3 * h * h;
 }
 // Subregion 2a — Eq. 22
 const R2A_PH = [
@@ -96,7 +96,7 @@ const R2C_PH = [
 function r2cBackwardT(p, h) {
     return evalPoly(R2C_PH, -25, 1.8, p, h / 2000);
 }
-function r2BackwardT(p, h) {
+export function r2BackwardT(p, h) {
     let T;
     if (p <= C.R2_P_CRT) {
         T = r2aBackwardT(p, h);
@@ -119,7 +119,7 @@ function r2BackwardT(p, h) {
 }
 // ─── Region 3 Backward T(P,H) and v(P,H) ──────────────────────────────────
 /** B3ab boundary: P → H */
-export function b3ab_P_to_H(p) {
+function b3ab_P_to_H(p) {
     return 2014.64004206875 + 3.74696550136983 * p - 0.0219921901054187 * p * p + 0.000087513168600995 * p * p * p;
 }
 const R3A_PH_T = [
@@ -173,22 +173,36 @@ const R3B_PH_V = [
     [-1, 5, -11.8035753702231], [0, 0, 0.169490044091791], [1, 0, -0.0179967222507787],
     [1, 1, 0.0371810116332674], [2, 2, -0.0536288335065096], [2, 6, 1.6069710109252],
 ];
-// R4: saturation pressure boundary from enthalpy
-const R4_H_PSAT = [
-    [0, 0, 0.600073641753024], [1, 1, -9.36203654849857], [1, 3, 24.6590798594147],
-    [1, 4, -107.014222858224], [1, 36, -9.15821315805768e13], [5, 3, -8625.32011700662],
-    [7, 0, -23.5837344740032], [8, 24, 2.52304969384128e17], [14, 16, -3.89718771997719e18],
-    [20, 16, -3.33775713645296e22], [22, 3, 3.56499469636328e10], [24, 18, -1.48547544720641e26],
-    [28, 8, 3.30611514838798e18], [36, 24, 8.13641294467829e37],
-];
-/** R4: enthalpy → saturation pressure for PH boundary detection */
-export function r4EnthalpyToPsat(h) {
-    const mu = h / 2600;
-    let p = 0;
-    for (const [I, J, N] of R4_H_PSAT) {
-        p += N * Math.pow(mu - 1.02, I) * Math.pow(mu - 0.608, J);
+export function r3BackwardPHInitial(p, h) {
+    if (h < b3ab_P_to_H(p)) {
+        const T = 760 * evalPoly(R3A_PH_T, -0.240, 0.615, p / 100, h / 2300);
+        const v = 0.0028 * evalPoly(R3A_PH_V, -0.128, 0.727, p / 100, h / 2100);
+        return { rho: 1 / v, T };
     }
-    return 22 * p;
+    const T = 860 * evalPoly(R3B_PH_T, -0.298, 0.720, p / 100, h / 2800);
+    const v = 0.0088 * evalPoly(R3B_PH_V, -0.0661, 0.720, p / 100, h / 2800);
+    return { rho: 1 / v, T };
+}
+function solveRegion3PH(p, h, rho0, T0) {
+    const pScale = Math.max(1, Math.abs(p));
+    const hScale = Math.max(1, Math.abs(h));
+    const [rho, T] = dampedNewton2D(([candidateRho, candidateT]) => {
+        const state = region3ByRhoT(candidateRho, candidateT);
+        const derivatives = helmholtzPropertyDerivatives(state, candidateRho);
+        return {
+            residual: [
+                (state.pressure - p) / pScale,
+                (state.enthalpy - h) / hScale,
+            ],
+            jacobian: [
+                [derivatives.dpDrho / pScale, derivatives.dpDT / pScale],
+                [derivatives.dhDrho / hScale, derivatives.dhDT / hScale],
+            ],
+        };
+    }, [rho0, T0], {
+        isValid: ([candidateRho, candidateT]) => candidateRho > 0 && candidateT > 0,
+    });
+    return region3ByRhoT(rho, T);
 }
 // ─── Main PH Solver ────────────────────────────────────────────────────────
 /**
@@ -210,7 +224,7 @@ export function solvePH(p, h) {
     switch (region) {
         case Region.Region1: {
             const T0 = r1BackwardT(p, h);
-            const T = newtonRaphson((T_x) => region1(p, T_x).enthalpy - h, T0);
+            const T = newtonRaphson((T_x) => region1(p, T_x).enthalpy - h, T0, (T_x) => region1(p, T_x).cp ?? Number.NaN);
             return validateBackwardState(region1(p, T), [
                 { label: 'pressure', expected: p },
                 { label: 'enthalpy', expected: h },
@@ -218,33 +232,17 @@ export function solvePH(p, h) {
         }
         case Region.Region2: {
             const T0 = r2BackwardT(p, h);
-            const T = newtonRaphson((T_x) => region2(p, T_x).enthalpy - h, T0);
+            const T = newtonRaphson((T_x) => region2(p, T_x).enthalpy - h, T0, (T_x) => region2(p, T_x).cp ?? Number.NaN);
             return validateBackwardState(region2(p, T), [
                 { label: 'pressure', expected: p },
                 { label: 'enthalpy', expected: h },
             ], { solverName: 'solvePH', expectedRegion: Region.Region2 });
         }
         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);
-                v0 = 0.0028 * evalPoly(R3A_PH_V, -0.128, 0.727, p / 100, h / 2100);
-            }
-            else {
-                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) => {
-                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]), [
+            const initial = r3BackwardPHInitial(p, h);
+            const state = solveRegion3PH(p, h, initial.rho, initial.T);
+            return validateBackwardState(state, [
                 { label: 'pressure', expected: p, tolerance: pressureTolerance },
                 { label: 'enthalpy', expected: h },
             ], { solverName: 'solvePH', expectedRegion: Region.Region3 });
@@ -259,7 +257,7 @@ export function solvePH(p, h) {
             ], { solverName: 'solvePH', expectedRegion: Region.Region4 });
         }
         case Region.Region5: {
-            const T = newtonRaphson((T_x) => region5(p, T_x).enthalpy - h, 1500);
+            const T = newtonRaphson((T_x) => region5(p, T_x).enthalpy - h, 1500, (T_x) => region5(p, T_x).cp ?? Number.NaN);
             return validateBackwardState(region5(p, T), [
                 { label: 'pressure', expected: p },
                 { label: 'enthalpy', expected: h },
@@ -269,4 +267,3 @@ export function solvePH(p, h) {
             throw new IF97Error(`Cannot determine region for P=${p} MPa, h=${h} kJ/kg`);
     }
 }
-//# sourceMappingURL=ph.js.map

package/dist/backward/ps.d.ts

@@ -10,4 +10,3 @@ import type { BasicProperties } from '../types.js';
  * @param s - Specific entropy [kJ/(kg·K)]
  */
 export declare function solvePS(p: number, s: number): BasicProperties;
-//# sourceMappingURL=ps.d.ts.map

package/dist/backward/ps.js

@@ -12,10 +12,9 @@ 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 { dampedNewton2D } from '../solvers/damped-newton-2d.js';
 import { validateBackwardState } from './solution-validation.js';
-import { backwardConstraintTolerance } from './tolerances.js';
-import { sumNormalizedResiduals } from './objective-normalization.js';
+import { helmholtzPropertyDerivatives } from './thermodynamic-derivatives.js';
 import { mixSaturationState, qualityFromSaturationProperty, saturationEndpointsAtPressure, } from '../saturation/common.js';
 import { assertCriticalRegion4PSInput, assertRegion4StateAllowed, } from '../saturation/region4-boundaries.js';
 function evalPoly(table, piShift, sigShift, pi, sig) {
@@ -90,9 +89,9 @@ function r2BackwardT(p, s) {
         return evalPoly(R2A_PS, 0, 2, p, s / 2);
     }
     if (s >= C.R2_S_CRT) {
-        return evalPoly(R2B_PS, 0, 10, p, s / 0.7853);
+        return evalPoly(R2B_PS, 0, -10, p, -s / 0.7853);
     }
-    return evalPoly(R2C_PS, 0, 2, p, s / 2.9251);
+    return evalPoly(R2C_PS, 0, -2, p, -s / 2.9251);
 }
 // ─── Region 3 Backward T(P,S) and v(P,S) ──────────────────────────────────
 const R3A_PS_T_TABLE = [
@@ -145,6 +144,27 @@ const R3B_PS_V_TABLE = [
     [0, 2, -19.1449143716586], [1, 0, -0.0150448002905284], [1, 2, 14.6407900162154],
     [2, 2, -3.2747778718823],
 ];
+function solveRegion3PS(p, s, rho0, T0) {
+    const pScale = Math.max(1, Math.abs(p));
+    const sScale = Math.max(1, Math.abs(s));
+    const [rho, T] = dampedNewton2D(([candidateRho, candidateT]) => {
+        const state = region3ByRhoT(candidateRho, candidateT);
+        const derivatives = helmholtzPropertyDerivatives(state, candidateRho);
+        return {
+            residual: [
+                (state.pressure - p) / pScale,
+                (state.entropy - s) / sScale,
+            ],
+            jacobian: [
+                [derivatives.dpDrho / pScale, derivatives.dpDT / pScale],
+                [derivatives.dsDrho / sScale, derivatives.dsDT / sScale],
+            ],
+        };
+    }, [rho0, T0], {
+        isValid: ([candidateRho, candidateT]) => candidateRho > 0 && candidateT > 0,
+    });
+    return region3ByRhoT(rho, T);
+}
 // ─── Main PS Solver ────────────────────────────────────────────────────────
 /**
  * Solve for thermodynamic state given P and S.
@@ -165,7 +185,7 @@ export function solvePS(p, s) {
     switch (region) {
         case Region.Region1: {
             const T0 = r1BackwardT(p, s);
-            const T = newtonRaphson((T_x) => region1(p, T_x).entropy - s, T0);
+            const T = newtonRaphson((T_x) => region1(p, T_x).entropy - s, T0, (T_x) => (region1(p, T_x).cp ?? Number.NaN) / T_x);
             return validateBackwardState(region1(p, T), [
                 { label: 'pressure', expected: p },
                 { label: 'entropy', expected: s },
@@ -173,7 +193,7 @@ export function solvePS(p, s) {
         }
         case Region.Region2: {
             const T0 = r2BackwardT(p, s);
-            const T = newtonRaphson((T_x) => region2(p, T_x).entropy - s, T0);
+            const T = newtonRaphson((T_x) => region2(p, T_x).entropy - s, T0, (T_x) => (region2(p, T_x).cp ?? Number.NaN) / T_x);
             return validateBackwardState(region2(p, T), [
                 { label: 'pressure', expected: p },
                 { label: 'entropy', expected: s },
@@ -181,7 +201,6 @@ export function solvePS(p, s) {
         }
         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);
@@ -191,14 +210,8 @@ 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) => {
-                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]), [
+            const state = solveRegion3PS(p, s, 1 / v0, T0);
+            return validateBackwardState(state, [
                 { label: 'pressure', expected: p, tolerance: pressureTolerance },
                 { label: 'entropy', expected: s },
             ], { solverName: 'solvePS', expectedRegion: Region.Region3 });
@@ -213,7 +226,7 @@ export function solvePS(p, s) {
             ], { solverName: 'solvePS', expectedRegion: Region.Region4 });
         }
         case Region.Region5: {
-            const T = newtonRaphson((T_x) => region5(p, T_x).entropy - s, 1500);
+            const T = newtonRaphson((T_x) => region5(p, T_x).entropy - s, 1500, (T_x) => (region5(p, T_x).cp ?? Number.NaN) / T_x);
             return validateBackwardState(region5(p, T), [
                 { label: 'pressure', expected: p },
                 { label: 'entropy', expected: s },
@@ -223,4 +236,3 @@ export function solvePS(p, s) {
             throw new IF97Error(`Cannot determine region for P=${p} MPa, s=${s} kJ/(kg·K)`);
     }
 }
-//# sourceMappingURL=ps.js.map

package/dist/backward/solution-validation.d.ts

@@ -10,4 +10,3 @@ export interface BackwardValidationOptions {
     expectedRegion?: Region;
 }
 export declare function validateBackwardState(state: BasicProperties, constraints: readonly BackwardConstraint[], options: BackwardValidationOptions): BasicProperties;
-//# sourceMappingURL=solution-validation.d.ts.map

package/dist/backward/solution-validation.js

@@ -17,6 +17,34 @@ function propertyValue(state, label) {
             return Number.NaN;
     }
 }
+function boundaryTolerance(value, boundary) {
+    return 1e-9 * Math.max(1, Math.abs(value), Math.abs(boundary));
+}
+function snapUpFromBelow(value, boundary) {
+    return value < boundary && boundary - value <= boundaryTolerance(value, boundary)
+        ? boundary
+        : value;
+}
+function snapDownFromAbove(value, boundary) {
+    return value > boundary && value - boundary <= boundaryTolerance(value, boundary)
+        ? boundary
+        : value;
+}
+function normalizeComputedPT(state) {
+    let pressure = snapUpFromBelow(state.pressure, C.P_MIN);
+    pressure = snapDownFromAbove(pressure, state.region === Region.Region5 ? C.R5_P_MAX : C.P_MAX);
+    let temperature = snapUpFromBelow(state.temperature, C.T_MIN);
+    if (state.region === Region.Region1) {
+        temperature = snapDownFromAbove(temperature, C.R2_T_MIN);
+    }
+    else if (state.region === Region.Region2) {
+        temperature = snapDownFromAbove(temperature, C.R2_T_MAX);
+    }
+    temperature = snapDownFromAbove(temperature, C.T_MAX);
+    return pressure === state.pressure && temperature === state.temperature
+        ? state
+        : { ...state, pressure, temperature };
+}
 function validateBasicEnvelope(state, solverName) {
     if (!Number.isFinite(state.pressure) || !Number.isFinite(state.temperature) ||
         !Number.isFinite(state.specificVolume) || state.specificVolume <= 0) {
@@ -77,9 +105,9 @@ function withExactConstraints(state, constraints) {
     return normalized;
 }
 export function validateBackwardState(state, constraints, options) {
-    validateBasicEnvelope(state, options.solverName);
-    validateRegionConsistency(state, options.solverName, options.expectedRegion);
-    validateConstraints(state, constraints, options.solverName);
-    return withExactConstraints(state, constraints);
+    const normalized = normalizeComputedPT(state);
+    validateBasicEnvelope(normalized, options.solverName);
+    validateRegionConsistency(normalized, options.solverName, options.expectedRegion);
+    validateConstraints(normalized, constraints, options.solverName);
+    return withExactConstraints(normalized, constraints);
 }
-//# sourceMappingURL=solution-validation.js.map

package/dist/backward/th.d.ts

@@ -22,4 +22,3 @@ import type { BasicProperties } from '../types.js';
  * @throws {IF97Error} if T is within the critical exclusion band
  */
 export declare function solveTH(T: number, h: number): BasicProperties;
-//# sourceMappingURL=th.d.ts.map

package/dist/backward/th.js

@@ -12,7 +12,6 @@ import { mixSaturationState, qualityFromSaturationProperty, saturationEndpointsA
 import { assertRegion4StateAllowed } from '../saturation/region4-boundaries.js';
 import { solveFixedTemperaturePressure } from './fixed-temperature-solver.js';
 import { validateBackwardState } from './solution-validation.js';
-const extractH = (s) => s.enthalpy;
 /**
  * Solve for full basic thermodynamic state from temperature and enthalpy.
  *
@@ -43,7 +42,7 @@ export function solveTH(T, h) {
     const region = detectRegionTH(T, h);
     switch (region) {
         case Region.Region1:
-            return validateBackwardState(solveFixedTemperaturePressure(region1, T, h, saturationPressure(T), C.P_MAX, extractH, 'solveTH'), [
+            return validateBackwardState(solveFixedTemperaturePressure(region1, T, h, saturationPressure(T), C.P_MAX, 'enthalpy', 'solveTH'), [
                 { label: 'temperature', expected: T },
                 { label: 'enthalpy', expected: h },
             ], {
@@ -56,7 +55,7 @@ export function solveTH(T, h) {
                 : T <= C.B23_T_MAX
                     ? boundary23_T_to_P(T)
                     : C.P_MAX;
-            return validateBackwardState(solveFixedTemperaturePressure(region2, T, h, C.P_MIN, upper, extractH, 'solveTH'), [
+            return validateBackwardState(solveFixedTemperaturePressure(region2, T, h, C.P_MIN, upper, 'enthalpy', 'solveTH'), [
                 { label: 'temperature', expected: T },
                 { label: 'enthalpy', expected: h },
             ], {
@@ -68,7 +67,7 @@ export function solveTH(T, h) {
             const lower = T <= C.Tc
                 ? saturationPressure(T)
                 : boundary23_T_to_P(T);
-            return validateBackwardState(solveFixedTemperaturePressure(solveRegion3PTBasic, T, h, lower, C.P_MAX, extractH, 'solveTH'), [
+            return validateBackwardState(solveFixedTemperaturePressure(solveRegion3PTBasic, T, h, lower, C.P_MAX, 'enthalpy', 'solveTH'), [
                 { label: 'temperature', expected: T },
                 { label: 'enthalpy', expected: h },
             ], {
@@ -86,7 +85,7 @@ export function solveTH(T, h) {
             ], { solverName: 'solveTH', expectedRegion: Region.Region4 });
         }
         case Region.Region5:
-            return validateBackwardState(solveFixedTemperaturePressure(region5, T, h, C.P_MIN, C.R5_P_MAX, extractH, 'solveTH'), [
+            return validateBackwardState(solveFixedTemperaturePressure(region5, T, h, C.P_MIN, C.R5_P_MAX, 'enthalpy', 'solveTH'), [
                 { label: 'temperature', expected: T },
                 { label: 'enthalpy', expected: h },
             ], {
@@ -97,4 +96,3 @@ export function solveTH(T, h) {
             throw new IF97Error(`solveTH cannot determine a valid IF97 state for T=${T} K, h=${h} kJ/kg`);
     }
 }
-//# sourceMappingURL=th.js.map

package/dist/backward/thermodynamic-derivatives.d.ts

@@ -0,0 +1,17 @@
+import type { BasicProperties } from '../types.js';
+export interface GibbsPropertyDerivatives {
+    dhDp: number;
+    dhDT: number;
+    dsDp: number;
+    dsDT: number;
+}
+export interface HelmholtzPropertyDerivatives {
+    dpDrho: number;
+    dpDT: number;
+    dhDrho: number;
+    dhDT: number;
+    dsDrho: number;
+    dsDT: number;
+}
+export declare function gibbsPropertyDerivatives(state: BasicProperties): GibbsPropertyDerivatives;
+export declare function helmholtzPropertyDerivatives(state: BasicProperties, rho: number): HelmholtzPropertyDerivatives;

package/dist/backward/thermodynamic-derivatives.js

@@ -0,0 +1,27 @@
+export function gibbsPropertyDerivatives(state) {
+    const cp = state.cp ?? Number.NaN;
+    const alpha = state.isobaricExpansion ?? Number.NaN;
+    const v = state.specificVolume;
+    const T = state.temperature;
+    return {
+        dhDp: 1000 * v * (1 - T * alpha),
+        dhDT: cp,
+        dsDp: -1000 * v * alpha,
+        dsDT: cp / T,
+    };
+}
+export function helmholtzPropertyDerivatives(state, rho) {
+    const cv = state.cv ?? Number.NaN;
+    const alpha = state.isobaricExpansion ?? Number.NaN;
+    const kappa = state.isothermalCompressibility ?? Number.NaN;
+    const T = state.temperature;
+    const rhoSquaredKappa = rho * rho * kappa;
+    return {
+        dpDrho: 1 / (rho * kappa),
+        dpDT: alpha / kappa,
+        dhDrho: 1000 * (1 - T * alpha) / rhoSquaredKappa,
+        dhDT: cv + 1000 * alpha / (rho * kappa),
+        dsDrho: -1000 * alpha / rhoSquaredKappa,
+        dsDT: cv / T,
+    };
+}

package/dist/backward/tolerances.d.ts

@@ -3,4 +3,3 @@ export declare const BACKWARD_REGION4_QUALITY_TOLERANCE = 0.000001;
 export declare function backwardConstraintTolerance(label: BackwardToleranceLabel, expected: number): number;
 export declare function region4SaturationPressureTolerance(pressure: number): number;
 export declare function backwardSpecificVolumeTolerance(expected: number): number;
-//# sourceMappingURL=tolerances.d.ts.map

package/dist/backward/tolerances.js

@@ -18,4 +18,3 @@ export function region4SaturationPressureTolerance(pressure) {
 export function backwardSpecificVolumeTolerance(expected) {
     return 1e-6 * Math.max(1, Math.abs(expected));
 }
-//# sourceMappingURL=tolerances.js.map

package/dist/backward/ts.d.ts

@@ -22,4 +22,3 @@ import type { BasicProperties } from '../types.js';
  * @throws {IF97Error} if T is within the critical exclusion band
  */
 export declare function solveTS(T: number, s: number): BasicProperties;
-//# sourceMappingURL=ts.d.ts.map

package/dist/backward/ts.js

@@ -12,7 +12,6 @@ import { mixSaturationState, qualityFromSaturationProperty, saturationEndpointsA
 import { assertRegion4StateAllowed } from '../saturation/region4-boundaries.js';
 import { solveFixedTemperaturePressure } from './fixed-temperature-solver.js';
 import { validateBackwardState } from './solution-validation.js';
-const extractS = (s) => s.entropy;
 /**
  * Solve for full basic thermodynamic state from temperature and entropy.
  *
@@ -43,7 +42,7 @@ export function solveTS(T, s) {
     const region = detectRegionTS(T, s);
     switch (region) {
         case Region.Region1:
-            return validateBackwardState(solveFixedTemperaturePressure(region1, T, s, saturationPressure(T), C.P_MAX, extractS, 'solveTS'), [
+            return validateBackwardState(solveFixedTemperaturePressure(region1, T, s, saturationPressure(T), C.P_MAX, 'entropy', 'solveTS'), [
                 { label: 'temperature', expected: T },
                 { label: 'entropy', expected: s },
             ], {
@@ -56,7 +55,7 @@ export function solveTS(T, s) {
                 : T <= C.B23_T_MAX
                     ? boundary23_T_to_P(T)
                     : C.P_MAX;
-            return validateBackwardState(solveFixedTemperaturePressure(region2, T, s, C.P_MIN, upper, extractS, 'solveTS'), [
+            return validateBackwardState(solveFixedTemperaturePressure(region2, T, s, C.P_MIN, upper, 'entropy', 'solveTS'), [
                 { label: 'temperature', expected: T },
                 { label: 'entropy', expected: s },
             ], {
@@ -68,7 +67,7 @@ export function solveTS(T, s) {
             const lower = T <= C.Tc
                 ? saturationPressure(T)
                 : boundary23_T_to_P(T);
-            return validateBackwardState(solveFixedTemperaturePressure(solveRegion3PTBasic, T, s, lower, C.P_MAX, extractS, 'solveTS'), [
+            return validateBackwardState(solveFixedTemperaturePressure(solveRegion3PTBasic, T, s, lower, C.P_MAX, 'entropy', 'solveTS'), [
                 { label: 'temperature', expected: T },
                 { label: 'entropy', expected: s },
             ], {
@@ -86,7 +85,7 @@ export function solveTS(T, s) {
             ], { solverName: 'solveTS', expectedRegion: Region.Region4 });
         }
         case Region.Region5:
-            return validateBackwardState(solveFixedTemperaturePressure(region5, T, s, C.P_MIN, C.R5_P_MAX, extractS, 'solveTS'), [
+            return validateBackwardState(solveFixedTemperaturePressure(region5, T, s, C.P_MIN, C.R5_P_MAX, 'entropy', 'solveTS'), [
                 { label: 'temperature', expected: T },
                 { label: 'entropy', expected: s },
             ], {
@@ -97,4 +96,3 @@ export function solveTS(T, s) {
             throw new IF97Error(`solveTS cannot determine a valid IF97 state for T=${T} K, s=${s} kJ/(kg·K)`);
     }
 }
-//# sourceMappingURL=ts.js.map

package/dist/boundaries.d.ts

@@ -3,4 +3,3 @@
  */
 export { boundary23_T_to_P, boundary23_P_to_T } from './regions/boundaries.js';
 export { region3Volume, region3SatVolume } from './regions/region3-subregions.js';
-//# sourceMappingURL=boundaries.d.ts.map

package/dist/boundaries.js

@@ -3,4 +3,3 @@
  */
 export { boundary23_T_to_P, boundary23_P_to_T } from './regions/boundaries.js';
 export { region3Volume, region3SatVolume } from './regions/region3-subregions.js';
-//# sourceMappingURL=boundaries.js.map

package/dist/constants.d.ts

@@ -28,8 +28,6 @@ export declare const REGION4_PRESSURE_TOLERANCE = 1e-9;
 export declare const REGION4_CRITICAL_HS_TOLERANCE = 0.000001;
 /** Residual tolerance for Region 4 h-s temperature inversion */
 export declare const REGION4_HS_RESIDUAL_TOLERANCE = 1e-10;
-/** Scan resolution used when bracketing Region 4 h-s temperature roots */
-export declare const REGION4_HS_BRACKET_SEGMENTS = 256;
 /** Critical density [kg/m³] */
 export declare const RHOc = 322;
 /** Triple point pressure [MPa] */
@@ -70,8 +68,6 @@ export declare const R2_P_CRT = 4;
 export declare const B23_P_MIN = 16.5291642526;
 /** B23 maximum temperature [K] */
 export declare const B23_T_MAX = 863.15;
-/** Region 3 minimum temperature [K] */
-export declare const R3_T_MIN = 623.15;
 /** Region 3 critical entropy [kJ/(kg·K)] */
 export declare const R3_S_CRT = 4.41202148223476;
 /** Region 3 critical enthalpy [kJ/kg] */
@@ -86,8 +82,3 @@ export declare const R5_T_MAX = 2273.15;
 export declare const B23_S_CURVE_MIN = 5.048096828;
 /** Maximum entropy along the B23 curve [kJ/(kg·K)], at T ≈ 644 K */
 export declare const B23_S_CURVE_MAX = 5.260578707;
-/** Minimum enthalpy along the B23 curve [kJ/kg], at T = 623.15 K (currently unused) */
-export declare const B23_H_CURVE_MIN = 2563.592004;
-/** Maximum enthalpy along the B23 curve [kJ/kg], at T = 863.15 K (currently unused) */
-export declare const B23_H_CURVE_MAX = 2812.942061;
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -30,8 +30,6 @@ export const REGION4_PRESSURE_TOLERANCE = 1e-9;
 export const REGION4_CRITICAL_HS_TOLERANCE = 1e-6;
 /** Residual tolerance for Region 4 h-s temperature inversion */
 export const REGION4_HS_RESIDUAL_TOLERANCE = 1e-10;
-/** Scan resolution used when bracketing Region 4 h-s temperature roots */
-export const REGION4_HS_BRACKET_SEGMENTS = 256;
 /** Critical density [kg/m³] */
 export const RHOc = 322;
 // ─── Triple Point ───────────────────────────────────────────────────────────
@@ -77,8 +75,6 @@ export const B23_P_MIN = 16.5291642526;
 /** B23 maximum temperature [K] */
 export const B23_T_MAX = 863.15;
 // ─── Region 3 Boundaries ───────────────────────────────────────────────────
-/** Region 3 minimum temperature [K] */
-export const R3_T_MIN = 623.15;
 /** Region 3 critical entropy [kJ/(kg·K)] */
 export const R3_S_CRT = 4.41202148223476;
 /** Region 3 critical enthalpy [kJ/kg] */
@@ -90,12 +86,11 @@ export const R5_T_MIN = 1073.15;
 export const R5_P_MAX = 50;
 /** Region 5 maximum temperature [K] */
 export const R5_T_MAX = 2273.15;
-// ─── B23 Curve Extrema (Entropy / Enthalpy) ────────────────────────────────
+// ─── B23 Curve Extrema (Entropy) ───────────────────────────────────────────
 //
 // These are the GLOBAL EXTREMA along the B23 boundary curve, NOT values at
-// the curve endpoints. Entropy has a minimum at T ≈ 777 K and a maximum at
-// T ≈ 644 K. Enthalpy is monotonic: min at the low-T endpoint (623.15 K),
-// max at the high-T endpoint (863.15 K).
+// the curve endpoints: entropy has a minimum at T ≈ 777 K and a maximum at
+// T ≈ 644 K.
 //
 // Ref: Computed from Region 2 properties evaluated along B23(T) for
 //      T ∈ [623.15, 863.15] K.
@@ -103,8 +98,3 @@ export const R5_T_MAX = 2273.15;
 export const B23_S_CURVE_MIN = 5.048096828;
 /** Maximum entropy along the B23 curve [kJ/(kg·K)], at T ≈ 644 K */
 export const B23_S_CURVE_MAX = 5.260578707;
-/** Minimum enthalpy along the B23 curve [kJ/kg], at T = 623.15 K (currently unused) */
-export const B23_H_CURVE_MIN = 2563.592004;
-/** Maximum enthalpy along the B23 curve [kJ/kg], at T = 863.15 K (currently unused) */
-export const B23_H_CURVE_MAX = 2812.942061;
-//# sourceMappingURL=constants.js.map

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

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

package/dist/core/input-validation.js

@@ -4,4 +4,3 @@ export function assertFiniteNumber(parameter, value) {
         throw new IF97Error(`${parameter} must be a finite number`);
     }
 }
-//# sourceMappingURL=input-validation.js.map

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

@@ -1,4 +1,3 @@
 import type { BasicProperties, SteamState } from '../types.js';
 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

@@ -51,4 +51,3 @@ function normalizeSteamState(state) {
 export function normalizePublicState(state) {
     return 'density' in state ? normalizeSteamState(state) : normalizeBasicProperties(state);
 }
-//# sourceMappingURL=public-normalization.js.map

package/dist/core/region-detector.d.ts

@@ -44,4 +44,3 @@ export declare function detectRegionTS(T: number, s: number): Region | -1;
  * @returns Region number (1–5) or -1 if out of range
  */
 export declare function detectRegionHS(h: number, s: number): Region | -1;
-//# sourceMappingURL=region-detector.d.ts.map