PetThermoTools 0.2.34__py3-none-any.whl → 0.2.36__py3-none-any.whl

PetThermoTools/Barom.py

@@ -11,46 +11,17 @@ from PetThermoTools.Plotting import *
 from PetThermoTools.Liq import *
 from PetThermoTools.MELTS import *
 from PetThermoTools.Path import *
-# try:
-#     from PetThermoTools.Holland import *
-# except:
-#     pass
 import multiprocessing
 from multiprocessing import Queue
 from multiprocessing import Process
 import time
-import sys
-from tqdm.notebook import tqdm, trange
 from scipy import interpolate
 from shapely.geometry import MultiPoint, Point, Polygon
 
-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):
@@ -127,7 +98,7 @@ def mineral_cosaturation(Model="MELTSv1.0.2", cores=int(np.floor(multiprocessing
                          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):
+                         find_min=True, fO2_buffer=None, fO2_offset=0.0, timeout = 90, multiprocesses = True):
 
     comp = bulk.copy()
     if H2O_Sat:
@@ -136,105 +107,100 @@ def mineral_cosaturation(Model="MELTSv1.0.2", cores=int(np.floor(multiprocessing
     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()
+    if multiprocesses:
+        index_in = np.arange(len(P_bar))
+        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)
+            non_empty_groups = [g for g in groups if g.size > 0]
+            groups = non_empty_groups
+
+            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, groups[i]))
+                p.start()
+
+            for p, q, group in processes:
+                try:
+                    res = q.get(timeout=timeout)
+                except:
+                    res = []
+                    idx_chunks = np.array([group[0]], dtype = int)
+                p.join(timeout = 2)
+                p.terminate()
 
-        for p, q in processes:
-            res = q.get(timeout=timeout)
-            p.join(timeout = 2)
-            p.terminate()
+                if len(res) > 0.0:
+                    idx_chunks, results = res
+                    combined_results.update(results)
 
-            idx_chunks, results = res
+                index_out = np.hstack((index_out, idx_chunks))
+    else:
+        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) 
+
+        if "MELTS" in Model:
+            for i in range(len(P_bar)):
+                results = {}
+                Results = 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,
+                        melts = melts
+                    )
+                results[f"index = {i}"] = Results
+                combined_results.update(results)
+        else:
+            if fO2_offset is None:
+                fO2_offset = 0.0
 
-            index_out = np.hstack((index_out, idx_chunks))
-            combined_results.update(results)
+            for i in range(len(P_bar)):
+                results = {}
+                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)
+                results[f"index = {i}"] = Results
+                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)
 
@@ -255,7 +221,7 @@ def mineral_cosaturation(Model="MELTSv1.0.2", cores=int(np.floor(multiprocessing
         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)
+        arr2[:, 3] = np.max(arr2[:,0:2], axis = 1)
 
         r_arr = np.hstack((arr,arr2))
 
@@ -431,6 +397,8 @@ def find_mineral_cosaturation(cores = None, Model = None, bulk = None, phases =
     Results: Dict
         Dictionary containing information regarding the saturation temperature of each phase and the residuals between the different phases
     '''
+    print('This function will be removed following the update to v0.3.0. Please switch to using the mineral_cosaturation() function')
+
     try:
         from meltsdynamic import MELTSdynamic
     except:

PetThermoTools/MELTS.py

@@ -1114,7 +1114,8 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
                 else:
                     melts.engine.calcEquilibriumState(2,0)
             except:
-                trail = False
+                if trail is not None:
+                    trail = False
                 # if trail is not None:
                 #     return Results, trail
                 # else:
@@ -1128,7 +1129,8 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
                 else:
                     melts.engine.calcEquilibriumState(3,0)
             except:
-                trail = False
+                if trail is not None:
+                    trail = False
                 # return Results
                 break
 
@@ -1136,7 +1138,8 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
             try:
                 melts.engine.calcEquilibriumState(4,0)
             except:
-                trail = False
+                if trail is not None:
+                    trail = False
                 # return Results
                 break
 
@@ -1156,7 +1159,8 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
         try:
             PhaseList = ['liquid1'] + melts.engine.solidNames
         except:
-            trail = False
+            if trail is not None:
+                trail = False
             # return Results
             break
 

PetThermoTools/Path.py

@@ -122,6 +122,7 @@ def multi_path(cores = None, Model = None, bulk = None, comp = None, Frac_solid
     except:
         Warning('alphaMELTS for Python files are not on the python path. \n Please add these files to the path running \n import sys \n sys.path.append(r"insert_your_path_to_melts_here") \n You are looking for the location of the meltsdynamic.py file')
 
+    timeout_main = timeout
 
     if Frac_solid is False:
         Frac_solid = None
@@ -302,157 +303,143 @@ def multi_path(cores = None, Model = None, bulk = None, comp = None, Frac_solid
         elif type(fO2_offset) == float or type(fO2_offset) == int:
             fO2_offset = np.zeros(int(L)) + fO2_offset
 
-        for j in tqdm(range(len(Group))):
-            ps = []
+        index_in = np.arange(int(L))
+        combined_results = {}
+        index_out = np.array([], dtype=int)
 
-            if Print_suppress is None:
-                print("Running " + Model + " calculations " + str(int(cores*j)) + " to " + str(int(cores*j) + Group[j] - 1) + " ...", end = "", flush = True)
-                s = time.time()
+        while len(index_out) < len(index_in):
+            index = np.setdiff1d(index_in, index_out)
+            groups = np.array_split(index, cores)
+            non_empty_groups = [g for g in groups if g.size > 0]
+            groups = non_empty_groups
 
-            for i in range(int(cores*j), int(cores*j + Group[j])):
-                if type(comp) == dict:
-                    p = Process(target = path, args = (q, i),
+            if len(groups[0])< 15:
+                timeout = len(groups[0])*timeout_main
+            else:
+                timeout = 15*timeout_main
+                
+            processes = []
+            Start = time.time()
+            for i in range(len(groups)):
+                q = Queue()
+                p = Process(target = path_multi, args = (q, groups[i]),
                                 kwargs = {'Model': Model, 'comp': comp, 'Frac_solid': Frac_solid, 'Frac_fluid': Frac_fluid,
-                                        'T_C': T_C[i], 'T_path_C': T_path_C[i], 'T_start_C': T_start_C[i], 'T_end_C': T_end_C[i], 'dt_C': dt_C[i],
-                                        'P_bar': P_bar[i], 'P_path_bar': P_path_bar[i], 'P_start_bar': P_start_bar[i], 'P_end_bar': P_end_bar[i], 'dp_bar': dp_bar[i],
-                                        'isenthalpic': isenthalpic, 'isentropic': isentropic, 'isochoric': isochoric, 'find_liquidus': find_liquidus,
-                                        'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset[i], 'fluid_sat': fluid_sat, 'Crystallinity_limit': Crystallinity_limit,
-                                        'Suppress': Suppress, 'Suppress_except': Suppress_except})
-                else:
-                    p = Process(target = path, args = (q, i),
-                                kwargs = {'Model': Model, 'comp': comp.loc[i].to_dict(), 'Frac_solid': Frac_solid, 'Frac_fluid': Frac_fluid,
-                                        'T_C': T_C[i], 'T_path_C': T_path_C[i], 'T_start_C': T_start_C[i], 'T_end_C': T_end_C[i], 'dt_C': dt_C[i],
-                                        'P_bar': P_bar[i], 'P_path_bar': P_path_bar[i], 'P_start_bar': P_start_bar[i], 'P_end_bar': P_end_bar[i], 'dp_bar': dp_bar[i],
+                                        '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,
                                         'isenthalpic': isenthalpic, 'isentropic': isentropic, 'isochoric': isochoric, 'find_liquidus': find_liquidus,
-                                        'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset[i], 'fluid_sat': fluid_sat, 'Crystallinity_limit': Crystallinity_limit,
+                                        'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset, 'fluid_sat': fluid_sat, 'Crystallinity_limit': Crystallinity_limit,
                                         'Suppress': Suppress, 'Suppress_except': Suppress_except})
-
-                ps.append(p)
+                
+                processes.append((p, q, groups[i]))
                 p.start()
 
-            if timeout is None:
-                TIMEOUT = 240
-            else:
-                TIMEOUT = timeout
-
-            start = time.time()
-            first = True
-            for p in ps:
-                if time.time() - start < TIMEOUT - 10:
-                    try:
-                        ret = q.get(timeout = TIMEOUT - (time.time()-start) + 10)
-                    except:
-                        ret = []
-                else:
-                    if first == True:
-                        print('Timeout Reached - this likely indicates the calculation failed. \n You can try increasing the timeout limit using the "timeout" kwarg.')
-                        first = False
-                    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)
+            for p, q, group in processes:
+                try:
+                    if time.time() - Start < timeout + 5:
+                        res = q.get(timeout=timeout)
                     else:
-                        p.terminate()
-                        p.join(5)
-                else:
-                    p.join()
-                    p.terminate()
+                        res = q.get(timeout=10)
+                except:
+                    res = []
+                    idx_chunks = np.array([group[0]], dtype = int)
 
-            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)):
-            if len(qs[i]) > 0:
-                Res, index = qs[i]
-                # if label is None:
-                Results['index = ' + str(index)] = Res
-                # elif label == "P" or label == "pressure" or label == "P_bar":
-                #     Out[str(round(Res['Conditions']['pressure'].loc[0]))] = Res
-                # elif label == "water" or label == "H2O" or label == "H2O_Liq":
-                #     if H2O_Liq is not None:
-                #         Out[str(round(H2O_Liq[index], 2))] = Res
-                #     else:
-                #         Out[str(round(bulk.loc[index, "H2O_Liq"], 2))] = Res
-                # elif label == "carbon" or label == "CO2":
-                #     Out[str(round(Res['liquid1']['CO2'].loc[0], 2))] = Res
-                # elif label == "oxygen fugacity" or label == "fO2":
-                #     Out[str(round(fO2_offset[index], 2))] = Res
-                # elif label == "Fe redox" or label == "Fe3Fet" or label == "Fe3Fet_Liq":
-                #     Out[str[round(Res['liquid1']['FeO'].loc[0]/(Res['liquid1']['FeO'].loc[0] + (71.844/(159.69/2))*Res['liquid1']['Fe2O3'].loc[0]),2)]] = Res
-                # elif label in list(comp.keys()):
-                #     Results[str(comp[label].loc[index])] = Res
-
-        # if label == "P" or label == "pressure" or label == "P_bar":
-        #     # A = Out.copy()
-        #     # B = [float(x) for x in A]
-        #     O = sorted(Out)
-        #     for o in O:
-        #         # if o % 1 == 0:
-        #         #     o = int(o)
-        #         Results['P = ' + o + ' bars'] = Out[o]
-
-        # if label == "water" or label == "H2O" or label == "H2O_Liq":
-        #     # A = Out.copy()
-        #     # B = [float(x) for x in A]
-        #     O = sorted(Out)
-        #     for o in O:
-        #         # if o % 1 == 0:
-        #         #     o = int(o)
-        #         Results['H2O_i = ' + o + ' wt%'] = Out[o]
-
-        # # if label == "carbon" or label == "CO2":
-        # #     # A = Out.copy()
-        # #     # B = [float(x) for x in A]
-        # #     O = sorted(B)
-        # #     for o in O:
-        # #         # if o % 1 == 0:
-        # #         #     o = int(o)
-        # #         Results['CO2 = ' + str(o) + ' wt%'] = Out[str[o]]
-
-        # if label == "oxygen fugacity" or label == "fO2":
-        #     # A = Out.copy()
-        #     # B = [float(x) for x in A]
-        #     O = sorted(B)
-        #     for o in O:
-        #         # if o % 1 == 0:
-        #         #     o = int(o)
-
-        #         # if o > 0.0:
-        #         #     Results[fO2_buffer + ' +' + str(o)] = out[str(o)]
-        #         # else:
-        #         Results[fO2_buffer + ' ' + str(o)] = Out[str[o]]
-
-        # if label == "Fe redox" or label == "Fe3Fet_Liq" or label == 'Fe3Fet':
-        #     # A = Out.copy()
-        #     # B = [float(x) for x in A]
-        #     O = sorted(B)
-        #     for o in O:
-        #         # if o % 1 == 0:
-        #         #     o = int(o)
-        #         Results['Fe3/Fet = ' + str(o)] = Out[str[o]]
-
-        # if print_label is not None:
-        #     print(Results.keys())
+                p.join(timeout = 2)
+                p.terminate()
 
+                if len(res) > 0.0:
+                    idx_chunks, results = res
+                    combined_results.update(results)
+
+                index_out = np.hstack((index_out, idx_chunks))
+
+            print(f"Completed {100*len(index_out)/len(index_in)} %")
+
+        results = combined_results
+
+        Results = stich(Res=results, multi=True, Model=Model, Frac_fluid = Frac_fluid, Frac_solid = Frac_solid)
+
+        # for j in tqdm(range(len(Group))):
+        #     ps = []
+
+        #     if Print_suppress is None:
+        #         print("Running " + Model + " calculations " + str(int(cores*j)) + " to " + str(int(cores*j) + Group[j] - 1) + " ...", end = "", flush = True)
+        #         s = time.time()
+
+        #     for i in range(int(cores*j), int(cores*j + Group[j])):
+        #         if type(comp) == dict:
+        #             p = Process(target = path, args = (q, i),
+        #                         kwargs = {'Model': Model, 'comp': comp, 'Frac_solid': Frac_solid, 'Frac_fluid': Frac_fluid,
+        #                                 'T_C': T_C[i], 'T_path_C': T_path_C[i], 'T_start_C': T_start_C[i], 'T_end_C': T_end_C[i], 'dt_C': dt_C[i],
+        #                                 'P_bar': P_bar[i], 'P_path_bar': P_path_bar[i], 'P_start_bar': P_start_bar[i], 'P_end_bar': P_end_bar[i], 'dp_bar': dp_bar[i],
+        #                                 'isenthalpic': isenthalpic, 'isentropic': isentropic, 'isochoric': isochoric, 'find_liquidus': find_liquidus,
+        #                                 'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset[i], 'fluid_sat': fluid_sat, 'Crystallinity_limit': Crystallinity_limit,
+        #                                 'Suppress': Suppress, 'Suppress_except': Suppress_except})
+        #         else:
+        #             p = Process(target = path, args = (q, i),
+        #                         kwargs = {'Model': Model, 'comp': comp.loc[i].to_dict(), 'Frac_solid': Frac_solid, 'Frac_fluid': Frac_fluid,
+        #                                 'T_C': T_C[i], 'T_path_C': T_path_C[i], 'T_start_C': T_start_C[i], 'T_end_C': T_end_C[i], 'dt_C': dt_C[i],
+        #                                 'P_bar': P_bar[i], 'P_path_bar': P_path_bar[i], 'P_start_bar': P_start_bar[i], 'P_end_bar': P_end_bar[i], 'dp_bar': dp_bar[i],
+        #                                 'isenthalpic': isenthalpic, 'isentropic': isentropic, 'isochoric': isochoric, 'find_liquidus': find_liquidus,
+        #                                 'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset[i], 'fluid_sat': fluid_sat, 'Crystallinity_limit': Crystallinity_limit,
+        #                                 'Suppress': Suppress, 'Suppress_except': Suppress_except})
+
+        #         ps.append(p)
+        #         p.start()
+
+        #     if timeout is None:
+        #         TIMEOUT = 240
+        #     else:
+        #         TIMEOUT = timeout
+
+        #     start = time.time()
+        #     first = True
+        #     for p in ps:
+        #         if time.time() - start < TIMEOUT - 10:
+        #             try:
+        #                 ret = q.get(timeout = TIMEOUT - (time.time()-start) + 10)
+        #             except:
+        #                 ret = []
+        #         else:
+        #             if first == True:
+        #                 print('Timeout Reached - this likely indicates the calculation failed. \n You can try increasing the timeout limit using the "timeout" kwarg.')
+        #                 first = False
+        #             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()
+
+        #     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)):
+        #     if len(qs[i]) > 0:
+        #         Res, index = qs[i]
+        #         Results['index = ' + str(index)] = Res
 
         #if "MELTS" in Model:
-        Results = stich(Results, multi = True, Model = Model, Frac_fluid = Frac_fluid, Frac_solid = Frac_solid)
+        # 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())
@@ -502,6 +489,99 @@ def label_results(Result,label):
     
     return new_out
 
+def path_multi(q, index, *, 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,
+            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 = None, Suppress_except = None, trail = True):
+    results = {}
+    idx = []
+
+    if len(index) > 15:
+        index = index[:15]
+    
+    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")
+  
+
+    for i in index:
+        try:
+            if "MELTS" in Model:
+                if type(comp) == dict:
+                    Results, tr = path_MELTS(Model = Model, comp = comp, Frac_solid = Frac_solid, Frac_fluid = Frac_fluid, 
+                                            T_initial_C = 1400, T_C = T_C[i], T_path_C = T_path_C[i], T_start_C = T_start_C[i], 
+                                            T_end_C = T_end_C[i], dt_C = dt_C[i], P_bar = P_bar[i], P_path_bar = P_path_bar[i], 
+                                            P_start_bar = P_start_bar[i], P_end_bar = P_end_bar[i], dp_bar = dp_bar[i], 
+                                            isenthalpic = isenthalpic, isentropic = isentropic, isochoric = isochoric, 
+                                            find_liquidus = find_liquidus, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset[i], 
+                                            fluid_sat = fluid_sat, Crystallinity_limit = Crystallinity_limit, Suppress = Suppress, 
+                                            Suppress_except=Suppress_except, trail = trail, melts = melts)
+                else:
+                    Results, tr = path_MELTS(Model = Model, comp = comp.loc[i].to_dict(), Frac_solid = Frac_solid, Frac_fluid = Frac_fluid, 
+                                            T_initial_C = 1400, T_C = T_C[i], T_path_C = T_path_C[i], T_start_C = T_start_C[i], 
+                                            T_end_C = T_end_C[i], dt_C = dt_C[i], P_bar = P_bar[i], P_path_bar = P_path_bar[i], 
+                                            P_start_bar = P_start_bar[i], P_end_bar = P_end_bar[i], dp_bar = dp_bar[i], 
+                                            isenthalpic = isenthalpic, isentropic = isentropic, isochoric = isochoric, 
+                                            find_liquidus = find_liquidus, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset[i], 
+                                            fluid_sat = fluid_sat, Crystallinity_limit = Crystallinity_limit, Suppress = Suppress, 
+                                            Suppress_except=Suppress_except, trail = trail, melts = melts)
+            else:
+                if fO2_offset[i] is None:
+                    fO2_offset[i] = 0.0
+
+                if Frac_solid is None:
+                    Frac_solid = False
+
+                if type(comp) == dict:
+                    comp_julia = jl.seval("Dict")(comp) 
+                else:
+                    comp_new = comp.loc[i].to_dict()
+                    comp_julia = jl.seval("Dict")(comp_new)
+            
+                # Results_df = jl.MAGEMinCalc.path(Model = Model, comp=comp_julia, T_start_C = T_start_C[i], T_end_C = T_end_C[i], dt_C=dt_C,
+                #                                 T_C = T_C[i], T_path_C = T_path_C[i], P_start_bar = P_start_bar[i], P_end_bar = P_end_bar[i],
+                #                                 dp_bar = dp_bar[i], P_bar = P_bar[i], P_path_bar = P_path_bar[i], frac_xtal = Frac_solid,
+                #                                 fo2_buffer = fO2_buffer, fo2_offset = fO2_offset[i], find_liquidus = find_liquidus)
+                    
+                Results_df = jl.MAGEMinCalc.path(
+                                    comp=comp_julia, T_start_C=T_start_C[i], T_end_C=T_end_C[i], dt_C=dt_C[i],
+                                    T_C=T_C[i], P_start_bar=P_start_bar[i], P_end_bar=P_end_bar[i], dp_bar=dp_bar[i],
+                                    P_bar=P_bar[i], T_path_C=T_path_C[i], P_path_bar=P_path_bar[i], frac_xtal=Frac_solid,
+                                    Model=Model, fo2_buffer=fO2_buffer, fo2_offset=fO2_offset[i], find_liquidus=find_liquidus
+                                )
+                
+                Results = dict(Results_df)
+                
+                tr = True
+
+            idx.append(i)
+
+
+            results[f"index = {i}"] = Results
+
+            if tr is False:
+                break
+        except:
+            idx.append(i)
+            break
+
+    q.put([idx, results])
+    return
+
 
 def path(q, index, *, 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, 
@@ -650,11 +730,14 @@ def path(q, index, *, Model = None, comp = None, Frac_solid = None, Frac_fluid =
             Frac_solid = False
 
         comp_julia = jl.seval("Dict")(comp)
+        # T_path_C = T_path_C.tolist()
+        T_path_C_julia = jlconvert(jl.Vector[jl.Float64], T_path_C)
+        P_path_bar_julia = jlconvert(jl.Vector[jl.Float64], P_path_bar)
 
         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,
+            P_bar=P_bar, T_path_C=T_path_C_julia, P_path_bar=P_path_bar_julia, frac_xtal=Frac_solid,
             Model=Model, fo2_buffer=fO2_buffer, fo2_offset=fO2_offset, find_liquidus=find_liquidus
         )
         # Results = jl.pyconvert(dict, Results)

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.34'
+__version__ = '0.2.36'

{PetThermoTools-0.2.34.dist-info → PetThermoTools-0.2.36.dist-info}/METADATA

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

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

@@ -1,20 +1,20 @@
-PetThermoTools/Barom.py,sha256=chxLZCCu0I8PLw0-TWsJboxiRqQJufKyVEVLk35dzVo,40494
+PetThermoTools/Barom.py,sha256=CXjwCb7KpQG8x7IhewCLTfqoJ02s4Ott3NwDcGQMWtQ,40221
 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=CjUOJSUEoq4yXEojl77HgCj7aewhFDeSGt4ZGk3L3vs,73688
+PetThermoTools/MELTS.py,sha256=DeTM8j2fJ5dAw_2DVCGfgh1R_lQB4Z5rLopKSJ1Q5xQ,73852
 PetThermoTools/Melting.py,sha256=h1-KchPFw5tI2xoOyNJUfVy_TJqTtcYiHtGuInIwzio,11017
-PetThermoTools/Path.py,sha256=FI_JkpCDXUVWsaKxA_PKOyKvXSzsQEBiLonGNiamcIM,33424
+PetThermoTools/Path.py,sha256=3jzojfIefiYbSJQ3aDtjk5YDjbsGCS5OgGoR5_R-gXQ,38411
 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=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,,
+PetThermoTools/_version.py,sha256=QMMdJR5-U4I1DZsdoQ1JdfCcA4AfdgUeqgFymIkCgHM,296
+PetThermoTools-0.2.36.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
+PetThermoTools-0.2.36.dist-info/METADATA,sha256=0mexGlH4AM6Inj69yfCSBZ03NBgCj4t9qN122iLoqR0,796
+PetThermoTools-0.2.36.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+PetThermoTools-0.2.36.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
+PetThermoTools-0.2.36.dist-info/RECORD,,