yaeos 0.1.1__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

yaeos/__init__.py

@@ -0,0 +1,30 @@
+"""Yet Another Equation-Of-State (library).
+
+Library to use EoS-based calculations. This main module imports all the
+relevant constants, procedures and objects to have better access to them.
+"""
+
+from yaeos.lib import yaeos_c
+from yaeos.models.excess_gibbs.nrtl import (
+    NRTL,
+)
+from yaeos.models.residual_helmholtz.cubic_eos import (
+    MHV,
+    PengRobinson76,
+    PengRobinson78,
+    QMR,
+    RKPR,
+    SoaveRedlichKwong,
+)
+
+
+__all__ = [
+    "yaeos_c",
+    "SoaveRedlichKwong",
+    "PengRobinson76",
+    "PengRobinson78",
+    "RKPR",
+    "QMR",
+    "NRTL",
+    "MHV",
+]

yaeos/core.py

@@ -0,0 +1,557 @@
+"""yaeos Python API core module.
+
+ArModel and GeModel abstract classes definition. Also, the implementation of
+the models' thermoprops methods.
+"""
+
+from abc import ABC
+from typing import Union
+
+import numpy as np
+
+from yaeos.lib import yaeos_c
+
+
+class GeModel(ABC):
+    """Excess Gibbs (Ge) model abstract class."""
+
+    def __del__(self) -> None:
+        """Delete the model from the available models list (Fortran side)."""
+        yaeos_c.make_available_ge_models_list(self.id)
+
+
+class ArModel(ABC):
+    """Residual Helmholtz (Ar) model abstract class."""
+
+    def lnphi_vt(
+        self,
+        moles,
+        volume: float,
+        temperature: float,
+        dt: bool = False,
+        dp: bool = False,
+        dn: bool = False,
+    ) -> Union[np.ndarray, tuple[np.ndarray, dict]]:
+        r"""Calculate fugacity coefficent given volume and temperature.
+
+        Calculate :math:`ln \phi_i(n,V,T)` and its derivatives with respect to
+        temperature, pressure and moles number.
+
+        Parameters
+        ----------
+        moles : array_like
+            Moles number vector [mol]
+        volume : float
+            Volume [L]
+        temperature : float
+            Temperature [K]
+        dt : bool, optional
+            Calculate temperature derivative, by default False
+        dp : bool, optional
+            Calculate pressure derivative, by default False
+        dn : bool, optional
+            Calculate moles derivative, by default False
+
+        Returns
+        -------
+        Union[np.ndarray, tuple[np.ndarray, dict]]
+            :math:`ln \phi_i(n,V,T)` vector or tuple with
+            :math:`ln \phi_i(n,V,T)` vector and derivatives dictionary if any
+            derivative is asked
+
+        Example
+        -------
+        .. code-block:: python
+
+            import numpy as np
+
+            from yaeos import PengRobinson76
+
+
+            tc = np.array([320.0, 375.0])   # critical temperatures [K]
+            pc = np.array([45.0, 60.0])     # critical pressures [bar]
+            w = np.array([0.0123, 0.045])   # acentric factors
+
+            model = PengRobinson76(tc, pc, w)
+
+            # Evaluating ln_phi only
+            # will print: [-1.45216274 -2.01044828]
+
+            print(model.lnphi_vt([5.0, 5.6], 1.0, 300.0))
+
+            # Asking for derivatives
+            # will print:
+            # (
+            # array([-1.45216274, -2.01044828]),
+            # {'dt': array([0.01400063, 0.01923493]), 'dp': None, 'dn': None}
+            # )
+
+            print(model.lnphi_vt([5.0, 5.6], 1.0, 300.0, dt=True)
+        """
+        nc = len(moles)
+
+        dt = np.empty(nc, order="F") if dt else None
+        dp = np.empty(nc, order="F") if dp else None
+        dn = np.empty((nc, nc), order="F") if dn else None
+
+        res = yaeos_c.lnphi_vt(
+            self.id,
+            moles,
+            volume,
+            temperature,
+            dlnphidt=dt,
+            dlnphidp=dp,
+            dlnphidn=dn,
+        )
+
+        if dt is None and dp is None and dn is None:
+            ...
+        else:
+            res = (res, {"dt": dt, "dp": dp, "dn": dn})
+        return res
+
+    def lnphi_pt(
+        self,
+        moles,
+        pressure: float,
+        temperature: float,
+        root: str = "stable",
+        dt: bool = False,
+        dp: bool = False,
+        dn: bool = False,
+    ) -> Union[np.ndarray, tuple[np.ndarray, dict]]:
+        r"""Calculate fugacity coefficent given pressure and temperature.
+
+        Calculate :math:`ln \phi_i(n,P,T)` and its derivatives with respect to
+        temperature, pressure and moles number.
+
+        Parameters
+        ----------
+        moles : array_like
+            Moles number vector [mol]
+        pressure : float
+            Pressure [bar]
+        temperature : float
+            Temperature [K]
+        root : str, optional
+            Volume root, use: "liquid", "vapor" or "stable", by default
+            "stable"
+        dt : bool, optional
+            Calculate temperature derivative, by default False
+        dp : bool, optional
+            Calculate pressure derivative, by default False
+        dn : bool, optional
+            Calculate moles derivative, by default False
+
+        Returns
+        -------
+        Union[np.ndarray, tuple[np.ndarray, dict]]
+            :math:`ln \phi_i(n,P,T)` vector or tuple with
+            :math:`ln \phi_i(n,P,T)` vector and derivatives dictionary if any
+            derivative is asked
+
+        Example
+        -------
+        .. code-block:: python
+
+            import numpy as np
+
+            from yaeos import PengRobinson76
+
+
+            tc = np.array([320.0, 375.0])   # critical temperatures [K]
+            pc = np.array([45.0, 60.0])     # critical pressures [bar]
+            w = np.array([0.0123, 0.045])   # acentric factors
+
+            model = PengRobinson76(tc, pc, w)
+
+            # Evaluating ln_phi only
+            # will print: [-0.10288733 -0.11909807]
+
+            print(model.lnphi_pt([5.0, 5.6], 10.0, 300.0))
+
+            # Asking for derivatives
+            # will print:
+            # (
+            # array([-0.10288733, -0.11909807]),
+            # {'dt': array([0.00094892, 0.00108809]), 'dp': None, 'dn': None}
+            # )
+
+            print(model.lnphi_pt([5.0, 5.6], 10.0, 300.0, dt=True)
+        """
+        nc = len(moles)
+
+        dt = np.empty(nc, order="F") if dt else None
+        dp = np.empty(nc, order="F") if dp else None
+        dn = np.empty((nc, nc), order="F") if dn else None
+
+        res = yaeos_c.lnphi_pt(
+            self.id,
+            moles,
+            pressure,
+            temperature,
+            root,
+            dlnphidt=dt,
+            dlnphidp=dp,
+            dlnphidn=dn,
+        )
+
+        if dt is None and dp is None and dn is None:
+            ...
+        else:
+            res = (res, {"dt": dt, "dp": dp, "dn": dn})
+        return res
+
+    def pressure(
+        self,
+        moles,
+        volume: float,
+        temperature: float,
+        dv: bool = False,
+        dt: bool = False,
+        dn: bool = False,
+    ) -> Union[float, tuple[float, dict]]:
+        """Calculate pressure given volume and temperature [bar].
+
+        Calculate :math:`P(n,V,T)` and its derivatives with respect to
+        volume, temperature and moles number.
+
+        Parameters
+        ----------
+        moles : array_like
+            Moles number vector [mol]
+        volume : float
+            Volume [L]
+        temperature : float
+            Temperature [K]
+        dv : bool, optional
+            Calculate volume derivative, by default False
+        dt : bool, optional
+            Calculate temperature derivative, by default False
+        dn : bool, optional
+            Calculate moles derivative, by default False
+
+        Returns
+        -------
+        Union[float, tuple[float, dict]]
+            Pressure or tuple with Presure and derivatives dictionary if any
+            derivative is asked [bar]
+
+        Example
+        -------
+        .. code-block:: python
+
+            import numpy as np
+
+            from yaeos import PengRobinson76
+
+
+            tc = np.array([320.0, 375.0])   # critical temperatures [K]
+            pc = np.array([45.0, 60.0])     # critical pressures [bar]
+            w = np.array([0.0123, 0.045])   # acentric factors
+
+            model = PengRobinson76(tc, pc, w)
+
+            # Evaluating pressure only
+            # will print: 16.011985733846956
+
+            print(model.pressure(np.array([5.0, 5.6]), 2.0, 300.0))
+
+            # Asking for derivatives
+            # will print:
+            # (
+            # 16.011985733846956,
+            # {'dv': None, 'dt': np.float64(0.7664672352866752), 'dn': None}
+            # )
+
+            print(model.pressure(np.array([5.0, 5.6]), 2.0, 300.0, dt=True))
+        """
+        nc = len(moles)
+
+        dv = np.empty(1, order="F") if dv else None
+        dt = np.empty(1, order="F") if dt else None
+        dn = np.empty(nc, order="F") if dn else None
+
+        res = yaeos_c.pressure(
+            self.id, moles, volume, temperature, dpdv=dv, dpdt=dt, dpdn=dn
+        )
+
+        if dt is None and dv is None and dn is None:
+            ...
+        else:
+            res = (
+                res,
+                {
+                    "dv": dv if dv is None else dv[0],
+                    "dt": dt if dt is None else dt[0],
+                    "dn": dn,
+                },
+            )
+        return res
+
+    def volume(
+        self, moles, pressure: float, temperature: float, root: str = "stable"
+    ) -> float:
+        """Calculate volume given pressure and temperature [L].
+
+        Parameters
+        ----------
+        moles : array_like
+            Moles number vector [mol]
+        pressure : float
+            Pressure [bar]
+        temperature : float
+            Temperature [K]
+        root : str, optional
+            Volume root, use: "liquid", "vapor" or "stable", by default
+            "stable"
+
+        Returns
+        -------
+        float
+            Volume [L]
+
+        Example
+        -------
+        .. code-block:: python
+
+            import numpy as np
+
+            from yaeos import PengRobinson76
+
+
+            tc = np.array([320.0, 375.0])   # critical temperatures [K]
+            pc = np.array([45.0, 60.0])     # critical pressures [bar]
+            w = np.array([0.0123, 0.045])   # acentric factors
+
+            model = PengRobinson76(tc, pc, w)
+
+            # Evaluating stable root volume
+            # will print: 23.373902973572587
+
+            print(model.volume(np.array([5.0, 5.6]), 10.0, 300.0))
+
+            # Liquid root volume (not stable)
+            # will print: 0.8156388756398074
+
+            print(model.volume(np.array([5.0, 5.6]), 10.0, 300.0, "liquid"))
+        """
+        res = yaeos_c.volume(self.id, moles, pressure, temperature, root)
+        return res
+
+    def flash_pt(self, z, pressure: float, temperature: float) -> dict:
+        """Two-phase split with specification of temperature and pressure.
+
+        Parameters
+        ----------
+        z : array_like
+            Global mole fractions
+        pressure : float
+            Pressure [bar]
+        temperature : float
+            Temperature [K]
+
+        Returns
+        -------
+        dict
+            Flash result dictionary with keys:
+                - x: heavy phase mole fractions
+                - y: light phase mole fractions
+                - Vx: heavy phase volume [L]
+                - Vy: light phase volume [L]
+                - P: pressure [bar]
+                - T: temperature [K]
+                - beta: light phase fraction
+
+        Example
+        -------
+        .. code-block:: python
+
+            import numpy as np
+
+            from yaeos import PengRobinson76
+
+
+            tc = np.array([369.83, 507.6])       # critical temperatures [K]
+            pc = np.array([42.48, 30.25])        # critical pressures [bar]
+            w = np.array([0.152291, 0.301261])   # acentric factors
+
+            model = PengRobinson76(tc, pc, w)
+
+            # Flash calculation
+            # will print:
+            # {
+            #   'x': array([0.3008742, 0.6991258]),
+            #   'y': array([0.85437317, 0.14562683]),
+            #   'Vx': 0.12742569165483714,
+            #   'Vy': 3.218831515959867,
+            #   'P': 8.0,
+            #   'T': 350.0,
+            #   'beta': 0.35975821044266726
+            # }
+
+            print(model.flash_pt([0.5, 0.5], 8.0, 350.0))
+        """
+        x, y, pressure, temperature, volume_x, volume_y, beta = yaeos_c.flash(
+            self.id, z, p=pressure, t=temperature
+        )
+
+        flash_result = {
+            "x": x,
+            "y": y,
+            "Vx": volume_x,
+            "Vy": volume_y,
+            "P": pressure,
+            "T": temperature,
+            "beta": beta,
+        }
+
+        return flash_result
+
+    def saturation_pressure(
+        self, z, temperature: float, kind: str = "bubble"
+    ) -> dict:
+        """Saturation pressure at specified temperature.
+
+        Arguments
+        ---------
+        z: array_like
+            Global molar fractions
+        temperature: float
+            Temperature [K]
+        kind: str, optional
+            Kind of saturation point, defaults to "bubble". Options are
+                - "bubble"
+                - "dew"
+                - "liquid-liquid"
+
+        Returns
+        -------
+        dict
+            Saturation pressure calculation result dictionary with keys:
+                - x: heavy phase mole fractions
+                - y: light phase mole fractions
+                - Vx: heavy phase volume [L]
+                - Vy: light phase volume [L]
+                - P: pressure [bar]
+                - T: temperature [K]
+                - beta: light phase fraction
+
+        Example
+        -------
+        .. code-block:: python
+
+            import numpy as np
+
+            from yaeos import PengRobinson76
+
+
+            tc = np.array([369.83, 507.6])       # critical temperatures [K]
+            pc = np.array([42.48, 30.25])        # critical pressures [bar]
+            w = np.array([0.152291, 0.301261])   # acentric factors
+
+            model = PengRobinson76(tc, pc, w)
+
+            # Saturation pressure calculation
+            # will print:
+            # {
+            # 'x': array([0.5, 0.5]),
+            # 'y': array([0.9210035 , 0.07899651]),
+            # 'Vx': 0.11974125553488875,
+            # 'Vy': 1.849650524323853,
+            # 'T': 350.0,
+            # 'P': 12.990142036059941,
+            # 'beta': 0.0
+            # }
+
+            print(model.saturation_pressure(np.array([0.5, 0.5]), 350.0))
+        """
+        p, x, y, volume_x, volume_y, beta = yaeos_c.saturation_pressure(
+            self.id, z, temperature, kind
+        )
+
+        return {
+            "x": x,
+            "y": y,
+            "Vx": volume_x,
+            "Vy": volume_y,
+            "T": temperature,
+            "P": p,
+            "beta": beta,
+        }
+
+    def phase_envelope_pt(
+        self,
+        z,
+        kind: str = "bubble",
+        max_points: int = 300,
+        t0: float = 150.0,
+        p0: float = 1.0,
+    ) -> dict:
+        """Two phase envelope calculation (PT).
+
+        Parameters
+        ----------
+        z : array_like
+            Global mole fractions
+        kind : str, optional
+            Kind of saturation point to start the envelope calculation,
+            defaults to "bubble". Options are
+            - "bubble"
+            - "dew"
+        max_points : int, optional
+            Envelope's maximum points to calculate (T, P), by default 300
+        t0 : float, optional
+            Initial guess for temperature [K] for the saturation point of kind:
+            `kind`, by default 150.0
+        p0 : float, optional
+            Initial guess for pressure [bar] for the saturation point of kind:
+            `kind`, by default 1.0
+
+        Returns
+        -------
+        dict
+            Envelope calculation result dictionary with keys:
+                - Ts: temperatures [K]
+                - Ps: pressures [bar]
+                - Tcs: critical temperatures [K]
+                - Pcs: critical pressures [bar]
+
+        Example
+        -------
+        .. code-block:: python
+
+            import numpy as np
+
+            import matplotlib.pyplot as plt
+
+            from yaeos import PengRobinson76
+
+
+            tc = np.array([369.83, 507.6])       # critical temperatures [K]
+            pc = np.array([42.48, 30.25])        # critical pressures [bar]
+            w = np.array([0.152291, 0.301261])   # acentric factors
+
+            model = PengRobinson76(tc, pc, w)
+
+            # Two phase envelope calculation and plot
+            env = model.phase_envelope_pt(
+                np.array([0.5, 0.5]),
+                t0=150.0,
+                p0=1.0
+            )
+
+            plt.plot(env["Ts"], env["Ps"])
+            plt.scatter(env["Tcs"], env["Pcs"])
+        """
+        ts, ps, tcs, pcs = yaeos_c.pt2_phase_envelope(
+            self.id, z, kind=kind, t0=t0, p0=p0, max_points=max_points
+        )
+
+        res = {"Ts": ts, "Ps": ps, "Tcs": tcs, "Pcs": pcs}
+
+        return res
+
+    def __del__(self) -> None:
+        """Delete the model from the available models list (Fortran side)."""
+        yaeos_c.make_available_ar_models_list(self.id)

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,22 @@
+"""Models module.
+
+Yaeos models module. This module provides the following submodules:
+
+- excess_gibbs: Excess Gibbs energy models
+    - NRTL: non-random two-liquid 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,12 @@
+"""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
+"""
+
+from .nrtl import NRTL
+
+
+__all__ = ["NRTL"]

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/residual_helmholtz/__init__.py

@@ -0,0 +1,19 @@
+"""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
+    - Mixing rules: mixing rules for cubic EoS
+        - QMR: cuadratic mixing rule
+        - MHV: modified Huron-Vidal mixing rule
+"""
+
+from . import cubic_eos
+
+
+__all__ = ["cubic_eos"]

yaeos/models/residual_helmholtz/cubic_eos/__init__.py

@@ -0,0 +1,34 @@
+"""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,
+    PengRobinson76,
+    PengRobinson78,
+    RKPR,
+    SoaveRedlichKwong,
+)
+from .mixing_rules import CubicMixRule, MHV, QMR
+
+
+__all__ = [
+    "CubicEoS",
+    "PengRobinson76",
+    "PengRobinson78",
+    "SoaveRedlichKwong",
+    "RKPR",
+    "CubicMixRule",
+    "QMR",
+    "MHV",
+]

yaeos/models/residual_helmholtz/cubic_eos/cubic_eos.py

@@ -0,0 +1,335 @@
+"""Cubic EoS implementations module."""
+
+from yaeos.core import ArModel
+from yaeos.lib import yaeos_c
+from yaeos.models.residual_helmholtz.cubic_eos.mixing_rules import CubicMixRule
+
+
+class CubicEoS(ArModel):
+    """Cubic equation of state base class.
+
+    Parameters
+    ----------
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+
+    Attributes
+    ----------
+    nc : int
+        Number of components
+    tc : array_like
+        Critical temperatures vector [K]
+    pc : array_like
+        Critical pressures vector [bar]
+    w : array_like
+        Acentric factors vector
+    """
+
+    def __init__(
+        self,
+        critical_temperatures,
+        critical_pressures,
+        acentric_factors,
+    ) -> None:
+        nc = len(critical_temperatures)
+        self.nc = nc
+        self.tc = critical_temperatures
+        self.pc = critical_pressures
+        self.w = acentric_factors
+
+    def set_mixrule(self, mixrule: CubicMixRule) -> None:
+        """Set the mixing rule for the EoS.
+
+        Parameters
+        ----------
+        mixrule : CubicMixRule
+            Mixing rule object
+        """
+        self.mixrule = mixrule
+        self.mixrule.set_mixrule(self.id)
+
+
+class PengRobinson76(CubicEoS):
+    """Peng-Robinson 1976 cubic equation of state.
+
+    Parameters
+    ----------
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+    mixrule : CubicMixRule, optional
+        Mixing rule object. If no provided the quadratric mixing rule (QMR)
+        with zero for kij and lij parameters is set, by default None
+
+    Attributes
+    ----------
+    nc : int
+        Number of components
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+    id : int
+        EoS identifier
+    mixrule : CubicMixRule
+        Mixing rule object
+
+    Example
+    -------
+    .. code-block:: python
+
+        from yaeos import PengRobinson76
+
+        tc = [190.56, 305.32]   # Critical temperatures [K]
+        pc = [45.99, 48.72]     # Critical pressures [bar]
+        w = [0.0115, 0.0985]    # Acentric factors
+
+        pr76 = PengRobinson76(tc, pc, w)
+    """
+
+    name = "PengRobinson76"
+
+    def __init__(
+        self,
+        critical_temperatures,
+        critical_pressures,
+        acentric_factors,
+        mixrule: CubicMixRule = None,
+    ) -> None:
+
+        super(PengRobinson76, self).__init__(
+            critical_temperatures,
+            critical_pressures,
+            acentric_factors,
+        )
+        self.id = yaeos_c.pr76(self.tc, self.pc, self.w)
+        self.mixrule = mixrule
+        if mixrule:
+            mixrule.set_mixrule(self.id)
+
+
+class PengRobinson78(CubicEoS):
+    """Peng-Robinson 1978 cubic equation of state.
+
+    Parameters
+    ----------
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+    mixrule : CubicMixRule, optional
+        Mixing rule object. If no provided the quadratric mixing rule (QMR)
+        with zero for kij and lij parameters is set, by default None
+
+    Attributes
+    ----------
+    nc : int
+        Number of components
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+    id : int
+        EoS identifier
+    mixrule : CubicMixRule
+        Mixing rule object
+
+    Example
+    -------
+    .. code-block:: python
+
+        from yaeos import PengRobinson78
+
+        tc = [190.56, 305.32]   # Critical temperatures [K]
+        pc = [45.99, 48.72]     # Critical pressures [bar]
+        w = [0.0115, 0.0985]    # Acentric factors
+
+        pr78 = PengRobinson78(tc, pc, w)
+    """
+
+    name = "PengRobinson78"
+
+    def __init__(
+        self,
+        critical_temperatures,
+        critical_pressures,
+        acentric_factors,
+        mixrule: CubicMixRule = None,
+    ) -> None:
+
+        super(PengRobinson78, self).__init__(
+            critical_temperatures,
+            critical_pressures,
+            acentric_factors,
+        )
+        self.id = yaeos_c.pr78(self.tc, self.pc, self.w)
+        self.mixrule = mixrule
+        if mixrule:
+            mixrule.set_mixrule(self.id)
+
+
+class SoaveRedlichKwong(CubicEoS):
+    """Soave-Redlich-Kwong cubic equation of state.
+
+    Parameters
+    ----------
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+    mixrule : CubicMixRule, optional
+        Mixing rule object. If no provided the quadratric mixing rule (QMR)
+        with zero for kij and lij parameters is set, by default None
+
+    Attributes
+    ----------
+    nc : int
+        Number of components
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+    id : int
+        EoS identifier
+    mixrule : CubicMixRule
+        Mixing rule object
+
+    Example
+    -------
+    .. code-block:: python
+
+        from yaeos import SoaveRedlichKwong
+
+        tc = [190.56, 305.32]   # Critical temperatures [K]
+        pc = [45.99, 48.72]     # Critical pressures [bar]
+        w = [0.0115, 0.0985]    # Acentric factors
+
+        srk = SoaveRedlichKwong(tc, pc, w)
+    """
+
+    name = "SoaveReldichKwong"
+
+    def __init__(
+        self,
+        critical_temperatures,
+        critical_pressures,
+        acentric_factors,
+        mixrule: CubicMixRule = None,
+    ) -> None:
+
+        super(SoaveRedlichKwong, self).__init__(
+            critical_temperatures,
+            critical_pressures,
+            acentric_factors,
+        )
+        self.id = yaeos_c.srk(self.tc, self.pc, self.w)
+        self.mixrule = mixrule
+        if mixrule:
+            mixrule.set_mixrule(self.id)
+
+
+class RKPR(CubicEoS):
+    """RKPR cubic equation of state.
+
+    Parameters
+    ----------
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+    critical_z : array_like
+        Critical compressibility factor vector
+    k : array_like, optional
+        k parameter, by default None
+    delta_1 : array_like, optional
+        delta_1 parameter, by default None
+    mixrule : CubicMixRule, optional
+        Mixing rule object. If no provided the quadratric mixing rule (QMR)
+        with zero for kij and lij parameters is set, by default None
+
+    Attributes
+    ----------
+    nc : int
+        Number of components
+    critical_temperatures : array_like
+        Critical temperatures vector [K]
+    critical_pressures : array_like
+        Critical pressures vector [bar]
+    acentric_factors : array_like
+        Acentric factors vector
+    zc : array_like
+        Critical compressibility factor vector
+    id : int
+        EoS identifier
+    mixrule : CubicMixRule
+        Mixing rule object
+
+    Example
+    -------
+    .. code-block:: python
+
+        from yaeos import RKPR
+
+        tc = [190.56, 305.32]   # Critical temperatures [K]
+        pc = [45.99, 48.72]     # Critical pressures [bar]
+        w = [0.0115, 0.0985]    # Acentric factors
+        zc = [0.27, 0.28]       # Critical compressibility factor
+
+        rkpr = RKPR(tc, pc, w, zc)
+    """
+
+    name = "RKPR"
+
+    def __init__(
+        self,
+        critical_temperatures,
+        critical_pressures,
+        acentric_factors,
+        critical_z,
+        k=None,
+        delta_1=None,
+        mixrule: CubicMixRule = None,
+    ) -> None:
+
+        super(RKPR, self).__init__(
+            critical_temperatures,
+            critical_pressures,
+            acentric_factors,
+        )
+        self.zc = critical_z
+
+        match (k is None, delta_1 is None):
+            case (True, True):
+                self.id = yaeos_c.rkpr(self.tc, self.pc, self.w, self.zc)
+            case (False, True):
+                self.id = yaeos_c.rkpr(self.tc, self.pc, self.w, self.zc, k=k)
+            case (True, False):
+                self.id = yaeos_c.rkpr(
+                    self.tc, self.pc, self.w, self.zc, delta_1=delta_1
+                )
+            case (False, False):
+                self.id = yaeos_c.rkpr(
+                    self.tc, self.pc, self.w, self.zc, k=k, delta_1=delta_1
+                )
+        self.mixrule = mixrule
+        if mixrule:
+            mixrule.set_mixrule(self.id)

yaeos/models/residual_helmholtz/cubic_eos/mixing_rules.py

@@ -0,0 +1,138 @@
+"""Cubic EoS mixing rules implementations module."""
+
+from abc import ABC, abstractmethod
+
+from yaeos.core import GeModel
+from yaeos.lib import yaeos_c
+
+
+class CubicMixRule(ABC):
+    """Cubic mix rule abstract class."""
+
+    @abstractmethod
+    def set_mixrule(self, ar_model_id: int) -> None:
+        """Set mix rule abstract method.
+
+        Changes the default mixing rule of the given cubic EoS model.
+
+        Parameters
+        ----------
+        ar_model_id : int
+            ID of the cubic EoS model
+
+        Raises
+        ------
+        NotImplementedError
+            Abstract error, this method must be implemented in the subclass
+        """
+        raise NotImplementedError
+
+
+class QMR(CubicMixRule):
+    """Quadratic mixing rule.
+
+    Parameters
+    ----------
+    kij : array_like
+        kij binary interaction parameters matrix
+    lij : array_like
+        lij binary interaction parameters matrix
+
+    Attributes
+    ----------
+    kij : array_like
+        kij binary interaction parameters matrix
+    lij : array_like
+        lij binary interaction parameters matrix
+
+    Example
+    -------
+    .. code-block:: python
+
+        from yaeos import QMR, SoaveRedlichKwong
+
+        kij = [[0.0, 0.1], [0.1, 0.0]]
+        lij = [[0.0, 0.02], [0.02, 0.0]]
+
+        mixrule = QMR(kij, lij)     # Quadratic mixing rule instance
+
+        tc = [305.32, 469.7]        # critical temperature [K]
+        pc = [48.72, 33.7]          # critical pressure [bar]
+        w = [0.0995, 0.152]         # acentric factor
+
+        model = SoaveRedlichKwong(tc, pc, w, mixrule)
+    """
+
+    def __init__(self, kij, lij) -> None:
+        self.kij = kij
+        self.lij = lij
+
+    def set_mixrule(self, ar_model_id: int) -> None:
+        """Set quadratic mix rule method.
+
+        Parameters
+        ----------
+        ar_model_id : int
+            ID of the cubic EoS model
+        """
+        yaeos_c.set_qmr(ar_model_id, self.kij, self.lij)
+
+
+class MHV(CubicMixRule):
+    """Modified Huron-Vidal mixing rule.
+
+    Parameters
+    ----------
+    ge : GeModel
+        Excess Gibbs energy model
+    q : float
+        q parameter. Use:
+            q = -0.594 for Soave-Redlich-Kwong
+            q = -0.53 for Peng-Robinson
+            q = -0.85 for Van der Waals
+    lij : array_like, optional
+        lij binary interaction parameters matrix, by default None
+
+    Attributes
+    ----------
+    ge : GeModel
+        Excess Gibbs energy model
+    q : float
+        q parameter
+    lij : array_like
+        lij binary interaction parameters matrix
+
+    Example
+    -------
+    .. code-block:: python
+
+        from yaeos import MHV, SoaveRedlichKwong, NRTL
+
+        tc = [647.14, 513.92]               # critical temperature [K]
+        pc = [220.64, 61.48]                # critical pressure [bar]
+        w =  [0.344, 0.649]                 # acentric factor
+
+        a = [[0, 3.458], [-0.801, 0]]       # NRTL aij parameters
+        b = [[0, -586.1], [246.2, 0]]       # NRTL bij parameters
+        c = [[0, 0.3], [0.3, 0]]            # NRTL cij parameters
+
+        ge_model = NRTL(a, b, c)
+        mixrule = MHV(ge_model, q=-0.53)
+
+        model_mhv = PengRobinson76(tc, pc, w, mixrule)
+    """
+
+    def __init__(self, ge: GeModel, q: float, lij=None) -> None:
+        self.ge = ge
+        self.q = q
+        self.lij = lij
+
+    def set_mixrule(self, ar_model_id: int) -> None:
+        """Set modified Huron-Vidal mix rule method.
+
+        Parameters
+        ----------
+        ar_model_id : int
+            ID of the cubic EoS model
+        """
+        yaeos_c.set_mhv(ar_model_id, self.ge.id, self.q)

yaeos-0.1.1.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: yaeos
+Version: 0.1.1
+Summary: Thermodynamic modelling with Equation of State
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# yaeos Python bindings
+THIS IS A WIP SO THE API WILL DRASTICALLY CHANGE WITH TIME
+
+Set of Python bindings to call `yaeos` functions and models.
+
+Editable installation
+
+```
+cd python
+pip install -r requirements-build.txt
+pip install -e . --no-build-isolation
+```
+
+If you want to install on your environment instead
+
+```shell
+pip install .
+```
+
+To check if the installation worked correctly:
+
+```python
+from yaeos import PengRobinson76
+
+import numpy as np
+
+model = PengRobinson76(np.array([320, 375]), np.array([30, 45]), np.array([0.0123, 0.045]), mr)
+
+model.lnphi_vt(np.array([5.0, 4.0]), 2.0, 303.15)
+```
+
+```
+{'ln_phi': array([0.47647471, 0.35338115]), 'dt': None, 'dp': None, 'dn': None}
+```

yaeos-0.1.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+yaeos.libs/liblapack-1ad85175.so.3.4.2,sha256=wrfEW65bG_XaXB2gB_JZR24uf8UxvWTrvVe6nIqfwu4,5682809
+yaeos.libs/libquadmath-96973f99.so.0.0.0,sha256=k0wi3tDn0WnE1GeIdslgUa3z2UVF2pYvYLQWWbB12js,247609
+yaeos.libs/libgfortran-91cc3cb1.so.3.0.0,sha256=VePrZzBsL_F-b4oIEOqg3LJulM2DkkxQZdUEDoeBRgg,1259665
+yaeos.libs/libgfortran-040039e1.so.5.0.0,sha256=FK-zEpsai1C8QKOwggx_EVLqm8EBIaqxUpQ_cFdHKIY,2686065
+yaeos.libs/libblas-357956a1.so.3.4.2,sha256=eLqolYX0nkk2PP64pkqa0Nif8hllaovrJMGbx8jU5W0,374265
+yaeos-0.1.1.dist-info/RECORD,,
+yaeos-0.1.1.dist-info/WHEEL,sha256=sZM_NeUMz2G4fDenMf11eikcCxcLaQWiYRmjwQBavQs,137
+yaeos-0.1.1.dist-info/METADATA,sha256=YVZPquTLIAItFG_32wy3SWcr_A7jsaq9OAJPLf9-esw,886
+yaeos/__init__.py,sha256=ZTMBNOaRmrcBEv6YLWyJdTKs0hX0VaMHP6_KGE4JI5I,578
+yaeos/core.py,sha256=Bp4Y9LBt8EAk6S8QaZJo0pRD7WAomfBygn0YxrxQBgg,16239
+yaeos/lib/__init__.py,sha256=JoG2sgKPrqe_TbvRI9bYXU0U_SF-GplchencGp9nNT0,199
+yaeos/lib/yaeos_python.cpython-310-x86_64-linux-gnu.so,sha256=mQ7z8vGGGh4AlbCC4JVb6Z8Mkd0CeX12s5iTubVMtdY,10195929
+yaeos/models/__init__.py,sha256=oH8vxuM-mMai2qeeaza0RK9KC3q-icGofg_I2t9ELaM,667
+yaeos/models/residual_helmholtz/__init__.py,sha256=OWgvPQlbfyF83UVxQih_9FeAJFBrhsDSc_BWfiYpqIA,573
+yaeos/models/residual_helmholtz/cubic_eos/mixing_rules.py,sha256=E8NFikKT8TxXDTUCSaKrX_IPFevUhVc4WXdMlGLQ5As,3600
+yaeos/models/residual_helmholtz/cubic_eos/cubic_eos.py,sha256=r0z48oIeBFGRN_E8f9Jt6-u100epzb_Y-UeTN_i1c-Y,9169
+yaeos/models/residual_helmholtz/cubic_eos/__init__.py,sha256=GM0qMwru74eSBXqVSuwxfFgK_NB3HWx9RM6ndlKRWpU,671
+yaeos/models/excess_gibbs/nrtl.py,sha256=U7uLp-SLdjO-By3FSiljO5apyk4AAhbbWKK7a0kKuLg,1023
+yaeos/models/excess_gibbs/__init__.py,sha256=sq1wetoEjgZB5iBZdECz-OB1bH9g0j9Ru7NuF_PaW8U,239

yaeos-0.1.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+