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

weac/core/scenario.py

@@ -0,0 +1,200 @@
+"""
+This module defines the Scenario class, which encapsulates the physical setup of the model.
+"""
+
+import logging
+from typing import List, Sequence, Union
+
+import numpy as np
+
+from weac.components import ScenarioConfig, Segment, SystemType, WeakLayer
+from weac.core.slab import Slab
+from weac.utils.misc import decompose_to_normal_tangential
+
+logger = logging.getLogger(__name__)
+
+
+class Scenario:
+    """
+    Sets up the scenario on which the eigensystem is solved.
+
+    Parameters
+    ---------
+    scenario_config: ScenarioConfig
+    segments: List[Segment]
+    weak_layer: WeakLayer
+    slab: Slab
+
+    Attributes
+    ----------
+    li : List[float]
+        length of segment i [mm]
+    ki : List[bool]
+        booleans indicating foundation support for segment i
+    mi : List[float]
+        skier masses (kg) on boundary of segment i and i+1 [kg]
+
+    system_type : SystemType
+    phi : float
+        Angle of slab in positive in counter-clockwise direction [deg]
+    L : float
+        Length of the model [mm]
+    crack_h: float
+        Height of the crack [mm]
+    """
+
+    # Inputs
+    scenario_config: ScenarioConfig
+    segments: List[Segment]
+    weak_layer: WeakLayer
+    slab: Slab
+
+    # Attributes
+    li: np.ndarray  # length of segment i [mm]
+    ki: np.ndarray  # booleans indicating foundation support for segment i
+    mi: np.ndarray  # skier masses (kg) on boundary of segment i and i+1 [kg]
+
+    cum_sum_li: np.ndarray  # cumulative sum of segment lengths [mm]
+
+    system_type: SystemType
+    phi: float  # Angle in [deg]
+    surface_load: float  # Surface Line-Load [N/mm]
+    qw: float  # Weight Line-Load [N/mm]
+    qn: float  # Total Normal Line-Load [N/mm]
+    qt: float  # Total Tangential Line-Load [N/mm]
+    L: float  # Length of the model [mm]
+    crack_h: float  # Height of the crack [mm]
+    cut_length: float  # Length of the cut [mm]
+
+    def __init__(
+        self,
+        scenario_config: ScenarioConfig,
+        segments: List[Segment],
+        weak_layer: WeakLayer,
+        slab: Slab,
+    ):
+        self.scenario_config = scenario_config
+        self.segments = segments
+        self.weak_layer = weak_layer
+        self.slab = slab
+
+        self.system_type = scenario_config.system_type
+        self.phi = scenario_config.phi
+        self.surface_load = scenario_config.surface_load
+        self.cut_length = scenario_config.cut_length
+
+        self._setup_scenario()
+        self._calc_normal_load()
+        self._calc_tangential_load()
+        self._calc_crack_height()
+
+    def refresh_from_config(self):
+        """Pull changed values out of scenario_config
+        and recompute derived attributes."""
+        self.system_type = self.scenario_config.system_type
+        self.phi = self.scenario_config.phi
+        self.surface_load = self.scenario_config.surface_load
+        self.cut_length = self.scenario_config.cut_length
+
+        self._setup_scenario()
+        self._calc_normal_load()
+        self._calc_tangential_load()
+        self._calc_crack_height()
+
+    def get_segment_idx(
+        self, x: Union[float, Sequence[float], np.ndarray]
+    ) -> Union[int, np.ndarray]:
+        """
+        Get the segment index for a given x-coordinate or coordinates.
+
+        Parameters
+        ----------
+        x: Union[float, Sequence[float], np.ndarray]
+            A single x-coordinate or a sequence of x-coordinates.
+
+        Returns
+        -------
+        Union[int, np.ndarray]
+            The segment index or an array of indices.
+        """
+        x_arr = np.asarray(x)
+        indices = np.digitize(x_arr, self.cum_sum_li)
+
+        if np.any(x_arr > self.L):
+            raise ValueError(f"Coordinate {x_arr} exceeds the slab length.")
+
+        if x_arr.ndim == 0:
+            return int(indices)
+
+        return indices
+
+    def _setup_scenario(self):
+        self.li = np.array([seg.length for seg in self.segments])
+        self.ki = np.array([seg.has_foundation for seg in self.segments])
+        # masses that act *between* segments: take all but the last one
+        self.mi = np.array([seg.m for seg in self.segments[:-1]])
+        self.cum_sum_li = np.cumsum(self.li)
+
+        # Add dummy segment if only one segment provided
+        if len(self.li) == 1:
+            self.li = np.append(self.li, 0)
+            self.ki = np.append(self.ki, True)
+            self.mi = np.append(self.mi, 0)
+
+        # Calculate the total slab length
+        self.L = np.sum(self.li)
+
+    def _calc_tangential_load(self):
+        """
+        Total Tangential Load (Surface Load + Weight Load)
+
+        Returns:
+        --------
+        qt : float
+            Tangential Component of Load [N/mm]
+        """
+        # Surface Load & Weight Load
+        qw = self.slab.qw
+        qs = self.surface_load
+
+        # Normal components of forces
+        phi = self.phi
+        _, qwt = decompose_to_normal_tangential(qw, phi)
+        _, qst = decompose_to_normal_tangential(qs, phi)
+        qt = qwt + qst
+        self.qt = qt
+
+    def _calc_normal_load(self):
+        """
+        Total Normal Load (Surface Load + Weight Load)
+
+        Returns:
+        --------
+        qn : float
+            Normal Component of Load [N/mm]
+        """
+        # Surface Load & Weight Load
+        qw = self.slab.qw
+        qs = self.surface_load
+
+        # Normal components of forces
+        phi = self.phi
+        qwn, _ = decompose_to_normal_tangential(qw, phi)
+        qsn, _ = decompose_to_normal_tangential(qs, phi)
+        qn = qwn + qsn
+        self.qn = qn
+
+    def _calc_crack_height(self):
+        """
+        Crack Height: Difference between collapsed weak layer and
+            Weak Layer (Winkler type) under slab load
+
+        Example:
+        if the collapse layer has a height of 5 and the non-collapsed layer
+        has a height of 15 the collapse height is 10
+        """
+        self.crack_h = self.weak_layer.collapse_height - self.qn / self.weak_layer.kn
+        if self.crack_h < 0:
+            raise ValueError(
+                f"Crack height is negative: {self.crack_h} decrease the surface load"
+            )

weac/core/slab.py

@@ -0,0 +1,149 @@
+"""
+This module defines the Slab class, which represents the snow slab and its properties.
+"""
+
+from typing import List
+
+import numpy as np
+
+from weac.components import Layer
+from weac.constants import EPS, G_MM_S2
+
+
+class Slab:  # pylint: disable=too-many-instance-attributes,too-few-public-methods
+    """
+    Parameters of all layers assembled into a slab,
+    provided as np.ndarray for easier access.
+
+    Coordinate frame:
+    - z-axis points downward (first index: top layer, last index: bottom layer)
+    - z = 0 is set at the mid-point of the slab's thickness
+
+    Attributes
+    ----------
+    zi_mid: np.ndarray
+        z-coordinate of the layer i mid-point
+    zi_bottom: np.ndarray
+        z-coordinate of the layer i (boundary towards bottom)
+    rhoi: np.ndarray
+        densities of the layer i [t/mm^3]
+    hi: np.ndarray
+        thickness of the layer i [mm]
+    Ei: np.ndarray
+        Young's modulus of the layer i [MPa]
+    Gi: np.ndarray
+        Shear Modulus of the layer i [MPa]
+    nui: np.ndarray
+        Poisson Ratio of the layer i [-]
+    H: float
+        Total slab thickness (i.e. assembled layers) [mm]
+    z_cog: float
+        z-coordinate of Center of Gravity [mm]
+    qw: float
+        Weight Load of the slab [N/mm]
+    """
+
+    # Input data
+    layers: List[Layer]
+
+    rhoi: np.ndarray  # densities of the layer i [t/mm^3]
+    hi: np.ndarray  # thickness of the layer i [mm]
+    Ei: np.ndarray  # Young's modulus of the layer i [MPa]
+    Gi: np.ndarray  # Shear Modulus of the layer i [MPa]
+    nui: np.ndarray  # Poisson Ratio of the layer i [-]
+
+    # Derived Values
+    z0: float  # z-coordinate of the top of the slab
+    zi_mid: np.ndarray  # z-coordinate of the layer i mid-point
+    zi_bottom: np.ndarray  # z-coordinate of the layer i (boundary towards bottom)
+    H: float  # Total slab thickness (i.e. assembled layers) [mm]
+    z_cog: float  # z-coordinate of Center of Gravity [mm]
+    qw: float  # Weight Load of the slab [N/mm]
+
+    def __init__(self, layers: List[Layer]) -> None:
+        self.layers = layers
+        self._calc_slab_params()
+
+    def calc_vertical_center_of_gravity(self, phi: float):
+        """
+        Vertical PSTs use triangular slabs (with horizontal cuts on the slab ends)
+        Calculate center of gravity of triangular slab segments for vertical PSTs.
+
+        Parameters
+        ----------
+        phi : float
+            Slope angle [deg]
+
+        Returns
+        -------
+        x_cog : float
+            Horizontal coordinate of center of gravity [mm]
+        z_cog : float
+            Vertical coordinate of center of gravity [mm]
+        w : float
+            Weight of the slab segment that is cut off or added [t]
+        """
+        # Convert slope angle to radians
+        phi = np.deg2rad(phi)
+
+        # Catch flat-field case
+        if abs(phi) < EPS:
+            x_cog = 0
+            z_cog = 0
+            w = 0
+        else:
+            n = len(self.hi)
+            rho = self.rhoi  # [t/mm^3]
+            hi = self.hi  # [mm]
+            H = self.H  # [mm]
+            # Layer coordinates z_i (top to bottom)
+            z = np.array([-H / 2 + sum(hi[0:j]) for j in range(n + 1)])
+            zi = z[:-1]
+            zii = z[1:]
+            # Center of gravity of all layers (top to bottom) derived from
+            # triangular slab geometry
+            zsi = zi + hi / 3 * (3 / 2 * H - zi - 2 * zii) / (H - zi - zii)
+            # Surface area of all layers (top to bottom), area = height * base / 2
+            # where base varies with slope angle
+            Ai = hi / 2 * (H - zi - zii) * np.tan(phi)
+            # Center of gravity in vertical direction
+            z_cog = sum(zsi * rho * Ai) / sum(rho * Ai)
+            # Center of gravity in horizontal direction
+            x_cog = (H / 2 - z_cog) * np.tan(phi / 2)
+            # Weight of added or cut off slab segments (t)
+            w = sum(Ai * rho)
+
+        # Return center of gravity and weight of slab segment
+        return x_cog, z_cog, w
+
+    def _calc_slab_params(self) -> None:
+        rhoi = (
+            np.array([ly.rho for ly in self.layers]) * 1e-12
+        )  # Layer densities (kg/m^3 -> t/mm^3)
+        hi = np.array([ly.h for ly in self.layers])  # Layer thickness
+        Ei = np.array([ly.E for ly in self.layers])
+        Gi = np.array([ly.G for ly in self.layers])
+        nui = np.array([ly.nu for ly in self.layers])
+
+        H = hi.sum()
+        # Vectorized midpoint coordinates per layer (top to bottom)
+        # previously: zi_mid = [float(H / 2 - sum(hi[j:n]) + hi[j] / 2) for j in range(n)]
+        suffix_cumsum = np.cumsum(hi[::-1])[::-1]
+        zi_mid = H / 2 - suffix_cumsum + hi / 2
+        zi_bottom = np.cumsum(hi) - H / 2
+        z_cog = sum(zi_mid * hi * rhoi) / sum(hi * rhoi)
+
+        qw = sum(rhoi * G_MM_S2 * hi)  # Line load [N/mm]
+
+        self.rhoi = rhoi
+        self.hi = hi
+        self.Ei = Ei
+        self.Gi = Gi
+        self.nui = nui
+
+        self.zi_mid = zi_mid
+        self.zi_bottom = zi_bottom
+        self.z0 = -H / 2  # z-coordinate of the top of the slab
+        self.H = H
+        self.z_cog = z_cog
+        self.qw = qw