PetThermoTools 0.2.32__py3-none-any.whl → 0.2.34__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,357 @@ 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
+
+import numpy as np
+import pandas as pd
+from joblib import Parallel, delayed
+import multiprocessing
+import time
+        
+def path_4_saturation(q, index, *, Model = None, P_bar = None, comp = None, T_maxdrop_C = None, dt_C = None, T_initial_C = None, fO2_buffer = None,
+                      fO2_offset = 0.0, H2O_Sat = None, phases = None):
+    if "MELTS" in Model:
+        Results = path_MELTS(P_bar = P_bar,
+                Model=Model,
+                comp=comp,
+                T_maxdrop_C=T_maxdrop_C,
+                dt_C=dt_C,
+                T_initial_C=T_initial_C,
+                find_liquidus=True,
+                fO2_buffer=fO2_buffer,
+                fO2_offset=fO2_offset,
+                fluid_sat=H2O_Sat,
+                Suppress=['rutile', 'tridymite'],
+                phases=phases
+            )
+        q.put([index, Results])
+    return
+
+def path_4_saturation_multi(q, index, *, Model = None, P_bar = None, comp = None, T_maxdrop_C = None, dt_C = None, T_initial_C = None, fO2_buffer = None,
+                      fO2_offset = 0.0, H2O_Sat = None, phases = None):
+    results = {}
+    idx = []
+    
+    if "MELTS" in Model:
+        from meltsdynamic import MELTSdynamic
+
+        if Model is None or Model == "MELTSv1.0.2":
+            melts = MELTSdynamic(1)
+        elif Model == "pMELTS":
+            melts = MELTSdynamic(2)
+        elif Model == "MELTSv1.1.0":
+            melts = MELTSdynamic(3)
+        elif Model == "MELTSv1.2.0":
+            melts = MELTSdynamic(4)
+    else:
+        from juliacall import Main as jl, convert as jlconvert
+
+        jl.seval("using MAGEMinCalc")
+
+        comp_julia = jl.seval("Dict")(comp)   
+
+    for i in index:
+        # try:
+        if "MELTS" in Model:
+            Results, tr = path_MELTS(P_bar = P_bar[i],
+                    Model=Model,
+                    comp=comp,
+                    T_maxdrop_C=T_maxdrop_C,
+                    dt_C=dt_C,
+                    T_initial_C=T_initial_C,
+                    find_liquidus=True,
+                    fO2_buffer=fO2_buffer,
+                    fO2_offset=fO2_offset,
+                    fluid_sat=H2O_Sat,
+                    Suppress=['rutile', 'tridymite'],
+                    phases=phases,
+                    trail = True,
+                    melts = melts
+                )
+        else:
+            if fO2_offset is None:
+                fO2_offset = 0.0
+
+            Results_df = jl.MAGEMinCalc.path(
+                                    comp=comp_julia, dt_C=dt_C,
+                                    P_bar=P_bar[i], T_min_C = T_maxdrop_C,            
+                                    Model=Model, fo2_buffer=fO2_buffer, 
+                                    fo2_offset=fO2_offset, find_liquidus=True,
+                                    frac_xtal = False
+                                    )
+            
+            Results = dict(Results_df)
+            
+            tr = True
+
+        idx.append(i)
+
+
+        results[f"index = {i}"] = Results
+
+        if tr is False:
+            break
+        # except:
+        #     idx.append(i)
+
+    q.put([idx, results])
+    return
+
+def mineral_cosaturation(Model="MELTSv1.0.2", cores=int(np.floor(multiprocessing.cpu_count())), 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)
+
+    index_in = np.arange(len(P_bar))
+    # index_in = index
+    combined_results = {}
+    index_out = np.array([], dtype=int)
+
+    while len(index_out) < len(index_in):
+        index = np.setdiff1d(index_in, index_out)
+        groups = np.array_split(index, cores)
+
+        processes = []
+        for i in range(len(groups)):
+            q = Queue()
+            p = Process(target = path_4_saturation_multi, args = (q, groups[i]),
+                        kwargs = {'Model': Model, 'comp': comp,
+                        'T_initial_C': T_initial_C, 'T_maxdrop_C': T_maxdrop_C,
+                        'dt_C': dt_C, 'P_bar': P_bar, 'phases': phases,
+                        'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset})
+            
+            processes.append((p, q))
+            p.start()
+
+        for p, q in processes:
+            res = q.get(timeout=timeout)
+            p.join(timeout = 2)
+            p.terminate()
+
+            idx_chunks, results = res
+
+            index_out = np.hstack((index_out, idx_chunks))
+            combined_results.update(results)
+
+    results = combined_results
+    # results = {}
+    # if len(P_bar) > 1:
+    #     A = len(P_bar)//cores
+    #     B = len(P_bar) % cores
+
+    # if A > 0:
+    #     Group = np.zeros(A) + cores
+    #     if B > 0:
+    #         Group = np.append(Group, B)
+    # else:
+    #     Group = np.array([B])
+
+    # # initialise queue
+    # qs = []
+    # q = Queue()
+
+
+    # # run calculations
+    # for k in range(len(Group)):
+    #     ps = []
+
+    #     for kk in range(int(cores*k), int(cores*k + Group[k])):
+    #         p = Process(target = path_4_saturation, args = (q, kk),
+    #                     kwargs = {'Model': Model, 'comp': comp,
+    #                     'T_initial_C': T_initial_C, 'T_maxdrop_C': T_maxdrop_C,
+    #                     'dt_C': dt_C, 'P_bar': P_bar[kk], 'phases': phases,
+    #                     'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset})
+            
+    #         ps.append(p)
+    #         p.start()
+
+    #     start = time.time()
+    #     for p in ps:
+    #         if time.time() - start < timeout - 10:
+    #             try:
+    #                 ret = q.get(timeout = timeout - (time.time()-start) + 10)
+    #             except:
+    #                 ret = []
+    #         else:
+    #             try:
+    #                 ret = q.get(timeout = 10)
+    #             except:
+    #                 ret = []
+
+    #         qs.append(ret)
+
+    #     TIMEOUT = 5
+    #     start = time.time()
+    #     for p in ps:
+    #         if p.is_alive():
+    #             while time.time() - start <= TIMEOUT:
+    #                 if not p.is_alive():
+    #                     p.join()
+    #                     p.terminate()
+    #                     break
+    #                 time.sleep(.1)
+    #             else:
+    #                 p.terminate()
+    #                 p.join(5)
+    #         else:
+    #             p.join()
+    #             p.terminate()
+
+    # for kk in range(len(qs)):
+    #     if len(qs[kk]) > 0:
+    #         index, res = qs[kk]
+    #         results[f"P = {P_bar[index]:.2f} bars"] = res.copy()
+
+    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 = 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 +972,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, trail = None, melts = 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.
 
@@ -882,6 +884,8 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
 
     '''
     Results = {}
+    if trail is not None:
+        trail = False
 
     if comp is None:
         raise Exception("No composition specified")
@@ -896,16 +900,17 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
     if T_path_C is None and T_start_C is None and find_liquidus is None:
         raise Exception("Starting temperature must be specified or the liquidus must be found")
 
-    from meltsdynamic import MELTSdynamic
+    if melts is None:
+        from meltsdynamic import MELTSdynamic
 
-    if Model is None or Model == "MELTSv1.0.2":
-        melts = MELTSdynamic(1)
-    elif Model == "pMELTS":
-        melts = MELTSdynamic(2)
-    elif Model == "MELTSv1.1.0":
-        melts = MELTSdynamic(3)
-    elif Model == "MELTSv1.2.0":
-        melts = MELTSdynamic(4)
+        if Model is None or Model == "MELTSv1.0.2":
+            melts = MELTSdynamic(1)
+        elif Model == "pMELTS":
+            melts = MELTSdynamic(2)
+        elif Model == "MELTSv1.1.0":
+            melts = MELTSdynamic(3)
+        elif Model == "MELTSv1.2.0":
+            melts = MELTSdynamic(4)
 
     bulk = [comp['SiO2_Liq'], comp['TiO2_Liq'], comp['Al2O3_Liq'], comp['Fe3Fet_Liq']*((159.59/2)/71.844)*comp['FeOt_Liq'], comp['Cr2O3_Liq'], (1- comp['Fe3Fet_Liq'])*comp['FeOt_Liq'], comp['MnO_Liq'], comp['MgO_Liq'], 0.0, 0.0, comp['CaO_Liq'], comp['Na2O_Liq'], comp['K2O_Liq'], comp['P2O5_Liq'], comp['H2O_Liq'], comp['CO2_Liq'], 0.0, 0.0, 0.0]
     bulk = list(100*np.array(bulk)/np.sum(bulk))
@@ -946,18 +951,27 @@ 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
+                if trail is not None:
+                    return Results, trail
+                else:
+                    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
+                if trail is not None:
+                    return Results, trail
+                else:
+                    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:
@@ -1034,6 +1048,10 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
     Results['liquid1_prop'] = pd.DataFrame(data = np.zeros((length, 4)), columns = ['h', 'mass', 'v', 'rho'])
 
     for i in range(length):
+        if i == 1:
+            if trail is not None:
+                trail = True
+
         if type(T) == np.ndarray:
             melts.engine.temperature = T[i]
         if type(P) == np.ndarray:
@@ -1082,7 +1100,11 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
                 else:
                     melts.engine.calcEquilibriumState(1,0)
             except:
-                return Results
+                trail = False
+                # if trail is not None:
+                #     return Results, trail
+                # else:
+                #     return Results
                 break
 
         if isenthalpic is not None:
@@ -1092,7 +1114,11 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
                 else:
                     melts.engine.calcEquilibriumState(2,0)
             except:
-                # return Results
+                trail = False
+                # if trail is not None:
+                #     return Results, trail
+                # else:
+                #     return Results
                 break
 
         if isentropic is not None:
@@ -1102,6 +1128,7 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
                 else:
                     melts.engine.calcEquilibriumState(3,0)
             except:
+                trail = False
                 # return Results
                 break
 
@@ -1109,6 +1136,7 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
             try:
                 melts.engine.calcEquilibriumState(4,0)
             except:
+                trail = False
                 # return Results
                 break
 
@@ -1128,7 +1156,8 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
         try:
             PhaseList = ['liquid1'] + melts.engine.solidNames
         except:
-            return Results
+            trail = False
+            # return Results
             break
 
         for phase in PhaseList:
@@ -1155,9 +1184,22 @@ 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
+    
+    if trail is not None:
+        return Results, trail
+    else:
+        return Results
 
 def findSatPressure_MELTS_multi(Model = None, comp = None, fO2_buffer = None, fO2_offset = None, P_bar = None, T_fixed_C = None):
     out = pd.DataFrame(columns = ['Sample_ID_Liq', 'SiO2_Liq', 'TiO2_Liq', 'Al2O3_Liq', 'Cr2O3_Liq', 'FeOt_Liq', 'MnO_Liq', 'MgO_Liq', 'CaO_Liq', 'Na2O_Liq', 'K2O_Liq', 'P2O5_Liq', 'H2O_Liq', 'CO2_Liq', 'Fe3Fet_Liq', 'P_bar', 'T_Liq'])

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.34'

PetThermoTools-0.2.34.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.34.dist-info}/METADATA

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

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

@@ -1,19 +1,20 @@
-PetThermoTools/Barom.py,sha256=RmFT7HQ2htKrrnzLNBU1HiVN88LU82Am3cEKByxo_6o,44439
+PetThermoTools/Barom.py,sha256=chxLZCCu0I8PLw0-TWsJboxiRqQJufKyVEVLk35dzVo,40494
 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=CjUOJSUEoq4yXEojl77HgCj7aewhFDeSGt4ZGk3L3vs,73688
 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=ZyVKd7JEm_88aeNoezRSEHfFgAtOuHaYQWt8wmb4mgc,296
+PetThermoTools-0.2.34.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
+PetThermoTools-0.2.34.dist-info/METADATA,sha256=okQdLGfhCpo2f211FXt6szwCr2KrRHpqxAVKSl6kPec,796
+PetThermoTools-0.2.34.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+PetThermoTools-0.2.34.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
+PetThermoTools-0.2.34.dist-info/RECORD,,