PetThermoTools 0.2.40__tar.gz → 0.2.42__tar.gz

{PetThermoTools-0.2.40/src/PetThermoTools.egg-info → PetThermoTools-0.2.42}/PKG-INFO

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

{PetThermoTools-0.2.40 → PetThermoTools-0.2.42}/setup.py

@@ -30,7 +30,7 @@ setup(
     },
     install_requires=[
             'pandas',
-            'numpy<2',
+            'numpy',
             'matplotlib',
             'scikit-learn',
             'scipy',

{PetThermoTools-0.2.40 → PetThermoTools-0.2.42}/src/PetThermoTools/Barom.py

@@ -186,8 +186,31 @@ def mineral_cosaturation(Model="MELTSv1.0.2", cores=int(np.floor(multiprocessing
     Results : dict
         Raw simulation outputs for each pressure step.
     """
-        
+    ## make sure everything is a float
+    T_initial_C = to_float(T_initial_C)
+    T_maxdrop_C = to_float(T_maxdrop_C)
+    T_cut_C = to_float(T_cut_C)
+
+    P_bar      = to_float(P_bar)
+
+    Fe3Fet_init= to_float(Fe3Fet_init)
+    H2O_init   = to_float(H2O_init)
+    CO2_init   = to_float(CO2_init)
+    fO2_offset = to_float(fO2_offset)
+    
     comp = bulk.copy()
+
+    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.")
+
+    if "MELTS" not in Model:
+        if fO2_buffer == "FMQ":
+            fO2_buffer = "qfm"
+        if fO2_buffer == "NNO":
+            fO2_buffer = "nno"
+            
     if H2O_Sat:
         comp['H2O_Liq'] = 20
 

{PetThermoTools-0.2.40 → PetThermoTools-0.2.42}/src/PetThermoTools/GenFuncs.py

@@ -4,52 +4,64 @@ import pandas as pd
 # from PetThermoTools.Liq import *
 # from PetThermoTools.Crystallise import *
 from PetThermoTools.MELTS import *
+from PetThermoTools.Compositions import *
 # try:
 #     from PetThermoTools.Holland import *
 # except:
 #     pass
 
 Names = {'liquid1': '_Liq',
-        'liquid2': '_Liq2',
-        'liquid3': '_Liq3',
-        'liquid4': '_Liq4',
         'olivine1': '_Ol',
-        'olivine2': '_Ol2',
+        'orthopyroxene1': '_Opx',
         'clinopyroxene1': '_Cpx',
-        'clinopyroxene2': '_Cpx2',
+        'garnet1': '_Grt',
+        'spinel1': '_Sp',
+        'k-feldspar1': '_Kspar',
+        'quartz1': '_Qtz',
+        'rhm-oxide1': '_Rhm',
+        'apatite1': '_Apa',
+        'olivine2': '_Ol2',
         'plagioclase1': '_Plag',
+        'clinopyroxene2': '_Cpx2',
         'plagioclase2': '_Plag2',
-        'spinel1': '_Sp',
         'spinel2': '_Sp2',
-        'k-feldspar1': '_Kspar',
         'k-feldspar2': '_Kspar2',
-        'garnet1': '_Grt',
         'garnet2': '_Grt2',
-        'rhm-oxide1': '_Rhm',
         'rhm-oxide2': '_Rhm2',
-        'quartz1': '_Qtz',
         'quartz2': '_Qtz2',
-        'orthopyroxene1': '_Opx',
         'orthopyroxene2': '_Opx2',
-        'apatite1': '_Apa',
-        'apatite2': '_Apa2'}
+        'apatite2': '_Apa2',
+        'liquid2': '_Liq2',
+        'liquid3': '_Liq3',
+        'liquid4': '_Liq4'}
 
 Names_MM = {'liq1': '_Liq',
-            'liq2': '_Liq2',
-            'liq3': '_Liq3',
-            'liq4': '_Liq4',
             'ol1': '_Ol',
-            'ol2': '_Ol2',
+            'opx1': '_Opx',
             'cpx1': '_Cpx',
+            'g1': '_Grt',
+            'spl1': '_Sp',
+            'fsp1': '_Plag',
+            'ol2': '_Ol2',
             'cpx2': '_Cpx2',
-            'opx1': '_Opx',
             'opx2': '_Opx2',
-            'g1': '_Grt',
             'g2': '_Grt2',
-            'fsp1': '_Plag',
             'fsp2': '_Plag2',
-            'spl1': '_Sp',
-            'spl2': '_Sp2'}
+            'spl2': '_Sp2',
+            'liq2': '_Liq2',
+            'liq3': '_Liq3',
+            'liq4': '_Liq4'}
+
+def to_float(x):
+    if x is None:
+        return None
+    if isinstance(x, (int, float)):
+        return float(x)
+    if isinstance(x, (list, tuple)):
+        return [float(v) for v in x]
+    if isinstance(x, np.ndarray):
+        return x.astype(float)
+    return x  # leave unchanged if unexpected type
 
 def label_results(Result,label):
     Results = Result.copy()
@@ -93,6 +105,36 @@ def supCalc(Model = "MELTSv1.0.2", bulk = None, phase = None, T_C = None, P_bar
     
     return Results
 
+def comp_check(comp_lith, Model, MELTS_filter, Fe3Fet):
+    if type(comp_lith) == str:
+        if Model != "pyMelt":
+            comp = Compositions[comp_lith]
+        else:
+            comp = comp_lith
+    else:
+        comp = comp_lith.copy()
+
+    # if comp is entered as a pandas series, it must first be converted to a dict
+    if Model != "pyMelt":
+        if type(comp) == pd.core.series.Series:
+            comp = comp.to_dict()
+
+        comp = comp_fix(Model = Model, comp = comp, Fe3Fet_Liq = Fe3Fet)
+
+    if "MELTS" in Model and MELTS_filter == True:
+        if type(comp) == pd.core.frame.DataFrame:
+            comp['K2O_Liq'] = np.zeros(len(comp['SiO2_Liq']))
+            comp['P2O5_Liq'] = np.zeros(len(comp['SiO2_Liq']))
+            comp['H2O_Liq'] = np.zeros(len(comp['SiO2_Liq']))
+            comp['CO2_Liq'] = np.zeros(len(comp['SiO2_Liq']))
+        else:
+            comp['K2O_Liq'] = 0
+            comp['P2O5_Liq'] = 0
+            comp['H2O_Liq'] = 0
+            comp['CO2_Liq'] = 0
+    
+    return comp
+
 
 def comp_fix(Model = None, comp = None, Fe3Fet_Liq = None, H2O_Liq = None, CO2_Liq = None):
     '''
@@ -345,12 +387,20 @@ def stich_work(Results = None, Order = None, Model = "MELTS", Frac_fluid = None,
             Results_Mass['fluid1_cumsum'] = Results_Mass['fluid1'].cumsum()
         elif Frac_fluid is None:
             for n in SN:
-                if n != 'liquid1' and n!= 'fluid1':
+                if n != 'liquid1' and n!= 'fluid1' and n != 'liq1' and n != 'fl1':
                     Results_Mass[n + '_cumsum'] = Results_Mass[n].cumsum()
+            if 'liq1' in SN:
+                Results_Mass[n + '_cumsum'] = Results_Mass.loc[0, 'liq1'] - Results_Mass.loc[:,Results_Mass.columns.str.contains('_cumsum')].sum(axis = 1)
+            elif 'liquid1' in SN:
+                Results_Mass[n + '_cumsum'] = Results_Mass.loc[0, 'liquid1'] - Results_Mass.loc[:,Results_Mass.columns.str.contains('_cumsum')].sum(axis = 1)
         else:
             for n in SN:
-                if n != 'liquid1':
+                if n != 'liquid1' and n != 'liq1':
                     Results_Mass[n + '_cumsum'] = Results_Mass[n].cumsum()
+            if 'liq1' in SN:
+                Results_Mass[n + '_cumsum'] = Results_Mass.loc[0, 'liq1'] - Results_Mass.loc[:,Results_Mass.columns.str.contains('_cumsum')].sum(axis = 1)
+            elif 'liquid1' in SN:
+                Results_Mass[n + '_cumsum'] = Results_Mass.loc[0, 'liquid1'] - Results_Mass.loc[:,Results_Mass.columns.str.contains('_cumsum')].sum(axis = 1)
 
     Results_All = Results['Conditions'].copy()
     for R in Results:

{PetThermoTools-0.2.40 → PetThermoTools-0.2.42}/src/PetThermoTools/Liq.py

@@ -16,6 +16,26 @@ def equilibrate_multi(cores = None, Model = None, bulk = None, T_C = None, P_bar
                       Fe3Fet_Liq = None, H2O_Liq = None, CO2_Liq = None, fO2_buffer = None, fO2_offset = None,
                       timeout = None, copy_columns = None, Suppress = None):
 
+    T_C        = to_float(T_C)
+
+    P_bar = to_float(P_bar)
+
+    H2O_Liq = to_float(H2O_Liq)
+    CO2_Liq = to_float(CO2_Liq)
+    Fe3Fet_Liq = to_float(Fe3Fet_Liq)
+    fO2_offset = to_float(fO2_offset)
+
+    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.")
+
+    if "MELTS" not in Model:
+        if fO2_buffer == "FMQ":
+            fO2_buffer = "qfm"
+        if fO2_buffer == "NNO":
+            fO2_buffer = "nno"
+
     if "MELTS" in Model:
         try:
             from meltsdynamic import MELTSdynamic
@@ -410,6 +430,17 @@ def findCO2_multi(cores = None, Model = None, bulk = None, T_initial_C = None, P
     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 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.")
+
+    if "MELTS" not in Model:
+        if fO2_buffer == "FMQ":
+            fO2_buffer = "qfm"
+        if fO2_buffer == "NNO":
+            fO2_buffer = "nno"
+
     comp = bulk.copy()
 
     if Model is None:
@@ -607,11 +638,22 @@ def findLiq_multi(cores = None, Model = None, bulk = None, T_initial_C = None, P
 
     comp = bulk.copy()
 
+    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.")
+
+    if "MELTS" not in Model:
+        if fO2_buffer == "FMQ":
+            fO2_buffer = "qfm"
+        if fO2_buffer == "NNO":
+            fO2_buffer = "nno"
+
     if Model is None:
         Model = "MELTSv1.0.2"
 
-    if Model == "Holland":
-        import pyMAGEMINcalc as MM
+    # if Model == "Holland":
+    #     import pyMAGEMINcalc as MM
 
     # if comp is entered as a pandas series, it must first be converted to a dict
     if type(comp) == pd.core.series.Series:
@@ -792,8 +834,8 @@ def findLiq_multi(cores = None, Model = None, bulk = None, T_initial_C = None, P
         else:
             return Res
     else:
-        T_Liq = MM.findLiq_multi(P_bar = P_bar, T_initial_C = T_initial_C, comp = comp)
-        return T_Liq
+        # T_Liq = MM.findLiq_multi(P_bar = P_bar, T_initial_C = T_initial_C, comp = comp)
+        return "find liquidus calculations are currently not available through the MAGEMin models. This is an issue I'm working to fix as soon as possible."
 
 def findCO2(q, index, *, Model = None, P_bar = None, T_initial_C = None, comp = None, fO2_buffer = None, fO2_offset = None):
     T_Liq = 0

{PetThermoTools-0.2.40 → PetThermoTools-0.2.42}/src/PetThermoTools/MELTS.py

@@ -1572,7 +1572,9 @@ def findSatPressure_MELTS(Model = None, T_C_init = None, T_fixed_C = None, P_bar
     else:
         return out
 
-def AdiabaticDecompressionMelting_MELTS(Model = None, comp = None, Tp_C = None, P_path_bar = None, P_start_bar = None, P_end_bar = None, dp_bar = None, Frac = False, fO2_buffer = None, fO2_offset = None):
+def AdiabaticDecompressionMelting_MELTS(Model = None, comp = None, Tp_C = None, Tp_Method = None,
+                                        P_path_bar = None, P_start_bar = None, P_end_bar = None, dp_bar = None, 
+                                        Frac = False, fO2_buffer = None, fO2_offset = None):
     try:
         import pyMelt as m     
         Lithologies = {'KLB-1': m.lithologies.matthews.klb1(),

{PetThermoTools-0.2.40 → PetThermoTools-0.2.42}/src/PetThermoTools/Melting.py

@@ -10,37 +10,6 @@ from multiprocessing import Process
 import time
 import sys
 from tqdm.notebook import tqdm, trange
-# import pyMelt as m
-
-def comp_check(comp_lith, Model, MELTS_filter, Fe3Fet):
-    if type(comp_lith) == str:
-        if Model != "pyMelt":
-            comp = Compositions[comp_lith]
-        else:
-            comp = comp_lith
-    else:
-        comp = comp_lith.copy()
-
-    # if comp is entered as a pandas series, it must first be converted to a dict
-    if Model != "pyMelt":
-        if type(comp) == pd.core.series.Series:
-            comp = comp.to_dict()
-
-        comp = comp_fix(Model = Model, comp = comp, Fe3Fet_Liq = Fe3Fet)
-
-    if "MELTS" in Model and MELTS_filter == True:
-        if type(comp) == pd.core.frame.DataFrame:
-            comp['K2O_Liq'] = np.zeros(len(comp['SiO2_Liq']))
-            comp['P2O5_Liq'] = np.zeros(len(comp['SiO2_Liq']))
-            comp['H2O_Liq'] = np.zeros(len(comp['SiO2_Liq']))
-            comp['CO2_Liq'] = np.zeros(len(comp['SiO2_Liq']))
-        else:
-            comp['K2O_Liq'] = 0
-            comp['P2O5_Liq'] = 0
-            comp['H2O_Liq'] = 0
-            comp['CO2_Liq'] = 0
-    
-    return comp
 
 def AdiabaticDecompressionMelting(cores = multiprocessing.cpu_count(), 
                                   Model = "pMELTS", bulk = "KLB-1", comp_lith_1 = None, 
@@ -48,22 +17,105 @@ def AdiabaticDecompressionMelting(cores = multiprocessing.cpu_count(),
                                   P_start_bar = 30000, P_end_bar = 2000, dp_bar = 200, 
                                   P_path_bar = None, Frac = False, prop = None, 
                                   fO2_buffer = None, fO2_offset = None, Fe3Fet = None, MELTS_filter = True):
+    """
+    Perform adiabatic decompression melting calculations using MELTS, MAGEMin, or pyMelt.
+
+    Simulates mantle melting along an adiabatic upwelling path (e.g., ridge or plume) with user-defined 
+    starting potential temperature, pressure range, and step size. Supports single-lithology mantle sources 
+    (e.g., KLB-1) at present, with expansion to multi-lithology systems in development.
+
+    Parameters
+    ----------
+    cores : int, optional
+        Number of CPU cores to use for multiprocessing. Defaults to total available.
+    Model : str, optional
+        Thermodynamic model. MELTS variants: "MELTSv1.0.2", "MELTSv1.1.0", "MELTSv1.2.0", "pMELTS";
+        or MAGEMin: "Green2025", "Weller2024". Alternatively calculations can be performed using 
+        pyMelt (Matthews et al. 2020): "pyMelt"
+    bulk : dict ot str, optional
+        Bulk composition name or composition dictionary.
+        Default is "KLB-1".
+    Tp_C : float or np.ndarray, optional
+        Mantle potential temperature(s) in °C. Default is 1350.
+    Tp_Method : str, optional
+        Method to calculate the starting pressure for adiabatic melting. Default is "pyMelt".
+    P_start_bar, P_end_bar, dp_bar : float or array, optional
+        Starting, ending, and step size pressures (in bar) for adiabatic decompression. 
+        Defaults: 30000, 2000, and 200, respectively.
+    P_path_bar : np.ndarray, optional
+        User-specified pressure path (in bar). If given, overrides `P_start_bar`, `P_end_bar`, and `dp_bar`.
+    fO2_buffer : {"FMQ", "NNO"}, optional
+        Redox buffer for constraining oxygen fugacity.
+    fO2_offset : float, optional
+        Offset (log units) from the chosen fO2 buffer.
+    Fe3Fet : float, optional
+        Initial Fe³⁺/ΣFe ratio for the bulk composition. If None, values is taken from the "bulk" variable or set according to fO2 buffer positions.
+    MELTS_filter : bool, default=True
+        If True, filters oxide components to avoid issues in MELTS calculations (e.g., K2O content set to 0.0).
+
+    Returns
+    -------
+    Results : dict
+        Dictionary containing DataFrames for the system and phase compositions and properties.
+
+    Notes
+    -----
+    - Currently limited to single-lithology melting.
+    - Normalizes output mass so that total initial mass = 1.
+
+    Examples
+    --------
+    Run a single adiabatic decompression path from 3.0 GPa to 0.2 GPa:
+
+    >>> results = AdiabaticDecompressionMelting(Model="pMELTS", bulk="KLB-1",
+    ...                                        Tp_C=1350, P_start_bar=30000,
+    ...                                        P_end_bar=2000, dp_bar=200)
+
+    Run with an explicit pressure path:
+
+    >>> import numpy as np
+    >>> P_path = np.linspace(30000, 2000, 20)
+    >>> results = AdiabaticDecompressionMelting(Model="pMELTS", comp_lith_1="KLB-1",
+    ...                                        P_path_bar=P_path, Tp_C=1400)
+    """
     
-    if Tp_Method == "pyMelt":
-        try:
-            import pyMelt as m
-            Lithologies = {'KLB-1': m.lithologies.matthews.klb1(),
-                        'KG1': m.lithologies.matthews.kg1(),
-                        'G2': m.lithologies.matthews.eclogite(),
-                        'hz': m.lithologies.shorttle.harzburgite()}
-        except ImportError:
-            raise RuntimeError('You havent installed pyMelt or there is an error when importing pyMelt. pyMelt is currently required to estimate the starting point for the melting calculations.')
+    Tp_C        = to_float(Tp_C)
+
+    P_path_bar = to_float(P_path_bar)
+    P_start_bar= to_float(P_start_bar)
+    P_end_bar  = to_float(P_end_bar)
+    dp_bar     = to_float(dp_bar)
+
+    Fe3Fet = to_float(Fe3Fet)
+    fO2_offset = to_float(fO2_offset)
+
+    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.")
+
+    if "MELTS" not in Model:
+        if fO2_buffer == "FMQ":
+            fO2_buffer = "qfm"
+        if fO2_buffer == "NNO":
+            fO2_buffer = "nno"
+
+    # if Tp_Method == "pyMelt":
+    #     try:
+    #         import pyMelt as m
+    #         Lithologies = {'KLB-1': m.lithologies.matthews.klb1(),
+    #                     'KG1': m.lithologies.matthews.kg1(),
+    #                     'G2': m.lithologies.matthews.eclogite(),
+    #                     'hz': m.lithologies.shorttle.harzburgite()}
+    #     except ImportError:
+    #         raise RuntimeError('You havent installed pyMelt or there is an error when importing pyMelt. pyMelt is currently required to estimate the starting point for the melting calculations.')
 
     if bulk is not None and comp_lith_1 is None:
         comp_lith_1 = bulk
 
     comp_1 = comp_check(comp_lith_1, Model, MELTS_filter, Fe3Fet)
 
+    # place holders for when code is expanded to account for multi-lithology mantle
     if comp_lith_2 is not None:
         comp_2 = comp_check(comp_lith_2, Model, MELTS_filter, Fe3Fet)
     else:
@@ -74,6 +126,8 @@ def AdiabaticDecompressionMelting(cores = multiprocessing.cpu_count(),
     else:
         comp_3 = None
 
+
+    # At present calculations only work for a single simulation - this represents a placeholder for when the code is expanded to account for multiple simulations
     One = 0
     if Model != "pyMelt":
         if type(comp_1) == pd.core.frame.DataFrame: # simplest scenario - one calculation per bulk composition imported
@@ -114,7 +168,7 @@ def AdiabaticDecompressionMelting(cores = multiprocessing.cpu_count(),
     if One == 1:
         p = Process(target = AdiabaticMelt, args = (q, 1),
                     kwargs = {'Model': Model, 'comp_1': comp_1, 'comp_2': comp_2, 'comp_3': comp_3,
-                              'Tp_C': Tp_C, 'P_path_bar': P_path_bar, 
+                              'Tp_C': Tp_C, 'Tp_Method': Tp_Method, 'P_path_bar': P_path_bar, 
                               'P_start_bar': P_start_bar, 'P_end_bar': P_end_bar, 'dp_bar': dp_bar,
                               'fO2_buffer': fO2_buffer, 'fO2_offset': fO2_offset, 'Frac': Frac, 'prop': prop})
 
@@ -156,7 +210,7 @@ def AdiabaticDecompressionMelting(cores = multiprocessing.cpu_count(),
 
     return Results
 
-def AdiabaticMelt(q, index, *, Model = None, comp_1 = None, comp_2 = None, comp_3 = None, 
+def AdiabaticMelt(q, index, *, Model = None, comp_1 = None, comp_2 = None, comp_3 = None, Tp_Method = "pyMelt",
                   Tp_C = None, P_start_bar = None, P_end_bar = None, dp_bar = None, P_path_bar = None, 
                   Frac = None, fO2_buffer = None, fO2_offset = None, prop = None):
     '''
@@ -166,7 +220,7 @@ def AdiabaticMelt(q, index, *, Model = None, comp_1 = None, comp_2 = None, comp_
     Results = {}
     if "MELTS" in Model:
         try:
-            Results = AdiabaticDecompressionMelting_MELTS(Model = Model, comp = comp_1, Tp_C = Tp_C, 
+            Results = AdiabaticDecompressionMelting_MELTS(Model = Model, comp = comp_1, Tp_C = Tp_C, Tp_Method = "pyMelt",
                                                           P_path_bar = P_path_bar, P_start_bar = P_start_bar, P_end_bar = P_end_bar, dp_bar = dp_bar, 
                                                           fO2_buffer = fO2_buffer, fO2_offset = fO2_offset)
             q.put([Results, index])
@@ -239,10 +293,6 @@ def AdiabaticMelt(q, index, *, Model = None, comp_1 = None, comp_2 = None, comp_
         return
 
     else:
-        # import pyMAGEMINcalc as MM
-        # Results = MM.AdiabaticDecompressionMelting(comp = comp_1, T_p_C = Tp_C, P_start_kbar = P_start_bar/1000, P_end_kbar = P_end_bar/1000, dp_kbar = dp_bar/1000, Frac = 0)
-        # print('Note that the ability to use MAGEMin to performed adiabatic decompression melting in PetThermoTools has been temporarily disabled. The underlying issue will be fixed soon and this funciton will once again become available.')
-        
         try:
             import pyMelt as m
             Lithologies = {'KLB-1': m.lithologies.matthews.klb1(),
@@ -252,10 +302,13 @@ def AdiabaticMelt(q, index, *, Model = None, comp_1 = None, comp_2 = None, comp_
         except ImportError:
             raise RuntimeError('You havent installed pyMelt or there is an error when importing pyMelt. pyMelt is currently required to estimate the starting point for the melting calculations.')
 
-        lz = m.lithologies.matthews.klb1()
-        mantle = m.mantle([lz], [1], ['Lz'])
-        T_start_C = mantle.adiabat(P_start_bar/10000.0, Tp_C)
-        
+        if Tp_Method == "pyMelt":
+            lz = m.lithologies.matthews.klb1()
+            mantle = m.mantle([lz], [1], ['Lz'])
+            T_start_C = mantle.adiabat(P_start_bar/10000.0, Tp_C)
+        else:
+            T_start_C = None
+
         from juliacall import Main as jl, convert as jlconvert
 
         jl.seval("using MAGEMinCalc")
@@ -265,7 +318,7 @@ def AdiabaticMelt(q, index, *, Model = None, comp_1 = None, comp_2 = None, comp_
         if type(comp_1) == dict:
             comp_julia = jl.seval("Dict")(comp_1) 
         else:
-            comp_new = comp_1.loc[i].to_dict()
+            comp_new = comp_1.loc[0].to_dict()
             comp_julia = jl.seval("Dict")(comp_new)
 
         Output_jl = jl.MAGEMinCalc.AdiabaticDecompressionMelting(comp = comp_julia, P_start_kbar = P_start_bar/1000.0, 

{PetThermoTools-0.2.40 → PetThermoTools-0.2.42}/src/PetThermoTools/Path.py

@@ -98,6 +98,26 @@ def multi_path(cores = None, Model = None, bulk = None, comp = None, Frac_solid
         Dictionary with each run's label as key. Values are sub-dictionaries of phase/property DataFrames.
         Includes `Input` key summarizing model configuration per run.
     """
+    ## make sure everything is a float
+    T_C        = to_float(T_C)
+    T_path_C   = to_float(T_path_C)
+    T_start_C  = to_float(T_start_C)
+    T_end_C    = to_float(T_end_C)
+    dt_C       = to_float(dt_C)
+
+    P_bar      = to_float(P_bar)
+    P_path_bar = to_float(P_path_bar)
+    P_start_bar= to_float(P_start_bar)
+    P_end_bar  = to_float(P_end_bar)
+    dp_bar     = to_float(dp_bar)
+
+    Fe3Fet_init= to_float(Fe3Fet_init)
+    Fe3Fet_Liq = to_float(Fe3Fet_Liq)
+    H2O_init   = to_float(H2O_init)
+    H2O_Liq    = to_float(H2O_Liq)
+    CO2_init   = to_float(CO2_init)
+    CO2_Liq    = to_float(CO2_Liq)
+    fO2_offset = to_float(fO2_offset)
 
     if timeout is None:
         timeout = 180
@@ -150,10 +170,12 @@ def multi_path(cores = None, Model = None, bulk = None, comp = None, Frac_solid
     if "MELTS" not in Model:
         if fO2_buffer == "FMQ":
             fO2_buffer = "qfm"
+        if fO2_buffer == "NNO":
+            fO2_buffer = "nno"
 
     # 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.")
@@ -473,28 +495,48 @@ def path_multi(q, index, *, Model = None, comp = None, Frac_solid = None, Frac_f
 
         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)
+                    if trail is not None:
+                        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 = 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)
+                    if trail is not None:
+                        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:
+                        Results = 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