yaeos 3.1.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

yaeos/envelopes.py

@@ -0,0 +1,407 @@
+"""Envelopes.
+
+This module contains the classes that wrapp the data structures used to
+represent different kinds of phase envelopes.
+"""
+
+from IPython.display import display
+
+import matplotlib.pyplot as plt
+
+import numpy as np
+
+import pandas as pd
+
+
+class PTEnvelope:
+    """PTEnvelope.
+
+    This class represents a pressure-temperature envelope.
+    """
+
+    def __init__(
+        self,
+        global_composition,
+        main_phases_compositions,
+        reference_phase_compositions,
+        main_phases_molar_fractions,
+        pressures,
+        temperatures,
+        iterations,
+        specified_variable,
+    ):
+
+        msk = ~np.isnan(pressures)
+        self.number_of_components = len(global_composition)
+        self.number_of_phases = main_phases_compositions.shape[1]
+        self.global_composition = global_composition
+        self.main_phases_compositions = main_phases_compositions[msk, :, :]
+        self.reference_phase_compositions = reference_phase_compositions[
+            msk, :
+        ]
+        self.main_phases_molar_fractions = main_phases_molar_fractions[msk]
+        self.pressures = pressures[msk]
+        self.temperatures = temperatures[msk]
+        self.iterations = iterations[msk]
+        self.specified_variable = specified_variable[msk]
+
+        df = pd.DataFrame()
+
+        df["T"] = self.temperatures
+        df["P"] = self.pressures
+
+        for i in range(self.number_of_components):
+            for j in range(self.number_of_phases):
+                df[f"x_{i+1}^{j+1}"] = self.main_phases_compositions[:, j, i]
+            df[f"w_{i+1}"] = self.reference_phase_compositions[:, i]
+
+        for i in range(self.number_of_phases):
+            df[f"beta^{i+1}"] = self.main_phases_molar_fractions[:, i]
+
+        self.df = df
+
+        idx = []
+        for phase in range(self.number_of_phases):
+            cp_idx = []
+            lnK = np.log(
+                self.reference_phase_compositions
+                / self.main_phases_compositions[:, phase]
+            )
+
+            for i in range(1, len(lnK)):
+                if all(lnK[i, :] * lnK[i - 1, :] < 0):
+                    cp_idx.append(i)
+
+            idx.append(cp_idx)
+
+        self.cp = idx
+
+        # lnKs1 = np.log(c["w"][1:]/c["x_l"][1:, 1])
+        # lnKs0 = np.log(c["w"][1:]/c["x_l"][1:, 0])
+        # for i, lnK in enumerate(np.log(c["w"][1:]/c["x_l"][1:, 1])):
+        #     lnK2 = np.log(c["w"]/c["x_l"][i, 1])
+        #     crit = (lnK * lnK2 < 0).all()
+        #     if crit:
+        #         print("asd")
+
+    def __getitem__(self, key):
+        if "key" in self.__dict__:
+            return self.__dict__["key"]
+        elif isinstance(key, np.ndarray):
+            return PTEnvelope(
+                global_composition=self.global_composition,
+                main_phases_compositions=self.main_phases_compositions[key],
+                reference_phase_compositions=self.reference_phase_compositions[
+                    key
+                ],
+                main_phases_molar_fractions=self.main_phases_molar_fractions[
+                    key
+                ],
+                pressures=self.pressures[key],
+                temperatures=self.temperatures[key],
+                iterations=self.iterations[key],
+                specified_variable=self.specified_variable[key],
+            )
+        elif key == "T":
+            return self.temperatures
+        elif key == "Tc":
+            return self.temperatures[self.cp]
+        elif key == "Pc":
+            return self.pressures[self.cp]
+        elif key == "P":
+            return self.pressures
+        elif key == "z":
+            return self.global_composition
+        elif key == "x":
+            return self.main_phases_compositions
+        elif key == "w":
+            return self.reference_phase_compositions
+
+    def plot(self):
+        plt.plot(self.temperatures, self.pressures)
+        plt.xlabel("Temperature (K)")
+        plt.ylabel("Pressure [bar]")
+        plt.title("PT Envelope")
+        for cp in self.cp:
+            plt.scatter(
+                self.temperatures[cp], self.pressures[cp], color="black"
+            )
+
+    def __repr__(self):
+        display(self.df)
+        return ""
+
+    def __mul__(self, other):
+        return PTEnvelope(
+            global_composition=self.global_composition,
+            main_phases_compositions=self.main_phases_compositions * other,
+            reference_phase_compositions=self.reference_phase_compositions
+            * other,
+            main_phases_molar_fractions=self.main_phases_molar_fractions
+            * other,
+            pressures=self.pressures * other,
+            temperatures=self.temperatures * other,
+            iterations=self.iterations,
+            specified_variable=self.specified_variable,
+        )
+
+    def __len__(self):
+        return len(self.temperatures)
+
+
+class PXEnvelope:
+    """PXEnvelope.
+
+    This class represents a pressure-composition envelope.
+    """
+
+    def __init__(
+        self,
+        temperature,
+        global_composition_0,
+        global_composition_i,
+        main_phases_compositions,
+        reference_phase_compositions,
+        main_phases_molar_fractions,
+        pressures,
+        alphas,
+        iterations,
+        specified_variable,
+    ):
+
+        msk = ~np.isnan(pressures)
+        self.temperature = temperature
+        self.number_of_components = len(global_composition_0)
+        self.number_of_phases = main_phases_compositions.shape[1]
+        self.global_composition_0 = global_composition_0
+        self.global_composition_i = global_composition_i
+        self.main_phases_compositions = main_phases_compositions[msk, :, :]
+        self.reference_phase_compositions = reference_phase_compositions[
+            msk, :
+        ]
+        self.main_phases_molar_fractions = main_phases_molar_fractions[msk]
+        self.pressures = pressures[msk]
+        self.alphas = alphas[msk]
+        self.iterations = iterations[msk]
+        self.specified_variable = specified_variable[msk]
+
+        df = pd.DataFrame()
+
+        df["alpha"] = self.alphas
+        df["P"] = self.pressures
+
+        for i in range(self.number_of_components):
+            for j in range(self.number_of_phases):
+                df[f"x_{i+1}^{j+1}"] = self.main_phases_compositions[:, j, i]
+            df[f"w_{i+1}"] = self.reference_phase_compositions[:, i]
+
+        for i in range(self.number_of_phases):
+            df[f"beta^{i+1}"] = self.main_phases_molar_fractions[:, i]
+
+        self.df = df
+
+        idx = []
+        for phase in range(self.number_of_phases):
+            cp_idx = []
+            lnK = np.log(
+                self.reference_phase_compositions
+                / self.main_phases_compositions[:, phase]
+            )
+
+            for i in range(1, len(lnK)):
+                if all(lnK[i, :] * lnK[i - 1, :] < 0):
+                    cp_idx.append(i)
+
+            idx.append(cp_idx)
+
+        self.cp = idx
+
+        # lnKs1 = np.log(c["w"][1:]/c["x_l"][1:, 1])
+        # lnKs0 = np.log(c["w"][1:]/c["x_l"][1:, 0])
+        # for i, lnK in enumerate(np.log(c["w"][1:]/c["x_l"][1:, 1])):
+        #     lnK2 = np.log(c["w"]/c["x_l"][i, 1])
+        #     crit = (lnK * lnK2 < 0).all()
+        #     if crit:
+        #         print("asd")
+
+    def __getitem__(self, key):
+        if "key" in self.__dict__:
+            return self.__dict__["key"]
+        elif isinstance(key, np.ndarray):
+            return PXEnvelope(
+                global_composition_0=self.global_composition_0,
+                global_composition_i=self.global_composition_i,
+                temperature=self.temperature,
+                main_phases_compositions=self.main_phases_compositions[key],
+                reference_phase_compositions=self.reference_phase_compositions[
+                    key
+                ],
+                main_phases_molar_fractions=self.main_phases_molar_fractions[
+                    key
+                ],
+                pressures=self.pressures[key],
+                alphas=self.alphas[key],
+                iterations=self.iterations[key],
+                specified_variable=self.specified_variable[key],
+            )
+        elif key == "alpha" or key == "a":
+            return self.alphas
+        elif key == "P":
+            return self.pressures
+        elif key == "z":
+            return self.global_composition
+        elif key == "x":
+            return self.main_phases_compositions
+        elif key == "w":
+            return self.reference_phase_compositions
+
+    def __repr__(self):
+        return self.df.__repr__()
+
+    def __mul__(self, other):
+        return PXEnvelope(
+            global_composition_0=self.global_composition_0,
+            global_composition_i=self.global_composition_i,
+            temperature=self.temperature,
+            main_phases_compositions=self.main_phases_compositions * other,
+            reference_phase_compositions=self.reference_phase_compositions
+            * other,
+            main_phases_molar_fractions=self.main_phases_molar_fractions
+            * other,
+            pressures=self.pressures * other,
+            alphas=self.alphas * other,
+            iterations=self.iterations,
+            specified_variable=self.specified_variable,
+        )
+
+    def __len__(self):
+        return len(self.alphas)
+
+
+class TXEnvelope:
+    """TXEnvelope.
+
+    This class represents a pressure-composition envelope.
+    """
+
+    def __init__(
+        self,
+        pressure,
+        global_composition_0,
+        global_composition_i,
+        main_phases_compositions,
+        reference_phase_compositions,
+        main_phases_molar_fractions,
+        temperatures,
+        alphas,
+        iterations,
+        specified_variable,
+    ):
+
+        msk = ~np.isnan(temperatures)
+        self.temperature = pressure
+        self.number_of_components = len(global_composition_0)
+        self.number_of_phases = main_phases_compositions.shape[1]
+        self.global_composition_0 = global_composition_0
+        self.global_composition_i = global_composition_i
+        self.main_phases_compositions = main_phases_compositions[msk, :, :]
+        self.reference_phase_compositions = reference_phase_compositions[
+            msk, :
+        ]
+        self.main_phases_molar_fractions = main_phases_molar_fractions[msk]
+        self.temperatures = temperatures[msk]
+        self.alphas = alphas[msk]
+        self.iterations = iterations[msk]
+        self.specified_variable = specified_variable[msk]
+
+        df = pd.DataFrame()
+
+        df["alpha"] = self.alphas
+        df["T"] = self.temperatures
+
+        for i in range(self.number_of_components):
+            for j in range(self.number_of_phases):
+                df[f"x_{i+1}^{j+1}"] = self.main_phases_compositions[:, j, i]
+            df[f"w_{i+1}"] = self.reference_phase_compositions[:, i]
+
+        for i in range(self.number_of_phases):
+            df[f"beta^{i+1}"] = self.main_phases_molar_fractions[:, i]
+
+        self.df = df
+
+        idx = []
+        for phase in range(self.number_of_phases):
+            cp_idx = []
+            lnK = np.log(
+                self.reference_phase_compositions
+                / self.main_phases_compositions[:, phase]
+            )
+
+            for i in range(1, len(lnK)):
+                if all(lnK[i, :] * lnK[i - 1, :] < 0):
+                    cp_idx.append(i)
+
+            idx.append(cp_idx)
+
+        self.cp = idx
+
+        # lnKs1 = np.log(c["w"][1:]/c["x_l"][1:, 1])
+        # lnKs0 = np.log(c["w"][1:]/c["x_l"][1:, 0])
+        # for i, lnK in enumerate(np.log(c["w"][1:]/c["x_l"][1:, 1])):
+        #     lnK2 = np.log(c["w"]/c["x_l"][i, 1])
+        #     crit = (lnK * lnK2 < 0).all()
+        #     if crit:
+        #         print("asd")
+
+    def __getitem__(self, key):
+        if "key" in self.__dict__:
+            return self.__dict__["key"]
+        elif isinstance(key, np.ndarray):
+            return TXEnvelope(
+                global_composition_0=self.global_composition_0,
+                global_composition_i=self.global_composition_i,
+                pressure=self.pressure,
+                main_phases_compositions=self.main_phases_compositions[key],
+                reference_phase_compositions=self.reference_phase_compositions[
+                    key
+                ],
+                main_phases_molar_fractions=self.main_phases_molar_fractions[
+                    key
+                ],
+                temperatures=self.temperatures[key],
+                alphas=self.alphas[key],
+                iterations=self.iterations[key],
+                specified_variable=self.specified_variable[key],
+            )
+        elif key == "alpha" or key == "a":
+            return self.alphas
+        elif key == "T":
+            return self.temperatures
+        elif key == "z":
+            return self.global_composition
+        elif key == "x":
+            return self.main_phases_compositions
+        elif key == "w":
+            return self.reference_phase_compositions
+
+    def __repr__(self):
+        return self.df.__repr__()
+
+    def __mul__(self, other):
+        return TXEnvelope(
+            global_composition_0=self.global_composition_0,
+            global_composition_i=self.global_composition_i,
+            pressure=self.pressure,
+            main_phases_compositions=self.main_phases_compositions * other,
+            reference_phase_compositions=self.reference_phase_compositions
+            * other,
+            main_phases_molar_fractions=self.main_phases_molar_fractions
+            * other,
+            temperatures=self.temperature * other,
+            alphas=self.alphas * other,
+            iterations=self.iterations,
+            specified_variable=self.specified_variable,
+        )
+
+    def __len__(self):
+        return len(self.alphas)

yaeos/fitting/__init__.py

@@ -0,0 +1,12 @@
+"""yaeos fitting module.
+
+This module provides classes and functions for fitting binary interaction
+parameters to experimental data.
+"""
+
+from yaeos.fitting.core import BinaryFitter
+from yaeos.fitting.model_setters import fit_kij_lij
+from yaeos.fitting.solvers import solve_pt
+
+
+__all__ = ["BinaryFitter", "fit_kij_lij", "solve_pt"]

yaeos/fitting/core.py

@@ -0,0 +1,193 @@
+"""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
+        # ---------------------------------------------------------------------
+        cl = model.critical_line(
+            z0=[0, 1], zi=[1, 0], a0=1e-2, s=1e-2, ds0=1e-3, max_points=5000
+        )
+
+        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)
+        self.evaluations["cl"].append(cl)
+
+        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