pyrestoolbox 3.8.4__tar.gz → 3.8.6__tar.gz

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrestoolbox
-Version: 3.8.4
+Version: 3.8.6
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -9,10 +9,11 @@ Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: pandas
 Requires-Dist: tabulate
-Requires-Dist: ilt-inversion
-Requires-Dist: mpmath
-Requires-Dist: gmpy2
 Requires-Dist: openpyxl
+Requires-Dist: ilt-inversion ; extra == 'aquifer'
+Requires-Dist: mpmath ; extra == 'aquifer'
+Requires-Dist: gmpy2 ; extra == 'aquifer'
+Provides-Extra: aquifer
 License-File: LICENSE
 Summary: pyResToolbox - A collection of Reservoir Engineering Utilities
 Keywords: restoolbox,petroleum,reservoir
@@ -64,7 +65,7 @@ All public PVT, flow rate, and simulation table functions support both oilfield
 Rust Acceleration (Optional)
 ----------------------------
 
-pyResToolbox includes optional Rust-compiled extensions that accelerate computationally intensive algorithms. When the compiled extension is present and loadable, these functions run automatically through Rust with no API changes. When the extension is unavailable, all functions fall back silently to the pure Python implementation.
+pyResToolbox includes optional Rust-compiled extensions that accelerate computationally intensive algorithms. When the compiled extension is present and loadable, these functions run automatically through Rust with no API changes. When the extension is unavailable, all functions fall back silently to the pure Python implementation. The one exception is ``simtools.influence_tables``, whose pure-Python fallback needs the optional ``aquifer`` extra (``pip install 'pyrestoolbox[aquifer]'``).
 
 **Accelerated functions:**
 

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.6}/README.rst

@@ -39,7 +39,7 @@ All public PVT, flow rate, and simulation table functions support both oilfield
 Rust Acceleration (Optional)
 ----------------------------
 
-pyResToolbox includes optional Rust-compiled extensions that accelerate computationally intensive algorithms. When the compiled extension is present and loadable, these functions run automatically through Rust with no API changes. When the extension is unavailable, all functions fall back silently to the pure Python implementation.
+pyResToolbox includes optional Rust-compiled extensions that accelerate computationally intensive algorithms. When the compiled extension is present and loadable, these functions run automatically through Rust with no API changes. When the extension is unavailable, all functions fall back silently to the pure Python implementation. The one exception is ``simtools.influence_tables``, whose pure-Python fallback needs the optional ``aquifer`` extra (``pip install 'pyrestoolbox[aquifer]'``).
 
 **Accelerated functions:**
 

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

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pyrestoolbox"
-version = "3.8.4"
+version = "3.8.6"
 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"}]
@@ -21,13 +21,14 @@ dependencies = [
     "scipy",
     "pandas",
     "tabulate",
-    "ilt-inversion",
-    "mpmath",
-    "gmpy2",
     "openpyxl",
 ]
 readme = "README.rst"
 
+[project.optional-dependencies]
+# Pure-Python fallback for simtools.influence_tables (the Rust extension needs none of these)
+aquifer = ["ilt-inversion", "mpmath", "gmpy2"]
+
 [project.urls]
 Homepage = "https://github.com/mwburgoyne/pyResToolbox"
 

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.6}/pyrestoolbox/docs/changelist.rst

@@ -1,3 +1,15 @@
+Changelist in 3.8.6:
+
+- **SIMTOOLS: ``influence_tables`` Rust path now holds the precision the inversion needs (results move).** The Rust Gaver-Wynn-Rho inversion evaluates the Van Everdingen-Hurst transform with its own MPFR Bessel functions, and those carried less precision than GWR needs (about 2.1M digits). The series-to-asymptotic switch was fixed at x = 25, where the asymptotic expansion is good to only about 22 digits; the K-series ran with half the guard bits its cancellation needs; pi in the asymptotic prefactors and Euler's constant in the K0 series were f64 or 50-digit constants; and the I1 asymptotic expansion had a sign error. The switch now depends on the working precision, the guard bits match the cancellation, all constants are MPFR, and the I1 sign is corrected. Against a reference converged to 1e-14, the worst point on a 126-point table (ReD 1.5-20, tD 0.01-200) is now 2.2e-5 at M=7 (was 4.5e-5), 1.4e-8 at M=12 (was 1.6e-4), 3.2e-11 at M=18 (was 6.7e-3) and 2e-16 at M=32 (ReD 1.5 at tD 0.044 returned 20.07 against 0.2175), the same convergence as the pure-Python path. At the default M=7 the README example table (ReD 1.5-1000) moves by up to 4.6e-5 relative (ReD 1.5, tD 0.027: 0.172801 to 0.172809), 6e-7 on average. Run time is unchanged or a little shorter (121 against 138 ms for that table at M=7).
+
+- **PACKAGING: ``ilt-inversion``, ``mpmath`` and ``gmpy2`` are now an optional extra (``pip install 'pyrestoolbox[aquifer]'``).** Only ``simtools.influence_tables`` uses them, and only on its pure-Python path; the Rust extension in every prebuilt wheel does the inverse Laplace transform and Bessel functions itself in MPFR. ``import pyrestoolbox.simtools`` no longer loads ``ilt`` or ``mpmath``. Without the Rust extension and without the extra, ``influence_tables`` raises ``ImportError`` naming the extra; every other function is unaffected. Existing environments keep working, since upgrading does not uninstall the three packages.
+
+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.6}/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.6}/pyrestoolbox/docs/simtools.rst

@@ -152,6 +152,8 @@ pyrestoolbox.simtools.influence_tables
 
 Solves Van Everdingin & Hurst Constant Terminal Rate solution via inverse Laplace transform and optionally writes out ECLIPSE styled AQUTAB include file.
 
+The Rust extension (in every prebuilt wheel) does the inversion with no extra packages. Without it, the pure-Python fallback needs the optional ``aquifer`` extra (``ilt-inversion``, ``mpmath``, ``gmpy2``): ``pip install 'pyrestoolbox[aquifer]'``. Calling ``influence_tables`` on the pure-Python path without them raises ``ImportError``.
+
 Returns a tuple of;
     1. Dimensionless time list
     2. list of lists of dimensionless pressures at each dimensionless time for each dimensionless radius

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.6}/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.6}/pyrestoolbox/simtools/_aquifer.py

@@ -30,8 +30,6 @@ from typing import Union, Tuple
 import numpy as np
 import numpy.typing as npt
 from tabulate import tabulate
-from ilt import gwr
-from mpmath import mp
 
 from pyrestoolbox._accelerator import RUST_AVAILABLE, _rust_module
 
@@ -74,7 +72,17 @@ def influence_tables(
     if RUST_AVAILABLE:
         pDs = _rust_module.influence_tables_rust(tD.tolist(), list(ReDs), M)
     else:
-        # Python fallback via ilt library
+        # Python fallback via ilt library (optional extra: pyrestoolbox[aquifer])
+        try:
+            from ilt import gwr
+            from mpmath import mp
+        except ImportError as e:
+            raise ImportError(
+                "influence_tables needs the Rust extension or the optional "
+                "inverse-Laplace dependencies; install them with "
+                "pip install 'pyrestoolbox[aquifer]'"
+            ) from e
+
         def laplace_Ps(s: float, ReD: float):
             x = mp.sqrt(s)
             # pre-calculate duplicated bessel function for greater efficiency

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.6}/setup.cfg

@@ -17,10 +17,13 @@ install_requires =
     scipy
     pandas
     tabulate
+    openpyxl
+
+[options.extras_require]
+aquifer =
     ilt-inversion
     mpmath
     gmpy2
-    openpyxl
 
 [options.packages.find]
 exclude =

{pyrestoolbox-3.8.4 → pyrestoolbox-3.8.6}/setup.py

@@ -32,9 +32,9 @@ setup(
         'scipy',
         'pandas',
         'tabulate',
-        'ilt-inversion',
-        'mpmath',
-        'gmpy2',
         'openpyxl'
-    ]
+    ],
+    extras_require={
+        'aquifer': ['ilt-inversion', 'mpmath', 'gmpy2'],
+    }
 )