weac 3.0.2__py3-none-any.whl → 3.1.1__py3-none-any.whl

weac/__init__.py

@@ -2,4 +2,4 @@
 WEAC - Weak Layer Anticrack Nucleation Model
 """
 
-__version__ = "3.0.2"
+__version__ = "3.1.1"

weac/analysis/__init__.py

@@ -8,7 +8,7 @@ from .criteria_evaluator import (
     CoupledCriterionResult,
     CriteriaEvaluator,
     FindMinimumForceResult,
-    SSERRResult,
+    SteadyStateResult,
 )
 from .plotter import Plotter
 
@@ -18,6 +18,6 @@ __all__ = [
     "CoupledCriterionHistory",
     "CoupledCriterionResult",
     "FindMinimumForceResult",
-    "SSERRResult",
+    "SteadyStateResult",
     "Plotter",
 ]

weac/analysis/analyzer.py

@@ -214,7 +214,7 @@ class Analyzer:
             ],  # Convert to t/mm^3
             "tensile_strength": [
                 layer.tensile_strength for layer in self.sm.slab.layers
-            ],
+            ],  # in kPa
         }
 
         # Repeat properties for each grid point in the layer
@@ -225,7 +225,7 @@ class Analyzer:
         return si
 
     @track_analyzer_call
-    def Sxx(self, Z, phi, dz=2, unit="kPa"):
+    def Sxx(self, Z, phi, dz=2, unit="kPa", normalize: bool = False):
         """
         Compute axial normal stress in slab layers.
 
@@ -239,6 +239,10 @@ class Analyzer:
             Element size along z-axis (mm). Default is 2 mm.
         unit : {'kPa', 'MPa'}, optional
             Desired output unit. Default is 'kPa'.
+        normalize : bool, optional
+            Toggle normalization. If True, normalize stress values to the tensile strength of each layer (dimensionless).
+            When normalized, the `unit` parameter is ignored and values are returned as ratios.
+            Default is False.
 
         Returns
         -------
@@ -258,30 +262,34 @@ class Analyzer:
         m = Z.shape[1]
 
         # Initialize axial normal stress Sxx
-        Sxx = np.zeros(shape=[n, m])
+        Sxx_MPa = np.zeros(shape=[n, m])
 
         # Compute axial normal stress Sxx at grid points in MPa
         for i, z in enumerate(zi):
-            E = zmesh["E"][i]
+            E_MPa = zmesh["E"][i]
             nu = zmesh["nu"][i]
-            Sxx[i, :] = E / (1 - nu**2) * self.sm.fq.du_dx(Z, z)
+            Sxx_MPa[i, :] = E_MPa / (1 - nu**2) * self.sm.fq.du_dx(Z, z)
 
         # Calculate weight load at grid points and superimpose on stress field
         qt = -rho * G_MM_S2 * np.sin(np.deg2rad(phi))
-        # Old Implementation: Changed for numerical stability
-        # for i, qi in enumerate(qt[:-1]):
-        #     Sxx[i, :] += qi * (zi[i + 1] - zi[i])
-        # Sxx[-1, :] += qt[-1] * (zi[-1] - zi[-2])
-        # New Implementation: Changed for numerical stability
+
         dz = np.diff(zi)
-        Sxx[:-1, :] += qt[:-1, np.newaxis] * dz[:, np.newaxis]
-        Sxx[-1, :] += qt[-1] * dz[-1]
+        Sxx_MPa[:-1, :] += qt[:-1, np.newaxis] * dz[:, np.newaxis]
+        Sxx_MPa[-1, :] += qt[-1] * dz[-1]
+
+        # Normalize tensile stresses to tensile strength
+        if normalize:
+            tensile_strength_kPa = zmesh["tensile_strength"]
+            tensile_strength_MPa = tensile_strength_kPa / 1e3
+            # Normalize axial normal stress to layers' tensile strength
+            normalized_Sxx = Sxx_MPa / tensile_strength_MPa[:, None]
+            return normalized_Sxx
 
         # Return axial normal stress in specified unit
-        return convert[unit] * Sxx
+        return convert[unit] * Sxx_MPa
 
     @track_analyzer_call
-    def Txz(self, Z, phi, dz=2, unit="kPa"):
+    def Txz(self, Z, phi, dz=2, unit="kPa", normalize: bool = False):
         """
         Compute shear stress in slab layers.
 
@@ -295,6 +303,9 @@ class Analyzer:
             Element size along z-axis (mm). Default is 2 mm.
         unit : {'kPa', 'MPa'}, optional
             Desired output unit. Default is 'kPa'.
+        normalize : bool, optional
+            Toggle normalization.  If True, normalize shear stress values to the tensile strength of each layer (dimensionless).
+            When normalized, the `unit` parameter is ignored and values are returned as ratios. Default is False.
 
         Returns
         -------
@@ -332,14 +343,22 @@ class Analyzer:
 
         # Integrate -dsxx_dx along z and add cumulative weight load
         # to obtain shear stress Txz in MPa
-        Txz = cumulative_trapezoid(dsxx_dx, zi, axis=0, initial=0)
-        Txz += cumulative_trapezoid(qt, zi, initial=0)[:, None]
+        Txz_MPa = cumulative_trapezoid(dsxx_dx, zi, axis=0, initial=0)
+        Txz_MPa += cumulative_trapezoid(qt, zi, initial=0)[:, None]
+
+        # Normalize shear stresses to tensile strength
+        if normalize:
+            tensile_strength_kPa = zmesh["tensile_strength"]
+            tensile_strength_MPa = tensile_strength_kPa / 1e3
+            # Normalize shear stress to layers' tensile strength
+            normalized_Txz = Txz_MPa / tensile_strength_MPa[:, None]
+            return normalized_Txz
 
         # Return shear stress Txz in specified unit
-        return convert[unit] * Txz
+        return convert[unit] * Txz_MPa
 
     @track_analyzer_call
-    def Szz(self, Z, phi, dz=2, unit="kPa"):
+    def Szz(self, Z, phi, dz=2, unit="kPa", normalize: bool = False):
         """
         Compute transverse normal stress in slab layers.
 
@@ -353,6 +372,10 @@ class Analyzer:
             Element size along z-axis (mm). Default is 2 mm.
         unit : {'kPa', 'MPa'}, optional
             Desired output unit. Default is 'kPa'.
+        normalize : bool, optional
+            Toggle normalization. If True, normalize stress values to the tensile strength of each layer (dimensionless).
+            When normalized, the `unit` parameter is ignored and values are returned as ratios.
+            Default is False.
 
         Returns
         -------
@@ -366,7 +389,7 @@ class Analyzer:
         # Get mesh along z-axis
         zmesh = self.get_zmesh(dz=dz)
         zi = zmesh["z"]
-        rho = zmesh["rho"]
+        rho_t_mm3 = zmesh["rho"]
         qs = self.sm.scenario.surface_load
         # Get dimensions of stress field (n rows, m columns)
         n = len(zi)
@@ -387,16 +410,24 @@ class Analyzer:
             dsxx_dxdx[i, :] = E / (1 - nu**2) * (du0_dxdxdx + z * dpsi_dxdxdx)
 
         # Calculate weight load at grid points
-        qn = rho * G_MM_S2 * np.cos(np.deg2rad(phi))
+        qn = -rho_t_mm3 * G_MM_S2 * np.cos(np.deg2rad(phi))
 
         # Integrate dsxx_dxdx twice along z to obtain transverse
         # normal stress Szz in MPa
         integrand = cumulative_trapezoid(dsxx_dxdx, zi, axis=0, initial=0)
-        Szz = cumulative_trapezoid(integrand, zi, axis=0, initial=0)
-        Szz += cumulative_trapezoid(-qn, zi, initial=0)[:, None]
+        Szz_MPa = cumulative_trapezoid(integrand, zi, axis=0, initial=0)
+        Szz_MPa += cumulative_trapezoid(qn, zi, initial=0)[:, None]
+
+        # Normalize tensile stresses to tensile strength
+        if normalize:
+            tensile_strength_kPa = zmesh["tensile_strength"]
+            tensile_strength_MPa = tensile_strength_kPa / 1e3
+            # Normalize transverse normal stress to layers' tensile strength
+            normalized_Szz = Szz_MPa / tensile_strength_MPa[:, None]
+            return normalized_Szz
 
-        # Return shear stress txz in specified unit
-        return convert[unit] * Szz
+        # Return transverse normal stress Szz in specified unit
+        return convert[unit] * Szz_MPa
 
     @track_analyzer_call
     def principal_stress_slab(
@@ -438,6 +469,8 @@ class Analyzer:
             'min', or if normalization of compressive principal stress
             is requested.
         """
+        convert = {"kPa": 1e3, "MPa": 1}
+
         # Raise error if specified component is not available
         if val not in ["min", "max"]:
             raise ValueError(f"Component {val} not defined.")
@@ -460,9 +493,10 @@ class Analyzer:
         # Normalize tensile stresses to tensile strength
         if normalize and val == "max":
             zmesh = self.get_zmesh(dz=dz)
-            tensile_strength = zmesh["tensile_strength"]
+            tensile_strength_kPa = zmesh["tensile_strength"]
+            tensile_strength_converted = tensile_strength_kPa / 1e3 * convert[unit]
             # Normalize maximum principal stress to layers' tensile strength
-            normalized_Ps = Ps / tensile_strength[:, None]
+            normalized_Ps = Ps / tensile_strength_converted[:, None]
             return normalized_Ps
 
         # Return absolute principal stresses

weac/analysis/criteria_evaluator.py

@@ -95,9 +95,42 @@ class CoupledCriterionResult:
 
 
 @dataclass
-class SSERRResult:
+class MaximalStressResult:
     """
-    Holds the results of the SSERR evaluation.
+    Holds the results of the maximal stress evaluation.
+
+    Attributes:
+    -----------
+    principal_stress_kPa: np.ndarray
+        The principal stress in kPa.
+    Sxx_kPa: np.ndarray
+        The axial normal stress in kPa.
+    principal_stress_norm: np.ndarray
+        The normalized principal stress to the tensile strength of the layers.
+    Sxx_norm: np.ndarray
+        The normalized axial normal stress to the tensile strength of the layers.
+    max_principal_stress_norm: float
+        The normalized maximum principal stress to the tensile strength of the layers.
+    max_Sxx_norm: float
+        The normalized maximum axial normal stress to the tensile strength of the layers.
+    slab_tensile_criterion: float
+        The slab tensile criterion, i.e. the portion of the slab thickness that is prone
+        to fail under tensile stresses in the steady state (between 0 and 1).
+    """
+
+    principal_stress_kPa: np.ndarray
+    Sxx_kPa: np.ndarray
+    principal_stress_norm: np.ndarray
+    Sxx_norm: np.ndarray
+    max_principal_stress_norm: float
+    max_Sxx_norm: float
+    slab_tensile_criterion: float
+
+
+@dataclass
+class SteadyStateResult:
+    """
+    Holds the results of the Steady State evaluation.
 
     Attributes:
     -----------
@@ -107,15 +140,21 @@ class SSERRResult:
         The message of the evaluation.
     touchdown_distance : float
         The touchdown distance.
-    SSERR : float
-        The Steady-State Energy Release Rate calculated with the
-        touchdown distance from G_I and G_II.
+    energy_release_rate : float
+        The steady-state energy release rate calculated with the
+        touchdown distance from the differential energy release rate.
+    maximal_stress_result: MaximalStressResult
+        The maximal stresses in the system at the touchdown distance.
+    system: SystemModel
+        The modified system model used for the steady state evaluation.
     """
 
     converged: bool
     message: str
     touchdown_distance: float
-    SSERR: float
+    energy_release_rate: float
+    maximal_stress_result: MaximalStressResult
+    system: SystemModel
 
 
 @dataclass
@@ -641,12 +680,12 @@ class CriteriaEvaluator:
             _recursion_depth=_recursion_depth + 1,
         )
 
-    def evaluate_SSERR(
+    def evaluate_SteadyState(
         self,
         system: SystemModel,
         vertical: bool = False,
         print_call_stats: bool = False,
-    ) -> SSERRResult:
+    ) -> SteadyStateResult:
         """
         Evaluates the Touchdown Distance in the Steady State and the Steady State
         Energy Release Rate.
@@ -671,9 +710,9 @@ class CriteriaEvaluator:
                 UserWarning,
             )
         system_copy = copy.deepcopy(system)
-        system_copy.config.touchdown = True
+        system_copy.toggle_touchdown(True)
         system_copy.update_scenario(scenario_config=ScenarioConfig(phi=0.0))
-        l_BC = system.slab_touchdown.l_BC
+        l_BC = system_copy.slab_touchdown.l_BC
 
         segments = [
             Segment(length=5e3, has_foundation=True, m=0.0),
@@ -684,16 +723,22 @@ class CriteriaEvaluator:
             phi=0.0,  # Slab Touchdown works only for flat slab
             cut_length=2 * l_BC,
         )
-        # system_copy.config.touchdown = True
         system_copy.update_scenario(segments=segments, scenario_config=scenario_config)
         touchdown_distance = system_copy.slab_touchdown.touchdown_distance
         analyzer = Analyzer(system_copy, printing_enabled=print_call_stats)
-        G, _, _ = analyzer.differential_ERR(unit="J/m^2")
-        return SSERRResult(
+        energy_release_rate, _, _ = analyzer.differential_ERR(unit="J/m^2")
+        maximal_stress_result = self._calculate_maximal_stresses(
+            system_copy, print_call_stats=print_call_stats
+        )
+        if print_call_stats:
+            analyzer.print_call_stats(message="evaluate_SteadyState Call Statistics")
+        return SteadyStateResult(
             converged=True,
-            message="SSERR evaluation successful.",
+            message="Steady State evaluation successful.",
             touchdown_distance=touchdown_distance,
-            SSERR=G,
+            energy_release_rate=energy_release_rate,
+            maximal_stress_result=maximal_stress_result,
+            system=system_copy,
         )
 
     def find_minimum_force(
@@ -1170,3 +1215,55 @@ class CriteriaEvaluator:
 
         # Return the difference from the target
         return g_delta_diff - target
+
+    def _calculate_maximal_stresses(
+        self,
+        system: SystemModel,
+        print_call_stats: bool = False,
+    ) -> MaximalStressResult:
+        """
+        Calculate the maximal stresses in the system.
+
+        Parameters
+        ----------
+        system : SystemModel
+            The system model to analyze.
+        print_call_stats : bool, optional
+            Whether to print analyzer call statistics. Default is False.
+
+        Returns
+        -------
+        MaximalStressResult
+            Object containing both absolute (in kPa) and normalized stress fields,
+            along with maximum normalized stress values.
+        """
+        analyzer = Analyzer(system, printing_enabled=print_call_stats)
+        _, Z, _ = analyzer.rasterize_solution(num=4000, mode="cracked")
+        Sxx_kPa = analyzer.Sxx(Z=Z, phi=system.scenario.phi, dz=5, unit="kPa")
+        principal_stress_kPa = analyzer.principal_stress_slab(
+            Z=Z, phi=system.scenario.phi, dz=5, unit="kPa"
+        )
+        Sxx_norm = analyzer.Sxx(
+            Z=Z, phi=system.scenario.phi, dz=5, unit="kPa", normalize=True
+        )
+        principal_stress_norm = analyzer.principal_stress_slab(
+            Z=Z, phi=system.scenario.phi, dz=5, unit="kPa", normalize=True
+        )
+        max_principal_stress_norm = np.max(principal_stress_norm)
+        max_Sxx_norm = np.max(Sxx_norm)
+        # evaluate for each height level if the slab is prone to fail under tensile stresses
+        height_level_prone_to_fail = np.max(Sxx_norm, axis=1)
+        slab_tensile_criterion = np.mean(height_level_prone_to_fail)
+        if print_call_stats:
+            analyzer.print_call_stats(
+                message="_calculate_maximal_stresses Call Statistics"
+            )
+        return MaximalStressResult(
+            principal_stress_kPa=principal_stress_kPa,
+            Sxx_kPa=Sxx_kPa,
+            principal_stress_norm=principal_stress_norm,
+            Sxx_norm=Sxx_norm,
+            max_principal_stress_norm=max_principal_stress_norm,
+            max_Sxx_norm=max_Sxx_norm,
+            slab_tensile_criterion=slab_tensile_criterion,
+        )

weac/analysis/plotter.py

@@ -885,48 +885,56 @@ class Plotter:
             zmax = np.max(Zsl + scale * Wsl) + pad
         zmin = np.min(Zsl) - pad
 
-        # Compute weak-layer grid coordinates (cm)
-        Xwl, Zwl = np.meshgrid(1e-1 * xwl, [1e-1 * (zi[-1] + H / 2), zmax])
+        # Filter out NaN values from weak layer coordinates
+        nanmask = np.isfinite(xwl)
+        xwl_finite = xwl[nanmask]
 
-        # Assemble weak-layer displacement field (top and bottom)
-        Uwl = np.vstack([Usl[-1, :], np.zeros(xwl.shape[0])])
-        Wwl = np.vstack([Wsl[-1, :], np.zeros(xwl.shape[0])])
+        # Compute weak-layer grid coordinates (cm) - only for finite xwl
+        Xwl, Zwl = np.meshgrid(1e-1 * xwl_finite, [1e-1 * (zi[-1] + H / 2), zmax])
+
+        # Assemble weak-layer displacement field (top and bottom) - only for finite xwl
+        Uwl = np.vstack([Usl[-1, nanmask], np.zeros(xwl_finite.shape[0])])
+        Wwl = np.vstack([Wsl[-1, nanmask], np.zeros(xwl_finite.shape[0])])
 
         # Compute stress or displacement fields
         match field:
             # Horizontal displacements (um)
             case "u":
                 slab = 1e4 * Usl
-                weak = 1e4 * Usl[-1, :]
+                weak = 1e4 * Usl[-1, nanmask]
                 label = r"$u$ ($\mu$m)"
             # Vertical deflection (um)
             case "w":
                 slab = 1e4 * Wsl
-                weak = 1e4 * Wsl[-1, :]
+                weak = 1e4 * Wsl[-1, nanmask]
                 label = r"$w$ ($\mu$m)"
-            # Axial normal stresses (kPa)
             case "Sxx":
-                slab = analyzer.Sxx(z, phi, dz=dz, unit="kPa")
-                weak = np.zeros(xwl.shape[0])
-                label = r"$\sigma_{xx}$ (kPa)"
+                slab = analyzer.Sxx(z, phi, dz=dz, unit="kPa", normalize=normalize)
+                weak = np.zeros(xwl_finite.shape[0])
+                label = (
+                    r"$\sigma_{xx}/\sigma_+$" if normalize else r"$\sigma_{xx}$ (kPa)"
+                )
             # Shear stresses (kPa)
             case "Txz":
-                slab = analyzer.Txz(z, phi, dz=dz, unit="kPa")
-                weak = Tauwl
-                label = r"$\tau_{xz}$ (kPa)"
+                slab = analyzer.Txz(z, phi, dz=dz, unit="kPa", normalize=normalize)
+                weak = Tauwl[nanmask]
+                label = r"$\tau_{xz}/\sigma_+$" if normalize else r"$\tau_{xz}$ (kPa)"
             # Transverse normal stresses (kPa)
             case "Szz":
-                slab = analyzer.Szz(z, phi, dz=dz, unit="kPa")
-                weak = Sigmawl
-                label = r"$\sigma_{zz}$ (kPa)"
+                slab = analyzer.Szz(z, phi, dz=dz, unit="kPa", normalize=normalize)
+                weak = Sigmawl[nanmask]
+                label = (
+                    r"$\sigma_{zz}/\sigma_+$" if normalize else r"$\sigma_{zz}$ (kPa)"
+                )
             # Principal stresses
             case "principal":
                 slab = analyzer.principal_stress_slab(
                     z, phi, dz=dz, val="max", unit="kPa", normalize=normalize
                 )
-                weak = analyzer.principal_stress_weaklayer(
+                weak_full = analyzer.principal_stress_weaklayer(
                     z, val="min", unit="kPa", normalize=normalize
                 )
+                weak = weak_full[nanmask]
                 if normalize:
                     label = (
                         r"$\sigma_\mathrm{I}/\sigma_+$ (slab),  "
@@ -937,11 +945,6 @@ class Plotter:
                         r"$\sigma_\mathrm{I}$ (kPa, slab),  "
                         r"$\sigma_\mathrm{I\!I\!I}$ (kPa, weak layer)"
                     )
-            case _:
-                raise ValueError(
-                    f"Invalid input '{field}' for field. Valid options are "
-                    "'u', 'w', 'Sxx', 'Txz', 'Szz', or 'principal'"
-                )
 
         # Complement label
         label += r"  $\longrightarrow$"
@@ -968,10 +971,9 @@ class Plotter:
 
         # Plot deformed weak-layer _outline
         if system_type in ["-pst", "pst-", "-vpst", "vpst-"]:
-            nanmask = np.isfinite(xwl)
             ax.plot(
-                _outline(Xwl[:, nanmask] + scale * Uwl[:, nanmask]),
-                _outline(Zwl[:, nanmask] + scale * Wwl[:, nanmask]),
+                _outline(Xwl + scale * Uwl),
+                _outline(Zwl + scale * Wwl),
                 "k",
                 linewidth=1,
             )
@@ -1033,6 +1035,369 @@ class Plotter:
 
         return fig
 
+    def plot_visualize_deformation(
+        self,
+        xsl: np.ndarray,
+        xwl: np.ndarray,
+        z: np.ndarray,
+        analyzer: Analyzer,
+        window: float | None = None,
+        weaklayer_proportion: float | None = None,
+        dz: int = 2,
+        levels: int = 300,
+        field: Literal["w", "u", "principal", "Sxx", "Txz", "Szz"] = "w",
+        normalize: bool = True,
+        filename: str = "visualize_deformation",
+    ) -> Figure:
+        """
+        Plot visualize deformation of the slab and weak layer.
+
+        Parameters
+        ----------
+        xsl : np.ndarray
+            Slab x-coordinates.
+        xwl : np.ndarray
+            Weak layer x-coordinates.
+        z : np.ndarray
+            Solution vector.
+        analyzer : Analyzer
+            Analyzer instance.
+        window: float | None, optional
+            Window size for the plot. Shows the right edge of the slab, where the slab is deformed. Default is None.
+        weaklayer_proportion: float | None, optional
+            Proportion of the plot to allocate to the weak layer. Default is None.
+        dz : int, optional
+            Element size along z-axis (mm). Default is 2 mm.
+        levels : int, optional
+            Number of levels for the colormap. Default is 300.
+        field : str, optional
+            Field to plot ('w', 'u', 'principal', 'Sxx', 'Txz', 'Szz'). Default is 'w'.
+        normalize : bool, optional
+            Toggle normalization. Default is True.
+        filename : str, optional
+            Filename for saving plot. Default is "visualize_deformation".
+
+        Returns
+        -------
+        matplotlib.figure.Figure
+            The generated plot figure.
+        """
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(111)
+
+        zi = analyzer.get_zmesh(dz=dz)["z"]
+        H = analyzer.sm.slab.H
+        phi = analyzer.sm.scenario.phi
+        system_type = analyzer.sm.scenario.system_type
+        fq = analyzer.sm.fq
+        sigma_comp = (
+            analyzer.sm.weak_layer.sigma_comp
+        )  # Compressive strength of the weak layer [kPa]
+
+        # Compute slab displacements on grid (cm)
+        Usl = np.vstack([fq.u(z, h0=h0, unit="cm") for h0 in zi])
+        Wsl = np.vstack([fq.w(z, unit="cm") for _ in zi])
+        Sigmawl = np.where(np.isfinite(xwl), fq.sig(z, unit="kPa"), np.nan)
+        Tauwl = np.where(np.isfinite(xwl), fq.tau(z, unit="kPa"), np.nan)
+
+        # Put coordinate origin at horizontal center
+        if system_type in ["skier", "skiers"]:
+            xsl = xsl - max(xsl) / 2
+            xwl = xwl - max(xwl) / 2
+
+        # Physical dimensions in cm
+        H_cm = H * 1e-1  # Slab height in cm
+        h_cm = analyzer.sm.weak_layer.h * 1e-1  # Weak layer height in cm
+        crack_h_cm = analyzer.sm.scenario.crack_h * 1e-1  # Crack height in cm
+
+        # Compute slab grid coordinates with vertical origin at top surface (cm)
+        Xsl, Zsl = np.meshgrid(1e-1 * (xsl), 1e-1 * (zi + H / 2))
+
+        # Calculate maximum displacement first (needed for proportion calculation)
+        max_w_displacement = np.nanmax(np.abs(Wsl))
+
+        # Calculate dynamic proportions based on displacement
+        # Weak layer percentage = weak_layer_height / max_displacement (as ratio)
+        # But capped at 40% maximum
+        if weaklayer_proportion is None:
+            if max_w_displacement > 0:
+                weaklayer_proportion = min(0.3, (h_cm / max_w_displacement) * 0.1)
+            else:
+                weaklayer_proportion = 0.3
+
+        # Slab takes the remaining space
+        slab_proportion = 1.0 - weaklayer_proportion
+        cracked_ratio = crack_h_cm / h_cm
+        cracked_proportion = weaklayer_proportion * cracked_ratio
+
+        # Set up plot coordinate system
+        # Plot height is normalized: slab (0 to slab_proportion), weak layer (slab_proportion to slab_proportion+weaklayer_proportion)
+        total_height_plot = (
+            slab_proportion + weaklayer_proportion
+        )  # Total height without displacement
+        # Map physical dimensions to plot coordinates
+        deformation_scale = weaklayer_proportion / h_cm
+
+        # Get x-axis limits spanning all provided x values (deformed and undeformed)
+        xmax = np.max([np.max(Xsl), np.max(Xsl + deformation_scale * Usl)]) + 10.0
+        xmin = np.min([np.min(Xsl), np.min(Xsl + deformation_scale * Usl)]) - 10.0
+
+        # Calculate zmax including maximum deformation
+        zmax = total_height_plot
+
+        # Convert physical coordinates to plot coordinates for slab
+        # Zsl is in cm, we need to map it to plot coordinates (0 to slab_proportion)
+        Zsl_plot = (Zsl / H_cm) * slab_proportion
+
+        # Filter out NaN values from weak layer coordinates
+        nanmask = np.isfinite(xwl)
+        xwl_finite = xwl[nanmask]
+
+        # Compute weak-layer grid coordinates in plot units
+        # Weak layer extends from bottom of slab (slab_proportion) to total height (1.0)
+        Xwl, Zwl_plot = np.meshgrid(
+            1e-1 * xwl_finite, [slab_proportion, total_height_plot]
+        )
+
+        # Assemble weak-layer displacement field (top and bottom) - only for finite xwl
+        Uwl = np.vstack([Usl[-1, nanmask], np.zeros(xwl_finite.shape[0])])
+        Wwl = np.vstack([Wsl[-1, nanmask], np.zeros(xwl_finite.shape[0])])
+
+        # Convert slab displacements to plot coordinates
+        # Scale factor for displacements:
+        # So scaled displacement in plot units = scale * Wsl
+        Wsl_plot = (
+            deformation_scale * Wsl
+        )  # Already in plot units (proportion of total height)
+        Usl_plot = deformation_scale * Usl  # Horizontal displacements also scaled
+        Wwl_plot = deformation_scale * Wwl  # Weak layer displacements
+        Uwl_plot = deformation_scale * Uwl  # Weak layer horizontal displacements
+
+        # Compute stress or displacement fields
+        match field:
+            # Horizontal displacements (um)
+            case "u":
+                slab = 1e4 * Usl
+                weak = 1e4 * Usl[-1, nanmask]
+                label = r"$u$ ($\mu$m)"
+            # Vertical deflection (um)
+            case "w":
+                slab = 1e4 * Wsl
+                weak = 1e4 * Wsl[-1, nanmask]
+                label = r"$w$ ($\mu$m)"
+            # Axial normal stresses (kPa)
+            case "Sxx":
+                slab = analyzer.Sxx(z, phi, dz=dz, unit="kPa", normalize=normalize)
+                weak = np.zeros(xwl_finite.shape[0])
+                label = (
+                    r"$\sigma_{xx}/\sigma_+$" if normalize else r"$\sigma_{xx}$ (kPa)"
+                )
+            # Shear stresses (kPa)
+            case "Txz":
+                slab = analyzer.Txz(z, phi, dz=dz, unit="kPa", normalize=normalize)
+                weak = Tauwl[nanmask]
+                label = r"$\tau_{xz}/\sigma_+$" if normalize else r"$\tau_{xz}$ (kPa)"
+            # Transverse normal stresses (kPa)
+            case "Szz":
+                slab = analyzer.Szz(z, phi, dz=dz, unit="kPa", normalize=normalize)
+                weak = Sigmawl[nanmask]
+                label = (
+                    r"$\sigma_{zz}/\sigma_+$" if normalize else r"$\sigma_{zz}$ (kPa)"
+                )
+            # Principal stresses
+            case "principal":
+                slab = analyzer.principal_stress_slab(
+                    z, phi, dz=dz, val="max", unit="kPa", normalize=normalize
+                )
+                weak_full = analyzer.principal_stress_weaklayer(
+                    z, sc=sigma_comp, val="min", unit="kPa", normalize=normalize
+                )
+                weak = weak_full[nanmask]
+                if normalize:
+                    label = (
+                        r"$\sigma_\mathrm{I}/\sigma_+$ (slab),  "
+                        r"$\sigma_\mathrm{I\!I\!I}/\sigma_-$ (weak layer)"
+                    )
+                else:
+                    label = (
+                        r"$\sigma_\mathrm{I}$ (kPa, slab),  "
+                        r"$\sigma_\mathrm{I\!I\!I}$ (kPa, weak layer)"
+                    )
+
+        # Complement label
+        label += r"  $\longrightarrow$"
+
+        # Assemble weak-layer output on grid
+        weak = np.vstack([weak, weak])
+
+        # Normalize colormap
+        absmax = np.nanmax(np.abs([slab.min(), slab.max(), weak.min(), weak.max()]))
+        clim = np.round(absmax, _significant_digits(absmax))
+        levels = np.linspace(-clim, clim, num=levels + 1, endpoint=True)
+
+        # Plot baseline
+        ax.axhline(zmax, color="k", linewidth=1)
+
+        # Plot outlines of the undeformed and deformed slab (using plot coordinates)
+        ax.plot(_outline(Xsl), _outline(Zsl_plot), "--", alpha=0.3, linewidth=1)
+        ax.plot(
+            _outline(Xsl + Usl_plot),
+            _outline(Zsl_plot + Wsl_plot),
+            "-",
+            linewidth=1,
+            color="k",
+        )
+
+        # Plot cracked weak-layer outline (where there is no weak layer)
+        xwl_cracked = xsl[~nanmask]
+        Xwl_cracked, Zwl_cracked_plot = np.meshgrid(
+            1e-1 * xwl_cracked,
+            [slab_proportion + cracked_proportion, total_height_plot],
+        )
+        # No displacements for the cracked weak layer outline (undeformed)
+        if xwl_cracked.shape[0] > 0:
+            ax.plot(
+                _outline(Xwl_cracked),
+                _outline(Zwl_cracked_plot),
+                "k-",
+                alpha=0.3,
+                linewidth=1,
+            )
+
+        # Then plot the deformed weak-layer outline where it exists
+        if system_type in ["-pst", "pst-", "-vpst", "vpst-"]:
+            ax.plot(
+                _outline(Xwl + Uwl_plot),
+                _outline(Zwl_plot + Wwl_plot),
+                "k",
+                linewidth=1,
+            )
+
+        cmap = plt.get_cmap("RdBu_r")
+        cmap.set_over(_adjust_lightness(cmap(1.0), 0.9))
+        cmap.set_under(_adjust_lightness(cmap(0.0), 0.9))
+
+        # Plot fields (using plot coordinates)
+        ax.contourf(
+            Xsl + Usl_plot,
+            Zsl_plot + Wsl_plot,
+            slab,
+            levels=levels,
+            cmap=cmap,
+            extend="both",
+        )
+        ax.contourf(
+            Xwl + Uwl_plot,
+            Zwl_plot + Wwl_plot,
+            weak,
+            levels=levels,
+            cmap=cmap,
+            extend="both",
+        )
+        if xwl_cracked.shape[0] > 0:
+            ax.contourf(
+                Xwl_cracked,
+                Zwl_cracked_plot,
+                np.zeros((2, xwl_cracked.shape[0])),
+                levels=levels,
+                cmap=cmap,
+                extend="both",
+            )
+
+        # Plot setup
+        # Set y-limits to match plot coordinate system (0 to total_height_plot = 1.0)
+        plot_ymin = -0.1
+        plot_ymax = (
+            total_height_plot  # Should be 1.0 (slab_proportion + weaklayer_proportion)
+        )
+
+        # Set limits first, then aspect ratio to avoid matplotlib adjusting limits
+        if window is None:
+            ax.set_xlim([xmin, xmax])
+        else:
+            ax.set_xlim([xmax - window, xmax])
+        ax.set_ylim([plot_ymin, plot_ymax])
+        ax.invert_yaxis()
+        ax.use_sticky_edges = False
+
+        # Hide the default y-axis on main axis (we'll use custom axes)
+        ax.yaxis.set_visible(False)
+
+        # Set up dual y-axes
+        # Right axis: slab height in cm (0 at top, H_cm at bottom of slab)
+        ax_right = ax.twinx()
+        slab_height_max = H_cm
+        # Map plot coordinates to physical slab height values
+        # Plot: 0 to slab_proportion (0.6) maps to physical: 0 to H_cm
+        slab_height_ticks = np.linspace(0, slab_height_max, num=5)
+        slab_height_positions_plot = (
+            slab_height_ticks / slab_height_max
+        ) * slab_proportion
+        ax_right.set_yticks(slab_height_positions_plot)
+        ax_right.set_yticklabels([f"{tick:.1f}" for tick in slab_height_ticks])
+        # Ensure right axis ticks and label are on the right side
+        ax_right.yaxis.tick_right()
+        ax_right.yaxis.set_label_position("right")
+        ax_right.set_ylim([plot_ymin, plot_ymax])
+        ax_right.invert_yaxis()
+        ax_right.set_ylabel(
+            r"slab depth [cm] $\longleftarrow$", rotation=90, labelpad=5, loc="top"
+        )
+
+        # Left axis: weak layer height in mm (0 at bottom of slab, h at bottom of weak layer)
+        ax_left = ax.twinx()
+        weak_layer_h_mm = analyzer.sm.weak_layer.h
+        # Map plot coordinates to physical weak layer height values
+        # Plot: slab_proportion (0.6) to total_height_plot (1.0) maps to physical: 0 to h_mm
+        weaklayer_height_ticks = np.linspace(0, weak_layer_h_mm, num=3)
+        # Map from plot coordinates (slab_proportion to 1.0) to physical (0 to h_mm)
+        weaklayer_height_positions_plot = (
+            slab_proportion
+            + (weaklayer_height_ticks / weak_layer_h_mm) * weaklayer_proportion
+        )
+        ax_left.set_yticks(weaklayer_height_positions_plot)
+        ax_left.set_yticklabels([f"{tick:.1f}" for tick in weaklayer_height_ticks])
+        # Move left axis to the left side
+        ax_left.yaxis.tick_left()
+        ax_left.yaxis.set_label_position("left")
+        ax_left.set_ylim([plot_ymin, plot_ymax])
+        ax_left.invert_yaxis()
+        ax_left.set_ylabel(
+            r"weaklayer depth [mm] $\longleftarrow$",
+            rotation=90,
+            labelpad=5,
+            loc="bottom",
+        )
+
+        # Plot labels
+        ax.set_xlabel(r"lateral position $x$ (cm) $\longrightarrow$")
+        ax.set_title(
+            f"{field}{' (normalized to tensile strength)' if normalize else ''}",
+            size=10,
+        )
+
+        # Show colorbar
+        ticks = np.linspace(levels[0], levels[-1], num=11, endpoint=True)
+        fig.colorbar(
+            ax.contourf(
+                Xsl + Usl_plot,
+                Zsl_plot + Wsl_plot,
+                slab,
+                levels=levels,
+                cmap=cmap,
+                extend="both",
+            ),
+            orientation="horizontal",
+            ticks=ticks,
+            label=label,
+            aspect=35,
+        )
+
+        # Save figure
+        self._save_figure(filename, fig)
+
+        return fig
+
     def plot_stress_envelope(
         self,
         system_model: SystemModel,

weac/components/layer.py

@@ -94,6 +94,10 @@ def _sigrist_tensile_strength(rho, unit: Literal["kPa", "MPa"] = "kPa"):
     return convert[unit] * 240 * (rho / RHO_ICE) ** 2.44
 
 
+# TODO: Compressive Strength from Schöttner
+# (11 +/- 7) * (rho/rho_0) ^ (5.4 +/- 0.5)
+
+
 class Layer(BaseModel):
     """
     Regular slab layer (no foundation springs).
@@ -225,6 +229,9 @@ class WeakLayer(BaseModel):
     )
     sigma_c: float = Field(default=6.16, gt=0, description="Tensile strength [kPa]")
     tau_c: float = Field(default=5.09, gt=0, description="Shear strength [kPa]")
+    sigma_comp: float = Field(
+        default=2.6, gt=0, description="Compressive strength [kPa]"
+    )
     E_method: Literal["bergfeld", "scapazzo", "gerling"] = Field(
         default="bergfeld",
         description="Method to calculate the Young's modulus",

weac/core/field_quantities.py

@@ -58,19 +58,23 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
         h0: float = 0,
         unit: LengthUnit = "mm",
     ) -> float | np.ndarray:
-        """Horizontal displacement *u = u₀ + h₀ ψ* at depth h₀."""
+        """
+        Horizontal displacement `u = u₀ + h₀ ψ` at depth `h₀` (mm).
+        """
         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₀ ψ'."""
+        """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*."""
+        """
+        Center-line (vertical) deflection `w` (mm).
+        """
         return self._unit_factor(unit) * Z[2, :]
 
     def dw_dx(self, Z: np.ndarray) -> float | np.ndarray:
-        """First derivative w'."""
+        """First derivative `w'` (-)."""
         return Z[3, :]
 
     def psi(
@@ -78,32 +82,32 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
         Z: np.ndarray,
         unit: AngleUnit = "rad",
     ) -> float | np.ndarray:
-        """Rotation ψ of the mid-plane."""
+        """Rotation `ψ` of the mid-plane (rad)."""
         factor = self._unit_factor(unit)
         return factor * Z[4, :]
 
     def dpsi_dx(self, Z: np.ndarray) -> float | np.ndarray:
-        """First derivative ψ′."""
+        """First derivative `ψ'` (rad/mm)."""
         return Z[5, :]
 
     def N(self, Z: np.ndarray) -> float | np.ndarray:
-        """Axial normal force N = A11 u' + B11 psi' in the slab [N]"""
+        """Axial normal force `N = A11 u' + B11 ψ'` 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]"""
+        """Bending moment `M = B11 u' + D11 ψ'` 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]"""
+        """Vertical shear force `V = kA55(w' + ψ)` [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"""
+        """Weak-layer normal stress `sig = -kn * w`"""
         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"""
+        """Weak-layer shear stress `tau = -kt * (w' * h/2 - u(h=H/2))`"""
         return (
             -self._unit_factor(unit)
             * self.es.weak_layer.kt
@@ -114,11 +118,11 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
         )
 
     def eps(self, Z: np.ndarray) -> float | np.ndarray:
-        """Weak-layer normal strain"""
+        """Weak-layer normal strain `eps = -w / h`"""
         return -self.w(Z) / self.es.weak_layer.h
 
     def gamma(self, Z: np.ndarray) -> float | np.ndarray:
-        """Weak-layer shear strain."""
+        """Weak-layer shear strain `gamma = (w' * h/2 - u(h=H/2)) / h`"""
         return (
             self.dw_dx(Z) / 2 - self.u(Z, h0=self.es.slab.H / 2) / self.es.weak_layer.h
         )
@@ -176,9 +180,9 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
 
     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.
+        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
+        `z''(x) = [u''(x) u'''(x) w''(x) w'''(x) psi''(x), psi'''(x)]^T`
 
         Parameters
         ----------
@@ -200,7 +204,7 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
 
     def du0_dxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray:
         """
-        Get second derivative of the horiz. centerline displacement u0''(x).
+        Get second derivative of the horiz. centerline displacement `u0''(x)` (mm⁻¹).
 
         Parameters
         ----------
@@ -213,13 +217,13 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
         -------
         ndarray, float
             Second derivative of the horizontal centerline displacement
-            u0''(x) (1/mm).
+            `u0''(x)`.
         """
         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).
+        Get second derivative of the cross-section rotation `psi''(x)` (mm⁻²).
 
         Parameters
         ----------
@@ -231,13 +235,13 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
         Returns
         -------
         ndarray, float
-            Second derivative of the cross-section rotation psi''(x) (1/mm^2).
+            Second derivative of the cross-section rotation psi''(x).
         """
         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).
+        Get third derivative of the horiz. centerline displacement `u0'''(x)` (mm⁻²).
 
         Parameters
         ----------
@@ -250,13 +254,13 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
         -------
         ndarray, float
             Third derivative of the horizontal centerline displacement
-            u0'''(x) (1/mm^2).
+            u0'''(x).
         """
         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).
+        Get third derivative of the cross-section rotation `psi'''(x)` (mm⁻³).
 
         Parameters
         ----------
@@ -268,6 +272,6 @@ class FieldQuantities:  # pylint: disable=too-many-instance-attributes, too-many
         Returns
         -------
         ndarray, float
-            Third derivative of the cross-section rotation psi'''(x) (1/mm^3).
+            Third derivative of the cross-section rotation psi'''(x).
         """
         return self.dz_dxdx(z, phi, qs)[5, :]

weac/core/unknown_constants_solver.py

@@ -273,17 +273,17 @@ class UnknownConstantsSolver:
         Arguments
         ---------
         zl : ndarray
-            Solution vector (6x1) or (6x6) at left end of beam segement.
+            Solution vector (6x1) or (6x6) at left end of beam segment.
         zr : ndarray
-            Solution vector (6x1) or (6x6) at right end of beam segement.
+            Solution vector (6x1) or (6x6) at right end of beam segment.
         has_foundation : boolean
             Indicates whether segment has foundation(True) or not (False).
             Default is False.
         pos: {'left', 'mid', 'right', 'l', 'm', 'r'}, optional
-            Determines whether the segement under consideration
-            is a left boundary segement (left, l), one of the
-            center segement (mid, m), or a right boundary
-            segement (right, r). Default is 'mid'.
+            Determines whether the segment under consideration
+            is a left boundary segment (left, l), one of the
+            center segment (mid, m), or a right boundary
+            segment (right, r). Default is 'mid'.
 
         Returns
         -------
@@ -310,7 +310,7 @@ class UnknownConstantsSolver:
                     bcs[2],
                     fq.u(zr, h0=0),  # ui(xi = li)
                     fq.w(zr),  # wi(xi = li)
-                    fq.psi(zr),  # psii(xi = li)
+                    fq.psi(zr),  # psi(xi = li)
                     fq.N(zr),  # Ni(xi = li)
                     fq.M(zr),  # Mi(xi = li)
                     fq.V(zr),  # Vi(xi = li)
@@ -321,13 +321,13 @@ class UnknownConstantsSolver:
                 [
                     -fq.u(zl, h0=0),  # -ui(xi = 0)
                     -fq.w(zl),  # -wi(xi = 0)
-                    -fq.psi(zl),  # -psii(xi = 0)
+                    -fq.psi(zl),  # -psi(xi = 0)
                     -fq.N(zl),  # -Ni(xi = 0)
                     -fq.M(zl),  # -Mi(xi = 0)
                     -fq.V(zl),  # -Vi(xi = 0)
                     fq.u(zr, h0=0),  # ui(xi = li)
                     fq.w(zr),  # wi(xi = li)
-                    fq.psi(zr),  # psii(xi = li)
+                    fq.psi(zr),  # psi(xi = li)
                     fq.N(zr),  # Ni(xi = li)
                     fq.M(zr),  # Mi(xi = li)
                     fq.V(zr),  # Vi(xi = li)
@@ -347,7 +347,7 @@ class UnknownConstantsSolver:
                 [
                     -fq.u(zl, h0=0),  # -ui(xi = 0)
                     -fq.w(zl),  # -wi(xi = 0)
-                    -fq.psi(zl),  # -psii(xi = 0)
+                    -fq.psi(zl),  # -psi(xi = 0)
                     -fq.N(zl),  # -Ni(xi = 0)
                     -fq.M(zl),  # -Mi(xi = 0)
                     -fq.V(zl),  # -Vi(xi = 0)
@@ -385,9 +385,9 @@ class UnknownConstantsSolver:
             Default is False.
         pos : {'left', 'mid', 'right', 'l', 'm', 'r'}, optional
             Determines whether the segement under consideration
-            is a left boundary segement (left, l), one of the
-            center segement (mid, m), or a right boundary
-            segement (right, r). Default is 'mid'.
+            is a left boundary segment (left, l), one of the
+            center segment (mid, m), or a right boundary
+            segment (right, r). Default is 'mid'.
 
         Returns
         -------

weac/utils/geldsetzer.py

@@ -82,18 +82,23 @@ HAND_HARDNESS = {
     "F-": 0.67,
     "F": 1,
     "F+": 1.33,
+    "F-4F": 1.5,
     "4F-": 1.67,
     "4F": 2,
     "4F+": 2.33,
+    "4F-1F": 2.5,
     "1F-": 2.67,
     "1F": 3,
     "1F+": 3.33,
+    "1F-P": 3.5,
     "P-": 3.67,
     "P": 4,
     "P+": 4.33,
+    "P-K": 4.5,
     "K-": 4.67,
     "K": 5,
     "K+": 5.33,
+    "K-I": 5.5,
     "I-": 5.67,
     "I": 6,
     "I+": 6.33,
@@ -117,18 +122,23 @@ HAND_HARDNESS_TO_DENSITY = {
     "F-": 71.7,
     "F": 103.7,
     "F+": 118.4,
+    "F-4F": 123.15,
     "4F-": 127.9,
     "4F": 158.2,
     "4F+": 163.7,
+    "4F-1F": 176.15,
     "1F-": 188.6,
     "1F": 208,
     "1F+": 224.4,
+    "1F-P": 238.6,
     "P-": 252.8,
     "P": 275.9,
     "P+": 314.6,
+    "P-K": 336.85,
     "K-": 359.1,
     "K": 347.4,
     "K+": 407.8,
+    "K-I": 407.8,
     "I-": 407.8,
     "I": 407.8,
     "I+": 407.8,

weac/utils/snow_types.py

@@ -65,18 +65,23 @@ class HandHardness(str, Enum):
     Fm = "F-"
     F = "F"
     Fp = "F+"
+    F_4F = "F-4F"
     _4Fm = "4F-"
     _4F = "4F"
     _4Fp = "4F+"
+    _4F_1F = "4F-1F"
     _1Fm = "1F-"
     _1F = "1F"
     _1Fp = "1F+"
+    _1F_P = "1F-P"
     Pm = "P-"
     P = "P"
     Pp = "P+"
+    P_K = "P-K"
     Km = "K-"
     K = "K"
     Kp = "K+"
+    K_I = "K-I"
     Im = "I-"
     I = "I"
     Ip = "I+"

{weac-3.0.2.dist-info → weac-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weac
-Version: 3.0.2
+Version: 3.1.1
 Summary: Weak layer anticrack nucleation model
 Author-email: 2phi GbR <mail@2phi.de>
 License-Expression: MIT
@@ -17,7 +17,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.9.1
-Requires-Dist: numpy>=2.0.1
+Requires-Dist: numpy<2.4.0,>=2.3.5
 Requires-Dist: scipy>=1.14.0
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: snowpylot>=1.1.3

{weac-3.0.2.dist-info → weac-3.1.1.dist-info}/RECORD

@@ -1,32 +1,32 @@
-weac/__init__.py,sha256=mOpFbjyMROJ4BdyLMOUvSfVmzVGLZTYXeIqvGZXGtl4,76
+weac/__init__.py,sha256=kgTwOD6mYTXI3qvj9z5uFDNJH84Toa29jQuKAu-5P_M,76
 weac/constants.py,sha256=BX8ifZhFciCuzzako1p-2Wh5CWWzR3cPdvyu501UtUs,1194
 weac/logging_config.py,sha256=GJn4Fs80dDRpbPkSPByCmIOLkEI01dbeuMMSv_IDgoM,1103
-weac/analysis/__init__.py,sha256=twF9OYrZiVmBtw6Lyzf5QUhLZNtqFFM2H3OuaYCog1k,486
-weac/analysis/analyzer.py,sha256=AR1yxM5trK1c-_lTEVn9e6e96IhWVWSRgHgQcaLy4Io,27089
-weac/analysis/criteria_evaluator.py,sha256=WY0FQnfzDfN0h1lI5b4LCUV0bwnvUAVDmS4mKCHGbmo,43599
-weac/analysis/plotter.py,sha256=6KzqiXWIDTIFE6qB947eXhtvEAuPp8B4P5idoSX8OwY,66120
+weac/analysis/__init__.py,sha256=FDbmQLC5zmT8OJftqNYgihXc8WYB1b9FasFPGzkKVU8,498
+weac/analysis/analyzer.py,sha256=-yoOqsdQvpNvBc-U2nqB4UEKHGTMBu23lVPJqKxUVcs,29095
+weac/analysis/criteria_evaluator.py,sha256=yiKQV6ccgNnDMEky18zlHT3YfvoxdqCQtnPHKhbnrJA,47624
+weac/analysis/plotter.py,sha256=ibkH4rzQ2pqQVXPRfek722e8eU3vP63uysb-Q-EzfC0,80556
 weac/components/__init__.py,sha256=94WIUVjPI3U-grN_7v0oi9bZB3Z8rCBcx9wJPOwJBAQ,439
 weac/components/config.py,sha256=tnOnJ0M-_knZBhdr052nDyyFFAZN0f2hQ68XRuXG6d8,869
 weac/components/criteria_config.py,sha256=f2agU7nXWURFAw8_68igiSk5aICUxwaB9u3Qasit-Q0,2909
-weac/components/layer.py,sha256=sF47006ORRmNnHW7QMk9h-M0vQQR6TL_PKOvInjdNsk,10560
+weac/components/layer.py,sha256=kfghjavzCqzzGrkKzllMMT4qD3F0pcYfk1ZHgM6rvE0,10755
 weac/components/model_input.py,sha256=oyX4p7PgaAtUXXtpvV8XO_KxwOXtG1TB0x7rXxNfCFA,3330
 weac/components/scenario_config.py,sha256=Tam-m9DQtdjmTm-lKQ8Dcjqje04ttJS2X3v_Nn7AUHQ,2563
 weac/components/segment.py,sha256=F279KcAAkRuJKWav_BZ4BanO96WZm4KXtKHinFZki7s,941
 weac/core/__init__.py,sha256=pRyCKD8XD3qXVUWtFG7N3cS91P5x5d8Jpr1hMEgxQ2U,233
 weac/core/eigensystem.py,sha256=b7KXi2weCY9IVlH_7lCTXzKSx_pLdWY-x8BPjHL5nKo,13736
-weac/core/field_quantities.py,sha256=ci7MvhJ4aYdbW6xxH8vHVgWtk5iypCYv6dZ6KjFNvt8,8964
+weac/core/field_quantities.py,sha256=rr0KvM5Eu9AR43CQrrODJJkXkM2b2N3BWk2dE38f64c,9175
 weac/core/scenario.py,sha256=vHHe-JDWc-8ECVfy6lFGVtJmIIKRc0J9iUEGR8zckdw,6050
 weac/core/slab.py,sha256=YwbAf7ogYDn3p0nXfj3IjVqwA6ro3jBSg2wXb_io_gQ,5125
 weac/core/slab_touchdown.py,sha256=k30FyvclH_Q3mCZNTbJkNhSenv3ja6qSNhhkmi5p04A,14009
 weac/core/system_model.py,sha256=HAZuquY6p1wf5QuUPA6VOVDIICeCxOaeXqk1dSfEzNY,15513
-weac/core/unknown_constants_solver.py,sha256=pzE7soTo7v-jdDECa21pOWRGBp8YeMU3k7egJOemfSY,17766
+weac/core/unknown_constants_solver.py,sha256=kzB8351UC03rVcJWez0FAwdawI2tERbpcgqMRKgYbi8,17753
 weac/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-weac/utils/geldsetzer.py,sha256=DxvpqmWulBacl-mGeAmAuJcv2xqFBx92PEfNC3aeDzk,3500
+weac/utils/geldsetzer.py,sha256=Rmn_PUyeomPLfxZlj9LDbdBBRDWovavrQenka318TIM,3681
 weac/utils/misc.py,sha256=lGz0IDDJ_3nvYjSkivPJ5Xscl1D_AmvQLSjaL7SUbKs,3674
-weac/utils/snow_types.py,sha256=eX9-5La6Oom7zh6pg5JZ4MZ6nLdWdc7RoUzm5e6b9w8,1483
+weac/utils/snow_types.py,sha256=OKSY8LzfKycSjg7uSUZkSXUzwhcw1D1fZs5S3hVQtUM,1573
 weac/utils/snowpilot_parser.py,sha256=drOLnUg7uzMJMO9qU9x79xZkqQfFPCCQonVpU9S0x8U,13682
-weac-3.0.2.dist-info/licenses/LICENSE,sha256=ojZPWKFHbFGDrlNOvuAKGH9WcKhpLHWZPcQ4SzhK91M,1082
-weac-3.0.2.dist-info/METADATA,sha256=p-UwzxwB89KHKa1zQIahEoGoymDvmhzRAieD3xzDPt0,25586
-weac-3.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-weac-3.0.2.dist-info/top_level.txt,sha256=8tyXUHPFU4Ba_5kPtpwvXo5l6GjJmOnODVBJFygpdeE,5
-weac-3.0.2.dist-info/RECORD,,
+weac-3.1.1.dist-info/licenses/LICENSE,sha256=ojZPWKFHbFGDrlNOvuAKGH9WcKhpLHWZPcQ4SzhK91M,1082
+weac-3.1.1.dist-info/METADATA,sha256=0cdfjFenF40KllOBi5gLkyOSkdA3Ko_1LAdX43AlUK4,25593
+weac-3.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+weac-3.1.1.dist-info/top_level.txt,sha256=8tyXUHPFU4Ba_5kPtpwvXo5l6GjJmOnODVBJFygpdeE,5
+weac-3.1.1.dist-info/RECORD,,