yaeos 4.0.0__cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

yaeos/fitting/core.py

@@ -0,0 +1,199 @@
+"""Yaeos fitting core module."""
+
+import numpy as np
+
+from scipy.optimize import minimize
+
+from yaeos.fitting.solvers import solve_pt
+
+
+class BinaryFitter:
+    """BinaryFitter class.
+
+    This class is used to fit binary interaction parameters to experimental
+    data. The objective function is defined as the sum of the squared errors
+    between the experimental data and the model predictions.
+
+    Parameters
+    ----------
+    model_setter : callable
+        A function that returns a model object. The function should take the
+        optimization parameters as the first argument and any other arguments
+        as the following arguments.
+    model_setter_args : tuple
+        A tuple with the arguments to pass to the model_setter function.
+    data : pandas.DataFrame
+        A DataFrame with the experimental data.
+        The DataFrame should have the following columns:
+        - kind: str, the kind of data point (bubble, dew, liquid-liquid, PT,
+        critical)
+        - x1: float, the mole fraction of component 1
+        - y1: float, the mole fraction of component 1
+        - T: float, the temperature in K
+        - P: float, the pressure in bar
+    verbose : bool, optional
+        If True, print the objective function value and the optimization
+    """
+
+    def __init__(self, model_setter, model_setter_args, data, verbose=False):
+        self._get_model = model_setter
+        self._get_model_args = model_setter_args
+        self.data = data
+        self.verbose = verbose
+        self.evaluations = {"fobj": [], "x": [], "cl": []}
+
+    def objective_function(self, x_values):
+        """
+        Objective function to minimize when fitting interaction parameters.
+
+        Parameters
+        ----------
+        x_values : array-like
+            The interaction parameters to fit.
+        """
+
+        def pressure_error(Pexp, Pmodel):
+            return (Pexp - Pmodel) ** 2 / Pexp
+
+        def composition_error(zexp, zmodel):
+            return np.abs(np.log(zmodel[0] / zexp[0])) + np.abs(
+                np.log(zmodel[1] / zexp[1])
+            )
+
+        def temperature_error(Texp, Tmodel):
+            return (Texp - Tmodel) ** 2 / Texp
+
+        model = self._get_model(x_values, *self._get_model_args)
+        data = self.data
+
+        # =====================================================================
+        # Calculate the critical line starting from the heavy component
+        # ---------------------------------------------------------------------
+        cp_msk = data["kind"] == "critical"
+        if len(data[cp_msk]) > 0:
+            cl = model.critical_line(
+                z0=[0, 1],
+                zi=[1, 0],
+                a0=1e-2,
+                s=1e-2,
+                ds0=1e-3,
+                max_points=15000,
+            )
+
+        err = 0
+
+        for _, row in data.iterrows():
+            x = [row["x1"], 1 - row["x1"]]
+            y = [row["y1"], 1 - row["y1"]]
+            t = row["T"]
+            p = row["P"]
+
+            try:
+                w = row["weight"]
+            except KeyError:
+                w = 1
+
+            error_i = 0
+
+            # =================================================================
+            # Bubble point
+            # -----------------------------------------------------------------
+            if row["kind"] == "bubble":
+                sat = model.saturation_pressure(
+                    x, kind="bubble", temperature=t, p0=p
+                )
+                error_i += pressure_error(p, sat["P"])
+
+            # =================================================================
+            # Dew points
+            # -----------------------------------------------------------------
+            if row["kind"] == "dew":
+                sat = model.saturation_pressure(
+                    x, kind="dew", temperature=t, p0=p
+                )
+
+                error_i += pressure_error(p, sat["P"])
+
+            if row["kind"] == "PT" or row["kind"] == "liquid-liquid":
+                x1, y1 = solve_pt(model, row["P"], row["T"], row["kind"])
+
+                if np.isnan(x[0]):
+                    error_i += composition_error(y, [y1, 1 - y1])
+
+                elif np.isnan(y[0]):
+                    error_i += composition_error(x, [x1, 1 - x1])
+
+                else:
+                    error_i += composition_error(
+                        x, [x1, 1 - x1]
+                    ) + composition_error(y, [y1, 1 - y1])
+
+            # =================================================================
+            # Critical point error is calculated by finding the nearest
+            # critical point in the critical line to the given critical
+            # point in the data.
+            # -----------------------------------------------------------------
+            if row["kind"] == "critical":
+                cp = row
+                distances = (
+                    (cp["T"] - cl["T"]) ** 2
+                    + ((cp["P"] - cl["P"]) ** 2)
+                    + ((cp["x1"] - cl["a"]) ** 2)
+                )
+                nearest = np.argmin(distances)
+                t_cl, p_cl, x1 = (
+                    cl["T"][nearest],
+                    cl["P"][nearest],
+                    cl["a"][nearest],
+                )
+                error_i += temperature_error(cp["T"], t_cl)
+                error_i += pressure_error(cp["P"], p_cl)
+                error_i += composition_error(
+                    [cp["x1"], 1 - cp["x1"]], [x1, 1 - x1]
+                )
+
+            if np.isnan(error_i):
+                error_i = row["P"]
+            err += error_i * w
+
+        # =====================================================================
+        # Normalize the error and save the valuation
+        # ---------------------------------------------------------------------
+        err = err / len(data)
+
+        self.evaluations["fobj"].append(err)
+        self.evaluations["x"].append(x_values)
+
+        if self.verbose:
+            print(err, x_values)
+        return err
+
+    def fit(self, x0, bounds, method="Nelder-Mead"):
+        """Fit the model to the data.
+
+        Fit the model to the data using the objective function defined in
+        the objective_function method. The optimization is performed using
+        the scipy.optimize.minimize function.
+        The optimization result is stored in the `.solution` property. Which
+
+        Parameters
+        ----------
+        x0 : array-like
+            Initial guess for the fitting parameters.
+        bounds : array-like
+            Bounds for the fitting parameters.
+        method : str, optional
+            The optimization method to use. Default is 'Nelder-Mead'.
+
+        Returns
+        -------
+        None
+        """
+        sol = minimize(
+            self.objective_function, x0=x0, bounds=bounds, method=method
+        )
+        self._solution = sol
+
+    @property
+    def solution(self):
+        return self._solution

yaeos/fitting/model_setters.py

@@ -0,0 +1,76 @@
+"""Model Setters.
+
+Compilation of functions that set a model's parameters to the values
+given in the input arguments.
+"""
+
+import numpy as np
+
+
+def fit_kij_lij(x, model, fit_kij, fit_lij):
+    """Set the kij and/or lij parameter of the model."""
+    mr = model.mixrule
+
+    if fit_kij and fit_lij:
+        kij = x[0]
+        lij = x[1]
+        mr.kij = np.array([[0, kij], [kij, 0]], order="F")
+        mr.lij = np.array([[0, lij], [lij, 0]], order="F")
+    elif fit_kij:
+        kij = x[0]
+        mr.kij = np.array([[0, kij], [kij, 0]], order="F")
+    elif fit_lij:
+        lij = x[0]
+        mr.lij = np.array([[0, lij], [lij, 0]], order="F")
+
+    model.set_mixrule(mr)
+    return model
+
+
+def fit_mhv_nrtl(x, args):
+    """Fit the MHV mixing rule for Cubic EoS with NRTL GE."""
+    from yaeos.models import NRTL, MHV
+
+    a12, a21, b12, b21, alpha = x
+
+    model = args[0]
+    q = args[1]
+
+    a = [
+        [
+            0,
+            a12,
+        ],
+        [a21, 0],
+    ]
+    b = [[0, b12], [b21, 0]]
+    c = [[0, alpha], [alpha, 0]]
+
+    nrtl = NRTL(a, b, c)
+    mr = MHV(ge=nrtl, q=q)
+    model.set_mixrule(mr)
+    return model
+
+
+def fit_hv_nrtl(x, args):
+    """Fit the HV mixing rule for Cubic EoS with NRTL GE."""
+    from yaeos.models import NRTL, HV
+
+    a12, a21, b12, b21, alpha = x
+
+    model = args[0]
+
+    a = [
+        [
+            0,
+            a12,
+        ],
+        [a21, 0],
+    ]
+    b = [[0, b12], [b21, 0]]
+    c = [[0, alpha], [alpha, 0]]
+
+    nrtl = NRTL(a, b, c)
+    mr = HV(nrtl)
+    model.set_mixrule(mr)
+    return model

yaeos/fitting/solvers.py

@@ -0,0 +1,87 @@
+"""Solvers.
+
+Module that contains different solvers for specific porpouses.
+"""
+
+import numpy as np
+
+
+def binary_isofugacity_x1y1pt(x, p, t, model):
+    """Isofugacity evaluation at a given P and T."""
+    y1, x1 = x
+
+    x = np.array([x1, 1 - x1])
+    y = np.array([y1, 1 - y1])
+
+    lnphi_x = model.lnphi_pt(x, pressure=p, temperature=t, root="stable")
+    lnphi_y = model.lnphi_pt(y, pressure=p, temperature=t, root="stable")
+
+    isofug = np.log(x) + lnphi_x - (np.log(y) + lnphi_y)
+
+    return isofug**2
+
+
+def solve_pt(model, p, t, kind):
+    """Solve a point at a given P and T."""
+    try:
+        x10, y10 = find_init_binary_ll(model, p, t, kind)
+    except ValueError:
+        x10, y10 = 0.1, 0.9
+
+    mean = (x10 + y10) / 2
+
+    z = [mean, 1 - mean]
+    y0 = np.array([y10, 1 - y10])
+    x0 = np.array([x10, 1 - x10])
+
+    flash = model.flash_pt(z, pressure=p, temperature=t, k0=y0 / x0)
+
+    x1 = flash["x"][0]
+    y1 = flash["y"][0]
+
+    return x1, y1
+
+
+def find_init_binary_ll(model, pressure, temperature, kind):
+    """Find initial guess for a binary liquid-liquid system."""
+    from scipy.signal import argrelmin, argrelmax
+
+    (
+        p,
+        t,
+    ) = (
+        pressure,
+        temperature,
+    )
+
+    if kind == "liquid-liquid":
+        root = "liquid"
+    else:
+        root = "stable"
+
+    zs = np.linspace(1e-15, 1 - 1e-15, 100)
+
+    phis = np.array(
+        [
+            model.lnphi_pt([z, 1 - z], temperature=t, pressure=p, root=root)
+            for z in zs
+        ]
+    )
+    phis = np.exp(phis)
+    fug_1 = zs * phis[:, 0] * p
+
+    argmin = argrelmin(zs * phis[:, 0] * p)[-1] + 1
+    argmax = argrelmax(zs * phis[:, 0] * p)[0] - 1
+
+    fug = np.mean([fug_1[argmin], fug_1[argmax]])
+
+    if fug > fug_1[-1]:
+        fug = np.mean([fug_1[argmin[0]], fug_1[-1]])
+
+    msk = zs < zs[argmax]
+    x1 = zs[msk][np.argmin(np.abs(fug - fug_1[msk]))]
+
+    msk = zs > zs[argmin]
+    y1 = zs[msk][np.argmin(np.abs(fug - fug_1[msk]))]
+
+    return x1, y1

yaeos/gpec.py

@@ -0,0 +1,225 @@
+"""Global Phase Equilibria Calculations.
+
+Module that implements the GPEC algorithm for calculation of GPEDs and its
+derivatives to obtain isopleths, isotherms and isobars.
+"""
+
+import matplotlib.pyplot as plt
+
+import numpy as np
+
+from yaeos.core import ArModel
+
+MAX_POINTS = 10000
+
+
+class GPEC:
+
+    def __init__(
+        self,
+        model: ArModel,
+        max_pressure=2500,
+        max_points=10000,
+        stability_analysis=True,
+        step_21=1e-2,
+        step_12=1e-5,
+    ):
+        self._z0 = np.array([0, 1])
+        self._zi = np.array([1, 0])
+        self._model = model
+
+        # Calculate the pure saturation pressures of each component and
+        # save it as an internal variable
+        psats = [model.pure_saturation_pressures(i) for i in [1, 2]]
+        self._pures = psats
+
+        # Calculate the critical line starting from the almost pure second
+        # component.
+        diff = 1e-3
+        cl, cep = model.critical_line(
+            z0=self._z0,
+            zi=self._zi,
+            ns=1,
+            s=diff,
+            a0=diff,
+            ds0=step_21,
+            stop_pressure=max_pressure,
+            max_points=max_points,
+            stability_analysis=stability_analysis,
+        )
+
+        self._cl21 = cl
+        self._cep21 = cep
+
+        # Check if the critical line did not reach to the pure first component.
+        # if not, calculate the critical line starting from the almost pure
+        # first component. It is important to make small steps because this
+        # kind of line can be pretty short.
+        if not np.isnan(cep["T"]) or (
+            abs(cl["T"][-1] - psats[0]["T"][-1]) > 10
+            and abs(cl["P"][-1] - psats[0]["P"][-1] > 10)
+        ):
+            cl, cep = model.critical_line(
+                z0=self._z0,
+                zi=self._zi,
+                ns=1,
+                s=1 - diff / 10,
+                a0=1 - diff / 10,
+                ds0=-step_12,
+                stop_pressure=max_pressure,
+                max_points=max_points,
+                stability_analysis=stability_analysis,
+            )
+
+            self._cl12 = cl
+            self._cep12 = cep
+        else:
+            self._cl12 = None
+            self._cep12 = None
+
+        a, T, V = model.critical_line_liquid_liquid(
+            z0=self._z0, zi=self._zi, pressure=max_pressure, t0=500
+        )
+
+        cl, cep = model.critical_line(
+            z0=self._z0,
+            zi=self._zi,
+            ns=4,
+            s=np.log(max_pressure),
+            a0=a,
+            v0=V,
+            t0=T,
+            p0=max_pressure,
+            ds0=-1e-1,
+            stop_pressure=max_pressure * 1.1,
+            max_points=max_points,
+            stability_analysis=stability_analysis,
+        )
+
+        self._cl_ll = cl
+        self._cep_ll = cep
+
+    def plot_gped(self):
+        for pure in self._pures:
+            plt.plot(pure["T"], pure["P"], color="green")
+
+        plt.plot(self._cl21["T"], self._cl21["P"], color="black")
+        if self._cl12:
+            plt.plot(self._cl12["T"], self._cl12["P"], color="black")
+        if self._cl_ll:
+            plt.plot(self._cl_ll["T"], self._cl_ll["P"], color="black")
+
+        plt.xlabel("Temperature (K)")
+        plt.ylabel("Pressure (bar)")
+
+    def plot_pxy(self, temperature, a0=1e-5):
+        """Plot a Pxy phase diagram"""
+        psat_1, psat_2 = self._pures
+
+        px_12 = px_21 = px_iso = None
+
+        # Below saturation temperature of light component
+        loc = np.argmin(abs(psat_2["T"] - temperature))
+        p0 = psat_2["P"][loc]
+        px_21 = self._model.phase_envelope_px(
+            self._z0,
+            self._zi,
+            temperature=temperature,
+            kind="bubble",
+            p0=p0,
+            a0=a0,
+            ds0=1e-3,
+            max_points=MAX_POINTS,
+        )
+
+        pxs = [px_12, px_21, px_iso]
+
+        for px in pxs:
+            if px:
+                plt.plot(px.main_phases_compositions[:, 0, 0], px["P"])
+                plt.plot(px.reference_phase_compositions[:, 0], px["P"])
+
+        plt.xlabel(r"$x_1$, $y_1$")
+        plt.ylabel("Pressure (bar)")
+
+        return pxs
+
+    def plot_txy(self, pressure, a0=1e-5):
+        """Plot a Txy phase diagram"""
+        psat_1, psat_2 = self._pures
+
+        tx_12 = tx_21 = tx_ll = None
+
+        # Below critical pressure of heavy component
+        if pressure < psat_2["P"][-1]:
+            loc = np.argmin(abs(psat_2["P"] - pressure))
+            t0 = psat_2["T"][loc]
+
+            tx_21 = self._model.phase_envelope_tx(
+                self._z0,
+                self._zi,
+                pressure=pressure,
+                kind="dew",
+                t0=t0,
+                a0=a0,
+                ds0=1e-5,
+                max_points=MAX_POINTS,
+            )
+        if pressure < psat_1["P"][-1]:
+            # Below critical pressure of the light component
+            loc = np.argmin(abs(psat_1["P"] - pressure))
+            t0 = psat_1["T"][loc]
+
+            tx_12 = self._model.phase_envelope_tx(
+                self._z0,
+                self._zi,
+                pressure=pressure,
+                kind="bubble",
+                t0=t0,
+                a0=1 - a0,
+                ds0=-1e-5,
+                max_points=MAX_POINTS,
+            )
+
+        if self._cl_ll:
+            loc = np.argmin(abs(self._cl_ll["P"] - pressure))
+            t0, p = self._cl_ll["T"][loc], self._cl_ll["P"][loc]
+            if abs(p - pressure) < 1 or pressure > psat_1["P"][-1]:
+
+                a = self._cl_ll["a"][loc]
+                z = a * self._zi + (1 - a) * self._z0
+                x_l0 = [z.copy()]
+
+                x_l0[0][0] += 1e-5
+                x_l0[0][1] -= 1e-5
+                w0 = z.copy()
+                w0[0] -= 1e-5
+                w0[1] += 1e-5
+
+                tx_ll = self._model.phase_envelope_tx_mp(
+                    z0=self._z0,
+                    zi=self._zi,
+                    p=pressure,
+                    kinds_x=["liquid"],
+                    kind_w="liquid",
+                    x_l0=x_l0,
+                    w0=w0,
+                    betas0=[1],
+                    t0=t0,
+                    alpha0=a + 1e-5,
+                    ns0=len(z) + 3,
+                    ds0=1e-4,
+                    max_points=MAX_POINTS,
+                )
+
+        txs = [tx_12, tx_21, tx_ll]
+
+        for tx in txs:
+            if tx:
+                plt.plot(tx.main_phases_compositions[:, 0, 0], tx["T"])
+                plt.plot(tx.reference_phase_compositions[:, 0], tx["T"])
+
+        plt.xlabel(r"$x_1$, $y_1$")
+        plt.ylabel("Temperature (K)")
+
+        return txs

yaeos/lib/__init__.py

@@ -0,0 +1,9 @@
+"""yaeos_c module.
+
+This module provides the yaeos_c module, which is a Python interface to the
+yaeos C API compiled with f2py.
+"""
+
+from yaeos.lib.yaeos_python import yaeos_c
+
+__all__ = ["yaeos_c"]

yaeos/models/__init__.py

@@ -0,0 +1,26 @@
+"""Models module.
+
+Yaeos models module. This module provides the following submodules:
+
+- excess_gibbs: Excess Gibbs energy models
+    - NRTL: non-random two-liquid model
+    - UNIFACVLE: Original UNIFAC VLE model
+    - UNIQUAC: UNIversal QUAsiChemical Excess Gibbs free energy model
+
+- residual_helmholtz: Residual Helmholtz energy models
+    - Cubic EoS:
+        - PengRobinson76: Peng-Robinson model (1976)
+        - PengRobinson78: Peng-Robinson model (1978)
+        - SoaveRedlichKwong: Soave-Redlich-Kwong model
+        - RKPR: RKPR model
+    - Mixing rules: mixing rules for cubic EoS
+        - QMR: cuadratic mixing rule
+        - MHV: modified Huron-Vidal mixing rule
+    - Multifluid EoS:
+        - GERG2008: GERG2008 Residual contribution
+"""
+
+from . import excess_gibbs, residual_helmholtz
+
+
+__all__ = ["excess_gibbs", "residual_helmholtz"]

yaeos/models/excess_gibbs/__init__.py

@@ -0,0 +1,20 @@
+"""Gibbs Excess Models module.
+
+Yaeos Gibbs excess module. This module provides the following submodules:
+
+- excess_gibbs: Excess Gibbs energy models
+    - NRTL: non-random two-liquid model
+    - UNIFACVLE: Original UNIFAC VLE model
+    - UNIFACPSRK: UNIFAC-PSRK model (Predictive Soave-Redlich-Kwong)
+    - UNIFACDortmund: UNIFAC Dortmund model
+    - UNIQUAC: UNIversal QUAsiChemical Excess Gibbs free energy model
+"""
+
+from .dortmund import UNIFACDortmund
+from .nrtl import NRTL
+from .psrk_unifac import UNIFACPSRK
+from .unifac import UNIFACVLE
+from .uniquac import UNIQUAC
+
+
+__all__ = ["NRTL", "UNIFACVLE", "UNIFACPSRK", "UNIFACDortmund", "UNIQUAC"]

yaeos/models/excess_gibbs/dortmund.py

@@ -0,0 +1,45 @@
+"""UNIFAC Dortmund Module."""
+
+from typing import List
+
+from yaeos.core import GeModel
+from yaeos.lib import yaeos_c
+from yaeos.models.groups import groups_from_dicts
+
+
+class UNIFACDortmund(GeModel):
+    """UNIFAC Dortmund model.
+
+    Please refer to the `yaeos` user documentation for an in-depth look at the
+    model's information: https://ipqa-research.github.io/yaeos/page/index.html
+
+    Parameters
+    ----------
+    molecules : list of dict
+        List of dicts with the groups and their amounts for each molecule.
+
+    Example
+    -------
+    .. code-block:: python
+
+        from yaeos import UNIFACDortmund
+
+        # Groups for water and ethanol
+        water = {16: 1}
+        ethanol = {1: 1, 2: 1, 14: 1}
+
+        groups = [water, ethanol]
+
+        model = UNIFACDortmund(groups)
+
+        model.ln_gamma([0.5, 0.5], 298.15)
+    """
+
+    def __init__(self, molecules: List[dict]) -> None:
+
+        (number_of_groups, groups_ids, groups_ammounts) = groups_from_dicts(
+            molecules
+        )
+        self.id = yaeos_c.unifac_dortmund(
+            ngs=number_of_groups, g_ids=groups_ids, g_v=groups_ammounts
+        )