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

weac/utils/misc.py

@@ -0,0 +1,127 @@
+"""
+This module contains miscellaneous utility functions.
+"""
+
+from typing import Literal
+
+import numpy as np
+
+from weac.components import Layer
+from weac.constants import G_MM_S2, LSKI_MM
+
+
+def decompose_to_normal_tangential(f: float, phi: float) -> tuple[float, float]:
+    """
+    Resolve a gravity-type force/line-load into its tangential (downslope) and
+    normal (into-slope) components with respect to an inclined surface.
+
+    Parameters
+    ----------
+    f : float
+        is interpreted as a vertical load magnitude
+        acting straight downward (global y negative).
+    phi : float
+        Surface dip angle `in degrees`, measured from horizontal.
+        Positive `phi` means the surface slopes upward in +x.
+
+    Returns
+    -------
+    f_norm, f_tan : float
+        Magnitudes of the tangential ( + downslope ) and normal
+        ( + into-slope ) components, respectively.
+    """
+    # Convert units
+    phi = np.deg2rad(phi)  # Convert inclination to rad
+    # Split into components
+    f_norm = f * np.cos(phi)  # Normal direction
+    f_tan = -f * np.sin(phi)  # Tangential direction
+    return f_norm, f_tan
+
+
+def get_skier_point_load(m: float) -> float:
+    """
+    Calculate skier point load.
+
+    Arguments
+    ---------
+    m : float
+        Skier weight [kg].
+
+    Returns
+    -------
+    f : float
+        Skier load [N/mm].
+    """
+    F = 1e-3 * m * G_MM_S2 / LSKI_MM  # Total skier
+    return F
+
+
+def load_dummy_profile(
+    profile_id: Literal[
+        "a", "b", "c", "d", "e", "f", "h", "soft", "medium", "hard", "comp"
+    ],
+) -> list[Layer]:
+    """Define standard layering types for comparison."""
+    soft_layer = Layer(rho=180, h=120, E=5)
+    medium_layer = Layer(rho=270, h=120, E=30)
+    hard_layer = Layer(rho=350, h=120, E=93.8)
+
+    tested_layers = [
+        Layer(rho=350, h=120),
+        Layer(rho=270, h=120),
+        Layer(rho=180, h=120),
+    ]
+
+    # Database (top to bottom)
+    database = {
+        # Layered
+        "a": [hard_layer, medium_layer, soft_layer],
+        "b": [soft_layer, medium_layer, hard_layer],
+        "c": [hard_layer, soft_layer, hard_layer],
+        "d": [soft_layer, hard_layer, soft_layer],
+        "e": [hard_layer, soft_layer, soft_layer],
+        "f": [soft_layer, soft_layer, hard_layer],
+        "tested": tested_layers,
+        # Homogeneous
+        "h": [medium_layer, medium_layer, medium_layer],
+        "soft": [soft_layer, soft_layer, soft_layer],
+        "medium": [medium_layer, medium_layer, medium_layer],
+        "hard": [hard_layer, hard_layer, hard_layer],
+        # Comparison
+        "comp": [
+            Layer(rho=240, h=200, E=5.23),
+        ],
+    }
+
+    # Load profile
+    try:
+        profile = database[profile_id.lower()]
+    except KeyError:
+        raise ValueError(f"Profile {profile_id} is not defined.") from None
+    return profile
+
+
+def isnotebook() -> bool:
+    """
+    Check if code is running in a Jupyter notebook environment.
+
+    Returns
+    -------
+    bool
+        True if running in Jupyter notebook, False otherwise.
+    """
+    try:
+        # Check if we're in IPython
+        from IPython import get_ipython  # pylint: disable=import-outside-toplevel
+
+        if get_ipython() is None:
+            return False
+
+        # Check if we're specifically in a notebook (not just IPython terminal)
+        if get_ipython().__class__.__name__ == "ZMQInteractiveShell":
+            return True  # Jupyter notebook
+        if get_ipython().__class__.__name__ == "TerminalInteractiveShell":
+            return False  # IPython terminal
+        return False  # Other IPython environments
+    except ImportError:
+        return False  # IPython not available

weac/utils/snow_types.py

@@ -0,0 +1,82 @@
+"""
+Snow grain types and hand hardness values.
+
+These values are used in Pydantic models for validation and correspond to the
+parameterizations available in `geldsetzer.py`.
+"""
+
+from enum import Enum
+
+
+class GrainType(str, Enum):
+    """SnowPilot grain type codes (see `geldsetzer.GRAIN_TYPE`)."""
+
+    DF = "DF"
+    DFbk = "DFbk"
+    DFdc = "DFdc"
+    DH = "DH"
+    DHch = "DHch"
+    DHcp = "DHcp"
+    DHla = "DHla"
+    DHpr = "DHpr"
+    DHxr = "DHxr"
+    FC = "FC"
+    FCsf = "FCsf"
+    FCso = "FCso"
+    FCxr = "FCxr"
+    IF = "IF"
+    IFbi = "IFbi"
+    IFic = "IFic"
+    IFil = "IFil"
+    IFrc = "IFrc"
+    IFsc = "IFsc"
+    MF = "MF"
+    MFcl = "MFcl"
+    MFcr = "MFcr"
+    MFpc = "MFpc"
+    MFsl = "MFsl"
+    PP = "PP"
+    PPco = "PPco"
+    PPgp = "PPgp"
+    PPhl = "PPhl"
+    PPip = "PPip"
+    PPir = "PPir"
+    PPnd = "PPnd"
+    PPpl = "PPpl"
+    PPrm = "PPrm"
+    PPsd = "PPsd"
+    RG = "RG"
+    RGlr = "RGlr"
+    RGsr = "RGsr"
+    RGwp = "RGwp"
+    RGxf = "RGxf"
+    SH = "SH"
+    SHcv = "SHcv"
+    SHsu = "SHsu"
+    SHxr = "SHxr"
+
+
+class HandHardness(str, Enum):
+    """Field hand hardness codes (see `geldsetzer.HAND_HARDNESS`).
+
+    Enum member names avoid starting with digits and special characters.
+    """
+
+    Fm = "F-"
+    F = "F"
+    Fp = "F+"
+    _4Fm = "4F-"
+    _4F = "4F"
+    _4Fp = "4F+"
+    _1Fm = "1F-"
+    _1F = "1F"
+    _1Fp = "1F+"
+    Pm = "P-"
+    P = "P"
+    Pp = "P+"
+    Km = "K-"
+    K = "K"
+    Kp = "K+"
+    Im = "I-"
+    I = "I"
+    Ip = "I+"

weac/utils/snowpilot_parser.py

@@ -0,0 +1,332 @@
+"""
+Utilizes the snowpylot library to convert a CAAML file to a WEAC ModelInput.
+
+The snowpylot library is used to parse the CAAML file and extract the snowpit.
+The snowpit is then converted to a List of WEAC ModelInput.
+
+Based on the different stability tests performed, several scenarios are created.
+Each scenario is a WEAC ModelInput.
+
+The scenarios are created based on the following logic:
+- For each PropSawTest, a scenario is created with `the cut length` and `a standard segment.`
+- For each ExtColumnTest, a scenario is created with `a standard segment.`
+- For each ComprTest, a scenario is created with `a standard segment.`
+- For each RBlockTest, a scenario is created with `a standard segment.`
+
+The `a standard segment` is a segment with a length of 1000 mm and a foundation of True.
+
+The `the cut length` is the cut length of the PropSawTest.
+The `the column length` is the column length of the PropSawTest.
+"""
+
+import logging
+from typing import List, Tuple
+
+import numpy as np
+from snowpylot import caaml_parser
+from snowpylot.layer import Layer as SnowpylotLayer
+from snowpylot.snow_pit import SnowPit
+from snowpylot.snow_profile import DensityObs
+
+# Import WEAC components
+from weac.components import (
+    Layer,
+    WeakLayer,
+)
+from weac.utils.geldsetzer import compute_density
+
+logger = logging.getLogger(__name__)
+
+convert_to_mm = {"cm": 10, "mm": 1, "m": 1000, "dm": 100}
+convert_to_deg = {"deg": 1, "rad": 180 / np.pi}
+
+
+class SnowPilotParser:
+    """Parser for SnowPilot files using the snowpylot library."""
+
+    def __init__(self, file_path: str):
+        self.snowpit: SnowPit = caaml_parser(file_path)
+
+    def extract_layers(self) -> Tuple[List[Layer], List[str]]:
+        """Extract layers from snowpit."""
+        snowpit = self.snowpit
+        # Extract layers from snowpit: List[SnowpylotLayer]
+        sp_layers: List[SnowpylotLayer] = [
+            layer
+            for layer in snowpit.snow_profile.layers
+            if layer.depth_top is not None
+        ]
+        sp_layers = sorted(sp_layers, key=lambda x: x.depth_top[0])  # type: ignore
+
+        # Extract density layers from snowpit: List[DensityObs]
+        sp_density_layers: List[DensityObs] = [
+            layer
+            for layer in snowpit.snow_profile.density_profile
+            if layer.depth_top is not None
+        ]
+        sp_density_layers = sorted(sp_density_layers, key=lambda x: x.depth_top[0])  # type: ignore
+
+        # Populate WEAC layers: List[Layer]
+        layers: List[Layer] = []
+        density_methods: List[str] = []
+        for _i, layer in enumerate(sp_layers):
+            # Parameters
+            grain_type = None
+            grain_size = None
+            hand_hardness = None
+            density = None
+            thickness = None
+
+            # extract THICKNESS
+            if layer.thickness is not None:
+                thickness, unit = layer.thickness
+                thickness = thickness * convert_to_mm[unit]  # Convert to mm
+            else:
+                raise ValueError("Thickness not found")
+
+            # extract GRAIN TYPE and SIZE
+            if layer.grain_form_primary:
+                if layer.grain_form_primary.grain_form:
+                    grain_type = layer.grain_form_primary.grain_form
+                    if layer.grain_form_primary.grain_size_avg:
+                        grain_size = (
+                            layer.grain_form_primary.grain_size_avg[0]
+                            * convert_to_mm[layer.grain_form_primary.grain_size_avg[1]]
+                        )
+                    elif layer.grain_form_primary.grain_size_max:
+                        grain_size = (
+                            layer.grain_form_primary.grain_size_max[0]
+                            * convert_to_mm[layer.grain_form_primary.grain_size_max[1]]
+                        )
+
+            # extract DENSITY
+            # Get layer depth range in mm for density matching
+            layer_depth_top_mm = layer.depth_top[0] * convert_to_mm[layer.depth_top[1]]
+            layer_depth_bottom_mm = layer_depth_top_mm + thickness
+            # Try to find density measurement that overlaps with this layer
+            measured_density = self.get_density_for_layer_range(
+                layer_depth_top_mm, layer_depth_bottom_mm, sp_density_layers
+            )
+
+            # Handle hardness and create layers accordingly
+            if layer.hardness_top is not None and layer.hardness_bottom is not None:
+                hand_hardness_top = layer.hardness_top
+                hand_hardness_bottom = layer.hardness_bottom
+
+                # Two hardness values - split into two layers
+                half_thickness = thickness / 2
+                layer_mid_depth_mm = layer_depth_top_mm + half_thickness
+
+                # Create top layer (first half)
+                if measured_density is not None:
+                    density_top = self.get_density_for_layer_range(
+                        layer_depth_top_mm, layer_mid_depth_mm, sp_density_layers
+                    )
+                    if density_top is None:
+                        density_methods.append("geldsetzer")
+                        density_top = compute_density(grain_type, hand_hardness_top)
+                    else:
+                        density_methods.append("density_obs")
+                else:
+                    density_methods.append("geldsetzer")
+                    density_top = compute_density(grain_type, hand_hardness_top)
+
+                layers.append(
+                    Layer(
+                        rho=density_top,
+                        h=half_thickness,
+                        grain_type=grain_type,
+                        grain_size=grain_size,
+                        hand_hardness=hand_hardness_top,
+                    )
+                )
+
+                # Create bottom layer (second half)
+                if measured_density is not None:
+                    density_bottom = self.get_density_for_layer_range(
+                        layer_mid_depth_mm, layer_depth_bottom_mm, sp_density_layers
+                    )
+                    if density_bottom is None:
+                        density_methods.append("geldsetzer")
+                        density_bottom = compute_density(
+                            grain_type, hand_hardness_bottom
+                        )
+                    else:
+                        density_methods.append("density_obs")
+                else:
+                    try:
+                        density_methods.append("geldsetzer")
+                        density_bottom = compute_density(
+                            grain_type, hand_hardness_bottom
+                        )
+                    except Exception as exc:
+                        raise AttributeError(
+                            "Layer is missing density information; density profile, "
+                            "hand hardness and grain type are all missing. "
+                            "Excluding SnowPit from calculations."
+                        ) from exc
+
+                layers.append(
+                    Layer(
+                        rho=density_bottom,
+                        h=half_thickness,
+                        grain_type=grain_type,
+                        grain_size=grain_size,
+                        hand_hardness=hand_hardness_bottom,
+                    )
+                )
+            else:
+                # Single hardness value - create one layer
+                hand_hardness = layer.hardness
+
+                if measured_density is not None:
+                    density = measured_density
+                    density_methods.append("density_obs")
+                else:
+                    try:
+                        density_methods.append("geldsetzer")
+                        density = compute_density(grain_type, hand_hardness)
+                    except Exception as exc:
+                        raise AttributeError(
+                            "Layer is missing density information; density profile, "
+                            "hand hardness and grain type are all missing. "
+                            "Excluding SnowPit from calculations."
+                        ) from exc
+
+                layers.append(
+                    Layer(
+                        rho=density,
+                        h=thickness,
+                        grain_type=grain_type,
+                        grain_size=grain_size,
+                        hand_hardness=hand_hardness,
+                    )
+                )
+
+        if len(layers) == 0:
+            raise AttributeError(
+                "No layers found for snowpit. Excluding SnowPit from calculations."
+            )
+        return layers, density_methods
+
+    def get_density_for_layer_range(
+        self,
+        layer_top_mm: float,
+        layer_bottom_mm: float,
+        sp_density_layers: List[DensityObs],
+    ) -> float | None:
+        """Find density measurements that overlap with the given layer depth range.
+
+        Args:
+            layer_top_mm: Top depth of layer in mm
+            layer_bottom_mm: Bottom depth of layer in mm
+            sp_density_layers: List of density observations
+
+        Returns:
+            Average density from overlapping measurements, or None if no overlap
+        """
+        if not sp_density_layers:
+            return None
+
+        overlapping_densities = []
+        overlapping_weights = []
+
+        for density_obs in sp_density_layers:
+            if density_obs.depth_top is None or density_obs.thickness is None:
+                continue
+
+            # Convert density observation depth range to mm
+            density_top_mm = (
+                density_obs.depth_top[0] * convert_to_mm[density_obs.depth_top[1]]
+            )
+            density_thickness_mm = (
+                density_obs.thickness[0] * convert_to_mm[density_obs.thickness[1]]
+            )
+            density_bottom_mm = density_top_mm + density_thickness_mm
+
+            # Check for overlap between layer and density measurement
+            overlap_top = max(layer_top_mm, density_top_mm)
+            overlap_bottom = min(layer_bottom_mm, density_bottom_mm)
+
+            if overlap_top < overlap_bottom:  # There is overlap
+                overlap_thickness = overlap_bottom - overlap_top
+
+                # Extract density value
+                if density_obs.density is not None:
+                    density_value = density_obs.density[0]  # (value, unit)
+
+                    overlapping_densities.append(density_value)
+                    overlapping_weights.append(overlap_thickness)
+
+        if overlapping_densities:
+            # Calculate weighted average based on overlap thickness
+            total_weight = sum(overlapping_weights)
+            if total_weight > 0:
+                weighted_density = (
+                    sum(
+                        d * w
+                        for d, w in zip(overlapping_densities, overlapping_weights)
+                    )
+                    / total_weight
+                )
+                return float(weighted_density)
+        return None
+
+    def extract_weak_layer_and_layers_above(
+        self, weak_layer_depth: float, layers: List[Layer]
+    ) -> Tuple[WeakLayer, List[Layer]]:
+        """Extract weak layer and layers above the weak layer for the given
+        depth_top extracted from the stability test."""
+        depth = 0
+        layers_above = []
+        weak_layer_rho = None
+        weak_layer_hand_hardness = None
+        weak_layer_grain_type = None
+        weak_layer_grain_size = None
+        if weak_layer_depth <= 0:
+            raise ValueError(
+                "The depth of the weak layer is not positive. "
+                "Excluding SnowPit from calculations."
+            )
+        if weak_layer_depth > sum(layer.h for layer in layers):
+            raise ValueError(
+                "The depth of the weak layer is below the recorded layers. "
+                "Excluding SnowPit from calculations."
+            )
+        layers = [layer.model_copy(deep=True) for layer in layers]
+        for i, layer in enumerate(layers):
+            if depth + layer.h < weak_layer_depth:
+                layers_above.append(layer)
+                depth += layer.h
+            elif depth < weak_layer_depth < depth + layer.h:
+                layer.h = weak_layer_depth - depth
+                layers_above.append(layer)
+                weak_layer_rho = layers[i].rho
+                weak_layer_hand_hardness = layers[i].hand_hardness
+                weak_layer_grain_type = layers[i].grain_type
+                weak_layer_grain_size = layers[i].grain_size
+                break
+            elif depth + layer.h == weak_layer_depth:
+                if i + 1 < len(layers):
+                    layers_above.append(layer)
+                    weak_layer_rho = layers[i + 1].rho
+                    weak_layer_hand_hardness = layers[i + 1].hand_hardness
+                    weak_layer_grain_type = layers[i + 1].grain_type
+                    weak_layer_grain_size = layers[i + 1].grain_size
+                else:
+                    weak_layer_rho = layers[i].rho
+                    weak_layer_hand_hardness = layers[i].hand_hardness
+                    weak_layer_grain_type = layers[i].grain_type
+                    weak_layer_grain_size = layers[i].grain_size
+                break
+
+        weak_layer = WeakLayer(
+            rho=weak_layer_rho,
+            h=20.0,
+            hand_hardness=weak_layer_hand_hardness,
+            grain_type=weak_layer_grain_type,
+            grain_size=weak_layer_grain_size,
+        )
+        if len(layers_above) == 0:
+            raise ValueError("No layers above weak layer found")
+        return weak_layer, layers_above