pyrestoolbox 3.8.4__tar.gz → 3.8.5__tar.gz

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.5}/Cargo.lock

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

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.5}/Cargo.toml

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

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.5}/PKG-INFO

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

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pyrestoolbox"
-version = "3.8.4"
+version = "3.8.5"
 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.4 → pyrestoolbox-3.8.5}/pyrestoolbox/docs/changelist.rst

@@ -1,3 +1,9 @@
+Changelist in 3.8.5:
+
+- **NODAL: gas VLP uses the ``gas_pvt`` Z-factor and viscosity methods (results move when a GasPVT is passed).** ``fbhp``, ``fthp``, ``outflow_curve``, ``operating_point`` and the simtools VFP tables took only the gas SG and Sutton/Wichert-Aziz pseudo-criticals from a ``GasPVT``; the march always ran Hall-Yarborough Z with Lee-Gonzalez-Eakin viscosity, so ``zmethod='BNS'`` (or the GasPVT default, DAK with PMC) was silently ignored, as were H2 and He (which raised a warning). The march now evaluates Z and viscosity exactly as ``gas_pvt.z()`` and ``gas_pvt.viscosity()`` do, at every step and in the zero-rate static column, in Python and Rust (the Rust march builds the same Z/viscosity evaluator as ``gas_dmp``, so every method stays accelerated; the two paths agree to 1e-9 relative). Calls without ``gas_pvt`` are bit-identical. Example (THP 1000 psia, 5 MMscf/d, 100 bbl/d water, 5000 ft of 2.441 in tubing, 80-200 degF, SG 0.65), Beggs-Brill BHP: 1475.3 psia before, 1459.3 with ``GasPVT(sg=0.65)`` (DAK/PMC), 1508.2 with ``zmethod='BNS'``; WG 1444.8, 1444.1, 1446.2. Beggs-Brill moves most because the distributed-to-segregated boundary sits mid-well here and the gradient steps 27% across it. The pure-Python fallback is about 15 times slower with a ``gas_pvt`` (about 40 ms per ``fbhp``), since each step calls ``gas_z`` and ``gas_ug``. No documented example passes a ``gas_pvt`` to the VLP functions, so none moves; one nodal test that asserted a sweet ``GasPVT`` equals the ``gsg``-only answer now compares an HY/SUT ``GasPVT`` (within 4e-5).
+
+- **NODAL: gas VLP results now approach the dry-gas answer continuously as the liquid rate goes to zero.** With no liquid every method returns the single-phase gas BHP, but a vanishing liquid rate did not: in a 5000 ft, 2.441 in well at 1000 psia THP and 5 MMscf/d (dry gas 1232 psia for all four methods), 1e-6 bbl/d of water gave WG 1294, GRAY 1243 and BB 1429 psia, and BB BHP fell as water rose from 0.001 to 1 bbl/d. The causes are in the correlations' low-liquid limits: the Woldesemayat-Ghajar drift-flux void fraction tends to u_sg/(u_sg + u_gm) because the drift velocity does not depend on the amount of liquid, leaving a stagnant liquid holdup u_gm/(u_sg + u_gm) at any liquid rate; Gray's holdup tends to exp(A); and Beggs-Brill holdup scales as lambda^0.58, so its friction parameter y = lambda/HL^2 grows without bound and the two-phase friction multiplier peaks near lambda = 1e-9. Hagedorn-Brown, whose holdup is floored at lambda, was already continuous. The gas segment march now blends each segment's gradient linearly between the method's own zero-liquid gradient and its two-phase gradient while the no-slip liquid fraction is below 1e-3 (``_LOW_LIQ_LAMBDA``, Rust ``LOW_LIQ_LAMBDA``). At zero liquid and at lambda >= 1e-3 results are unchanged; in between they are continuous and BHP rises monotonically with liquid rate. In the example, 1 bbl/d of water now gives WG 1237.5 (was 1298.5), GRAY 1233.3 (1245.8), BB 1241.2 (1335.7) and HB 1232.0 (1232.3) psia; 10 bbl/d gives WG 1300.8 (1312.7), GRAY 1263.3 (1269.2), BB 1324.9 (1338.9), HB 1234.7 (1235.3). Gas wells with a liquid-to-gas ratio above roughly 3 bbl/MMscf at flowing conditions, and every oil-well march, are unaffected. No frozen baseline or documented example moves.
+
 Changelist in 3.8.4:
 
 - **GAS: associated-gas hydrocarbon pseudo-criticals for BNS (``ag``).** Burgoyne, Nielsen & Stanko (2025) fitted two hydrocarbon Tc/Pc correlations, for gas condensates and for associated gas; only the condensate one was exposed. Every gas function that takes ``he`` (except ``gas_sg``, ``gas_hydrate`` and the recommenders, which use no critical properties) now also takes ``ag`` (keyword, appended last): ``gas_tc_pc``, ``gas_z``, ``gas_ug``, ``gas_cg``, ``gas_bg``, ``gas_den``, ``gas_thermal``, ``gas_ponz2p``, ``gas_grad2sg``, ``gas_dmp``, ``gas_rate_radial``, ``gas_rate_linear``, ``GasPVT`` and ``gas_matbal``. ``ag=True`` makes ``cmethod='BNS'`` return the associated-gas values (SG 0.75: Tc 397.7 against 401.2 degR, Pc 653.9 against 663.4 psia), and the hydrocarbon-inert BIPs follow the selected Tc, as in the regression. Other cmethods ignore it and a user ``tc``/``pc`` takes precedence. The resolved values reach the Rust paths through the existing hydrocarbon Tc/Pc override, so the Rust code is unchanged. With ``ag=True``, results match the reference BNS implementation (``AG=True``) to 5e-15 in Z and viscosity and 7e-13 Btu/lb-mol in enthalpy; with ``ag=False`` (the default) every result is bit-identical to 3.8.3 on both paths.

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.5}/pyrestoolbox/docs/nodal.rst

@@ -426,7 +426,7 @@ Returns flowing bottom hole pressure (psia, or barsa if metric=True) using the s
      - 'gas' or 'oil'
    * - gas_pvt
      - GasPVT
-     - Gas PVT object. If provided, extracts gas composition (sg, co2, h2s, n2, h2, he) and method selections for IPR calculations
+     - Gas PVT object. If provided, the gas-well VLP march evaluates Z and gas viscosity with its methods and composition (as ``gas_pvt.z()`` and ``gas_pvt.viscosity()``: DAK with PMC by default, or HY or BNS as configured, impurities and H2/He included), and IPR calculations use the same. Without it the march uses Hall-Yarborough Z on Sutton pseudo-criticals of ``gsg`` with Lee-Gonzalez-Eakin viscosity
    * - oil_pvt
      - OilPVT
      - Oil PVT object. If provided for oil wells, extracts api, sgsp, pb, rsb

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.5}/pyrestoolbox/nodal/nodal.py

@@ -62,6 +62,7 @@ from pyrestoolbox.constants import (BAR_TO_PSI, PSI_TO_BAR, degc_to_degf, degf_t
                                     D_PER_SM3_TO_D_PER_MSCF, D_PER_MSCF_TO_D_PER_SM3,
                                     STB_TO_SM3, SM3_TO_STB)
 import pyrestoolbox.gas as gas
+from pyrestoolbox.gas.gas import _rust_cmethod
 import pyrestoolbox.oil as oil
 from pyrestoolbox.brine.viscosity_route import brine_viscosity as _brine_viscosity
 from pyrestoolbox._accelerator import RUST_AVAILABLE as _RUST_AVAILABLE, rust_accelerated
@@ -273,6 +274,12 @@ _GRAY_ND_COEF = 205.0           # Diameter number coefficient in A
 _GRAY_ROUGH_K = 28.5            # Effective roughness coefficient
 _GRAY_R_THRESH = 0.007          # R threshold for roughness interpolation
 _GRAY_SP_LIQ_FRAC = 1e-6        # v_sg/v_m below this is single-phase liquid (dry roughness)
+# Below this no-slip liquid fraction the two-phase gradient is blended
+# linearly toward the method's own zero-liquid gradient (weight lambda/_LOW_LIQ_LAMBDA).
+# WG drift-flux and Gray holdup tend to finite values as liquid vanishes and
+# Beggs-Brill's friction parameter y = lambda/HL^2 grows without bound, so
+# without the blend a trace of liquid moved dry-gas BHP by up to 16%.
+_LOW_LIQ_LAMBDA = 1e-3
 _GRAY_ROUGH_FLOOR = 2.77e-5     # Minimum effective roughness (ft)
 
 # ============================================================================
@@ -372,31 +379,25 @@ class _FlowInputs:
     gsg: float = 0.65
     vis_frac: float = 1.0
     rsb_frac: float = 1.0
-    tc: Optional[float] = None   # pseudo-critical T (deg R); None -> Sutton from gsg in the march
-    pc: Optional[float] = None   # pseudo-critical P (psia); None -> Sutton from gsg in the march
+    # Gas Z/viscosity spec from GasPVT (_gas_pvt_zspec); None -> Hall-Yarborough
+    # on Sutton pseudo-criticals of gsg with Lee-Gonzalez-Eakin viscosity
+    zspec: Optional[tuple] = None
 
 
-def _gas_pvt_tc_pc(gas_pvt):
-    """Mixture pseudo-criticals for the VLP march from a GasPVT object.
+def _gas_pvt_zspec(gas_pvt):
+    """Z-factor and viscosity specification for the VLP march from a GasPVT.
 
-    The march runs Hall-Yarborough on Sutton pseudo-criticals of the total-gas
-    sg. User-supplied tc/pc are honoured as given; otherwise, when the object
-    carries CO2/H2S/N2, Sutton + Wichert-Aziz is applied so impurities reach the
-    Z-factor as they already do in ipr_curve. Sweet gas returns (None, None) so
-    the march path is untouched. BNS-style tc/pc are hydrocarbon-only and are
-    not usable with a single-pseudo-component Z-factor, hence the SUT call here.
+    Returns (zmethod, cmethod, sg, [co2, h2s, n2, h2, he], tc, pc) with the
+    object's resolved methods and effective critical properties, so the march
+    evaluates Z and viscosity exactly as gas_pvt.z() and gas_pvt.viscosity()
+    do (Python via gas_z/gas_ug, Rust via the same GasState as gas_dmp). PMC
+    travels as 'SUT' with its already-resolved tc/pc, which gas_z treats as a
+    mixture override, as the Rust batch paths do.
     """
-    if getattr(gas_pvt, '_user_tc_pc', False):
-        return gas_pvt.tc, gas_pvt.pc
-    if gas_pvt.h2 > 0 or getattr(gas_pvt, 'he', 0) > 0:
-        warnings.warn(
-            "VLP correlations use a Hall-Yarborough Z-factor with Sutton + Wichert-Aziz "
-            "pseudo-criticals; the H2 and He fractions on gas_pvt are ignored in the wellbore march.",
-            RuntimeWarning, stacklevel=3)
-    if gas_pvt.co2 > 0 or gas_pvt.h2s > 0 or gas_pvt.n2 > 0:
-        return gas.gas_tc_pc(gas_pvt.sg, co2=gas_pvt.co2, h2s=gas_pvt.h2s,
-                             n2=gas_pvt.n2, cmethod='SUT')
-    return None, None
+    return (gas_pvt.zmethod.name, _rust_cmethod(gas_pvt.cmethod), float(gas_pvt.sg),
+            [float(gas_pvt.co2), float(gas_pvt.h2s), float(gas_pvt.n2),
+             float(gas_pvt.h2), float(getattr(gas_pvt, 'he', 0))],
+            float(gas_pvt.tc), float(gas_pvt.pc))
 
 
 def _prepare_flow_inputs(well_type, metric, gas_pvt=None, oil_pvt=None,
@@ -435,7 +436,7 @@ def _prepare_flow_inputs(well_type, metric, gas_pvt=None, oil_pvt=None,
     if gas_pvt is not None and well_type == 'gas':
         if f.gsg == 0.65:
             f.gsg = gas_pvt.sg
-        f.tc, f.pc = _gas_pvt_tc_pc(gas_pvt)
+        f.zspec = _gas_pvt_zspec(gas_pvt)
 
     # OilPVT already holds oilfield units
     if oil_pvt is not None and well_type == 'oil':
@@ -1063,7 +1064,25 @@ def _condensate_vis(pr, cgr_local, gsg, api, temp_f, p_avg, oil_vis):
     return oil_vis
 
 
-def _static_gas_column_pressure(thp, length, tht, bht, gsg, theta=math.pi / 2.0):
+def _march_gas_z_mu(gsg, temp_f, press_psia, tc, pc, zspec, viscosity=True):
+    """(Z, gas viscosity cP) for the gas march.
+
+    zspec None: Hall-Yarborough on (tc, pc) and Lee-Gonzalez-Eakin. Otherwise
+    the GasPVT methods carried by zspec (see _gas_pvt_zspec). viscosity=False
+    returns (Z, None).
+    """
+    if zspec is None:
+        zee = _z_factor(gsg, temp_f, press_psia, tc=tc, pc=pc)
+        mu = _gas_viscosity(gsg, temp_f, press_psia, z=zee, tc=tc, pc=pc) if viscosity else None
+        return zee, mu
+    zmethod, cmethod, sg, (co2, h2s, n2, h2, he), tc_z, pc_z = zspec
+    kw = dict(p=press_psia, sg=sg, degf=temp_f, zmethod=zmethod, cmethod=cmethod,
+              co2=co2, h2s=h2s, n2=n2, h2=h2, he=he, tc=tc_z, pc=pc_z)
+    zee = float(gas.gas_z(**kw))
+    return zee, (float(gas.gas_ug(**kw)) if viscosity else None)
+
+
+def _static_gas_column_pressure(thp, length, tht, bht, gsg, theta=math.pi / 2.0, zspec=None):
     tc, pc = _sutton_tc_pc(gsg)
     n_seg = 50
     d_len = length / n_seg
@@ -1073,7 +1092,7 @@ def _static_gas_column_pressure(thp, length, tht, bht, gsg, theta=math.pi / 2.0)
         frac = (i + 0.5) / n_seg
         temp_local = tht + (bht - tht) * frac
         temp_r = temp_local + 459.67
-        zee = _z_factor(gsg, temp_local, max(p, 14.7), tc=tc, pc=pc)
+        zee, _ = _march_gas_z_mu(gsg, temp_local, max(p, 14.7), tc, pc, zspec, viscosity=False)
         rho_gas = _MW_AIR * gsg * p / (zee * _R_GAS * temp_r)
         p += rho_gas / _IN2_PER_FT2 * d_len * sin_theta
     return p
@@ -1186,11 +1205,11 @@ def _hb_gradient_gas(s):
 def _hb_fbhp_gas(thp, api, gsg, tid, rough, length, tht, bht,
                   wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
                   injection=False, pr=0.0, theta=math.pi / 2.0,
-                  tc=None, pc=None):
+                  zspec=None):
     return _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
                               wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
                               injection, pr, theta, _hb_gradient_gas,
-                              tc=tc, pc=pc)
+                              zspec=zspec)
 
 
 @rust_accelerated('hb_fbhp_oil_rust')
@@ -1312,11 +1331,11 @@ def _wg_gradient_gas(s):
 def _wg_fbhp_gas(thp, api, gsg, tid, rough, length, tht, bht,
                   wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
                   injection=False, pr=0.0, theta=math.pi / 2.0,
-                  tc=None, pc=None):
+                  zspec=None):
     return _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
                               wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
                               injection, pr, theta, _wg_gradient_gas,
-                              tc=tc, pc=pc)
+                              zspec=zspec)
 
 
 @rust_accelerated('wg_fbhp_oil_rust')
@@ -1404,16 +1423,16 @@ def _gray_effective_roughness(rough_dry, sigma, rho_ns, v_sl, v_sg):
 
 def _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
                        wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
-                       injection, pr, theta, gradient_fn, tc=None, pc=None):
+                       injection, pr, theta, gradient_fn, zspec=None):
     """Shared segment march for all gas VLP methods.
 
     gradient_fn(s) -> dpdz (psi/ft)
         Called at each pressure iteration with a dict containing all
         computed PVT/flow properties for the current segment step.
-    tc, pc: mixture pseudo-criticals (deg R, psia); None -> Sutton from gsg.
+    zspec: GasPVT Z/viscosity spec (_gas_pvt_zspec); None -> Hall-Yarborough
+        on Sutton pseudo-criticals of gsg with Lee-Gonzalez-Eakin viscosity.
     """
-    if tc is None or pc is None:
-        tc, pc = _sutton_tc_pc(gsg)
+    tc, pc = _sutton_tc_pc(gsg)
     osg = 141.5 / (api + 131.5)
     total_mass = (_RHO_AIR_STC * gsg * qg_mmscfd * 1e6 +
                   osg * _RHO_FW * cgr * qg_mmscfd * _FT3_PER_BBL +
@@ -1432,7 +1451,7 @@ def _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
                 "the specified liquid rates (liquid loading not modelled).",
                 RuntimeWarning, stacklevel=3
             )
-        return _static_gas_column_pressure(thp, length, tht, bht, gsg, theta=theta)
+        return _static_gas_column_pressure(thp, length, tht, bht, gsg, theta=theta, zspec=zspec)
 
     diam_ft = tid / 12.0
     rough_ft = rough / 12.0
@@ -1466,8 +1485,7 @@ def _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
             oil_vis_loc = _condensate_vis(pr, cgr_loc, gsg, api,
                                           temp_f, p_avg, oil_vis)
 
-            zee = _z_factor(gsg, temp_f, p_avg, tc=tc, pc=pc)
-            mu_g = _gas_viscosity(gsg, temp_f, p_avg, z=zee, tc=tc, pc=pc)
+            zee, mu_g = _march_gas_z_mu(gsg, temp_f, p_avg, tc, pc, zspec)
 
             rho_g = _MW_AIR * gsg * p_avg / (zee * _R_GAS * temp_r)
             rho_l = lsg_loc * _RHO_FW
@@ -1506,7 +1524,7 @@ def _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
                 'qg_mmscfd': qg_mmscfd, 'api': api,
             }
 
-            dpdz = gradient_fn(s)
+            dpdz = _low_liquid_gradient(gradient_fn, s)
             p_est = p_psia + dpdz * seg_len
 
         p_psia = p_est
@@ -1518,6 +1536,25 @@ def _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
     return p_psia
 
 
+def _low_liquid_gradient(gradient_fn, s):
+    """Gradient with a continuous approach to the dry-gas limit.
+
+    For 0 < lambda_l < _LOW_LIQ_LAMBDA returns g0 + (lambda_l/_LOW_LIQ_LAMBDA)(g - g0),
+    where g is the method's two-phase gradient and g0 the same method with the
+    liquid removed (its existing lambda_l = 0 path). At lambda_l = 0 and at or
+    above _LOW_LIQ_LAMBDA this is exactly gradient_fn(s).
+    """
+    g = gradient_fn(s)
+    lam = s['lambda_l']
+    if not 0.0 < lam < _LOW_LIQ_LAMBDA:
+        return g
+    s0 = dict(s, mflow_l=0.0, mflow_o=0.0, mflow_w=0.0, v_sl=0.0,
+              v_m=s['v_sg'], lambda_l=0.0, rho_ns=s['rho_g'],
+              mflow_total=s['mflow_g'], qo_loc=0.0, ql_loc=0.0, qw_bwpd=0.0)
+    g0 = gradient_fn(s0)
+    return g0 + (lam / _LOW_LIQ_LAMBDA) * (g - g0)
+
+
 # ============================================================================
 #  Shared Oil Segment March
 # ============================================================================
@@ -1673,11 +1710,11 @@ def _gray_gradient_gas(s):
 def _gray_fbhp_gas(thp, api, gsg, tid, rough, length, tht, bht,
                     wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
                     injection=False, pr=0.0, theta=math.pi / 2.0,
-                  tc=None, pc=None):
+                  zspec=None):
     return _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
                               wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
                               injection, pr, theta, _gray_gradient_gas,
-                              tc=tc, pc=pc)
+                              zspec=zspec)
 
 
 @rust_accelerated('gray_fbhp_oil_rust')
@@ -1857,12 +1894,12 @@ def _bb_gradient_gas(s):
 def _bb_core_gas(thp, api, gsg, tid, rough, length, tht, bht,
                  wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
                  injection=False, pr=0.0, theta=math.pi / 2.0,
-                  tc=None, pc=None):
+                 zspec=None):
     """Beggs & Brill core for gas wells."""
     return _segment_march_gas(thp, api, gsg, tid, rough, length, tht, bht,
                               wsg, qg_mmscfd, cgr, qw_bwpd, oil_vis,
                               injection, pr, theta, _bb_gradient_gas,
-                              tc=tc, pc=pc)
+                              zspec=zspec)
 
 
 @rust_accelerated('bb_fbhp_oil_rust')
@@ -1975,7 +2012,7 @@ def fbhp(thp: float, completion: 'Completion', vlpmethod: str = 'WG', well_type:
                 length=length, tht=tht_seg, bht=bht_seg, wsg=wsg,
                 qg_mmscfd=f.qg_mmscfd, cgr=f.cgr, qw_bwpd=f.qw_bwpd,
                 oil_vis=oil_vis, injection=injection, pr=f.pr, theta=theta,
-                tc=f.tc, pc=f.pc)
+                zspec=f.zspec)
         else:
             return _OIL_METHOD_DIC[vlpmethod.name](
                 thp=thp_in, api=f.api, gsg=f.gsg, tid=tid, rough=rough,

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.5}/src/pseudopressure.rs

@@ -65,8 +65,9 @@ enum ZMethod {
 ///
 /// These eleven values used to be threaded through eval_z, gl_integrate,
 /// p_over_z and solve_ponz2p_single one argument at a time, and repeated
-/// verbatim at every call site.
-struct GasState<'a> {
+/// verbatim at every call site. Built with `GasState::new`, shared by the
+/// pseudopressure entry points and the VLP gas march.
+pub(crate) struct GasState {
     method: ZMethod,
     deg_r: f64,
     sg: f64,
@@ -81,13 +82,72 @@ struct GasState<'a> {
     n2: f64,
     h2: f64,
     he: f64,
-    lbc_params: &'a Option<gas_viscosity::LbcParams>,
+    lbc_params: Option<gas_viscosity::LbcParams>,
 }
 
-impl GasState<'_> {
+impl GasState {
+    /// Resolve the method and critical properties once for a temperature.
+    ///
+    /// zmethod "DAK", "HY" (cmethod "SUT") or "BNS"/"BUR"; anything else is
+    /// an Err so the caller can fall back to Python. User tc/pc (both > 0)
+    /// replace the mixture Tc/Pc for DAK/HY and only the hydrocarbon
+    /// pseudo-component Tc/Pc for BNS (inert constants and LBC MW unchanged).
+    /// `with_viscosity` precomputes the BNS LBC parameters.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new(
+        degf: f64, sg: f64, zmethod: &str, cmethod: &str,
+        inerts: [f64; 5], tc: f64, pc: f64, with_viscosity: bool,
+    ) -> Result<Self, String> {
+        let [co2, h2s, n2, h2, he] = inerts;
+        let method = match (zmethod, cmethod) {
+            ("DAK", "SUT") => ZMethod::DakSut,
+            ("HY", "SUT") => ZMethod::HySut,
+            ("BNS", _) | ("BUR", _) => ZMethod::Bns,
+            _ => {
+                return Err(format!(
+                    "Rust acceleration not available for zmethod={}, cmethod={}", zmethod, cmethod
+                ));
+            }
+        };
+        let user_tc_pc = tc > 0.0 && pc > 0.0;
+        let (tpc_sut, ppc_sut) = match method {
+            ZMethod::DakSut | ZMethod::HySut => {
+                if user_tc_pc {
+                    (tc, pc)
+                } else {
+                    critical_properties::sutton_wa_internal(sg, co2, h2s, n2)?
+                }
+            }
+            ZMethod::Bns => (0.0, 0.0), // Not used
+        };
+        let (tpc_bns, ppc_bns) = match method {
+            ZMethod::Bns => {
+                if user_tc_pc {
+                    (tc, pc)
+                } else {
+                    let (t, p, _) = critical_properties::bns_pseudocritical_internal(sg, co2, h2s, n2, h2, he);
+                    (t, p)
+                }
+            }
+            _ => (0.0, 0.0),
+        };
+        // LBC parameters honour the HC Tc/Pc override
+        let lbc_params = match method {
+            ZMethod::Bns if with_viscosity => {
+                let (tc_lbc, pc_lbc) = if user_tc_pc { (tc, pc) } else { (0.0, 0.0) };
+                Some(gas_viscosity::lbc_params(degf, sg, co2, h2s, n2, h2, he, tc_lbc, pc_lbc))
+            }
+            _ => None,
+        };
+        Ok(GasState {
+            method, deg_r: degf + DEGF2R, sg, tpc_sut, ppc_sut, tpc_bns, ppc_bns,
+            co2, h2s, n2, h2, he, lbc_params,
+        })
+    }
+
     /// Z-factor at a single pressure. All critical property computation is
     /// internal — no Python round-trips.
-    fn eval_z(&self, p_psia: f64) -> f64 {
+    pub(crate) fn eval_z(&self, p_psia: f64) -> f64 {
         match self.method {
             ZMethod::DakSut => {
                 zfactor::dak_core_pub(p_psia / self.ppc_sut, self.deg_r / self.tpc_sut)
@@ -103,9 +163,9 @@ impl GasState<'_> {
     }
 
     /// Viscosity at a single pressure, using LBC only on the BNS path.
-    fn eval_ug(&self, p_psia: f64, zee: f64) -> f64 {
+    pub(crate) fn eval_ug(&self, p_psia: f64, zee: f64) -> f64 {
         match self.method {
-            ZMethod::Bns => match self.lbc_params {
+            ZMethod::Bns => match &self.lbc_params {
                 Some(params) => {
                     gas_viscosity::lbc_viscosity_with_params(p_psia, self.deg_r, zee, params)
                 }
@@ -219,67 +279,11 @@ pub fn gas_dmp_rust(
 ) -> PyResult<f64> {
     // inerts = [co2, h2s, n2, h2, he] mole fractions (one record keeps the
     // signature under clippy's argument threshold)
-    let [co2, h2s, n2, h2, he] = inerts;
     if p1 == p2 {
         return Ok(0.0);
     }
-
-    let deg_r = degf + DEGF2R;
-
-    // Determine method
-    let method = match (zmethod, cmethod) {
-        ("DAK", "SUT") | ("DAK", _) if cmethod == "SUT" => ZMethod::DakSut,
-        ("HY", "SUT") | ("HY", _) if cmethod == "SUT" => ZMethod::HySut,
-        ("BNS", _) | ("BUR", _) => ZMethod::Bns,
-        _ => {
-            return Err(pyo3::exceptions::PyValueError::new_err(
-                format!("Rust acceleration not available for zmethod={}, cmethod={}", zmethod, cmethod)
-            ));
-        }
-    };
-
-    // Precompute critical properties — user tc/pc override is method-dependent:
-    // DAK/HY+SUT: (tc, pc) replace the mixture Tc/Pc.
-    // BNS: (tc, pc) replace only the HC pseudo-component Tc/Pc; inert Tc/Pc
-    //      remain at BNS internal constants. LBC params also honor the HC override.
-    let user_tc_pc = tc > 0.0 && pc > 0.0;
-    let (tpc_sut, ppc_sut) = match method {
-        ZMethod::DakSut | ZMethod::HySut => {
-            if user_tc_pc {
-                (tc, pc)
-            } else {
-                critical_properties::sutton_wa_internal(sg, co2, h2s, n2)
-                    .map_err(pyo3::exceptions::PyValueError::new_err)?
-            }
-        }
-        ZMethod::Bns => (0.0, 0.0), // Not used
-    };
-
-    let (tpc_bns, ppc_bns) = match method {
-        ZMethod::Bns => {
-            if user_tc_pc {
-                (tc, pc)
-            } else {
-                let (t, p, _) = critical_properties::bns_pseudocritical_internal(sg, co2, h2s, n2, h2, he);
-                (t, p)
-            }
-        }
-        _ => (0.0, 0.0),
-    };
-
-    // Precompute LBC params for BNS method (propagates HC Tc/Pc override)
-    let lbc_p = match method {
-        ZMethod::Bns => {
-            let (tc_lbc, pc_lbc) = if user_tc_pc { (tc, pc) } else { (0.0, 0.0) };
-            Some(gas_viscosity::lbc_params(degf, sg, co2, h2s, n2, h2, he, tc_lbc, pc_lbc))
-        }
-        _ => None,
-    };
-
-    let state = GasState {
-        method, deg_r, sg, tpc_sut, ppc_sut, tpc_bns, ppc_bns,
-        co2, h2s, n2, h2, he, lbc_params: &lbc_p,
-    };
+    let state = GasState::new(degf, sg, zmethod, cmethod, inerts, tc, pc, true)
+        .map_err(pyo3::exceptions::PyValueError::new_err)?;
 
     // Two-tier Gauss-Legendre integration
     let result_7 = state.gl_integrate(p1, p2, &GL7_NODES, &GL7_WEIGHTS);
@@ -310,54 +314,9 @@ pub fn gas_ponz2p_rust(
     pc: f64,
     rtol: f64,
 ) -> PyResult<Vec<f64>> {
-    // inerts = [co2, h2s, n2, h2, he] mole fractions
-    let [co2, h2s, n2, h2, he] = inerts;
-    let deg_r = degf + DEGF2R;
-
-    // Determine method
-    let method = match (zmethod, cmethod) {
-        ("DAK", "SUT") | ("DAK", _) if cmethod == "SUT" => ZMethod::DakSut,
-        ("HY", "SUT") | ("HY", _) if cmethod == "SUT" => ZMethod::HySut,
-        ("BNS", _) | ("BUR", _) => ZMethod::Bns,
-        _ => {
-            return Err(pyo3::exceptions::PyValueError::new_err(
-                format!("Rust acceleration not available for zmethod={}, cmethod={}", zmethod, cmethod)
-            ));
-        }
-    };
-
-    // Precompute critical properties — see gas_dmp_rust for override semantics.
-    let user_tc_pc = tc > 0.0 && pc > 0.0;
-    let (tpc_sut, ppc_sut) = match method {
-        ZMethod::DakSut | ZMethod::HySut => {
-            if user_tc_pc {
-                (tc, pc)
-            } else {
-                critical_properties::sutton_wa_internal(sg, co2, h2s, n2)
-                    .map_err(pyo3::exceptions::PyValueError::new_err)?
-            }
-        }
-        ZMethod::Bns => (0.0, 0.0),
-    };
-
-    let (tpc_bns, ppc_bns) = match method {
-        ZMethod::Bns => {
-            if user_tc_pc {
-                (tc, pc)
-            } else {
-                let (t, p, _) = critical_properties::bns_pseudocritical_internal(sg, co2, h2s, n2, h2, he);
-                (t, p)
-            }
-        }
-        _ => (0.0, 0.0),
-    };
-
-    // P/Z needs no viscosity, so the LBC parameters stay unset here.
-    let no_lbc = None;
-    let state = GasState {
-        method, deg_r, sg, tpc_sut, ppc_sut, tpc_bns, ppc_bns,
-        co2, h2s, n2, h2, he, lbc_params: &no_lbc,
-    };
+    // inerts = [co2, h2s, n2, h2, he] mole fractions; P/Z needs no viscosity
+    let state = GasState::new(degf, sg, zmethod, cmethod, inerts, tc, pc, false)
+        .map_err(pyo3::exceptions::PyValueError::new_err)?;
 
     let mut results = Vec::with_capacity(poverz.len());
     for &target in &poverz {

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.5}/src/vlp/constants.rs

@@ -149,6 +149,12 @@ pub const GRAY_ND_COEF: f64 = 205.0; // Diameter number coefficient in A
 pub const GRAY_ROUGH_K: f64 = 28.5; // Effective roughness coefficient
 pub const GRAY_R_THRESH: f64 = 0.007; // R threshold for roughness interpolation
 pub const GRAY_SP_LIQ_FRAC: f64 = 1e-6; // v_sg/v_m below this is single-phase liquid (dry roughness)
+/// Below this no-slip liquid fraction the gas march blends each segment's
+/// gradient linearly toward the method's own zero-liquid gradient (weight
+/// lambda / LOW_LIQ_LAMBDA): WG and Gray holdup tend to finite values as liquid
+/// vanishes and Beggs-Brill y = lambda/HL^2 grows without bound (Python
+/// _LOW_LIQ_LAMBDA, nodal.py).
+pub const LOW_LIQ_LAMBDA: f64 = 1e-3;
 pub const GRAY_ROUGH_FLOOR: f64 = 2.77e-5; // Minimum effective roughness (ft)
 
 // ============================================================================