prbs-eos 0.1.0__py3-none-any.whl

prbs_eos/__init__.py

@@ -0,0 +1,6 @@
+from .constants import R
+from .data import Component, Mixture, get_component, available_components
+from .core import PREOS, PRBSEOS, solve_cubic, select_z
+from .equilibrium import flash_pt, FlashResult, is_stable
+from .thermodynamics import enthalpy_departure, entropy_departure
+from .regression import regress_kij, regress_vpaa

prbs_eos/__main__.py

@@ -0,0 +1,4 @@
+"""Allow running the CLI via ``python -m prbs_eos``."""
+from .cli import main
+
+main()

prbs_eos/cli.py

@@ -0,0 +1,308 @@
+"""
+prbs-eos command-line interface.
+
+Usage examples
+--------------
+    prbs-eos components
+    prbs-eos properties methane
+    prbs-eos flash    --T 250 --P 1e6  --mix methane:0.6 propane:0.4
+    prbs-eos zfactor  --T 300 --P 2e6  --mix methane:0.7 propane:0.3 --phase vapor
+    prbs-eos fugacity --T 300 --P 2e6  --mix methane:0.7 propane:0.3 --phase vapor
+    prbs-eos bubble   --T 250          --mix methane:0.5 propane:0.5  --P-guess 2e6
+    prbs-eos dew      --T 250          --mix methane:0.5 propane:0.5  --P-guess 2e6
+    prbs-eos enthalpy --T 300 --P 2e6  --mix methane:0.7 propane:0.3 --phase vapor
+"""
+
+import argparse
+import json
+import sys
+import numpy as np
+
+from . import (
+    Mixture, PREOS, get_component, available_components,
+    flash_pt, enthalpy_departure, entropy_departure,
+)
+from .equilibrium.phase_envelope import bubble_point_P, dew_point_P
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _parse_mix(mix_tokens: list[str]) -> tuple[Mixture, np.ndarray]:
+    """
+    Parse ``['methane:0.6', 'propane:0.4']`` into a (Mixture, z) pair.
+    Mole fractions are normalised to sum to 1.
+    """
+    comps, fracs = [], []
+    for token in mix_tokens:
+        if ":" not in token:
+            _die(f"Bad mixture token '{token}'. Expected format: name:fraction")
+        name, frac_str = token.rsplit(":", 1)
+        try:
+            frac = float(frac_str)
+        except ValueError:
+            _die(f"Cannot parse fraction '{frac_str}' in token '{token}'")
+        if frac < 0:
+            _die(f"Negative mole fraction in token '{token}'")
+        comps.append(get_component(name.strip()))
+        fracs.append(frac)
+    z = np.array(fracs, dtype=float)
+    total = z.sum()
+    if total <= 0:
+        _die("Mole fractions sum to zero.")
+    z /= total
+    return Mixture(comps), z
+
+
+def _die(msg: str) -> None:
+    print(f"ERROR: {msg}", file=sys.stderr)
+    sys.exit(1)
+
+
+def _out(data: dict, as_json: bool) -> None:
+    """Print result as a formatted table or JSON."""
+    if as_json:
+        print(json.dumps(data, indent=2))
+    else:
+        for key, val in data.items():
+            if isinstance(val, dict):
+                print(f"  {key}:")
+                for k2, v2 in val.items():
+                    print(f"    {k2:<20s} {v2}")
+            else:
+                print(f"  {key:<26s} {val}")
+
+
+# ---------------------------------------------------------------------------
+# Sub-command handlers
+# ---------------------------------------------------------------------------
+
+def cmd_components(_args) -> None:
+    print("Built-in components:")
+    for name in available_components():
+        print(f"  {name}")
+
+
+def cmd_properties(args) -> None:
+    try:
+        c = get_component(args.name)
+    except KeyError as e:
+        _die(str(e))
+    data = {
+        "name":         c.name,
+        "Tc (K)":       f"{c.Tc:.2f}",
+        "Pc (MPa)":     f"{c.Pc / 1e6:.4f}",
+        "omega":        f"{c.omega:.4f}",
+        "Mw (g/mol)":   f"{c.Mw:.3f}",
+        "c (m3/mol)":   f"{c.c:.3e}",
+        "epsilon (J/mol)": f"{c.epsilon:.2f}",
+        "kappa":        f"{c.kappa:.4f}",
+        "assoc_sites":  str(c.assoc_sites),
+    }
+    _out(data, args.json)
+
+
+def cmd_flash(args) -> None:
+    try:
+        mix, z = _parse_mix(args.mix)
+    except KeyError as e:
+        _die(str(e))
+    eos = PREOS(mix)
+    res = flash_pt(eos, T=args.T, P=args.P, z=z)
+    names = [c.name for c in mix.components]
+    data = {
+        "T (K)":            f"{args.T:.2f}",
+        "P (MPa)":          f"{args.P / 1e6:.4f}",
+        "vapour fraction beta":f"{res.beta:.6f}",
+        "converged":        str(res.converged),
+        "iterations":       str(res.iterations),
+        "liquid  x": {n: f"{v:.6f}" for n, v in zip(names, res.x)},
+        "vapour  y": {n: f"{v:.6f}" for n, v in zip(names, res.y)},
+        "K-factors": {n: f"{v:.6f}" for n, v in zip(names, res.K)},
+    }
+    _out(data, args.json)
+
+
+def cmd_zfactor(args) -> None:
+    try:
+        mix, z = _parse_mix(args.mix)
+    except KeyError as e:
+        _die(str(e))
+    eos = PREOS(mix)
+    Z = eos.Z_factor(T=args.T, P=args.P, z=z, phase=args.phase)
+    data = {
+        "T (K)":    f"{args.T:.2f}",
+        "P (MPa)":  f"{args.P / 1e6:.4f}",
+        "phase":    args.phase,
+        "Z-factor": f"{Z:.6f}",
+    }
+    _out(data, args.json)
+
+
+def cmd_fugacity(args) -> None:
+    try:
+        mix, z = _parse_mix(args.mix)
+    except KeyError as e:
+        _die(str(e))
+    eos = PREOS(mix)
+    phi = eos.fugacity_coeff(T=args.T, P=args.P, z=z, phase=args.phase)
+    f   = eos.fugacity(T=args.T, P=args.P, z=z, phase=args.phase)
+    names = [c.name for c in mix.components]
+    data = {
+        "T (K)":   f"{args.T:.2f}",
+        "P (MPa)": f"{args.P / 1e6:.4f}",
+        "phase":   args.phase,
+        "fugacity coefficients phi_i": {n: f"{v:.6f}" for n, v in zip(names, phi)},
+        "fugacities f_i (Pa)":        {n: f"{v:.4e}" for n, v in zip(names, f)},
+    }
+    _out(data, args.json)
+
+
+def cmd_bubble(args) -> None:
+    try:
+        mix, z = _parse_mix(args.mix)
+    except KeyError as e:
+        _die(str(e))
+    eos = PREOS(mix)
+    Pb = bubble_point_P(eos, T=args.T, z=z, P_guess=args.P_guess)
+    data = {
+        "T (K)":               f"{args.T:.2f}",
+        "bubble-point P (Pa)": "nan (supercritical or out of range)" if np.isnan(Pb) else f"{Pb:.2f}",
+        "bubble-point P (MPa)":"nan" if np.isnan(Pb) else f"{Pb / 1e6:.4f}",
+    }
+    _out(data, args.json)
+
+
+def cmd_dew(args) -> None:
+    try:
+        mix, z = _parse_mix(args.mix)
+    except KeyError as e:
+        _die(str(e))
+    eos = PREOS(mix)
+    Pd = dew_point_P(eos, T=args.T, z=z, P_guess=args.P_guess)
+    data = {
+        "T (K)":             f"{args.T:.2f}",
+        "dew-point P (Pa)":  "nan (supercritical or out of range)" if np.isnan(Pd) else f"{Pd:.2f}",
+        "dew-point P (MPa)": "nan" if np.isnan(Pd) else f"{Pd / 1e6:.4f}",
+    }
+    _out(data, args.json)
+
+
+def cmd_enthalpy(args) -> None:
+    try:
+        mix, z = _parse_mix(args.mix)
+    except KeyError as e:
+        _die(str(e))
+    eos = PREOS(mix)
+    H = enthalpy_departure(eos, T=args.T, P=args.P, z=z, phase=args.phase)
+    S = entropy_departure(eos,  T=args.T, P=args.P, z=z, phase=args.phase)
+    data = {
+        "T (K)":                 f"{args.T:.2f}",
+        "P (MPa)":               f"{args.P / 1e6:.4f}",
+        "phase":                 args.phase,
+        "H_dep (J/mol)":         f"{H:.4f}",
+        "S_dep (J/mol/K)":        f"{S:.6f}",
+        "G_dep = H-TS (J/mol)":   f"{H - args.T * S:.4f}",
+    }
+    _out(data, args.json)
+
+
+# ---------------------------------------------------------------------------
+# Argument parser
+# ---------------------------------------------------------------------------
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="prbs-eos",
+        description=(
+            "PRBS Equation of State — petroleum thermodynamics toolkit.\n"
+            "Run 'prbs-eos <command> --help' for per-command options."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version="prbs-eos 0.1.0")
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+    sub.required = True
+
+    # ---- shared options ------------------------------------------------
+    def add_mix(p):
+        p.add_argument(
+            "--mix", nargs="+", required=True, metavar="NAME:FRAC",
+            help="Mixture components, e.g.  methane:0.6 propane:0.4"
+        )
+    def add_TP(p):
+        p.add_argument("--T", type=float, required=True, metavar="K",
+                       help="Temperature [K]")
+        p.add_argument("--P", type=float, required=True, metavar="Pa",
+                       help="Pressure [Pa]  (e.g. 2e6 = 2 MPa)")
+    def add_phase(p):
+        p.add_argument("--phase", choices=["vapor", "liquid"], default="vapor",
+                       help="Phase selection (default: vapor)")
+    def add_json(p):
+        p.add_argument("--json", action="store_true",
+                       help="Output as JSON")
+    def add_P_guess(p):
+        p.add_argument("--P-guess", type=float, default=1e6, dest="P_guess",
+                       metavar="Pa",
+                       help="Initial pressure guess for bracketing [Pa] (default: 1e6)")
+
+    # ---- components ----------------------------------------------------
+    p = sub.add_parser("components", help="List all built-in components")
+    add_json(p)
+    p.set_defaults(func=cmd_components)
+
+    # ---- properties ----------------------------------------------------
+    p = sub.add_parser("properties", help="Show critical properties of a component")
+    p.add_argument("name", help="Component name (e.g. methane, co2, water)")
+    add_json(p)
+    p.set_defaults(func=cmd_properties)
+
+    # ---- flash ---------------------------------------------------------
+    p = sub.add_parser("flash", help="Two-phase PT flash (Rachford-Rice)")
+    add_TP(p); add_mix(p); add_json(p)
+    p.set_defaults(func=cmd_flash)
+
+    # ---- zfactor -------------------------------------------------------
+    p = sub.add_parser("zfactor", help="Compressibility factor Z")
+    add_TP(p); add_mix(p); add_phase(p); add_json(p)
+    p.set_defaults(func=cmd_zfactor)
+
+    # ---- fugacity ------------------------------------------------------
+    p = sub.add_parser("fugacity", help="Fugacity coefficients and fugacities")
+    add_TP(p); add_mix(p); add_phase(p); add_json(p)
+    p.set_defaults(func=cmd_fugacity)
+
+    # ---- bubble --------------------------------------------------------
+    p = sub.add_parser("bubble", help="Bubble-point pressure at fixed T")
+    p.add_argument("--T", type=float, required=True, metavar="K")
+    add_mix(p); add_P_guess(p); add_json(p)
+    p.set_defaults(func=cmd_bubble)
+
+    # ---- dew -----------------------------------------------------------
+    p = sub.add_parser("dew", help="Dew-point pressure at fixed T")
+    p.add_argument("--T", type=float, required=True, metavar="K")
+    add_mix(p); add_P_guess(p); add_json(p)
+    p.set_defaults(func=cmd_dew)
+
+    # ---- enthalpy ------------------------------------------------------
+    p = sub.add_parser("enthalpy",
+                        help="Enthalpy/entropy departure functions (H_dep, S_dep, G_dep)")
+    add_TP(p); add_mix(p); add_phase(p); add_json(p)
+    p.set_defaults(func=cmd_enthalpy)
+
+    return parser
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main(argv: list[str] | None = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

prbs_eos/constants.py

@@ -0,0 +1 @@
+R = 8.314462618  # J/(mol·K)

prbs_eos/core/__init__.py

@@ -0,0 +1,4 @@
+from .cubic_solver import solve_cubic, select_z
+from .eos_base import CubicEOS
+from .pr_eos import PREOS
+from .prbs_eos import PRBSEOS

prbs_eos/core/cubic_solver.py

@@ -0,0 +1,30 @@
+"""
+Analytical and numerical roots of the cubic EOS in Z-factor form:
+  Z³ + p·Z² + q·Z + r = 0
+"""
+import numpy as np
+
+
+def solve_cubic(p: float, q: float, r: float) -> np.ndarray:
+    """Return all real roots of Z³ + p·Z² + q·Z + r = 0, sorted ascending."""
+    coeffs = [1.0, p, q, r]
+    roots = np.roots(coeffs)
+    real_roots = roots[np.abs(roots.imag) < 1e-8].real
+    return np.sort(real_roots)
+
+
+def select_z(roots: np.ndarray, phase: str) -> float:
+    """
+    From the array of real positive Z roots select the thermodynamically
+    correct one for the requested phase ('vapor' or 'liquid').
+    """
+    pos = roots[roots > 0]
+    if len(pos) == 0:
+        raise ValueError("No positive Z root found.")
+    if len(pos) == 1:
+        return float(pos[0])
+    if phase == "vapor":
+        return float(pos.max())
+    if phase == "liquid":
+        return float(pos.min())
+    raise ValueError(f"Unknown phase '{phase}'. Use 'vapor' or 'liquid'.")

prbs_eos/core/eos_base.py

@@ -0,0 +1,84 @@
+"""Abstract base for cubic EOS implementations."""
+from abc import ABC, abstractmethod
+import numpy as np
+from ..data.mixture import Mixture
+
+
+class CubicEOS(ABC):
+    """
+    Subclasses must implement `_ab_pure` and `_mix_rule`.
+    Public API: `Z_factor`, `fugacity_coeff`.
+    """
+
+    def __init__(self, mixture: Mixture):
+        self.mix = mixture
+
+    # ------------------------------------------------------------------
+    # Abstract
+    # ------------------------------------------------------------------
+    @abstractmethod
+    def _ab_pure(self, T: float) -> tuple[np.ndarray, np.ndarray]:
+        """Return arrays (a_i, b_i) for each component at temperature T."""
+
+    @abstractmethod
+    def _mix_rule(
+        self, T: float, z: np.ndarray
+    ) -> tuple[float, float, np.ndarray]:
+        """
+        Return (a_mix, b_mix, (da/dni)_T) using the van der Waals mixing rule
+        with kij corrections.
+        """
+
+    @abstractmethod
+    def _cubic_coeffs(
+        self, T: float, P: float, a: float, b: float
+    ) -> tuple[float, float, float]:
+        """Return (p, q, r) for Z³ + p·Z² + q·Z + r = 0."""
+
+    @abstractmethod
+    def _ln_phi_i(
+        self,
+        i: int,
+        Z: float,
+        T: float,
+        P: float,
+        z: np.ndarray,
+        a: float,
+        b: float,
+        dai_dn: np.ndarray,
+    ) -> float:
+        """Return ln φ_i for component i."""
+
+    # ------------------------------------------------------------------
+    # Public
+    # ------------------------------------------------------------------
+    def Z_factor(
+        self, T: float, P: float, z: np.ndarray, phase: str = "vapor"
+    ) -> float:
+        from .cubic_solver import solve_cubic, select_z
+        z = np.asarray(z, dtype=float)
+        a, b, _ = self._mix_rule(T, z)
+        p, q, r = self._cubic_coeffs(T, P, a, b)
+        roots = solve_cubic(p, q, r)
+        return select_z(roots, phase)
+
+    def fugacity_coeff(
+        self, T: float, P: float, z: np.ndarray, phase: str = "vapor"
+    ) -> np.ndarray:
+        z = np.asarray(z, dtype=float)
+        a, b, dai_dn = self._mix_rule(T, z)
+        p, q, r = self._cubic_coeffs(T, P, a, b)
+        from .cubic_solver import solve_cubic, select_z
+        roots = solve_cubic(p, q, r)
+        Z = select_z(roots, phase)
+        nc = self.mix.nc
+        ln_phi = np.array(
+            [self._ln_phi_i(i, Z, T, P, z, a, b, dai_dn) for i in range(nc)]
+        )
+        return np.exp(ln_phi)
+
+    def fugacity(
+        self, T: float, P: float, z: np.ndarray, phase: str = "vapor"
+    ) -> np.ndarray:
+        z = np.asarray(z, dtype=float)
+        return z * P * self.fugacity_coeff(T, P, z, phase)

prbs_eos/core/pr_eos.py

@@ -0,0 +1,66 @@
+"""
+Peng-Robinson EOS (1976).
+  P = RT/(V-b) - a(T)/[V(V+b)+b(V-b)]
+"""
+import numpy as np
+from ..constants import R
+from ..data.mixture import Mixture
+from .eos_base import CubicEOS
+
+
+class PREOS(CubicEOS):
+    # PR universal constants
+    _OmegaA = 0.45723553
+    _OmegaB = 0.07779607
+
+    def __init__(self, mixture: Mixture):
+        super().__init__(mixture)
+
+    # ------------------------------------------------------------------
+    def _kappa(self) -> np.ndarray:
+        w = self.mix.omega
+        return 0.37464 + 1.54226 * w - 0.26992 * w ** 2
+
+    def _ab_pure(self, T: float):
+        Tc = self.mix.Tc
+        Pc = self.mix.Pc
+        kappa = self._kappa()
+        Tr = T / Tc
+        alpha = (1.0 + kappa * (1.0 - np.sqrt(Tr))) ** 2
+        a = self._OmegaA * (R * Tc) ** 2 / Pc * alpha
+        b = self._OmegaB * R * Tc / Pc
+        return a, b
+
+    def _mix_rule(self, T: float, z: np.ndarray):
+        a_i, b_i = self._ab_pure(T)
+        kij = self.mix.kij
+        nc = self.mix.nc
+        # a_ij = sqrt(a_i * a_j) * (1 - kij)
+        a_ij = np.sqrt(np.outer(a_i, a_i)) * (1.0 - kij)
+        a_mix = float(z @ a_ij @ z)
+        b_mix = float(z @ b_i)
+        # da_mix/dn_i  (at constant n_j≠i, normalised mole fraction)
+        dai_dn = 2.0 * (a_ij @ z)
+        return a_mix, b_mix, dai_dn
+
+    def _cubic_coeffs(self, T: float, P: float, a: float, b: float):
+        A = a * P / (R * T) ** 2
+        B = b * P / (R * T)
+        p = B - 1.0
+        q = A - 3.0 * B ** 2 - 2.0 * B
+        r = B ** 3 + B ** 2 - A * B
+        return p, q, r
+
+    def _ln_phi_i(self, i, Z, T, P, z, a, b, dai_dn):
+        a_i, b_i = self._ab_pure(T)
+        A = a * P / (R * T) ** 2
+        B = b * P / (R * T)
+        bi = b_i[i]
+        ln_phi = (
+            bi / b * (Z - 1.0)
+            - np.log(Z - B)
+            - A / (2.0 * np.sqrt(2.0) * B)
+            * (dai_dn[i] / a - bi / b)
+            * np.log((Z + (1.0 + np.sqrt(2.0)) * B) / (Z + (1.0 - np.sqrt(2.0)) * B))
+        )
+        return ln_phi

prbs_eos/core/prbs_eos.py

@@ -0,0 +1,100 @@
+"""
+PRBS-EOS: Peng-Robinson with Boublik-Mansoori-Carnahan-Starling (BMCS)
+hard-sphere repulsion term and a simplified CPA-style association
+contribution, combined with a Peneloux volume shift.
+
+For non-associating mixtures this reduces to standard PR with a
+volume shift, so it is backward-compatible with PREOS.
+"""
+import numpy as np
+from scipy.optimize import brentq
+from ..constants import R
+from ..data.mixture import Mixture
+from .pr_eos import PREOS
+
+
+class PRBSEOS(PREOS):
+    """
+    PRBS = PR + volume-shift (Peneloux) + optional association (CPA-style).
+
+    Association contribution uses a 4-site model for self-associating
+    components (e.g. water).  Cross-association is neglected here.
+    """
+
+    def __init__(self, mixture: Mixture):
+        super().__init__(mixture)
+        self._c = np.array([comp.c for comp in mixture.components])
+        self._eps = np.array([comp.epsilon for comp in mixture.components])
+        self._kap = np.array([comp.kappa for comp in mixture.components])
+        self._sites = np.array([comp.assoc_sites for comp in mixture.components], dtype=int)
+
+    # ------------------------------------------------------------------
+    # Volume shift: shift molar volume after Z-factor calculation
+    # ------------------------------------------------------------------
+    def _volume_shift(self, z: np.ndarray) -> float:
+        """Return molar volume shift c_mix = Σ z_i c_i  [m³/mol]."""
+        return float(z @ self._c)
+
+    def molar_volume(
+        self, T: float, P: float, z: np.ndarray, phase: str = "vapor"
+    ) -> float:
+        """Volume-shifted molar volume [m³/mol]."""
+        z = np.asarray(z, dtype=float)
+        Z = self.Z_factor(T, P, z, phase)
+        V_raw = Z * R * T / P
+        return V_raw - self._volume_shift(z)
+
+    # ------------------------------------------------------------------
+    # Association  (simplified 4-site CPA)
+    # ------------------------------------------------------------------
+    def _assoc_X(self, T: float, rho_mol: float, z: np.ndarray) -> np.ndarray:
+        """
+        Solve for fraction of unbonded sites X_i ∈ (0,1] for each component.
+        Uses the Michelsen-Hendriks iterative scheme.
+
+        Association strength:  Δ_i = b_i * κ_i * (exp(ε_i / RT) - 1)
+        At low density rho_mol → 0, the site-occupancy denominator vanishes
+        and X_i → 1 (all sites free), which is the correct ideal-gas limit.
+        """
+        nc = self.mix.nc
+        _, b_i = self._ab_pure(T)   # co-volume b_i [m³/mol] for each component
+        X = np.ones(nc)
+        for _ in range(200):
+            X_old = X.copy()
+            for i in range(nc):
+                if self._sites[i] == 0:
+                    continue
+                # Δ = b_i * κ_i * (exp(ε_i / RT) - 1)   [m³/mol]
+                delta = b_i[i] * self._kap[i] * (np.exp(self._eps[i] / (R * T)) - 1.0)
+                X[i] = 1.0 / (1.0 + self._sites[i] * z[i] * rho_mol * delta * X[i])
+            if np.max(np.abs(X - X_old)) < 1e-10:
+                break
+        return X
+
+    def _assoc_lnphi_correction(
+        self, T: float, P: float, z: np.ndarray, phase: str
+    ) -> np.ndarray:
+        """ln φ correction from association for each component."""
+        nc = self.mix.nc
+        if not np.any(self._sites > 0):
+            return np.zeros(nc)
+        V = self.molar_volume(T, P, z, phase)
+        rho_mol = 1.0 / V  # mol/m³
+        X = self._assoc_X(T, rho_mol, z)
+        ln_corr = np.zeros(nc)
+        for i in range(nc):
+            M = self._sites[i]
+            if M == 0:
+                continue
+            ln_corr[i] = M * (np.log(X[i]) - X[i] / 2.0 + 0.5)
+        return ln_corr
+
+    # ------------------------------------------------------------------
+    # Override fugacity_coeff to add association
+    # ------------------------------------------------------------------
+    def fugacity_coeff(
+        self, T: float, P: float, z: np.ndarray, phase: str = "vapor"
+    ) -> np.ndarray:
+        phi_pr = super().fugacity_coeff(T, P, z, phase)
+        ln_assoc = self._assoc_lnphi_correction(T, P, z, phase)
+        return phi_pr * np.exp(ln_assoc)

prbs_eos/data/__init__.py

@@ -0,0 +1,3 @@
+from .component import Component
+from .mixture import Mixture
+from .component_db import get_component, available_components

prbs_eos/data/component.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class Component:
+    """Pure-component critical properties and acentric factor."""
+    name: str
+    Tc: float        # critical temperature [K]
+    Pc: float        # critical pressure [Pa]
+    omega: float     # acentric factor [-]
+    Mw: float        # molecular weight [g/mol]
+    # optional PRBS volume-shift and association parameters
+    c: float = 0.0           # Peneloux volume-shift [m³/mol]
+    epsilon: float = 0.0     # association energy [J/mol]
+    kappa: float = 0.0       # association volume [-]
+    assoc_sites: int = 0     # number of association sites
+
+    def __post_init__(self):
+        if self.Tc <= 0:
+            raise ValueError(f"Tc must be positive, got {self.Tc}")
+        if self.Pc <= 0:
+            raise ValueError(f"Pc must be positive, got {self.Pc}")
+        if self.Mw <= 0:
+            raise ValueError(f"Mw must be positive, got {self.Mw}")

prbs_eos/data/component_db.py

@@ -0,0 +1,59 @@
+"""
+Built-in component database.  Properties from DIPPR / Poling et al. (2001).
+Pc in Pa, Tc in K, omega dimensionless, Mw in g/mol.
+"""
+from .component import Component
+
+_DB: dict[str, Component] = {
+    "methane": Component(
+        name="methane", Tc=190.56, Pc=4.599e6, omega=0.0115, Mw=16.043
+    ),
+    "ethane": Component(
+        name="ethane", Tc=305.32, Pc=4.872e6, omega=0.0995, Mw=30.070
+    ),
+    "propane": Component(
+        name="propane", Tc=369.83, Pc=4.248e6, omega=0.1523, Mw=44.097
+    ),
+    "n-butane": Component(
+        name="n-butane", Tc=425.12, Pc=3.796e6, omega=0.2002, Mw=58.123
+    ),
+    "n-pentane": Component(
+        name="n-pentane", Tc=469.70, Pc=3.370e6, omega=0.2515, Mw=72.150
+    ),
+    "n-hexane": Component(
+        name="n-hexane", Tc=507.60, Pc=3.025e6, omega=0.3013, Mw=86.177
+    ),
+    "n-heptane": Component(
+        name="n-heptane", Tc=540.20, Pc=2.740e6, omega=0.3495, Mw=100.204
+    ),
+    "n-octane": Component(
+        name="n-octane", Tc=568.70, Pc=2.490e6, omega=0.3996, Mw=114.231
+    ),
+    "nitrogen": Component(
+        name="nitrogen", Tc=126.20, Pc=3.390e6, omega=0.0372, Mw=28.014
+    ),
+    "co2": Component(
+        name="co2", Tc=304.12, Pc=7.374e6, omega=0.2239, Mw=44.010
+    ),
+    "water": Component(
+        name="water", Tc=647.10, Pc=22.064e6, omega=0.3449, Mw=18.015,
+        epsilon=1804.0 * 8.314462618,  # 1804 K × R  [J/mol]
+        kappa=0.0692, assoc_sites=4,
+    ),
+    "hydrogen_sulfide": Component(
+        name="hydrogen_sulfide", Tc=373.10, Pc=8.963e6, omega=0.0942, Mw=34.081
+    ),
+}
+
+
+def get_component(name: str) -> Component:
+    key = name.strip().lower().replace(" ", "_").replace("-", "-")
+    if key not in _DB:
+        raise KeyError(
+            f"Component '{name}' not found. Available: {list(_DB.keys())}"
+        )
+    return _DB[key]
+
+
+def available_components() -> list[str]:
+    return list(_DB.keys())

prbs_eos/data/mixture.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass, field
+import numpy as np
+from typing import List
+from .component import Component
+
+
+@dataclass
+class Mixture:
+    """Collection of components with binary interaction parameters."""
+    components: List[Component]
+    kij: np.ndarray = field(default=None)   # shape (nc, nc)
+
+    def __post_init__(self):
+        nc = len(self.components)
+        if nc == 0:
+            raise ValueError("Mixture must have at least one component.")
+        if self.kij is None:
+            self.kij = np.zeros((nc, nc))
+        self.kij = np.asarray(self.kij, dtype=float)
+        if self.kij.shape != (nc, nc):
+            raise ValueError(
+                f"kij shape {self.kij.shape} does not match nc={nc}"
+            )
+
+    @property
+    def nc(self) -> int:
+        return len(self.components)
+
+    @property
+    def Tc(self) -> np.ndarray:
+        return np.array([c.Tc for c in self.components])
+
+    @property
+    def Pc(self) -> np.ndarray:
+        return np.array([c.Pc for c in self.components])
+
+    @property
+    def omega(self) -> np.ndarray:
+        return np.array([c.omega for c in self.components])
+
+    @property
+    def Mw(self) -> np.ndarray:
+        return np.array([c.Mw for c in self.components])

prbs_eos/equilibrium/__init__.py

@@ -0,0 +1,3 @@
+from .flash import flash_pt, FlashResult
+from .stability import is_stable, tpd_min
+from .phase_envelope import bubble_point_P, dew_point_P

prbs_eos/equilibrium/flash.py

@@ -0,0 +1,83 @@
+"""
+Two-phase PT flash using successive substitution + Newton acceleration.
+Rachford-Rice equation for vapour fraction beta.
+"""
+import numpy as np
+from scipy.optimize import brentq
+from dataclasses import dataclass
+from ..constants import R
+from ..core.eos_base import CubicEOS
+
+
+@dataclass
+class FlashResult:
+    beta: float          # vapour mole fraction
+    x: np.ndarray        # liquid mole fractions
+    y: np.ndarray        # vapour mole fractions
+    K: np.ndarray        # K-factors (y/x)
+    converged: bool
+    iterations: int
+
+
+def _rachford_rice(beta: float, z: np.ndarray, K: np.ndarray) -> float:
+    return float(np.sum(z * (K - 1.0) / (1.0 + beta * (K - 1.0))))
+
+
+def _solve_rr(z: np.ndarray, K: np.ndarray) -> float:
+    """Solve Rachford-Rice for beta ∈ (0,1)."""
+    f0 = _rachford_rice(0.0, z, K)
+    f1 = _rachford_rice(1.0, z, K)
+    if f0 <= 0.0:
+        return 0.0
+    if f1 >= 0.0:
+        return 1.0
+    return brentq(_rachford_rice, 0.0, 1.0, args=(z, K), xtol=1e-12)
+
+
+def flash_pt(
+    eos: CubicEOS,
+    T: float,
+    P: float,
+    z: np.ndarray,
+    max_iter: int = 200,
+    tol: float = 1e-10,
+) -> FlashResult:
+    """Two-phase isothermal-isobaric flash."""
+    z = np.asarray(z, dtype=float)
+    nc = eos.mix.nc
+
+    # Wilson K-factor initialisation
+    Tc = eos.mix.Tc
+    Pc = eos.mix.Pc
+    omega = eos.mix.omega
+    K = (Pc / P) * np.exp(5.373 * (1.0 + omega) * (1.0 - Tc / T))
+
+    beta = _solve_rr(z, K)
+    converged = False
+
+    for it in range(max_iter):
+        beta = _solve_rr(z, K)
+        x = z / (1.0 + beta * (K - 1.0))
+        x = np.clip(x, 1e-300, 1.0)
+        x /= x.sum()
+        y = K * x
+        y = np.clip(y, 1e-300, 1.0)
+        y /= y.sum()
+
+        phi_L = eos.fugacity_coeff(T, P, x, "liquid")
+        phi_V = eos.fugacity_coeff(T, P, y, "vapor")
+        K_new = phi_L / phi_V
+
+        err = np.max(np.abs(np.log(K_new / K)))
+        K = K_new
+        if err < tol:
+            converged = True
+            break
+
+    beta = _solve_rr(z, K)
+    x = z / (1.0 + beta * (K - 1.0))
+    x /= x.sum()
+    y = K * x
+    y /= y.sum()
+    return FlashResult(beta=beta, x=x, y=y, K=K,
+                       converged=converged, iterations=it + 1)

prbs_eos/equilibrium/phase_envelope.py

@@ -0,0 +1,55 @@
+"""
+Simple PT phase-envelope tracer: bubble-point and dew-point pressure solvers.
+
+Uses the Wilson K-factor correlation:
+  K_i = (Pc_i / P) * exp(5.373 * (1 + omega_i) * (1 - Tc_i / T))
+
+Bubble-point condition: sum_i K_i * z_i = 1
+  - K_i strictly decreases with P → objective goes from + to - → reliable bracket.
+
+Dew-point condition:   sum_i z_i / K_i = 1
+  - 1/K_i strictly increases with P → objective goes from - to + → reliable bracket.
+
+Returns nan when no root lies within [P_guess*0.01, P_guess*100], which naturally
+occurs for supercritical T (where the Wilson P would be far outside the bracket).
+"""
+import numpy as np
+from scipy.optimize import brentq
+
+
+def _wilson_K(eos, T: float, P: float) -> np.ndarray:
+    """Wilson K-factor correlation K_i = (Pc_i/P)*exp(5.373*(1+ω_i)*(1-Tc_i/T))."""
+    Tc = eos.mix.Tc
+    Pc = eos.mix.Pc
+    omega = eos.mix.omega
+    return (Pc / P) * np.exp(5.373 * (1.0 + omega) * (1.0 - Tc / T))
+
+
+def bubble_point_P(eos, T, z, P_guess=1e6):
+    """Bubble-point pressure [Pa] at temperature T for feed z."""
+    z = np.asarray(z, dtype=float)
+
+    def obj(P):
+        K = _wilson_K(eos, T, P)
+        return float(np.sum(K * z)) - 1.0
+
+    try:
+        return brentq(obj, P_guess * 0.01, P_guess * 100.0,
+                      xtol=1.0, rtol=1e-6, maxiter=100)
+    except ValueError:
+        return float("nan")
+
+
+def dew_point_P(eos, T, z, P_guess=1e6):
+    """Dew-point pressure [Pa] at temperature T for feed z."""
+    z = np.asarray(z, dtype=float)
+
+    def obj(P):
+        K = _wilson_K(eos, T, P)
+        return float(np.sum(z / K)) - 1.0
+
+    try:
+        return brentq(obj, P_guess * 0.01, P_guess * 100.0,
+                      xtol=1.0, rtol=1e-6, maxiter=100)
+    except ValueError:
+        return float("nan")

prbs_eos/equilibrium/stability.py

@@ -0,0 +1,36 @@
+"""
+Tangent-plane distance (TPD) stability test (Michelsen 1982).
+"""
+import numpy as np
+from scipy.optimize import minimize
+from ..constants import R
+from ..core.eos_base import CubicEOS
+
+
+def tpd_min(eos, T, P, z, phase_feed="vapor"):
+    z = np.asarray(z, dtype=float)
+    nc = eos.mix.nc
+    ln_phi_z = np.log(eos.fugacity_coeff(T, P, z, phase_feed))
+    hi = np.log(z) + ln_phi_z
+
+    def tpd(W):
+        w = np.abs(W)
+        w_sum = w.sum()
+        if w_sum < 1e-30:
+            return 0.0
+        y = w / w_sum
+        trial_phase = "liquid" if phase_feed == "vapor" else "vapor"
+        ln_phi_y = np.log(eos.fugacity_coeff(T, P, y, trial_phase))
+        return float(w_sum * (1.0 + np.sum(w / w_sum * (np.log(w / w_sum) + ln_phi_y - hi)) - 1.0))
+
+    best = np.inf
+    for start in [z * 0.5, z * 2.0, np.ones(nc) / nc]:
+        res = minimize(tpd, start, method="L-BFGS-B",
+                       bounds=[(1e-12, None)] * nc)
+        if res.fun < best:
+            best = res.fun
+    return best
+
+
+def is_stable(eos, T, P, z, phase_feed="vapor", tol=-1e-6):
+    return tpd_min(eos, T, P, z, phase_feed) > tol

prbs_eos/regression/__init__.py

@@ -0,0 +1,2 @@
+from .eos_regression import regress_kij
+from .vpaa_regressor import regress_vpaa

prbs_eos/regression/eos_regression.py

@@ -0,0 +1,39 @@
+"""Regression of binary interaction parameters kij to VLE data."""
+import numpy as np
+from scipy.optimize import least_squares
+from ..core.pr_eos import PREOS
+from ..data.mixture import Mixture
+
+
+def regress_kij(mixture, T_data, P_data, x_data, y_data, kij_bounds=(-0.5, 0.5)):
+    from ..equilibrium.flash import flash_pt
+    nc = mixture.nc
+    n_pairs = nc * (nc - 1) // 2
+    if n_pairs == 0:
+        return np.zeros((nc, nc))
+    pair_idx = [(i, j) for i in range(nc) for j in range(i + 1, nc)]
+
+    def residuals(params):
+        kij = np.zeros((nc, nc))
+        for k, (i, j) in enumerate(pair_idx):
+            kij[i, j] = kij[j, i] = params[k]
+        mix = Mixture(mixture.components, kij=kij)
+        eos = PREOS(mix)
+        res_list = []
+        for n in range(len(T_data)):
+            z = x_data[n]
+            try:
+                fl = flash_pt(eos, T_data[n], P_data[n], z)
+                res_list.extend((fl.y - y_data[n]).tolist())
+            except Exception:
+                res_list.extend([1.0] * nc)
+        return np.array(res_list)
+
+    x0 = np.zeros(n_pairs)
+    bounds = ([kij_bounds[0]] * n_pairs, [kij_bounds[1]] * n_pairs)
+    result = least_squares(residuals, x0, bounds=bounds, method="trf",
+                           ftol=1e-8, xtol=1e-8, max_nfev=500)
+    kij_out = np.zeros((nc, nc))
+    for k, (i, j) in enumerate(pair_idx):
+        kij_out[i, j] = kij_out[j, i] = result.x[k]
+    return kij_out

prbs_eos/regression/vpaa_regressor.py

@@ -0,0 +1,34 @@
+"""
+Vapour-pressure and acentric-factor regression from experimental Psat data.
+"""
+import numpy as np
+from scipy.optimize import least_squares
+from ..data.component import Component
+from ..constants import R
+
+
+def regress_vpaa(
+    comp: Component,
+    T_data: np.ndarray,
+    Psat_data: np.ndarray,
+) -> tuple[float, float]:
+    """
+    Fit omega and Pc to vapour-pressure data via Wilson correlation.
+
+    Returns
+    -------
+    (omega_fit, Pc_fit)
+    """
+    T_data = np.asarray(T_data, dtype=float)
+    Psat_data = np.asarray(Psat_data, dtype=float)
+
+    def residuals(params):
+        omega, Pc = params
+        Psat_calc = Pc * np.exp(5.373 * (1 + omega) * (1 - comp.Tc / T_data))
+        return np.log(Psat_calc) - np.log(Psat_data)
+
+    x0 = [comp.omega, comp.Pc]
+    bounds = ([0.0, 1e4], [2.0, 1e8])
+    result = least_squares(residuals, x0, bounds=bounds, method="trf",
+                           ftol=1e-10, xtol=1e-10)
+    return float(result.x[0]), float(result.x[1])

prbs_eos/thermodynamics/__init__.py

@@ -0,0 +1 @@
+from .departure import enthalpy_departure, entropy_departure

prbs_eos/thermodynamics/departure.py

@@ -0,0 +1,61 @@
+"""
+Departure functions for PR-EOS.
+All quantities are per mole of mixture.
+"""
+import numpy as np
+from ..constants import R
+from ..core.pr_eos import PREOS
+from ..core.cubic_solver import solve_cubic, select_z
+
+
+def _AB(eos: PREOS, T: float, P: float, z: np.ndarray):
+    a, b, _ = eos._mix_rule(T, z)
+    A = a * P / (R * T) ** 2
+    B = b * P / (R * T)
+    return a, b, A, B
+
+
+def enthalpy_departure(
+    eos: PREOS, T: float, P: float, z: np.ndarray, phase: str = "vapor"
+) -> float:
+    """H_dep = H - H_ig  [J/mol]."""
+    z = np.asarray(z, dtype=float)
+    a, b, A, B = _AB(eos, T, P, z)
+    # da/dT
+    a_i, b_i = eos._ab_pure(T)
+    kappa = eos._kappa()
+    Tc = eos.mix.Tc
+    Pc = eos.mix.Pc
+    kij = eos.mix.kij
+    alpha_i = a_i / (eos._OmegaA * (R * Tc) ** 2 / Pc)
+    dadt_i = (
+        -eos._OmegaA * (R * Tc) ** 2 / Pc
+        * kappa
+        * np.sqrt(alpha_i / (T * Tc))
+    )
+    a_ij = np.sqrt(np.outer(a_i, a_i)) * (1.0 - kij)
+    # dadt_ij = 0.5*(dadt_i/sqrt(a_i))*sqrt(a_j)*(1-kij) + sym
+    dadt_ij = 0.5 * (
+        np.outer(dadt_i / a_i, a_i) + np.outer(a_i, dadt_i / a_i)
+    ) * np.sqrt(np.outer(a_i, a_i)) * (1.0 - kij)
+    dadt_mix = float(z @ dadt_ij @ z)
+
+    Z = eos.Z_factor(T, P, z, phase)
+    s2 = np.sqrt(2.0)
+    H_dep = (
+        R * T * (Z - 1.0)
+        + (T * dadt_mix - a) / (b * 2.0 * s2)
+        * np.log((Z + (1 + s2) * B) / (Z + (1 - s2) * B))
+    )
+    return H_dep
+
+
+def entropy_departure(
+    eos: PREOS, T: float, P: float, z: np.ndarray, phase: str = "vapor"
+) -> float:
+    """S_dep = S - S_ig  [J/(mol·K)]."""
+    z = np.asarray(z, dtype=float)
+    H_dep = enthalpy_departure(eos, T, P, z, phase)
+    ln_phi = np.log(eos.fugacity_coeff(T, P, z, phase))
+    G_dep = R * T * float(z @ ln_phi)
+    return (H_dep - G_dep) / T

prbs_eos-0.1.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: prbs-eos
+Version: 0.1.0
+Summary: PRBS Equation of State — Peng-Robinson with volume-shift and CPA association for petroleum thermodynamics
+Author: PRBS-EOS Contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/your-org/prbs-eos
+Project-URL: Repository, https://github.com/your-org/prbs-eos
+Project-URL: Issues, https://github.com/your-org/prbs-eos/issues
+Keywords: thermodynamics,equation-of-state,peng-robinson,petroleum,flash,VLE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: pandas>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Requires-Dist: pyinstaller>=6.0; extra == "dev"
+
+# prbs-eos
+
+**PRBS Equation of State** — a Python library for petroleum thermodynamics.
+
+## Features
+
+- Peng-Robinson EOS (PR) with van der Waals mixing rules and binary interaction parameters (kij)
+- PRBS-EOS: PR + Peneloux volume-shift + CPA-style association (e.g. water, H₂S)
+- Two-phase PT flash (Rachford-Rice + successive substitution)
+- Tangent-plane stability analysis (Michelsen TPD)
+- Bubble-point / dew-point pressure solvers (Wilson K-factor)
+- Enthalpy and entropy departure functions
+- kij regression from VLE data; vapour-pressure / acentric-factor regression
+- Built-in database: methane, ethane, propane, n-butane … n-octane, N₂, CO₂, water, H₂S
+- Command-line interface: `prbs-eos flash`, `prbs-eos bubble`, `prbs-eos properties`, …
+
+## Quick start
+
+```python
+import numpy as np
+import prbs_eos as eos
+
+mix = eos.Mixture([eos.get_component("methane"), eos.get_component("propane")])
+pr  = eos.PREOS(mix)
+
+res = eos.flash_pt(pr, T=250.0, P=1e6, z=np.array([0.6, 0.4]))
+print(f"β = {res.beta:.3f}   x = {res.x}   y = {res.y}")
+```
+
+## CLI
+
+```
+prbs-eos flash   --T 250 --P 1e6 --mix methane:0.6 propane:0.4
+prbs-eos bubble  --T 250         --mix methane:0.5 propane:0.5
+prbs-eos properties methane
+prbs-eos components
+```

prbs_eos-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+prbs_eos/__init__.py,sha256=Lc3jtKz-DFYxg9qM40K2mYffLF6GbWASqScDAlXMKp4,335
+prbs_eos/__main__.py,sha256=7ZoLnk_SqsSGgXOkx5gMAAdEm96roAQgRhF0ythsZ1I,86
+prbs_eos/cli.py,sha256=9bWdG0qbob7P8VNV8SVWelhNJGbZ3DHzLFjQypjsEC8,10911
+prbs_eos/constants.py,sha256=qeO6maLY3eAeqQU4dTdbby4QGY0uVSu7qf7khnGhFnk,30
+prbs_eos/core/__init__.py,sha256=dzzwLcnUNs9yUe431DQ9Ety7VciRYKX9BsK4Zm5HqLs,135
+prbs_eos/core/cubic_solver.py,sha256=7mkZo4i2lkXP9WvQWK2MED-IlTuUhL7YNRxwBzyqUJ8,963
+prbs_eos/core/eos_base.py,sha256=4YrB5kKJ5m1OokXKGj3HDJVaev4CgS415_8oDFwyl9s,2677
+prbs_eos/core/pr_eos.py,sha256=RrvvyzZSu6qAU4SvFoR0f3UHRpdOHl3OnFsd6Nt-i34,2010
+prbs_eos/core/prbs_eos.py,sha256=cFa-kmZvfKYuA0qqsWuAP4hi17swMhQj9B-ccUoslNw,4162
+prbs_eos/data/__init__.py,sha256=holrFRrpn-LEb3YHXpAfzV44LGTjhpuOjOcVc_fXD_A,124
+prbs_eos/data/component.py,sha256=JPiLurLhu4-uncczLzNbsJZ8w3JGjf8LfVe_hotuXfA,967
+prbs_eos/data/component_db.py,sha256=Rb-sqv5Iixj2sk_0b6PNi5ggqCieEpvNllF7e5OzKew,1909
+prbs_eos/data/mixture.py,sha256=nvgtzSbxIqq6MoRj8n35Sj3kaH-qCp_EodMnlVjObuU,1241
+prbs_eos/equilibrium/__init__.py,sha256=GR7ADq_KALSaxE0jGotMKXSTGJ-lVGI-adQqj2guL4Y,142
+prbs_eos/equilibrium/flash.py,sha256=e0bCK3YgYO5wy9MbGCazYzyoDk0eLquF2Cm72DixbmE,2206
+prbs_eos/equilibrium/phase_envelope.py,sha256=o2DAmiWSd6dfDM6ZY8L0of2Muo-iwNkJIXdmrGh6ufI,1830
+prbs_eos/equilibrium/stability.py,sha256=qywjEE0AqI36ngyT2bNF4qZ_ofpf2_F5DtqGNGBi-QE,1155
+prbs_eos/pvt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prbs_eos/pvt/export.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prbs_eos/pvt/pvt_tables.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prbs_eos/pvt/separator.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prbs_eos/regression/__init__.py,sha256=_brdCoDhx1SD6ZAAvKpjHp0ukJVjtxoYUPB8WzgypqI,83
+prbs_eos/regression/eos_regression.py,sha256=tH2jTHIrCu7Ba3-u3H0x2l0qEG_ecL6K23-LF60NfJg,1475
+prbs_eos/regression/vpaa_regressor.py,sha256=lIb1ID6n4_f6diOhJaAEnsGFkuh4MkANKybOKUD9lq0,1019
+prbs_eos/thermodynamics/__init__.py,sha256=EKLFCTDVQ1Vzk4x0sRv2k3UOT_rbefVIv3FWU6s44UM,61
+prbs_eos/thermodynamics/departure.py,sha256=Vv-aSq3G00HUL_OWVzGutyVscZkIsnOln2ZMJYWhrvQ,1779
+prbs_eos-0.1.0.dist-info/METADATA,sha256=l8ies3CVdc3dSmm-uVF_x3I-YrJYxPn0sRjQrTshw0g,2603
+prbs_eos-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+prbs_eos-0.1.0.dist-info/entry_points.txt,sha256=I8t_Egguo1J2NeNw-GhLVLnshxFHjf1ElGZ6Di9aZNw,47
+prbs_eos-0.1.0.dist-info/top_level.txt,sha256=KDom8s7RiWwChQoM0uB2_myb_t18-DkRYVqujfuBj3E,9
+prbs_eos-0.1.0.dist-info/RECORD,,

prbs_eos-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

prbs_eos-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+prbs-eos = prbs_eos.cli:main

prbs_eos-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+prbs_eos