pyrestoolbox 3.1.0__tar.gz → 3.1.2__tar.gz

{pyrestoolbox-3.1.0 → pyrestoolbox-3.1.2}/.github/workflows/build-wheels.yml

@@ -40,12 +40,12 @@ jobs:
         shell: bash
 
       - name: Build wheels via cibuildwheel
-        uses: pypa/cibuildwheel@v2.21
+        uses: pypa/cibuildwheel@v2.23
         env:
           # Use maturin as the build frontend
           CIBW_BUILD_FRONTEND: "build"
-          # Build for CPython 3.10-3.13 (drop 3.9 — scipy 1.14+ requires 3.10)
-          CIBW_BUILD: "cp310-* cp311-* cp312-* cp313-*"
+          # Build for CPython 3.8-3.13 (last 5+ years of Python releases)
+          CIBW_BUILD: "cp38-* cp39-* cp310-* cp311-* cp312-* cp313-*"
           # Skip 32-bit and musl (uncommon for scientific Python)
           CIBW_SKIP: "*-win32 *-manylinux_i686 *-musllinux*"
           # maturin needs Rust in the build container
@@ -74,8 +74,9 @@ jobs:
           CIBW_TEST_COMMAND: >
             python -c "from pyrestoolbox._accelerator import get_status; s = get_status(); print(s); assert s['rust_available'], f'Rust not loaded: {s}'"
           CIBW_TEST_REQUIRES: "numpy"
-          # Skip tests on Linux (scipy needs OpenBLAS absent in manylinux) and cross-arch
-          CIBW_TEST_SKIP: "*-manylinux* *-macosx_x86_64"
+          # Skip tests on Linux (scipy needs OpenBLAS absent in manylinux), macOS (MPFR symbol issue),
+          # and cp38/cp39 (dependency ilt-inversion may not have matching wheels on PyPI yet)
+          CIBW_TEST_SKIP: "*-manylinux* *-macosx* cp38-* cp39-*"
 
       - uses: actions/upload-artifact@v4
         with:
@@ -98,10 +99,10 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
 
       - name: Build wheels via cibuildwheel
-        uses: pypa/cibuildwheel@v2.21
+        uses: pypa/cibuildwheel@v2.23
         env:
           CIBW_BUILD_FRONTEND: "build"
-          CIBW_BUILD: "cp310-* cp311-* cp312-* cp313-*"
+          CIBW_BUILD: "cp38-* cp39-* cp310-* cp311-* cp312-* cp313-*"
           CIBW_ARCHS_MACOS: "x86_64"
           CIBW_TEST_COMMAND: >
             python -c "from pyrestoolbox._accelerator import get_status; s = get_status(); print(s); assert s['rust_available'], f'Rust not loaded: {s}'"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrestoolbox
-Version: 3.1.0
+Version: 3.1.2
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -20,7 +20,7 @@ Keywords: restoolbox,petroleum,reservoir
 Home-Page: https://github.com/mwburgoyne/pyResToolbox
 Author-email: "Mark W. Burgoyne" <mark.w.burgoyne@gmail.com>
 License: GPL-3.0-or-later
-Requires-Python: >=3.9
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst; charset=UTF-8
 Project-URL: Homepage, https://github.com/mwburgoyne/pyResToolbox
 
@@ -203,7 +203,7 @@ A set of Gas-Oil relative permeability curves with the LET method
     >>> plt.grid('both')
     >>> plt.plot()
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/sgof.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/sgof.png
     :alt: SGOF Relative Permeability Curves
 
 Or a set of Water-Oil relative permeability curves with the Corey method
@@ -220,7 +220,7 @@ Or a set of Water-Oil relative permeability curves with the Corey method
     >>> plt.grid('both')
     >>> plt.plot()
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/swof.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/swof.png
     :alt: SWOF Relative Permeability Curves
 
 A set of dimensionless pressures for the constant terminal rate Van Everdingin & Hurst aquifer, along with an AQUTAB.INC export for use in ECLIPSE.
@@ -242,7 +242,7 @@ A set of dimensionless pressures for the constant terminal rate Van Everdingin &
     >>> plt.title('Constant Terminal Rate Solution')
     >>> plt.show()
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/influence.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/influence.png
     :alt: Constant Terminal Rate influence tables
 
 Or creating black oil table information for oil
@@ -295,7 +295,7 @@ Or creating black oil table information for oil
     Reservoir Water Compressibility: 2.930237693350768e-06 1/psi
     Reservoir Water Viscosity: 0.3640686136171888 cP
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/bot.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/bot.png
     :alt: Black Oil Properties
 
 And gas
@@ -310,7 +310,7 @@ And gas
     >>> ...
     >>> plt.show()
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/dry_gas.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/dry_gas.png
     :alt: Dry Gas Properties
 
 With ability to generate Live Oil PVTO style table data as well
@@ -384,7 +384,7 @@ With ability to generate Live Oil PVTO style table data as well
     Reservoir Water Compressibility: 2.930237693350768e-06 1/psi
     Reservoir Water Viscosity: 0.3640686136171888 cP
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/bot_PVTO.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/bot_PVTO.png
     :alt: Live Oil Properties
 
 

{pyrestoolbox-3.1.0 → pyrestoolbox-3.1.2}/README.rst

@@ -177,7 +177,7 @@ A set of Gas-Oil relative permeability curves with the LET method
     >>> plt.grid('both')
     >>> plt.plot()
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/sgof.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/sgof.png
     :alt: SGOF Relative Permeability Curves
 
 Or a set of Water-Oil relative permeability curves with the Corey method
@@ -194,7 +194,7 @@ Or a set of Water-Oil relative permeability curves with the Corey method
     >>> plt.grid('both')
     >>> plt.plot()
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/swof.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/swof.png
     :alt: SWOF Relative Permeability Curves
 
 A set of dimensionless pressures for the constant terminal rate Van Everdingin & Hurst aquifer, along with an AQUTAB.INC export for use in ECLIPSE.
@@ -216,7 +216,7 @@ A set of dimensionless pressures for the constant terminal rate Van Everdingin &
     >>> plt.title('Constant Terminal Rate Solution')
     >>> plt.show()
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/influence.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/influence.png
     :alt: Constant Terminal Rate influence tables
 
 Or creating black oil table information for oil
@@ -269,7 +269,7 @@ Or creating black oil table information for oil
     Reservoir Water Compressibility: 2.930237693350768e-06 1/psi
     Reservoir Water Viscosity: 0.3640686136171888 cP
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/bot.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/bot.png
     :alt: Black Oil Properties
 
 And gas
@@ -284,7 +284,7 @@ And gas
     >>> ...
     >>> plt.show()
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/dry_gas.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/dry_gas.png
     :alt: Dry Gas Properties
 
 With ability to generate Live Oil PVTO style table data as well
@@ -358,7 +358,7 @@ With ability to generate Live Oil PVTO style table data as well
     Reservoir Water Compressibility: 2.930237693350768e-06 1/psi
     Reservoir Water Viscosity: 0.3640686136171888 cP
 
-.. image:: https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/img/bot_PVTO.png
+.. image:: https://raw.githubusercontent.com/mwburgoyne/pyResToolbox/main/pyrestoolbox/docs/img/bot_PVTO.png
     :alt: Live Oil Properties
 
 

pyrestoolbox-3.1.2/benchmark_rust_vs_python.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+Benchmark: Rust-accelerated vs pure-Python pyResToolbox functions.
+
+Runs 8 test cases with BNS method, comparing results, accuracy and speedup.
+Pure-Python runs in a subprocess with PYRESTOOLBOX_NO_RUST=1 (set before
+import since the accelerator probes at import time).
+"""
+
+import json
+import os
+import subprocess
+import sys
+import time
+
+import numpy as np
+from tabulate import tabulate
+
+
+# ── Helper: run a test case in a subprocess ──────────────────────────────
+def _run_in_subprocess(test_code: str, env_override: dict | None = None) -> dict:
+    """Execute test_code in a fresh Python process and return JSON result."""
+    env = os.environ.copy()
+    if env_override:
+        env.update(env_override)
+
+    wrapper = f"""
+import json, time, sys, os
+sys.path.insert(0, {os.getcwd()!r})
+{test_code}
+"""
+    result = subprocess.run(
+        [sys.executable, "-c", wrapper],
+        capture_output=True, text=True, env=env, timeout=300
+    )
+    if result.returncode != 0:
+        return {"error": result.stderr.strip(), "elapsed": 0, "value": None}
+    try:
+        return json.loads(result.stdout.strip().split("\n")[-1])
+    except (json.JSONDecodeError, IndexError):
+        return {"error": f"Bad output: {result.stdout[:200]}", "elapsed": 0, "value": None}
+
+
+# ── Test case definitions ────────────────────────────────────────────────
+
+PREAMBLE = """
+from pyrestoolbox import gas, oil
+from pyrestoolbox.nodal import Completion, fbhp
+from pyrestoolbox import simtools
+from pyrestoolbox.classes import z_method, c_method
+import numpy as np
+import time
+import json
+"""
+
+# (label, function_call_string, test_code)
+TESTS = [
+    (
+        "(a) Single Z-factor",
+        "gas.gas_z(p=3000, sg=0.7, degf=200, zmethod=z_method.BNS, cmethod=c_method.BNS)",
+        """
+z = gas.gas_z(p=3000, sg=0.7, degf=200, zmethod=z_method.BNS, cmethod=c_method.BNS)
+print(json.dumps({"elapsed": _elapsed, "value": float(z)}))
+""",
+    ),
+    (
+        "(b) 1000x Z-factors",
+        "[gas.gas_z(p=p, sg=0.7, degf=200, zmethod=z_method.BNS, cmethod=c_method.BNS)\n  for p in np.linspace(500, 5000, 1000)]",
+        """
+pressures = np.linspace(500, 5000, 1000).tolist()
+results = [gas.gas_z(p=p, sg=0.7, degf=200, zmethod=z_method.BNS, cmethod=c_method.BNS) for p in pressures]
+print(json.dumps({"elapsed": _elapsed, "value": float(np.mean(results))}))
+""",
+    ),
+    (
+        "(c) Single viscosity",
+        "gas.gas_ug(p=3000, sg=0.7, degf=200, zmethod=z_method.BNS, cmethod=c_method.BNS)",
+        """
+ug = gas.gas_ug(p=3000, sg=0.7, degf=200, zmethod=z_method.BNS, cmethod=c_method.BNS)
+print(json.dumps({"elapsed": _elapsed, "value": float(ug)}))
+""",
+    ),
+    (
+        "(d) 1000x viscosities",
+        "[gas.gas_ug(p=p, sg=0.7, degf=200, zmethod=z_method.BNS, cmethod=c_method.BNS)\n  for p in np.linspace(500, 5000, 1000)]",
+        """
+pressures = np.linspace(500, 5000, 1000).tolist()
+results = [gas.gas_ug(p=p, sg=0.7, degf=200, zmethod=z_method.BNS, cmethod=c_method.BNS) for p in pressures]
+print(json.dumps({"elapsed": _elapsed, "value": float(np.mean(results))}))
+""",
+    ),
+    (
+        "(e) Pseudopressure",
+        "gas.gas_dmp(p1=500, p2=4000, degf=200, sg=0.7, zmethod=z_method.BNS, cmethod=c_method.BNS)",
+        """
+pp = gas.gas_dmp(p1=500, p2=4000, degf=200, sg=0.7, zmethod=z_method.BNS, cmethod=c_method.BNS)
+print(json.dumps({"elapsed": _elapsed, "value": float(pp)}))
+""",
+    ),
+    (
+        "(f) Gas outflow",
+        "fbhp(thp=500, completion=Completion(2.441, 10000, 100, 200),\n  vlpmethod='WG', well_type='gas', qg_mmscfd=5, cgr=10,\n  qw_bwpd=10, api=45, gsg=0.65)",
+        """
+c = Completion(tid=2.441, length=10000, tht=100, bht=200)
+bhp = fbhp(thp=500, completion=c, vlpmethod='WG', well_type='gas',
+           qg_mmscfd=5.0, cgr=10, qw_bwpd=10, api=45, gsg=0.65, wsg=1.07)
+print(json.dumps({"elapsed": _elapsed, "value": float(bhp)}))
+""",
+    ),
+    (
+        "(g) Oil outflow",
+        "fbhp(thp=200, completion=Completion(2.441, 8000, 100, 180),\n  vlpmethod='HB', well_type='oil', qt_stbpd=2000, gor=800,\n  wc=0.3, pb=2500, rsb=500, api=35, sgsp=0.65, gsg=0.65)",
+        """
+c = Completion(tid=2.441, length=8000, tht=100, bht=180)
+bhp = fbhp(thp=200, completion=c, vlpmethod='HB', well_type='oil',
+           qt_stbpd=2000, gor=800, wc=0.3, pb=2500, rsb=500,
+           api=35, sgsp=0.65, gsg=0.65)
+print(json.dumps({"elapsed": _elapsed, "value": float(bhp)}))
+""",
+    ),
+    (
+        "(h) CT Influence table",
+        "simtools.influence_tables(ReDs=[2, 5, 10],\n  min_td=0.01, max_td=10, n_incr=10, M=7)",
+        """
+tds, pds = simtools.influence_tables(ReDs=[2, 5, 10], min_td=0.01, max_td=10, n_incr=10, M=7, export=False)
+val = sum(sum(pd) for pd in pds)
+print(json.dumps({"elapsed": _elapsed, "value": float(val)}))
+""",
+    ),
+]
+
+
+def _wrap_timed(test_code: str) -> str:
+    """Wrap test code with timing. Replaces _elapsed placeholder."""
+    lines = test_code.strip().split("\n")
+    print_line = lines[-1]
+    setup_lines = "\n".join(lines[:-1])
+    return f"""
+{PREAMBLE}
+t0 = time.perf_counter()
+{setup_lines}
+_elapsed = time.perf_counter() - t0
+{print_line}
+"""
+
+
+def main():
+    print("=" * 78)
+    print("  pyResToolbox Benchmark: Rust-accelerated vs Pure Python (BNS)")
+    print("=" * 78)
+    print()
+
+    # Confirm Rust status
+    rust_check = _run_in_subprocess(
+        PREAMBLE + """
+from pyrestoolbox._accelerator import get_status
+s = get_status()
+print(json.dumps({"elapsed": 0, "value": 1 if s['rust_available'] else 0}))
+"""
+    )
+    rust_avail = rust_check.get("value", 0) == 1
+    print(f"  Rust acceleration available: {rust_avail}")
+    if not rust_avail:
+        print("  WARNING: Rust not available - benchmark will show Python vs Python")
+    print()
+
+    rows = []
+    for label, call_str, test_code in TESTS:
+        full_code = _wrap_timed(test_code)
+
+        # Run with Rust (default)
+        print(f"  Running {label} (Rust)...", end="", flush=True)
+        r_rust = _run_in_subprocess(full_code)
+        if r_rust.get("error"):
+            print(f" ERROR: {r_rust['error'][:80]}")
+            rows.append([label, call_str, "ERROR", "", "", "", "", ""])
+            continue
+        print(f" {r_rust['elapsed']:.4f}s", flush=True)
+
+        # Run pure Python
+        print(f"  Running {label} (Python)...", end="", flush=True)
+        r_py = _run_in_subprocess(full_code, env_override={"PYRESTOOLBOX_NO_RUST": "1"})
+        if r_py.get("error"):
+            print(f" ERROR: {r_py['error'][:80]}")
+            rows.append([label, call_str, f"{r_rust['elapsed']:.4f}", "ERROR",
+                         f"{r_rust['value']:.6g}", "", "", ""])
+            continue
+        print(f" {r_py['elapsed']:.4f}s", flush=True)
+
+        speedup = r_py["elapsed"] / r_rust["elapsed"] if r_rust["elapsed"] > 1e-9 else float("inf")
+        v_rust, v_py = r_rust["value"], r_py["value"]
+        if v_rust is not None and v_py is not None and abs(v_py) > 1e-30:
+            rel_err = abs(v_rust - v_py) / abs(v_py)
+            accuracy = "Exact" if rel_err < 1e-12 else f"{rel_err:.2e}"
+        else:
+            accuracy = "N/A"
+
+        rows.append([
+            label,
+            call_str,
+            f"{r_rust['elapsed']:.4f}",
+            f"{r_py['elapsed']:.4f}",
+            f"{v_rust:.6g}",
+            f"{v_py:.6g}",
+            f"{speedup:.1f}x",
+            accuracy,
+        ])
+
+    print()
+    print(tabulate(
+        rows,
+        headers=["Test", "Function Call", "Rust (s)", "Python (s)",
+                 "Rust Result", "Python Result", "Speedup", "Rel Error"],
+        tablefmt="pretty",
+        colalign=("left", "left", "right", "right", "right", "right", "right", "center"),
+    ))
+
+
+if __name__ == "__main__":
+    main()

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

@@ -4,12 +4,12 @@ build-backend = "maturin"
 
 [project]
 name = "pyrestoolbox"
-version = "3.1.0"
+version = "3.1.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"}]
 keywords = ["restoolbox", "petroleum", "reservoir"]
-requires-python = ">=3.9"
+requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Rust",

{pyrestoolbox-3.1.0 → pyrestoolbox-3.1.2}/pyrestoolbox/docs/simtools.rst

@@ -146,7 +146,7 @@ pyrestoolbox.simtools.influence_tables
 
 .. code-block:: python
 
-    influence_tables(ReDs, min_td = 0.01, max_td = 200, n_incr = 20, M = 8, export = False)-> tuple
+    influence_tables(ReDs, min_td = 0.01, max_td = 200, n_incr = 20, M = 7, export = False)-> tuple
 
 Solves Van Everdingin & Hurst Constant Terminal Rate solution via inverse Laplace transform and optionally writes out ECLIPSE styled AQUTAB include file.
 
@@ -175,7 +175,7 @@ Returns a tuple of;
      - Number of log transformed increments to split dimensionless time into. Default = 20
    * - M
      - int
-     - Laplace invesrion accuracy. Higher = more accurate, but more time. Generally 6-12 is good range. Default = 8
+     - Laplace inversion accuracy. Higher = more accurate, but more time. Generally 6-12 is good range. Default = 7
    * - export
      - bool
      - Boolean value that controls whether an include file with 'INFLUENCE.INC' name is created. Default: False

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

@@ -536,32 +536,60 @@ def _cardano_cubic(c2, c1, c0, flag=0):
         return max(Zs)
     return Zs
 
-def _halley_cubic_vec(c2, c1, c0, max_iter=50, tol=1e-12):
+def _halley_cubic_vec(c2, c1, c0, A=None, B=None, max_iter=50, tol=1e-12):
     """Vectorized Halley solver: solve Z^3+c2*Z^2+c1*Z+c0=0 for max root (vapor Z).
     c2, c1, c0 are 1D arrays of length N. Returns 1D array of Z values.
-    Falls back to _cardano_cubic for any non-converged elements."""
-    N = len(c2)
-    Z = -c2 / 3.0
-    f0 = Z**3 + c2 * Z**2 + c1 * Z + c0
-    Z = np.where(f0 < 0, Z + 1.0, Z)
+    When A and B are provided, solves in Z* = Z - B space (per Aaron Zick's
+    reformulation) where all physical roots lie in (0, 1], giving more
+    robust convergence. Falls back to _cardano_cubic for any bad elements."""
+
+    if A is not None and B is not None:
+        # Z* = Z - B reformulation: Z*³ + d2·Z*² + d1·Z* + d0 = 0
+        # f*(0) = -2B² < 0, f*(1) = A >= 0, so largest root in (0, 1]
+        d2 = 4.0 * B - 1.0
+        d1 = A + 2.0 * B * (B - 2.0)
+        d0 = -2.0 * B * B
+
+        # Start at Z* = 1 (above largest root since f*(1) = A >= 0)
+        Zs = np.ones_like(c2)
+
+        for _ in range(max_iter):
+            f = Zs**3 + d2 * Zs**2 + d1 * Zs + d0
+            fp = 3.0 * Zs**2 + 2.0 * d2 * Zs + d1
+            fpp = 6.0 * Zs + 2.0 * d2
+            safe_fp = np.where(np.abs(fp) < 1e-30, 1e-30, fp)
+            dZ = f / safe_fp
+            denom = safe_fp - 0.5 * dZ * fpp
+            denom = np.where(np.abs(denom) < 1e-30, 1e-30, denom)
+            dZ = f / denom
+            Zs -= dZ
+            if np.max(np.abs(dZ)) < tol:
+                break
+
+        # Convert Z* -> Z; fallback to Cardano in Z space for bad elements
+        Z = Zs + B
+        f = Zs**3 + d2 * Zs**2 + d1 * Zs + d0
+        bad = (np.abs(f) > 1e-6) | (Zs <= 0.0)
+    else:
+        # Legacy path: solve directly in Z space with Cauchy upper bound
+        Z = 1.0 + np.maximum(np.abs(c2), np.maximum(np.abs(c1), np.abs(c0)))
+
+        for _ in range(max_iter):
+            f = Z**3 + c2 * Z**2 + c1 * Z + c0
+            fp = 3.0 * Z**2 + 2.0 * c2 * Z + c1
+            fpp = 6.0 * Z + 2.0 * c2
+            safe_fp = np.where(np.abs(fp) < 1e-30, 1e-30, fp)
+            dZ = f / safe_fp
+            denom = safe_fp - 0.5 * dZ * fpp
+            denom = np.where(np.abs(denom) < 1e-30, 1e-30, denom)
+            dZ = f / denom
+            Z -= dZ
+            if np.max(np.abs(dZ)) < tol:
+                break
 
-    for _ in range(max_iter):
         f = Z**3 + c2 * Z**2 + c1 * Z + c0
-        fp = 3.0 * Z**2 + 2.0 * c2 * Z + c1
-        fpp = 6.0 * Z + 2.0 * c2
-        # Protect against zero derivatives
-        safe_fp = np.where(np.abs(fp) < 1e-30, 1e-30, fp)
-        dZ = f / safe_fp
-        denom = safe_fp - 0.5 * dZ * fpp
-        denom = np.where(np.abs(denom) < 1e-30, 1e-30, denom)
-        dZ = f / denom
-        Z -= dZ
-        if np.max(np.abs(dZ)) < tol:
-            break
+        bad = (np.abs(f) > 1e-6) | (Z < 0.0)
 
-    # Check residuals and fall back to Cardano for any bad elements
-    f = Z**3 + c2 * Z**2 + c1 * Z + c0
-    bad = np.abs(f) > 1e-6
     if np.any(bad):
         bad_idx = np.where(bad)[0]
         for idx in bad_idx:
@@ -766,7 +794,7 @@ def gas_z(
         c0 = -(A * B - B**2 - B**3)
 
         # Solve all cubics at once - get max (vapor) root
-        Z_raw = _halley_cubic_vec(c2, c1_coeff, c0)    # (N,)
+        Z_raw = _halley_cubic_vec(c2, c1_coeff, c0, A=A, B=B)    # (N,)
 
         # Fugacity-based root selection for sub-critical conditions
         # When 3 real roots exist, the thermodynamically stable phase

{pyrestoolbox-3.1.0 → pyrestoolbox-3.1.2}/pyrestoolbox/simtools/simtools.py

@@ -64,6 +64,7 @@ import pandas as pd
 from tabulate import tabulate
 from ilt import gwr
 from mpmath import mp
+from pyrestoolbox._accelerator import RUST_AVAILABLE, _rust_module
 
 from pyrestoolbox.classes import (kr_family, kr_table, vlp_method,
                                   z_method, c_method, pb_method, rs_method,
@@ -720,7 +721,7 @@ def influence_tables(
     min_td: float = 0.01,
     max_td: float = 200,
     n_incr: int = 20,
-    M: int = 8,
+    M: int = 7,
     export: bool = False,
 ) -> Tuple:
     """ Returns a Tuple of;
@@ -734,7 +735,7 @@ def influence_tables(
         min_td: Minimum dimensionless time. Default = 0.01
         max_td: Maximum dimensionless time. Dfeault = 200
         n_incr: Number of increments to split dimensionless time into (log transformed), Default = 20
-        M: Laplace invesrion accuracy. Higher = more accurate, but more time. Generally 6-12 is good range. Default = 8
+        M: Laplace inversion accuracy. Higher = more accurate, but more time. Generally 6-12 is good range. Default = 7
         export: Boolean value that controls whether an include file with 'INFLUENCE.INC' name is created. Default: False
     """
     if len(ReDs) == 0:
@@ -742,26 +743,30 @@ def influence_tables(
     if min(ReDs) <=1:
         raise ValueError("ReDs must all be strictly greater than 1.0")
 
-    # Eq 23 from SPE 81428
-    def laplace_Ps(s: float, ReD: float):
-        x = mp.sqrt(s)
-        # pre-calculate duplicated bessel function for greater efficiency
-        i1sReD = mp.besseli(1, x * ReD)
-        k1sReD = mp.besselk(1, x * ReD)
-        numerator = k1sReD * mp.besseli(0, x) + i1sReD * mp.besselk(0, x)
-        denominator = s ** 1.5 * (
-            i1sReD * mp.besselk(1, x) - k1sReD * mp.besseli(1, x)
-        )
-        return numerator / denominator
-
     dtD = np.log(max_td / min_td) / n_incr
     tD = [np.exp(x * dtD + np.log(min_td)) for x in range(n_incr + 1)]
     tD = np.array(tD)
 
-    pDs = []
-    for ReD in ReDs:
-        print("Calculating ReD = " + str(ReD))
-        pDs.append(gwr(lambda s: laplace_Ps(s, ReD), tD, M))
+    # Rust fast path: Bessel + GWR entirely in Rust (no Python callbacks)
+    if RUST_AVAILABLE:
+        pDs = _rust_module.influence_tables_rust(tD.tolist(), list(ReDs), M)
+    else:
+        # Python fallback via ilt library
+        def laplace_Ps(s: float, ReD: float):
+            x = mp.sqrt(s)
+            # pre-calculate duplicated bessel function for greater efficiency
+            i1sReD = mp.besseli(1, x * ReD)
+            k1sReD = mp.besselk(1, x * ReD)
+            numerator = k1sReD * mp.besseli(0, x) + i1sReD * mp.besselk(0, x)
+            denominator = s ** 1.5 * (
+                i1sReD * mp.besselk(1, x) - k1sReD * mp.besseli(1, x)
+            )
+            return numerator / denominator
+
+        pDs = []
+        for ReD in ReDs:
+            print("Calculating ReD = " + str(ReD))
+            pDs.append(gwr(lambda s: laplace_Ps(s, ReD), tD, M))
 
     if export:
         inc_out = "---------------------------------------\n"

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

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

{pyrestoolbox-3.1.0 → pyrestoolbox-3.1.2}/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.0',  # Ideally should be same as your GitHub release tag version
+    version='3.1.2',  # 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.0 → pyrestoolbox-3.1.2}/src/gwr.rs

@@ -511,7 +511,7 @@ fn gwr_single(
 // =========================================================================
 
 #[pyfunction]
-#[pyo3(signature = (td_array, red_array, m=8))]
+#[pyo3(signature = (td_array, red_array, m=7))]
 pub fn influence_tables_rust(
     td_array: Vec<f64>,
     red_array: Vec<f64>,

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

@@ -288,37 +288,46 @@ fn cardano_cubic(c2: f64, c1: f64, c0: f64, flag: i32) -> f64 {
     }
 }
 
-/// Halley's method for finding max root of cubic z^3 + c2*z^2 + c1*z + c0 = 0
-fn halley_cubic(c2: f64, c1: f64, c0: f64) -> f64 {
-    let mut z = -c2 / 3.0;
-    let f0 = z * z * z + c2 * z * z + c1 * z + c0;
-    if f0 < 0.0 {
-        z += 1.0;
-    }
+/// Halley's method for finding max root of cubic z^3 + c2*z^2 + c1*z + c0 = 0,
+/// using Z* = Z - B transformation (per Aaron Zick's reformulation).
+/// For any standard cubic EOS with non-negative A, all physical Z* roots
+/// lie in (0, 1], eliminating negative/huge roots and guaranteeing convergence.
+/// Returns Z (not Z*), i.e. the B offset is added back before returning.
+fn halley_cubic_zstar(a_mix: f64, b_mix: f64) -> f64 {
+    // Z* cubic: Z*³ + d2·Z*² + d1·Z* + d0 = 0
+    // where f*(0) = d0 = -2B² < 0 and f*(1) = A >= 0
+    let d2 = 4.0 * b_mix - 1.0;
+    let d1 = a_mix + 2.0 * b_mix * (b_mix - 2.0);
+    let d0 = -2.0 * b_mix * b_mix;
+
+    // Start at Z* = 1 where f* = A >= 0 (above largest root).
+    let mut zs = 1.0_f64;
 
     for _ in 0..50 {
-        let f = z * z * z + c2 * z * z + c1 * z + c0;
-        let fp = 3.0 * z * z + 2.0 * c2 * z + c1;
-        let fpp = 6.0 * z + 2.0 * c2;
+        let f = zs * zs * zs + d2 * zs * zs + d1 * zs + d0;
+        let fp = 3.0 * zs * zs + 2.0 * d2 * zs + d1;
+        let fpp = 6.0 * zs + 2.0 * d2;
 
         let fp_safe = if fp.abs() < 1e-30 { 1e-30 } else { fp };
         let dz = f / fp_safe;
         let denom = fp_safe - 0.5 * dz * fpp;
         let denom_safe = if denom.abs() < 1e-30 { 1e-30 } else { denom };
         let dz_final = f / denom_safe;
-        z -= dz_final;
+        zs -= dz_final;
         if dz_final.abs() < 1e-12 {
             break;
         }
     }
 
-    // Verify convergence
-    let f = z * z * z + c2 * z * z + c1 * z + c0;
-    if f.abs() > 1e-6 {
-        // Fallback to Cardano
+    // Verify convergence; fallback to Cardano in Z space if needed
+    let f = zs * zs * zs + d2 * zs * zs + d1 * zs + d0;
+    if f.abs() > 1e-6 || zs <= 0.0 {
+        let c2 = -(1.0 - b_mix);
+        let c1 = a_mix - 3.0 * b_mix * b_mix - 2.0 * b_mix;
+        let c0 = -(a_mix * b_mix - b_mix * b_mix - b_mix * b_mix * b_mix);
         return cardano_cubic(c2, c1, c0, 1);
     }
-    z
+    zs + b_mix
 }
 
 fn bns_zfactor_core(
@@ -381,28 +390,29 @@ fn bns_zfactor_core(
         b_mix += zi[i] * bi[i];
     }
 
-    // Cubic coefficients: Z^3 + c2*Z^2 + c1*Z + c0 = 0
-    let c2 = -(1.0 - b_mix);
-    let c1 = a_mix - 3.0 * b_mix * b_mix - 2.0 * b_mix;
-    let c0 = -(a_mix * b_mix - b_mix * b_mix - b_mix * b_mix * b_mix);
-
-    // Solve cubic - get max (vapor) root
-    let z_max = halley_cubic(c2, c1, c0);
+    // Solve cubic in Z* = Z - B space (Aaron Zick reformulation)
+    let z_max = halley_cubic_zstar(a_mix, b_mix);
 
-    // Check for 3-root case (fugacity-based root selection)
-    let p_d = (3.0 * c1 - c2 * c2) / 3.0;
-    let q_d = (2.0 * c2 * c2 * c2 - 9.0 * c2 * c1 + 27.0 * c0) / 27.0;
+    // Fugacity-based root selection for sub-critical conditions.
+    // Use Z* cubic discriminant to check for 3-root case.
+    let d2 = 4.0 * b_mix - 1.0;
+    let d1 = a_mix + 2.0 * b_mix * (b_mix - 2.0);
+    let d0 = -2.0 * b_mix * b_mix;
+    let p_d = (3.0 * d1 - d2 * d2) / 3.0;
+    let q_d = (2.0 * d2 * d2 * d2 - 9.0 * d2 * d1 + 27.0 * d0) / 27.0;
     let disc = q_d * q_d / 4.0 + p_d * p_d * p_d / 27.0;
 
     let z_selected = if disc < -1e-15 {
-        // 3 real roots - find min root via deflation
-        let b_q = c2 + z_max;
-        let c_q = c1 + z_max * b_q;
+        // 3 real roots — find min root via deflation in Z* space
+        let zs_max = z_max - b_mix; // convert back to Z*
+        let b_q = d2 + zs_max;
+        let c_q = d1 + zs_max * b_q;
         let det = (b_q * b_q - 4.0 * c_q).max(0.0);
-        let z_min = (-b_q - det.sqrt()) / 2.0;
+        let zs_min = (-b_q - det.sqrt()) / 2.0;
+        let z_min = zs_min + b_mix; // convert to Z
 
-        // Fugacity comparison (Gibbs criterion)
-        if z_min > b_mix {
+        // Fugacity comparison (Gibbs criterion); Z > B ↔ Z* > 0
+        if zs_min > 0.0 {
             let sqrt2: f64 = std::f64::consts::SQRT_2;
             let s2p1 = 1.0 + sqrt2;
             let s2m1 = sqrt2 - 1.0;