PetThermoTools 0.2.39__py3-none-any.whl → 0.2.40__py3-none-any.whl

PetThermoTools/PhaseDiagrams.py

@@ -11,7 +11,12 @@ from tqdm.notebook import tqdm, trange
 import random
 import time
 
-def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar = None, T_min_C = None, T_max_C = None, T_num = None, P_min_bar = None, P_max_bar = None, P_num = None, Fe3Fet_Liq = None, H2O_Liq = None, fO2_buffer = None, fO2_offset = None, i_max = 25, grid = True):
+def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar = None, 
+                      T_min_C = None, T_max_C = None, T_num = None, 
+                      P_min_bar = None, P_max_bar = None, P_num = None, 
+                      Fe3Fet_Liq = None, H2O_Liq = None, CO2_Liq = None,
+                      Fe3Fet_init = None, H2O_init = None, CO2_init = None,
+                      fO2_buffer = None, fO2_offset = None, i_max = 25, grid = True, refine = None):
     """
     Calculate phase diagrams for igneous systems (rocks and magmas).
 
@@ -61,6 +66,20 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
     pandas.DataFrame
         A dataframe containing the phase diagram results.
     """
+    if H2O_Liq is not None:
+        print('Warning - the kwarg "H2O_Liq" will be removed from v1.0.0 onwards. Please use "H2O_init" instead.')
+        if H2O_init is None:
+            H2O_init = H2O_Liq
+
+    if CO2_Liq is not None:
+        print('Warning - the kwarg "CO2_Liq" will be removed from v1.0.0 onwards. Please use "CO2_init" instead.')
+        if CO2_init is None:
+            CO2_init = CO2_Liq
+
+    if Fe3Fet_Liq is not None:
+        print('Warning - the kwarg "Fe3Fet_Liq" will be removed from v1.0.0 onwards. Please use "Fe3Fet_init" instead.')
+        if Fe3Fet_init is None:
+            Fe3Fet_init = Fe3Fet_Liq
 
     comp = bulk.copy()
 
@@ -80,7 +99,7 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
         comp = comp.to_dict()
 
     # ensure the bulk composition has the correct headers etc.
-    comp = comp_fix(Model = Model, comp = comp, Fe3Fet_Liq = Fe3Fet_Liq, H2O_Liq = H2O_Liq)
+    comp = comp_fix(Model = Model, comp = comp, Fe3Fet_Liq = Fe3Fet_init, H2O_Liq = H2O_init, CO2_Liq=CO2_init)
 
     if type(comp) == dict:
         if comp['Fe3Fet_Liq'] == 0.0 and "MELTS" in Model and fO2_buffer is None:
@@ -110,20 +129,6 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
     c = 0
     j = 0
 
-
-    # subarray_length = len(T_flat) // cores
-
-    # # Initialize an empty list to store subarrays
-    # subarrays_T = []
-
-    # Loop through the indices and create subarrays
-    # for i in range(subarray_length):
-    #     subarray_T = T_flat[i::subarray_length]
-    #     subarrays_T.append(subarray_T)
-        
-    #     subarray_P = T_flat[i::subarray_length]
-    #     subarrays_P.append(subarray_P)
-
     while len(T_flat)>1:
         if j > i_max:
             break
@@ -175,22 +180,6 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
                 T_path_C = np.flip(T_path_C)
                 P_path_bar = np.flip(P_path_bar)
 
-            # if "MELTS" not in Model:
-            #     T_path_C = T_path_C.tolist()
-            #     P_path_bar = P_path_bar.tolist()
-
-            # if j > 5:
-            #     com = list(zip(T, P))
-
-            #     # Step 2: Randomize the order of the combined list
-            #     random.shuffle(com)
-
-            #     # Step 3: Separate the pairs back into two arrays
-            #     T_randomized, P_randomized = zip(*com)
-
-            #     T_path_C = np.array(T_randomized)
-            #     P_path_bar = np.array(P_randomized)
-
             p = Process(target = path, args = (q,i), kwargs = {'Model': Model, 'comp': comp, 
                                                                'T_path_C': T_path_C, 
                                                                'P_path_bar': P_path_bar, 
@@ -242,66 +231,6 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
                 p.join()
                 p.terminate()
 
-        # TIMEOUT = 150 #+ #0.5*len(T_flat)
-        # start = time.time()
-        # for p in ps:
-        #     ret = []
-        #     if time.time() - start <= TIMEOUT:
-        #         while time.time() - start <= TIMEOUT:
-        #             try:
-        #                 ret = q.get(timeout = 2)
-        #                 break
-        #             except:
-        #                 continue
-        #
-        #             # if p.is_alive():
-        #             #     time.sleep(.1)
-        #             # else:
-        #             #     p.terminate()
-        #             #     p.join()
-        #             #     break
-        #
-        #         # if p.is_alive():
-        #     else:
-        #         try:
-        #             ret = q.get(timeout = 5)
-        #         except:
-        #             ret =[]
-        #
-        #     p.terminate()
-        #     p.join()
-
-            # else:
-            #     p.terminate()
-            #     p.join()
-
-            # try:
-            #     ret = q.get(timeout = 5)
-            # except:
-            #     ret = []
-
-            # qs.append(ret)
-            # if p.is_alive():
-            #     while time.time() - start <= TIMEOUT:
-            #         if not p.is_alive():
-            #             p.terminate()
-            #             p.join()
-            #             break
-            #         time.sleep(.1)
-            #     else:
-            #         p.terminate()
-            #         p.join()
-            # else:
-            #     p.terminate()
-            #     p.join()
-            #
-            # try:
-            #     ret = q.get(timeout = 2)
-            # except:
-            #     ret = []
-
-            # qs.append(ret)
-
         for p in ps:
             p.kill()
 
@@ -347,9 +276,6 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
     new_flat = flat[np.where((flat[:, None] == Res_flat).all(-1).any(-1) == False)]
 
     if np.shape(new_flat)[0] > 0.0:
-        # df = pd.DataFrame(columns = ['T_C', 'P_bar'])
-        # for i in range(len(new_flat)):
-        #     df.loc[i] = new_flat[i]
         A = np.zeros((np.shape(new_flat)[0], np.shape(Combined.values)[1]))
         A[:,:2] = new_flat
 
@@ -358,7 +284,6 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
         C = np.concatenate((A, B))
 
         Combined = pd.DataFrame(columns = list(Combined.keys()), data = C)
-        # Combined = pd.concat([Combined, df], axis = 0, ignore_index = True)
 
     Combined['T_C'] = np.round(Combined['T_C'], 2)
     Combined['P_bar'] = np.round(Combined['P_bar'], 2)
@@ -366,9 +291,15 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
     Combined = Combined.reset_index(drop = True)
     Combined = Combined.dropna(subset = ['T_C'])
 
+    if refine is not None:
+        for i in range(refine):
+            Combined = phaseDiagram_refine(Data = Combined, Model = Model, bulk = bulk, Fe3Fet_Liq=Fe3Fet_init,
+                                           H2O_Liq=H2O_init, CO2_Liq=CO2_init, fO2_buffer=fO2_buffer, fO2_offset=fO2_offset, i_max = i_max)
+
     return Combined
 
-def phaseDiagram_refine(Data = None, Model = None, bulk = None, Fe3Fet_Liq = None, H2O_Liq = None, fO2_buffer = None, fO2_offset = None, i_max = 25):
+def phaseDiagram_refine(Data = None, Model = None, bulk = None, Fe3Fet_Liq = None, H2O_Liq = None, CO2_Liq = None, 
+                        fO2_buffer = None, fO2_offset = None, i_max = 25):
     Combined = Data.copy()
     # find existing T,P data
     T_C = Combined['T_C'].unique()
@@ -508,7 +439,8 @@ def phaseDiagram_refine(Data = None, Model = None, bulk = None, Fe3Fet_Liq = Non
     matching_df = matching_df.loc[np.where(matching_df['h'] != 0.0)[0],:]
     matching_df = matching_df.reset_index(drop = True)
 
-    New = phaseDiagram_calc(cores = 1, Model = Model, bulk = bulk, T_C = T_C, P_bar = P_bar, Fe3Fet_Liq = Fe3Fet_Liq, H2O_Liq = H2O_Liq, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset, i_max = i_max, grid = False)
+    New = phaseDiagram_calc(cores = multiprocessing.cpu_count(), 
+                            Model = Model, bulk = bulk, T_C = T_C, P_bar = P_bar, Fe3Fet_init = Fe3Fet_Liq, H2O_init = H2O_Liq, CO2_init = CO2_Liq, fO2_buffer = fO2_buffer, fO2_offset = fO2_offset, i_max = i_max, grid = False)
 
     # A = New.values
     # B = matching_df.values

PetThermoTools/Saturation.py

@@ -303,7 +303,357 @@ def findSatPressure(cores = None, Model = None, bulk = None, T_C_init = None, T_
         return Res
 
 
-def satP(q, index, *, Model = None, comp = None, T_C_init = None, T_fixed_C = None, P_bar_init = None, fO2_buffer = None, fO2_offset = None):
+def saturation_pressure(Model = "MELTSv1.2.0", cores = multiprocessing.cpu_count(),
+                        bulk = None, T_C_init = None, T_fixed_C = None, P_bar_init = 5000,
+                        Fe3Fet_Liq = None, Fe3Fet_init = None, H2O_Liq = None, H2O_init = None,
+                        CO2_Liq = None, CO2_init = None, fO2_buffer = None, fO2_offset = None, 
+                        copy_columns = None, multi_processing = True, timeout = 180):
+    """
+    Estimates the pressure at which volatile saturation occurs for one or more melt compositions
+    using MELTS thermodynamic models.
+
+    Supports both single and batched calculations, with optional multiprocessing to accelerate large-scale runs.
+
+    Parameters
+    ----------
+    Model : str, default 'MELTSv1.2.0'
+        The thermodynamic model to use. 
+            MELTS:
+                "MELTSv1.2.0"
+                "MELTSv1.1.0"
+                "MELTSv1.0.2" - only H2O
+                "pMELTS" - only H2O
+    cores : int, default multiprocessing.cpu_count()
+        Number of parallel processes to use.
+    bulk : dict, pandas.Series, or pandas.DataFrame
+        Bulk melt composition(s). If a Series or single dict is passed, a single calculation is run.
+        If a DataFrame is passed, a calculation is performed for each row.
+    T_C_init : float or np.ndarray, optional
+        Initial temperature(s) in degrees Celsius. System will co-solve the liquidus temperature and pressure of volatile saturation. Used if not specifying `T_fixed_C`.
+    T_fixed_C : float or np.ndarray, optional
+        Fixed temperature(s) for the saturation pressure calculation. Solid phases are disabled in all calculations.
+    P_bar_init : float or np.ndarray, default 5000
+        Initial pressure guess(es) in bars.
+    Fe3Fet_Liq : float or np.ndarray, optional [DEPRECATED]
+        Legacy alias for initial Fe³⁺/∑Fe ratio. Prefer `Fe3Fet_init`.
+    Fe3Fet_init : float or np.ndarray, optional
+        Initial Fe³⁺/∑Fe ratio(s) in the liquid.
+    H2O_Liq : float or np.ndarray, optional [DEPRECATED]
+        Legacy alias for initial H₂O content. Prefer `H2O_init`.
+    H2O_init : float or np.ndarray, optional
+        Initial H₂O content(s) in the liquid, in wt%.
+    CO2_Liq : float or np.ndarray, optional [DEPRECATED]
+        Legacy alias for initial CO₂ content. Prefer `CO2_init`.
+    CO2_init : float or np.ndarray, optional
+        Initial CO₂ content(s) in the liquid, in wt%.
+    fO2_buffer : str, optional
+        Oxygen fugacity buffer to use ('FMQ' or 'NNO').
+    fO2_offset : float or np.ndarray, optional
+        Offset from the fO₂ buffer in log units (e.g., +1.0 = 1 log unit above buffer).
+    copy_columns : str or list of str, optional
+        If bulk is a DataFrame, copies specified columns from input into output DataFrame for tracking.
+    multi_processing : bool, default True
+        Whether to parallelize the calculations across multiple cores.
+    timeout : int, default 180
+        Timeout for individual parallel processes, in seconds.
+
+    Returns
+    -------
+    pandas.DataFrame or dict
+        - If multiple calculations are performed, returns a DataFrame with saturation pressures and
+          other outputs, indexed by run number.
+        - If a single calculation is run (`multi_processing=False` or `bulk` is a single composition),
+          returns a dictionary of calculated results.
+
+    Raises
+    ------
+    Warning
+        - If required MELTS packages are not found in the Python path.
+        - If unsupported fO₂ buffers are specified.
+        - If zero Fe³⁺/∑Fe or H₂O is specified in MELTS without buffer constraints.
+
+    Notes
+    -----
+    - Missing inputs for temperature, pressure, or fO₂ offset are auto-expanded if multiple runs are inferred.
+    - For MELTS-based models, small amounts of H₂O and ferric iron often improve model stability.
+    - The function handles multiprocessing with safe timeouts and partial result recovery.
+    """
+       
+    if "MELTS" in Model:
+        try:
+            from meltsdynamic import MELTSdynamic
+        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')
+
+    if bulk is not None:
+        comp = bulk.copy()
+
+    if H2O_Liq is not None:
+        print('Warning - the kwarg "H2O_Liq" will be removed from v1.0.0 onwards. Please use "H2O_init" instead.')
+        if H2O_init is None:
+            H2O_init = H2O_Liq
+
+    if CO2_Liq is not None:
+        print('Warning - the kwarg "CO2_Liq" will be removed from v1.0.0 onwards. Please use "CO2_init" instead.')
+        if CO2_init is None:
+            CO2_init = CO2_Liq
+
+    if Fe3Fet_Liq is not None:
+        print('Warning - the kwarg "Fe3Fet_Liq" will be removed from v1.0.0 onwards. Please use "Fe3Fet_init" instead.')
+        if Fe3Fet_init is None:
+            Fe3Fet_init = Fe3Fet_Liq
+
+    # if comp is entered as a pandas series, it must first be converted to a dict
+    if type(comp) == pd.core.series.Series:
+        comp = comp.to_dict()
+
+    if fO2_buffer is not None:
+        if fO2_buffer != "NNO":
+            if fO2_buffer != "FMQ":
+                raise Warning("fO2 buffer specified is not an allowed input. This argument can only be 'FMQ' or 'NNO' \n if you want to offset from these buffers use the 'fO2_offset' argument.")
+
+    # ensure the bulk composition has the correct headers etc.
+    comp = comp_fix(Model = Model, comp = comp, Fe3Fet_Liq = Fe3Fet_init, H2O_Liq = H2O_init, CO2_Liq = CO2_init)
+
+    if type(comp) == dict:
+        if comp['H2O_Liq'] == 0.0 and "MELTS" in Model:
+            raise Warning("Adding small amounts of H$_{2}$O may improve the ability of MELTS to accurately reproduce the saturation of oxide minerals. Additionally, sufficient H$_{2}$O is required in the model for MELTS to predict the crystallisation of apatite, rather than whitlockite.")
+
+        if comp['Fe3Fet_Liq'] == 0.0 and "MELTS" in Model and fO2_buffer is None:
+            raise Warning("MELTS often fails to produce any results when no ferric Fe is included in the starting composition and an fO2 buffer is not set.")
+
+    # specify the number of calculations to be performed in each sequence
+    One = 0
+    if type(comp) == pd.core.frame.DataFrame: # simplest scenario - one calculation per bulk composition imported
+        A = len(comp['SiO2_Liq'])//cores
+        B = len(comp['SiO2_Liq'])%cores
+    else:
+        if T_fixed_C is not None and type(T_fixed_C) == np.ndarray: # one calculation per T loaded.
+            A = len(T_fixed_C)//cores
+            B = len(T_fixed_C)%cores
+        elif fO2_offset is not None and type(fO2_offset) == np.ndarray: # one calculation per offset
+            A = len(fO2_offset)//cores
+            B = len(fO2_offset)%cores
+        else: # just one calculation
+            One = 1
+            A = 1
+            B = 0
+
+    Group = np.zeros(A) + cores
+    if B > 0:
+        Group = np.append(Group, B)
+
+    qs = []
+    q = Queue()
+    if One == 1:
+        if multi_processing:
+            p = Process(target = satP, args = (q,0),
+                        kwargs = {'Model': Model, 'comp': comp, 'T_C_init': T_C_init,
+                                  'T_fixed_C': T_fixed_C, 'P_bar_init': P_bar_init,
+                                  'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset})
+            p.start()
+            try:
+                ret = q.get(timeout = timeout)
+            except:
+                ret = []
+
+            TIMEOUT = 5
+            start = time.time()
+            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 len(ret) > 0:
+                Results, index = ret
+            else:
+                Results = {}
+
+            return Results
+        else:
+            Results = findSatPressure_MELTS(Model = Model, T_C_init=T_C_init, T_fixed_C=T_fixed_C,
+                                            P_bar_init=P_bar_init, comp = comp, fO2_buffer=fO2_buffer,
+                                            fO2_offset=fO2_offset)
+            return Results
+    else: # perform multiple crystallisation calculations
+        # first make sure everything is the right length
+        L = np.sum(Group)
+        if type(P_bar_init) == float or type(P_bar_init) == int:
+            P_bar_init = np.zeros(int(L)) + P_bar_init
+        if T_C_init is None:
+            T_C_init = [None] * int(L)
+        elif type(T_C_init) == float or type(T_C_init) == int:
+            T_C_init = np.zeros(int(L)) + T_C_init
+        if T_fixed_C is None:
+            T_fixed_C = [None] * int(L)
+        elif type(T_fixed_C) == float or type(T_fixed_C) == int:
+            T_fixed_C = np.zeros(int(L)) + T_fixed_C
+        if fO2_offset is None:
+            fO2_offset = [None] * int(L)
+        elif type(fO2_offset) == float or type(fO2_offset) == int:
+            fO2_offset = np.zeros(int(L)) + fO2_offset
+
+        index_in = np.arange(int(L))
+        combined_results = {}
+        index_out = np.array([], dtype=int)
+        timeout_main = timeout
+
+        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
+
+            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 = saturationP_multi, args = (q, groups[i]),
+                            kwargs = {'Model': Model, 'comp': comp, 'T_C_init': T_C_init,
+                                      'T_fixed_C': T_fixed_C, 'P_bar_init': P_bar_init, 
+                                      'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset})
+                
+                processes.append([p, q, groups[i]])
+                p.start()
+
+            for p, q, group in processes:
+                try:
+                    if time.time() - Start < timeout + 5:
+                        res = q.get(timeout = timeout)
+                    else:
+                        res = q.get(timeout=10)
+                except:
+                    res = []
+                    idx_chunks = np.array([group[0]], dtype = int)
+
+                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
+
+        def results_to_dataframe(results, full_index):
+            # Convert 'Run X' → X and create DataFrame
+            df = pd.DataFrame.from_dict(results, orient='index')
+            df.index = df.index.str.extract(r'Run (\d+)')[0].values.astype(int)
+
+            # Reindex with full range, fill missing with 0.0
+            df = df.reindex(full_index, fill_value=0.0)
+
+            # Optional: sort index if needed
+            df = df.sort_index()
+
+            return df
+        Results = results_to_dataframe(results, index_in)
+        
+        if copy_columns is not None:
+            if type(copy_columns) == str:
+                Results.insert(0, copy_columns, comp[copy_columns])
+                # Af_Combined.insert(0, copy_columns, comp[copy_columns])
+            elif type(copy_columns) == list:
+                j = 0
+                for i in copy_columns:
+                    Results.insert(j, i, comp[i])
+                    # Af_Combined.insert(j, i, comp[i])
+                    j = j + 1
+
+        return Results
+
+def saturationP_multi(q, index, *, Model = None, comp = None, T_C_init = None, T_fixed_C = None,
+               P_bar_init = None, fO2_buffer = None, fO2_offset = 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)
+
+        
+        melts.engine.pressure = P_bar_init[0]
+        if T_fixed_C[0] is not None:
+            melts.engine.temperature = T_fixed_C[0] + 500
+        else:
+            melts.engine.temperature = T_C_init[0] + 500
+
+        if type(comp) == dict:
+            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]
+        else:
+            bulk = [comp.loc[0,'SiO2_Liq'], comp.loc[0,'TiO2_Liq'], comp.loc[0,'Al2O3_Liq'], 
+                    comp.loc[0,'Fe3Fet_Liq']*((159.59/2)/71.844)*comp.loc[0,'FeOt_Liq'], 
+                    comp.loc[0,'Cr2O3_Liq'], (1- comp.loc[0,'Fe3Fet_Liq'])*comp.loc[0,'FeOt_Liq'], 
+                    comp.loc[0,'MnO_Liq'], comp.loc[0,'MgO_Liq'], 0.0, 0.0, comp.loc[0,'CaO_Liq'], 
+                    comp.loc[0,'Na2O_Liq'], comp.loc[0,'K2O_Liq'], comp.loc[0,'P2O5_Liq'], 
+                    comp.loc[0,'H2O_Liq'], comp.loc[0,'CO2_Liq'], 0.0, 0.0, 0.0]
+            
+        melts.engine.setBulkComposition(bulk)
+        PL = melts.engine.calcSaturationState()
+        if T_fixed_C[0] is not None:
+            for p in PL:
+                if p != "fluid":
+                    if p != "water":
+                        melts.engine.setSystemProperties("Suppress", p)
+        else:
+            Suppress = ['rutile', 'tridymite']
+            for p in Suppress:
+                melts.engine.setSystemProperties("Suppress", p)
+
+    for i in index:
+        melts = melts.addNodeAfter()
+        try:
+            if type(comp) == dict:
+                Results, tr = findSatPressure_MELTS(Model = Model, T_C_init=T_C_init[i], T_fixed_C=T_fixed_C[i],
+                                            P_bar_init=P_bar_init[i], comp = comp, fO2_buffer=fO2_buffer,
+                                            fO2_offset=fO2_offset[i], trial = True, melts = melts, suppressed = True)
+            else:
+                Results, tr = findSatPressure_MELTS(Model = Model, T_C_init=T_C_init[i], T_fixed_C=T_fixed_C[i],
+                                            P_bar_init=P_bar_init[i], comp = comp.loc[i].to_dict(), fO2_buffer=fO2_buffer,
+                                            fO2_offset=fO2_offset[i], trial = True, melts = melts, suppressed = True)
+
+            results[f"Run {i}"] = Results
+            idx.append(i)
+            if tr is False:
+                break
+        except:
+            idx.append(i)
+            break
+
+    q.put([idx, results])
+
+def satP(q, index, *, Model = None, comp = None, T_C_init = None, T_fixed_C = None, 
+         P_bar_init = None, fO2_buffer = None, fO2_offset = None):
     """Find the saturation pressure for a given composition and temperature.
 
     This function calculates the volatile saturation pressure for a given composition using the MELTS models. The results are returned in the form of a tuple and added to the specified queue.
@@ -329,7 +679,8 @@ def satP(q, index, *, Model = None, comp = None, T_C_init = None, T_fixed_C = No
     
 def satP_multi(q, index, *, Model = None, comp = None, fO2_buffer = None):
     if "MELTS" in Model:
-        Results = findSatPressure_MELTS_multi(Model = Model, comp = comp, fO2_buffer=fO2_buffer, fO2_offset=comp['fO2_offset'],
+        Results = findSatPressure_MELTS_multi(Model = Model, comp = comp, fO2_buffer=fO2_buffer, 
+                                              fO2_offset=comp['fO2_offset'],
                                               P_bar = comp['P_bar'], T_fixed_C=comp['T_fixed_C'])
         q.put([Results, index])
         return

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.39'
+__version__ = '0.2.40'

{PetThermoTools-0.2.39.dist-info → PetThermoTools-0.2.40.dist-info}/METADATA

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

PetThermoTools-0.2.40.dist-info/RECORD

@@ -0,0 +1,20 @@
+PetThermoTools/Barom.py,sha256=2NLhuidKKG8ljaXdWtQfGUE7QgIVMjHyJZq0GUtsayI,45818
+PetThermoTools/Compositions.py,sha256=65NzfduzWdfHJ8VmHBN1Cv7fMz7kF3QbDVLei-e4v00,1483
+PetThermoTools/GenFuncs.py,sha256=KS2zgccvUWDU_A4e6tK7NQrBrHYHTysHiFGC8WdilW8,17824
+PetThermoTools/Holland.py,sha256=udBFeVUyTBpSfLIhx7Hy6o0I8ApNCDvwU_gZa0diY5w,7251
+PetThermoTools/Installation.py,sha256=UfVOW1NZFdzMWPyID5u7t0KwvpJA0AqYohzidXIAwYs,6098
+PetThermoTools/Liq.py,sha256=BxAiHTeVQSLgpJT1Ac71apOQYmY3LGTPrxXclwE4F6w,35145
+PetThermoTools/MELTS.py,sha256=MIW1QUF-W76xjS4nD4tmFXKzYdh7ghY4W05kXU3hoBc,76412
+PetThermoTools/Melting.py,sha256=6EXjDJi5ZEZkQdoZbClRvnm3la_9c1tqurwyagcp5ts,12808
+PetThermoTools/Path.py,sha256=gF8C_bGV_BkVyCvBYEVWN2A6TcfHAppiV4jAOmJilA8,35207
+PetThermoTools/Path_wrappers.py,sha256=gUxs_4Qbk4MLlLl4iySxfbfKU34588bIJAYyhHmhFdc,30177
+PetThermoTools/PhaseDiagrams.py,sha256=7tagrboKpln3fTXOZVX1ouxhzhV2-cmWGo9Qtmtsfn4,29285
+PetThermoTools/Plotting.py,sha256=uvL_j2emMveGumLQ-IeJqyMXGUQT_PyInOpGnsWziAI,28992
+PetThermoTools/Saturation.py,sha256=m014Wtcd6pT8qmQhUoQQczZEB6dX3iIdxsCGtxmuOh0,29806
+PetThermoTools/__init__.py,sha256=PbiwQj_mNNEwuIZOLETmtMMshiXa50wjCA6mfvpOpOs,2393
+PetThermoTools/_version.py,sha256=_VYZ5bFE97hEGZ_S_lc6cSL5MwEE0cohtbh7q3t2VcM,296
+PetThermoTools-0.2.40.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
+PetThermoTools-0.2.40.dist-info/METADATA,sha256=LEddDdRVihjM4jtAPOkPKt6Qm5jYAWtjKOM8u0ZdFm4,796
+PetThermoTools-0.2.40.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+PetThermoTools-0.2.40.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
+PetThermoTools-0.2.40.dist-info/RECORD,,

PetThermoTools-0.2.39.dist-info/RECORD

@@ -1,20 +0,0 @@
-PetThermoTools/Barom.py,sha256=CXjwCb7KpQG8x7IhewCLTfqoJ02s4Ott3NwDcGQMWtQ,40221
-PetThermoTools/Compositions.py,sha256=65NzfduzWdfHJ8VmHBN1Cv7fMz7kF3QbDVLei-e4v00,1483
-PetThermoTools/GenFuncs.py,sha256=_hhy4Myen18rMa5AVagb0wvwdXVZ5BtF2bRW_vnM3tY,17681
-PetThermoTools/Holland.py,sha256=udBFeVUyTBpSfLIhx7Hy6o0I8ApNCDvwU_gZa0diY5w,7251
-PetThermoTools/Installation.py,sha256=UfVOW1NZFdzMWPyID5u7t0KwvpJA0AqYohzidXIAwYs,6098
-PetThermoTools/Liq.py,sha256=2kdU8r00Y20khwvPvCvLr6P7y2HEOvCH2cwrF_qw5u8,35541
-PetThermoTools/MELTS.py,sha256=DeTM8j2fJ5dAw_2DVCGfgh1R_lQB4Z5rLopKSJ1Q5xQ,73852
-PetThermoTools/Melting.py,sha256=6EXjDJi5ZEZkQdoZbClRvnm3la_9c1tqurwyagcp5ts,12808
-PetThermoTools/Path.py,sha256=ey1nKnmdtriQ_0W6nG5Hbqhhk4EYqY64y1bMwhoXTW0,33050
-PetThermoTools/Path_wrappers.py,sha256=_0pBs_cK2hICxAHkYxKXICUnUEBSiUg07-qhgBeuTdc,26555
-PetThermoTools/PhaseDiagrams.py,sha256=8S_BcqggBzfUbiCPcsJRWFBenGL4tcCevte3-ATQjQI,30884
-PetThermoTools/Plotting.py,sha256=uvL_j2emMveGumLQ-IeJqyMXGUQT_PyInOpGnsWziAI,28992
-PetThermoTools/Saturation.py,sha256=XXY6fKVouQM3RLgQgXur4xSq7_uGp7bCw_k7NNlWYi8,14095
-PetThermoTools/__init__.py,sha256=PbiwQj_mNNEwuIZOLETmtMMshiXa50wjCA6mfvpOpOs,2393
-PetThermoTools/_version.py,sha256=mHkADyHdAemaOsQ81BakYanLTpx-qI1XT0aama1lkCw,296
-PetThermoTools-0.2.39.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
-PetThermoTools-0.2.39.dist-info/METADATA,sha256=EaGuwfuigrt061ZQbwUN0JEYA0jg-D7YIQd-pXPwQe0,796
-PetThermoTools-0.2.39.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-PetThermoTools-0.2.39.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
-PetThermoTools-0.2.39.dist-info/RECORD,,