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

weac/components/__init__.py

@@ -0,0 +1,21 @@
+"""
+Component Classes for Inputs of the WEAC model.
+"""
+
+from .config import Config
+from .criteria_config import CriteriaConfig
+from .layer import Layer, WeakLayer
+from .model_input import ModelInput
+from .segment import Segment
+from .scenario_config import ScenarioConfig, SystemType
+
+__all__ = [
+    "Config",
+    "WeakLayer",
+    "Layer",
+    "Segment",
+    "CriteriaConfig",
+    "ScenarioConfig",
+    "ModelInput",
+    "SystemType",
+]

weac/components/config.py

@@ -0,0 +1,33 @@
+"""
+Configuration for the WEAC simulation.
+These settings control runtime parameters for WEAC.
+In general, developers maintain these defaults; end users should see a stable configuration.
+
+We utilize the pydantic library to define the configuration.
+
+Pydantic syntax is for a field:
+field_name: type = Field(..., gt=0, description="Description")
+- typing, default value, constraints, description
+"""
+
+from pydantic import BaseModel, Field
+
+
+class Config(BaseModel):
+    """
+    Configuration for the WEAC simulation.
+
+    Attributes
+    ----------
+    touchdown : bool
+        Whether slab touchdown on the collapsed weak layer is considered.
+    """
+
+    touchdown: bool = Field(
+        default=False, description="Whether to include slab touchdown in the analysis"
+    )
+
+
+if __name__ == "__main__":
+    config = Config()
+    print(config.model_dump_json(indent=2))

weac/components/criteria_config.py

@@ -0,0 +1,86 @@
+"""
+Module for configuring failure-mode interaction criteria and stress failure envelope selection.
+
+Main fields:
+- fn, fm: interaction exponents for normal (sigma) and shear (tau) stresses (> 0).
+- gn, gm: interaction exponents for mode-I (G_I) and mode-II (G_II) energy release rates (> 0).
+- stress_envelope_method: one of
+        {"adam_unpublished", "schottner", "mede_s-RG1", "mede_s-RG2", "mede_s-FCDH"}.
+- scaling_factor, order_of_magnitude: positive scalars applied to the stress envelope.
+
+Typical usage:
+    from weac.components.criteria_config import CriteriaConfig
+
+    config = CriteriaConfig(
+        stress_envelope_method="schottner",
+        scaling_factor=1.0,
+        order_of_magnitude=1.0,
+    )
+
+See also:
+- weac.analysis.criteria_evaluator for how these parameters influence failure checks.
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class CriteriaConfig(BaseModel):
+    """
+    Parameters defining the interaction between different failure modes.
+
+    Attributes
+    ----------
+    fn : float
+        Failure mode interaction exponent for normal stress (sigma). Default is 2.0.
+    fm : float
+        Failure mode interaction exponent for shear stress (tau). Default is 2.0.
+    gn : float
+        Failure mode interaction exponent for closing energy release rate (G_I). Default is 5.0.
+    gm : float
+        Failure mode interaction exponent for shearing energy release rate (G_II). Default is 2.22.
+    stress_envelope_method : str
+        Method to calculate the stress failure envelope. Default is "adam_unpublished".
+    scaling_factor : float
+        Scaling factor for stress envelope. Default is 1.0.
+    order_of_magnitude : float
+        Order of magnitude for stress envelope. Default is 1.0.
+    """
+
+    fn: float = Field(
+        default=2.0,
+        gt=0,
+        description="Failure mode interaction exponent for normal stress (sigma)",
+    )
+    fm: float = Field(
+        default=2.0,
+        gt=0,
+        description="Failure mode interaction exponent for shear stress (tau)",
+    )
+    gn: float = Field(
+        default=1 / 0.2,
+        gt=0,
+        description="Failure mode interaction exponent for closing energy release rate (G_I)",
+    )
+    gm: float = Field(
+        default=1 / 0.45,
+        gt=0,
+        description="Failure mode interaction exponent for shearing energy release rate (G_II)",
+    )
+    stress_envelope_method: Literal[
+        "adam_unpublished", "schottner", "mede_s-RG1", "mede_s-RG2", "mede_s-FCDH"
+    ] = Field(
+        default="adam_unpublished",
+        description="Method to calculate the stress failure envelope",
+    )
+    scaling_factor: float = Field(
+        default=1,
+        gt=0,
+        description="Scaling factor for stress envelope",
+    )
+    order_of_magnitude: float = Field(
+        default=1,
+        gt=0,
+        description="Order of magnitude for stress envelope",
+    )

weac/components/layer.py

@@ -0,0 +1,284 @@
+"""
+Mechanical properties of snow-pack layers.
+
+* `Layer` - a regular slab layer (no foundation springs)
+* `WeakLayer` - a slab layer that also acts as a Winkler-type foundation
+"""
+
+from typing import Literal
+
+import numpy as np
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from weac.constants import CB0, CB1, CG0, CG1, NU, RHO_ICE
+from weac.utils.snow_types import GrainType, HandHardness
+
+
+def _collapse_height(h: float) -> float:
+    """
+    Based on data from Herwijnen (van Herwijnen, 2016)
+    `Estimating the effective elastic modulus and specific fracture energy of
+    snowpack layers from field experiments`
+    Data collection 2005 - 2016.
+
+    Arguments:
+    ----------
+    h : float
+        Height/Thickness of the layer [mm].
+    """
+    return 4.70 * (1 - np.exp(-h / 7.78))
+
+
+def _bergfeld_youngs_modulus(rho: float, C_0: float = CB0, C_1: float = CB1) -> float:
+    """Young's modulus from Bergfeld et al. (2023) - returns MPa.
+
+    Arguments
+    ---------
+    rho : float or ndarray
+        Density (kg/m^3).
+    C0 : float, optional
+        Multiplicative constant of Young modulus parametrization
+        according to Bergfeld et al. (2023). Default is 6.5.
+    C1 : float, optional
+        Exponent of Young modulus parameterization according to
+        Bergfeld et al. (2023). Default is 4.4.
+    """
+    return C_0 * 1e3 * (rho / RHO_ICE) ** C_1
+
+
+def _scapozza_youngs_modulus(rho: float) -> float:
+    """Young's modulus from Scapozzo et al. (2019) - return MPa
+    `rho` in [kg/m^3]"""
+    rho = rho * 1e-12  # Convert to [t/mm^3]
+    rho_0 = RHO_ICE * 1e-12  # Density of ice in [t/mm^3]
+    return 5.07e3 * (rho / rho_0) ** 5.13
+
+
+def _gerling_youngs_modulus(rho: float, C_0: float = CG0, C_1: float = CG1) -> float:
+    """Young's modulus according to Gerling et al. (2017).
+
+    Arguments
+    ---------
+    rho : float or ndarray
+        Density (kg/m^3).
+    C0 : float, optional
+        Multiplicative constant of Young modulus parametrization
+        according to Gerling et al. (2017). Default is 6.0.
+    C1 : float, optional
+        Exponent of Young modulus parameterization according to
+        Gerling et al. (2017). Default is 4.6.
+    """
+    return C_0 * 1e-10 * rho**C_1
+
+
+def _sigrist_tensile_strength(rho, unit: Literal["kPa", "MPa"] = "kPa"):
+    """
+    Estimate the tensile strength of a slab layer from its density.
+
+    Uses the density parametrization of Sigrist (2006).
+
+    Arguments
+    ---------
+    rho : ndarray, float
+        Layer density (kg/m^3).
+    unit : str, optional
+        Desired output unit of the layer strength. Default is 'kPa'.
+
+    Returns
+    -------
+    ndarray
+        Tensile strength in specified unit.
+    """
+    convert = {"kPa": 1, "MPa": 1e-3}
+    # Sigrist's equation is given in kPa
+    return convert[unit] * 240 * (rho / RHO_ICE) ** 2.44
+
+
+class Layer(BaseModel):
+    """
+    Regular slab layer (no foundation springs).
+
+    Attributes
+    ----------
+    rho : float
+        Density of the layer [kg m⁻³].
+    h : float
+        Height/Thickness of the layer [mm].
+    nu : float
+        Poisson's ratio [-] Defaults to `weac.constants.NU`).
+    E : float, optional
+        Young's modulus E [MPa].  If omitted it is derived from ``rho``.
+    G : float, optional
+        Shear modulus G [MPa].  If omitted it is derived from ``E`` and ``nu``.
+    """
+
+    # has to be provided
+    rho: float = Field(default=150, gt=0, description="Density of the Slab  [kg m⁻³]")
+    h: float = Field(
+        default=200, gt=0, description="Height/Thickness of the slab  [mm]"
+    )
+
+    # derived if not provided
+    nu: float = Field(default=NU, ge=0, lt=0.5, description="Poisson's ratio [-]")
+    E: float = Field(default=0.0, ge=0, description="Young's modulus [MPa]")
+    G: float = Field(default=0.0, ge=0, description="Shear modulus [MPa]")
+    tensile_strength: float = Field(
+        default=0.0, ge=0, description="Tensile strength [kPa]"
+    )
+    tensile_strength_method: Literal["sigrist"] = Field(
+        default="sigrist",
+        description="Method to calculate the tensile strength",
+    )
+    E_method: Literal["bergfeld", "scapazzo", "gerling"] = Field(
+        default="bergfeld",
+        description="Method to calculate the Young's modulus",
+    )
+    grain_type: GrainType | None = Field(default=None, description="Grain type")
+    grain_size: float | None = Field(default=None, description="Grain size [mm]")
+    hand_hardness: HandHardness | None = Field(
+        default=None, description="Hand hardness"
+    )
+
+    def model_post_init(self, _ctx):  # pylint: disable=arguments-differ
+        if self.E_method == "bergfeld":
+            object.__setattr__(self, "E", self.E or _bergfeld_youngs_modulus(self.rho))
+        elif self.E_method == "scapazzo":
+            object.__setattr__(self, "E", self.E or _scapozza_youngs_modulus(self.rho))
+        elif self.E_method == "gerling":
+            object.__setattr__(self, "E", self.E or _gerling_youngs_modulus(self.rho))
+        else:
+            raise ValueError(f"Invalid E_method: {self.E_method}")
+        object.__setattr__(self, "G", self.G or self.E / (2 * (1 + self.nu)))
+        if self.tensile_strength_method == "sigrist":
+            object.__setattr__(
+                self,
+                "tensile_strength",
+                self.tensile_strength
+                or _sigrist_tensile_strength(self.rho, unit="kPa"),
+            )
+        else:
+            raise ValueError(
+                f"Invalid tensile_strength_method: {self.tensile_strength_method}"
+            )
+
+    @model_validator(mode="after")
+    def validate_positive_E_G(self):
+        """Validate that E and G are positive."""
+        if self.E <= 0:
+            raise ValueError("E must be positive")
+        if self.G <= 0:
+            raise ValueError("G must be positive")
+        return self
+
+
+class WeakLayer(BaseModel):
+    """
+    Weak layer that also behaves as a Winkler foundation.
+
+    Attributes
+    ----------
+    rho : float
+        Density of the layer [kg m⁻³].
+    h : float
+        Height/Thickness of the layer [mm].
+    nu : float
+        Poisson's ratio [-] Defaults to `weac.constants.NU`).
+    E : float, optional
+        Young's modulus E [MPa].  If omitted it is derived from ``rho``.
+    G : float, optional
+        Shear modulus G [MPa].  If omitted it is derived from ``E`` and ``nu``.
+    kn : float, optional
+        Normal (compression) spring stiffness kₙ [N mm⁻³].  If omitted it is
+        computed as ``E_plane / t`` where
+        ``E_plane = E / (1 - nu²)``.
+    kt : float, optional
+        Shear spring stiffness kₜ [N mm⁻³].  If omitted it is ``G / t``.
+    G_c : float
+        Total fracture energy Gc [J/m^2].  Default 1.0 J/m^2.
+    G_Ic : float
+        Mode-I fracture toughness GIc [J/m^2].  Default 0.56 J/m^2.
+    G_IIc : float
+        Mode-II fracture toughness GIIc [J/m^2].  Default 0.79 J/m^2.
+    """
+
+    rho: float = Field(default=125, gt=0, description="Density of the Slab  [kg m⁻³]")
+    h: float = Field(default=20, gt=0, description="Height/Thickness of the slab  [mm]")
+    collapse_height: float = Field(
+        default=0.0, ge=0, description="Collapse height [mm]"
+    )
+    nu: float = Field(default=NU, ge=0, lt=0.5, description="Poisson's ratio [-]")
+
+    E: float = Field(default=0.0, ge=0, description="Young's modulus [MPa]")
+    G: float = Field(default=0.0, ge=0, description="Shear modulus [MPa]")
+    # Winkler springs (can be overridden by caller)
+    kn: float = Field(default=0.0, description="Normal stiffness  [N mm⁻³]")
+    kt: float = Field(default=0.0, description="Shear  stiffness  [N mm⁻³]")
+    # fracture-mechanics parameters
+    G_c: float = Field(
+        default=1.0, gt=0, description="Total fracture energy Gc [J/m^2]"
+    )
+    G_Ic: float = Field(
+        default=0.56, gt=0, description="Mode-I fracture toughness GIc [J/m^2]"
+    )
+    G_IIc: float = Field(
+        default=0.79, gt=0, description="Mode-II fracture toughness GIIc [J/m^2]"
+    )
+    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]")
+    E_method: Literal["bergfeld", "scapazzo", "gerling"] = Field(
+        default="bergfeld",
+        description="Method to calculate the Young's modulus",
+    )
+    grain_type: GrainType | None = Field(default=None, description="Grain type")
+    grain_size: float | None = Field(default=None, description="Grain size [mm]")
+    hand_hardness: HandHardness | None = Field(
+        default=None, description="Hand hardness"
+    )
+
+    model_config = ConfigDict(
+        frozen=True,
+        extra="forbid",
+    )
+
+    def model_post_init(self, _ctx):  # pylint: disable=arguments-differ
+        if self.E_method == "bergfeld":
+            object.__setattr__(self, "E", self.E or _bergfeld_youngs_modulus(self.rho))
+        elif self.E_method == "scapazzo":
+            object.__setattr__(self, "E", self.E or _scapozza_youngs_modulus(self.rho))
+        elif self.E_method == "gerling":
+            object.__setattr__(self, "E", self.E or _gerling_youngs_modulus(self.rho))
+        else:
+            raise ValueError(f"Invalid E_method: {self.E_method}")
+        object.__setattr__(
+            self, "collapse_height", self.collapse_height or _collapse_height(self.h)
+        )
+
+        # Validate that collapse height is smaller than layer height
+        if self.collapse_height >= self.h:
+            raise ValueError(
+                f"Collapse height ({self.collapse_height:.2f} mm) must be smaller than "
+                f"layer height ({self.h:.2f} mm). Consider reducing collapse_height or "
+                f"increasing layer thickness."
+            )
+
+        object.__setattr__(self, "G", self.G or self.E / (2 * (1 + self.nu)))
+        E_plane = self.E / (1 - self.nu**2)  # plane-strain Young
+        object.__setattr__(self, "kn", self.kn or E_plane / self.h)
+        object.__setattr__(self, "kt", self.kt or self.G / self.h)
+
+    @model_validator(mode="after")
+    def validate_positive_E_G(self):
+        """Validate that E and G are positive."""
+        if self.E <= 0:
+            raise ValueError("E must be positive")
+        if self.G <= 0:
+            raise ValueError("G must be positive")
+        return self
+
+
+if __name__ == "__main__":
+    ly1 = Layer(rho=180, h=120)  # E,G,k auto-computed
+    ly2 = Layer(rho=250, h=80, E=50.0)  # override E, derive G
+    wl = WeakLayer(rho=170, h=30)  # full set incl. kn, kt
+
+    print(wl.model_dump())

weac/components/model_input.py

@@ -0,0 +1,103 @@
+"""
+This module defines the input data model for the WEAC simulation.
+
+We utilize the pydantic library instead of dataclasses to define the input
+data model. The advantages of pydantic are:
+1. validate the input data for the WEAC simulation, compared to __post_init__ methods.
+2. generate JSON schemas for the input data, which is good for API endpoints.
+3. generate the documentation for the input data.
+
+Pydantic syntax is for a field:
+field_name: type = Field(..., gt=0, description="Description")
+- typing, default value, conditions, description
+"""
+
+import json
+import logging
+from typing import List
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from weac.components.layer import Layer, WeakLayer
+from weac.components.scenario_config import ScenarioConfig
+from weac.components.segment import Segment
+
+logger = logging.getLogger(__name__)
+
+
+class ModelInput(BaseModel):
+    """
+    Comprehensive input data model for a WEAC simulation.
+
+    Attributes
+    ----------
+    scenario_config : ScenarioConfig
+        Scenario configuration.
+    weak_layer : WeakLayer
+        Weak layer properties.
+    layers : List[Layer]
+        List of snow slab layers.
+    segments : List[Segment]
+        List of segments defining the slab geometry and loading.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    weak_layer: WeakLayer = Field(
+        default_factory=lambda: WeakLayer(rho=125, h=20, E=1.0),
+        description="Weak layer",
+    )
+    layers: List[Layer] = Field(
+        default_factory=lambda: [Layer(rho=250, h=100)], description="List of layers"
+    )
+    scenario_config: ScenarioConfig = Field(
+        default_factory=ScenarioConfig, description="Scenario configuration"
+    )
+    segments: List[Segment] = Field(
+        default_factory=lambda: [
+            Segment(length=5000, has_foundation=True, m=100),
+            Segment(length=5000, has_foundation=True, m=0),
+        ],
+        description="Segments",
+    )
+
+    @model_validator(mode="after")
+    def _validate_non_empty_components(self):
+        """Post-initialization checks."""
+        # Check that the last segment does not have a mass
+        if not self.segments:
+            raise ValueError("At least one segment is required")
+        if not self.layers:
+            raise ValueError("At least one layer is required")
+        if self.segments[-1].m != 0:
+            raise ValueError("The last segment must have a mass of 0")
+        return self
+
+
+if __name__ == "__main__":
+    # Example usage requiring all mandatory fields for proper instantiation
+    example_scenario_config = ScenarioConfig(phi=30, system_type="skiers")
+    # example_weak_layer = WeakLayer(
+    #     rho=200, h=10
+    # )  # grain_size, temp, E, G_I have defaults
+
+    example_layers = [
+        Layer(rho=250, h=100),  # grain_size, temp have defaults
+        Layer(rho=280, h=150),
+    ]
+    example_segments = [
+        Segment(length=5000, has_foundation=True, m=80),
+        Segment(length=3000, has_foundation=False, m=0),
+    ]
+
+    model_input = ModelInput(
+        scenario_config=example_scenario_config,
+        layers=example_layers,
+        segments=example_segments,
+    )
+    print(model_input.model_dump_json(indent=2))
+    print("\n\n")
+    schema_json = json.dumps(ModelInput.model_json_schema(), indent=2)
+    print(schema_json)

weac/components/scenario_config.py

@@ -0,0 +1,72 @@
+"""
+This module defines the ScenarioConfig class, which contains the configuration for a given scenario.
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+SystemType = Literal[
+    "skier", "skiers", "pst-", "-pst", "rot", "trans", "vpst-", "-vpst"
+]
+
+
+class ScenarioConfig(BaseModel):
+    """
+    Configuration for the overall scenario, such as slope angle.
+
+    Attributes
+    ----------
+    phi : float, optional
+        Slope angle in degrees (counterclockwise positive).
+    system_type : SystemType
+        Type of system. Allowed values are:
+        - skier: single skier in-between two segments
+        - skiers: multiple skiers spread over the slope
+        - pst-: positive PST: down-slope + slab-normal cuts
+        - -pst: negative PST: up-slope + slab-normal cuts
+        - rot: rotation: rotation of the slab
+        - trans: translation: translation of the slab
+        - vpst-: positive VPST: down-slope + vertical cuts
+        - -vpst: negative VPST: up-slope + vertical cuts
+    cut_length : float, optional
+        Cut length for PST/VPST [mm].
+    stiffness_ratio : float, optional
+        Stiffness ratio between collapsed and uncollapsed weak layer.
+    surface_load : float, optional
+        Surface line-load on slab [N/mm] (force per mm of out-of-plane width).
+    """
+
+    system_type: SystemType = Field(
+        default="skiers",
+        description="Type of system, '-pst', 'pst-', ....; \n"
+        "skier: single skier in-between two segments, \n"
+        "skiers: multiple skiers spread over the slope, \n"
+        "pst-: positive PST: down-slope + slab-normal cuts, \n"
+        "-pst: negative PST: up-slope + slab-normal cuts, \n"
+        "rot: rotation: rotation of the slab, \n"
+        "trans: translation: translation of the slab, \n"
+        "vpst-: positive VPST: down-slope + vertical cuts, \n"
+        "-vpst: negative VPST: up-slope + vertical cuts, \n",
+    )
+    phi: float = Field(
+        default=0.0,
+        ge=-90.0,
+        le=90.0,
+        description="Slope angle in degrees (counterclockwise positive)",
+    )
+    cut_length: float = Field(
+        default=0.0, ge=0, description="Cut length of performed PST or VPST [mm]"
+    )
+    stiffness_ratio: float = Field(
+        default=1000.0,
+        gt=0.0,
+        description="Stiffness ratio between collapsed and uncollapsed weak layer",
+    )
+    surface_load: float = Field(
+        default=0.0,
+        ge=0.0,
+        description="Surface line-load on slab [N/mm], e.g. evenly spaced weights, "
+        "Adam et al. (2024)",
+    )

weac/components/segment.py

@@ -0,0 +1,31 @@
+"""
+This module defines the Segment class, which represents a segment of the snowpack.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class Segment(BaseModel):
+    """
+    Defines a snow-slab segment: its length, foundation support, and applied loads.
+
+    Attributes
+    ----------
+    length: float
+        Segment length in millimeters [mm].
+    has_foundation: bool
+        Whether the segment is supported (foundation present) or cracked/free-hanging
+        (no foundation).
+    m: float
+        Skier mass at the segment's right edge [kg].
+    """
+
+    length: float = Field(default=5e3, ge=0, description="Segment length in [mm]")
+    has_foundation: bool = Field(
+        default=True,
+        description="Whether the segment is supported (foundation present) or "
+        "cracked/free-hanging (no foundation)",
+    )
+    m: float = Field(
+        default=0, ge=0, description="Skier mass at the segment's right edge in [kg]"
+    )

weac/constants.py

@@ -0,0 +1,37 @@
+"""
+Constants for the WEAC simulation.
+"""
+
+from typing import Final
+
+G_MM_S2: Final[float] = 9810.0  # gravitational acceleration (mm s⁻²)
+NU: Final[float] = 0.25  # Global Poisson's ratio
+SHEAR_CORRECTION_FACTOR: Final[float] = 5.0 / 6.0  # Shear-correction factor (slabs)
+STIFFNESS_COLLAPSE_FACTOR: Final[float] = (
+    1000.0  # Stiffness ratio between collapsed and uncollapsed weak layer.
+)
+ROMBERG_TOL: Final[float] = 1e-3  # Romberg integration tolerance
+LSKI_MM: Final[float] = 1000.0  # Effective out-of-plane length of skis (mm)
+EPS: Final[float] = 1e-9  # Global numeric tolerance for float comparisons
+
+RHO_ICE: Final[float] = 916.7  # Density of ice (kg/m^3)
+CB0: Final[float] = (
+    6.5
+    # Multiplicative constant of Young modulus
+    # parametrization according to Bergfeld et al. (2023)
+)
+CB1: Final[float] = (
+    4.4
+    # Exponent of Young modulus parameterization
+    # according to Bergfeld et al. (2023)
+)
+CG0: Final[float] = (
+    6.0
+    # Multiplicative constant of Young modulus
+    # parametrization according to Gerling et al. (2017)
+)
+CG1: Final[float] = (
+    4.5
+    # Exponent of Young modulus parameterization
+    # according to Gerling et al. (2017)
+)

weac/core/__init__.py

@@ -0,0 +1,10 @@
+"""
+Core modules for the WEAC model.
+"""
+
+from .eigensystem import Eigensystem
+from .scenario import Scenario
+from .slab import Slab
+from .system_model import SystemModel
+
+__all__ = ["Eigensystem", "Scenario", "Slab", "SystemModel"]