yaeos 3.1.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

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,104 @@
+"""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
+
+
+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 = [0, 1]
+        self._zi = [1, 0]
+        self._model = model
+
+        psats = [model.pure_saturation_pressures(i) for i in [1, 2]]
+
+        self._pures = psats
+
+        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
+
+        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")

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,24 @@
+"""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
+"""
+
+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
+        )

yaeos/models/excess_gibbs/nrtl.py

@@ -0,0 +1,49 @@
+"""Non-random two-liquid model (NRTL) module."""
+
+from yaeos.core import GeModel
+from yaeos.lib import yaeos_c
+
+
+class NRTL(GeModel):
+    """Non-random two-liquid model (NRTL) class.
+
+    Parameters
+    ----------
+    a : array_like
+        NRTL aij parameters matrix
+    b : array_like
+        NRTL bij parameters matrix
+    c : array_like
+        NRTL cij parameters matrix
+
+    Attributes
+    ----------
+    a : array_like
+        NRTL aij parameters matrix
+    b : array_like
+        NRTL bij parameters matrix
+    c : array_like
+        NRTL cij parameters matrix
+    id : int
+        NRTL model ID
+
+    Example
+    -------
+    .. code-block:: python
+
+        import numpy as np
+
+        from yaeos import NRTL
+
+        a = np.array([[0, 0.3], [0.3, 0]])
+        b = np.array([[0, 0.4], [0.4, 0]])
+        c = np.array([[0, 0.5], [0.5, 0]])
+
+        nrtl = NRTL(a, b, c)
+    """
+
+    def __init__(self, a, b, c) -> None:
+        self.a = a
+        self.b = b
+        self.c = c
+        self.id = yaeos_c.nrtl(a, b, c)

yaeos/models/excess_gibbs/psrk_unifac.py

@@ -0,0 +1,45 @@
+"""PSRK-UNIFAC 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 UNIFACPSRK(GeModel):
+    """PSRK-UNIFAC 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 UNIFACPSRK
+
+        # Groups for water and ethanol
+        water = {16: 1}
+        ethanol = {1: 1, 2: 1, 14: 1}
+
+        groups = [water, ethanol]
+
+        model = UNIFACPSRK(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_psrk(
+            ngs=number_of_groups, g_ids=groups_ids, g_v=groups_ammounts
+        )

yaeos/models/excess_gibbs/unifac.py

@@ -0,0 +1,45 @@
+"""UNIFAC 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 UNIFACVLE(GeModel):
+    """UNIFAC VLE 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 UNIFACVLE
+
+        # Groups for water and ethanol
+        water = {16: 1}
+        ethanol = {1: 1, 2: 1, 14: 1}
+
+        groups = [water, ethanol]
+
+        model = UNIFAVLE(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_vle(
+            ngs=number_of_groups, g_ids=groups_ids, g_v=groups_ammounts
+        )

yaeos/models/excess_gibbs/uniquac.py

@@ -0,0 +1,117 @@
+"""UNIQUAC (UNIversal QUAsiChemical) Excess Gibbs free energy model."""
+
+import numpy as np
+
+from yaeos.core import GeModel
+from yaeos.lib import yaeos_c
+
+
+class UNIQUAC(GeModel):
+    """UNIQUAC (UNIversal QUAsiChemical) Excess Gibbs free energy 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
+    ----------
+    qs : array_like
+        Molecule's relative areas :math:`Q_i`
+    rs : array_like
+        Molecule's relative volumes :math:`R_i`
+    aij : array_like
+        Interaction parameters matrix :math:`a_{ij}` zero matrix if no
+        provided, by default None
+    bij : array_like
+        Interaction parameters matrix :math:`b_{ij}` zero matrix if no
+        provided, by default None
+    cij : array_like
+        Interaction parameters matrix :math:`c_{ij}` zero matrix if no
+        provided, by default None
+    dij : array_like
+        Interaction parameters matrix :math:`d_{ij}` zero matrix if no
+        provided, by default None
+    eij : array_like
+        Interaction parameters matrix :math:`e_{ij}` zero matrix if no
+        provided, by default None
+
+    Attributes
+    ----------
+    qs : array_like
+        Molecule's relative areas :math:`Q_i`
+    rs : array_like
+        Molecule's relative volumes :math:`R_i`
+    aij : array_like
+        Interaction parameters matrix :math:`a_{ij}`
+    bij : array_like
+        Interaction parameters matrix :math:`b_{ij}`
+    cij : array_like
+        Interaction parameters matrix :math:`c_{ij}`
+    dij : array_like
+        Interaction parameters matrix :math:`d_{ij}`
+    eij : array_like
+        Interaction parameters matrix :math:`e_{ij}`
+
+    Example
+    -------
+    .. code-block:: python
+
+        import numpy as np
+
+        from yaeos import UNIQUAC
+
+        b = np.array(
+            [
+                [0.0, -526.02, -309.64],
+                [318.06, 0.0, 91.532],
+                [-1325.1, -302.57, 0.0],
+            ]
+        )
+
+        rs = np.array([0.92, 2.1055, 3.1878])
+        qs = np.array([1.4, 1.972, 2.4])
+
+        t = 298.15
+
+        model = UNIQUAC(qs, rs, bij=b)
+
+        n = np.array([2.0, 2.0, 8.0])
+
+        gammas = np.exp(model.ln_gamma(n, t)) # [8.856, 0.860, 1.425]
+    """
+
+    def __init__(
+        self, qs, rs, aij=None, bij=None, cij=None, dij=None, eij=None
+    ) -> None:
+        self.qs = qs
+        self.rs = rs
+
+        nc = len(qs)
+
+        if aij is not None:
+            self.aij = np.array(aij, order="F")
+        else:
+            self.aij = np.zeros((nc, nc), order="F")
+
+        if bij is not None:
+            self.bij = np.array(bij, order="F")
+        else:
+            self.bij = np.zeros((nc, nc), order="F")
+
+        if cij is not None:
+            self.cij = np.array(cij, order="F")
+        else:
+            self.cij = np.zeros((nc, nc), order="F")
+
+        if dij is not None:
+            self.dij = np.array(dij, order="F")
+        else:
+            self.dij = np.zeros((nc, nc), order="F")
+
+        if eij is not None:
+            self.eij = np.array(eij, order="F")
+        else:
+            self.eij = np.zeros((nc, nc), order="F")
+
+        self.id = yaeos_c.uniquac(
+            qs, rs, self.aij, self.bij, self.cij, self.dij, self.eij
+        )

yaeos/models/groups.py

@@ -0,0 +1,49 @@
+"""Handling groups for Group Contribution Models."""
+
+from typing import List
+
+import numpy as np
+
+
+def groups_from_dicts(molecules: List[dict]):
+    """Convert list of dicts with groups and their to C-API format.
+
+    Convert list of dicts with groups and their amounts to the format required
+    by the C-API.
+
+    Parameters
+    ----------
+    molecules : list of dict
+
+    Returns
+    -------
+    number_of_groups : list of int
+        Number of groups for each molecule.
+    groups_ids : np.ndarray
+        Groups ids for each molecule.
+    groups_ammounts : np.ndarray
+        Groups amounts for each molecule.
+    """
+    nc = len(molecules)
+    max_ng = max([len(groups) for groups in molecules])
+
+    # The C-API expects two 2D arrays with the groups and their amounts
+    # for each molecule. Each row in the arrays corresponds to a molecule
+    # and the columns to the groups. The arrays are padded with zeros.
+    groups_ids = np.zeros((nc, max_ng), dtype=np.int32, order="F")
+    groups_ammounts = np.zeros((nc, max_ng), dtype=np.int32, order="F")
+
+    # Construction of the arrays from the input dictionary
+    number_of_groups = []
+    for i, molecule_groups in enumerate(molecules):
+        ids = []
+        ammount = []
+        for group_id, group_count in molecule_groups.items():
+            ids.append(int(group_id))
+            ammount.append(int(group_count))
+
+        number_of_groups.append(len(ids))
+        groups_ids[i, : len(ids)] = ids
+        groups_ammounts[i, : len(ids)] = ammount
+
+    return number_of_groups, groups_ids, groups_ammounts

yaeos/models/residual_helmholtz/__init__.py

@@ -0,0 +1,21 @@
+"""Residual Helmholtz energy models module.
+
+Yaeos Residual Helmholtz module. This module provides the following submodules:
+
+- 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
+        - PSRK: Predictive-Soave-Redlich-Kwong model
+    - Mixing rules: mixing rules for cubic EoS
+        - QMR: cuadratic mixing rule
+        - HV: Huron-Vidal mixing rule
+        - MHV: Michelsen's modified Huron-Vidal mixing rule
+"""
+
+from . import cubic_eos
+
+
+__all__ = ["cubic_eos"]

yaeos/models/residual_helmholtz/cubic_eos/__init__.py

@@ -0,0 +1,38 @@
+"""Cubic EoS module.
+
+Implemented 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
+"""
+
+from .cubic_eos import (
+    CubicEoS,
+    PSRK,
+    PengRobinson76,
+    PengRobinson78,
+    RKPR,
+    SoaveRedlichKwong,
+)
+from .mixing_rules import CubicMixRule, HV, MHV, QMR, QMRTD
+
+
+__all__ = [
+    "CubicEoS",
+    "PengRobinson76",
+    "PengRobinson78",
+    "SoaveRedlichKwong",
+    "RKPR",
+    "PSRK",
+    "CubicMixRule",
+    "QMR",
+    "QMRTD",
+    "MHV",
+    "HV",
+]