PetThermoTools 0.2.32__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/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/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.32'
+__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.32.dist-info → PetThermoTools-0.2.33.dist-info}/METADATA

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

{PetThermoTools-0.2.32.dist-info → PetThermoTools-0.2.33.dist-info}/RECORD

@@ -1,19 +1,20 @@
-PetThermoTools/Barom.py,sha256=RmFT7HQ2htKrrnzLNBU1HiVN88LU82Am3cEKByxo_6o,44439
+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=-nkyo3yx7dZXVnRwZhlMRGCc5SkYSm1nP3qDbLDNNyY,72354
+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=biM4QJFCH6xVDpK-nG2oAIGIFFJCzBt5Uez6XzTFiGY,28107
+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=Dx2nyXCP2anL0ePIK0yaL-9dVQUNLwN_Y5sjqdoNjU0,296
-PetThermoTools-0.2.32.dist-info/METADATA,sha256=bzOGZMsHROBRHP9DrgSejdN3d8YyMbaYSX9Pt9yn5Ho,796
-PetThermoTools-0.2.32.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-PetThermoTools-0.2.32.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
-PetThermoTools-0.2.32.dist-info/RECORD,,
+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,,