pyrestoolbox 3.8.0__tar.gz → 3.8.2__tar.gz

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/Cargo.lock

@@ -152,7 +152,7 @@ dependencies = [
 
 [[package]]
 name = "pyrestoolbox-native"
-version = "3.8.0"
+version = "3.8.2"
 dependencies = [
  "pyo3",
  "rug",

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pyrestoolbox-native"
-version = "3.8.0"
+version = "3.8.2"
 edition = "2021"
 license = "GPL-3.0-or-later"
 description = "Rust acceleration extensions for pyResToolbox"

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrestoolbox
-Version: 3.8.0
+Version: 3.8.2
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pyrestoolbox"
-version = "3.8.0"
+version = "3.8.2"
 description = "pyResToolbox - A collection of Reservoir Engineering Utilities"
 license = {text = "GPL-3.0-or-later"}
 authors = [{name = "Mark W. Burgoyne", email = "mark.w.burgoyne@gmail.com"}]

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/pyrestoolbox/brine/_lib_vle_engine.py

@@ -67,6 +67,14 @@ R_GAS = 8.314462  # J/(mol·K)
 OMEGA_A = 0.45724
 OMEGA_B = 0.07780
 MW_NACL = 58.4428  # NaCl molar weight (matches brine.MWSAL)
+# flash_tp trivial-solution test: max|ln K| below this means both labelled
+# phases collapsed onto one composition (K -> 1). Gas-water K-values sit
+# orders of magnitude from 1, so a genuine split never comes near it.
+TRIVIAL_LNK_TOL = 1e-6
+# Tangent-plane stability (Michelsen 1982, Fluid Phase Equilib. 9:1-19): a
+# non-trivial stationary point with sum(Y) above 1 + this makes the feed
+# unstable. The margin keeps round-off at sum(Y) = 1 from reading as a split.
+STABILITY_TM_TOL = 1e-8
 MW_H2O = 18.015
 
 # H2 critical temperature for BIP correlations (manuscript value, NIST)
@@ -1130,6 +1138,11 @@ def rr_solver(
     return N_it, yi, xi, V, L
 
 
+def _is_trivial_k(K: np.ndarray) -> bool:
+    """True when every K is within TRIVIAL_LNK_TOL of 1 in log terms."""
+    return bool(np.max(np.abs(np.log(K))) < TRIVIAL_LNK_TOL)
+
+
 def solve_rachford_rice(z: np.ndarray, K: np.ndarray) -> Tuple[float, np.ndarray, np.ndarray]:
     """
     Convenience wrapper around rr_solver for flash calculations.
@@ -2059,6 +2072,16 @@ class SWMultiComponentFlash:
             tol: Convergence tolerance on K-values
 
         Returns: V (vapor fraction), x (liquid), y (vapor), converged (bool)
+
+        When successive substitution collapses onto the trivial solution
+        (all K -> 1; e.g. a feed so dilute in gas that the trial vapor stays
+        water-dominated and both phases take the liquid root), a tangent-plane
+        stability test decides. A stable feed returns single phase, converged:
+        V = 0 when water is the majority component (x = z), else V = 1 (y = z).
+        The other composition is the incipient-phase stationary point, or the
+        feed itself when no such phase exists on the cubic. An unstable feed
+        is re-flashed from K seeded by the stability test. converged is False
+        only if the result is still trivial or the test is inconclusive.
         """
         z = np.asarray(z, dtype=float)
         z = z / np.sum(z)
@@ -2107,9 +2130,41 @@ class SWMultiComponentFlash:
             gamma_eff = np.asarray(gamma, dtype=float)
 
         # Initialize K-values (Wilson + gamma for initial estimate)
-        K = self._wilson_k_values(T_K, P_Pa) * gamma_eff
-        K[self.iw] = min(K[self.iw], 0.01)
+        K0 = self._wilson_k_values(T_K, P_Pa) * gamma_eff
+        K0[self.iw] = min(K0[self.iw], 0.01)
+
+        eos = (Ai, Bi, sqrt_Ai, onemk)
+        K, converged = self._ss_iterate(z, K0, eos, gamma_eff, max_iter, tol)
+
+        # SS collapsed onto K = 1: both labelled phases took one composition,
+        # so V says nothing. Settle it with a stability test instead.
+        if _is_trivial_k(K):
+            verdict = self._resolve_trivial(z, K0, eos, gamma_eff, max_iter, tol)
+            if verdict is not None and verdict[0] == 'stable':
+                _, feed_liquid, incipient = verdict
+                if feed_liquid:
+                    return 0.0, z.copy(), incipient, True
+                return 1.0, incipient, z.copy(), True
+            if verdict is not None:
+                K, converged = self._ss_iterate(z, verdict[1], eos, gamma_eff,
+                                                max_iter, tol)
+
+        # Final compositions with converged K
+        V, x, y = solve_rachford_rice(z, K)
+        x = np.clip(x, 1e-15, None)
+        y = np.clip(y, 1e-15, None)
+        x = x / np.sum(x)
+        y = y / np.sum(y)
+        if _is_trivial_k(K):
+            converged = False
+        return V, x, y, converged
 
+    def _ss_iterate(self, z: np.ndarray, K: np.ndarray, eos: tuple,
+                    gamma_eff: np.ndarray, max_iter: int,
+                    tol: float) -> Tuple[np.ndarray, bool]:
+        """Damped successive substitution from K. Returns (K, converged)."""
+        Ai, Bi, sqrt_Ai, onemk = eos
+        K = K.copy()
         converged = False
         damp = 0.5
         prev_err = np.inf
@@ -2145,15 +2200,84 @@ class SWMultiComponentFlash:
             prev_err = err
 
             K = K * (K_new / K)**damp
+        return K, converged
 
-        # Final compositions with converged K
-        V, x, y = solve_rachford_rice(z, K)
-        x = np.clip(x, 1e-15, None)
-        y = np.clip(y, 1e-15, None)
-        x = x / np.sum(x)
-        y = y / np.sum(y)
-        return V, x, y, converged
+    def _stability_trial(self, lnf_feed: np.ndarray, seed: np.ndarray,
+                         trial_phase: str, eos: tuple, ln_gamma: np.ndarray,
+                         max_iter: int, tol: float) -> Optional[Tuple[float, np.ndarray]]:
+        """
+        Tangent-plane stationary point by direct substitution (Michelsen 1982):
+        ln Y_i = ln f_i(z) - ln phi_i(y), less ln gamma_i for a liquid trial.
 
+        Returns (sum Y, normalised y), or None when the cubic fails or the
+        search does not settle (inconclusive).
+        """
+        Ai, Bi, sqrt_Ai, onemk = eos
+        lnY = np.log(np.clip(seed / np.sum(seed), 1e-300, None))
+        for _ in range(max_iter):
+            Y = np.exp(lnY)
+            phi = self._calc_fugacity_fast(Y / np.sum(Y), Ai, Bi, sqrt_Ai, onemk,
+                                           trial_phase)
+            if not np.all(np.isfinite(phi)):
+                return None
+            lnY_new = lnf_feed - np.log(phi)
+            if trial_phase == 'liquid':
+                lnY_new = lnY_new - ln_gamma
+            step = np.max(np.abs(lnY_new - lnY))
+            lnY = lnY_new
+            if step < tol:
+                Y = np.exp(lnY)
+                return float(np.sum(Y)), Y / np.sum(Y)
+        return None
+
+    def _resolve_trivial(self, z: np.ndarray, K0: np.ndarray, eos: tuple,
+                         gamma_eff: np.ndarray, max_iter: int, tol: float):
+        """
+        Stability test on the feed after SS collapsed onto K = 1.
+
+        The feed is taken as aqueous (liquid root, with gamma) when water is
+        the majority component, else as the non-aqueous phase (vapor root).
+        Vapor-like trials seeded from K0*z and from the gas components, and
+        liquid-like trials seeded from z/K0 and from pure water, search for a
+        second phase; any unstable trial wins.
+
+        Returns ('stable', feed_liquid, incipient) where incipient is the
+        opposite-phase stationary point (the feed itself when that trial
+        collapsed, i.e. no such phase exists on the cubic), ('split', K) with
+        K seeded from an unstable trial, or None when inconclusive.
+        """
+        Ai, Bi, sqrt_Ai, onemk = eos
+        feed_liquid = bool(z[self.iw] > 0.5)
+        ln_gamma = np.log(gamma_eff)
+        zc = np.clip(z, 1e-300, None)
+        phi_z = self._calc_fugacity_fast(zc, Ai, Bi, sqrt_Ai, onemk,
+                                         'liquid' if feed_liquid else 'vapor')
+        if not np.all(np.isfinite(phi_z)):
+            return None
+        lnf = np.log(zc) + np.log(phi_z) + (ln_gamma if feed_liquid else 0.0)
+
+        # Wilson-type seeds alone can start water-dominated and collapse onto
+        # the feed even when a split exists, so each trial phase also gets a
+        # near-pure seed: gas-only for the vapor, water-only for the liquid.
+        not_w = np.arange(len(z)) != self.iw
+        gas_seed = np.where(not_w, zc, 0.0) + 1e-10
+        water_seed = np.where(not_w, 1e-10, 1.0)
+        incipient = z.copy()
+        seeds = (('vapor', K0 * zc), ('vapor', gas_seed),
+                 ('liquid', zc / K0), ('liquid', water_seed))
+        for phase, seed in seeds:
+            res = self._stability_trial(lnf, seed, phase, eos, ln_gamma,
+                                        max_iter, tol)
+            if res is None:
+                return None
+            sum_Y, y = res
+            if _is_trivial_k(y / zc):
+                continue
+            if sum_Y > 1.0 + STABILITY_TM_TOL:
+                return 'split', (y / zc if phase == 'vapor' else zc / y)
+            if (phase == 'vapor') == feed_liquid:
+                incipient = y
+        return 'stable', feed_liquid, incipient
 
     def calc_equilibrium(self, T_K: float, P_Pa: float, z: np.ndarray,
                          salinity_method: str = 'gamma_phi',

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/pyrestoolbox/docs/changelist.rst

@@ -1,3 +1,11 @@
+Changelist in 3.8.2:
+
+- **BRINE (internal VLE flash): feeds far from saturation now return a proper single-phase result instead of an arbitrary phase label (GitHub issue #5).** The Soreide-Whitson flash behind ``calc_gas_brine_equilibrium`` (``SWMultiComponentFlash.flash_tp``) used successive substitution with no stability test. When the trial phase started on the feed's side of the cubic, both phases took the same root, the K-values collapsed to 1 and Rachford-Rice reported V = 0 or V = 1 from a rounding-level residual, with ``converged=True``; the Python and Rust paths could disagree on which. This hit about a third of a broad sweep of feeds (very water-rich or very gas-rich). The reported case, 1 kg water with 5e-7 mol each of H2 and CH4 at 1 mol/kg NaCl, 45 degC and 100 bar, came back all vapour. A collapsed iteration is now settled by a Michelsen (1982) tangent-plane stability test with Wilson and near-pure trial phases, in Python and Rust (parity 1.5e-14). A stable feed returns single phase and converged, as aqueous (V = 0, x = feed) when water is the majority component and as the non-aqueous phase (V = 1) otherwise; the other composition is the incipient phase where one exists. An unstable feed is re-flashed from the stability test's K-values. ``converged=False`` is returned only if that still fails. Converged two-phase results are unchanged, so ``SoreideWhitson`` and every documented value are unaffected: the public path flashes gas-excess feeds only. ``SWMultiComponentFlash`` remains internal; there is no public interface for splitting a finite inventory into phase amounts.
+
+Changelist in 3.8.1:
+
+- **NODAL: condensate that drops out in the tubing is treated as a saturated light liquid, not a dead oil.** The gas VLP marches gave dropped-out condensate the Beggs-Robinson dead-oil viscosity (Rs = 0), which is 2-5 times too viscous for a liquid in equilibrium with gas (up to about 16 cP at low temperature) and made the Woldesemayat-Ghajar BHP with dropout exceed the no-dropout value. The dropped liquid now takes the Beggs-Robinson live-oil viscosity at the Standing (1947) solution GOR at local pressure and temperature, with the bubble point at the local pressure (0.25-1.6 cP for 45-55 API condensate), in Python and Rust. Only gas wells with ``pr`` supplied (condensate dropout on) are affected; for 5 MMscf/d with CGR 10, 10 bbl/d water and 3000 psia reservoir pressure (6000 ft tubing), BHP moves from 877.6 to 850.4 psia for WG and from 635.6 to 652.9 psia for HB (its holdup correlation runs through the liquid viscosity number), with Gray and BB within 0.4%. With dropout on, WG BHP is now below the no-dropout value, as it should be with less liquid in the tubing.
+
 Changelist in 3.8.0:
 
 - **NODAL: water viscosity in the VLP marches comes from the library's brine model (documented values move).** The marches used a private water-viscosity formula that evaluated a natural-log fit in degC as a base-10 fit in degF, so water viscosity was 12-30x too low (0.054 cP at 100 degF against 0.68; floored at 0.01 cP above about 200 degF), understating liquid friction and holdup in every method. Both the Python and Rust marches now use the same gas-free brine viscosity ``brine_props`` reports (IAPWS-2008 water with IF97 density, Jones-Dole NaCl ratio, Kestin pressure factor), with the salinity taken from ``wsg`` via McCain's gamma_w = 1 + 0.695e-6 ppm; Rust carries a port of that chain matching Python to 1e-14. Wells without water are unchanged. With water the change is modest for small water rates (the documented gas examples with 10 bbl/d move by -0.1 to -45.6 psi; WG moves most because realistic viscosity puts the liquid Reynolds number below Chisholm's laminar threshold) and larger with more water (5 MMscf/d with 500 bbl/d: HB +9%, WG +5%). The pure-Python march is slower (about 15 ms per ``fbhp`` against 3); the Rust path is about 0.2-0.3 ms.

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/pyrestoolbox/nodal/nodal.py

@@ -1048,8 +1048,17 @@ def _condensate_dropout(cgr, qg_mmscfd, p_avg, pr, osg, qw_bwpd, wsg):
 
 
 def _condensate_vis(pr, cgr_local, gsg, api, temp_f, p_avg, oil_vis):
+    """Viscosity (cP) of condensate dropped out in the tubing.
+
+    The dropped liquid is in equilibrium with the gas at the local pressure, so
+    it is a saturated live liquid: Beggs-Robinson live-oil viscosity at the
+    Standing (1947) solution GOR at local p and T, with Pb = p. Before 3.8.1 it
+    was given the dead-oil viscosity (Rs = 0), 2-5x too viscous for a light
+    condensate (up to ~16 cP at low temperature).
+    """
     if pr > 14.7 and cgr_local > 0.01:
-        return _oil_viscosity_full(gsg, api, temp_f, rsb=0.0, pb=14.7,
+        rs_sat = _standing_rs(gsg, p_avg, temp_f, api)
+        return _oil_viscosity_full(gsg, api, temp_f, rsb=rs_sat, pb=p_avg,
                                    press_psia=p_avg)
     return oil_vis
 

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/src/vle/flash.rs

@@ -12,6 +12,17 @@ use crate::vle::fugacity::calc_fugacity_fast;
 use crate::vle::k_init::sw_kvalue_init;
 use crate::vle::rachford_rice::solve_rachford_rice;
 
+/// Trivial-solution test for `flash_tp`: max|ln K| below this means both
+/// labelled phases collapsed onto one composition (K -> 1). Gas-water K-values
+/// sit orders of magnitude from 1, so a genuine split never comes near it.
+/// Same value as Python `_lib_vle_engine.TRIVIAL_LNK_TOL`.
+const TRIVIAL_LNK_TOL: f64 = 1e-6;
+
+/// Tangent-plane stability (Michelsen 1982, Fluid Phase Equilib. 9:1-19): a
+/// non-trivial stationary point with sum(Y) above 1 + this makes the feed
+/// unstable. Same value as Python `_lib_vle_engine.STABILITY_TM_TOL`.
+const STABILITY_TM_TOL: f64 = 1e-8;
+
 /// Precomputed EOS quantities that are constant across SS iterations (T,P fixed).
 struct EosPrecomputed {
     ai_dim: Vec<f64>,  // Dimensionless Ai = ai*P/(RT)^2
@@ -110,7 +121,14 @@ fn precompute_eos(
 /// * `tol` - Convergence tolerance on K-values
 ///
 /// # Returns
-/// (V, x, y, converged) - vapor fraction, liquid comp, vapor comp, convergence flag
+/// (V, x, y, converged) - vapor fraction, liquid comp, vapor comp, convergence flag.
+/// When successive substitution collapses onto the trivial solution (all
+/// K -> 1), a tangent-plane stability test decides: a stable feed returns
+/// single phase, converged (V = 0 with x = z when water is the majority
+/// component, else V = 1 with y = z; the other composition is the incipient
+/// stationary point, or the feed when none exists); an unstable feed is
+/// re-flashed from the trial's K. `converged` is false only if the result is
+/// still trivial or the test is inconclusive. Port of Python `flash_tp`.
 pub fn flash_tp(
     t_k: f64,
     p_pa: f64,
@@ -149,22 +167,68 @@ pub fn flash_tp(
 
     // Initialize K-values (SW-specific + gamma for initial estimate)
     let k_init = sw_kvalue_init(comp_indices, &tc, &pc, &omega, t_k, p_pa);
-    let mut k_vals: Vec<f64> = k_init
+    let mut k0: Vec<f64> = k_init
         .iter()
         .zip(gamma.iter())
         .map(|(&ki, &gi)| ki * gi)
         .collect();
 
     // Water K should be << 1 in gas-water systems
-    k_vals[iw] = k_vals[iw].min(0.01);
+    k0[iw] = k0[iw].min(0.01);
+
+    let (mut k_vals, mut converged) = ss_iterate(&z_norm, &k0, &eos, gamma, nc, max_iter, tol);
+
+    // SS collapsed onto K = 1: both labelled phases took one composition, so
+    // V says nothing. Settle it with a stability test instead.
+    if is_trivial_k(&k_vals) {
+        match resolve_trivial(&z_norm, &k0, &eos, gamma, iw, max_iter, tol) {
+            Some(Verdict::Stable { feed_liquid, incipient }) => {
+                return if feed_liquid {
+                    (0.0, z_norm, incipient, true)
+                } else {
+                    (1.0, incipient, z_norm, true)
+                };
+            }
+            Some(Verdict::Split(k_seed)) => {
+                (k_vals, converged) = ss_iterate(&z_norm, &k_seed, &eos, gamma, nc, max_iter, tol);
+            }
+            None => {}
+        }
+    }
+
+    // Final compositions with converged K
+    let (v, mut x, mut y) = solve_rachford_rice(&z_norm, &k_vals);
+    clip_and_normalize(&mut x);
+    clip_and_normalize(&mut y);
 
+    let converged = converged && !is_trivial_k(&k_vals);
+
+    (v, x, y, converged)
+}
+
+/// True when every K is within `TRIVIAL_LNK_TOL` of 1 in log terms.
+fn is_trivial_k(k: &[f64]) -> bool {
+    k.iter().map(|k| k.ln().abs()).fold(0.0_f64, f64::max) < TRIVIAL_LNK_TOL
+}
+
+/// Damped successive substitution from `k_start`. Returns (K, converged).
+fn ss_iterate(
+    z: &[f64],
+    k_start: &[f64],
+    eos: &EosPrecomputed,
+    gamma: &[f64],
+    nc: usize,
+    max_iter: usize,
+    tol: f64,
+) -> (Vec<f64>, bool) {
+    let mut k_vals = k_start.to_vec();
     let mut converged = false;
     let mut damp: f64 = 0.5;
     let mut prev_err: f64 = f64::INFINITY;
 
     for _it in 0..max_iter {
         // Robust RR solver (Nielsen & Lia 2022)
-        let (_v, mut x, mut y) = solve_rachford_rice(&z_norm, &k_vals);
+        let (_v, mut x, mut y) = solve_rachford_rice(z, &k_vals);
 
         // Clip and normalize
         clip_and_normalize(&mut x);
@@ -206,13 +270,118 @@ pub fn flash_tp(
             k_vals[i] *= (k_new[i] / k_vals[i]).powf(damp);
         }
     }
+    (k_vals, converged)
+}
 
-    // Final compositions with converged K
-    let (v, mut x, mut y) = solve_rachford_rice(&z_norm, &k_vals);
-    clip_and_normalize(&mut x);
-    clip_and_normalize(&mut y);
+/// Outcome of the stability test after a trivial SS exit.
+enum Verdict {
+    /// Feed is one phase; `incipient` is the opposite-phase stationary point
+    /// (the feed itself when that trial collapsed).
+    Stable { feed_liquid: bool, incipient: Vec<f64> },
+    /// Feed splits; K seeded from the unstable trial.
+    Split(Vec<f64>),
+}
 
-    (v, x, y, converged)
+/// Tangent-plane stationary point by direct substitution (Michelsen 1982):
+/// ln Y_i = ln f_i(z) - ln phi_i(y), less ln gamma_i for a liquid trial.
+/// Returns (sum Y, normalised y), or None when phi is non-finite or the
+/// search does not settle. Port of Python `_stability_trial`.
+#[allow(clippy::too_many_arguments)]
+fn stability_trial(
+    lnf_feed: &[f64],
+    seed: &[f64],
+    liquid: bool,
+    eos: &EosPrecomputed,
+    ln_gamma: &[f64],
+    nc: usize,
+    max_iter: usize,
+    tol: f64,
+) -> Option<(f64, Vec<f64>)> {
+    let seed_sum: f64 = seed.iter().sum();
+    let mut ln_y: Vec<f64> = seed.iter().map(|&s| (s / seed_sum).max(1e-300).ln()).collect();
+    for _ in 0..max_iter {
+        let big_y: Vec<f64> = ln_y.iter().map(|v| v.exp()).collect();
+        let y_sum: f64 = big_y.iter().sum();
+        let y: Vec<f64> = big_y.iter().map(|v| v / y_sum).collect();
+        let phi = calc_fugacity_fast(&y, &eos.ai_dim, &eos.bi_dim, &eos.sqrt_ai, &eos.onemk, nc, liquid);
+        if !phi.iter().all(|p| p.is_finite()) {
+            return None;
+        }
+        let mut step = 0.0_f64;
+        for i in 0..nc {
+            let mut v = lnf_feed[i] - phi[i].ln();
+            if liquid {
+                v -= ln_gamma[i];
+            }
+            step = step.max((v - ln_y[i]).abs());
+            ln_y[i] = v;
+        }
+        if step < tol {
+            let big_y: Vec<f64> = ln_y.iter().map(|v| v.exp()).collect();
+            let y_sum: f64 = big_y.iter().sum();
+            return Some((y_sum, big_y.iter().map(|v| v / y_sum).collect()));
+        }
+    }
+    None
+}
+
+/// Stability test on the feed after SS collapsed onto K = 1. The feed is
+/// taken as aqueous (liquid root, with gamma) when water is the majority
+/// component, else as the non-aqueous phase (vapor root). Vapor-like trials
+/// seeded from K0*z and from the gas components, and liquid-like trials seeded
+/// from z/K0 and from pure water, search for a second phase; any unstable
+/// trial wins. Port of Python `_resolve_trivial`.
+fn resolve_trivial(
+    z: &[f64],
+    k0: &[f64],
+    eos: &EosPrecomputed,
+    gamma: &[f64],
+    iw: usize,
+    max_iter: usize,
+    tol: f64,
+) -> Option<Verdict> {
+    let nc = z.len();
+    let feed_liquid = z[iw] > 0.5;
+    let ln_gamma: Vec<f64> = gamma.iter().map(|g| g.ln()).collect();
+    let zc: Vec<f64> = z.iter().map(|&v| v.max(1e-300)).collect();
+    let phi_z = calc_fugacity_fast(&zc, &eos.ai_dim, &eos.bi_dim, &eos.sqrt_ai, &eos.onemk, nc, feed_liquid);
+    if !phi_z.iter().all(|p| p.is_finite()) {
+        return None;
+    }
+    let lnf: Vec<f64> = (0..nc)
+        .map(|i| zc[i].ln() + phi_z[i].ln() + if feed_liquid { ln_gamma[i] } else { 0.0 })
+        .collect();
+
+    // Wilson-type seeds alone can start water-dominated and collapse onto the
+    // feed even when a split exists, so each trial phase also gets a near-pure
+    // seed: gas-only for the vapor, water-only for the liquid.
+    let gas_seed: Vec<f64> = (0..nc).map(|i| if i == iw { 0.0 } else { zc[i] } + 1e-10).collect();
+    let water_seed: Vec<f64> = (0..nc).map(|i| if i == iw { 1.0 } else { 1e-10 }).collect();
+    let wilson_vap: Vec<f64> = (0..nc).map(|i| k0[i] * zc[i]).collect();
+    let wilson_liq: Vec<f64> = (0..nc).map(|i| zc[i] / k0[i]).collect();
+    let seeds: [(bool, &[f64]); 4] = [
+        (false, &wilson_vap),
+        (false, &gas_seed),
+        (true, &wilson_liq),
+        (true, &water_seed),
+    ];
+
+    let mut incipient = z.to_vec();
+    for (liquid, seed) in seeds {
+        let (sum_y, y) = stability_trial(&lnf, seed, liquid, eos, &ln_gamma, nc, max_iter, tol)?;
+        let k_trial: Vec<f64> = (0..nc).map(|i| y[i] / zc[i]).collect();
+        if is_trivial_k(&k_trial) {
+            continue;
+        }
+        if sum_y > 1.0 + STABILITY_TM_TOL {
+            let k_seed = if liquid { k_trial.iter().map(|k| 1.0 / k).collect() } else { k_trial };
+            return Some(Verdict::Split(k_seed));
+        }
+        if liquid != feed_liquid {
+            incipient = y;
+        }
+    }
+    Some(Verdict::Stable { feed_liquid, incipient })
 }
 
 /// Clip compositions to [1e-15, inf) and normalize.

{pyrestoolbox-3.8.0 → pyrestoolbox-3.8.2}/src/vlp/march.rs

@@ -86,8 +86,11 @@ fn condensate_vis(
     pr: f64, cgr_local: f64, gsg: f64, api: f64, temp_f: f64,
     p_avg: f64, oil_vis: f64,
 ) -> f64 {
+    // Dropped condensate is a saturated live liquid: Beggs-Robinson at the
+    // Standing solution GOR at local p, T with Pb = p (mirrors Python _condensate_vis)
     if pr > 14.7 && cgr_local > 0.01 {
-        oil_viscosity_full(gsg, api, temp_f, 0.0, 14.7, p_avg, 1.0, 1.0)
+        let rs_sat = standing_rs(gsg, p_avg, temp_f, api);
+        oil_viscosity_full(gsg, api, temp_f, rs_sat, p_avg, p_avg, 1.0, 1.0)
     } else {
         oil_vis
     }