weac 2.6.4__py3-none-any.whl → 3.0.1__py3-none-any.whl

weac/core/eigensystem.py

@@ -0,0 +1,405 @@
+"""
+This module provides the Eigensystem class, which is used to solve
+the eigenvalue problem for a layered beam on an elastic foundation.
+"""
+
+import logging
+from typing import Optional
+
+import numpy as np
+from numpy.typing import NDArray
+
+from weac.components import WeakLayer
+from weac.constants import SHEAR_CORRECTION_FACTOR
+from weac.core.slab import Slab
+from weac.utils.misc import decompose_to_normal_tangential
+
+logger = logging.getLogger(__name__)
+
+
+class Eigensystem:
+    """
+    Calculates system properties and solves the eigenvalue problem
+    for a layered beam on an elastic foundation (Winkler model).
+
+    Attributes
+    ----------
+    weak_layer: WeakLayer
+    slab: Slab
+
+    System properties
+    -----------------
+    A11: float          # extensional stiffness
+    B11: float          # coupling stiffness
+    D11: float          # bending stiffness
+    kA55: float         # shear stiffness
+    K0: float           # foundation stiffness
+
+    Eigenvalues and Eigenvectors
+    ----------------------------
+    ewC: NDArray[np.complex128]     # shape (k): Complex Eigenvalues
+    ewR: NDArray[np.float64]        # shape (k): Real Eigenvalues
+    evC: NDArray[np.complex128]     # shape (6, k): Complex Eigenvectors
+    evR: NDArray[np.float64]        # shape (6, k): Real Eigenvectors
+    sR: NDArray[np.float64]         # shape (k): Real positive eigenvalue shifts
+                                    # (for numerical robustness)
+    sC: NDArray[np.float64]         # shape (k): Complex positive eigenvalue shifts
+                                    # (for numerical robustness)
+    """
+
+    # Input data
+    weak_layer: WeakLayer
+    slab: Slab
+
+    # System properties
+    A11: float  # extensional stiffness
+    B11: float  # coupling stiffness
+    D11: float  # bending stiffness
+    kA55: float  # shear stiffness
+    K0: float  # foundation stiffness
+
+    K: NDArray  # System Matrix
+
+    # Eigenvalues and Eigenvectors
+    ewC: NDArray[np.complex128]  # shape (k): Complex Eigenvalues
+    ewR: NDArray[np.float64]  # shape (k): Real Eigenvalues
+    evC: NDArray[np.complex128]  # shape (6, k): Complex Eigenvectors
+    evR: NDArray[np.float64]  # shape (6, k): Real Eigenvectors
+    sR: NDArray[
+        np.float64
+    ]  # shape (k): Real positive eigenvalue shifts (for numerical robustness)
+    sC: NDArray[
+        np.float64
+    ]  # shape (k): Complex positive eigenvalue shifts (for numerical robustness)
+
+    def __init__(self, weak_layer: WeakLayer, slab: Slab):
+        self.slab = slab
+        self.weak_layer = weak_layer
+
+        self.calc_eigensystem()
+
+    def calc_eigensystem(self):
+        """Calculate the fundamental system of the problem."""
+        self._calc_laminate_stiffness_parameters()
+        self.K = self.assemble_system_matrix(kn=None, kt=None)
+        self.ewC, self.ewR, self.evC, self.evR, self.sR, self.sC = (
+            self.calc_eigenvalues_and_eigenvectors(self.K)
+        )
+
+    def _calc_laminate_stiffness_parameters(self):
+        """
+        Provide ABD matrix.
+
+        Return plane-strain laminate stiffness matrix (ABD matrix).
+        """
+        # Append z_{1} at top of surface layer
+        zis = np.concatenate(([-self.slab.H / 2], self.slab.zi_bottom))
+
+        # Initialize stiffness components
+        A11, B11, D11, kA55 = 0, 0, 0, 0
+        # Add layerwise contributions
+        for i in range(len(zis) - 1):
+            E = self.slab.Ei[i]
+            G = self.slab.Gi[i]
+            nu = self.slab.nui[i]
+            A11 += E / (1 - nu**2) * (zis[i + 1] - zis[i])
+            B11 += 1 / 2 * E / (1 - nu**2) * (zis[i + 1] ** 2 - zis[i] ** 2)
+            D11 += 1 / 3 * E / (1 - nu**2) * (zis[i + 1] ** 3 - zis[i] ** 3)
+            kA55 += SHEAR_CORRECTION_FACTOR * G * (zis[i + 1] - zis[i])
+
+        self.A11 = A11
+        self.B11 = B11
+        self.D11 = D11
+        self.kA55 = kA55
+        self.K0 = B11**2 - A11 * D11
+
+    def assemble_system_matrix(
+        self, kn: Optional[float], kt: Optional[float]
+    ) -> NDArray[np.float64]:
+        """
+        Assemble first-order ODE system matrix K.
+
+        Using the solution vector z = [u, u', w, w', psi, psi']
+        the ODE system is written in the form Az' + Bz = d
+        and rearranged to z' = -(A^-1)Bz + (A^-1)d = Kz + q
+
+        Returns
+        -------
+        NDArray[np.float64]
+            System matrix K (6x6).
+        """
+        kn = kn or self.weak_layer.kn
+        kt = kt or self.weak_layer.kt
+        H = self.slab.H  # total slab thickness
+        h = self.weak_layer.h  # weak layer thickness
+
+        # Abbreviations
+        K21 = kt * (-2 * self.D11 + self.B11 * (H + h)) / (2 * self.K0)
+        K24 = (
+            2 * self.D11 * kt * h
+            - self.B11 * kt * h * (H + h)
+            + 4 * self.B11 * self.kA55
+        ) / (4 * self.K0)
+        K25 = (
+            -2 * self.D11 * H * kt
+            + self.B11 * H * kt * (H + h)
+            + 4 * self.B11 * self.kA55
+        ) / (4 * self.K0)
+        K43 = kn / self.kA55
+        K61 = kt * (2 * self.B11 - self.A11 * (H + h)) / (2 * self.K0)
+        K64 = (
+            -2 * self.B11 * kt * h
+            + self.A11 * kt * h * (H + h)
+            - 4 * self.A11 * self.kA55
+        ) / (4 * self.K0)
+        K65 = (
+            2 * self.B11 * H * kt
+            - self.A11 * H * kt * (H + h)
+            - 4 * self.A11 * self.kA55
+        ) / (4 * self.K0)
+
+        # System matrix
+        K = [
+            [0, 1, 0, 0, 0, 0],
+            [K21, 0, 0, K24, K25, 0],
+            [0, 0, 0, 1, 0, 0],
+            [0, 0, K43, 0, 0, -1],
+            [0, 0, 0, 0, 0, 1],
+            [K61, 0, 0, K64, K65, 0],
+        ]
+
+        return np.array(K, dtype=np.float64)
+
+    def calc_eigenvalues_and_eigenvectors(
+        self, system_matrix: NDArray[np.float64]
+    ) -> tuple[
+        NDArray[np.complex128],
+        NDArray[np.float64],
+        NDArray[np.complex128],
+        NDArray[np.float64],
+        NDArray[np.float64],
+        NDArray[np.float64],
+    ]:
+        """
+        Calculate eigenvalues and eigenvectors of the system matrix.
+
+        Parameters:
+        -----------
+        system_matrix: NDArray          # system_matrix size (6x6) of the eigenvalue problem
+
+        Return:
+        -------
+        ewC: NDArray[np.complex128]     # shape (k): Complex Eigenvalues
+        ewR: NDArray[np.float64]        # shape (g): Real Eigenvalues
+        evC: NDArray[np.complex128]     # shape (6, k): Complex Eigenvectors
+        evR: NDArray[np.float64]        # shape (6, g): Real Eigenvectors
+        sR: NDArray[np.float64]         # shape (k): Real positive eigenvalue shifts
+                                        # (for numerical robustness)
+        sC: NDArray[np.float64]         # shape (g): Complex positive eigenvalue shifts
+                                        # (for numerical robustness)
+        """
+        # Calculate eigenvalues (ew) and eigenvectors (ev)
+        ew, ev = np.linalg.eig(system_matrix)
+        # Classify real and complex eigenvalues
+        real = (ew.imag == 0) & (ew.real != 0)  # real eigenvalues
+        cmplx = ew.imag > 0  # positive complex conjugates
+        # Eigenvalues
+        ewC = ew[cmplx]
+        ewR = ew[real].real
+        # Eigenvectors
+        evC = ev[:, cmplx]
+        evR = ev[:, real].real
+        # Prepare positive eigenvalue shifts for numerical robustness
+        # 1. Keep small-positive eigenvalues away from zero, to not have a near-singular matrix
+        sR, sC = np.zeros(ewR.shape), np.zeros(ewC.shape)
+        sR[ewR > 0], sC[ewC > 0] = -1, -1
+        return ewC, ewR, evC, evR, sR, sC
+
+    def zh(self, x: float, length: float = 0, has_foundation: bool = True) -> NDArray:
+        """
+        Compute bedded or free complementary solution at position x.
+
+        Arguments
+        ---------
+        x : float
+            Horizontal coordinate (mm).
+        length : float, optional
+            Segment length (mm). Default is 0.
+        has_foundation : bool
+            Indicates whether segment has foundation or not. Default
+            is True.
+
+        Returns
+        -------
+        zh : ndarray
+            Complementary solution matrix (6x6) at position x.
+        """
+        if has_foundation:
+            zh = np.concatenate(
+                [
+                    # Real
+                    self.evR * np.exp(self.ewR * (x + length * self.sR)),
+                    # Complex
+                    np.exp(self.ewC.real * (x + length * self.sC))
+                    * (
+                        self.evC.real * np.cos(self.ewC.imag * x)
+                        - self.evC.imag * np.sin(self.ewC.imag * x)
+                    ),
+                    # Complex
+                    np.exp(self.ewC.real * (x + length * self.sC))
+                    * (
+                        self.evC.imag * np.cos(self.ewC.imag * x)
+                        + self.evC.real * np.sin(self.ewC.imag * x)
+                    ),
+                ],
+                axis=1,
+            )
+        else:
+            # Abbreviations
+            H14 = 3 * self.B11 / self.A11 * x**2
+            H24 = 6 * self.B11 / self.A11 * x
+            H54 = -3 * x**2 + 6 * self.K0 / (self.A11 * self.kA55)
+            # Complementary solution matrix of free segments
+            zh = np.array(
+                [
+                    [0, 0, 0, H14, 1, x],
+                    [0, 0, 0, H24, 0, 1],
+                    [1, x, x**2, x**3, 0, 0],
+                    [0, 1, 2 * x, 3 * x**2, 0, 0],
+                    [0, -1, -2 * x, H54, 0, 0],
+                    [0, 0, -2, -6 * x, 0, 0],
+                ]
+            )
+
+        return zh
+
+    def zp(
+        self, x: float, phi: float = 0, has_foundation=True, qs: float = 0
+    ) -> NDArray:
+        """
+        Compute bedded or free particular integrals at position x.
+
+        Arguments
+        ---------
+        x : float
+            Horizontal coordinate (mm).
+        phi : float
+            Inclination (degrees).
+        has_foundation : bool
+            Indicates whether segment has foundation (True) or not
+            (False). Default is True.
+        qs : float
+            additional surface load weight
+
+        Returns
+        -------
+        zp : ndarray
+            Particular integral vector (6x1) at position x.
+        """
+        # Get weight and surface loads
+        qw_n, qw_t = decompose_to_normal_tangential(f=self.slab.qw, phi=phi)
+        qs_n, qs_t = decompose_to_normal_tangential(f=qs, phi=phi)
+
+        # Weak Layer properties
+        kn = self.weak_layer.kn
+        kt = self.weak_layer.kt
+        h = self.weak_layer.h
+
+        # Slab properties
+        H = self.slab.H
+        z_cog = self.slab.z_cog
+
+        # Laminate stiffnesses
+        A11 = self.A11
+        B11 = self.B11
+        kA55 = self.kA55
+        K0 = self.K0
+
+        # Assemble particular integral vectors
+        if has_foundation:
+            zp = np.array(
+                [
+                    [
+                        (qw_t + qs_t) / kt
+                        + H * qw_t * (H + h - 2 * z_cog) / (4 * kA55)
+                        + H * qs_t * (2 * H + h) / (4 * kA55)
+                    ],
+                    [0],
+                    [(qw_n + qs_n) / kn],
+                    [0],
+                    [-(qw_t * (H + h - 2 * z_cog) + qs_t * (2 * H + h)) / (2 * kA55)],
+                    [0],
+                ]
+            )
+        else:
+            zp = np.array(
+                [
+                    [
+                        (-3 * (qw_t + qs_t) / A11 - B11 * (qw_n + qs_n) * x / K0)
+                        / 6
+                        * x**2
+                    ],
+                    [(-2 * (qw_t + qs_t) / A11 - B11 * (qw_n + qs_n) * x / K0) / 2 * x],
+                    [-A11 * (qw_n + qs_n) * x**4 / (24 * K0)],
+                    [-A11 * (qw_n + qs_n) * x**3 / (6 * K0)],
+                    [
+                        A11 * (qw_n + qs_n) * x**3 / (6 * K0)
+                        + (
+                            (z_cog - B11 / A11) * qw_t
+                            - H * qs_t / 2
+                            - (qw_n + qs_n) * x
+                        )
+                        / kA55
+                    ],
+                    [(qw_n + qs_n) * (A11 * x**2 / (2 * K0) - 1 / kA55)],
+                ]
+            )
+
+        return zp
+
+    def get_load_vector(self, phi: float, qs: float = 0) -> NDArray:
+        """
+        Compute system load vector q.
+
+        Using the solution vector z = [u, u', w, w', psi, psi']
+        the ODE system is written in the form Az' + Bz = d
+        and rearranged to z' = -(A ^ -1)Bz + (A ^ -1)d = Kz + q
+
+        Arguments
+        ---------
+        phi : float
+            Inclination [deg]. Counterclockwise positive.
+        qs : float
+            Surface Load [N/mm]
+
+        Returns
+        -------
+        ndarray
+            System load vector q (6x1).
+        """
+        # Get weight and surface loads
+        qw_n, qw_t = decompose_to_normal_tangential(f=self.slab.qw, phi=phi)
+        qs_n, qs_t = decompose_to_normal_tangential(f=qs, phi=phi)
+
+        return np.array(
+            [
+                [0],
+                [
+                    (
+                        self.B11 * (self.slab.H * qs_t - 2 * qw_t * self.slab.z_cog)
+                        + 2 * self.D11 * (qw_t + qs_t)
+                    )
+                    / (2 * self.K0)
+                ],
+                [0],
+                [-(qw_n + qs_n) / self.kA55],
+                [0],
+                [
+                    -(
+                        self.A11 * (self.slab.H * qs_t - 2 * qw_t * self.slab.z_cog)
+                        + 2 * self.B11 * (qw_t + qs_t)
+                    )
+                    / (2 * self.K0)
+                ],
+            ]
+        )

weac/core/field_quantities.py

@@ -0,0 +1,273 @@
+"""
+This module defines the FieldQuantities class, which is responsible for calculating
+and providing access to various physical quantities within the slab.
+"""
+
+from typing import Literal
+
+import numpy as np
+
+from weac.core.eigensystem import Eigensystem
+
+LengthUnit = Literal["m", "cm", "mm", "um"]
+AngleUnit = Literal["deg", "rad"]
+StressUnit = Literal["Pa", "kPa", "MPa", "GPa"]
+EnergyUnit = Literal["J/m^2", "kJ/m^2", "N/mm"]
+Unit = Literal[LengthUnit, AngleUnit, StressUnit, EnergyUnit]
+
+_UNIT_FACTOR: dict[str, float] = {
+    "m": 1e-3,
+    "cm": 1e-1,
+    "mm": 1,
+    "um": 1e3,
+    "rad": 1,
+    "deg": 180 / np.pi,
+    "Pa": 1e6,
+    "kPa": 1e3,
+    "MPa": 1,
+    "GPa": 1e-3,
+    "J/m^2": 1e3,  # joule per square meter
+    "kJ/m^2": 1,  # kilojoule per square meter
+    "N/mm": 1,  # newton per millimeter
+}
+
+
+class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many-public-methods
+    """
+    Convenience accessors for a 6xN solution matrix Z =
+    [u, u', w, w', ψ, ψ']ᵀ.  All functions are *vectorized* along the second
+    axis (x-coordinate), so they return an `ndarray` of length N.
+    """
+
+    def __init__(self, eigensystem: Eigensystem):
+        self.es = eigensystem
+
+    @staticmethod
+    def _unit_factor(unit: Unit, /) -> float:
+        """Return multiplicative factor associated with *unit*."""
+        try:
+            return _UNIT_FACTOR[unit]
+        except KeyError as exc:
+            raise ValueError(
+                f"Unsupported unit: {unit!r}, supported units are {_UNIT_FACTOR}"
+            ) from exc
+
+    def u(
+        self,
+        Z: np.ndarray,
+        h0: float = 0,
+        unit: LengthUnit = "mm",
+    ) -> float | np.ndarray:
+        """Horizontal displacement *u = u₀ + h₀ ψ* at depth h₀."""
+        return self._unit_factor(unit) * (Z[0, :] + h0 * self.psi(Z))
+
+    def du_dx(self, Z: np.ndarray, h0: float) -> float | np.ndarray:
+        """Derivative u' = u₀' + h₀ ψ'."""
+        return Z[1, :] + h0 * self.dpsi_dx(Z)
+
+    def w(self, Z: np.ndarray, unit: LengthUnit = "mm") -> float | np.ndarray:
+        """Center-line deflection *w*."""
+        return self._unit_factor(unit) * Z[2, :]
+
+    def dw_dx(self, Z: np.ndarray) -> float | np.ndarray:
+        """First derivative w'."""
+        return Z[3, :]
+
+    def psi(
+        self,
+        Z: np.ndarray,
+        unit: AngleUnit = "rad",
+    ) -> float | np.ndarray:
+        """Rotation ψ of the mid-plane."""
+        factor = self._unit_factor(unit)
+        return factor * Z[4, :]
+
+    def dpsi_dx(self, Z: np.ndarray) -> float | np.ndarray:
+        """First derivative ψ′."""
+        return Z[5, :]
+
+    def N(self, Z: np.ndarray) -> float | np.ndarray:
+        """Axial normal force N = A11 u' + B11 psi' in the slab [N]"""
+        return self.es.A11 * Z[1, :] + self.es.B11 * Z[5, :]
+
+    def M(self, Z: np.ndarray) -> float | np.ndarray:
+        """Bending moment M = B11 u' + D11 psi' in the slab [Nmm]"""
+        return self.es.B11 * Z[1, :] + self.es.D11 * Z[5, :]
+
+    def V(self, Z: np.ndarray) -> float | np.ndarray:
+        """Vertical shear force V = kA55(w' + psi) [N]"""
+        return self.es.kA55 * (Z[3, :] + Z[4, :])
+
+    def sig(self, Z: np.ndarray, unit: StressUnit = "MPa") -> float | np.ndarray:
+        """Weak-layer normal stress"""
+        return -self._unit_factor(unit) * self.es.weak_layer.kn * self.w(Z)
+
+    def tau(self, Z: np.ndarray, unit: StressUnit = "MPa") -> float | np.ndarray:
+        """Weak-layer shear stress"""
+        return (
+            -self._unit_factor(unit)
+            * self.es.weak_layer.kt
+            * (
+                self.dw_dx(Z) * self.es.weak_layer.h / 2
+                - self.u(Z, h0=self.es.slab.H / 2)
+            )
+        )
+
+    def eps(self, Z: np.ndarray) -> float | np.ndarray:
+        """Weak-layer normal strain"""
+        return -self.w(Z) / self.es.weak_layer.h
+
+    def gamma(self, Z: np.ndarray) -> float | np.ndarray:
+        """Weak-layer shear strain."""
+        return (
+            self.dw_dx(Z) / 2 - self.u(Z, h0=self.es.slab.H / 2) / self.es.weak_layer.h
+        )
+
+    def Gi(self, Ztip: np.ndarray, unit: EnergyUnit = "kJ/m^2") -> float | np.ndarray:
+        """Mode I differential energy release rate at crack tip.
+
+        Arguments
+        ---------
+        Ztip : ndarray
+            Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T
+            at the crack tip.
+        unit : {'N/mm', 'kJ/m^2', 'J/m^2'}, optional
+            Desired output unit. Default is kJ/m^2.
+        """
+        return (
+            self._unit_factor(unit) * self.sig(Ztip) ** 2 / (2 * self.es.weak_layer.kn)
+        )
+
+    def Gii(self, Ztip: np.ndarray, unit: EnergyUnit = "kJ/m^2") -> float | np.ndarray:
+        """Mode II differential energy release rate at crack tip.
+
+        Arguments
+        ---------
+        Ztip : ndarray
+            Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T
+            at the crack tip.
+        unit : {'N/mm', 'kJ/m^2', 'J/m^2'}, optional
+            Desired output unit. Default is kJ/m^2 = N/mm.
+        """
+        return (
+            self._unit_factor(unit) * self.tau(Ztip) ** 2 / (2 * self.es.weak_layer.kt)
+        )
+
+    def dz_dx(self, z: np.ndarray, phi: float, qs: float = 0) -> np.ndarray:
+        """First derivative z'(x) = K*z(x) + q of the solution vector.
+
+        z'(x) = [u'(x) u''(x) w'(x) w''(x) psi'(x), psi''(x)]^T
+
+        Parameters
+        ----------
+        z : ndarray
+            Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T
+        phi : float
+            Inclination (degrees). Counterclockwise positive.
+
+        Returns
+        -------
+        ndarray
+            First derivative z'(x) for the solution vector (6x1).
+        """
+        K = self.es.K
+        q = self.es.get_load_vector(phi=phi, qs=qs)
+        return np.dot(K, z) + q
+
+    def dz_dxdx(self, z: np.ndarray, phi: float, qs: float) -> np.ndarray:
+        """
+        Get second derivative z''(x) = K*z'(x) of the solution vector.
+
+        z''(x) = [u''(x) u'''(x) w''(x) w'''(x) psi''(x), psi'''(x)]^T
+
+        Parameters
+        ----------
+        z : ndarray
+            Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T
+        phi : float
+            Inclination (degrees). Counterclockwise positive.
+
+        Returns
+        -------
+        ndarray
+            Second derivative z''(x) = (K*z(x) + q)' = K*z'(x) = K*(K*z(x) + q)
+            of the solution vector (6x1).
+        """
+        K = self.es.K
+        q = self.es.get_load_vector(phi=phi, qs=qs)
+        dz_dx = np.dot(K, z) + q
+        return np.dot(K, dz_dx)
+
+    def du0_dxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray:
+        """
+        Get second derivative of the horiz. centerline displacement u0''(x).
+
+        Parameters
+        ----------
+        z : ndarray
+            Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T.
+        phi : float
+            Inclination (degrees). Counterclockwise positive.
+
+        Returns
+        -------
+        ndarray, float
+            Second derivative of the horizontal centerline displacement
+            u0''(x) (1/mm).
+        """
+        return self.dz_dx(z, phi, qs)[1, :]
+
+    def dpsi_dxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray:
+        """
+        Get second derivative of the cross-section rotation psi''(x).
+
+        Parameters
+        ----------
+        z : ndarray
+            Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T.
+        phi : float
+            Inclination (degrees). Counterclockwise positive.
+
+        Returns
+        -------
+        ndarray, float
+            Second derivative of the cross-section rotation psi''(x) (1/mm^2).
+        """
+        return self.dz_dx(z, phi, qs)[5, :]
+
+    def du0_dxdxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray:
+        """
+        Get third derivative of the horiz. centerline displacement u0'''(x).
+
+        Parameters
+        ----------
+        z : ndarray
+            Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T.
+        phi : float
+            Inclination (degrees). Counterclockwise positive.
+
+        Returns
+        -------
+        ndarray, float
+            Third derivative of the horizontal centerline displacement
+            u0'''(x) (1/mm^2).
+        """
+        return self.dz_dxdx(z, phi, qs)[1, :]
+
+    def dpsi_dxdxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray:
+        """
+        Get third derivative of the cross-section rotation psi'''(x).
+
+        Parameters
+        ----------
+        z : ndarray
+            Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T.
+        phi : float
+            Inclination (degrees). Counterclockwise positive.
+
+        Returns
+        -------
+        ndarray, float
+            Third derivative of the cross-section rotation psi'''(x) (1/mm^3).
+        """
+        return self.dz_dxdx(z, phi, qs)[5, :]