peridoxia 2.1__tar.gz

peridoxia-2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Suzanne Birner]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

peridoxia-2.1/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: peridoxia
+Version: 2.1
+Summary: Package for assessing redox during mantle melting
+Author-email: "Suzanne K. Birner" <birners@berea.edu>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/skbirner/peridoxia
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: <3.11,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: deprecation>=2.1.0
+Requires-Dist: matplotlib>=3.6.2
+Requires-Dist: nptyping
+Requires-Dist: numdifftools
+Requires-Dist: openpyxl
+Requires-Dist: pandas>=1.5.2
+Requires-Dist: pytest>=7.2.0
+Requires-Dist: pytest-cov>=4.0.0
+Requires-Dist: scipy>=1.9.3
+Requires-Dist: seaborn>=0.12.1
+Requires-Dist: thermoengine>=2.0.0.dev10
+Dynamic: license-file
+
+# Peridoxia
+
+Peridoxia is an empirical partitioning model designed to assess redox evolution during mantle melting in the shallow garnet and spinel fields. It uses natural and experimental results to constrain ferric iron partitioning between mantle phases. It was first developed by Suzanne Birner (birners AT berea.edu) in 2024 for the manuscript "Deep, hot, ancient melting recorded by ultralow oxygen fugacity in peridotites" (https://www.nature.com/articles/s41586-024-07603-w)
+
+Documentation and Examples may be foud here: https://peridoxia.readthedocs.io/en/latest/
+
+This package requires a virtual environment with python 3.10. For help with installation in a virtual environment, please see the Installation Guide: https://peridoxia.readthedocs.io/en/latest/installation.html.

peridoxia-2.1/README.md

@@ -0,0 +1,7 @@
+# Peridoxia
+
+Peridoxia is an empirical partitioning model designed to assess redox evolution during mantle melting in the shallow garnet and spinel fields. It uses natural and experimental results to constrain ferric iron partitioning between mantle phases. It was first developed by Suzanne Birner (birners AT berea.edu) in 2024 for the manuscript "Deep, hot, ancient melting recorded by ultralow oxygen fugacity in peridotites" (https://www.nature.com/articles/s41586-024-07603-w)
+
+Documentation and Examples may be foud here: https://peridoxia.readthedocs.io/en/latest/
+
+This package requires a virtual environment with python 3.10. For help with installation in a virtual environment, please see the Installation Guide: https://peridoxia.readthedocs.io/en/latest/installation.html.

peridoxia-2.1/peridoxia/PTF_functions.py

@@ -0,0 +1,53 @@
+# PTF_Functions
+
+# The model uses the equations of Langmuir, Klein, and Plank (1992) to calculate Pressure (P), Temperature (T), and Melt Fraction (F) along an adiabatic decompression path.
+
+import numpy as np
+
+def PTF_geotherm(
+        TK_pot: float=1350+273.15, 
+        PGPa_range: list[float]=[4.,0.1], 
+        P_step: float=-0.01, 
+        melting: bool=True):
+    
+    '''Calculates a set of PT values along a geotherm from a given potential temperature
+       Equations are from Langmuir, Klein, and Plank (1992)'''
+    
+    PGPa_all = np.arange(PGPa_range[0], PGPa_range[1], P_step)
+    
+    TK_all = np.zeros_like(PGPa_all)
+    F_all = np.zeros_like(PGPa_all)
+    
+    if melting==False:
+        
+        # 1°C/kbar is the value given in LKP92
+        TK_all = 1*(PGPa_all*10) + TK_pot
+        
+    else:
+        
+        # Calculate P at the solidus (intersection of solidus and adiabat)
+        PGPa_sol = ((TK_pot-273.15) - 1118)/117
+        if PGPa_sol > PGPa_range[0]:
+            raise ValueError(f"ERROR! Solidus pressure {PGPa_sol:.2f} is higher than starting pressure! {PGPa_range[0]:.2f}")
+    
+        # Constants for calculating P
+        a = 88*12/3.5
+        k = 88*0.95/3.5
+        
+        # Calculate T and F at each P
+        for idx, PGPa in enumerate(PGPa_all):
+            
+            if PGPa >= PGPa_sol:
+                TK_all[idx] = 1*(PGPa*10) + TK_pot
+                F_all[idx] = 0.
+            
+            else:
+
+                F = a*np.log((PGPa-k)/(PGPa_sol-k))
+                TC_sol_P = 1118 + 127*PGPa
+                TC = TC_sol_P + 3.5*F/(1+PGPa/4.5)
+                
+                F_all[idx] = F
+                TK_all[idx] = TC + 273.15
+        
+    return PGPa_all, TK_all, F_all

peridoxia-2.1/peridoxia/__init__.py

@@ -0,0 +1,17 @@
+from . import PTF_functions
+from . import plotting_and_saving
+
+from . import setup_composition_parameters
+from . import data_structures
+from . import setup_partitioning_constraints
+from . import reactions
+from . import cation_equilibration_functions
+from . import input_composition
+
+from . import main
+
+
+
+
+
+

peridoxia-2.1/peridoxia/cation_equilibration_functions.py

@@ -0,0 +1,154 @@
+###-----------------------------------------------------------------------------------------------------------------------
+### Equilibration Reactions
+###-----------------------------------------------------------------------------------------------------------------------
+
+### These functions adjust cations in each phase via exchange reactions in order to fulfill the partitioning constraints defined in setup_partitioning_constraints.py
+
+import numpy as np
+import copy
+import scipy.optimize as opt
+
+from peridoxia import setup_partitioning_constraints as partitioning
+from peridoxia import data_structures as data_struct
+from peridoxia import reactions
+
+### Exchange Reactions
+
+# Olv-Opx-Cpx exchange (included in all models)
+olv_opx_cpx_exchange = [
+    # 3+ cation exchange
+    reactions.define_reaction(reactants={'opx_CaFeAlSiO6':1, 'cpx_CaAlAlSiO6':1}, products={'opx_CaAlAlSiO6':1,'cpx_CaFeAlSiO6':1}), #Fe3-Al, opx-cpx
+    reactions.define_reaction(reactants={'opx_CaCrAlSiO6':1, 'cpx_CaAlAlSiO6':1}, products={'opx_CaAlAlSiO6':1,'cpx_CaCrAlSiO6':1}), #Cr-Al, opx-cpx
+    # 2+ cation exchange
+    reactions.define_reaction(reactants={'olv_Mg2SiO4':1, 'opx_Fe2Si2O6':1}, products={'olv_Fe2SiO4':1, 'opx_Mg2Si2O6':1}), #Fe2-Mg, olv-opx
+    reactions.define_reaction(reactants={'olv_Mg2SiO4':1, 'cpx_Fe2Si2O6':1}, products={'olv_Fe2SiO4':1, 'cpx_Mg2Si2O6':1}), #Fe2-Mg, olv-cpx
+    reactions.define_reaction(reactants={'cpx_Mg2Si2O6':1, 'opx_CaMgSi2O6':1}, products={'cpx_CaMgSi2O6':1, 'opx_Mg2Si2O6':1}), #Ca-Mg, cpx-opx
+    # Ts exchange
+    reactions.define_reaction(reactants={'opx_CaAlAlSiO6':1, 'cpx_CaMgSi2O6':1}, products={'opx_CaMgSi2O6':1, 'cpx_CaAlAlSiO6':1}), #AlAl-MgSi, opx-cpx
+    reactions.define_reaction(reactants={'spl_MgAl2O4':1, 'opx_Mg2Si2O6':1}, products={'olv_Mg2SiO4':1, 'opx_MgAlAlSiO6':1}) #spl+opx <-> ol+Ts-opx
+]
+spl_exchange = [
+    # 3+ cation exchange
+    reactions.define_reaction(reactants={'spl_FeFe2O4':1,'opx_FeAlAlSiO6':2}, products={'spl_FeAl2O4':1,'opx_FeFeAlSiO6':2}), #Fe3-Al, spl-opx
+    reactions.define_reaction(reactants={'spl_FeCr2O4':1, 'opx_FeAlAlSiO6':2}, products={'spl_FeAl2O4':1,'opx_FeCrAlSiO6':2}), #Cr-Al, spl-opx
+    # 2+ cation exchange
+    reactions.define_reaction(reactants={'spl_FeAl2O4':1, 'opx_MgAlAlSiO6':1}, products={'spl_MgAl2O4':1, 'opx_FeAlAlSiO6':1}), #Fe2-Mg, spl-opx
+]
+gt_exchange = [
+    # 3+ cation exchange
+    reactions.define_reaction(reactants={'gt_Ca3Fe2Si3O12':1, 'opx_CaAlAlSiO6':2}, products={'gt_Ca3Al2Si3O12':1, 'opx_CaFeAlSiO6':2}), #Fe3-Al, gt-opx 
+    reactions.define_reaction(reactants={'gt_Ca3Cr2Si3O12':1, 'opx_CaAlAlSiO6':2}, products={'gt_Ca3Al2Si3O12':1, 'opx_CaCrAlSiO6':2}), #Cr-Al, gt-cpx 
+    # 2+ cation exchange
+    reactions.define_reaction(reactants={'gt_Fe3Al2Si3O12':2, 'opx_Mg2Si2O6':3}, products={'gt_Mg3Al2Si3O12':2, 'opx_Fe2Si2O6':3}), #Fe2-Mg, gt-opx
+    reactions.define_reaction(reactants={'gt_Ca3Al2Si3O12':2, 'opx_Mg2Si2O6':3}, products={'gt_Mg3Al2Si3O12':2, 'opx_Ca2Si2O6':3}), #Ca-Mg, gt-cpx 
+]
+liq_exchange = [
+    reactions.define_reaction(reactants={'opx_CaFeAlSiO6':2, 'liq_Al2O3':1}, products={'opx_CaAlAlSiO6':2, 'liq_Fe2O3':1}), #Fe3-Al, liq-opx
+    reactions.define_reaction(reactants={'opx_CaCrAlSiO6':2, 'liq_Al2O3':1}, products={'opx_CaAlAlSiO6':2, 'liq_Cr2O3':1}), #Cr-Al, liq-opx
+    reactions.define_reaction(reactants={'opx_Mg2Si2O6':1, 'liq_FeO':2}, products={'opx_Fe2Si2O6':1, 'liq_MgO':2}), #Fe2-Mg, liq-opx
+    reactions.define_reaction(reactants={'opx_CaAlAlSiO6':1, 'liq_MgO':1, 'liq_SiO2':1}, products={'opx_CaMgSi2O6':1, 'liq_Al2O3':1}), #AlAl-MgSi, opx-liq
+]
+all_exchange = np.concatenate((olv_opx_cpx_exchange, 
+                                    spl_exchange,
+                                    gt_exchange,
+                                    liq_exchange)
+                                    )
+
+
+### Offset Function
+def get_offset(partitioning_constraints: list, assemblage: data_struct.Assemblage, reactions: np.ndarray, amts: np.ndarray):
+    '''Calculates offset between actual partitioning and desired partitioning.
+    Goal of Solver function is to make each offset zero.
+    Input list is a list of partitioning constraint function names (strings)'''
+
+    EQ_assemblage = Exchange_Cations(assemblage, reactions, amts)
+
+    partitioning_calculator = partitioning.PartitioningConstraintCalculator(EQ_assemblage)
+
+    offset_array = np.zeros(len(partitioning_constraints))
+    for idx, constraint in enumerate(partitioning_constraints):
+        partitioning_result = getattr(partitioning_calculator, constraint)() # assesses each partitioning constraint
+        offset_array[idx] = partitioning_result[2]
+
+    return offset_array
+
+
+### Equilibration/Exchange Functions
+def Equilibrate_Cations(assemblage: data_struct.Assemblage, reactions, display=False):
+    '''This function finds a solution for the amount of exchange reactions between minerals necessary to reach the required partitioning.
+        Input reactions are a set of reaction coefficients for each extensive endmember.'''
+    
+    def fT(amts):
+        # Allow amount of each reaction to vary
+
+        ### Determine which partitioning constraints are necessary
+
+        constraints = []
+
+        # Olv-Opx-Cpx constraints (all models)
+        constraints+=partitioning.partitioning_constraints_ol_opx_cpx
+
+        ### TODO: Think about these. Logic might not be correct for liq/spl/gt field interactions
+
+        # Liq constraints
+        if assemblage.get_phase_mass('liq') > 0:
+            constraints+=partitioning.partitioning_constraints_liq
+        # Garnet-field constraints
+        if assemblage.get_phase_mass('gt') > 0: # & (modes['spl'] == 0):
+            constraints+=partitioning.partitioning_constraints_gt
+        # Spinel-field constraints:
+        if assemblage.get_phase_mass('spl') > 0: #constraints.append(partitioning_constraints_liq)
+            constraints+=partitioning.partitioning_constraints_spl
+
+        offsets = get_offset(constraints, assemblage, reactions, amts)
+
+        if display==True:
+            print(offsets)
+            
+        # Make sure number of variables = number of constraints
+        if len(amts) != len(offsets):
+            print("ERROR! Number of variables (exchange reactions) does not equal number of constraints (partitioning relationships)!")
+            print("Exchange Reactions:")
+            for amt in amts:
+                print(amt)
+            print("Offsets:")
+            for val in offsets:
+                print(val)
+            return 
+            
+        return offsets.ravel()
+
+    # Set an initial guess of no reaction
+    initial_guess = np.zeros(len(reactions))
+    
+    # Minimize fT() function
+    #    (i.e., we want the D offsets to be as small as possible) 
+    solution = opt.least_squares(fT, initial_guess)
+
+    amts_array = solution.x
+    residuals = solution.fun
+    
+    for residual in residuals:
+        if abs(residual) > 1e-7:
+            print(f"Residual is not zero! Residual = {residual}")
+         
+    return amts_array, residuals
+
+
+def Exchange_Cations(assemblage: data_struct.Assemblage, reactions: np.ndarray, amts: np.ndarray):
+    '''Applies the indicated amount of each reaction to the starting compositions.
+    Reactions are a set of reaction coefficients for each extensive endmember.
+    Amts is an array of the amount to apply each reaction'''
+    
+    # Initial amount of each extensive endmember
+    ext_end_array = assemblage.extensive_endmember_array
+
+    adjustment = np.dot(amts,reactions)
+
+    # New amounts of each extensive endmember
+    new_endmember_array = ext_end_array + adjustment
+
+    new_assemblage = copy.deepcopy(assemblage)
+    new_assemblage.extensive_endmember_array = new_endmember_array
+
+    return new_assemblage