cosmopharm 0.0.24__tar.gz → 0.0.25__tar.gz

{cosmopharm-0.0.24/src/cosmopharm.egg-info → cosmopharm-0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cosmopharm
-Version: 0.0.24
+Version: 0.0.25
 Summary: Predictive modeling for drug-polymer compatibility in pharmaceutical formulations using COSMO-SAC.
 Home-page: https://github.com/ivanantolo/cosmopharm,
 Author: Ivan Antolovic

{cosmopharm-0.0.24 → cosmopharm-0.0.25}/README.md

@@ -153,6 +153,21 @@ For convenience, here's the citation in BibTeX format:
 }
 ```
 
+### Gaussian Citation
+**Permission from Gaussian, Inc.** was obtained to make the [.cosmo files](https://github.com/ivanantolo/cosmopharm/tree/main/profiles/polymers/cosmo) for the oligomers included in [our paper in *Molecular Pharmaceutics*](https://dx.doi.org/10.1021/acs.jctc.9b01016) available for academic and research (noncommercial) use. This is to enhance research transparency and facilitate the validation process.
+
+When using COSMOPharm with the sigma-profiles provided therein, please also cite Gaussian as follows:
+
+```bibtex
+@misc{g16,
+author={M. J. Frisch and G. W. Trucks and H. B. Schlegel and G. E. Scuseria and M. A. Robb and J. R. Cheeseman and G. Scalmani and V. Barone and G. A. Petersson and H. Nakatsuji and X. Li and M. Caricato and A. V. Marenich and J. Bloino and B. G. Janesko and R. Gomperts and B. Mennucci and H. P. Hratchian and J. V. Ortiz and A. F. Izmaylov and J. L. Sonnenberg and D. Williams-Young and F. Ding and F. Lipparini and F. Egidi and J. Goings and B. Peng and A. Petrone and T. Henderson and D. Ranasinghe and V. G. Zakrzewski and J. Gao and N. Rega and G. Zheng and W. Liang and M. Hada and M. Ehara and K. Toyota and R. Fukuda and J. Hasegawa and M. Ishida and T. Nakajima and Y. Honda and O. Kitao and H. Nakai and T. Vreven and K. Throssell and Montgomery, {Jr.}, J. A. and J. E. Peralta and F. Ogliaro and M. J. Bearpark and J. J. Heyd and E. N. Brothers and K. N. Kudin and V. N. Staroverov and T. A. Keith and R. Kobayashi and J. Normand and K. Raghavachari and A. P. Rendell and J. C. Burant and S. S. Iyengar and J. Tomasi and M. Cossi and J. M. Millam and M. Klene and C. Adamo and R. Cammi and J. W. Ochterski and R. L. Martin and K. Morokuma and O. Farkas and J. B. Foresman and D. J. Fox},
+title={Gaussian˜16 {R}evision {C}.01},
+year={2016},
+note={Gaussian Inc. Wallingford CT}
+} 
+```
+
 ## License
 
-COSMOPharm is released under the MIT License. See the [LICENSE](https://github.com/ivanantolo/cosmopharm/LICENSE) file for more details.
+COSMOPharm is released under the MIT License. See the [LICENSE](https://github.com/ivanantolo/cosmopharm/LICENSE) file for more details.
+

{cosmopharm-0.0.24 → cosmopharm-0.0.25}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = cosmopharm
-version = 0.0.24
+version = 0.0.25
 author = Ivan Antolovic
 author_email = Ivan.Antolovic@tu-berlin.de
 maintainer = Martin Klajmon

{cosmopharm-0.0.24 → cosmopharm-0.0.25}/src/cosmopharm/actmodels/actmodel.py

@@ -35,6 +35,17 @@ class ActModel:
         # Fill gmix with calculated values where the mask is True
         gmix[mask] = _gmix
         return gmix[0] if is_scalar else gmix
+    
+    def thermofac(self, T, x):
+        """ Approximate thermodynamic factor
+        Simple derivative form, when no analytical equation is available. 
+        """
+        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)
+        return 1 + x * dy
 
 
 # =============================================================================

{cosmopharm-0.0.24 → cosmopharm-0.0.25}/src/cosmopharm/actmodels/cosmo.py

@@ -1,4 +1,3 @@
-
 import numpy as np
 import cCOSMO
 
@@ -6,9 +5,9 @@ from typing import List, Union, Literal
 from .actmodel import ActModel
 from ..components import Component
 
-
 class COSMOSAC(ActModel):
-    # Handling invalid values for free volume calculation
+
+    # Handle invalid values for free volume calculation
     class InvalidFreeVolumeParametersException(Exception):
         pass
 
@@ -67,7 +66,6 @@ class COSMOSAC(ActModel):
         (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])

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

@@ -0,0 +1,178 @@
+import numpy as np
+import pandas as pd
+from scipy.optimize import least_squares, root
+from typing import Union, Optional, Type, List, Dict
+
+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 miscibility(self,
+                    T: float,
+                    x0: np.ndarray = None,
+                    x0_type: str = 'mole',
+                    max_gap: float = 0.1,
+                    max_gap_type: str = 'mole',
+                    max_T: float = 1000,
+                    dT: float = 10,
+                    exponent: float = 1
+                    ) -> pd.DataFrame:
+        """ Calculate miscibility """
+        self.config = getattr(self.actmodel, 'config', '')
+        Mw = np.array([c.Mw for c in self.mixture])
+        self.is_valid_Mw = self.is_valid_numpy_array(Mw)
+        res = {'binodal':[], 'spinodal':[]}
+        var = 'x' if max_gap_type == 'mole' else 'w'
+        print()
+        print("Calculating LLE...")
+
+        # Define column names
+        binodal_columns = ['T', 'xL1', 'xL2']
+        if self.is_valid_Mw:
+            binodal_columns += ['wL1', 'wL2']
+
+        # Check for valid molar masses
+        if x0_type == 'weight':
+            if self.is_valid_Mw:
+                x0 = self.convert_to_mole_fractions(x0, self.mixture.Mw)
+            else:
+                raise ValueError("Molar masses are not available for conversion from weight to mole fraction.")
+# =============================================================================
+# TODO: Implement all edge cases (no LLE, bad approximation, ....)
+# TODO: Improve code structure
+        # Approximate initial value for LLE
+        if x0 is None:
+            print("...searching for suitable initial value...")
+            x0 = self.approx_init_x0(T)
+
+            if any(x is None for x in x0):
+                print("...no initial value at T0 was found. Try another T0.")
+                return pd.DataFrame(columns=binodal_columns)
+
+            # Check if initial guess is reasonable - otherwise increase T
+            # TODO: Check whether it might be an LCST if isLower
+            binodal = self.solve_lle(T, x0, show_output=False)
+            isEqual = np.diff(binodal['x'])[0] < 1e-8 # check if both phases have equal composition
+            if isEqual:
+                print("...no initial value at T0 was found. Try another T0.")
+                return pd.DataFrame(columns=binodal_columns)
+            isLower = min(binodal['x']) < min(x0) # lower bound below min(x0)
+            while isLower 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 = self.solve_lle(T, x0, show_output=False)
+            print("Suitable initial value found! Proceed with calculating LLE...")
+# =============================================================================
+        # First iteration step
+        binodal = self.solve_lle(T, x0)
+        gap = np.diff(binodal[var])[0]
+        res['binodal'].append((T, *[val for vals in binodal.values() for val in vals]))
+
+        # Subsequent iteration steps
+        while gap > max_gap and T <= max_T:
+            T += dT * gap**exponent
+            x0 = binodal['x']
+            binodal = self.solve_lle(T, x0)
+            gap = np.diff(binodal[var])[0]
+            res['binodal'].append((T, *[val for vals in binodal.values() for val in vals]))
+
+        # Convert lists to DataFrames
+        res = pd.DataFrame(res['binodal'], columns=binodal_columns)
+        return res
+
+# =============================================================================
+# MATHEMATICS
+# =============================================================================
+
+    def solve_lle(self, T: float, x0: np.ndarray, show_output=True) -> Dict[str, np.ndarray]:
+        """ Solve for liquid-liquid equilibrium (LLE) at a given temperature and initial composition. """
+        binodal = {'x': self.binodal(T, x0)}
+        output = [f"{k}={v:.4f}" for k,v in zip(['xL1', 'xL2'], binodal['x'])]
+
+        if self.is_valid_Mw:
+            binodal['w'] = self.actmodel._convert(binodal['x'])
+            output += [f"{k}={v:.4f}" for k,v in zip(['wL1', 'wL2'], binodal['w'])]
+
+        if show_output:
+            prefix = f'LLE ({self.config})' if self.config else 'LLE'
+            print(f'{prefix}: ', f"{T=:.2f}", *output)
+        return binodal
+
+
+
+
+# =============================================================================
+# THERMODYNAMICS
+# =============================================================================
+    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):
+        if x0 is None:
+            x0 = [0.1, 0.999]
+        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, T, x0=None):
+        if x0 is None:
+            x0 = self.binodal(T, x0)
+        kwargs = dict(bounds=(0,1), ftol=1e-15, xtol=1e-15)
+        res = least_squares(self.fobj_spinodal, x0, args=(T,), **kwargs)
+        return res.x
+
+
+# =============================================================================
+# AUXILLIARY FUNCTIONS
+# =============================================================================
+    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 _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)
+
+    def is_valid_numpy_array(self, arr: np.ndarray) -> bool:
+        """Check if a numpy array contains only numbers and no None values."""
+        if not isinstance(arr, np.ndarray):
+            return False
+        if arr.dtype == object:  # Check if the array contains objects (which could include None)
+            return not np.any(arr == None)
+        else:
+            return np.issubdtype(arr.dtype, np.number)

{cosmopharm-0.0.24 → cosmopharm-0.0.25}/src/cosmopharm/equilibrium/sle.py

@@ -77,7 +77,7 @@ class SLE:
             x0 = out if not is_iterable else x0
             res = {key: arg, lock: out, 'vary': self._vary}
             res['w'] = self.actmodel._convert(res['x'])[0]
-            text = (f"T={res['T']:.2f}", f"w={res['w']:.4f}", f"x={res['x']:.4f}")
+            text = (f"T={res['T']:.2f}", f"x={res['x']:.4f}", f"w={res['w']:.4f}")
             if self.show_progress:
                 print(f'SLE ({self.config}): ', *text)
             yield res

{cosmopharm-0.0.24 → cosmopharm-0.0.25/src/cosmopharm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cosmopharm
-Version: 0.0.24
+Version: 0.0.25
 Summary: Predictive modeling for drug-polymer compatibility in pharmaceutical formulations using COSMO-SAC.
 Home-page: https://github.com/ivanantolo/cosmopharm,
 Author: Ivan Antolovic

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

@@ -1,126 +0,0 @@
-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)