pyrestoolbox 3.7.2__tar.gz → 3.7.4__tar.gz

{pyrestoolbox-3.7.2 → pyrestoolbox-3.7.4}/.gitignore

@@ -43,3 +43,6 @@ ilt/
 benchmark_ilt.py
 benchmark_rust.py
 BUILD_INSTRUCTIONS.txt
+
+# local virtualenv (389 MB, never committed)
+.venv/

{pyrestoolbox-3.7.2 → pyrestoolbox-3.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrestoolbox
-Version: 3.7.2
+Version: 3.7.4
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -55,6 +55,7 @@ Includes functions to perform calculations including;
 - Generation of AQUTAB include file influence functions for use in ECLIPSE
 - Creation of Corey, LET and Jerauld relative permeability tables in Eclipse format, with curve fitting support
 - Calculation of Methane, CO2 and multicomponent gas saturated brine properties (Soreide-Whitson VLE)
+- Multi-salt gas-free brine viscosity: IAPWS-2008 water, an ion-additive salt ratio over any combination of Na, K, Mg, Ca, Sr, Ba, Cl, Br, sulfate and carbonate, and a measured pressure factor
 - Method recommendation engine for selecting appropriate correlations based on fluid composition
 - Sensitivity analysis with parameter sweeps and tornado charts
 
@@ -127,7 +128,7 @@ Module List
    * - `library <https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/library.rst>`_
      - Return critical parameters for typical single components
    * - `brine <https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/brine.rst>`_
-     - Calculate suite of brine properties with variable methane, Calculate suite of CO2 saturated brine properties, Multicomponent gas-saturated brine (Soreide-Whitson VLE)
+     - Calculate suite of brine properties with variable methane, Calculate suite of CO2 saturated brine properties, Multicomponent gas-saturated brine (Soreide-Whitson VLE), multi-salt gas-free brine viscosity
    * - `layer <https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/layer.rst>`_
      - Lorenz coefficient from Beta value, Lorenz coefficient from flow fraction, Lorenz coefficient to flow fraction, Lorenz coefficient to permeability array
    * - `simtools <https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/simtools.rst>`_

{pyrestoolbox-3.7.2 → pyrestoolbox-3.7.4}/README.rst

@@ -29,6 +29,7 @@ Includes functions to perform calculations including;
 - Generation of AQUTAB include file influence functions for use in ECLIPSE
 - Creation of Corey, LET and Jerauld relative permeability tables in Eclipse format, with curve fitting support
 - Calculation of Methane, CO2 and multicomponent gas saturated brine properties (Soreide-Whitson VLE)
+- Multi-salt gas-free brine viscosity: IAPWS-2008 water, an ion-additive salt ratio over any combination of Na, K, Mg, Ca, Sr, Ba, Cl, Br, sulfate and carbonate, and a measured pressure factor
 - Method recommendation engine for selecting appropriate correlations based on fluid composition
 - Sensitivity analysis with parameter sweeps and tornado charts
 
@@ -101,7 +102,7 @@ Module List
    * - `library <https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/library.rst>`_
      - Return critical parameters for typical single components
    * - `brine <https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/brine.rst>`_
-     - Calculate suite of brine properties with variable methane, Calculate suite of CO2 saturated brine properties, Multicomponent gas-saturated brine (Soreide-Whitson VLE)
+     - Calculate suite of brine properties with variable methane, Calculate suite of CO2 saturated brine properties, Multicomponent gas-saturated brine (Soreide-Whitson VLE), multi-salt gas-free brine viscosity
    * - `layer <https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/layer.rst>`_
      - Lorenz coefficient from Beta value, Lorenz coefficient from flow fraction, Lorenz coefficient to flow fraction, Lorenz coefficient to permeability array
    * - `simtools <https://github.com/mwburgoyne/pyResToolbox/blob/main/pyrestoolbox/docs/simtools.rst>`_

pyrestoolbox-3.7.4/benchmark_batch.py

@@ -0,0 +1,160 @@
+"""Benchmark: Batch vs scalar Rust dispatch for gas_z and gas_ug."""
+
+import time
+import numpy as np
+import sys
+sys.path.insert(0, '/home/mark/projects')
+
+from pyrestoolbox._native import (
+    bns_zfactor_full, bns_zfactor_batch,
+    dak_zfactor_full, dak_zfactor_batch,
+    hy_zfactor_batch, hall_yarborough_zfactor_full,
+    gas_ug_lge, gas_ug_lge_batch,
+    gas_ug_lbc, gas_ug_lbc_batch,
+)
+from pyrestoolbox import gas as gmod
+import pyrestoolbox.gas.gas as gas_mod
+
+N_POINTS = 10_000
+N_REPEATS = 20
+pressures = np.linspace(14.7, 15000, N_POINTS)
+p_list = pressures.tolist()
+
+# Common parameters
+sg, degf = 0.7, 200.0
+co2, h2s, n2, h2 = 0.01, 0.0, 0.02, 0.0
+
+print(f"Batch vs Scalar Rust dispatch: {N_POINTS} pressure points, {N_REPEATS} repeats")
+print("=" * 80)
+
+def bench(name, fn, repeats=N_REPEATS):
+    times = []
+    result = None
+    for _ in range(repeats):
+        t0 = time.perf_counter()
+        result = fn()
+        t1 = time.perf_counter()
+        times.append(t1 - t0)
+    return np.median(times) * 1000, np.min(times) * 1000, result
+
+# ==================== Z-Factor ====================
+print("\n--- Z-Factor: BNS Method ---")
+_, t_scalar, z_scalar = bench("BNS scalar", lambda: np.array([
+    bns_zfactor_full(float(pi), degf, sg, co2, h2s, n2, h2) for pi in pressures
+]))
+_, t_batch, z_batch = bench("BNS batch", lambda: np.array(
+    bns_zfactor_batch(p_list, degf, sg, co2, h2s, n2, h2)
+))
+
+# Also benchmark pure Python (Rust disabled)
+orig_rust = gas_mod.RUST_AVAILABLE
+gas_mod.RUST_AVAILABLE = False
+_, t_python, z_python = bench("BNS Python", lambda: gmod.gas_z(
+    pressures, sg, degf, zmethod='BNS', co2=co2, h2s=h2s, n2=n2, h2=h2
+))
+gas_mod.RUST_AVAILABLE = orig_rust
+
+print(f"  {'Method':<30} {'Min (ms)':>10} {'Speedup':>10}")
+print(f"  {'-'*55}")
+print(f"  {'Python (NumPy vectorized)':<30} {t_python:>10.2f} {'baseline':>10}")
+print(f"  {'Rust scalar (N FFI calls)':<30} {t_scalar:>10.2f} {t_python/t_scalar:>10.1f}x")
+print(f"  {'Rust batch  (1 FFI call)':<30} {t_batch:>10.2f} {t_python/t_batch:>10.1f}x")
+print(f"  Batch vs scalar speedup: {t_scalar/t_batch:.1f}x")
+print(f"  Max |batch - scalar|: {np.max(np.abs(z_batch - z_scalar)):.2e}")
+
+# DAK
+print("\n--- Z-Factor: DAK Method (SUT critical props) ---")
+_, t_dak_scalar, z_dak_s = bench("DAK scalar", lambda: np.array([
+    dak_zfactor_full(float(pi), degf, sg, co2, h2s, n2) for pi in pressures
+]))
+_, t_dak_batch, z_dak_b = bench("DAK batch", lambda: np.array(
+    dak_zfactor_batch(p_list, degf, sg, co2, h2s, n2)
+))
+gas_mod.RUST_AVAILABLE = False
+_, t_dak_py, _ = bench("DAK Python", lambda: gmod.gas_z(
+    pressures, sg, degf, zmethod='DAK', cmethod='SUT', co2=co2, h2s=h2s, n2=n2
+))
+gas_mod.RUST_AVAILABLE = orig_rust
+
+print(f"  {'Method':<30} {'Min (ms)':>10} {'Speedup':>10}")
+print(f"  {'-'*55}")
+print(f"  {'Python (NumPy vectorized)':<30} {t_dak_py:>10.2f} {'baseline':>10}")
+print(f"  {'Rust scalar (N FFI calls)':<30} {t_dak_scalar:>10.2f} {t_dak_py/t_dak_scalar:>10.1f}x")
+print(f"  {'Rust batch  (1 FFI call)':<30} {t_dak_batch:>10.2f} {t_dak_py/t_dak_batch:>10.1f}x")
+print(f"  Batch vs scalar speedup: {t_dak_scalar/t_dak_batch:.1f}x")
+print(f"  Max |batch - scalar|: {np.max(np.abs(z_dak_b - z_dak_s)):.2e}")
+
+# HY
+print("\n--- Z-Factor: HY Method (SUT critical props) ---")
+_, t_hy_scalar, z_hy_s = bench("HY scalar", lambda: np.array([
+    hall_yarborough_zfactor_full(float(pi), degf, sg, co2, h2s, n2) for pi in pressures
+]))
+_, t_hy_batch, z_hy_b = bench("HY batch", lambda: np.array(
+    hy_zfactor_batch(p_list, degf, sg, co2, h2s, n2)
+))
+gas_mod.RUST_AVAILABLE = False
+_, t_hy_py, _ = bench("HY Python", lambda: gmod.gas_z(
+    pressures, sg, degf, zmethod='HY', cmethod='SUT', co2=co2, h2s=h2s, n2=n2
+))
+gas_mod.RUST_AVAILABLE = orig_rust
+
+print(f"  {'Method':<30} {'Min (ms)':>10} {'Speedup':>10}")
+print(f"  {'-'*55}")
+print(f"  {'Python (NumPy vectorized)':<30} {t_hy_py:>10.2f} {'baseline':>10}")
+print(f"  {'Rust scalar (N FFI calls)':<30} {t_hy_scalar:>10.2f} {t_hy_py/t_hy_scalar:>10.1f}x")
+print(f"  {'Rust batch  (1 FFI call)':<30} {t_hy_batch:>10.2f} {t_hy_py/t_hy_batch:>10.1f}x")
+print(f"  Batch vs scalar speedup: {t_hy_scalar/t_hy_batch:.1f}x")
+print(f"  Max |batch - scalar|: {np.max(np.abs(z_hy_b - z_hy_s)):.2e}")
+
+# ==================== Viscosity ====================
+print("\n--- Viscosity: LGE Method ---")
+z_dak = np.array(dak_zfactor_batch(p_list, degf, sg, co2, h2s, n2))
+_, t_lge_scalar, ug_lge_s = bench("LGE scalar", lambda: np.array([
+    gas_ug_lge(float(pi), sg, degf, float(zi)) for pi, zi in zip(pressures, z_dak)
+]))
+_, t_lge_batch, ug_lge_b = bench("LGE batch", lambda: np.array(
+    gas_ug_lge_batch(p_list, z_dak.tolist(), sg, degf)
+))
+print(f"  {'Method':<30} {'Min (ms)':>10} {'Speedup':>10}")
+print(f"  {'-'*55}")
+print(f"  {'Rust scalar (N FFI calls)':<30} {t_lge_scalar:>10.2f} {'baseline':>10}")
+print(f"  {'Rust batch  (1 FFI call)':<30} {t_lge_batch:>10.2f} {t_lge_scalar/t_lge_batch:>10.1f}x")
+print(f"  Max |batch - scalar|: {np.max(np.abs(ug_lge_b - ug_lge_s)):.2e}")
+
+print("\n--- Viscosity: LBC Method (BNS) ---")
+z_bns = np.array(bns_zfactor_batch(p_list, degf, sg, co2, h2s, n2, h2))
+_, t_lbc_scalar, ug_lbc_s = bench("LBC scalar", lambda: np.array([
+    gas_ug_lbc(float(pi), sg, degf, co2, h2s, n2, h2, float(zi)) for pi, zi in zip(pressures, z_bns)
+]))
+_, t_lbc_batch, ug_lbc_b = bench("LBC batch", lambda: np.array(
+    gas_ug_lbc_batch(p_list, z_bns.tolist(), sg, degf, co2, h2s, n2, h2)
+))
+print(f"  {'Method':<30} {'Min (ms)':>10} {'Speedup':>10}")
+print(f"  {'-'*55}")
+print(f"  {'Rust scalar (N FFI calls)':<30} {t_lbc_scalar:>10.2f} {'baseline':>10}")
+print(f"  {'Rust batch  (1 FFI call)':<30} {t_lbc_batch:>10.2f} {t_lbc_scalar/t_lbc_batch:>10.1f}x")
+print(f"  Max |batch - scalar|: {np.max(np.abs(ug_lbc_b - ug_lbc_s)):.2e}")
+
+# ==================== Full Pipeline (gas_z + gas_ug via public API) ====================
+print("\n" + "=" * 80)
+print("--- Full Pipeline: gas_z() + gas_ug() via public API ---")
+
+# With batch Rust (current)
+gas_mod.RUST_AVAILABLE = True
+_, t_full_batch, _ = bench("Batch Rust", lambda: (
+    gmod.gas_z(pressures, sg, degf, zmethod='BNS', co2=co2, h2s=h2s, n2=n2, h2=h2),
+    gmod.gas_ug(pressures, sg, degf, zmethod='BNS', co2=co2, h2s=h2s, n2=n2, h2=h2),
+))
+
+# Pure Python
+gas_mod.RUST_AVAILABLE = False
+_, t_full_python, _ = bench("Python", lambda: (
+    gmod.gas_z(pressures, sg, degf, zmethod='BNS', co2=co2, h2s=h2s, n2=n2, h2=h2),
+    gmod.gas_ug(pressures, sg, degf, zmethod='BNS', co2=co2, h2s=h2s, n2=n2, h2=h2),
+))
+gas_mod.RUST_AVAILABLE = orig_rust
+
+print(f"  {'Method':<30} {'Min (ms)':>10} {'Speedup':>10}")
+print(f"  {'-'*55}")
+print(f"  {'Python (NumPy vectorized)':<30} {t_full_python:>10.2f} {'baseline':>10}")
+print(f"  {'Rust batch (2 FFI calls)':<30} {t_full_batch:>10.2f} {t_full_python/t_full_batch:>10.1f}x")

pyrestoolbox-3.7.4/benchmark_viscosity.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""
+BNS Viscosity Benchmark: Rust-accelerated vs Pure Python
+
+Replicates the benchmarking approach from Peter Kirkham's analysis at
+https://pkirkham.github.io/analysis/viscosity-bns/
+
+Runs randomised BNS viscosity calculations in 5-second windows, comparing
+Rust-accelerated pyResToolbox against the pure-Python fallback. Reports
+calculations per second for single and batch (1000-pressure) modes, and
+produces a logarithmic bar chart.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import time
+
+# ── Benchmark code executed inside subprocesses ──────────────────────────
+
+BENCHMARK_CODE = r'''
+import time
+import random
+import numpy as np
+from pyrestoolbox import gas
+from pyrestoolbox.classes import z_method, c_method
+
+P_SC = 14.7    # psia
+T_SC = 60.0    # degF
+DURATION = 5.0 # seconds per benchmark window
+
+def random_between(a, b):
+    return a + (b - a) * random.random()
+
+def run_single(duration=DURATION):
+    """Single-pressure calculations, one at a time."""
+    count = 0
+    start = time.time()
+    while time.time() - start < duration:
+        p = random_between(P_SC, 15000.0)
+        t = random_between(T_SC, 300.0)
+        sg = random_between(0.65, 0.9)
+        if random.random() < 0.3:
+            inert_frac = random.random()
+            co2 = random_between(0.0, inert_frac)
+            h2s = random_between(0.0, 1.0 - co2)
+            n2  = random_between(0.0, 1.0 - co2 - h2s)
+            h2  = random_between(0.0, 1.0 - co2 - h2s - n2)
+        else:
+            co2 = h2s = n2 = h2 = 0.0
+
+        mu = gas.gas_ug(p=p, sg=sg, degf=t,
+                        zmethod=z_method.BNS, cmethod=c_method.BNS,
+                        co2=co2, h2s=h2s, n2=n2, h2=h2)
+        assert np.all(np.isfinite(mu)) and np.all(mu > 0)
+        count += 1
+
+    elapsed = time.time() - start
+    return count / elapsed
+
+def run_batch(n_samples=1000, duration=DURATION):
+    """Batch-pressure calculations, n_samples pressures per iteration."""
+    rng = np.random.default_rng()
+    count = 0
+    start = time.time()
+    while time.time() - start < duration:
+        p = rng.uniform(P_SC, 15000.0, size=n_samples)
+        t = random_between(T_SC, 300.0)
+        sg = random_between(0.65, 0.9)
+        if random.random() < 0.3:
+            inert_frac = random.random()
+            co2 = random_between(0.0, inert_frac)
+            h2s = random_between(0.0, 1.0 - co2)
+            n2  = random_between(0.0, 1.0 - co2 - h2s)
+            h2  = random_between(0.0, 1.0 - co2 - h2s - n2)
+        else:
+            co2 = h2s = n2 = h2 = 0.0
+
+        mu = gas.gas_ug(p=p, sg=sg, degf=t,
+                        zmethod=z_method.BNS, cmethod=c_method.BNS,
+                        co2=co2, h2s=h2s, n2=n2, h2=h2)
+        assert np.all(np.isfinite(mu)) and np.all(mu > 0)
+        count += n_samples
+
+    elapsed = time.time() - start
+    return count / elapsed
+
+import json
+single_rate = run_single()
+batch_rate = run_batch()
+print(json.dumps({"single": single_rate, "batch": batch_rate}))
+'''
+
+
+def run_subprocess(env_override=None):
+    """Run the benchmark in a subprocess, return dict with single/batch rates."""
+    env = os.environ.copy()
+    if env_override:
+        env.update(env_override)
+
+    code = f"import sys, os\nsys.path.insert(0, {os.getcwd()!r})\n{BENCHMARK_CODE}"
+    result = subprocess.run(
+        [sys.executable, "-c", code],
+        capture_output=True, text=True, env=env, timeout=120
+    )
+    if result.returncode != 0:
+        print(f"  ERROR: {result.stderr.strip()[:200]}")
+        return None
+    try:
+        return json.loads(result.stdout.strip().split("\n")[-1])
+    except (json.JSONDecodeError, IndexError):
+        print(f"  Bad output: {result.stdout[:200]}")
+        return None
+
+
+def main():
+    print("=" * 70)
+    print("  BNS Viscosity Benchmark: Rust vs Pure Python")
+    print("  (after P. Kirkham, https://pkirkham.github.io/analysis/viscosity-bns/)")
+    print("=" * 70)
+    print()
+    print("  Parameters:")
+    print("    Pressure:    14.7 – 15,000 psia (uniform random)")
+    print("    Temperature: 60 – 300 °F (uniform random)")
+    print("    SG:          0.65 – 0.9 (uniform random)")
+    print("    Inerts:      30% chance of CO2/H2S/N2/H2")
+    print("    Duration:    5 s per test window")
+    print("    Batch size:  1,000 pressures per call")
+    print()
+
+    # ── Rust-accelerated run ─────────────────────────────────────────────
+    print("  Running Rust-accelerated benchmark...", flush=True)
+    rust = run_subprocess()
+    if rust is None:
+        print("  Rust benchmark failed!")
+        return
+
+    print(f"    Single: {rust['single']:>10,.0f} calc/s")
+    print(f"    Batch:  {rust['batch']:>10,.0f} calc/s")
+    print()
+
+    # ── Pure Python run ──────────────────────────────────────────────────
+    print("  Running pure-Python benchmark...", flush=True)
+    python = run_subprocess(env_override={"PYRESTOOLBOX_NO_RUST": "1"})
+    if python is None:
+        print("  Python benchmark failed!")
+        return
+
+    print(f"    Single: {python['single']:>10,.0f} calc/s")
+    print(f"    Batch:  {python['batch']:>10,.0f} calc/s")
+    print()
+
+    # ── Summary table ────────────────────────────────────────────────────
+    speedup_single = rust["single"] / python["single"] if python["single"] > 0 else 0
+    speedup_batch = rust["batch"] / python["batch"] if python["batch"] > 0 else 0
+
+    print("  ┌─────────────────┬──────────────┬──────────────┬──────────┐")
+    print("  │ Mode            │ Rust (calc/s)│Python (calc/s)│ Speedup  │")
+    print("  ├─────────────────┼──────────────┼──────────────┼──────────┤")
+    print(f"  │ Single pressure │ {rust['single']:>12,.0f}│{python['single']:>14,.0f}│ {speedup_single:>7.1f}x │")
+    print(f"  │ 1000x batch     │ {rust['batch']:>12,.0f}│{python['batch']:>14,.0f}│ {speedup_batch:>7.1f}x │")
+    print("  └─────────────────┴──────────────┴──────────────┴──────────┘")
+    print()
+
+    # ── Bar chart ────────────────────────────────────────────────────────
+    try:
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+        import numpy as np
+
+        labels = ["Python\nSingle", "Rust\nSingle", "Python\nBatch (1000)", "Rust\nBatch (1000)"]
+        rates = [python["single"], rust["single"], python["batch"], rust["batch"]]
+        colors = ["#4878CF", "#D65F5F", "#4878CF", "#D65F5F"]
+        hatches = ["", "", "//", "//"]
+
+        fig, ax = plt.subplots(figsize=(8, 5))
+        bars = ax.bar(labels, rates, color=colors, edgecolor="black", linewidth=0.8)
+        for bar, h in zip(bars, hatches):
+            bar.set_hatch(h)
+
+        ax.set_yscale("log")
+        ax.set_ylabel("BNS Viscosity Calculations per Second")
+        ax.set_title("BNS Viscosity Benchmark: Rust-accelerated vs Pure Python\n"
+                      "(P: 14.7–15,000 psia, T: 60–300 °F, SG: 0.65–0.9, 30% inerts)")
+        ax.grid(axis="y", which="both", alpha=0.3)
+
+        # Annotate bars with values
+        for bar, rate in zip(bars, rates):
+            ax.text(bar.get_x() + bar.get_width() / 2, rate * 1.3,
+                    f"{rate:,.0f}/s", ha="center", va="bottom", fontsize=10, fontweight="bold")
+
+        # Add speedup annotations
+        ax.annotate(f"{speedup_single:.1f}x", xy=(1, rust["single"]),
+                    xytext=(0.5, rust["single"] * 3),
+                    arrowprops=dict(arrowstyle="->", color="green", lw=1.5),
+                    fontsize=11, color="green", fontweight="bold", ha="center")
+        ax.annotate(f"{speedup_batch:.1f}x", xy=(3, rust["batch"]),
+                    xytext=(2.5, rust["batch"] * 3),
+                    arrowprops=dict(arrowstyle="->", color="green", lw=1.5),
+                    fontsize=11, color="green", fontweight="bold", ha="center")
+
+        plt.tight_layout()
+        outpath = os.path.join(os.path.dirname(__file__) or ".", "benchmark_viscosity.png")
+        plt.savefig(outpath, dpi=150)
+        print(f"  Chart saved to: {outpath}")
+    except ImportError:
+        print("  (matplotlib not available — skipping chart)")
+
+
+if __name__ == "__main__":
+    main()

pyrestoolbox-3.7.4/benchmark_zfactor.py

@@ -0,0 +1,207 @@
+"""Benchmark: Halley (Z*=Z-B) vs Cardano analytical solver for PR-EOS cubic.
+
+Tests both pure Python and Rust-accelerated paths.
+"""
+
+import time
+import numpy as np
+import sys
+sys.path.insert(0, '/home/mark/projects')
+
+from pyrestoolbox.gas.gas import _cardano_cubic, _halley_cubic_vec
+
+# ---------- Setup: generate realistic cubic coefficients ----------
+# Use BNS-style PR-EOS coefficients for a range of pressures
+# Simulate a typical gas: sg=0.7, T=200F, pressures 14.7 to 15000 psia
+np.random.seed(42)
+
+N_POINTS = 10_000  # Number of pressure points to solve
+
+# Realistic ranges for A and B from PR-EOS mixing rules
+# A ~ 0.01 to 5.0, B ~ 0.001 to 0.5
+A = np.random.uniform(0.01, 5.0, N_POINTS)
+B = np.random.uniform(0.005, 0.5, N_POINTS)
+
+# PR cubic coefficients: Z^3 - (1-B)*Z^2 + (A-3B^2-2B)*Z - (AB-B^2-B^3) = 0
+c2 = -(1.0 - B)
+c1 = A - 3.0 * B**2 - 2.0 * B
+c0 = -(A * B - B**2 - B**3)
+
+# ---------- Pure Python benchmarks ----------
+N_REPEATS = 20
+
+print(f"Benchmarking Z-factor solvers: {N_POINTS} cubic equations, {N_REPEATS} repeats")
+print("=" * 70)
+
+# --- Halley (vectorized, Z* reformulation) ---
+times_halley = []
+for _ in range(N_REPEATS):
+    t0 = time.perf_counter()
+    Z_halley = _halley_cubic_vec(c2.copy(), c1.copy(), c0.copy(), A=A, B=B)
+    t1 = time.perf_counter()
+    times_halley.append(t1 - t0)
+
+halley_median = np.median(times_halley) * 1000
+halley_min = np.min(times_halley) * 1000
+
+# --- Cardano (element-by-element, analytical) ---
+times_cardano = []
+for _ in range(N_REPEATS):
+    t0 = time.perf_counter()
+    Z_cardano = np.array([_cardano_cubic(c2[i], c1[i], c0[i], flag=1) for i in range(N_POINTS)])
+    t1 = time.perf_counter()
+    times_cardano.append(t1 - t0)
+
+cardano_median = np.median(times_cardano) * 1000
+cardano_min = np.min(times_cardano) * 1000
+
+# --- Halley without Z* (legacy path, for comparison) ---
+times_halley_legacy = []
+for _ in range(N_REPEATS):
+    t0 = time.perf_counter()
+    Z_halley_leg = _halley_cubic_vec(c2.copy(), c1.copy(), c0.copy())
+    t1 = time.perf_counter()
+    times_halley_legacy.append(t1 - t0)
+
+halley_leg_median = np.median(times_halley_legacy) * 1000
+halley_leg_min = np.min(times_halley_legacy) * 1000
+
+print("\n--- Pure Python Results ---")
+print(f"{'Method':<30} {'Median (ms)':>12} {'Min (ms)':>12} {'Speedup':>10}")
+print("-" * 70)
+print(f"{'Halley Z* (vectorized)':<30} {halley_median:>12.2f} {halley_min:>12.2f} {'baseline':>10}")
+print(f"{'Halley legacy (vectorized)':<30} {halley_leg_median:>12.2f} {halley_leg_min:>12.2f} {halley_min/halley_leg_min:>10.2f}x")
+print(f"{'Cardano (scalar loop)':<30} {cardano_median:>12.2f} {cardano_min:>12.2f} {halley_min/cardano_min:>10.2f}x")
+
+# Verify agreement
+max_diff = np.max(np.abs(Z_halley - Z_cardano))
+print(f"\nMax |Z_halley - Z_cardano|: {max_diff:.2e}")
+
+# Count Halley fallbacks (where Halley needed Cardano backup)
+d2 = 4.0 * B - 1.0
+d1_star = A + 2.0 * B * (B - 2.0)
+d0_star = -2.0 * B * B
+Zs_check = Z_halley - B
+f_check = Zs_check**3 + d2 * Zs_check**2 + d1_star * Zs_check + d0_star
+n_fallback = np.sum((np.abs(f_check) > 1e-6) | (Zs_check <= 0))
+print(f"Halley Z* fallbacks to Cardano: {n_fallback}/{N_POINTS}")
+
+# ---------- Rust benchmarks ----------
+print("\n" + "=" * 70)
+try:
+    from pyrestoolbox.gas.gas import _rust_module, RUST_AVAILABLE
+    if not RUST_AVAILABLE:
+        raise ImportError("Rust module not available")
+    print("Rust module loaded successfully")
+
+    # For Rust, we need to go through the full BNS path which includes
+    # mixing rules. Let's benchmark the full gas_z call instead.
+    from pyrestoolbox import gas as gmod
+
+    # Test parameters
+    sg = 0.7
+    degf = 200.0
+    co2, h2s, n2, h2 = 0.01, 0.0, 0.02, 0.0
+    pressures = np.linspace(14.7, 15000, N_POINTS).tolist()
+
+    # --- Rust BNS path ---
+    # Force Rust
+    times_rust = []
+    for _ in range(N_REPEATS):
+        t0 = time.perf_counter()
+        z_rust = np.array([_rust_module.bns_zfactor_full(
+            float(pi), float(degf), float(sg),
+            float(co2), float(h2s), float(n2), float(h2)
+        ) for pi in pressures])
+        t1 = time.perf_counter()
+        times_rust.append(t1 - t0)
+
+    rust_median = np.median(times_rust) * 1000
+    rust_min = np.min(times_rust) * 1000
+
+    # --- Python BNS path (force by temporarily hiding Rust) ---
+    import pyrestoolbox.gas.gas as gas_mod
+    orig_rust = gas_mod.RUST_AVAILABLE
+    gas_mod.RUST_AVAILABLE = False
+
+    times_python_full = []
+    for _ in range(N_REPEATS):
+        t0 = time.perf_counter()
+        z_python = gmod.gas_z(pressures, sg, degf, zmethod='BNS',
+                              co2=co2, h2s=h2s, n2=n2, h2=h2)
+        t1 = time.perf_counter()
+        times_python_full.append(t1 - t0)
+
+    gas_mod.RUST_AVAILABLE = orig_rust
+
+    python_full_median = np.median(times_python_full) * 1000
+    python_full_min = np.min(times_python_full) * 1000
+
+    # --- Rust with Cardano-only path ---
+    # Check if Rust module has a cardano-only entry point
+    has_cardano_only = hasattr(_rust_module, 'bns_zfactor_full_cardano')
+
+    print("\n--- Full BNS Z-Factor Pipeline (mixing rules + solve + fugacity) ---")
+    print(f"{'Method':<30} {'Median (ms)':>12} {'Min (ms)':>12} {'Speedup':>10}")
+    print("-" * 70)
+    print(f"{'Python Halley Z*':<30} {python_full_median:>12.2f} {python_full_min:>12.2f} {'baseline':>10}")
+    print(f"{'Rust Halley Z* (scalar loop)':<30} {rust_median:>12.2f} {rust_min:>12.2f} {python_full_min/rust_min:>10.1f}x")
+
+    max_diff_full = np.max(np.abs(np.array(z_rust) - np.array(z_python)))
+    print(f"\nMax |Z_rust - Z_python|: {max_diff_full:.2e}")
+
+    if has_cardano_only:
+        times_rust_cardano = []
+        for _ in range(N_REPEATS):
+            t0 = time.perf_counter()
+            z_rc = np.array([_rust_module.bns_zfactor_full_cardano(
+                float(pi), float(degf), float(sg),
+                float(co2), float(h2s), float(n2), float(h2)
+            ) for pi in pressures])
+            t1 = time.perf_counter()
+            times_rust_cardano.append(t1 - t0)
+        rc_median = np.median(times_rust_cardano) * 1000
+        rc_min = np.min(times_rust_cardano) * 1000
+        print(f"{'Rust Cardano (scalar loop)':<30} {rc_median:>12.2f} {rc_min:>12.2f} {python_full_min/rc_min:>10.1f}x")
+
+except ImportError as e:
+    print(f"Rust module not available: {e}")
+    print("Skipping Rust benchmarks.")
+
+# ---------- Iteration count analysis ----------
+print("\n" + "=" * 70)
+print("--- Halley Z* Iteration Count Analysis ---")
+
+# Count how many iterations Halley needs
+iter_counts = np.zeros(N_POINTS, dtype=int)
+d2 = 4.0 * B - 1.0
+d1_star = A + 2.0 * B * (B - 2.0)
+d0_star = -2.0 * B * B
+
+Zs = np.ones(N_POINTS)
+for it in range(50):
+    f = Zs**3 + d2 * Zs**2 + d1_star * Zs + d0_star
+    fp = 3.0 * Zs**2 + 2.0 * d2 * Zs + d1_star
+    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
+
+    # Mark converged
+    not_converged = np.abs(dZ) >= 1e-12
+    iter_counts[not_converged] = it + 1
+
+# The ones that converged at iteration X have iter_counts = X
+# The ones still at 0 converged in 1 iteration
+iter_counts[iter_counts == 0] = 1
+
+print(f"Mean iterations: {np.mean(iter_counts):.1f}")
+print(f"Max iterations:  {np.max(iter_counts)}")
+print(f"Distribution:")
+for i in range(1, min(np.max(iter_counts) + 1, 15)):
+    count = np.sum(iter_counts == i)
+    if count > 0:
+        print(f"  {i} iterations: {count:>6} ({100*count/N_POINTS:.1f}%)")