pyrestoolbox 3.1.2__tar.gz → 3.1.3__tar.gz

{pyrestoolbox-3.1.2 → pyrestoolbox-3.1.3}/PKG-INFO

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

{pyrestoolbox-3.1.2 → pyrestoolbox-3.1.3}/pyproject.toml

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

@@ -1,3 +1,11 @@
+Changelist in 3.1.3:
+
+- **Z-factor Z*=Z-B reformulation**: BNS Peng-Robinson cubic solver now uses Aaron Zick's Z* = Z - B variable substitution, which bounds all physical roots to (0, 1] and guarantees Halley solver convergence. Eliminates rare failures at extreme pressures. Falls back to Cardano analytically if needed.
+- **Rust batch vectorization**: Rust-accelerated ``gas_z()`` and ``gas_ug()`` now use batch dispatch (single FFI call for all pressures) instead of per-pressure scalar loops. Precomputes critical properties, BIPs, and LBC mixture parameters once per call. New Rust functions: ``bns_zfactor_batch``, ``dak_zfactor_batch``, ``hy_zfactor_batch``, ``gas_ug_lge_batch``, ``gas_ug_lbc_batch``. LBC viscosity batch is 9.3x faster than scalar; full BNS pipeline (Z + viscosity) is 2x faster than pure Python.
+- **Rust GWR inverse Laplace transform**: Rust/MPFR-accelerated Gaver-Wynn-Rho algorithm and Bessel functions for influence table generation. Switched dependency from ``gwr_inversion`` to ``ilt-inversion``.
+- **oil_co() Pb discontinuity fix**: Fixed oil compressibility discontinuity at bubble point in black oil tables. Added ``undersaturated_only`` mode.
+- 630 validation tests (up from 603 in 3.0.5).
+
 Changelist in 3.0.5:
 
 - **Rust acceleration (optional)**: Computationally intensive algorithms now have optional Rust-compiled acceleration. When the compiled extension is present it is used automatically with no API changes; when unavailable, all functions fall back silently to pure Python. Accelerated functions include all 8 VLP segment loops (4 methods x gas/oil), gas Z-factor (DAK, HY, BNS), gas viscosity (LGE, LBC), gas pseudopressure, oil density (SWMH), oil FVF (McCain), DCA hyperbolic grid search (``fit_decline``, ``fit_decline_cum``), and the material balance regression objective. Set ``PYRESTOOLBOX_NO_RUST=1`` to force pure Python; set ``PYRESTOOLBOX_RETRY_RUST=1`` to retry after a blocked probe. Use ``from pyrestoolbox._accelerator import get_status`` for programmatic status checks.

{pyrestoolbox-3.1.2 → pyrestoolbox-3.1.3}/pyrestoolbox/gas/gas.py

@@ -840,29 +840,29 @@ def gas_z(
         
     zfuncs = {"DAK": zdak, "HY": z_hy, "WYW": z_wyw, "BUR": z_bur}
 
-    # Rust acceleration dispatch
+    # Rust acceleration dispatch (batch — single FFI call for all pressures)
     if RUST_AVAILABLE:
         if zmethod.name in ('BNS', 'BUR'):
-            zout = np.array([_rust_module.bns_zfactor_full(
-                float(pi), float(degf), float(sg),
+            zout = np.array(_rust_module.bns_zfactor_batch(
+                p.tolist(), float(degf), float(sg),
                 float(co2), float(h2s), float(n2), float(h2)
-            ) for pi in p])
+            ))
             return process_output(zout, is_list)
         elif zmethod.name == 'DAK':
             if cmethod.name == 'SUT':
-                zout = np.array([_rust_module.dak_zfactor_full(
-                    float(pi), float(degf), float(sg),
+                zout = np.array(_rust_module.dak_zfactor_batch(
+                    p.tolist(), float(degf), float(sg),
                     float(co2), float(h2s), float(n2)
-                ) for pi in p])
+                ))
             else:
                 zout = np.array([_rust_module.dak_zfactor(float(pr_i), float(tr)) for pr_i in pprs])
             return process_output(zout, is_list)
         elif zmethod.name == 'HY':
             if cmethod.name == 'SUT':
-                zout = np.array([_rust_module.hall_yarborough_zfactor_full(
-                    float(pi), float(degf), float(sg),
+                zout = np.array(_rust_module.hy_zfactor_batch(
+                    p.tolist(), float(degf), float(sg),
                     float(co2), float(h2s), float(n2)
-                ) for pi in p])
+                ))
             else:
                 zout = np.array([_rust_module.hall_yarborough_zfactor(float(pr_i), float(tr)) for pr_i in pprs])
             return process_output(zout, is_list)
@@ -945,15 +945,17 @@ def gas_ug(
     
     rho = m * p / (t * zee * R * 62.37)
 
-    # Rust-accelerated viscosity (scalar dispatch)
+    # Rust-accelerated viscosity (batch — single FFI call for all pressures)
     if RUST_AVAILABLE:
         if zmethod.name not in ('BNS', 'BUR'):
-            ug_list = np.array([_rust_module.gas_ug_lge(float(pi), sg, degf, float(zi))
-                                for pi, zi in zip(p, zee)])
+            ug_list = np.array(_rust_module.gas_ug_lge_batch(
+                p.tolist(), zee.tolist(), sg, degf
+            ))
             ug = process_output(ug_list, is_list)
         else:
-            ug_list = np.array([_rust_module.gas_ug_lbc(float(pi), sg, degf, co2, h2s, n2, h2, float(zi))
-                                for pi, zi in zip(p, zee)])
+            ug_list = np.array(_rust_module.gas_ug_lbc_batch(
+                p.tolist(), zee.tolist(), sg, degf, co2, h2s, n2, h2
+            ))
             ug = process_output(ug_list, is_list)
         if ugz:
             return process_output(ug * zee, is_list)

{pyrestoolbox-3.1.2 → pyrestoolbox-3.1.3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = pyrestoolbox
-version = 3.1.2
+version = 3.1.3
 author = Mark W. Burgoyne
 author_email = mark.w.burgoyne@gmail.com
 description = pyResToolbox - A collection of Reservoir Engineering Utilities

{pyrestoolbox-3.1.2 → pyrestoolbox-3.1.3}/setup.py

@@ -12,7 +12,7 @@ with open(os.path.join(ROOT, 'README.rst'), 'r', encoding='utf-8') as f:
 setup(
     name='pyrestoolbox',
     include_package_data=True,
-    version='3.1.2',  # Ideally should be same as your GitHub release tag version
+    version='3.1.3',  # Ideally should be same as your GitHub release tag version
     packages=find_packages(exclude=['pyrestoolbox.tests', 'pyrestoolbox.tests.*']),
     description='pyResToolbox - A collection of Reservoir Engineering Utilities',
     license="GNU General Public License v3 or later (GPLv3+)",

{pyrestoolbox-3.1.2 → pyrestoolbox-3.1.3}/src/gas_viscosity/mod.rs

@@ -159,3 +159,54 @@ pub fn gas_ug_lbc(
     let params = lbc_params(degf, sg, co2, h2s, n2, h2);
     Ok(lbc_viscosity_with_params(p_psia, deg_r, zee, &params))
 }
+
+// =========================================================================
+// Batch (vectorized) viscosity functions
+// =========================================================================
+
+/// LGE viscosity for a batch of (pressure, z-factor) pairs.
+#[pyfunction]
+pub fn gas_ug_lge_batch(
+    pressures: Vec<f64>,
+    z_factors: Vec<f64>,
+    sg: f64,
+    degf: f64,
+) -> PyResult<Vec<f64>> {
+    let t_degr = degf + DEGF2R;
+    let m = MW_AIR * sg;
+
+    // Precompute temperature-dependent LGE coefficients
+    let b = 3.448 + (986.4 / t_degr) + (0.01009 * m);
+    let c = 2.447 - (0.2224 * b);
+    let a = (9.379 + (0.01607 * m)) * t_degr.powf(1.5) / (209.2 + (19.26 * m) + t_degr);
+
+    let result: Vec<f64> = pressures.iter().zip(z_factors.iter()).map(|(&p, &z)| {
+        let rho = m * p / (t_degr * z * R * 62.37);
+        a * 0.0001 * (b * rho.powf(c)).exp()
+    }).collect();
+
+    Ok(result)
+}
+
+/// LBC viscosity for a batch of (pressure, z-factor) pairs.
+/// Precomputes LBC mixture parameters (u0, eta_mix, rhoc) once.
+#[pyfunction]
+pub fn gas_ug_lbc_batch(
+    pressures: Vec<f64>,
+    z_factors: Vec<f64>,
+    sg: f64,
+    degf: f64,
+    co2: f64,
+    h2s: f64,
+    n2: f64,
+    h2: f64,
+) -> PyResult<Vec<f64>> {
+    let deg_r = degf + DEGF2R;
+    let params = lbc_params(degf, sg, co2, h2s, n2, h2);
+
+    let result: Vec<f64> = pressures.iter().zip(z_factors.iter()).map(|(&p, &z)| {
+        lbc_viscosity_with_params(p, deg_r, z, &params)
+    }).collect();
+
+    Ok(result)
+}

{pyrestoolbox-3.1.2 → pyrestoolbox-3.1.3}/src/lib.rs

@@ -38,10 +38,19 @@ fn _native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(zfactor::hall_yarborough_zfactor_full, m)?)?;
     m.add_function(wrap_pyfunction!(zfactor::bns_zfactor_full, m)?)?;
 
+    // Z-factor batch functions
+    m.add_function(wrap_pyfunction!(zfactor::dak_zfactor_batch, m)?)?;
+    m.add_function(wrap_pyfunction!(zfactor::hy_zfactor_batch, m)?)?;
+    m.add_function(wrap_pyfunction!(zfactor::bns_zfactor_batch, m)?)?;
+
     // Gas viscosity
     m.add_function(wrap_pyfunction!(gas_viscosity::gas_ug_lge, m)?)?;
     m.add_function(wrap_pyfunction!(gas_viscosity::gas_ug_lbc, m)?)?;
 
+    // Gas viscosity batch functions
+    m.add_function(wrap_pyfunction!(gas_viscosity::gas_ug_lge_batch, m)?)?;
+    m.add_function(wrap_pyfunction!(gas_viscosity::gas_ug_lbc_batch, m)?)?;
+
     // Pseudopressure integration
     m.add_function(wrap_pyfunction!(pseudopressure::gas_dmp_rust, m)?)?;
 

{pyrestoolbox-3.1.2 → pyrestoolbox-3.1.3}/src/zfactor/mod.rs

@@ -463,6 +463,80 @@ pub fn bns_zfactor_full(
     Ok(bns_zfactor_core(p_psia, deg_r, co2_frac, h2s_frac, n2_frac, h2_frac, tpc, ppc))
 }
 
+// =========================================================================
+// Batch (vectorized) pipeline functions — precompute once, loop pressures
+// =========================================================================
+
+/// DAK Z-factor for a batch of pressures. Precomputes Sutton+WA critical properties once.
+#[pyfunction]
+pub fn dak_zfactor_batch(
+    pressures: Vec<f64>,
+    t_degf: f64,
+    sg: f64,
+    co2_frac: f64,
+    h2s_frac: f64,
+    n2_frac: f64,
+) -> PyResult<Vec<f64>> {
+    let (tpc, ppc) = critical_properties::sutton_wa_internal(sg, co2_frac, h2s_frac, n2_frac)
+        .map_err(|e| PyValueError::new_err(e))?;
+    let t_rankine = t_degf + DEGF2R;
+    let tr = t_rankine / tpc;
+
+    let result: Vec<f64> = pressures.iter().map(|&p| {
+        let pr = p / ppc;
+        dak_core(pr, tr)
+    }).collect();
+
+    Ok(result)
+}
+
+/// Hall-Yarborough Z-factor for a batch of pressures. Precomputes Sutton+WA critical properties once.
+#[pyfunction]
+pub fn hy_zfactor_batch(
+    pressures: Vec<f64>,
+    t_degf: f64,
+    sg: f64,
+    co2_frac: f64,
+    h2s_frac: f64,
+    n2_frac: f64,
+) -> PyResult<Vec<f64>> {
+    let (tpc, ppc) = critical_properties::sutton_wa_internal(sg, co2_frac, h2s_frac, n2_frac)
+        .map_err(|e| PyValueError::new_err(e))?;
+    let t_rankine = t_degf + DEGF2R;
+    let tr = t_rankine / tpc;
+
+    let result: Vec<f64> = pressures.iter().map(|&p| {
+        let pr = p / ppc;
+        hy_core(pr, tr)
+    }).collect();
+
+    Ok(result)
+}
+
+/// BNS Z-factor for a batch of pressures. Precomputes critical properties, BIPs,
+/// alpha, and m once — loops only mixing rules, cubic solve, and fugacity selection.
+#[pyfunction]
+pub fn bns_zfactor_batch(
+    pressures: Vec<f64>,
+    t_degf: f64,
+    sg: f64,
+    co2_frac: f64,
+    h2s_frac: f64,
+    n2_frac: f64,
+    h2_frac: f64,
+) -> PyResult<Vec<f64>> {
+    let deg_r = t_degf + DEGF2R;
+    let (tpc_hc, ppc_hc, _) = critical_properties::bns_pseudocritical_internal(
+        sg, co2_frac, h2s_frac, n2_frac, h2_frac
+    );
+
+    let result: Vec<f64> = pressures.iter().map(|&p| {
+        bns_zfactor_core(p, deg_r, co2_frac, h2s_frac, n2_frac, h2_frac, tpc_hc, ppc_hc)
+    }).collect();
+
+    Ok(result)
+}
+
 // =========================================================================
 // Public wrappers for cross-module access (used by pseudopressure)
 // =========================================================================