clean-Up: Variational formulation

.cursorignore

@@ -1,5 +1,4 @@
 /.venv/
 /data/
 /img/
-/demo/
 /LICENSE

.gitignore

@@ -28,6 +28,7 @@ venv/
 .env
 .env.local
 .env.*
+!.env.example
 
 # Caches
 .ruff_cache/

pyproject.toml

@@ -36,7 +36,7 @@ Documentation = "https://2phi.github.io/weac"
 interactive = [
     "jupyter",
     "ipython>=8.37.0",
-    "ipykernel>=6.30.1",
+    "ipykernel>=7.1.0",
     "jupyter_client>=8.6.3",
     "jupyter_core>=5.8.1",
     "matplotlib-inline>=0.1.7",
@@ -56,7 +56,7 @@ dev = [
     # Jupyter stack for interactive development
     "jupyter",
     "ipython>=8.37.0",
-    "ipykernel>=6.30.1",
+    "ipykernel>=7.1.0",
     "jupyter_client>=8.6.3",
     "jupyter_core>=5.8.1",
     "matplotlib-inline>=0.1.7",

src/weac/analysis/analyzer.py

@@ -745,8 +745,8 @@ def differential_ERR(
                     )
                 Gdif[1:, j] = np.concatenate(
                     (
-                        self.sm.fq.Gi(z_ct, z_ub, phi=phi, theta=theta, unit=unit),
-                        self.sm.fq.Gii(z_ct, z_ub, phi=phi, theta=theta, unit=unit),
+                        self.sm.fq.Gi(z_ct, z_ub, phi, theta, unit=unit),
+                        self.sm.fq.Gii(z_ct, z_ub, phi, theta, unit=unit),
                         self.sm.fq.Giii(z_ct, z_ub, phi, theta, unit=unit),
                     )
                 )

src/weac/analysis/criteria_evaluator.py

@@ -1266,20 +1266,18 @@ def _calculate_maximal_stresses(
         """
         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")
+        Sxx_kPa = analyzer.Sxx(Z=Z, phi=system.scenario.phi, dz=1, 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
+            Z=Z, phi=system.scenario.phi, dz=1, unit="kPa"
         )
+        Sxx_norm = analyzer.Sxx(Z=Z, phi=system.scenario.phi, dz=1, normalize=True)
         principal_stress_norm = analyzer.principal_stress_slab(
-            Z=Z, phi=system.scenario.phi, dz=5, unit="kPa", normalize=True
+            Z=Z, phi=system.scenario.phi, dz=1, 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)
+        height_level_prone_to_fail = np.max(Sxx_norm, axis=1) > 1
         slab_tensile_criterion = np.mean(height_level_prone_to_fail)
         if print_call_stats:
             analyzer.print_call_stats(

src/weac/components/__init__.py

@@ -6,17 +6,29 @@
 from .criteria_config import CriteriaConfig
 from .layer import Layer, WeakLayer
 from .model_input import ModelInput
-from .segment import Segment
+from .presets import (
+    LESS_WEAK_LAYER,
+    VERY_WEAK_LAYER,
+    WEAK_LAYER,
+    WEAK_LAYER_PRESETS,
+    weak_layer_from_preset,
+)
 from .scenario_config import ScenarioConfig, SystemType, TouchdownMode
+from .segment import Segment
 
 __all__ = [
     "Config",
-    "WeakLayer",
-    "Layer",
-    "Segment",
     "CriteriaConfig",
-    "ScenarioConfig",
+    "Layer",
+    "LESS_WEAK_LAYER",
     "ModelInput",
+    "ScenarioConfig",
+    "Segment",
     "SystemType",
     "TouchdownMode",
+    "VERY_WEAK_LAYER",
+    "WEAK_LAYER",
+    "WEAK_LAYER_PRESETS",
+    "WeakLayer",
+    "weak_layer_from_preset",
 ]

src/weac/components/config.py

@@ -12,7 +12,7 @@
 
 from typing import Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from weac.components.scenario_config import TouchdownMode
 
@@ -33,6 +33,8 @@ class Config(BaseModel):
         are recalculated with different scenario parameters.
     """
 
+    model_config = ConfigDict(validate_assignment=True)
+
     touchdown: bool = Field(
         default=False, description="Whether to include slab touchdown in the analysis"
     )
@@ -49,6 +51,37 @@ class Config(BaseModel):
         description="Force a specific touchdown mode instead of auto-calculating",
     )
 
+    @field_validator("touchdown")
+    @classmethod
+    def validate_touchdown_with_backend(cls, v, info):
+        """Validate touchdown compatibility when touchdown is assigned."""
+        if v and info.data.get("backend") == "generalized":
+            raise ValueError(
+                "Slab touchdown is only available for the classic backend. "
+                "Set backend='classic' or disable touchdown."
+            )
+        return v
+
+    @field_validator("backend")
+    @classmethod
+    def validate_backend_with_touchdown(cls, v, info):
+        """Validate backend compatibility when backend is assigned."""
+        if v == "generalized" and info.data.get("touchdown"):
+            raise ValueError(
+                "Slab touchdown is only available for the classic backend. "
+                "Set backend='classic' or disable touchdown."
+            )
+        return v
+
+    @model_validator(mode="after")
+    def validate_touchdown_backend_compatibility(self):
+        if self.touchdown and self.backend == "generalized":
+            raise ValueError(
+                "Slab touchdown is only available for the classic backend. "
+                "Set backend='classic' or disable touchdown."
+            )
+        return self
+
 
 if __name__ == "__main__":
     config = Config()

src/weac/components/presets.py

@@ -0,0 +1,53 @@
+"""Named presets for WEAC components."""
+
+from weac.components.layer import WeakLayer
+
+_WEAK_LAYER_PARAMS: dict[str, dict] = {
+    "very_weak": {
+        "rho": 125,
+        "h": 10,
+        "sigma_c": 5.16,
+        "tau_c": 4.09,
+        "E": 2.0,
+    },
+    "weak": {
+        "rho": 125,
+        "h": 10,
+        "sigma_c": 6.16,
+        "tau_c": 5.09,
+        "E": 2.0,
+    },
+    "less_weak": {
+        "rho": 125,
+        "h": 10,
+        "sigma_c": 7.16,
+        "tau_c": 6.09,
+        "E": 2.0,
+    },
+}
+
+VERY_WEAK_LAYER = WeakLayer(**_WEAK_LAYER_PARAMS["very_weak"])
+WEAK_LAYER = WeakLayer(**_WEAK_LAYER_PARAMS["weak"])
+LESS_WEAK_LAYER = WeakLayer(**_WEAK_LAYER_PARAMS["less_weak"])
+
+WEAK_LAYER_PRESETS: dict[str, WeakLayer] = {
+    "very_weak": VERY_WEAK_LAYER,
+    "weak": WEAK_LAYER,
+    "less_weak": LESS_WEAK_LAYER,
+}
+
+
+def weak_layer_from_preset(name: str, **overrides) -> WeakLayer:
+    """Create a WeakLayer from a named preset, with optional overrides.
+
+    Without overrides, returns the shared frozen instance.
+    With overrides, returns a new instance.
+    """
+    if name not in _WEAK_LAYER_PARAMS:
+        raise ValueError(
+            f"Unknown preset '{name}'. Available: {list(_WEAK_LAYER_PARAMS)}"
+        )
+    if not overrides:
+        return WEAK_LAYER_PRESETS[name]
+    params = {**_WEAK_LAYER_PARAMS[name], **overrides}
+    return WeakLayer(**params)