cosmopharm 0.0.22__tar.gz → 0.0.23.1__tar.gz

{cosmopharm-0.0.22/src/cosmopharm.egg-info → cosmopharm-0.0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cosmopharm
-Version: 0.0.22
+Version: 0.0.23.1
 Summary: Predictive modeling for drug-polymer compatibility in pharmaceutical formulations using COSMO-SAC.
 Home-page: https://github.com/ivanantolo/cosmopharm,
 Author: Ivan Antolovic
@@ -38,13 +38,13 @@ Requires-Dist: matplotlib>=3.0; extra == "examples"
 
 # COSMOPharm
 
+Welcome to the COSMOPharm package, accompanying [our paper in *J. Chem. Theory Comput.*](https://dx.doi.org/10.1021/acs.jctc.9b01016). This project and its associated publication offer insights and a practical toolkit for researching drug-polymer and drug-solvent systems, aiming to provide the scientific community with the means to reproduce our findings and further the development of COSMO-SAC-based models.
+
 <p align="center">
   <!-- <img src="https://github.com/usnistgov/COSMOSAC/raw/master/JCTC2020.PNG" alt="TOC Figure" width="500"> -->
   <img src="https://github.com/usnistgov/COSMOSAC/raw/master/JCTC2020.PNG" alt="TOC Figure">
 </p>
 
-Welcome to the COSMOPharm package, accompanying [our paper in *J. Chem. Theory Comput.*](https://dx.doi.org/10.1021/acs.jctc.9b01016). This project and its associated publication offer insights and a practical toolkit for researching drug-polymer and drug-solvent systems, aiming to provide the scientific community with the means to reproduce our findings and further the development of COSMO-SAC-based models.
-
 ## About 
 
 COSMOPharm is a Python package designed for predictive modeling of drug-polymer compatibility and drug-solubility in common solvents. It leverages the COSMO-SAC (Conductor-like Screening Model Segment Activity Coefficient) model, offering a robust platform for solubility, miscibility, and phase behavior prediction in drug formulation processes.
@@ -62,7 +62,7 @@ Install COSMOPharm with pip:
 
 `pip install cosmopharm`
 
-Ensure you have installed the cCOSMO library as per instructions on the [COSMOSAC GitHub page](https://github.com/usnistgov/COSMOSAC).
+Ensure you have installed the `cCOSMO` library as per instructions on the [COSMOSAC GitHub page](https://github.com/usnistgov/COSMOSAC).
 
 ## Quick Start
 

{cosmopharm-0.0.22 → cosmopharm-0.0.23.1}/README.md

@@ -5,7 +5,7 @@
 </p>
 
 
-Welcome to the COSMOPharm repository, accompanying [our paper in *J. Chem. Theory Comput.*](https://dx.doi.org/10.1021/acs.jctc.9b01016). This project and its associated publication offer insights and a practical toolkit for researching drug-polymer and drug-solvent systems, aiming to provide the scientific community with the means to reproduce our findings and further the development of COSMO-SAC-based models.
+Welcome to the COSMOPharm repository, accompanying [our paper in *Molecular Pharmaceutics*](https://dx.doi.org/10.1021/acs.jctc.9b01016). This project and its associated publication offer insights and a practical toolkit for researching drug-polymer and drug-solvent systems, aiming to provide the scientific community with the means to reproduce our findings and further the development of COSMO-SAC-based models.
 
 ## About 
 
@@ -23,7 +23,7 @@ COSMOPharm is a Python package designed to streamline the predictive modeling of
 ### Quick Installation
 For most users, the quickest and easiest way to install COSMOPharm is via pip, which will manage all dependencies for you. Ensure you have already installed the `cCOSMO` library by following the instructions on the [COSMOSAC GitHub page](https://github.com/usnistgov/COSMOSAC).
 
-Once cCOSMO is installed, you can install COSMOPharm directly from [PyPI](https://pypi.org/project/cosmopharm/):
+Once `cCOSMO` is installed, you can install COSMOPharm directly from [PyPI](https://pypi.org/project/cosmopharm/):
 
 ```
 pip install cosmopharm
@@ -35,9 +35,9 @@ For users who need more control over the installation process (e.g., for develop
 
 #### Step 1: Clone the Repository
 
-First, clone the COSMOPharm repository:
+First, clone the COSMOPharm repository. The project includes a submodule named "pharmaceuticals" that stores essential data files (.sigma, .cosmo, and .xyz files) for the pharmaceutical components. Use the --recurse-submodules option to ensure that the "pharmaceuticals" submodule is correctly initialized and updated along with the main project.
 ```
-git clone https://github.com/ivanantolo/cosmopharm
+git clone --recurse-submodules https://github.com/ivanantolo/cosmopharm
 ```
 
 #### Step 2: Navigate to the Repository Directory
@@ -65,7 +65,7 @@ python setup.py install
 
 While this method is straightforward, using `pip` is generally preferred for its dependency management capabilities.
 
-Please note: Before proceeding with either advanced installation option, ensure the cCOSMO library is installed as described at the beginning of this section.
+Please note: Before proceeding with either advanced installation option, ensure the `cCOSMO` library is installed as described at the beginning of this section.
 
 ## Quick Start
 
@@ -73,22 +73,23 @@ Get started with COSMOPharm using the minimal example below, which demonstrates
 
 
 ```python
+import matplotlib.pyplot as plt
 import cCOSMO
 from cosmopharm import SLE, COSMOSAC
 from cosmopharm.utils import create_components, read_params
 
-# Define components - replace 'DrugName' and 'PolymerName' with your actual component names
-names = ['DrugName', 'PolymerName']
-params_file = "path/to/your/params.xlsx"
+# Define components
+names = ['SIM','PLGA50']
+params_file = "data/sle/table_params.xlsx"
 
 # Load parameters and create components
 parameters = read_params(params_file)
-components = create_components(names, parameters)
+mixture = create_components(names, parameters)
 
 # Initialize COSMO-SAC model - replace paths with your local paths to COSMO profiles
 db = cCOSMO.DelawareProfileDatabase(
-    "path/to/your/complist/complist.txt",
-    "path/to/your/profiles/")
+    "./profiles/_import_methods/UD/complist.txt",
+    "./profiles/_import_methods/UD/sigma3/")
 
 for name in names:
     iden = db.normalize_identifier(name)
@@ -96,16 +97,32 @@ for name in names:
 COSMO = cCOSMO.COSMO3(names, db)
 
 # Setup the COSMO-SAC model with components
-model = COSMOSAC(COSMO, components=components)
+actmodel = COSMOSAC(COSMO, mixture=mixture)
 
 # Calculate solubility (SLE)
-sle = SLE(solute=components[0], solvent=components[1], actmodel=model)
+sle = SLE(actmodel=actmodel)
 solubility = sle.solubility(mix='real')
 
 # Output the solubility
 print(solubility[['T', 'w', 'x']].to_string(index=False))
+
+# Plot results
+plt.plot(*solubility[['w','T']].values.T,'.-', label='Solubility (w)')
+
+# Settings
+plt.xlim(0,1)
+plt.ylim(300,500)
+# Adding title and labels
+plt.title('Solubility vs. Temperature')
+plt.ylabel("T / K")
+xlabel = {'w':'Weight', 'x':'Mole'}
+plt.xlabel(f"Weight fraction {mixture[0].name}")
+plt.legend()
+# Save the figure to a PNG or PDF file
+plt.savefig('solubility_plot.png')  # Saves the plot as a PNG file
+# plt.savefig('solubility_plot.pdf')  # Saves the plot as a PDF file
+plt.show()
 ```
-Replace 'DrugName', 'PolymerName', and file paths with your actual data and files.
 
 For a more comprehensive demonstration, including advanced functionalities and plotting results, please see the [example_usage.py](https://github.com/ivanantolo/cosmopharm/blob/main/example_usage.py) script in this repository. This detailed example walks through the process of setting up COSMOPharm, initializing models, and visualizing the results of solubility and miscibility calculations.
 
@@ -118,8 +135,23 @@ For bugs, feature requests, or other queries, please [open an issue](https://git
 
 ## Citation
 
-If you use COSMOPharm in your research, please consider citing it. You can find the citation format in [CITATION.md](https://github.com/ivanantolo/cosmopharm/CITATION.md).
-
+We appreciate citations to our work as they help acknowledge and spread our research contributions. If you use COSMOPharm in your research, please cite the associated paper. Citation details are provided in the [`CITATION.cff`](https://github.com/ivanantolo/cosmopharm/CITATION.cff) file, and GitHub generates APA or BibTeX formats accessible under the "Cite this repository" dropdown on our repository page.
+
+For convenience, here's the citation in BibTeX format:
+
+```bibtex
+@article{Antolovic2024COSMOPharm,
+  title={COSMOPharm: Drug--Polymer Compatibility of Pharmaceutical Amorphous Solid Dispersions from COSMO-SAC},
+  author={Antolovic, Ivan and Vrabec, Jadran and Klajmon, Martin},
+  journal={Molecular Pharmaceutics},
+  year={2024},
+  volume={1}, # Will be adjusted accordingly
+  issue={1}, # Will be adjusted accordingly
+  month={3}, # Will be adjusted accordingly
+  pages={1--10},  # Will be adjusted accordingly
+  doi={10.1021/acs.molpharmaceut.3c12345} # Will be adjusted accordingly
+}
+```
 
 ## License
 

{cosmopharm-0.0.22 → cosmopharm-0.0.23.1}/setup.cfg

@@ -1,12 +1,11 @@
 [metadata]
 name = cosmopharm
-version = 0.0.22
+version = 0.0.23.1
 author = Ivan Antolovic
 author_email = Ivan.Antolovic@tu-berlin.de
 maintainer = Martin Klajmon
 maintainer_email = Martin.Klajmon@vscht.cz
-description = 
-	Predictive modeling for drug-polymer compatibility in pharmaceutical formulations using COSMO-SAC.
+description = Predictive modeling for drug-polymer compatibility in pharmaceutical formulations using COSMO-SAC.
 keywords = Drug-Polymer Compatibility, Amorphous Solid Dispersions, Pharmaceutical Formulation, COSMO-SAC Model, Solubility Prediction, Miscibility Analysis, Phase Behavior Prediction, Pharmaceutical Sciences, Drug Formulation Research, Polymer Science, Predictive Modeling in Pharma, Drug Development Tools, Biopharmaceuticals
 url = https://github.com/ivanantolo/cosmopharm,
 license = MIT

cosmopharm-0.0.23.1/src/cosmopharm/actmodels/actmodel.py

@@ -0,0 +1,107 @@
+import numpy as np
+import numbers
+from numpy.typing import NDArray
+from typing import List, Literal
+
+from ..components import Component
+from ..utils.convert import convert
+
+class ActModel:
+
+    def __init__(self, components: List[Component]):
+        self.mixture = components
+
+    def lngamma(self, T, x):
+        raise NotImplementedError("lngamma() hasn't been implemented yet.")
+
+    def activity(self, T, x):
+        act = np.log(x) + self.lngamma(T, x)
+        act[(act == np.inf) | (act == -np.inf)] = np.nan
+        return act
+
+    def gmix(self, T, x):
+        is_scalar = np.isscalar(x)
+        # Convert input as needed
+        x = self._convert_input(x)
+        # Create mask to identify columns that don't contain 0 or 1
+        mask = np.any((x != 0) & (x != 1), axis=0)
+        # Apply the mask to filter x
+        _x = x[:, mask]
+        # Calculate gmix for the  x values
+        _gmix = _x * (np.log(_x) + self.lngamma(T, _x))
+        _gmix = np.sum(_gmix, axis=0)
+        # Initialize gmix array with zeros
+        gmix = np.zeros(1 if x.ndim==1 else x.shape[1])
+        # Fill gmix with calculated values where the mask is True
+        gmix[mask] = _gmix
+        return gmix[0] if is_scalar else gmix
+
+
+# =============================================================================
+# Wrapper functions (Decorators)
+# =============================================================================
+    @staticmethod
+    def vectorize(func):
+        ''' Intended vor ActModels where only single mole fractions can be
+        handled, like e.g. COSMO-SAC. This function vectorizes the lngamma()
+        to make it work with arrays of mole fractions.
+        '''
+        def wrapper(self, T, x):
+            # Convert input to appropriate format
+            x = self._convert_input(x)
+            # Process based on the dimensionality of x
+            if x.ndim == 1:
+                return func(self, T, x)
+            elif x.ndim == 2:
+                results = [func(self, T, x[:, col]) for col in range(x.shape[1])]
+                return np.array(results).T
+            else:
+                raise ValueError("Input must be either a scalar, 0D, 1D or 2D array")
+        return wrapper
+
+
+# =============================================================================
+# Auxilliary functions
+# =============================================================================
+    def _convert_input(self, x):
+        """Converts input to a 1-dim ndarray if it's a number or 0-dim ndarray."""
+        if isinstance(x, numbers.Number) or (isinstance(x, np.ndarray) and x.ndim == 0):
+            return np.array([float(x), 1 - float(x)])
+        elif isinstance(x, np.ndarray) and x.ndim == 1 and len(x) != len(self.mixture):
+            return np.array([x, 1 - x])
+        return x
+
+    def _convert(self, 
+                 x : NDArray[np.float64], 
+                 to : Literal['weight', 'mole'] ='weight'
+                 ) -> NDArray[np.float64]:
+        """
+        Convert the fraction of a binary mixture between mole fraction and weight fraction.
+
+        This method is designed for internal use with binary mixtures, where the mixture is defined by two components. 
+        It uses the 'convert' function to perform the conversion by creating an array with the fractions of both 
+        components and the molecular weights from the mixture's attributes.
+
+        Parameters:
+            x (NDArray[np.float64]): The mole or weight fraction of the first component of the mixture. 
+                                    If converting 'to' weight, 'x' represents mole fractions; if converting 'to' mole, 
+                                    'x' represents weight fractions. This should be a single value or a 1D array of values.
+            to (Literal['weight', 'mole'], optional): The target type for the conversion. Defaults to 'weight'.
+                                                    Use 'weight' to convert mole fractions to weight fractions,
+                                                    and 'mole' to convert weight fractions to mole fractions.
+
+        Returns:
+            NDArray[np.float64]: The converted fraction(s) of the first component in the same shape as 'x'.
+                                If 'x' is a single value, the return will be a single converted value;
+                                if 'x' is a 1D array, the return will be a 1D array of converted values.
+
+        Example:
+            >>> mixture = Mixture(components=[component1, component2], Mw=np.array([18.01528, 46.06844]))
+            >>> sle = SLE(mix=mixture)
+            >>> x_mole_fraction = np.array([0.4])  # Mole fraction of the first component
+            >>> x_weight_fraction = sle._convert(x_mole_fraction, to='weight')
+            >>> print(x_weight_fraction)
+            array([0.01373165])
+        """
+        Mw = np.array([c.Mw for c in self.mixture])
+        return convert(x=np.array([x, 1-x], dtype=np.float64), Mw=Mw, to=to)[0]

cosmopharm-0.0.23.1/src/cosmopharm/actmodels/cosmo.py

@@ -0,0 +1,154 @@
+
+import numpy as np
+import cCOSMO
+
+from typing import List, Union, Literal
+from .actmodel import ActModel
+from ..components import Component
+
+
+class COSMOSAC(ActModel):
+    # Handling invalid values for free volume calculation
+    class InvalidFreeVolumeParametersException(Exception):
+        pass
+
+    def __init__(self,
+                 COSMO: Union[cCOSMO.COSMO1, cCOSMO.COSMO3],
+                 mixture: List[Component],
+                 combinatorial: Union[Literal['sg', 'fv'], bool] = 'sg',
+                 dispersion: bool = False,
+                 ) -> None:
+        self.COSMO = COSMO
+        self.mixture = mixture
+        # Flexible assignment of 'get_lngamma_comb' and 'get_lngamma_dsp'
+        # that changes dynamically if the values for 'combinatorial' or
+        # 'dispersion' are changed after initialization of an instance.
+        self._combinatorial = combinatorial
+        self._dispersion = dispersion
+
+    @ActModel.vectorize
+    def lngamma(self, T, x):
+        resid = self.get_lngamma_resid(T, x)
+        comb  = self.get_lngamma_comb(x)
+        disp  = self.get_lngamma_disp(x)
+        lngamma = resid + comb + disp
+        return lngamma
+
+    def get_lngamma_fv(self, x):
+        """
+        Calculates the free-volume term of the activity coefficient for a mixture.
+
+        This implementation uses a formula to avoid numerical instability when
+        `x_i` approaches zero, which is important in asymmetric API-polymer
+        mixtures. The formula used is:
+
+        ```
+        phi_i^FV / x_i = v_i^F / sum_j(x_j * v_j^F)
+        ```
+
+        where
+        - `phi_i^FV` is the free-volume fraction of component `i`,
+        - `x_i` is the mole fraction of component `i`,
+        - `v_i^F` is the free volume of component `i`,
+        and the summation is over all components `j` in the mixture.
+
+        Parameters
+        ----------
+        x : array_like
+            Mole fractions of the components in the mixture.
+
+        Returns
+        -------
+        np.ndarray
+            Logarithm of the free-volume term of the activity coefficient.
+
+        Note:
+        Free-volume term of the activity coefficient according to Elbro et al.
+        (can replace ln_gamma_comb of normal COSMO-SAC) - Kuo2013
+        x, v_298, v_hc are 1D arrays (number of elements = number of components)
+        """
+        # TODO: Make sure, that v_298 and v_hc are provided, else "FV" not possible
+        self.validate_free_volume_parameters()  # Ensure components are valid before proceeding
+        v_298 = np.array([comp.v_298 for comp in self.mixture])
+        v_hc = np.array([comp.v_hc for comp in self.mixture])
+        vf = v_298-v_hc
+        sum_vf = np.sum(x*vf)
+        phix = vf/sum_vf
+        return np.log(phix) + 1 - phix
+
+    def get_lngamma_sg(self, x):
+        return self.COSMO.get_lngamma_comb(0, x)
+
+    def get_lngamma_resid(self, T, x):
+        return self.COSMO.get_lngamma_resid(T, x)
+
+    def get_lngamma_comb(self, x):
+        if self._combinatorial is False:
+            return np.zeros(len(x))
+        elif self._combinatorial.lower() == 'sg':
+            return self.get_lngamma_sg(x)
+        elif self._combinatorial.lower() == 'fv':
+            return self.get_lngamma_fv(x)
+
+    def get_lngamma_disp(self, x):
+        if self._dispersion:
+            return self.COSMO.get_lngamma_disp(x)
+        else:
+            return np.zeros(len(x))
+
+    @property
+    def dispersion(self):
+        return self._dispersion
+
+    @dispersion.setter
+    def dispersion(self, value):
+        self._dispersion = value
+
+    @property
+    def combinatorial(self):
+        return self._combinatorial
+
+    @combinatorial.setter
+    def combinatorial(self, value: Union[str, bool]):
+        is_valid_string = isinstance(value, str) and value.lower() in ('sg', 'fv')
+        is_False = value is False
+        if is_valid_string or is_False:
+            self._combinatorial = value
+        else:
+            msg = "Invalid value for combinatorial term. Please choose 'sg', 'fv', or set to False."
+            raise ValueError(msg)
+
+# =============================================================================
+# Auxilliary functions
+# =============================================================================
+    def configuration(self,
+                      comb: Union[Literal['sg', 'fv'], bool] = 'sg',
+                      dsp: bool = False, **kwargs
+                      ):
+        """ Convenience function to quickly configure COSMO parameters """
+        self._combinatorial = comb
+        self._dispersion = dsp
+
+
+    def validate_free_volume_parameters(self):
+        # List of parameters to validate
+        parameters_to_check = ["v_298", "v_hc"]
+
+        for comp in self.mixture:
+            invalid_params = []  # List to accumulate names of invalid parameters for this component
+            for param in parameters_to_check:
+                value = getattr(comp, param, None)
+                # Check if value is None, not a number (np.nan), less than or equal to 0
+                if value is None or np.isnan(value) or value <= 0:
+                    invalid_params.append((param, value))  # Append parameter name and value tuple
+
+            # Check if any errors were found for this component
+            if invalid_params:
+                # If errors were found, construct the warning message
+                error_message = f"Invalid FV parameters for component {comp}: {invalid_params}"
+                raise self.InvalidFreeVolumeParametersException(error_message)
+
+            # Additionally check if v_298 and v_hc are equal
+            if comp.v_298 == comp.v_hc:
+                msg = f"v_298 and v_hc are equal for component {comp}: v_298={comp.v_298}, v_hc={comp.v_hc}"
+                raise self.InvalidFreeVolumeParametersException(msg)

{cosmopharm-0.0.22 → cosmopharm-0.0.23.1}/src/cosmopharm/components.py

@@ -2,12 +2,13 @@ from typing import Optional
 from numbers import Number
 
 class Component:
-    def __init__(self, name: Optional[str] = None,
-                 Mw: Optional[Number] = None,
-                 T_fus: Optional[Number] = None,
-                 H_fus: Optional[Number] = None,
-                 Cp_fus_a_fit: Optional[Number] = None,
-                 Cp_fus_bT_fit: Optional[Number] = None,
+    def __init__(self,
+                 name: Optional[str] = None,
+                 Mw: Optional[Number] = None,  # Positive number expected
+                 T_fus: Optional[Number] = None,  # Positive number expected
+                 H_fus: Number = 0,
+                 Cp_fus_a_fit: Number = 0,
+                 Cp_fus_bT_fit: Number = 0,
                  v_298: Optional[Number] = None,
                  v_hc: Optional[Number] = None,
                  ):

cosmopharm-0.0.23.1/src/cosmopharm/equilibrium/lle.py

@@ -0,0 +1,126 @@
+import numpy as np
+import pandas as pd
+from scipy.optimize import least_squares, root
+from typing import Union, Optional, Type, List
+
+from ..components import Component
+from ..actmodels import ActModel
+from ..utils.spacing import spacing
+from ..utils.lle_scanner import estimate_lle_from_gmix
+
+
+class LLE:
+    def __init__(self,
+                 actmodel: Union[ActModel, Type[ActModel]],
+                 mixture: Optional[List[Component]] = None) -> None:
+        self.actmodel = actmodel
+        self.mixture = mixture
+        self._validate_arguments()
+
+    def fobj_binodal(self, x1, T):
+        # Equilibrium: Isoactivity criterion (aL1 - aL2 = 0)
+        x = np.array([x1, 1-x1])
+        activity = self.actmodel.activity(T, x)
+        equilibrium = np.diff(activity, axis=1)
+        return equilibrium.ravel() # reshape from (2,1) --> (2,)
+
+    def fobj_spinodal(self, x1):
+        T = 0
+        x = np.array([x1, 1-x1])
+        return self.actmodel.thermofac(T, x)
+
+    def binodal(self, T, x0=None, solver='least_squares'):
+        if x0 is None:
+            x0 = [0.1, 0.999]    # 1_N2_Ethan
+
+        if solver == 'least_squares':
+            kwargs = dict(bounds=(0,1), ftol=1e-15, xtol=1e-15)
+            res = least_squares(self.fobj_binodal, x0, args=(T,), **kwargs)
+            # print(res.nfev)
+            return res.x, res.nfev
+        else:
+            kwargs = dict(method='krylov', options={'maxiter': 5})
+            res = root(self.fobj_binodal, x0, args=(T,), **kwargs)
+            # print(res.nit)
+            return res.x, 30
+
+    def spinodal(self, x0=None):
+        if x0 is None:
+            x0 = self.binodal()
+        return least_squares(self.fobj_spinodal, x0).x
+
+# =============================================================================
+# TODO: (1) Add some "approx_initial_values" function based on gmix
+# TODO: (2) Overall improve this code to match the SLE code
+# =============================================================================
+    def approx_init_x0(self, T):
+        x1 = spacing(0,1,51,'poly',n=3)
+        gmix = self.actmodel.gmix(T, x1)
+        xL, xR, yL, yR = estimate_lle_from_gmix(x1, gmix, rough=True)
+        return xL, xR
+
+    def solve_lle(self, T, x0, solver='least_squares', info=True):
+        binodal_x, nfev = self.binodal(T, x0, solver)
+        binodal_w = self.actmodel._convert(binodal_x)
+        formatted_w_binodal = [f"wL{i+1}={value:.4f}" for i, value in enumerate(binodal_w)]
+        formatted_x_binodal = [f"xL{i+1}={value:.6f}" for i, value in enumerate(binodal_x)]
+        msg = ('LLE: ', f"{T=:.2f}", *formatted_w_binodal, *formatted_x_binodal)
+        if info:
+            print(*msg)
+            return binodal_x, binodal_w, nfev
+        return binodal_x, binodal_w, nfev, msg
+
+    def miscibility(self, T, x0=None, max_gap=0.1, max_T=500, dT=25, exponent=2):
+        """ Calculate miscibility """
+        print()
+        print("Calculating LLE...")
+        res = []
+
+        if x0 is None:
+            print("...searching for suitable initial value...")
+            x0 = self.approx_init_x0(T)
+        binodal_x, binodal_w, nfev, msg = self.solve_lle(T, x0, info=False)
+
+        # Check if initial guess is reasonalble - otherwise increase T
+        while binodal_x[0] < x0[0] and T <= max_T:
+            print('LLE: ', f"{T=:.2f}", "...no feasbible initial value found.")
+            T += 10  # Increase T by 10
+            x0 = self.approx_init_x0(T)
+            binodal_x, binodal_w, nfev, msg = self.solve_lle(T, x0, info=False)
+        print("Suitable initial value found! Proceed with calculating LLE...")
+        print(*msg)
+        gap = np.diff(binodal_w)[0]
+        res.append((T, *binodal_w, *binodal_x))
+
+        while gap > max_gap and T <= max_T:
+            solver = 'least_squares' if nfev <= 30 else 'root'
+            solver = 'least_squares'
+            # print(solver)
+            T += dT * gap**exponent
+            x0 = binodal_x
+            binodal_x, binodal_w, nfev = self.solve_lle(T, x0, solver)
+            gap = np.diff(binodal_w)[0]
+            res.append((T, *binodal_w, *binodal_x))
+
+        columns = ['T', 'wL1', 'wL2', 'xL1', 'xL2']
+        res = pd.DataFrame(res, columns=columns)
+        return res
+
+# =============================================================================
+# AUXILLIARY FUNCTIONS
+# =============================================================================
+    def _validate_arguments(self):
+        """Validate the arguments for the LLE class."""
+        # TODO: Insert case where both actmodel and mixture are provided (check if acmodel.mixture == mixture, if not raise warning)
+        if isinstance(self.actmodel, ActModel):
+            # If actmodel is an instance of ActModel
+            self.mixture: List[Component] = self.mixture or self.actmodel.mixture
+        elif isinstance(self.actmodel, type) and issubclass(self.actmodel, ActModel):
+            # If actmodel is a class (subclass of ActModel)
+            if self.mixture is None:
+                raise ValueError("Please provide a valid mixture:Mixture.")
+            self.actmodel: ActModel = self.actmodel(self.mixture)
+        else:
+            # If actmodel is neither an instance nor a subclass of ActModel
+            err = "'actmodel' must be an instance or a subclass of 'ActModel'"
+            raise ValueError(err)

{cosmopharm-0.0.22 → cosmopharm-0.0.23.1}/src/cosmopharm/equilibrium/sle.py

@@ -1,72 +1,95 @@
-import pandas as pd
 import numpy as np
+import pandas as pd
 from scipy.optimize import fsolve, root
-from typing import Literal
+from numpy.typing import NDArray
+from typing import Literal, Optional, Type, Union, List, Tuple, Generator, Dict
 
 from ..components import Component
+from ..actmodels import ActModel
 from ..utils.spacing import spacing
 
+NumericOrFrame = Union[float, List[float], Tuple[float, ...], NDArray[np.float64], pd.DataFrame]
+
 class SLE:
-    def __init__(self, solute, solvent, actmodel):
-        self.mix = [solute, solvent]
-        self.model = actmodel
-        self.solute, self.solvent = solute, solvent
+    def __init__(self,
+                 actmodel: Union[ActModel, Type[ActModel]],
+                 mixture: Optional[List[Component]] = None) -> None:
+        self.actmodel = actmodel
+        self.mixture = mixture
+        self._validate_arguments()
+        # Assign 'solute' and 'solvent' based on order in 'mixture'
+        # Default assignment can be changed in e.g. 'solubility()'
+        self.solute, self.solvent = self.mixture
 
     def solubility(self,
-                   solute: Component = None, solvent: Component = None,
-                   args=None, init=None, data=None,
+                   solute: Optional[Component] = None,
+                   solvent: Optional[Component] = None,
                    vary: Literal['T', 'w', 'auto'] = 'auto',
-                   mix: Literal['ideal', 'real'] = 'real',
+                   mix_type: Literal['ideal', 'real'] = 'real',
+                   args: Optional[NumericOrFrame] = None,
+                   init: Optional[NumericOrFrame] = None,
                    solver: Literal['root', 'fsolve'] = 'root',
-                   show_progress=False):
+                   show_progress=False, **kwargs):
         ''' Calculate solubility curve of solute in solvent.'''
         self.solute = solute or self.solute
         self.solvent = solvent or self.solvent
-        self.vary, self.mix_type = vary, mix
+        self.vary, self.mix_type = vary, mix_type
         self.show_progress = show_progress
+        self.config = getattr(self.actmodel, 'config', self.mix_type)
         if self.vary == 'auto':
             gen = self.auto_solve(solver)
         else:
             self._vary = self.vary
-            if args is None or init is None:
-                args, init = self.initialize(init=init, data=data)
+            args = self.set_args(args)
+            init = self.set_x0(init)
             gen = self.solve_sle(args, init, solver)
-        res = [k for k in gen]
-        res = pd.DataFrame(res, columns=['T', 'x', 'vary', 'w'])
-        res = res[['T', 'w', 'x', 'vary']]
-        return res
+        try:
+            res = [k for k in gen]
+            res = pd.DataFrame(res, columns=['T', 'x', 'vary', 'w'])
+            res = res[['T', 'w', 'x', 'vary']]
+            return res
+        except self.actmodel.InvalidFreeVolumeParametersException as e:
+            print(f"Warning: {e}")  # Inform the user
+            return pd.DataFrame(columns=['T', 'w', 'x', 'vary'])
 
 
 # =============================================================================
 # MATHEMATICS
 # =============================================================================
-    def solve_sle(self, args, init, solver='root'):
-        is_iterable = hasattr(init, "__len__") and len(init) > 1
+    def solve_sle(self, args: NDArray[np.float64], init: NDArray[np.float64],
+                  solver: Literal['root', 'fsolve'] = 'root'
+                  ) -> Generator[Dict[str, Union[float, str]], None, None]:
+        # Check compatibility of the "init" values
+        is_iterable = init.size > 1
+        if is_iterable and not init.size == args.size:
+            msg = 'The length of "init" must be the same as "args".'
+            raise ValueError(msg)
+        x0 = init
+        # Setup solver and handle pure component case
         key, lock = ['T', 'x'] if self._vary == 'T' else ['x', 'T']
         solve = self.set_solver(solver=solver)
-        x0 = init
         args, pure_component = self._handle_pure_component(args)
         if pure_component: # no need to calculate pure component
             yield pure_component
-
         for i, arg in enumerate(args):
             x0 = init[i] if is_iterable else x0
             out = float(solve(x0, arg))
             x0 = out if not is_iterable else x0
             res = {key: arg, lock: out, 'vary': self._vary}
-            res['w'] = self.model._convert(res['x'])[0]
+            res['w'] = self.actmodel._convert(res['x'])[0]
             text = (f"T={res['T']:.2f}", f"w={res['w']:.4f}", f"x={res['x']:.4f}")
             if self.show_progress:
-                print(f'SLE ({self.mix_type}): ', *text)
+                print(f'SLE ({self.config}): ', *text)
             yield res
 
     def auto_solve(self, solver: Literal['root', 'fsolve'] = 'root'):
         if self.show_progress:
             print()
-            print(f"Calculating SLE ({self.mix_type})...")
+            print(f"Calculating SLE ({self.config})...")
         # Start with varying 'w' until dTdw > THRESHOLD
         self._vary = 'w'
-        args, x0 = self.initialize()
+        args = self.set_args()
+        x0 = self.set_x0()
         gen = self.solve_sle(args, x0, solver)
         previous = None
         for i, current in enumerate(gen):
@@ -77,10 +100,7 @@ class SLE:
         # Switch to varying 'T'
         self._vary = 'T'
         T0, x0 = current['T'], current['x']
-        # # (Deprecated): If last dT>5, make the next dT=5 (from old version)
-        # T1 = previous['T']; dT = T0 - T1
-        # T0 += dT if abs(dT) < 5 else np.sign(dT) * 5
-        args = self.set_args(xmax=T0)[1:]  # exclude initial point (redundant)
+        args = self.set_args(xmax=T0)[1:]  # exclude initial point
         gen = self.solve_sle(args, x0)
         yield from gen
 
@@ -92,7 +112,7 @@ class SLE:
         return np.exp(-self.gibbs_fusion(T))
 
     def real_mix(self, T, x):
-        lngamma = self.model.lngamma(T, x)[0]
+        lngamma = self.actmodel.lngamma(T, x)[0]
         return np.log(x) + lngamma + self.gibbs_fusion(T)
 
     # Gibbs energy of fusion, i.e., the right-hand side of the solubility equation:
@@ -115,12 +135,12 @@ class SLE:
 # =============================================================================
 # HELPER FUNCTIONS
 # =============================================================================
-    def initialize(self, xmin=None, xmax=None, dx=None, data=None, init=None):
-        args = self.set_args(xmin, xmax, dx, data)
-        x0 = self.set_x0(init)
-        return args, x0
-
-    def set_args(self, xmin=None, xmax=None, dx=None, data=None):
+    def set_args(self,
+                 args: Optional[NumericOrFrame] = None,
+                 xmin: Optional[float] = None,
+                 xmax: Optional[float] = None,
+                 dx: Optional[float] = None
+                 ) -> NDArray[np.float64]:
         vary = self._vary
         # Determine argument values based on input data or generate
         # them based on range and type
@@ -132,7 +152,7 @@ class SLE:
         ma = defaults[vary]['max'] if xmax is None else xmax
         dx = defaults[vary]['step'] if dx is None else dx
 
-        if data is None:
+        if args is None:
             if self.vary != 'auto':  # auto_vary == False
                 args = np.arange(ma, mi-dx, -dx)
                 args[-1] = np.maximum(args[-1], mi)
@@ -145,17 +165,18 @@ class SLE:
             else:  # vary == 'w'
                 num = 16 if self.mix_type == 'ideal' else 21
                 args = spacing(ma, mi, num, 'quadratic')
-        else:
-            args = data
-        return args if vary != 'w' else self.model._convert(args, to='mole')
+        args = np.asarray(args)
+        args = args if vary != 'w' else self.actmodel._convert(args, to='mole')
+        return args
 
-    def set_x0(self, init=None):
+    def set_x0(self, init: Optional[NumericOrFrame] = None) -> NDArray[np.float64]:
         vary = self._vary
         # Set up initial values based on the type of variable ('T' or 'w')
         if vary == 'T':
-            x0 = 1. if init is None else self.model._convert(init, to='mole')
+            x0 = 1. if init is None else self.actmodel._convert(init, to='mole')
         else:  # vary == 'w'
             x0 = self.solute.T_fus if init is None else init
+        x0 = np.asarray(x0)
         return x0
 
     def set_solver(self, solver: Literal['root', 'fsolve'] = 'root'):
@@ -205,3 +226,19 @@ class SLE:
             args = args[args != 1]
             return args, res
         return args, None
+
+    def _validate_arguments(self):
+        """Validate the arguments for the SLE class."""
+        # TODO: Insert case where both actmodel and mixture are provided (check if acmodel.mixture == mixture, if not raise warning)
+        if isinstance(self.actmodel, ActModel):
+            # If actmodel is an instance of ActModel
+            self.mixture: List[Component] = self.mixture or self.actmodel.mixture
+        elif isinstance(self.actmodel, type) and issubclass(self.actmodel, ActModel):
+            # If actmodel is a class (subclass of ActModel)
+            if self.mixture is None:
+                raise ValueError("Please provide a valid mixture:Mixture.")
+            self.actmodel: ActModel = self.actmodel(self.mixture)
+        else:
+            # If actmodel is neither an instance nor a subclass of ActModel
+            err = "'actmodel' must be an instance or a subclass of 'ActModel'"
+            raise ValueError(err)

{cosmopharm-0.0.22 → cosmopharm-0.0.23.1}/src/cosmopharm/utils/helpers.py

@@ -21,8 +21,8 @@ def add_parameters(c, params):
     c.Mw = params['Mw']  # g/mol
     c.T_fus = params['T_fus'] if params['T_fus'] > 0 else np.nan  # K
     c.H_fus = params['H_fus'] * KILOJOULE_TO_JOULE  # J/mol
-    c.Cp_fus_A = params['Cp_fus_a_fit']  # J/(mol K)
-    c.Cp_fus_BT = params['Cp_fus_bT_fit']  # J/(mol K²)
+    c.Cp_fus_A = np.nan_to_num(params['Cp_fus_a_fit'])  # J/(mol K)
+    c.Cp_fus_BT = np.nan_to_num(params['Cp_fus_bT_fit'])  # J/(mol K²)
     c.v_298 = params['v298']  # cm³/mol
     c.v_hc = params['v_hc']  # cm³/mol
 

{cosmopharm-0.0.22 → cosmopharm-0.0.23.1/src/cosmopharm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cosmopharm
-Version: 0.0.22
+Version: 0.0.23.1
 Summary: Predictive modeling for drug-polymer compatibility in pharmaceutical formulations using COSMO-SAC.
 Home-page: https://github.com/ivanantolo/cosmopharm,
 Author: Ivan Antolovic
@@ -38,13 +38,13 @@ Requires-Dist: matplotlib>=3.0; extra == "examples"
 
 # COSMOPharm
 
+Welcome to the COSMOPharm package, accompanying [our paper in *J. Chem. Theory Comput.*](https://dx.doi.org/10.1021/acs.jctc.9b01016). This project and its associated publication offer insights and a practical toolkit for researching drug-polymer and drug-solvent systems, aiming to provide the scientific community with the means to reproduce our findings and further the development of COSMO-SAC-based models.
+
 <p align="center">
   <!-- <img src="https://github.com/usnistgov/COSMOSAC/raw/master/JCTC2020.PNG" alt="TOC Figure" width="500"> -->
   <img src="https://github.com/usnistgov/COSMOSAC/raw/master/JCTC2020.PNG" alt="TOC Figure">
 </p>
 
-Welcome to the COSMOPharm package, accompanying [our paper in *J. Chem. Theory Comput.*](https://dx.doi.org/10.1021/acs.jctc.9b01016). This project and its associated publication offer insights and a practical toolkit for researching drug-polymer and drug-solvent systems, aiming to provide the scientific community with the means to reproduce our findings and further the development of COSMO-SAC-based models.
-
 ## About 
 
 COSMOPharm is a Python package designed for predictive modeling of drug-polymer compatibility and drug-solubility in common solvents. It leverages the COSMO-SAC (Conductor-like Screening Model Segment Activity Coefficient) model, offering a robust platform for solubility, miscibility, and phase behavior prediction in drug formulation processes.
@@ -62,7 +62,7 @@ Install COSMOPharm with pip:
 
 `pip install cosmopharm`
 
-Ensure you have installed the cCOSMO library as per instructions on the [COSMOSAC GitHub page](https://github.com/usnistgov/COSMOSAC).
+Ensure you have installed the `cCOSMO` library as per instructions on the [COSMOSAC GitHub page](https://github.com/usnistgov/COSMOSAC).
 
 ## Quick Start
 

cosmopharm-0.0.22/src/cosmopharm/actmodels/actmodel.py

@@ -1,83 +0,0 @@
-import numpy as np
-import numbers
-
-from ..utils.convert import convert
-
-class ActModel:
-
-    def __init__(self, components: list = []):
-        self.mix = components
-
-    def lngamma(self, T, x):
-        pass
-
-    def dlngamma(self, T, x):
-        # Only binary case
-        def f(x1):
-            x = np.array([x1, 1-x1])
-            return self.lngamma(T, x)#[0]
-        h, x = 0.0001, x[0]
-        dy = (f(x+h)-f(x-h))/(2*h)
-        # Revert direction of dy2_dx2 --> dy2_dx1
-        dy[1] = dy[1][::-1]
-        return f(x), dy
-
-    def activity(self, T, x):
-        act = np.log(x) + self.lngamma(T, x)
-        act[(act == np.inf) | (act == -np.inf)] = np.nan
-        return act
-
-    def gmix(self, T, x):
-        # Convert input as needed
-        x = self._convert_input(x)
-        # Create mask to identify columns that don't contain 0 or 1
-        mask = np.any((x != 0) & (x != 1), axis=0)
-        # Apply the mask to filter x
-        _x = x[:, mask]
-        # Calculate gmix for the  x values
-        _gmix = _x * (np.log(_x) + self.lngamma(T, _x))
-        _gmix = np.sum(_gmix, axis=0)
-        # Initialize gmix array with zeros
-        gmix = np.zeros(x.shape[1])
-        # Fill gmix with calculated values where the mask is True
-        gmix[mask] = _gmix
-        return gmix
-
-
-# =============================================================================
-# Wrapper functions (Decorators)
-# =============================================================================
-    @staticmethod
-    def vectorize(func):
-        ''' Intended vor ActModels where only single mole fractions can be
-        handled, like e.g. COSMO-SAC. This function vectorizes the lngamma()
-        to make it work with arrays of mole fractions.
-        '''
-        def wrapper(self, T, x):
-            # Convert input to appropriate format
-            x = self._convert_input(x)
-            # Process based on the dimensionality of x
-            if x.ndim == 1:
-                return func(self, T, x)
-            elif x.ndim == 2:
-                results = [func(self, T, x[:, col]) for col in range(x.shape[1])]
-                return np.array(results).T
-            else:
-                raise ValueError("Input must be either a scalar, 0D, 1D or 2D array")
-        return wrapper
-
-
-# =============================================================================
-# Auxilliary functions
-# =============================================================================
-    def _convert_input(self, x):
-        """Converts input to a 1-dim ndarray if it's a number or 0-dim ndarray."""
-        if isinstance(x, numbers.Number) or (isinstance(x, np.ndarray) and x.ndim == 0):
-            return np.array([float(x), 1 - float(x)])
-        elif isinstance(x, np.ndarray) and x.ndim == 1 and len(x) != len(self.mix):
-            return np.array([x, 1 - x])
-        return x
-
-    def _convert(self, x, to='weight'):
-        Mw = np.array([c.Mw for c in self.mix])
-        return convert(x=np.array([x, 1-x]), Mw=Mw, to=to)[0]

cosmopharm-0.0.22/src/cosmopharm/actmodels/cosmo.py

@@ -1,106 +0,0 @@
-import numpy as np
-from .actmodel import ActModel
-
-class COSMOSAC(ActModel):
-    def __init__(self, COSMO, components: list, free_volume=False,
-                 dispersion=False, combinatorial=True):
-        self.COSMO = COSMO
-        self.mix = components
-        # Flexible assignment of 'get_lngamma_comb' and 'get_lngamma_dsp'
-        # that changes dynamically if the values for 'free_volume', 'dispersion'
-        # or "combinatorial" are changed after initialization of an instance.
-        self._free_volume = free_volume
-        self._dispersion = dispersion
-        self._combinatorial = combinatorial
-
-    @ActModel.vectorize
-    def lngamma(self, T, x):
-        resid = self.get_lngamma_resid(T, x)
-        comb  = self.get_lngamma_comb(x)
-        disp  = self.get_lngamma_disp(x)
-        lngamma = resid + comb + disp
-        return lngamma
-
-    def get_lngamma_fv(self, x):
-        """
-        Calculates the free-volume term of the activity coefficient for a mixture.
-
-        This implementation uses a formula to avoid numerical instability when
-        `x_i` approaches zero, which is important in asymmetric API-polymer
-        mixtures. The formula used is:
-
-        ```
-        phi_i^FV / x_i = v_i^F / sum_j(x_j * v_j^F)
-        ```
-
-        where
-        - `phi_i^FV` is the free-volume fraction of component `i`,
-        - `x_i` is the mole fraction of component `i`,
-        - `v_i^F` is the free volume of component `i`,
-        and the summation is over all components `j` in the mixture.
-
-        Parameters
-        ----------
-        x : array_like
-            Mole fractions of the components in the mixture.
-
-        Returns
-        -------
-        np.ndarray
-            Logarithm of the free-volume term of the activity coefficient.
-
-        Note:
-        Free-volume term of the activity coefficient according to Elbro et al.
-        (can replace ln_gamma_comb of normal COSMO-SAC) - Kuo2013
-        x, v_298, v_hc are 1D arrays (number of elements = number of components)
-        """
-        v_298 = np.array([c.v_298 for c in self.mix])
-        v_hc = np.array([c.v_hc for c in self.mix])
-        vf = v_298-v_hc
-        sum_vf = np.sum(x*vf)
-        phix = vf/sum_vf
-        return np.log(phix) + 1 - phix
-
-    def get_lngamma_sg(self, x):
-        return self.COSMO.get_lngamma_comb(0, x)
-
-    def get_lngamma_resid(self, T, x):
-        return self.COSMO.get_lngamma_resid(T, x)
-
-    def get_lngamma_comb(self, x):
-        if not self._combinatorial:
-            return np.zeros(len(x))
-        elif self._free_volume:
-            return self.get_lngamma_fv(x)
-        else:
-            return self.get_lngamma_sg(x)
-
-    def get_lngamma_disp(self, x):
-        if self._dispersion:
-            return self.COSMO.get_lngamma_disp(x)
-        else:
-            return np.zeros(len(x))
-
-    @property
-    def free_volume(self):
-        return self._free_volume
-
-    @free_volume.setter
-    def free_volume(self, value):
-        self._free_volume = value
-
-    @property
-    def dispersion(self):
-        return self._dispersion
-
-    @dispersion.setter
-    def dispersion(self, value):
-        self._dispersion = value
-
-    @property
-    def combinatorial(self):
-        return self._combinatorial
-
-    @combinatorial.setter
-    def combinatorial(self, value):
-        self._combinatorial = value

cosmopharm-0.0.22/src/cosmopharm/equilibrium/lle.py

@@ -1,89 +0,0 @@
-import numpy as np
-import pandas as pd
-from scipy.optimize import least_squares
-
-from ..utils import spacing
-from ..utils.lle_scanner import estimate_lle_from_gmix
-
-
-class LLE:
-    def __init__(self, actmodel):
-        self.mix = actmodel.mix
-        self.model  = actmodel
-
-    def fobj_binodal(self, x1, T):
-        # Equilibrium: Isoactivity criterion (aL1 - aL2 = 0)
-        x = np.array([x1, 1-x1])
-        activity = self.model.activity(T, x)
-        equilibrium = np.diff(activity, axis=1)
-        return equilibrium.ravel() # reshape from (2,1) --> (2,)
-
-    def fobj_spinodal(self, x1):
-        T = 0
-        x = np.array([x1, 1-x1])
-        return self.model.thermofac(T, x)
-
-    def binodal(self, T, x0=None):
-        if x0 is None:
-            x0 = [0.1, 0.999]    # 1_N2_Ethan
-        kwargs = dict(bounds=(0,1), ftol=1e-15, xtol=1e-15)
-        res = least_squares(self.fobj_binodal, x0, args=(T,), **kwargs)
-        return res.x
-
-    def spinodal(self, x0=None):
-        if x0 is None:
-            x0 = self.binodal()
-        return least_squares(self.fobj_spinodal, x0).x
-
-# =============================================================================
-#
-# =============================================================================
-    def approx_init_x0(self, T):
-        x1 = spacing(0,1,51,'poly',n=3)
-        gmix = self.model.gmix(T, x1)
-        xL, xR, yL, yR = estimate_lle_from_gmix(x1, gmix, rough=True)
-        return xL, xR
-
-    def solve_lle(self, T, x0, info=True):
-        binodal_x = self.binodal(T, x0)
-        binodal_w = self.model._convert(binodal_x)
-        formatted_w_binodal = [f"wL{i+1}={value:.4f}" for i, value in enumerate(binodal_w)]
-        formatted_x_binodal = [f"xL{i+1}={value:.6f}" for i, value in enumerate(binodal_x)]
-        msg = ('LLE: ', f"{T=:.2f}", *formatted_w_binodal, *formatted_x_binodal)
-        if info:
-            print(*msg)
-            return binodal_x, binodal_w
-        return binodal_x, binodal_w, msg
-
-    def miscibility(self, T, x0=None, max_gap=0.1, max_T=500, dT=25):
-        print()
-        print("Calculating LLE...")
-        res = []
-
-        if x0 is None:
-            print("...searching for suitable initial value...")
-            x0 = self.approx_init_x0(T)
-        binodal_x, binodal_w, msg = self.solve_lle(T, x0, info=False)
-
-        # Check if initial guess is reasonalble - otherwise increase T
-        while binodal_x[0] < x0[0] and T <= max_T:
-            print('LLE: ', f"{T=:.2f}", "...no feasbible initial value found.")
-            T += 10  # Increase T by 10
-            x0 = self.approx_init_x0(T)
-            binodal_x, binodal_w, msg = self.solve_lle(T, x0, info=False)
-        print("Suitable initial value found! Proceed with calculating LLE...")
-        print(*msg)
-        gap = np.diff(binodal_w)[0]
-        res.append((T, *binodal_w, *binodal_x))
-
-        exponent = 2.1
-        while gap > max_gap and T <= max_T:
-            T += dT * gap**exponent
-            x0 = binodal_x
-            binodal_x, binodal_w = self.solve_lle(T, x0)
-            gap = np.diff(binodal_w)[0]
-            res.append((T, *binodal_w, *binodal_x))
-
-        columns = ['T', 'wL1', 'wL2', 'xL1', 'xL2']
-        res = pd.DataFrame(res, columns=columns)
-        return res