peritheos 0.1.0__py3-none-any.whl

peritheos/eos/rt/bm.py

@@ -0,0 +1,281 @@
+"""
+Non-thermal equations of state module
+
+This module implements various non-thermal equations of state commonly used in
+high-pressure physics and materials science, including:
+
+1. Birch-Murnaghan equation of state (2nd, 3rd, and 4th order)
+2. Object-oriented implementation with a base class and specific EOS implementations
+
+These equations describe the relationship between pressure and volume (or density)
+at constant temperature, and are particularly useful for modeling the behavior of
+solids under compression.
+
+References:
+-----------
+1. Birch, F. (1947). Finite elastic strain of cubic crystals. Physical Review, 71(11), 809.
+2. Birch, F. (1978). Finite strain isotherm and velocities for single-crystal and
+   polycrystalline NaCl at high pressures and 300 K. Journal of Geophysical Research,
+   83(B3), 1257-1268.
+3. Anderson, O.L. (1995) Equations of State of Solids for Geophysics and Ceramic Science,
+   Oxford University Press, Oxford, UK.
+4. Poirier, J.P., (2000), Introduction to the Physics of the Earth's
+   Interior, Cambridge University Press, Cambridge, UK.
+"""
+
+from peritheos.eos import (
+    EosBase,
+    NumericType,
+    validate_finite_scalar,
+    validate_positive_scalar,
+    validate_volume,
+)
+
+
+class BM2(EosBase):
+    """
+    2nd-order Birch-Murnaghan equation of state.
+
+    The 2nd-order Birch-Murnaghan EOS is defined as:
+    P(V) = (3/2) * K0 * [(V0/V)^(7/3) - (V0/V)^(5/3)]
+
+    or in terms of the Eulerian strain f = [(V0/V)^(2/3) - 1]/2:
+    P(V) = 3 * K0 * f * (1 + 2f)^(5/2)
+
+    Equations from:
+    Poirier, J.P., 2000, Introduction to the Physics of the Earth's
+    Interior, Cambridge University Press, Cambridge, UK.
+    """
+
+    def __init__(self, V0: float, K0: float) -> None:
+        """
+        Initialize the 2nd-order Birch-Murnaghan EOS.
+
+        Parameters
+        ----------
+        V0 : float
+            Reference volume (in cubic angstroms or any consistent unit)
+        K0 : float
+            Bulk modulus at reference volume (in GPa or any consistent unit)
+        """
+        self.V0 = validate_positive_scalar(V0, "V0")
+        self.K0 = validate_positive_scalar(K0, "K0")
+
+    def pressure(self, V: NumericType) -> NumericType:
+        """
+        Calculate pressure using the 2nd-order Birch-Murnaghan EOS.
+
+        Parameters
+        ----------
+        V : float or numpy.ndarray
+            Volume (in the same units as V0)
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Pressure (in the same units as K0)
+        """
+        V = validate_volume(V)
+        f = ((self.V0 / V) ** (2 / 3) - 1) / 2
+        return 3 * self.K0 * f * (1 + 2 * f) ** (5 / 2)
+
+    def bulk_modulus(self, V: NumericType) -> NumericType:
+        """
+        Return the bulk modulus at the given volume.
+
+        Parameters
+        ----------
+        V : float or numpy.ndarray
+            Volume (in the same units as V0)
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Bulk modulus (in the same units as K0)
+        """
+        V = validate_volume(V)
+        eta = ((self.V0 / V) ** (2 / 3) - 1) / 2
+        return self.K0 * (1 + 7 * eta) * (1 + 2 * eta) ** (5 / 2)
+
+
+class BM3(EosBase):
+    """
+    3rd-order Birch-Murnaghan equation of state.
+
+    The 3rd-order Birch-Murnaghan EOS is defined as:
+    P(V) = (3/2) * K0 * [(V0/V)^(7/3) - (V0/V)^(5/3)] *
+           {1 + (3/4) * (K0' - 4) * [(V0/V)^(2/3) - 1]}
+
+    or in terms of the Eulerian strain f = [(V0/V)^(2/3) - 1]/2:
+    P(V) = 3 * K0 * f * (1 + 2f)^(5/2) * [1 + (3/2) * (K0' - 4) * f]
+
+    Equations from:
+    Anderson, O.L., (1995) Equations of State of Solids for Geophysics and Ceramic Science,
+    Oxford University Press, Oxford, UK.
+    """
+
+    def __init__(self, V0: float, K0: float, K0_prime: float) -> None:
+        """
+        Initialize the 3rd-order Birch-Murnaghan EOS.
+
+        Parameters
+        ----------
+        V0 : float
+            Reference volume (in cubic angstroms or any consistent unit)
+        K0 : float
+            Bulk modulus at reference volume (in GPa or any consistent unit)
+        K0_prime : float
+            Pressure derivative of the bulk modulus at reference volume (dimensionless)
+        """
+        self.V0 = validate_positive_scalar(V0, "V0")
+        self.K0 = validate_positive_scalar(K0, "K0")
+        self.K0_prime = validate_finite_scalar(K0_prime, "K0_prime")
+
+    def pressure(self, V: NumericType) -> NumericType:
+        """
+        Calculate pressure using the 3rd-order Birch-Murnaghan EOS.
+
+        Parameters
+        ----------
+        V : float or numpy.ndarray
+            Volume (in the same units as V0)
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Pressure (in the same units as K0)
+        """
+        V = validate_volume(V)
+        f = ((self.V0 / V) ** (2 / 3) - 1) / 2
+        return (
+            3
+            * self.K0
+            * f
+            * (1 + 2 * f) ** (5 / 2)
+            * (1 + (3 / 2) * (self.K0_prime - 4) * f)
+        )
+
+    def bulk_modulus(self, V: NumericType) -> NumericType:
+        """
+        Calculate the bulk modulus at the given volume.
+
+        For the 3rd-order Birch-Murnaghan EOS, the bulk modulus at V0 is:
+        K(V) = K0 * (1 + 2f)^(5/2) * [K0 + (3K0*K0'-5K0)f + 27/2(K0*K0'-4K0)f^2]
+
+        Parameters
+        ----------
+        V : float or numpy.ndarray
+            Volume (in the same units as V0)
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Bulk modulus (in the same units as K0)
+        """
+        V = validate_volume(V)
+        f = ((self.V0 / V) ** (2 / 3) - 1) / 2
+        return (1.0 + 2.0 * f) ** (5.0 / 2.0) * (
+            self.K0
+            + (3.0 * self.K0 * self.K0_prime - 5 * self.K0) * f
+            + 27.0 / 2.0 * (self.K0 * self.K0_prime - 4.0 * self.K0) * f * f
+        )
+
+class BM4(EosBase):
+    """
+    4th-order Birch-Murnaghan equation of state.
+
+    The 4th-order Birch-Murnaghan EOS is defined as:
+    P(V) = (3/2) * K0 * [(V0/V)^(-7/3) - (V0/V)^(-5/3)] * 
+            { 1 + (3/4) * (K0'- 4) * ((V0/V)^(-2/3) - 1) + (3/8) * [K0 * K0'' + (K0'- 4) * (K0' - 3) + (35/9)] * ((V0/V)^(-2/3) - 1)
+
+    or in terms of the Eulerian strain f = [(V0/V)^(2/3) - 1]/2, zeta = (3/4) * (4 - K0'), and xi = (3/8) * [K0 * K0'' + (K0'- 4) * (K0' - 3) + (35/9)]:
+    P(f) = 3 * K0 *f * (1 + 2f)^(5/2) * [1 + 2 * zeta * f + 4 * xi * f ** 2] 
+    
+    Equations from:
+    Anderson, O.L., (1995) Equations of State of Solids for Geophysics and Ceramic Science,
+    Oxford University Press, Oxford, UK.
+    """
+
+    def __init__(self, V0: float, K0: float, K0_prime: float, K0_double_prime: float) -> None:
+        """
+        Initialize the 4th-order Birch-Murnaghan EOS.
+
+        Parameters
+        ----------
+        V0 : float
+            Reference volume (in cubic angstroms or any consistent unit)
+        K0 : float
+            Bulk modulus at reference volume (in GPa or any consistent unit)
+        K0_prime : float
+            Pressure derivative of the bulk modulus at reference volume (dimensionless)
+        K0_double_prime : float
+            Second pressure derivative of the bulk modulus at reference volume
+            (inverse pressure, e.g. GPa^-1 when K0 is in GPa)
+        """
+        self.V0 = validate_positive_scalar(V0, "V0")
+        self.K0 = validate_positive_scalar(K0, "K0")
+        self.K0_prime = validate_finite_scalar(K0_prime, "K0_prime")
+        self.K0_double_prime = validate_finite_scalar(
+            K0_double_prime, "K0_double_prime"
+        )
+
+    def pressure(self, V: NumericType) -> NumericType:
+        """
+        Calculate pressure using the 4th-order Birch-Murnaghan EOS.
+
+        Parameters
+        ----------
+        V : float or numpy.ndarray
+            Volume (in the same units as V0)
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Pressure (in the same units as K0)
+        """
+        V = validate_volume(V)
+        f = ((self.V0/V) ** (2 / 3) - 1) / 2
+        zeta = (3 / 4) * (4 - self.K0_prime)
+        xi = (3 / 8) * (self.K0 * self.K0_double_prime + (self.K0_prime - 4) * (self.K0_prime - 3) + (35 / 9))
+        return (
+            3 
+            * self.K0 
+            * f 
+            * (1 + 2 * f) ** (5/2) 
+            * (1 - 2 * zeta * f + 4 * xi * f ** 2)
+        ) 
+
+    def bulk_modulus(self, V: NumericType) -> NumericType:
+        """
+        Calculate the bulk modulus at the given volume.
+
+        For the 4th-order Birch-Murnaghan EOS, the bulk modulus at V0 with f = f = ((V0/V) ** (2 / 3) - 1) / 2
+        zeta = (3 / 4) * (4 - K0_prime)
+        xi = (3 / 8) * [K0 * K0_double_prime + (K0_prime - 4) * (K0_prime - 3) + (35 / 9)]
+        K(f) = 5 * self.K0 * (1 + 2 * f) ** (5 / 2) * (1 - 2 * zeta * f + 4 * xi * f ** 2) + self.K0 * (1 + 2 * f) ** (7 / 2)
+            * (1 - 4 * zeta * f + 12 * xi * f ** 2)
+
+        Parameters
+        ----------
+        V : float or numpy.ndarray
+            Volume (in the same units as V0)
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Bulk modulus (in the same units as K0)
+        """
+        V = validate_volume(V)
+        f = ((self.V0/V) ** (2 / 3) - 1) / 2
+        zeta = (3 / 4) * (4 - self.K0_prime)
+        xi = (3 / 8) * (self.K0 * self.K0_double_prime + (self.K0_prime - 4) * (self.K0_prime - 3) + (35 / 9))
+        return (
+            5 
+            * f
+            * self.K0
+            * (1 + 2 * f) ** (5 / 2)
+            * (1 - 2 * zeta * f + 4 * xi * f ** 2) 
+            + self.K0
+            * (1 + 2 * f) ** (7 / 2)
+            * (1 - 4 * zeta * f + 12 * xi * f ** 2)
+        )

peritheos/eos/rt/holzapfel.py

@@ -0,0 +1,196 @@
+import numpy as np
+from peritheos.eos import (
+    EosBase,
+    NumericType,
+    validate_finite_scalar,
+    validate_positive_scalar,
+    validate_volume,
+)
+
+
+class Holzapfel(EosBase):
+    """
+    Holzapfel equation of state. Introduced in Holzapfel et al. 2001. And here implemented as described in
+    Sokolova et al. 2016.
+    """
+
+    def __init__(self, V0: float, K0: float, K0_prime: float, n: float, Z: int) -> None:
+        """
+        Initialize the Holzapfel equation of state.
+
+        **Note:**
+        Contrary to other EOS implementations, the reference values need to be provided in the correct units.
+        For consistency with the equation of states, the pressure unit is GPa - contrary to excel spreadsheets from
+        Sokolova et al. 2016 where the bulk modulus is given in kbar.
+
+        Parameters
+        ----------
+        V0 : float
+            Reference volume [JBar^-1] (same as [cm^3/mol]/10)
+        K0 : float
+            Bulk modulus at reference volume in [GPa]
+        K0_prime : float
+            Pressure derivative of bulk modulus at reference volume
+        n : float
+            Number of atoms in a chemical formula
+        Z : int
+            Atomic number of the forumala unit
+        """
+        super().__init__()
+        self.V0 = validate_positive_scalar(V0, "V0")
+        self.K0 = validate_positive_scalar(K0, "K0")
+        self.K0_prime = validate_finite_scalar(K0_prime, "K0_prime")
+        self.n = validate_positive_scalar(n, "n")
+        self.Z = validate_positive_scalar(Z, "Z")
+
+        self._P_FG0 = 1003.6 * (self.Z * self.n / (self.V0 * 10)) ** (5 / 3)
+        self._c0 = -np.log(3 * self.K0 / self._P_FG0)
+        self._c2 = 1.5 * (self.K0_prime - 3) - self._c0
+
+    def pressure(self, V: NumericType) -> NumericType:
+        """
+        Calculate pressure using the Holzapfel equation of state.
+
+        Parameters
+        ----------
+        V : float or np.ndarray
+            Volume in [JBar^-1] (same as [cm^3/mol]/10)
+
+        Returns
+        -------
+        float or np.ndarray
+            Pressure in [GPa]
+        """
+        V = validate_volume(V)
+        x = (V / self.V0) ** (1 / 3)
+        return (
+            3
+            * self.K0
+            * np.exp(self._c0 * (1 - x))
+            * (1 / x**5 - 1 / x**4)
+            * (1 + self._c2 * x - self._c2 * x**2)
+        )
+
+    def bulk_modulus(self, V: NumericType) -> NumericType:
+        """
+        Calculate bulk modulus using the Holzapfel equation of state.
+
+        Parameters
+        ----------
+        V : float or np.ndarray
+            Volume in [JBar^-1] (same as [cm^3/mol]/10)
+
+        Returns
+        -------
+        float or np.ndarray
+            Bulk modulus in [GPa]
+        """
+        V = validate_volume(V)
+        x = (V / self.V0) ** (1 / 3)
+        term1 = self.K0 * x**-5 * np.exp(self._c0 * (1 - x))
+
+        bracket_1 = (5 - 4 * x) * (1 + self._c2 * x * (1 - x))
+        bracket_2 = self._c0 * x * (1 - x) * (1 + self._c2 * x * (1 - x))
+        bracket_3 = -(1 - x) * (self._c2 * x - 2 * self._c2 * x**2)
+        term2 = bracket_1 + bracket_2 + bracket_3
+        return term1 * term2
+
+    def bulk_modulus_derivative(self, V: NumericType, eps: float = 1e-6) -> NumericType:
+        """
+        Compute the pressure derivative of the bulk modulus using a
+        numerical approximation.
+
+        This method provides a faster alternative to the analytical approach implemented in
+        `bulk_modulus_derivative_analytical`, which is more than twice as slow. The numerical
+        derivative is computed using a small relative perturbation in volume with a step size of `eps`.
+
+        Parameters
+        ----------
+        V : float or np.ndarray
+            Volume in [JBar^-1] (same as [cm^3/mol]/10)
+        eps : float
+            Step size for the numerical derivative, default is 1e-6. This value is used as the
+            relative difference between the two perturbed volumes. The accuracy of the numerical
+            derivative is approximately `eps * 100%`.
+
+        Returns
+        -------
+        float or np.ndarray
+            Pressure derivative of bulk modulus (unitless)
+        """
+        V = validate_volume(V)
+        eps = validate_positive_scalar(eps, "eps")
+        if eps >= 1:
+            raise ValueError("eps must be smaller than one")
+        V = np.array([V * (1 + eps), V * (1 - eps)])
+        P = self.pressure(V)
+        K = self.bulk_modulus(V)
+        return (K[0] - K[1]) / (P[0] - P[1])
+
+
+def bulk_modulus_derivative_analytical(V0, V, KT, K0, c0, c2):
+    """
+    Calculate the pressure derivative of bulk modulus using the Holzapfel equation of state.
+    Equation have been taken from excel sheets provided in Sokolova et al. 2016. The listed equation (5) on page
+    163 in this paper seems to be incorrect.
+    Values have been verified against the excel sheets provided by Sokolova et al. 2016 and the numerical
+    derivative (see test_holzapfel.py).
+
+    Parameters
+    ----------
+    V : float or np.ndarray
+        Volume in [JBar^-1] (same as [cm^3/mol]/10)
+    KT : float or np.ndarray
+        Bulk modulus in [kbar]
+    K0 : float
+        Bulk modulus at reference volume in [kbar]
+    c0 : float
+        Constant in the Holzapfel equation of state
+    c2 : float
+        Constant in the Holzapfel equation of state
+    Returns
+    -------
+    """
+    x = (V / V0) ** (1 / 3)
+
+    # convert moduli from GPa to bar
+    K0 = K0 * 10000
+    KT = KT * 10000
+
+    term1 = (
+        3
+        / x**4
+        * K0
+        * np.exp(c0 * (1 - x))
+        * (
+            (-5 / x**2 + 4 / x) * (1 + c2 * x - c2 * x**2)
+            - (1 / x - 1) * (1 + c2 * x - c2 * x**2) * c0
+            + (1 / x - 1) * (c2 - 2 * c2 * x)
+        )
+    )
+    term2 = (
+        1
+        / x**3
+        * K0
+        * np.exp(c0 * (1 - x))
+        * c0
+        * (
+            (-5 / x**2 + 4 / x) * (1 + c2 * x - c2 * x**2)
+            - (1 / x - 1) * (1 + c2 * x - c2 * x**2) * c0
+            + (1 / x - 1) * (c2 - 2 * c2 * x)
+        )
+    )
+    term3 = (
+        K0
+        * np.exp(c0 * (1 - x))
+        * (
+            (10 / x**3 - 4 / x**2) * (1 + c2 * x - c2 * x**2)
+            + (-5 / x**2 + 4 / x) * (c2 - 2 * c2 * x)
+            + c0 / x**2 * (1 + c2 * x - c2 * x**2)
+            - (1 / x - 1) * (c2 - 2 * c2 * x) * c0
+            - (c2 - 2 * c2 * x) / x**2
+            - 2 * c2 * (1 / x - 1)
+        )
+        / x**3
+    )
+    return (term1 + term2 - term3) / (-KT / x) / 3

peritheos/eos/rt/vinet.py

@@ -0,0 +1,86 @@
+"""
+Vinet equation of state
+"""
+
+import numpy as np
+from peritheos.eos import (
+    EosBase,
+    NumericType,
+    validate_finite_scalar,
+    validate_positive_scalar,
+    validate_volume,
+)
+
+
+class Vinet(EosBase):
+    """
+    Vinet equation of state. It has been presented multiple times in the literature. But has been
+    attributed finally to Vinet 1986, 1987. An earlier description can be found in the work of
+    Stacey et al. 1981. The Vinet EOS is based on a variant of the Morse potential, the Rydberg
+    potential which was introduced by Rydberg in 1932.
+
+    The Vinet EOS is defined as:
+    P(V) = 3 * K0 * (1 - f)/ f^2 * exp(3/2 * (K0_prime - 1) * (1 - f))
+    where f = (V / V0)^(1/3)
+
+    The bulk modulus is given by:
+    K(V) = K0 * f^(-2) * (1 + (eta * f + 1) * (1 - f) * exp(eta * (1 - f)))
+    where f = (V / V0)^(1/3)
+    and eta = 3/2 * (K0_prime - 1)
+    """
+
+    def __init__(self, V0: float, K0: float, K0_prime: float) -> None:
+        """
+        Initialize the Vinet equation of state.
+
+        Parameters
+        ----------
+        V0 : float
+            Reference volume (in cubic angstroms or any consistent unit)
+        K0 : float
+            Bulk modulus at reference volume (in GPa or any consistent unit)
+        K0_prime : float
+            Pressure derivative of bulk modulus at reference volume
+        """
+        self.V0 = validate_positive_scalar(V0, "V0")
+        self.K0 = validate_positive_scalar(K0, "K0")
+        self.K0_prime = validate_finite_scalar(K0_prime, "K0_prime")
+
+    def pressure(self, V: NumericType) -> NumericType:
+        """
+        Calculate pressure using the Vinet equation of state.
+
+        Parameters
+        ----------
+        V : float or numpy.ndarray
+            Volume (in cubic angstroms or any consistent unit)
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Pressure (in the same units as K0)
+        """
+        V = validate_volume(V)
+        f = (V / self.V0) ** (1 / 3)
+        return (
+            3 * self.K0 * (1 - f) / f**2 * np.exp(3 / 2 * (self.K0_prime - 1) * (1 - f))
+        )
+
+    def bulk_modulus(self, V: NumericType) -> NumericType:
+        """
+        Calculate the bulk modulus using the Vinet equation of state.
+
+        Parameters
+        ----------
+        V : float or numpy.ndarray
+            Volume (in cubic angstroms or any consistent unit)
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Bulk modulus (in the same units as K0)
+        """
+        V = validate_volume(V)
+        f = (V / self.V0) ** (1 / 3)
+        eta = 3 / 2 * (self.K0_prime - 1)
+        return self.K0 * f**-2 * (1 + (eta * f + 1) * (1 - f)) * np.exp(eta * (1 - f))

peritheos/eos/thermal/__init__.py

@@ -0,0 +1,5 @@
+"""
+This module contains the thermal equations of state (EOS) implementations.
+"""
+
+from .sokolova2016 import Sokolova2016