DiadFit 0.0.84__tar.gz → 0.0.88__tar.gz

{DiadFit-0.0.84 → DiadFit-0.0.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: DiadFit
-Version: 0.0.84
+Version: 0.0.88
 Summary: DiadFit
 Home-page: https://github.com/PennyWieser/DiadFit
 Author: Penny Wieser

{DiadFit-0.0.84 → DiadFit-0.0.88}/setup.py

@@ -27,8 +27,10 @@ setup(
 
     package_data={
         # Include all pickle files
-        "": ["*.pkl"],
+        "": ["*.pkl", "*.csv"],
     },
+
+
     install_requires=[
             'pandas',
             'numpy<2',

{DiadFit-0.0.84 → DiadFit-0.0.88}/src/DiadFit/CO2_EOS.py

@@ -829,7 +829,7 @@ def calculate_SP19942(T_K, target_pressure_MPa):
         target_p=np.array(target_pressure_MPa)
         Density=calculate_Density_Sterner_Pitzer_1994(T_K=T_K, target_pressure_MPa=target_p)
     else:
-        Density=np.empty(len(target_pressure_MPa))
+        Density=np.zeros(len(target_pressure_MPa))
         for i in range(0, len(target_pressure_MPa)):
             Density[i]=calculate_Density_Sterner_Pitzer_1994(T_K=T_K, target_pressure_MPa=target_pressure_MPa[i])
     return Density
@@ -860,7 +860,7 @@ def calculate_SP1994_Temp(CO2_dens_gcm3, target_pressure_MPa):
         target_p=np.array(target_pressure_MPa)
         Density=calculate_Temp_Sterner_Pitzer_1994(CO2_dens_gcm3=CO2_dens_gcm3, target_pressure_MPa=target_p)
     else:
-        Density=np.empty(len(target_pressure_MPa))
+        Density=np.zeros(len(target_pressure_MPa))
         for i in range(0, len(target_pressure_MPa)):
             Density[i]=calculate_Temp_Sterner_Pitzer_1994(CO2_dens_gcm3=CO2_dens_gcm3, target_pressure_MPa=target_pressure_MPa[i])
     return Density

{DiadFit-0.0.84 → DiadFit-0.0.88}/src/DiadFit/CO2_H2O_EOS.py

@@ -102,45 +102,7 @@ aH2[13] = -4.13039220 / 10**1  # alpha for CO2
 aH2[14] = -8.47988634  # beta for CO2
 aH2[15] = 2.800 / 10**2  # gamma for CO2
 
-## This is for when you only feed a numpy array
-# def ensure_series(a, b, c):
-#     # Determine the target length
-#     lengths = [len(a) if isinstance(a, pd.Series) else None,
-#                len(b) if isinstance(b, pd.Series) else None,
-#                len(c) if isinstance(c, pd.Series) else None]
-#     lengths = [l for l in lengths if l is not None]
-#     target_length = max(lengths) if lengths else 1
-#
-#     # Convert each input to a Series of the target length
-#     if not isinstance(a, pd.Series):
-#         a = pd.Series([a] * target_length)
-#     if not isinstance(b, pd.Series):
-#         b = pd.Series([b] * target_length)
-#     if not isinstance(c, pd.Series):
-#         c = pd.Series([c] * target_length)
-#
-#     return a, b, c
-#
-#
-# def ensure_series_4(a, b, c, d):
-#     # Determine the target length
-#     lengths = [len(a) if isinstance(a, pd.Series) else None,
-#                len(b) if isinstance(b, pd.Series) else None,
-#                len(c) if isinstance(c, pd.Series) else None,
-#                len(d) if isinstance(d, pd.Series) else None]
-#     lengths = [l for l in lengths if l is not None]
-#     target_length = max(lengths) if lengths else 1
-#
-#     # Convert each input to a Series of the target length
-#     if not isinstance(a, pd.Series):
-#         a = pd.Series([a] * target_length)
-#     if not isinstance(b, pd.Series):
-#         b = pd.Series([b] * target_length)
-#     if not isinstance(c, pd.Series):
-#         c = pd.Series([c] * target_length)
-#     if not isinstance(d, pd.Series):
-#         d = pd.Series([d] * target_length)
-#     return a, b, c, d
+
 
 import pandas as pd
 import numpy as np
@@ -257,7 +219,7 @@ def pureEOS_CF(i, V, P, B, C, D, E, F, Vc, TK, b, g):
 
 # Volume iterative function using Netwon-Raphson method.
 def purevolume(i, V, P, B, C, D, E, F, Vc, TK, b, g):
-    """ Using the pure EOS, this function solves for the best volume using the pureEOS residual calculated above
+    """ Using the pure EOS, this function solves for the best molar volume (in cm3/mol) using the pureEOS residual calculated above
 
     It returns the volume.
 
@@ -280,9 +242,9 @@ def purevolume(i, V, P, B, C, D, E, F, Vc, TK, b, g):
     return V
 
 def purepressure(i, V, P, TK):
-    """ Using the pure EOS, this function solves for the best pressure using the pureEOS residual calculated above
+    """ Using the pure EOS, this function solves for the best pressure (in bars) using the pureEOS residual calculated above
 
-    It returns the pressure.
+    It returns the pressure in bars
 
     """
     for iter in range(1, 51):
@@ -294,6 +256,10 @@ def purepressure(i, V, P, TK):
         # Update the pressure using the Newton-Raphson method
         Pnew = P - pureEOS(i, V, P, B, C, D, E, F, Vc, TK, b, g) / diff
 
+        # Dont allow negative solutions
+        if Pnew < 0:
+            Pnew = 30000
+
         # Check if the update is within the tolerance (0.000001)
         if abs(Pnew - P) <= 0.000001:
             break
@@ -308,13 +274,13 @@ def purepressure(i, V, P, TK):
 
 
 def mol_vol_to_density(mol_vol, XH2O):
-    """ Converts molar mass to molar density for a given XH2O"""
+    """ Converts molar volume (cm3/mol) to density (g/cm3) for a given XH2O"""
     density=((1-XH2O)*44 + (XH2O)*18)/mol_vol
     return density
 
 def pure_lnphi(i, Z, B, Vc, V, C, D, E, F, g, b):
     """
-    This function calculates the fugacity coefficient from the equation of state for a pure fluid
+    This function calculates the fugacity coefficient (kbar) from the equation of state for a pure fluid
 
     """
     lnph = Z[i] - 1.0 - math.log(Z[i]) + (B[i] * Vc[i] / V[i]) + (C[i] * Vc[i] * Vc[i] / (2.0 * V[i] * V[i]))
@@ -358,7 +324,7 @@ def mixEOS_CF(V, P, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK):
 
 
 def mixvolume(V, P, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK):
-    """ This function iterates in volume space to get the best match to the entered pressure using the mixEOS function above.
+    """ This function iterates in volume space to get the best match volume (cm3/mol) to the entered pressure using the mixEOS function above.
 
     """
     for iter in range(1, 51):
@@ -371,10 +337,61 @@ def mixvolume(V, P, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK):
 
     return V
 
+import warnings as w
+
+## We are going to have to use a look up table to help the netwon raphson converge.
+
+# Load the lookup table from the CSV file
+DiadFit_dir=Path(__file__).parent
+file_str='lookup_table_noneg.csv'
+dz06_lookuptable=pd.read_csv(DiadFit_dir/file_str)
+#df = pd.read_csv('lookup_table_noneg.csv')
+
+
+
+
+
+def get_initial_guess(V_target, T_K_target, XH2O_target):
+    # Calculate the Euclidean distance from the target point to all points in the table
+    # We normalize each dimension by its range to give equal weight to all parameters
+
+
+    df=dz06_lookuptable
+
+    # code to find best value
+
+    P_range = df['P_kbar'].max() - df['P_kbar'].min()
+    T_K_range = df['T_K'].max() - df['T_K'].min()
+    XH2O_range = df['XH2O'].max() - df['XH2O'].min()
+    V_range = df['V'].max() - df['V'].min()
+
+    # Calculate normalized distances
+    distances = np.sqrt(
+        ((df['P_kbar'] - df['P_kbar'].mean()) / P_range) ** 2 +
+        ((df['T_K'] - T_K_target) / T_K_range) ** 2 +
+        ((df['XH2O'] - XH2O_target) / XH2O_range) ** 2 +
+        ((df['V'] - V_target) / V_range) ** 2
+    )
+
+    # Find the index of the closest row in the DataFrame
+    closest_index = distances.argmin()
+
+    # Retrieve the P_kbar value from the closest row
+    initial_guess_P = df.iloc[closest_index]['P_kbar']
+
+
+
+    return initial_guess_P
+
+
+
+
 def mixpressure(P, V, TK, Y):
-    """ This function iterates in pressure space to get the best match to the entered volume using the mixEOS function above.
+    """ This function iterates in pressure space to get the best match in bars to the entered volume in cm3/mol using the mixEOS function above.
 
     """
+
+
     for iter in range(1, 51):
         k1_temperature, k2_temperature, k3_temperature, a1, a2, g, b, Vc, B, C, D, E, F, Vguess=get_EOS_params(P, TK)
         Bij, Vcij, BVc_prm, BVc, Cijk, Vcijk, CVc2_prm, CVc2, Dijklm, Vcijklm, DVc4_prm, DVc4, Eijklmn, Vcijklmn, EVc5_prm,  EVc5, Fij, FVc2_prm, FVc2, bmix, b_prm, gijk, gVc2_prm, gVc2=mixing_rules(B, C,D, E, F, Vc, Y, b,    g, k1_temperature, k2_temperature, k3_temperature)
@@ -382,15 +399,63 @@ def mixpressure(P, V, TK, Y):
         diff = ((mixEOS(V, P + 0.0001, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK)
         - mixEOS(V, P, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK)) / 0.0001)
         Pnew = P - mixEOS(V, P, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK) / diff
+
+
+
+
         if abs(Pnew - P) <= 0.000001:
             break
+
         P = Pnew
 
     return P
 
+        # # Dont allow negative solutions
+        # if Pnew<0:
+        #     Pnew = 3000
+
+        # if Pnew < 10000 and Pnew>0 and V<50:
+        #     w.warn('Sometimes the adapted Newton Raphson method will find a second root at lower (or negative pressure). This initially found a root at P=' + str(np.round(Pnew, 2)) + ', V=' + str(np.round(V)) + '. The algorithm has started its search again at P=3000 bars. Double check your results make sense')
+        #
+        #     Pnew = 10000  # Replace 0.0001 with a small positive value that makes sense for your system
+        #
+
+
+# def mixpressure(P_init, V, TK, Y, max_restarts=3):
+#     """This function iterates in pressure space to get the best match to the entered volume using the mixEOS function above."""
+#
+#     restarts = 0
+#     while restarts <= max_restarts:
+#         P = P_init
+#         for iter in range(1, 51):
+#             # Your EOS parameters and mixing rules calculations here
+#
+#             diff = ((mixEOS(V, P + 0.0001, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK) - mixEOS(V, P, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK)) / 0.0001)
+#             Pnew = P - mixEOS(V, P, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, TK) / diff
+#
+#             # Don't allow unrealistic solutions but provide a chance to reset
+#             if Pnew < 5000 and V > 10:
+#                 warnings.warn('Root forced above 5000 bars due to conditions, attempting restart...')
+#                 Pnew = 5000  # Force the pressure up due to your condition
+#                 break  # Break out of the current iteration loop to allow for a restart
+#
+#             if abs(Pnew - P) <= 0.000001:  # Convergence criterion
+#                 return Pnew  # Return the converged value
+#             P = Pnew
+#
+#         restarts += 1  # Increment the number of restarts attempted
+#         P_init = 5000  # Set a new starting point that might be closer to the suspected real root
+#
+#     warnings.warn('Max restarts reached, solution may not be optimal.')
+#     return P  # Return the last computed pressure if all restart attempts fail
+
+
+
+
 
 
 def mix_lnphi(i, Zmix, BVc_prm, CVc2_prm, DVc4_prm, EVc5_prm, FVc2_prm, FVc2, bmix, b_prm, gVc2, gVc2_prm, Vmix):
+    """ This function calculates lnphi values"""
     lnph=0
 
     lnph = -math.log(Zmix)
@@ -562,6 +627,8 @@ def mix_fugacity_ind(*, P_kbar, T_K, XH2O, Vmix):
 
 
 def mixing_rules(B, C, D, E, F, Vc, Y, b, g, k1_temperature, k2_temperature, k3_temperature):
+    """ This function applies the DZ06 mixing rules"""
+
     Bij = np.zeros((2, 2))
     Vcij = np.zeros((2, 2))
     BVc_prm = np.zeros(2)
@@ -739,7 +806,7 @@ def mixing_rules(B, C, D, E, F, Vc, Y, b, g, k1_temperature, k2_temperature, k3_
 ## Getting EOS contsants themselves
 
 def get_EOS_params(P, TK):
-    """ This function returns the EOS 'constants' if you know the pressure and temperature
+    """ This function returns the EOS 'constants' if you know the pressure (in bars) and temperature (in Kelvin)
 
     """
 
@@ -813,7 +880,7 @@ def get_EOS_params(P, TK):
 ## Lets wrap all these functions up.
 
 def calculate_molar_volume_ind_DZ2006(*, P_kbar, T_K, XH2O):
-    """ This function calculates molar volume for a known pressure, T in K and XH2O (mol frac) for a single value
+    """ This function calculates molar volume (cm3/mol) for a known pressure (kbar), T in K and XH2O (mol frac) for a single value
     """
 
     P=P_kbar*1000
@@ -838,11 +905,14 @@ def calculate_molar_volume_ind_DZ2006(*, P_kbar, T_K, XH2O):
 
         mol_vol=mixvolume(Vguess, P, BVc, CVc2, DVc4, EVc5, FVc2, bmix, gVc2, T_K)
 
+    if mol_vol<0:
+        mol_vol=np.nan
+
     return mol_vol
 
 
 def calculate_molar_volume_DZ2006(*, P_kbar, T_K, XH2O):
-    """ Used to calculate molar volume in a loop for multiple inputs
+    """ Used to calculate molar volume (cm3/mol) in a loop for multiple inputs
 
 
     """
@@ -855,7 +925,7 @@ def calculate_molar_volume_DZ2006(*, P_kbar, T_K, XH2O):
         raise ValueError("All input Pandas Series must have the same length.")
 
     # Set up loop
-    mol_vol=np.empty(len(P_kbar), float)
+    mol_vol=np.zeros(len(P_kbar), float)
 
     for i in range(0, len(P_kbar)):
         mol_vol[i]=calculate_molar_volume_ind_DZ2006(P_kbar=P_kbar.iloc[i].astype(float), T_K=T_K.iloc[i].astype(float), XH2O=XH2O.iloc[i].astype(float))
@@ -867,40 +937,50 @@ def calculate_molar_volume_DZ2006(*, P_kbar, T_K, XH2O):
     return mol_vol
 
 def calculate_Pressure_ind_DZ2006(*, mol_vol, T_K, XH2O, Pguess=None):
-    """ This function calculates pressure for a known molar volume, T in K and XH2O (mol frac) for a single value
+    """ This function calculates pressure  (in bars) for a known molar volume, T in K and XH2O (mol frac) for a single value. It uses a look up table to get pressure, then a newton and raphson method (implemented in the function mixpressure) to find the best fit pressure. There are some densities, T_K and XH2O values where the volume is negative.
     """
     V=mol_vol
-    if Pguess is None:
-        if V>1000:
-            Pguess=1000
-        elif V<10:
-            Pguess=20000
-        else:
-            Pguess=200
+    # if Pguess is None:
+    #     if V>1000:
+    #         Pguess=1000
+    #     elif V<10:
+    #         Pguess=20000
+    #     else:
+    #         Pguess=200
+
+    # Lets get P guess from a look up table
+    # uses a look up table
+    Pguess=get_initial_guess(V_target=V, T_K_target=T_K, XH2O_target=XH2O)*1000
+
+    if Pguess <= 0:
+            return np.nan
+
 
     TK=T_K
 
     # lets do for low pressure initially
 
 
-    if XH2O==0:
-        P=purepressure(1,  V, Pguess, TK)
+    # if XH2O==0:
+    #     P=purepressure(1,  V, Pguess, TK)
+    #
+    # elif XH2O==1:
+    #     P=purepressure(0, V, Pguess, TK)
+    #
+    # else:
+    XCO2=1-XH2O
+    Y = [0] * 2
+    Y[0]=XH2O
+    Y[1]=XCO2
 
-    elif XH2O==1:
-        P=purepressure(0, V, Pguess, TK)
+    # Now iteratively solve for pressure starting from this initial guess.
 
-    else:
-        XCO2=1-XH2O
-        Y = [0] * 2
-        Y[0]=XH2O
-        Y[1]=XCO2
-
-        P=mixpressure(Pguess, V, T_K, Y)
+    P=mixpressure(Pguess, V, T_K, Y)
 
     return P
 
 def calculate_Pressure_DZ2006(*, mol_vol=None, density=None, T_K, XH2O):
-    """ Used to calculate molar volume in a loop for multiple inputs
+    """ Used to calculate pressure in a loop for multiple inputs. Dens - bulk density.
 
 
     """
@@ -919,7 +999,7 @@ def calculate_Pressure_DZ2006(*, mol_vol=None, density=None, T_K, XH2O):
         raise ValueError("All input Pandas Series must have the same length.")
 
     # Set up loop
-    P=np.empty(len(mol_vol), float)
+    P=np.zeros(len(mol_vol), float)
 
     for i in range(0, len(mol_vol)):
         P[i]=calculate_Pressure_ind_DZ2006(mol_vol=mol_vol.iloc[i].astype(float), T_K=T_K.iloc[i].astype(float), XH2O=XH2O.iloc[i].astype(float))
@@ -945,12 +1025,12 @@ def mix_fugacity(*, P_kbar, T_K, XH2O, Vmix):
     if len(set(lengths)) != 1:
         raise ValueError("All input Pandas Series must have the same length.")
 
-    f=np.empty(len(P_kbar), float)
-    a_CO2=np.empty(len(P_kbar), float)
-    a_H2O=np.empty(len(P_kbar), float)
-    f_CO2=np.empty(len(P_kbar), float)
-    f_H2O=np.empty(len(P_kbar), float)
-    Zmix=np.empty(len(P_kbar), float)
+    f=np.zeros(len(P_kbar), float)
+    a_CO2=np.zeros(len(P_kbar), float)
+    a_H2O=np.zeros(len(P_kbar), float)
+    f_CO2=np.zeros(len(P_kbar), float)
+    f_H2O=np.zeros(len(P_kbar), float)
+    Zmix=np.zeros(len(P_kbar), float)
     for i in range(0, len(P_kbar)):
 
         f_H2O[i], f_CO2[i], a_H2O[i], a_CO2[i], Zmix[i]=mix_fugacity_ind(P_kbar=P_kbar.iloc[i].astype(float), T_K=T_K.iloc[i].astype(float), XH2O=XH2O.iloc[i].astype(float), Vmix=Vmix.iloc[i].astype(float))
@@ -1059,7 +1139,7 @@ def calculate_entrapment_P_XH2O(*, XH2O, CO2_dens_gcm3, T_K, T_K_ambient=37+273.
         P_kbar_mixCO2_DZ06_Hloss: Pressure calculated from the reconstructed mixed fluid density using the mixed EOS from Duan and Zhang (2006) assuming H loss
         P_kbar_mixCO2_DZ06_noHloss: Pressure calculated from the reconstructed mixed fluid density using the mixed EOS from Duan and Zhang (2006) assuming H loss
         P Mix_Hloss/P Pure DZ06: Correction factor - e.g. how much deeper the pressure is from the mixed EOS with H loss
-        P Mix_noHloss/P Pure DZ06: Correction factor - e.g. how much deeper the pressure is from the mixed EOS with H loss
+        P Mix_noHloss/P Pure DZ06: Correction factor - e.g. how much deeper the pressure is from the mixed EOS (assuming no H loss)
         rho_mix_calc_noHloss: Bulk density calculated (C+H)
         rho_mix_calc_Hloss: Bulk density calculated (C+H) after h loss
         CO2_dens_gcm3: Input CO2 density
@@ -1079,26 +1159,28 @@ def calculate_entrapment_P_XH2O(*, XH2O, CO2_dens_gcm3, T_K, T_K_ambient=37+273.
     # IF water isnt lost
 
     # Calculate mass ratio from molar ratio
-    mass_ratio=(XH2O*18)/((1-XH2O)*44)
-    # Calculate pressure in CO2 fluid
-    P=calculate_P_for_rho_T_SW96(CO2_dens_gcm3, T_K_ambient)
+    XH2O_mass=(XH2O*18)/((1-XH2O)*44 +(XH2O*18) )
+    # Calculate pressure in CO2 fluid - returns answer in kbar
+    P_CO2=calculate_P_for_rho_T_SW96(CO2_dens_gcm3, T_K_ambient)['P_kbar']
     # Now calculate density of H2O fluid
 
-    # Calculate density of H2O
-    rho_H2O=calculate_rho_for_P_T_H2O(P['P_kbar'], T_K_ambient)
+    # See https://www.youtube.com/watch?v=6wE4Tk6OjGY
+    Ptotal=P_CO2/(1-XH2O) # Calculate the total pressure from the pressure we know for CO2.
+    P_H2O=Ptotal*XH2O # Now calculate the pressure of H2O. You could also do this as PTot*XH2O
+
+    # calculate density of H2O using EOS
+    H2O_dens=calculate_rho_for_P_T_H2O(P_kbar=P_H2O,T_K=T_K_ambient)
 
+    # Calculate the bulk density by re-arranging the two volume equations
+    rho_orig_no_H_loss=(CO2_dens_gcm3*H2O_dens)/((1-XH2O_mass)*H2O_dens+XH2O_mass*CO2_dens_gcm3)
 
 
-    # Assume a system of unit 1. Calculate volume of CO2
-    VolCO2=(1-mass_ratio)/CO2_dens_gcm3
-    VolH2O=mass_ratio/rho_H2O
-    rho_orig_no_H_loss=1/(VolH2O+VolCO2)
 
     if fast_calcs is True:
         if Hloss is True:
             P=calculate_Pressure_DZ2006(density=rho_orig_H_loss, T_K=T_K, XH2O=XH2O)
         if Hloss is False:
-            P=calculate_Pressure_DZ2006(density=rho_orig_H_loss, T_K=T_K, XH2O=XH2O)
+            P=calculate_Pressure_DZ2006(density=rho_orig_no_H_loss, T_K=T_K, XH2O=XH2O)
         return P/1000
 
     else:
@@ -1106,9 +1188,10 @@ def calculate_entrapment_P_XH2O(*, XH2O, CO2_dens_gcm3, T_K, T_K_ambient=37+273.
         # Lets calculate the pressure using SW96
         P_SW=calculate_P_for_rho_T(T_K=T_K, CO2_dens_gcm3=rho_meas, EOS='SW96')
         P_SP=calculate_P_for_rho_T(T_K=T_K, CO2_dens_gcm3=rho_meas, EOS='SP94')
-        # Same for DZ2006
+        # Run Duan and Zhang with no XHO@ to start with
         P_DZ=calculate_Pressure_DZ2006(density=rho_meas, T_K=T_K, XH2O=XH2O*0)
-        # Now doing it with XH2O
+        # Now doing it with XH2O for two different densities
+
         P_DZ_mix_H_loss=calculate_Pressure_DZ2006(density=rho_orig_H_loss, T_K=T_K, XH2O=XH2O)
         P_DZ_mix_noH_loss=calculate_Pressure_DZ2006(density=rho_orig_no_H_loss, T_K=T_K, XH2O=XH2O)