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

weac/__init__.py

@@ -2,4 +2,4 @@
 WEAC - Weak Layer Anticrack Nucleation Model
 """
 
-__version__ = "3.0.1"
+__version__ = "3.1.0"

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,13 +262,13 @@ 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))
@@ -274,14 +278,22 @@ class Analyzer:
         # 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 +307,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 +347,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 +376,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
         -------
@@ -392,11 +419,19 @@ class Analyzer:
         # 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]
 
-        # Return shear stress txz in specified unit
-        return convert[unit] * Szz
+        # 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 transverse normal stress Szz in specified unit
+        return convert[unit] * Szz_MPa
 
     @track_analyzer_call
     def principal_stress_slab(
@@ -438,6 +473,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 +497,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

@@ -9,7 +9,6 @@ import logging
 import time
 import warnings
 from dataclasses import dataclass
-from typing import List, Optional, Union
 
 # Third party imports
 import numpy as np
@@ -34,12 +33,12 @@ logger = logging.getLogger(__name__)
 class CoupledCriterionHistory:
     """Stores the history of the coupled criterion evaluation."""
 
-    skier_weights: List[float]
-    crack_lengths: List[float]
-    incr_energies: List[np.ndarray]
-    g_deltas: List[float]
-    dist_maxs: List[float]
-    dist_mins: List[float]
+    skier_weights: list[float]
+    crack_lengths: list[float]
+    incr_energies: list[np.ndarray]
+    g_deltas: list[float]
+    dist_maxs: list[float]
+    dist_mins: list[float]
 
 
 @dataclass
@@ -89,16 +88,45 @@ class CoupledCriterionResult:
     g_delta: float
     dist_ERR_envelope: float
     iterations: int
-    history: Optional[CoupledCriterionHistory]
+    history: CoupledCriterionHistory | None
     final_system: SystemModel
     max_dist_stress: float
     min_dist_stress: float
 
 
 @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.
+    """
+
+    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
+
+
+@dataclass
+class SteadyStateResult:
+    """
+    Holds the results of the Steady State evaluation.
 
     Attributes:
     -----------
@@ -108,15 +136,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
@@ -130,9 +164,9 @@ class FindMinimumForceResult:
         Whether the algorithm converged.
     critical_skier_weight : float
         The critical skier weight.
-    new_segments : List[Segment]
+    new_segments : list[Segment]
         The new segments.
-    old_segments : List[Segment]
+    old_segments : list[Segment]
         The old segments.
     iterations : int
         The number of iterations.
@@ -144,9 +178,9 @@ class FindMinimumForceResult:
 
     success: bool
     critical_skier_weight: float
-    new_segments: List[Segment]
-    old_segments: List[Segment]
-    iterations: Optional[int]
+    new_segments: list[Segment]
+    old_segments: list[Segment]
+    iterations: int | None
     max_dist_stress: float
     min_dist_stress: float
 
@@ -203,10 +237,10 @@ class CriteriaEvaluator:
 
     def stress_envelope(
         self,
-        sigma: Union[float, np.ndarray],
-        tau: Union[float, np.ndarray],
+        sigma: float | np.ndarray,
+        tau: float | np.ndarray,
         weak_layer: WeakLayer,
-        method: Optional[str] = None,
+        method: str | None = None,
     ) -> np.ndarray:
         """
         Evaluate the stress envelope for given stress components.
@@ -642,12 +676,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.
@@ -672,25 +706,36 @@ class CriteriaEvaluator:
                 UserWarning,
             )
         system_copy = copy.deepcopy(system)
+        system_copy.config.touchdown = True
+        system_copy.update_scenario(scenario_config=ScenarioConfig(phi=0.0))
+        l_BC = system.slab_touchdown.l_BC
+
         segments = [
             Segment(length=5e3, has_foundation=True, m=0.0),
-            Segment(length=5e3, has_foundation=False, m=0.0),
+            Segment(length=2 * l_BC, has_foundation=False, m=0.0),
         ]
         scenario_config = ScenarioConfig(
             system_type="vpst-" if vertical else "pst-",
-            phi=system.scenario.phi,
-            cut_length=5e3,
+            phi=0.0,  # Slab Touchdown works only for flat slab
+            cut_length=2 * l_BC,
         )
-        system_copy.config.touchdown = True
+        # 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(
@@ -825,7 +870,7 @@ class CriteriaEvaluator:
         system: SystemModel,
         search_interval: tuple[float, float] | None = None,
         target: float = 1,
-    ) -> tuple[float, List[Segment]]:
+    ) -> tuple[float, list[Segment]]:
         """
         Finds the minimum crack length required to surpass the energy release rate envelope.
 
@@ -838,7 +883,7 @@ class CriteriaEvaluator:
         --------
         minimum_crack_length: float
             The minimum crack length required to surpass the energy release rate envelope [mm]
-        new_segments: List[Segment]
+        new_segments: list[Segment]
             The updated list of segments
         """
         old_segments = copy.deepcopy(system.scenario.segments)
@@ -928,7 +973,7 @@ class CriteriaEvaluator:
         self,
         system: SystemModel,
         skier_weight: float,
-    ) -> tuple[float, List[Segment]]:
+    ) -> tuple[float, list[Segment]]:
         """
         Finds the resulting anticrack length and updated segment configurations
         for a given skier weight.
@@ -944,7 +989,7 @@ class CriteriaEvaluator:
         -------
         new_crack_length: float
             The total length of the new cracked segments [mm]
-        new_segments: List[Segment]
+        new_segments: list[Segment]
             The updated list of segments
         """
         logger.info(
@@ -1086,7 +1131,7 @@ class CriteriaEvaluator:
 
     def _find_stress_envelope_crossings(
         self, system: SystemModel, weak_layer: WeakLayer
-    ) -> List[float]:
+    ) -> list[float]:
         """
         Finds the exact x-coordinates where the stress envelope is crossed.
         """
@@ -1167,3 +1212,51 @@ 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)
+        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,
+        )