PetThermoTools 0.2.41__py3-none-any.whl → 0.2.42__py3-none-any.whl

PetThermoTools/Barom.py

@@ -199,6 +199,18 @@ def mineral_cosaturation(Model="MELTSv1.0.2", cores=int(np.floor(multiprocessing
     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/GenFuncs.py

@@ -4,52 +4,53 @@ 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:
@@ -104,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):
     '''
@@ -356,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/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/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/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,6 +17,67 @@ 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)
+    """
     
     Tp_C        = to_float(Tp_C)
 
@@ -59,22 +89,33 @@ def AdiabaticDecompressionMelting(cores = multiprocessing.cpu_count(),
     Fe3Fet = to_float(Fe3Fet)
     fO2_offset = to_float(fO2_offset)
 
-
-    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 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:
@@ -85,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
@@ -125,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})
 
@@ -167,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):
     '''
@@ -177,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])
@@ -250,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(),
@@ -263,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")

PetThermoTools/Path.py

@@ -170,6 +170,8 @@ 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)

PetThermoTools/PhaseDiagrams.py

@@ -103,6 +103,17 @@ def phaseDiagram_calc(cores = None, Model = None, bulk = None, T_C = None, P_bar
 
     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 cores is None:
         cores = multiprocessing.cpu_count()
 

PetThermoTools/Plotting.py

@@ -3,128 +3,237 @@ import pandas as pd
 from shapely.geometry import MultiPoint, Point, Polygon
 import matplotlib.pyplot as plt
 from matplotlib import cm
+import matplotlib.colors as mc
 from PetThermoTools.GenFuncs import *
-
-def harker(Results = None, x_axis = None, y_axis = None, phase = None, line_style = None, line_color = None, data = None, d_color = None, d_marker = None, label = None):
-    '''
-    Construct harker plots.
-
-    Parameters:
-    -----------
-    Results: dict
-        Contains DataFrames with the results of the MELTS or MAGEMin calculations.
-
-    x_axis: str
-        Oxide to be placed on the x-axis, Default = "MgO".
-
-    y_axis: list
-        Oxides to be displayed on the y-axes.
-
-    phase: str
-        Phase compositions to be plotted. Plots the liquid component by default.
-
-    line_style: str
-        Line style to use for the MELTS/MAGEMin results. Default = '-'.
-
-    line_color: str or tuple
-        Color of the line used to display the MELTS/MAGEMin results. Black as default.
-
-    data: DataFrame
-        Optional. Include natural or experimental data to plot against the calculation results.
-
-    d_color: str or tuple
-        Color of the symbols used to display the natural/experimental data.
-
-    d_marker: str
-        Marker style for the natural/experimental data.
-    '''
+from itertools import zip_longest
+
+def harker(Results=None, x_axis="MgO", y_axis=("SiO2", "TiO2", "Al2O3", "Cr2O3", "FeOt", "CaO", "Na2O", "K2O"),
+    phase="liquid1", line_color=None, data=None, d_color=None, d_marker=None,
+    legend=True, legend_loc=None,
+    xlim=None, ylim=None):
+    """
+    Generates a Harker diagram (oxide vs. MgO or another oxide) from model results.
+
+    Parameters
+    ----------
+    Results : dict or None, optional
+        MELTS or MAGEMin results dictionary. If multiple results, they are overlaid.
+    x_axis : str, default="MgO"
+        Oxide to use for the x-axis.
+    y_axis : tuple of str, default=("SiO2","TiO2","Al2O3","Cr2O3","FeOt","CaO","Na2O","K2O")
+        Oxides to plot on y-axes. Plotted in groups of three per row.
+    phase : str, default="liquid1"
+        Phase to plot (must be in PetThermoTools.GenFuncs.Names).
+    line_color : str or None, optional
+        Line color. If None, uses matplotlib's default cycle.
+    data : pd.DataFrame, dict of DataFrames, or str, optional
+        External data to plot for comparison. If str, treated as CSV path.
+        If dict, plots each DataFrame with different marker/color.
+    d_colors : list of str or None, optional
+        Colors for external datasets. Cycles if fewer than number of datasets.
+    d_markers : list of str or None, optional
+        Markers for external datasets. Cycles if fewer than number of datasets.
+    legend : bool, default=True
+        Whether to display a legend.
+    legend_loc : tuple(int, int) or None, optional
+        Location of legend in subplot grid, as (row, col). If None, placed on last axis.
+    xlim, ylim : tuple or None, optional
+        Limits for x and y axes.
+
+    Returns
+    -------
+    f : matplotlib.figure.Figure
+        Figure object.
+    a : np.ndarray of Axes
+        Array of Axes objects.
+    """
     if Results is None:
-        raise Exception("We need some results to work with!")
-
-    if x_axis is None:
-        x_axis = "MgO"
-
-    if y_axis is None:
-        y_axis = ["SiO2", "TiO2", "Al2O3", "FeOt", "CaO", "Na2O"]
+        raise ValueError("Results cannot be None. Provide MELTS or MAGEMin results dictionary.")
 
-    if phase is None:
-        phase = "liquid1"
+    if isinstance(y_axis, str):
+        y_axis = (y_axis,)
 
-    if line_style is None:
-        line_style = '-'
-
-    if line_color is None:
-        line_color = 'k'
+    y_axis = list(y_axis)
 
+    # Data loading
     if data is not None:
-        if d_color is None:
-            d_color = 'red'
-
-        if d_marker is None:
-            d_marker = 'o'
-
-    if type(y_axis) == list:
-        y_axis = np.array(y_axis)
-
-    if len(y_axis) % 3 == 0.0:
-        y_axis = y_axis.reshape(len(y_axis)//3, 3)
+        if isinstance(data, str):
+            if data.contains('.csv'):
+                data = pd.read_csv(data)
+            else:
+                data = pd.read_excel(data)
+        elif isinstance(data, dict):
+            # validate
+            for k, v in data.items():
+                if not isinstance(v, pd.DataFrame):
+                    raise ValueError(f"data['{k}'] must be a DataFrame, got {type(v)}")
+                
+    # -------------------- filter y_axis to only include variables present --------------------
+    valid_y = []
+    for y in y_axis:
+        found = False
+
+        # Check Results
+        for r in (Results.keys() if isinstance(Results, dict) else [Results]):
+            Res = Results[r] if isinstance(Results, dict) else Results
+            if "All" in Res:
+                cols = Res["All"].columns
+                if (y + Names[phase]) in cols or y in cols:
+                    if np.nanmax(Res["All"][y + Names[phase]]) > 0.0:
+                        found = True
+                    break
+
+        # Check data (dict or DataFrame)
+        if not found and data is not None:
+            if isinstance(data, dict):
+                for df in data.values():
+                    cols = df.columns
+                    if (y + Names[phase]) in cols or y in cols:
+                        found = True
+                        break
+            else:
+                cols = data.columns
+                if (y + Names[phase]) in cols or y in cols:
+                    found = True
+
+        if found:
+            valid_y.append(y)
+
+    # Replace y_axis with only valid variables
+    y_axis = valid_y
+
+    # -------------------- subplot grid handling --------------------
+    n_vars = len(y_axis)
+
+    if n_vars == 4:  # special case: 2x2 grid
+        ncols, nrows = 2, 2
+        rows = list(zip_longest(*[iter(y_axis)] * ncols, fillvalue=None))
     else:
-        y_axis = np.append(y_axis, np.array(["None"] * (3 - (len(y_axis) % 3))))
-        y_axis = y_axis.reshape(len(y_axis)//3, 3)
-
-    f, a = plt.subplots(np.shape(y_axis)[0], np.shape(y_axis)[1], figsize = (3.5 * np.shape(y_axis)[1], 3.5 * np.shape(y_axis)[0]))
-    if 'All' in list(Results.keys()):
-        if type(phase) == str:
-            for i in range(np.shape(y_axis)[0]):
-                for j in range(np.shape(y_axis)[1]):
-                    if y_axis[i,j] != "None":
-                        if data is not None:
-                            a[i][j].plot(data.loc[:,data.columns.str.contains(x_axis)].values, data.loc[:,data.columns.str.contains(y_axis[i,j])].values, d_marker, markerfacecolor = d_color, markeredgecolor = 'k', markersize = 4)
-
-                        a[i][j].plot(Results['All'][x_axis + Names[phase]], Results['All'][y_axis[i,j] + Names[phase]], line_style, linewidth = 2, color = line_color)
-                        a[i][j].set_ylabel(y_axis[i][j] + " wt%")
-                        if i != np.shape(y_axis)[0] - 1:
-                            if i == np.shape(y_axis)[0] - 2:
-                                if y_axis[i+1,j] == "None":
-                                    a[i][j].set_xlabel(x_axis + " wt%")
-                        else:
-                            a[i][j].set_xlabel(x_axis + " wt%")
-
-                    else:
-                        a[i][j].axis('off')
+        ncols = 3
+        nrows = int(np.ceil(n_vars / ncols))
+        rows = list(zip_longest(*[iter(y_axis)] * ncols, fillvalue=None))
+
+    # scale figure size dynamically
+    fig_width = 3.2 * ncols
+    fig_height = 3.0 * nrows
+    f, a = plt.subplots(nrows, ncols, figsize=(fig_width, fig_height))
+    a = np.atleast_2d(a)
+
+    # Color handling for models
+    color_cycle = plt.rcParams["axes.prop_cycle"].by_key()["color"]
+    if line_color is None:
+        def pick_color(i): return color_cycle[i % len(color_cycle)]
+    else:
+        def pick_color(i): return line_color
+
+    # Color/marker cycles for user data
+    d_color_cycle = d_color if d_color else color_cycle
+    d_marker_cycle = d_marker if d_marker else ["o", "s", "^", "D", "v", "P", "*"]
+
+    # -------------------- helper functions --------------------
+    def plot_panel(ax, x_var, y_var, idx=None, Res = None):
+        """Plot one panel (model + data) on given Axes."""
+        suffix = Names[phase] if phase in Names else ""
+        xcol, ycol = x_var + suffix, y_var + suffix
+
+        # plot model data
+        if Res is not None:
+            if xcol in Results[Res]["All"] and ycol in Results[Res]["All"]:
+                x = Results[Res]["All"][xcol].values
+                y = Results[Res]["All"][ycol].values
+                ax.plot(x, y, color=pick_color(idx), label=Res)
+        else:
+            if xcol in Results["All"] and ycol in Results["All"]:
+                x = Results["All"][xcol].values
+                y = Results["All"][ycol].values
+                ax.plot(x, y, color='k')
+
+    def plot_data(ax, x_var, y_var):
+        # plot external data
+        suffix = Names[phase] if phase in Names else ""
+        xcol, ycol = x_var + suffix, y_var + suffix
+
+        if data is not None:
+            if isinstance(data, pd.DataFrame):
+                datasets = {"data": data}
+            else:
+                datasets = data
+
+            for k, df in datasets.items():
+                c = d_color_cycle[list(datasets.keys()).index(k) % len(d_color_cycle)]
+                m = d_marker_cycle[list(datasets.keys()).index(k) % len(d_marker_cycle)]
+
+                # try with suffix first
+                if xcol in df.columns:
+                    dx = df[xcol].values
+                elif x_var in df.columns:
+                    dx = df[x_var].values
+                else:
+                    dx = None
+                    print(f"x axis variable  {x_var} not found in data")
 
+                if ycol in df.columns:
+                    dy = df[ycol].values
+                elif y_var in df.columns:
+                    dy = df[y_var].values
+                else:
+                    dy = None
+                    print(f"y axis variable  {y_var} not found in data")
+
+                if dx is not None and dy is not None:
+                    ax.plot(dx, dy, m,
+                            markerfacecolor=c,
+                            markeredgecolor="k",
+                            markersize=4,
+                            linestyle="None",
+                            label=k)
+
+        ax.set(xlabel=x_var, ylabel=y_var)
+
+        if xlim:
+            ax.set_xlim(xlim)
+        if ylim:
+            ax.set_ylim(ylim)
+
+    # -------------------- main plotting --------------------
+    for i, row in enumerate(rows):
+        for j, y in enumerate(row):
+            if y is None:
+                a[i, j].axis("off")
+                continue
+            if 'All' in Results.keys():
+                if data is not None:
+                    plot_data(a[i,j], x_axis, y)
+                plot_panel(a[i,j], x_axis, y)
+            else:
+                if data is not None:
+                    plot_data(a[i,j], x_axis, y)
+                for idx, Res in enumerate(Results):
+                    plot_panel(a[i, j], x_axis, y, idx=idx, Res = Res)
+
+    # -------------------- legend --------------------
+    empty_axes = []
+    for i in range(a.shape[0]):
+        for j in range(a.shape[1]):
+            if i * a.shape[1] + j >= len(y_axis):  # beyond valid y variables
+                empty_axes.append(a[i][j])
+
+    handles, labels = a[0][0].get_legend_handles_labels()
+    if empty_axes and handles:
+        empty_axes[0].legend(handles, labels, loc = "center")
+        empty_axes[0].axis("off")
     else:
-        if type(phase) == str:
-            for i in range(np.shape(y_axis)[0]):
-                for j in range(np.shape(y_axis)[1]):
-                    if y_axis[i,j] != "None":
-                        if data is not None:
-                            a[i][j].plot(data.loc[:,data.columns.str.contains(x_axis)], data.loc[:,data.columns.str.contains(y_axis[i,j])], d_marker, markerfacecolor = d_color, markeredgecolor = 'k', markersize = 4, label = "Data")
-
-                        a[i][j].set_ylabel(y_axis[i][j] + " wt%")
-                        if i != np.shape(y_axis)[0] - 1:
-                            if i == np.shape(y_axis)[0] - 2:
-                                if y_axis[i+1,j] == "None":
-                                    a[i][j].set_xlabel(x_axis + " wt%")
-                        else:
-                            a[i][j].set_xlabel(x_axis + " wt%")
-
-                    else:
-                        a[i][j].axis('off')
-
-        for r in Results:
-            Res = Results[r].copy()
-            if type(phase) == str:
-                for i in range(np.shape(y_axis)[0]):
-                    for j in range(np.shape(y_axis)[1]):
-                        if y_axis[i,j] != "None":
-                            a[i][j].plot(Res['All'][x_axis + Names[phase]], Res['All'][y_axis[i,j] + Names[phase]], line_style, linewidth = 2, label = r)
-
-        if label is not None:
-            a[0][0].legend()
+        if legend:
+            if legend_loc is None:
+                loc_i, loc_j = len(rows) - 1, 0
+            else:
+                loc_i, loc_j = legend_loc
+            a[loc_i, loc_j].legend()
 
     f.tight_layout()
 
+    return f, a
+
 def plot_surfaces(Results = None, P_bar = None, phases = None, H2O_Liq = None):
     if H2O_Liq is None:
         f, a = plt.subplots(1,1, figsize = (5,4))
@@ -358,69 +467,191 @@ def residualT_plot(Results = None, P_bar = None, phases = None, H2O_Liq = None,
                         a[i][j].plot_surface(X_new, Y_new, z_plot, cmap = 'viridis')
                         a[i][j].set_zlim([0,50])
 
-def phase_plot(Results = None, y_axis = None, x_axis = None, 
-               phases = ['Liq', 'Ol', 'Opx', 'Cpx', 'Sp', 'Grt'], cmap = "Reds",
-               title = None, figsize = None):
-    
-    if type(Results) != list:
-        f, a = plt.subplots(1,1, figsize = (5, 8))
-        c = cm.get_cmap(cmap, len(phases))
-        x = c(np.arange(0,1,1/len(phases)))
 
-        PhaseList = {}
-        for idx, p in enumerate(phases):
-            PhaseList[p] = x[idx]
-
-        Stop = np.zeros(len(Results['All']['P_bar']))
-        for idx, p in enumerate(phases):
-            if 'mass_' + p in Results['All'].keys():
-                a.fill_betweenx(Results['All']['P_bar'], Stop, 
-                                x2= Stop + Results['All']['mass_' + p], alpha = 0.75, color = PhaseList[p], lw = 0)
-
-                Stop = Stop + Results['All']['mass_' + p]
-
-        a.set_ylabel('Pressure (bars)')
-        a.set_xlabel('Mass (g)')
-
-        a.set_xlim([0,np.nanmax(Stop)])
-        a.set_ylim([np.nanmax(Results['All']['P_bar']), np.nanmin(Results['All']['P_bar'])])
-    else:
-        if figsize is None:
-            figsize = (10,2*len(Results))
-
-        f, a = plt.subplots(len(Results), 1, figsize = figsize, sharex = True)
+def phase_plot(Results, x_axis = None, y_axis = None, cmap = "Reds"):
+    """
+    Create stacked phase mass-fraction plots from thermodynamic model results.
+
+    This function generates diagrams of phase proportions from the results of 
+    crystallization or melting simulations. Mass fractions of crystalline and 
+    liquid phases are stacked either along the x-axis or y-axis, depending on 
+    user specification, to visualize how phase proportions evolve with pressure, 
+    temperature, or another variable.
+
+    Parameters
+    ----------
+    Results : dict
+        Dictionary containing model outputs. It should have one of the following structures:
+        - **Single-run results**:
+          ```
+          Results = {
+              "Mass": pandas.DataFrame,   # columns = phase names or phase_cumsum
+              "All":  pandas.DataFrame    # contains the axis variable (e.g., T_C, P_bar)
+          }
+          ```
+        - **Multi-run results**:
+          ```
+          Results = {
+              run_label: {
+                  "Mass": pandas.DataFrame,
+                  "All":  pandas.DataFrame
+              },
+              ...
+          }
+          ```
+
+        The `"Mass"` DataFrame must include mass fractions for each phase
+        (either raw values or cumulative values with `"_cumsum"` suffix).
+        The `"All"` DataFrame must contain the column specified by `x_axis` or `y_axis`.
+
+    x_axis : str, optional
+        Column name in `Results["All"]` (or equivalent) to plot on the x-axis. 
+        If provided, `y_axis` must be `None`. Typically something like `"T_C"`.
+    
+    y_axis : str, optional
+        Column name in `Results["All"]` (or equivalent) to plot on the y-axis. 
+        If provided, `x_axis` must be `None`. Typically `"P_bar"`.
+    
+    cmap : str, default = "Reds"
+        Matplotlib colormap used to assign colors to phases.
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure or list of Figures
+        - If `Results` contains a single run: a single `Figure`.
+        - If `Results` contains multiple runs: a list of `Figure` objects, one per run.
+
+    axes : matplotlib.axes.Axes or list of Axes
+        - If `Results` contains a single run: a single `Axes` object.
+        - If `Results` contains multiple runs: a list of `Axes` objects, one per run.
+
+    Notes
+    -----
+    - If both `x_axis` and `y_axis` are provided, the function raises a `ValueError`.
+    - Phases are automatically ordered:
+        1. By the index where they first appear (highest pressure or temperature).
+        2. By the order specified in the petthermotools dictionaries `Names` and `Names_MM`, 
+           if available.
+    - The liquid phase (`"liq1"` or `"liquid1"`) is always plotted last.
+    - A legend with readable phase labels is added outside 
+      the plot area.
+
+    Examples
+    --------
+    >>> fig, ax = phase_plot(Results, y_axis="P_bar")
+    # Plots stacked phase proportions vs. pressure
+
+    >>> fig, axes = phase_plot(MultiRunResults, x_axis="T_C")
+    # Creates one stacked phase plot per run, vs. temperature
+    """
+    if x_axis is not None and y_axis is not None:
+        raise ValueError("Please provide either a x-axis or y-axis parameter to plot the mass fractions against")
+    
+    def makeplot(Mass, Res, title = None):
+        # --- Identify whether _cumsum columns exist ---
+        use_cumsum = any(col.endswith("_cumsum") for col in Mass.columns)
+        suffix = "_cumsum" if use_cumsum else ""
+
+        # --- Identify phases ---
+        exclude_cols = {'T_C', None}
+        phases = [
+            col.replace(suffix, "")
+            for col in Mass.columns
+            if col.endswith(suffix) or (not use_cumsum and not col.endswith("_cumsum") and col not in exclude_cols)
+        ]
+
+        # --- Handle liquid phase ---
+        liquid_name = None
+        for liq_name in ["liq1", "liquid1"]:
+            if liq_name in Mass.columns:
+                liquid_name = liq_name
+                if liq_name in phases:
+                    phases.remove(liq_name)
+                break  # use the first match
+
+        # --- Create dictionary priority (order in Names/Names_MM) ---
+        phase_priority = {}
+        for order_dict in [Names, Names_MM]:
+            for i, key in enumerate(order_dict.keys()):
+                phase_priority[key] = i  # smaller i = higher priority in tie
+
+        # --- Sort crystalline phases ---
+        phase_first_index = {}
+        for p in phases:
+            col = p + suffix if (use_cumsum and p + suffix in Mass.columns) else p
+            vals = Mass[col].values
+            nz = np.flatnonzero(vals > 0)
+            phase_first_index[p] = nz[0] if len(nz) > 0 else np.inf
+
+        def sort_key(p):
+            return (phase_first_index[p], phase_priority.get(p, 1e6))
+
+        phases = sorted(phases, key=sort_key)
+
+        # --- Append liquid last ---
+        if liquid_name is not None:
+            phases.append(liquid_name)
+
+        # --- Assign colors ---
         c = cm.get_cmap(cmap, len(phases))
-        x = c(np.arange(0,1,1/len(phases)))
-
-        PhaseList = {}
-        for idx, p in enumerate(phases):
-            PhaseList[p] = x[idx]
+        PhaseColors = {p: c(i) for i, p in enumerate(phases)}
 
-        for i in range(len(Results)):
-            Stop = np.zeros(len(Results[i]['All']['P_bar']))
-            for idx, p in enumerate(phases):
-                a[i].fill_between(Results[i]['All']['P_bar'], Stop, 
-                                y2= Stop + Results[i]['All']['mass_' + p], alpha = 0.75, color = PhaseList[p], lw = 0,
-                                label = p)
+        # --- Setup figure ---
+        if y_axis == "P_bar":
+            f, a = plt.subplots(figsize=(4, 6))
+        else:
+            f, a = plt.subplots(figsize=(4, 3.5))
+
+        # --- Determine orientation ---
+        coord = Res[y_axis] if y_axis else Res[x_axis]
+        horizontal = y_axis is not None
+
+        Stop = np.zeros(len(Mass))
+        for p in phases:
+            col = p + suffix if use_cumsum else p
+            vals = Mass[col].values
+
+            # --- Legend label mapping ---
+            label = Names.get(p, Names_MM.get(p, p))[1:]
+
+            if horizontal:
+                a.fill_betweenx(coord, Stop, Stop + vals, color=PhaseColors[p], alpha=0.75, lw=0, label=label)
+            else:
+                a.fill_between(coord, Stop, Stop + vals, color=PhaseColors[p], alpha=0.75, lw=0, label=label)
+            Stop += vals
+
+        # --- Labels ---
+        if horizontal:
+            a.set_ylabel(y_axis)
+            a.set_xlabel("Mass fraction")
+        else:
+            a.set_xlabel(x_axis)
+            a.set_ylabel("Mass fraction")
 
-                Stop = Stop + Results[i]['All']['mass_'+p]
+        if title is not None:
+            a.set_title(title)
 
-            if i == len(Results)-1:
-                a[i].set_xlabel('Pressure (bars)')
-                a[i].legend(loc = "lower right")
-            a[i].set_ylabel('Mass Fraction')
+        # --- Remove whitespace ---
+        a.margins(0)
+        f.tight_layout()
 
-            a[i].set_ylim([0,np.nanmax(Stop)])
-            a[i].set_xlim([np.nanmin(Results[i]['All']['P_bar']), np.nanmax(Results[i]['All']['P_bar'])])
+        a.legend(loc="center left", bbox_to_anchor=(1.02, 0.5))
 
+        return f, a
+    fig = []
+    axes = []
 
-            if title is not None:
-                if type(title) != list:
-                    a[i].set_title(title)
-                else:
-                    a[i].set_title(title[i])
+    if 'All' in Results.keys():
+        fig, axes = makeplot(Results['Mass'], Results['All'])
+    else:
+        for val in Results.keys():
+            f, a = makeplot(Results[val]['Mass'],
+                            Results[val]['All'],
+                            title = val)
+            fig.append(f)
+            axes.append(a)
+    return fig, axes
 
-    return f, a
 
 def plot_phaseDiagram(Model = "Holland", Combined = None, P_units = "bar", T_units = "C", 
                       lines = None, T_C = None, P_bar = None, label = True, colormap = None):

PetThermoTools/Saturation.py

@@ -412,6 +412,11 @@ def saturation_pressure(Model = "MELTSv1.2.0", cores = multiprocessing.cpu_count
             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"
     # 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)
 

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.41'
+__version__ = '0.2.42'

{PetThermoTools-0.2.41.dist-info → PetThermoTools-0.2.42.dist-info}/METADATA

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

PetThermoTools-0.2.42.dist-info/RECORD

@@ -0,0 +1,20 @@
+PetThermoTools/Barom.py,sha256=HKd1TTHHl0FnM_SGb0qC7KqH7rybyVixVMH7Wph-nk8,46613
+PetThermoTools/Compositions.py,sha256=65NzfduzWdfHJ8VmHBN1Cv7fMz7kF3QbDVLei-e4v00,1483
+PetThermoTools/GenFuncs.py,sha256=oMV3FYIpfHNpGZloN5a6Vr8Sv_5IRsKt4hHIUNbDu24,19996
+PetThermoTools/Holland.py,sha256=udBFeVUyTBpSfLIhx7Hy6o0I8ApNCDvwU_gZa0diY5w,7251
+PetThermoTools/Installation.py,sha256=UfVOW1NZFdzMWPyID5u7t0KwvpJA0AqYohzidXIAwYs,6098
+PetThermoTools/Liq.py,sha256=4tOnVROXr7V6cfvZceKidFT9J20TZE3Om2oem92QC4s,36842
+PetThermoTools/MELTS.py,sha256=2WB4Y11i7yfTM5dRjEr-KrJY2_7f1kLaW4V0di6Qnew,76511
+PetThermoTools/Melting.py,sha256=D4mXTrKkoUPK8dAuHPQRAnK79owI23W7JBmUMvm1DVU,15332
+PetThermoTools/Path.py,sha256=jUAVvKSDuVSYRiIZbL1J21E8X4Loc2xCkRTYyl4PzG4,38179
+PetThermoTools/Path_wrappers.py,sha256=gUxs_4Qbk4MLlLl4iySxfbfKU34588bIJAYyhHmhFdc,30177
+PetThermoTools/PhaseDiagrams.py,sha256=sjjX84LK34m_OjsKCV78zpzRDAXG7oaLu_Z5BxwB_3I,30298
+PetThermoTools/Plotting.py,sha256=KxBNT2nqqrVn9dsAIjGk1hMUVRq7r-WrG_b9quNcRMo,37295
+PetThermoTools/Saturation.py,sha256=3liK4WDVtl5DWpMpE_tQ_fONBCZTctkiNeCXCuNmXoM,29961
+PetThermoTools/__init__.py,sha256=PbiwQj_mNNEwuIZOLETmtMMshiXa50wjCA6mfvpOpOs,2393
+PetThermoTools/_version.py,sha256=gEQfVmDQZosUq8hqgOF7-NXfujY6yVc6ya0YiW2W8ZM,296
+PetThermoTools-0.2.42.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
+PetThermoTools-0.2.42.dist-info/METADATA,sha256=yUKuTP6xbaOHpYQ3g4D5T5qA5XyqfsB0Gs1aBTJF0YA,794
+PetThermoTools-0.2.42.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+PetThermoTools-0.2.42.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
+PetThermoTools-0.2.42.dist-info/RECORD,,

PetThermoTools-0.2.41.dist-info/RECORD

@@ -1,20 +0,0 @@
-PetThermoTools/Barom.py,sha256=6uObJ8ZsHQD6r46ZAyBQGiuVKbmdIVMe4SFp5v-Vigg,46149
-PetThermoTools/Compositions.py,sha256=65NzfduzWdfHJ8VmHBN1Cv7fMz7kF3QbDVLei-e4v00,1483
-PetThermoTools/GenFuncs.py,sha256=qiDB0Tdxu4sErSZGCl_Hm6ZUginDI2LG0s9YGiiRqBw,18130
-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=O6BX_NEWsjLrdkpaZSwPYqQOzIvSHxfyOMKtg7HSmZc,13061
-PetThermoTools/Path.py,sha256=9ijpgp91QNRUftnR80F7wWgenWr8bsZkaZ20OIdOD0M,38116
-PetThermoTools/Path_wrappers.py,sha256=gUxs_4Qbk4MLlLl4iySxfbfKU34588bIJAYyhHmhFdc,30177
-PetThermoTools/PhaseDiagrams.py,sha256=CqiZbP3R2DHTHXI6EYam91Lqz_CqrRjyxG01FlOUVHU,29847
-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=WvrDLHqvUFROTO0ipm6xZxsmiXhJ3Pibqtgbf_NAJkM,296
-PetThermoTools-0.2.41.dist-info/LICENSE.txt,sha256=-mkx4iEw8Pk1RZUvncBhGLW87Uur5JB7FBQtOmX-VP0,1752
-PetThermoTools-0.2.41.dist-info/METADATA,sha256=DQ0lx7W5xgUFICbzLIyjAzANmDoHfdU1bPe4Op9Jh2U,794
-PetThermoTools-0.2.41.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-PetThermoTools-0.2.41.dist-info/top_level.txt,sha256=IqK8iYBR3YJozzMOTRZ8x8mU2k6x8ycoMBxZTm-I06U,15
-PetThermoTools-0.2.41.dist-info/RECORD,,