PetThermoTools 0.2.31__py3-none-any.whl → 0.2.33__py3-none-any.whl

PetThermoTools/Barom.py

@@ -10,6 +10,7 @@ from PetThermoTools.GenFuncs import *
 from PetThermoTools.Plotting import *
 from PetThermoTools.Liq import *
 from PetThermoTools.MELTS import *
+from PetThermoTools.Path import *
 # try:
 #     from PetThermoTools.Holland import *
 # except:
@@ -23,7 +24,212 @@ from tqdm.notebook import tqdm, trange
 from scipy import interpolate
 from shapely.geometry import MultiPoint, Point, Polygon
 
-def find_mineral_cosaturation(cores = None, Model = None, bulk = None, phases = None, P_bar = None, Fe3Fet_Liq = None, H2O_Liq = None, H2O_Sat = False, T_initial_C = None, dt_C = None, T_maxdrop_C = None, T_cut_C = None, find_range = None, find_min = None, fO2_buffer = None, fO2_offset = None):
+from functools import partial
+import concurrent.futures
+
+
+def run_melts_single(Pin, Model, comp, T_maxdrop_C, dt_C, T_initial_C,
+                     fO2_buffer, fO2_offset, H2O_Sat, phases):
+    try:
+        return path_MELTS(
+            Model=Model,
+            comp=comp,
+            T_maxdrop_C=T_maxdrop_C,
+            dt_C=dt_C,
+            T_initial_C=T_initial_C,
+            P_bar=Pin,
+            find_liquidus=True,
+            fO2_buffer=fO2_buffer,
+            fO2_offset=fO2_offset,
+            fluid_sat=H2O_Sat,
+            Suppress=['rutile', 'tridymite'],
+            phases=phases
+        )
+    except Exception as e:
+        print(f"Failed at {Pin} bar: {e}")
+        return None
+
+def mineral_cosaturation(Model="MELTSv1.0.2", cores=int(np.floor(multiprocessing.cpu_count()/2)), bulk=None,
+                         phases=['quartz1', 'alkali-feldspar1', 'plagioclase1'],
+                         P_bar=np.linspace(250, 5000, 32), Fe3Fet_init=None, H2O_init=None,
+                         CO2_init=None, H2O_Sat=False, T_initial_C=None, dt_C=2,
+                         T_maxdrop_C=50, T_cut_C=20, find_range=True,
+                         find_min=True, fO2_buffer=None, fO2_offset=0.0, timeout = 30):
+
+    comp = bulk.copy()
+    if H2O_Sat:
+        comp['H2O_Liq'] = 20
+
+    comp = comp_fix(Model=Model, comp=comp, Fe3Fet_Liq=Fe3Fet_init,
+                    H2O_Liq=H2O_init, CO2_Liq=CO2_init)
+
+    run_partial = partial(run_melts_single, 
+                          Model=Model, comp=comp, T_maxdrop_C=T_maxdrop_C,
+                          dt_C=dt_C, T_initial_C=T_initial_C,
+                          fO2_buffer=fO2_buffer, fO2_offset=fO2_offset,
+                          H2O_Sat=H2O_Sat, phases=phases)
+
+    results = {}
+    with concurrent.futures.ProcessPoolExecutor(max_workers=cores) as executor:
+        futures = {executor.submit(run_partial, p): i for i, p in enumerate(P_bar)}
+
+        done, not_done = concurrent.futures.wait(
+            futures.keys(), timeout=timeout, return_when=concurrent.futures.ALL_COMPLETED
+        )
+
+        for future in done:
+            i = futures[future]
+            try:
+                results[f"P = {P_bar[i]:.2f} bars"] = future.result()
+            except Exception as e:
+                print(f"Failure at {P_bar[i]} bar: {e}")
+                results[f"P = {P_bar[i]:.2f} bars"] = {}
+
+        for future in not_done:
+            i = futures[future]
+            print(f"Timeout at {P_bar[i]} bar. Either the calculation was slow (increase timeout) or it failed.")
+            results[f"P = {P_bar[i]:.2f} bars"] = {}
+            future.cancel()  # Cancel if still running
+
+    Results = stich(Res=results, multi=True, Model=Model)
+
+    ## determine the offset between the phases
+    if len(phases)  == 3:
+        arr = np.zeros((len(Results.keys()), 4))
+        arr2 = np.zeros((len(Results.keys()), 4))
+        columns = ['P_bar'] + phases + [phases[0] + ' - ' + phases[1], phases[0] + ' - ' + phases[2], phases[1] + ' - ' + phases[2], '3 Phase Saturation']
+        for i, r in enumerate(Results.keys()):
+            for idx, p in enumerate(phases):
+                if p in Results[r]['Mass'].keys():
+                    arr[i, idx+1] = Results[r]['Conditions'].loc[Results[r]['Mass'][p] > 0.0, 'T_C'].values[0]
+                else:
+                    arr[i, idx + 1] = np.nan
+
+            arr[i,0] = Results[r]['Conditions']['P_bar'].loc[0]
+
+        arr2[:, 0] = np.abs(arr[:,1] - arr[:,2])
+        arr2[:, 1] = np.abs(arr[:,1] - arr[:,3])
+        arr2[:, 2] = np.abs(arr[:,2] - arr[:,3])
+        arr2[:,3] = np.max(arr2[:,0:2], axis = 1)
+
+        r_arr = np.hstack((arr,arr2))
+
+        out = pd.DataFrame(data = r_arr, columns = columns)
+        out = out.sort_values('P_bar').reset_index(drop=True)
+
+    else:
+        arr = np.zeros((len(Results.keys()),4))
+        columns = ['P_bar'] + phases + [phases[0]+' - '+phases[1]]
+        for i, r in enumerate(Results.keys()):
+            for idx, p in enumerate(phases):
+                if p in Results[r]['Mass'].keys():
+                    arr[i, idx+1] = Results[r]['Conditions'].loc[Results[r]['Mass'][p] > 0.0, 'T_C'].values[0]
+                else:
+                    arr[i, idx + 1] = np.nan
+
+            arr[i,0] = Results[r]['Conditions']['P_bar'].loc[0]
+
+        arr[:,3] = np.abs(arr[:,1] - arr[:,2])
+
+        out = pd.DataFrame(data = r_arr, columns = columns)
+        out = out.sort_values('P_bar').reset_index(drop=True)
+
+    if find_min:
+        res = findmin(out = out, P_bar = P_bar, T_cut_C = T_cut_C)
+        out = {'CurveMin': res, 'Output': out}
+    else:
+        out = {'Output': out}
+
+    return out, Results
+
+def findmin(out = None, P_bar = None, T_cut_C = None):
+    Res = out.copy()
+
+    if '3 Phase Saturation' in list(Res.keys()):
+        T_cut_old = T_cut_C
+        T_cut_C = T_cut_C + np.nanmin(Res[4:])
+        Minimum = list(Res.keys())[4:]
+        CurveMin = {}
+        for m in Minimum:
+            if len(Res[m][~np.isnan(Res[m].values)]) > 2:
+                y = Res[m][(~np.isnan(Res[m].values)) & (Res[m].values < T_cut_C)].values
+                x = P_bar[(~np.isnan(Res[m].values)) & (Res[m].values < T_cut_C)]
+
+                try:
+                    y_new = interpolate.UnivariateSpline(x, y, k = 3)
+
+                    P_new = np.linspace(P_bar[P_bar == np.nanmin(P_bar[(~np.isnan(Res[m].values)) & (Res[m].values < T_cut_C)])], 
+                                        P_bar[P_bar == np.nanmax(P_bar[(~np.isnan(Res[m].values)) & (Res[m].values < T_cut_C)])], 200)
+
+                    NewMin = np.nanmin(y_new(P_new))
+                    P_min = P_new[np.where(y_new(P_new) == NewMin)][0]
+                    if NewMin < T_cut_old:
+                        Test = 'Pass'
+                    else:
+                        Test = 'Fail'
+
+                    CurveMin[m] = {'P_min': P_min, 'Res_min': NewMin, 'y_new': y_new(P_new), 'P_new': P_new, 'test': Test}
+                except:
+                    try:
+                        y_new = interpolate.UnivariateSpline(x, y, k = 2)
+
+                        P_new = np.linspace(P_bar[P_bar == np.nanmin(P_bar[(~np.isnan(Res[m].values)) & (Res[m].values < T_cut_C)])], 
+                                            P_bar[P_bar == np.nanmax(P_bar[(~np.isnan(Res[m].values)) & (Res[m].values < T_cut_C)])], 200)
+
+                        NewMin = np.nanmin(y_new(P_new))
+                        P_min = P_new[np.where(y_new(P_new) == NewMin)][0]
+                        if NewMin < T_cut_old:
+                            Test = 'Pass'
+                        else:
+                            Test = 'Fail'
+
+                        CurveMin[m] = {'P_min': P_min, 'Res_min': NewMin, 'y_new': y_new(P_new), 'P_new': P_new, 'test': Test}
+                    except:
+                        CurveMin[m] = {'P_min': np.nan, 'Res_min': np.nan, 'y_new': np.nan, 'P_new': np.nan, 'test': 'Fail'}
+            else:
+                y_new = np.nan
+                P_new = np.nan
+                NewMin = np.nan
+                P_min = np.nan
+                Test = 'Fail'
+                CurveMin[m] = {'P_min': P_min, 'Res_min': NewMin, 'y_new': y_new, 'P_new': P_new, 'test': Test}
+
+    else:
+        CurveMin = {}
+        m = Res.keys()[3]
+        if len(Res[m][~np.isnan(Res[m])]) > 2:
+            y = Res[m][(~np.isnan(Res[m].values)) & (Res[m].values < T_cut_C*2)].values
+            x = P_bar[(~np.isnan(Res[m].values)) & (Res[m].values < T_cut_C*2)]
+
+            try:
+                y_new = interpolate.UnivariateSpline(x, y, k = 3)
+            except:
+                y_new = interpolate.UnivariateSpline(x, y, k = 2)
+
+            P_new = np.linspace(P_bar[P_bar == np.nanmin(P_bar[(~np.isnan(Res[m])) & (Res[m] < T_cut_C*2)])], 
+                                    P_bar[P_bar == np.nanmax(P_bar[(~np.isnan(Res[m])) & (Res[m] < T_cut_C*2)])], 200)
+            
+            NewMin = np.nanmin(y_new(P_new))
+            P_min = P_new[np.where(y_new(P_new) == NewMin)][0]
+            if NewMin < T_cut_C:
+                Test = 'Pass'
+            else:
+                Test = 'Fail'
+        else:
+            y_new = np.nan
+            P_new = np.nan
+            NewMin = np.nan
+            P_min = np.nan
+            Test = 'Fail'
+
+        CurveMin[m] = {'P_min': P_min, 'Res_min': NewMin, 'y_new': y_new, 'P_new': P_new, 'test': Test}
+
+    return CurveMin
+
+
+def find_mineral_cosaturation(cores = None, Model = None, bulk = None, phases = None, P_bar = None, Fe3Fet_Liq = None, 
+                              H2O_Liq = None, H2O_Sat = False, T_initial_C = None, dt_C = None, T_maxdrop_C = None, 
+                              T_cut_C = None, find_range = None, find_min = None, fO2_buffer = None, fO2_offset = None):
     '''
     Carry out multiple calculations in parallel. Allows isobaric, polybaric and isochoric crystallisation to be performed as well as isothermal, isenthalpic or isentropic decompression. All temperature inputs/outputs are reported in degrees celcius and pressure is reported in bars.
 
@@ -621,406 +827,3 @@ def satTemperature(q, index, *, Model = None, comp = None, phases = None, T_init
         return
 
 
-# def detRange(P, Model, bulk, Results, Phases, T_initial = None, Fe3 = None, H2O = None, T_cut = None, findRange = None, cores = None):
-#     '''
-#     re-run the SatPress calculations using a higher resolution to determine the range of P (+H2O +fO2) where the maximum difference between the target saturation curve is below some reference value.
-#     '''
-#     if T_cut is None:
-#         T_cut = 5
-#
-#     if T_initial is None:
-#         T_initial = 1200
-#
-#     Res_key = list(Results.keys())[:-2]
-#
-#     if Fe3 is None and H2O is None:
-#         P_min = np.zeros(len(Res_key))
-#         P_max = np.zeros(len(Res_key))
-#         i = 0
-#         for Res in Res_key:
-#             if len(Results[Res][np.where(Results[Res]<T_cut*2)]) > 0:
-#                 P_min[i] = np.nanmin(P[np.where(Results[Res]<T_cut*2)])
-#                 P_max[i] = np.nanmax(P[np.where(Results[Res]<T_cut*2)])
-#             else:
-#                 P_min[i] = np.nan
-#                 P_max[i] = np.nan
-#
-#             i = i + 1
-#
-#         P_start = np.nanmin(P_min)
-#         P_end = np.nanmax(P_max)
-#
-#         P_space = 1 + 3*(P_end - P_start)/((np.max(P) - np.min(P))/(len(P)-1))
-#
-#         P = np.linspace(P_start, P_end, int(P_space))
-#
-#         with open('bulk.obj', 'wb') as f:
-#             pickle.dump(bulk, f)
-#
-#         if len(Phases) == 3:
-#             phases[0], b_Sat, c_Sat, T_Liq, H2O_Melt = findSat(P, Model, Phases, bulk, T_initial = T_initial, dt = T_cut, T_step = T_cut, cores = cores)
-#         else:
-#             phases[0], b_Sat, T_Liq, H2O_Melt = findSat(P, Model, Phases, bulk, T_initial = T_initial, dt = T_cut, T_step = T_cut, cores = cores)
-#
-#         # calc residuals
-#         if len(Phases) == 3:
-#             Results_new = findResiduals(phases[0], b_Sat, c_Sat = c_Sat)
-#         else:
-#             Results_new = findResiduals(phases[0], b_Sat)
-#
-#         Results_new['H2O_sat'] = H2O_Melt
-#         Results_new['T_Liq'] = T_Liq
-#
-#         for Res in Res_key:
-#             if len(Results_new[Res][np.where(~np.isnan(Results_new[Res]))]) > 0:
-#                 Results_new[Res + '_min_P'] = np.nanmin(P[~np.isnan(Results_new[Res])])
-#                 Results_new[Res + '_max_P'] = np.nanmin(P[~np.isnan(Results_new[Res])])
-#             else:
-#                 Results_new[Res + '_min_P'] = np.nan
-#                 Results_new[Res + '_max_P'] = np.nan
-#
-#         return Results_new
-#
-#     if Fe3 is not None and H2O is None:
-#         P_min = np.zeros(len(Res_key))
-#         P_max = np.zeros(len(Res_key))
-#
-#         Fe3_min = np.zeros(len(Res_key))
-#         Fe3_max = np.zeros(len(Res_key))
-#
-#         P_mat, Fe3_mat = np.meshgrid(P, Fe3)
-#
-#         i = 0
-#         for Res in Res_key:
-#             if len(Results[Res][np.where(Results[Res]<T_cut*2)]) > 0:
-#                 P_min[i] = np.nanmin(P_mat[np.where(Results[Res]<T_cut*2)])
-#                 P_max[i] = np.nanmax(P_mat[np.where(Results[Res]<T_cut*2)])
-#
-#                 Fe3_min[i] = np.nanmin(Fe3_mat[np.where(Results[Res]<T_cut*2)])
-#                 Fe3_max[i] = np.nanmax(Fe3_mat[np.where(Results[Res]<T_cut*2)])
-#             else:
-#
-#                 P_min[i] = np.nan
-#                 P_max[i] = np.nan
-#
-#                 Fe3_min[i] = np.nan
-#                 Fe3_max[i] = np.nan
-#
-#             i = i + 1
-#
-#         P_start = np.nanmin(P_min)
-#         P_end = np.nanmax(P_max)
-#
-#         Fe3_start = np.nanmin(Fe3_min)
-#         Fe3_end = np.nanmax(Fe3_max)
-#
-#         P = np.linspace(P_start, P_end, int(1 + 3*(P_end - P_start)/((np.max(P) - np.min(P))/(len(P)-1))))
-#         Fe3 = np.linspace(Fe3_start, Fe3_end, int(1 + 3*(Fe3_end - Fe3_start)/((np.max(Fe3) - np.min(Fe3))/(len(Fe3)-1))))
-#
-#         if len(Phases) == 3:
-#             Res_abc_mat = np.zeros((len(Fe3), len(P)))
-#             Res_ac_mat = np.zeros((len(Fe3), len(P)))
-#             Res_bc_mat = np.zeros((len(Fe3), len(P)))
-#
-#         Res_ab_mat = np.zeros((len(Fe3), len(P)))
-#         H2O_mat = np.zeros((len(Fe3), len(P)))
-#         T_Liq_mat = np.zeros((len(Fe3), len(P)))
-#
-#         for i in range(len(Fe3)):
-#             Bulk_new = bulk.copy()
-#             Bulk_new[3] = Fe3[i]*((159.69/2)/71.844)*bulk[5]
-#             Bulk_new[5] = (1-Fe3[i])*bulk[5]
-#
-#             with open('bulk.obj', 'wb') as f:
-#                 pickle.dump(Bulk_new, f)
-#
-#             if len(Phases) == 3:
-#                 phases[0], b_Sat, c_Sat, T_Liq, H2O_Melt = findSat(P, Model, Phases, bulk, T_initial = T_initial, dt = T_cut, T_step = T_cut, cores = cores)
-#             else:
-#                 phases[0], b_Sat, T_Liq, H2O_Melt = findSat(P, Model, Phases, bulk, T_initial = T_initial, dt = T_cut, T_step = T_cut, cores = cores)
-#
-#             # calc residuals
-#             if len(Phases) == 3:
-#                 Res = findResiduals(phases[0], b_Sat, c_Sat = c_Sat)
-#                 Res_abc_mat[i, :] = Res['abc']
-#                 Res_ac_mat[i, :] = Res['ac']
-#                 Res_bc_mat[i, :] = Res['bc']
-#             else:
-#                 Res = findResiduals(phases[0], b_Sat)
-#
-#             T_Liq_mat[i, :] = T_Liq
-#             H2O_mat[i, :] = H2O_Melt
-#             Res_ab_mat[i, :] = Res['ab']
-#
-#         if len(Phases) == 3:
-#             Results_new = {'abc': Res_abc_mat, 'ab': Res_ab_mat, 'ac': Res_ac_mat, 'bc': Res_bc_mat, 'H2O_Sat': H2O_mat, 'T_Liq': T_Liq_mat}
-#         else:
-#             Results_new = {'ab': Res_ab_mat, 'H2O_Sat': H2O_mat, 'T_Liq': T_Liq_mat}
-#
-#         P_mat, Fe3_mat = np.meshgrid(P, Fe3)
-#         for Res in Res_key:
-#             if len(Results_new[Res][np.where(~np.isnan(Results_new[Res]))]) > 0:
-#                 Results_new[Res + '_min_P'] = np.nanmin(P_mat[np.where(~np.isnan(Results_new[Res]))])
-#                 Results_new[Res + '_max_P'] = np.nanmin(P_mat[np.where(~np.isnan(Results_new[Res]))])
-#
-#                 Results_new[Res + '_min_Fe3'] = np.nanmin(Fe3_mat[np.where(~np.isnan(Results_new[Res]))])
-#                 Results_new[Res + '_max_Fe3'] = np.nanmin(Fe3_mat[np.where(~np.isnan(Results_new[Res]))])
-#             else:
-#                 Results_new[Res + '_min_P'] = np.nan
-#                 Results_new[Res + '_max_P'] = np.nan
-#
-#                 Results_new[Res + '_min_Fe3'] = np.nan
-#                 Results_new[Res + '_max_Fe3'] = np.nan
-#
-#         return Results_new
-#
-#     if Fe3 is None and H2O is not None:
-#         P_min = np.zeros(len(Res_key))
-#         P_max = np.zeros(len(Res_key))
-#
-#         H2O_min = np.zeros(len(Res_key))
-#         H2O_max = np.zeros(len(Res_key))
-#
-#         P_mat, H2O_mat = np.meshgrid(P, H2O)
-#
-#         i = 0
-#         for Res in Res_key:
-#             if len(Results[Res][np.where(Results[Res]<T_cut*2)]) > 0:
-#                 P_min[i] = np.nanmin(P_mat[np.where(Results[Res]<T_cut*2)])
-#                 P_max[i] = np.nanmax(P_mat[np.where(Results[Res]<T_cut*2)])
-#
-#                 H2O_min[i] = np.nanmin(H2O_mat[np.where(Results[Res]<T_cut*2)])
-#                 H2O_max[i] = np.nanmax(H2O_mat[np.where(Results[Res]<T_cut*2)])
-#             else:
-#
-#                 P_min[i] = np.nan
-#                 P_max[i] = np.nan
-#
-#                 H2O_min[i] = np.nan
-#                 H2O_max[i] = np.nan
-#
-#             i = i + 1
-#
-#         P_start = np.nanmin(P_min)
-#         P_end = np.nanmax(P_max)
-#
-#         H2O_start = np.nanmin(H2O_min)
-#         H2O_end = np.nanmax(H2O_max)
-#
-#         P = np.linspace(P_start, P_end, int(1 + 3*(P_end - P_start)/((np.max(P) - np.min(P))/(len(P)-1))))
-#         H2O = np.linspace(H2O_start, H2O_end, int(1 + 3*(H2O_end - H2O_start)/((np.max(H2O) - np.min(H2O))/(len(H2O)-1))))
-#
-#         if len(Phases) == 3:
-#             Res_abc_mat = np.zeros((len(H2O), len(P)))
-#             Res_ac_mat = np.zeros((len(H2O), len(P)))
-#             Res_bc_mat = np.zeros((len(H2O), len(P)))
-#
-#         Res_ab_mat = np.zeros((len(H2O), len(P)))
-#         H2O_mat = np.zeros((len(H2O), len(P)))
-#         T_Liq_mat = np.zeros((len(H2O), len(P)))
-#
-#         for i in range(len(H2O)):
-#             Bulk_new = bulk.copy()
-#             Bulk_new[14] = H2O[i]
-#
-#             with open('bulk.obj', 'wb') as f:
-#                 pickle.dump(Bulk_new, f)
-#
-#             if len(Phases) == 3:
-#                 phases[0], b_Sat, c_Sat, T_Liq, H2O_Melt = findSat(P, Model, Phases, bulk, T_initial = T_initial, dt = T_cut, T_step = T_cut, cores = cores)
-#             else:
-#                 phases[0], b_Sat, T_Liq, H2O_Melt = findSat(P, Model, Phases, bulk, T_initial = T_initial, dt = T_cut, T_step = T_cut, cores = cores)
-#
-#             # calc residuals
-#             if len(Phases) == 3:
-#                 Res = findResiduals(phases[0], b_Sat, c_Sat = c_Sat)
-#                 Res_abc_mat[i, :] = Res['abc']
-#                 Res_ac_mat[i, :] = Res['ac']
-#                 Res_bc_mat[i, :] = Res['bc']
-#             else:
-#                 Res = findResiduals(phases[0], b_Sat)
-#
-#             T_Liq_mat[i, :] = T_Liq
-#             H2O_mat[i, :] = H2O_Melt
-#             Res_ab_mat[i, :] = Res['ab']
-#
-#         if len(Phases) == 3:
-#             Results_new = {'abc': Res_abc_mat, 'ab': Res_ab_mat, 'ac': Res_ac_mat, 'bc': Res_bc_mat, 'H2O_Sat': H2O_mat, 'T_Liq': T_Liq_mat}
-#         else:
-#             Results_new = {'ab': Res_ab_mat, 'H2O_Sat': H2O_mat, 'T_Liq': T_Liq_mat}
-#
-#         P_mat, H2O_mat = np.meshgrid(P, H2O)
-#         for Res in Res_key:
-#             if len(Results_new[Res][np.where(~np.isnan(Results_new[Res]))]) > 0:
-#                 Results_new[Res + '_min_P']= np.nanmin(P_mat[np.where(~np.isnan(Results_new[Res]))])
-#                 Results_new[Res + '_max_P'] = np.nanmin(P_mat[np.where(~np.isnan(Results_new[Res]))])
-#
-#                 Results_new[Res + '_min_H2O'] = np.nanmin(Results_new['H2O_Sat'][np.where(~np.isnan(Results_new[Res]))])
-#                 Results_new[Res + '_max_H2O'] = np.nanmin(Results_new['H2O_Sat'][np.where(~np.isnan(Results_new[Res]))])
-#             else:
-#                 Results_new[Res + '_min_P']= np.nan
-#                 Results_new[Res + '_max_P'] = np.nan
-#
-#                 Results_new[Res + '_min_H2O'] = np.nan
-#                 Results_new[Res + '_max_H2O'] = np.nan
-#
-#         return Results_new
-#
-#     if H2O is not None and Fe3 is not None:
-#         Results_new = {}
-#         P_min = np.zeros(len(Res_key))
-#         P_max = np.zeros(len(Res_key))
-#
-#         Fe3_min = np.zeros(len(Res_key))
-#         Fe3_max = np.zeros(len(Res_key))
-#
-#         H2O_min = np.zeros(len(Res_key))
-#         H2O_max = np.zeros(len(Res_key))
-#
-#         Fe3_mat, H2O_mat, P_mat = np.meshgrid(Fe3, H2O, P)
-#
-#         i = 0
-#         for Res in Res_key:
-#             if len(Results[Res][np.where(Results[Res]<T_cut*2)]) > 0:
-#                 P_min[i] = np.nanmin(P_mat[np.where(Results[Res]<T_cut*2)])
-#                 P_max[i] = np.nanmax(P_mat[np.where(Results[Res]<T_cut*2)])
-#
-#                 H2O_min[i] = np.nanmin(H2O_mat[np.where(Results[Res]<T_cut*2)])
-#                 H2O_max[i] = np.nanmax(H2O_mat[np.where(Results[Res]<T_cut*2)])
-#
-#                 Fe3_min[i] = np.nanmin(Fe3_mat[np.where(Results[Res]<T_cut*2)])
-#                 Fe3_max[i] = np.nanmax(Fe3_mat[np.where(Results[Res]<T_cut*2)])
-#             else:
-#
-#                 P_min[i] = np.nan
-#                 P_max[i] = np.nan
-#
-#                 H2O_min[i] = np.nan
-#                 H2O_max[i] = np.nan
-#
-#                 Fe3_min[i] = np.nan
-#                 Fe3_max[i] = np.nan
-#
-#             i = i + 1
-#
-#         if findRange == 'abc':
-#             P_start = P_min[0] - (P[1] - P[0])/3
-#             P_end = P_max[0] + (P[1] - P[0])/3
-#
-#             H2O_start = H2O_min[0] - (H2O[1] - H2O[0])/3
-#             H2O_end = H2O_max[0] + (H2O[1] - H2O[0])/3
-#
-#             Fe3_start = Fe3_min[0] - (Fe3[1] - Fe3[0])/3
-#             Fe3_end = Fe3_max[0] + (Fe3[1] - Fe3[0])/3
-#         else:
-#             P_start = np.nanmin(P_min)
-#             P_end = np.nanmax(P_max)
-#
-#             H2O_start = np.nanmin(H2O_min)
-#             H2O_end = np.nanmax(H2O_max)
-#
-#             Fe3_start = np.nanmin(Fe3_min)
-#             Fe3_end = np.nanmax(Fe3_max)
-#
-#         if P_end - P_start > 0:
-#             P = np.linspace(P_start, P_end, int(1 + 3*(P_end - P_start)/((np.max(P) - np.min(P))/(len(P)))))
-#         else:
-#             return Results_new
-#
-#         if H2O_end - H2O_start > 0:
-#             H2O = np.linspace(H2O_start, H2O_end, int(1 + 3*(H2O_end - H2O_start)/((np.max(H2O) - np.min(H2O))/(len(H2O)))))
-#         else:
-#             return Results_new
-#
-#         if Fe3_end - Fe3_start > 0:
-#             Fe3 = np.linspace(Fe3_start, Fe3_end, int(1 + 3*(Fe3_end - Fe3_start)/((np.max(Fe3) - np.min(Fe3))/(len(Fe3)))))
-#         else:
-#             return Results_new
-#
-#         if len(Phases) == 3:
-#             Res_abc_mat = np.zeros((len(H2O), len(Fe3), len(P)))
-#             Res_ac_mat = np.zeros((len(H2O), len(Fe3), len(P)))
-#             Res_bc_mat = np.zeros((len(H2O), len(Fe3), len(P)))
-#
-#         Res_ab_mat = np.zeros((len(H2O), len(Fe3), len(P)))
-#         T_Liq_3Dmat = np.zeros((len(H2O), len(Fe3), len(P)))
-#         H2O_Liq_3Dmat = np.zeros((len(H2O), len(Fe3), len(P)))
-#
-#         for i in range(len(H2O)):
-#             Bulk_new = bulk.copy()
-#             Bulk_new[14] = H2O[i]
-#
-#             if len(Phases) == 3:
-#                 Res_abc_mat_2D = np.zeros((len(Fe3), len(P)))
-#                 Res_ac_mat_2D = np.zeros((len(Fe3), len(P)))
-#                 Res_bc_mat_2D = np.zeros((len(Fe3), len(P)))
-#
-#             Res_ab_mat_2D = np.zeros((len(Fe3), len(P)))
-#             T_Liq_mat_2D = np.zeros((len(Fe3), len(P)))
-#             H2O_Liq_mat_2D = np.zeros((len(Fe3), len(P)))
-#
-#             for j in range(len(Fe3)):
-#
-#                 Bulk_new[3] = Fe3[j]*((159.69/2)/71.844)*bulk[5]
-#                 Bulk_new[5] = (1-Fe3[j])*bulk[5]
-#
-#                 with open('bulk.obj', 'wb') as f:
-#                     pickle.dump(Bulk_new, f)
-#
-#                 if len(Phases) == 3:
-#                     phases[0], b_Sat, c_Sat, T_Liq, H2O_Melt = findSat(P, Model, Phases, Bulk_new, T_initial = T_initial, dt = T_cut, T_step = T_cut, cores = cores)
-#                 else:
-#                     phases[0], b_Sat, T_Liq, H2O_Melt = findSat(P, Model, Phases, Bulk_new, T_initial = T_initial, dt = T_cut, T_step = T_cut, cores = cores)
-#
-#                 # calc residuals
-#                 if len(Phases) == 3:
-#                     Res = findResiduals(phases[0], b_Sat, c_Sat = c_Sat)
-#                     Res_abc_mat_2D[j, :] = Res['abc']
-#                     Res_ac_mat_2D[j, :] = Res['ac']
-#                     Res_bc_mat_2D[j, :] = Res['bc']
-#                 else:
-#                     Res = findResiduals(phases[0], b_Sat)
-#
-#                 Res_ab_mat_2D[j, :] = Res['ab']
-#                 T_Liq_mat_2D[j, :] = T_Liq
-#                 H2O_Liq_mat_2D[j, :] = H2O_Melt
-#
-#             if len(Phases) == 3:
-#                 Res_abc_mat[i,:,:] = Res_abc_mat_2D
-#                 Res_ac_mat[i,:,:] = Res_ac_mat_2D
-#                 Res_bc_mat[i,:,:] = Res_bc_mat_2D
-#
-#             Res_ab_mat[i,:,:] = Res_ab_mat_2D
-#             T_Liq_3Dmat[i,:,:] = T_Liq_mat_2D
-#             H2O_Liq_3Dmat[i,:,:] = H2O_Liq_mat_2D
-#
-#         if len(Phases) == 3:
-#             Results_new = {'abc': Res_abc_mat, 'ab': Res_ab_mat, 'ac': Res_ac_mat, 'bc': Res_bc_mat, 'H2O_Sat': H2O_Liq_3Dmat, 'T_Liq': T_Liq_3Dmat}
-#         else:
-#             Results_new = {'ab': Res_ab_mat, 'H2O_Sat': H2O_Liq_3Dmat, 'T_Liq': T_Liq_3Dmat}
-#
-#
-#         Fe3_mat, H2O_mat, P_mat = np.meshgrid(Fe3, H2O, P)
-#
-#         for Res in Res_key:
-#             if len(Results_new[Res][np.where(~np.isnan(Results_new[Res]))]) > 0:
-#                 Results_new[Res + '_min_P'] = np.nanmin(P_mat[np.where(~np.isnan(Results_new[Res]))])
-#                 Results_new[Res + '_max_P'] = np.nanmax(P_mat[np.where(~np.isnan(Results_new[Res]))])
-#
-#                 Results_new[Res + '_min_H2O'] = np.nanmin(Results_new['H2O_Sat'][np.where(~np.isnan(Results_new[Res]))])
-#                 Results_new[Res + '_max_H2O'] = np.nanmax(Results_new['H2O_Sat'][np.where(~np.isnan(Results_new[Res]))])
-#
-#                 Results_new[Res + '_min_Fe3'] = np.nanmin(Fe3_mat[np.where(~np.isnan(Results_new[Res]))])
-#                 Results_new[Res + '_max_Fe3'] = np.nanmax(Fe3_mat[np.where(~np.isnan(Results_new[Res]))])
-#             else:
-#                 Results_new[Res + '_min_P'] = np.nan
-#                 Results_new[Res + '_max_P'] = np.nan
-#
-#                 Results_new[Res + '_min_H2O'] = np.nan
-#                 Results_new[Res + '_max_H2O'] = np.nan
-#
-#                 Results_new[Res + '_min_Fe3'] = np.nan
-#                 Results_new[Res + '_max_Fe3'] = np.nan
-#
-#         return Results_new
-

PetThermoTools/Liq.py

@@ -366,12 +366,15 @@ def equilibrate_multi(cores = None, Model = None, bulk = None, T_C = None, P_bar
         # Affinity = Af_Combined.copy()
         return Combined
     else:
-        import julia
-        from julia.api import Julia
-        jl = Julia(compiled_modules=False)
-        from julia import MAGEMinCalc
-        # Output = MM.equilibrate_multi(P_bar = P_bar, T_C = T_C, comp = comp)
-        
+        # import julia
+        # from julia.api import Julia
+        # jl = Julia(compiled_modules=False)
+        # from julia import MAGEMinCalc
+        ## Output = MM.equilibrate_multi(P_bar = P_bar, T_C = T_C, comp = comp)
+        from juliacall import Main as jl, convert as jlconvert
+
+        jl.seval("using MAGEMinCalc")
+
         comp['O'] = comp['Fe3Fet_Liq']*(((159.59/2)/71.844)*comp['FeOt_Liq'] - comp['FeOt_Liq'])
 
         if Model == "Weller2024":
@@ -380,8 +383,19 @@ def equilibrate_multi(cores = None, Model = None, bulk = None, T_C = None, P_bar
             bulk = comp[['SiO2_Liq', 'Al2O3_Liq', 'CaO_Liq', 'MgO_Liq', 'FeOt_Liq', 'K2O_Liq', 'Na2O_Liq', 'TiO2_Liq', 'O', 'Cr2O3_Liq', 'H2O_Liq']].astype(float).values
 
         print(np.shape(bulk))
+        bulk_jl = jl.seval("collect")(bulk)
+
+        if type(T_C) == np.ndarray:
+            T_C = jl.seval("collect")(T_C)
+        if type(P_bar) == np.ndarray:
+            P_kbar = jl.seval("collect")(P_bar/1000.0)
+        else:
+            P_kbar = P_bar/1000.0
+        if type(fO2_offset) == np.ndarray:
+            fO2_offset = jl.seval("collect")(fO2_offset)
 
-        Output = MAGEMinCalc.equilibrate(bulk = bulk, P_kbar = P_bar/1000.0, T_C = T_C, fo2_buffer = fO2_buffer, fo2_offset = fO2_offset, Model = Model)
+        Output = jl.MAGEMinCalc.equilibrate(bulk = bulk_jl, P_kbar = P_kbar, T_C = T_C, fo2_buffer = fO2_buffer, fo2_offset = fO2_offset, Model = Model)
+        Output = dict(Output)
         Combined = stich(Output, Model = Model)
 
         if copy_columns is not None:

PetThermoTools/MELTS.py

@@ -299,7 +299,9 @@ def findCO2_MELTS(P_bar = None, Model = None, T_C = None, comp = None, melts = N
 
     return T_Liq, H2O, CO2
 
-def findLiq_MELTS(P_bar = None, Model = None, T_C_init = None, comp = None, melts = None, fO2_buffer = None, fO2_offset = None, Step = None, fluid_test = None, bulk_return = None, step = None, Affinity = False):
+def findLiq_MELTS(P_bar = None, Model = None, T_C_init = None, comp = None, melts = None, 
+                fO2_buffer = None, fO2_offset = None, Step = None, fluid_test = None, 
+                bulk_return = None, step = None, Affinity = False):
     '''
     Perform a single find liquidus calculation in MELTS. WARNING! Running this function directly from the command land/jupyter notebook will initiate the MELTS C library in the main python process. Once this has been initiated the MELTS C library cannot be re-loaded and failures during the calculation will likely cause a terminal error to occur.
 
@@ -801,12 +803,12 @@ def phaseSat_MELTS(Model = None, comp = None, phases = None, T_initial_C = None,
 
     return Results
 
-def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None, 
-               T_C = None, T_path_C = None, T_start_C = None, T_end_C = None, dt_C = None, 
+def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None, T_initial_C = 1400,
+               T_C = None, T_path_C = None, T_start_C = None, T_end_C = None, dt_C = None, T_maxdrop_C = None,
                P_bar = None, P_path_bar = None, P_start_bar = None, P_end_bar = None, dp_bar = None, 
                isenthalpic = None, isentropic = None, isochoric = None, find_liquidus = None, 
                fO2_buffer = None, fO2_offset = None, fluid_sat = None, Crystallinity_limit = None, 
-               Suppress = ['rutile', 'tridymite'], Suppress_except=False):
+               Suppress = ['rutile', 'tridymite'], Suppress_except=False, phases=None):
     '''
     Perform a single  calculation in MELTS. WARNING! Running this function directly from the command land/jupyter notebook will initiate the MELTS C library in the main python process. Once this has been initiated the MELTS C library cannot be re-loaded and failures during the calculation will likely cause a terminal error to occur.
 
@@ -946,18 +948,21 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
         if P_path_bar is not None:
             try:
                 if type(P_path_bar) == np.ndarray:
-                    Liq_Results = findLiq_MELTS(P_bar = P_path_bar[0], comp = bulk, melts = melts, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset, T_C_init = 1400)
+                    Liq_Results = findLiq_MELTS(P_bar = P_path_bar[0], comp = bulk, melts = melts, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset, T_C_init = T_initial_C)
                 else:
-                    Liq_Results = findLiq_MELTS(P_bar = P_path_bar, comp = bulk, melts = melts, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset, T_C_init = 1400)
+                    Liq_Results = findLiq_MELTS(P_bar = P_path_bar, comp = bulk, melts = melts, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset, T_C_init = T_initial_C)
             except:
                 return Results
         elif P_start_bar is not None:
             try:
-                Liq_Results = findLiq_MELTS(P_bar = P_start_bar, comp = bulk, melts = melts, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset, T_C_init = 1400)
+                Liq_Results = findLiq_MELTS(P_bar = P_start_bar, comp = bulk, melts = melts, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset, T_C_init = T_initial_C)
             except:
                 return Results
 
+        print(Liq_Results)
         T_start_C = Liq_Results['T_Liq'] + 0.1
+        if T_end_C is None and T_maxdrop_C is not None:
+            T_end_C = T_start_C - T_maxdrop_C
 
     else:
         if fO2_buffer is not None:
@@ -1155,6 +1160,15 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
             if Volume/Total_volume > Crystallinity_limit:
                 break
 
+        if phases is not None:
+            ll = 0
+            for p in phases:
+                if p in Results.keys():
+                    ll = ll + 1
+            
+            if ll == len(phases):
+                break
+
         melts = melts.addNodeAfter()
 
     return Results

PetThermoTools/Melting.py

@@ -171,8 +171,9 @@ def AdiabaticMelt(q, index, *, Model = None, comp_1 = None, comp_2 = None, comp_
         return
 
     if Model == "Holland":
-        import pyMAGEMINcalc as MM
-        Results = MM.AdiabaticDecompressionMelting(comp = comp_1, T_p_C = Tp_C, P_start_kbar = P_start_bar/1000, P_end_kbar = P_end_bar/1000, dp_kbar = dp_bar/1000, Frac = 0)
+        # import pyMAGEMINcalc as MM
+        # Results = MM.AdiabaticDecompressionMelting(comp = comp_1, T_p_C = Tp_C, P_start_kbar = P_start_bar/1000, P_end_kbar = P_end_bar/1000, dp_kbar = dp_bar/1000, Frac = 0)
+        print('Note that the ability to use MAGEMin to performed adiabatic decompression melting in PetThermoTools has been temporarily disabled. The underlying issue will be fixed soon and this funciton will once again become available.')
         q.put([Results, index])
         return
     

PetThermoTools/Path.py

@@ -201,7 +201,7 @@ def multi_path(cores = None, Model = None, bulk = None, comp = None, Frac_solid
 
     qs = []
     q = Queue()
-
+    
     # perform calculation if only 1 calculation is specified
     if One == 1:
         if Print_suppress is None:
@@ -374,6 +374,7 @@ def multi_path(cores = None, Model = None, bulk = None, comp = None, Frac_solid
             if Print_suppress is None:
                 print(" Complete (time taken = " + str(round(time.time() - s,2)) + " seconds)", end = "\n", flush = True)
 
+
         Results = {}
         Out = {}
         for i in range(len(qs)):
@@ -452,7 +453,6 @@ def multi_path(cores = None, Model = None, bulk = None, comp = None, Frac_solid
 
         #if "MELTS" in Model:
         Results = stich(Results, multi = True, Model = Model, Frac_fluid = Frac_fluid, Frac_solid = Frac_solid)
-
         
         for r in Results:
             i = int(r.split('=')[1].strip())
@@ -625,21 +625,41 @@ def path(q, index, *, Model = None, comp = None, Frac_solid = None, Frac_fluid =
         return
 
     if "MELTS" not in Model:
-        import julia
-        from julia.api import Julia
-        jl = Julia(compiled_modules=False)
-        from julia import MAGEMinCalc
-        # import pyMAGEMINcalc as MM
-        # try:
-            # Results = MM.path(Model = Model, comp = comp, Frac_solid = Frac_solid, Frac_fluid = Frac_fluid, T_C = T_C, T_path_C = T_path_C, T_start_C = T_start_C, T_end_C = T_end_C, dt_C = dt_C, P_bar = P_bar, P_path_bar = P_path_bar, P_start_bar = P_start_bar, P_end_bar = P_end_bar, dp_bar = dp_bar, find_liquidus = find_liquidus, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset)
+        # import julia
+        # from julia.api import Julia
+        # jl = Julia(compiled_modules=False)
+        # from julia import MAGEMinCalc
+        # # import pyMAGEMINcalc as MM
+        # # try:
+        #     # Results = MM.path(Model = Model, comp = comp, Frac_solid = Frac_solid, Frac_fluid = Frac_fluid, T_C = T_C, T_path_C = T_path_C, T_start_C = T_start_C, T_end_C = T_end_C, dt_C = dt_C, P_bar = P_bar, P_path_bar = P_path_bar, P_start_bar = P_start_bar, P_end_bar = P_end_bar, dp_bar = dp_bar, find_liquidus = find_liquidus, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset)
+        # if Frac_solid is None:
+        #     Frac_solid = False
+            
+        # Results = MAGEMinCalc.path(comp = comp, T_start_C = T_start_C, T_end_C = T_end_C, dt_C = dt_C,
+        #                             T_C = T_C, P_start_bar = P_start_bar, P_end_bar = P_end_bar, dp_bar = dp_bar,
+        #                             P_bar = P_bar, T_path_C = T_path_C, P_path_bar = P_path_bar, frac_xtal = Frac_solid,
+        #                             Model = Model, fo2_buffer = fO2_buffer, fo2_offset = fO2_offset, find_liquidus = find_liquidus)
+        # q.put([Results, index])
+
+        # import julia
+        from juliacall import Main as jl, convert as jlconvert
+
+        jl.seval("using MAGEMinCalc")
+
         if Frac_solid is None:
             Frac_solid = False
-            
-        Results = MAGEMinCalc.path(comp = comp, T_start_C = T_start_C, T_end_C = T_end_C, dt_C = dt_C,
-                                    T_C = T_C, P_start_bar = P_start_bar, P_end_bar = P_end_bar, dp_bar = dp_bar,
-                                    P_bar = P_bar, T_path_C = T_path_C, P_path_bar = P_path_bar, frac_xtal = Frac_solid,
-                                    Model = Model, fo2_buffer = fO2_buffer, fo2_offset = fO2_offset, find_liquidus = find_liquidus)
-        q.put([Results, index])
+
+        comp_julia = jl.seval("Dict")(comp)
+
+        Results = jl.MAGEMinCalc.path(
+            comp=comp_julia, T_start_C=T_start_C, T_end_C=T_end_C, dt_C=dt_C,
+            T_C=T_C, P_start_bar=P_start_bar, P_end_bar=P_end_bar, dp_bar=dp_bar,
+            P_bar=P_bar, T_path_C=T_path_C, P_path_bar=P_path_bar, frac_xtal=Frac_solid,
+            Model=Model, fo2_buffer=fO2_buffer, fo2_offset=fO2_offset, find_liquidus=find_liquidus
+        )
+        # Results = jl.pyconvert(dict, Results)
+        Results_df = dict(Results)
+        q.put([Results_df, index])
         # except:
         #     q.put([])
         # return

PetThermoTools/Plotting.py

@@ -131,12 +131,20 @@ def plot_surfaces(Results = None, P_bar = None, phases = None, H2O_Liq = None):
         a.set_xlabel('P (bars)')
         a.set_ylabel('T ($\degree$C)')
         for i in range(len(phases)):
-            if i == 0:
-                a.plot(P_bar, Results[phases[0]][0,0,:], '-r', linewidth = 2, label = phases[i])
-            if i == 1:
-                a.plot(P_bar, Results[phases[1]][0,0,:], '-b', linewidth = 2, label = phases[i])
-            if i == 2:
-                a.plot(P_bar, Results[phases[2]][0,0,:], '-k', linewidth = 2, label = phases[i])
+            try:
+                if i == 0:
+                    a.plot(P_bar, Results['Output'][phases[0]], '-r', linewidth = 2, label = phases[i])
+                if i == 1:
+                    a.plot(P_bar, Results['Output'][phases[1]], '-b', linewidth = 2, label = phases[i])
+                if i == 2:
+                    a.plot(P_bar, Results['Output'][phases[2]], '-k', linewidth = 2, label = phases[i])
+            except:
+                if i == 0:
+                    a.plot(P_bar, Results[phases[0]][0,0,:], '-r', linewidth = 2, label = phases[i])
+                if i == 1:
+                    a.plot(P_bar, Results[phases[1]][0,0,:], '-b', linewidth = 2, label = phases[i])
+                if i == 2:
+                    a.plot(P_bar, Results[phases[2]][0,0,:], '-k', linewidth = 2, label = phases[i])
 
         a.legend()
 
@@ -184,7 +192,11 @@ def residualT_plot(Results = None, P_bar = None, phases = None, H2O_Liq = None,
             for i in range(2):
                 for j in range(2):
                     a[i][j].set_title(Name[i,j])
-                    a[i][j].plot(P_bar, Results[m[i,j]][0,0,:], 'ok', markerfacecolor="b", label="original", markersize = 8)
+                    try:
+                        a[i][j].plot(P_bar, Results['Output'][m[i,j]], 'ok', markerfacecolor="b", label="original", markersize = 8)
+                    except:
+                        print("You are using the old find_mineral_saturation function.\n This will soon be removed, please transition to the mineral_cosaturation function.")
+                        a[i][j].plot(P_bar, Results[m[i,j]][0,0,:], 'ok', markerfacecolor="b", label="original", markersize = 8)
                     if interpolate is True:
                         if ~np.isnan(Results['CurveMin'][m[i,j]]['P_min']):
                             a[i][j].plot(Results['CurveMin'][m[i,j]]['P_new'], Results['CurveMin'][m[i,j]]['y_new'],

PetThermoTools/_version.py

@@ -5,4 +5,4 @@
 # 1) we don't load dependencies by storing it in __init__.py
 # 2) we can import it in setup.py for the same reason
 # 3) we can import it into your module
-__version__ = '0.2.31'
+__version__ = '0.2.33'

PetThermoTools-0.2.33.dist-info/LICENSE.txt

@@ -0,0 +1,16 @@
+LICENSE
+
+Copyright (c) [2025] [Matthew Gleeson]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+Special Clause on GUI Usage
+
+Use of PetThermoTools in graphical user interfaces (GUIs), including but not limited to applications that provide point-and-click access to PetThermoTools's functions, requires prior written permission from the author.
+
+This requirement exists because of a broader issue in the geoscience community: tools that wrap or interface with core scientific software often receive the bulk of citations, while foundational packages like PetThermoTools go unrecognized—particularly when journals impose citation limits. PetThermoTools represents a significant and ongoing labor investment. Responsible citation and acknowledgment are necessary to support its continued development and maintenance.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

{PetThermoTools-0.2.31.dist-info → PetThermoTools-0.2.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PetThermoTools
-Version: 0.2.31
+Version: 0.2.33
 Summary: PetThermoTools
 Home-page: https://github.com/gleesonm1/PetThermoTools
 Author: Matthew Gleeson

PetThermoTools-0.2.33.dist-info/RECORD

@@ -0,0 +1,20 @@
+PetThermoTools/Barom.py,sha256=zfRgGnqInXP1B5oG_k5ZMJH3cylHcQXWiBRz7YlQjkw,36119
+PetThermoTools/Compositions.py,sha256=65NzfduzWdfHJ8VmHBN1Cv7fMz7kF3QbDVLei-e4v00,1483
+PetThermoTools/GenFuncs.py,sha256=u2GWqH--Wmqd0WXHxfulEAatQb6uswjl1s9SyyoHSa8,16412
+PetThermoTools/Holland.py,sha256=udBFeVUyTBpSfLIhx7Hy6o0I8ApNCDvwU_gZa0diY5w,7251
+PetThermoTools/Installation.py,sha256=UfVOW1NZFdzMWPyID5u7t0KwvpJA0AqYohzidXIAwYs,6098
+PetThermoTools/Liq.py,sha256=2kdU8r00Y20khwvPvCvLr6P7y2HEOvCH2cwrF_qw5u8,35541
+PetThermoTools/MELTS.py,sha256=hqc5vSDwvnCyBwD7wbEOwemUNpDQGpsWdOOoVjNnMvE,72810
+PetThermoTools/Melting.py,sha256=h1-KchPFw5tI2xoOyNJUfVy_TJqTtcYiHtGuInIwzio,11017
+PetThermoTools/Path.py,sha256=FI_JkpCDXUVWsaKxA_PKOyKvXSzsQEBiLonGNiamcIM,33424
+PetThermoTools/Path_wrappers.py,sha256=_0pBs_cK2hICxAHkYxKXICUnUEBSiUg07-qhgBeuTdc,26555
+PetThermoTools/PhaseDiagrams.py,sha256=8S_BcqggBzfUbiCPcsJRWFBenGL4tcCevte3-ATQjQI,30884
+PetThermoTools/Plotting.py,sha256=IMYYusZy6REQATG9NI3dGlGs6h3vQ48aJHkZnHmSDDY,28924
+PetThermoTools/Saturation.py,sha256=XXY6fKVouQM3RLgQgXur4xSq7_uGp7bCw_k7NNlWYi8,14095
+PetThermoTools/__init__.py,sha256=PbiwQj_mNNEwuIZOLETmtMMshiXa50wjCA6mfvpOpOs,2393
+PetThermoTools/_version.py,sha256=i2Na-DPnshyTFid0Y6FmelIcA0OHEcYVuQdFt_mKzeI,296
+PetThermoTools-0.2.33.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
+PetThermoTools-0.2.33.dist-info/METADATA,sha256=MM-RsleOmZq3PfygLozR2VrdewAuBMezGJLwnGc9Km8,796
+PetThermoTools-0.2.33.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+PetThermoTools-0.2.33.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
+PetThermoTools-0.2.33.dist-info/RECORD,,

PetThermoTools-0.2.31.dist-info/RECORD

@@ -1,19 +0,0 @@
-PetThermoTools/Barom.py,sha256=RmFT7HQ2htKrrnzLNBU1HiVN88LU82Am3cEKByxo_6o,44439
-PetThermoTools/Compositions.py,sha256=65NzfduzWdfHJ8VmHBN1Cv7fMz7kF3QbDVLei-e4v00,1483
-PetThermoTools/GenFuncs.py,sha256=u2GWqH--Wmqd0WXHxfulEAatQb6uswjl1s9SyyoHSa8,16412
-PetThermoTools/Holland.py,sha256=udBFeVUyTBpSfLIhx7Hy6o0I8ApNCDvwU_gZa0diY5w,7251
-PetThermoTools/Installation.py,sha256=UfVOW1NZFdzMWPyID5u7t0KwvpJA0AqYohzidXIAwYs,6098
-PetThermoTools/Liq.py,sha256=I-vYp2i7CpQjzoo-nZ8gQNTP5jrao6pZtmkmwLtjodY,35043
-PetThermoTools/MELTS.py,sha256=-nkyo3yx7dZXVnRwZhlMRGCc5SkYSm1nP3qDbLDNNyY,72354
-PetThermoTools/Melting.py,sha256=iQpSXXDhwfEUTlHa80-XFK1lahb_VNrLW8ISbVCE8lY,10773
-PetThermoTools/Path.py,sha256=RChQYqDayqc0hVugmX3j3uE1x2BvWIfcINFqcqwrRxw,32642
-PetThermoTools/Path_wrappers.py,sha256=_0pBs_cK2hICxAHkYxKXICUnUEBSiUg07-qhgBeuTdc,26555
-PetThermoTools/PhaseDiagrams.py,sha256=8S_BcqggBzfUbiCPcsJRWFBenGL4tcCevte3-ATQjQI,30884
-PetThermoTools/Plotting.py,sha256=biM4QJFCH6xVDpK-nG2oAIGIFFJCzBt5Uez6XzTFiGY,28107
-PetThermoTools/Saturation.py,sha256=XXY6fKVouQM3RLgQgXur4xSq7_uGp7bCw_k7NNlWYi8,14095
-PetThermoTools/__init__.py,sha256=PbiwQj_mNNEwuIZOLETmtMMshiXa50wjCA6mfvpOpOs,2393
-PetThermoTools/_version.py,sha256=x3oJ2coFvekDMGQwrW7LzNxduPT9SxWIZWCKamBahjQ,296
-PetThermoTools-0.2.31.dist-info/METADATA,sha256=TDZlBVXnbinSw2bKIR_YvA9KJqR4w2XxlqSGVEe4klg,796
-PetThermoTools-0.2.31.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-PetThermoTools-0.2.31.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
-PetThermoTools-0.2.31.dist-info/RECORD,,