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

PetThermoTools/Barom.py

@@ -11,50 +11,94 @@ 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
+import multiprocessing
+import time
 
+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
 
-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,
+        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):
+                         find_min=True, fO2_buffer=None, fO2_offset=0.0, timeout = 90, multiprocesses = True):
 
     comp = bulk.copy()
     if H2O_Sat:
@@ -63,33 +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)
 
-    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)
+    combined_results = {}
+    if multiprocesses:
+        index_in = np.arange(len(P_bar))
+        index_out = np.array([], dtype=int)
 
-    results = {}
-    with concurrent.futures.ProcessPoolExecutor(max_workers=cores) as executor:
-        futures = {executor.submit(run_partial, p): i for i, p in enumerate(P_bar)}
+        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
 
-        done, not_done = concurrent.futures.wait(
-            futures.keys(), timeout=timeout, return_when=concurrent.futures.ALL_COMPLETED
-        )
+            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 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"] = {}
+                if len(res) > 0.0:
+                    idx_chunks, results = res
+                    combined_results.update(results)
 
-        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
+                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
+
+            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 = stich(Res=results, multi=True, Model=Model)
 
@@ -110,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))
 
@@ -131,7 +242,7 @@ def mineral_cosaturation(Model="MELTSv1.0.2", cores=int(np.floor(multiprocessing
 
         arr[:,3] = np.abs(arr[:,1] - arr[:,2])
 
-        out = pd.DataFrame(data = r_arr, columns = columns)
+        out = pd.DataFrame(data = arr, columns = columns)
         out = out.sort_values('P_bar').reset_index(drop=True)
 
     if find_min:
@@ -286,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

@@ -808,7 +808,7 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = 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, phases=None):
+               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.
 
@@ -884,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")
@@ -898,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))
@@ -952,12 +955,18 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
                 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 = 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 = 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
@@ -1039,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:
@@ -1087,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:
@@ -1097,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:
@@ -1107,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
 
@@ -1114,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
 
@@ -1133,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:
@@ -1171,7 +1195,11 @@ def path_MELTS(Model = None, comp = None, Frac_solid = None, Frac_fluid = None,
 
         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/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, 

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.33'
+__version__ = '0.2.35'

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

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

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

@@ -1,20 +1,20 @@
-PetThermoTools/Barom.py,sha256=zfRgGnqInXP1B5oG_k5ZMJH3cylHcQXWiBRz7YlQjkw,36119
+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=hqc5vSDwvnCyBwD7wbEOwemUNpDQGpsWdOOoVjNnMvE,72810
+PetThermoTools/MELTS.py,sha256=CjUOJSUEoq4yXEojl77HgCj7aewhFDeSGt4ZGk3L3vs,73688
 PetThermoTools/Melting.py,sha256=h1-KchPFw5tI2xoOyNJUfVy_TJqTtcYiHtGuInIwzio,11017
-PetThermoTools/Path.py,sha256=FI_JkpCDXUVWsaKxA_PKOyKvXSzsQEBiLonGNiamcIM,33424
+PetThermoTools/Path.py,sha256=u2PNtgnqsXbiWvpj-shSjzxiC5kLus9aIzsq_YLjRfY,38220
 PetThermoTools/Path_wrappers.py,sha256=_0pBs_cK2hICxAHkYxKXICUnUEBSiUg07-qhgBeuTdc,26555
 PetThermoTools/PhaseDiagrams.py,sha256=8S_BcqggBzfUbiCPcsJRWFBenGL4tcCevte3-ATQjQI,30884
 PetThermoTools/Plotting.py,sha256=IMYYusZy6REQATG9NI3dGlGs6h3vQ48aJHkZnHmSDDY,28924
 PetThermoTools/Saturation.py,sha256=XXY6fKVouQM3RLgQgXur4xSq7_uGp7bCw_k7NNlWYi8,14095
 PetThermoTools/__init__.py,sha256=PbiwQj_mNNEwuIZOLETmtMMshiXa50wjCA6mfvpOpOs,2393
-PetThermoTools/_version.py,sha256=i2Na-DPnshyTFid0Y6FmelIcA0OHEcYVuQdFt_mKzeI,296
-PetThermoTools-0.2.33.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
-PetThermoTools-0.2.33.dist-info/METADATA,sha256=MM-RsleOmZq3PfygLozR2VrdewAuBMezGJLwnGc9Km8,796
-PetThermoTools-0.2.33.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-PetThermoTools-0.2.33.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
-PetThermoTools-0.2.33.dist-info/RECORD,,
+PetThermoTools/_version.py,sha256=Yz_zSUyefR3Q96ONxPsaaqcFw6TTx12jT1iGtXcC84o,296
+PetThermoTools-0.2.35.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
+PetThermoTools-0.2.35.dist-info/METADATA,sha256=UyTbMSzbIvHSV0GGsJRDvkqlp1P7jAU27wNbIK8MyR4,796
+PetThermoTools-0.2.35.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+PetThermoTools-0.2.35.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
+PetThermoTools-0.2.35.dist-info/RECORD,,