feat(assembly): rectangular stacks + ΔP/pump UI (v0.5 Phase 2)

- StackAssembly: add `aspect_ratio` (default 1.0, area-preserving)
  + `active_dimensions_m(a) → (w, h)`. BPP outer follows as rectangle.
- Fluid wire-up: `assembly_pressure_drop` + `assembly_pump_power_w`
  take current + T + λ, return ΔP result / stack pump [W].
- Streamlit: aspect_ratio slider in sidebar, ΔP/pump block in Assembly
  tab (λ, η_pump inputs, metrics, turbulent-regime warning).
- Visualization: `_draw_flow_pattern` takes (width, height) not edge;
  `draw_bpp_top_view` accepts optional aspect_ratio (backward compat).
- Legacy JSONs without aspect_ratio load as square (default field).
- +13 tests (total 157 passing), ruff clean.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: Tools00

CHANGELOG.md

@@ -5,11 +5,35 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) · SemVer.
 
 ## [Unreleased]
 
-### Planned (next)
-- Tafel-Plot (semi-log) in der UI zur Visualisierung der Validation
-- Effizienz-Kurve η_energy(j) neben Polarisationskurve
-- Vergleichs-Modus (2 Zellen/Stacks nebeneinander)
-- 2. Validation gegen experimentelle Paper-Kurve
+### Added (v0.5 Phase 2 — rectangular stacks + ΔP in UI)
+- **`aspect_ratio` auf `StackAssembly`** (`src/assembly.py`): dimensionslos,
+  default 1.0 (quadratisch = v0.4-Verhalten). `active_dimensions_m(a) → (w, h)`
+  mit `w·h = active_area_m2` und `w/h = aspect_ratio`. BPP-Außenmaße folgen
+  als `(w + 2·frame, h + 2·frame)` — echte rechteckige Plates.
+  - v0.4-JSONs ohne `aspect_ratio`-Feld laden weiterhin als quadratisch (Default).
+- **Fluid-Kopplung** (`src/assembly.py`): `assembly_pressure_drop(a, *, current_a,
+  temperature_k, stoich_ratio)` berechnet ΔP über `fluid.pressure_drop` mit
+  aktiven Dimensionen aus `aspect_ratio`. `assembly_pump_power_w(...)` liefert
+  Stack-Pumpenleistung (alle N Zellen hydraulisch parallel, Q_total = N·Q_cell).
+- **Streamlit Assembly-Tab**: neuer Block „Flow field — pressure drop & pump
+  power" mit λ- und η_pump-Slidern, Metrics für ΔP [kPa], v [cm/s], Re, Pump
+  [W] + Parasit-Anteil der Stack-Leistung. Turbulenter Regime (Re > 2000)
+  liefert saubere Warnung statt Crash.
+- **Streamlit Sidebar**: `aspect_ratio`-Slider 0.25…4.0; Caption zeigt
+  resultierende w × h der aktiven Fläche. Area bleibt beim Drehen konstant.
+- **13 neue Tests** (total 157): aspect_ratio area-preserving, ΔP-Linearität
+  in I, Pump-Power ∝ N, serpentine > parallel ΔP, JSON-Roundtrip mit
+  aspect_ratio, Legacy-JSON-Kompat, rechteckige BPP-Visualization.
+- **Rechteckiges Flow-Field-Rendering** (`src/visualization.py`):
+  `_draw_flow_pattern` nimmt `width_mm`+`height_mm` statt `edge_mm`. Bei
+  aspect_ratio ≠ 1.0 zeichnen alle drei Pattern (parallel, serpentine,
+  interdigitated) auf rechteckiger Fläche.
+
+### Planned (next, v0.5 Phase 3 + release)
+- Validation gegen Bernt et al. (2020) *Chem. Ing. Tech.* 92(1-2), 31–39, Fig. 1
+  (80 °C, Nafion 212, 2 mg Ir/cm², 0.35 mg Pt/cm²; RMSE-Target 40 mV)
+- ADR-007 für v0.5-Architektur-Entscheidungen
+- v0.5.0 Release-Commit + README-Update
 
 ## [0.4.1] — 2026-04-20
 

src/assembly.py

@@ -29,6 +29,12 @@
     GasketSpec,
     TieRodSpec,
 )
+from src.fluid import (
+    PressureDropResult,
+    pressure_drop,
+    pump_power_w,
+    stoichiometric_water_flow_m3_s,
+)
 from src.materials import (
     CATALYSTS_ANODE,
     CATALYSTS_CATHODE,
@@ -47,8 +53,10 @@ class StackAssembly:
     Vollständige Konfiguration eines Stacks. Alle Bauteile per Preset-Name.
 
     active_area_m2 ist die geometrische Fläche pro Zelle (innerhalb des
-    Gasket-Rahmens). BPP ist quadratisch angenommen mit Kante
-    sqrt(active_area) + 2 * gasket.frame_width.
+    Gasket-Rahmens). aspect_ratio (v0.5) = width/height der aktiven Fläche,
+    dimensionslos, > 0. aspect_ratio=1.0 ergibt quadratisch (v0.4-Verhalten).
+    aspect_ratio=2.0 → Breite = 2× Höhe, gleiche Gesamtfläche. BPP-Außenkante
+    folgt als (w + 2·frame, h + 2·frame).
     """
 
     n_cells: int
@@ -65,6 +73,8 @@ class StackAssembly:
     tie_rod: str
     # Optional Catalyst-Layer-Dicke aus Loading+Density; default 10 µm reicht für Visualisierung.
     catalyst_layer_thickness_m: float = field(default=10e-6)
+    # v0.5: Aspect-Ratio der aktiven Fläche (width/height). Default 1.0 = quadratisch.
+    aspect_ratio: float = field(default=1.0)
 
     # ---------------- Preset resolution ---------------- #
 
@@ -150,15 +160,31 @@ def total_stack_mass_kg(a: StackAssembly) -> float:
     return m_bpp + m_ep + m_cc
 
 
+def active_dimensions_m(a: StackAssembly) -> tuple[float, float]:
+    """
+    Aktive Fläche (width, height) [m]. Bei aspect_ratio=1.0 quadratisch.
+
+    Beziehung:  w · h = active_area_m2  und  w / h = aspect_ratio
+    →  w = sqrt(A · aspect_ratio),  h = sqrt(A / aspect_ratio)
+
+    @raises ValueError: wenn aspect_ratio ≤ 0.
+    """
+    if a.aspect_ratio <= 0:
+        raise ValueError(f"aspect_ratio={a.aspect_ratio} must be positive")
+    w = (a.active_area_m2 * a.aspect_ratio) ** 0.5
+    h = (a.active_area_m2 / a.aspect_ratio) ** 0.5
+    return w, h
+
+
 def bpp_outer_dimensions_m(a: StackAssembly) -> tuple[float, float]:
     """
-    Kantenlänge der quadratischen BPP [m, m].
+    BPP-Außenmaße (width, height) [m] = active + 2·frame_width in jeder Richtung.
 
-    = sqrt(active_area) + 2 * gasket.frame_width. Return-Tuple ist (width, height).
-    Rechteckige Stacks sind v0.5-Scope.
+    Bei aspect_ratio=1.0 ist w == h (quadratische BPP); ansonsten rechteckig.
     """
-    edge = a.active_area_m2**0.5 + 2 * a.gasket_spec().frame_width_m
-    return edge, edge
+    aw, ah = active_dimensions_m(a)
+    fw = a.gasket_spec().frame_width_m
+    return aw + 2 * fw, ah + 2 * fw
 
 
 def bpp_resistance_ohm_m2(a: StackAssembly) -> float:
@@ -173,6 +199,82 @@ def bpp_resistance_ohm_m2(a: StackAssembly) -> float:
     return bpp.bulk_resistivity_ohm_m * bpp.thickness_m
 
 
+# ---------------- Fluid coupling (v0.5) ---------------- #
+
+
+def assembly_pressure_drop(
+    a: StackAssembly,
+    *,
+    current_a: float,
+    temperature_k: float,
+    stoich_ratio: float = 50.0,
+) -> PressureDropResult:
+    """
+    Druckabfall im Flow-Field einer Zelle bei Betriebsbedingungen [Pa].
+
+    Volumenstrom pro Zelle wird aus Stromstärke und Stöchiometrie berechnet
+    (`fluid.stoichiometric_water_flow_m3_s`), anschließend laminar durch das
+    BPP-Flow-Field geleitet (`fluid.pressure_drop`).
+
+    Args:
+        current_a:      Zellstrom [A] (NICHT Stack-Strom — im Stack sind alle
+                        Zellen elektrisch in Serie und sehen denselben I).
+        temperature_k:  Betriebstemperatur [K] für Wasser-Eigenschaften + Stoich.
+        stoich_ratio:   λ = Q_feed / Q_stoich; default 50 (typ. PEM-EC).
+
+    Raises:
+        ValueError: wenn Re > 2000 (turbulent, nicht implementiert in v0.5).
+
+    @ref: siehe src/fluid.py.
+    """
+    bpp = a.bipolar_plate_spec()
+    aw, ah = active_dimensions_m(a)
+    q_cell = stoichiometric_water_flow_m3_s(
+        current_a=current_a,
+        stoich_ratio=stoich_ratio,
+        temperature_k=temperature_k,
+    )
+    return pressure_drop(
+        flow_pattern=bpp.flow_pattern,
+        channel_width_m=bpp.channel_width_m,
+        channel_depth_m=bpp.channel_depth_m,
+        channel_pitch_m=bpp.channel_pitch_m,
+        active_width_m=aw,
+        active_height_m=ah,
+        volumetric_flow_per_cell_m3_s=q_cell,
+        temperature_k=temperature_k,
+    )
+
+
+def assembly_pump_power_w(
+    a: StackAssembly,
+    *,
+    current_a: float,
+    temperature_k: float,
+    stoich_ratio: float = 50.0,
+    eta_pump: float = 0.5,
+) -> float:
+    """
+    Hydraulische Pumpenleistung für den gesamten Stack [W].
+
+    P_pump,stack = N_cells · ΔP_cell · Q_cell / η_pump.
+    (Alle Zellen sind hydraulisch parallel geschaltet, sehen denselben ΔP,
+    erhalten jeweils eigenen Q_cell; Stack-Pumpe liefert Summe.)
+    """
+    res = assembly_pressure_drop(
+        a,
+        current_a=current_a,
+        temperature_k=temperature_k,
+        stoich_ratio=stoich_ratio,
+    )
+    q_cell = stoichiometric_water_flow_m3_s(
+        current_a=current_a,
+        stoich_ratio=stoich_ratio,
+        temperature_k=temperature_k,
+    )
+    return a.n_cells * pump_power_w(res.dp_pa, q_cell, eta_pump)
+
+
 # ---------------- JSON Save/Load ---------------- #
 
 

src/streamlit_app.py

@@ -23,6 +23,9 @@
 from src import units as U
 from src.assembly import (
     StackAssembly,
+    active_dimensions_m,
+    assembly_pressure_drop,
+    assembly_pump_power_w,
     bpp_outer_dimensions_m,
     bpp_resistance_ohm_m2,
     from_json,
@@ -146,6 +149,23 @@
     value=100.0,
     step=1.0,
 )
+aspect_ratio = st.sidebar.slider(
+    "Aspect ratio (width / height)",
+    min_value=0.25,
+    max_value=4.0,
+    value=1.0,
+    step=0.05,
+    help=(
+        "Shape of the active area. 1.0 = square (v0.4 default). "
+        "0.5 = tall, 2.0 = wide. Area stays constant; only w·h ratio changes."
+    ),
+)
+_aw_m = (U.cm2_to_m2(active_area_cm2) * aspect_ratio) ** 0.5
+_ah_m = (U.cm2_to_m2(active_area_cm2) / aspect_ratio) ** 0.5
+st.sidebar.caption(
+    f"→ active {_aw_m * 1000:.1f} × {_ah_m * 1000:.1f} mm "
+    f"(area {active_area_cm2:.0f} cm² unchanged)"
+)
 
 # ---------------- Sidebar: Thermal ---------------- #
 st.sidebar.header("Thermal management")
@@ -633,6 +653,7 @@
         current_collector=cc_sel,
         gasket=gk_sel,
         tie_rod=tr_sel,
+        aspect_ratio=float(aspect_ratio),
     )
 
     if uploaded is not None:
@@ -649,11 +670,12 @@
         fig_cs = draw_layer_cross_section(assembly, max_visible_cells=6)
         st.plotly_chart(fig_cs, use_container_width=True)
 
-        fig_top = draw_bpp_top_view(bpp_sel, area_si, gk_sel)
+        fig_top = draw_bpp_top_view(bpp_sel, area_si, gk_sel, aspect_ratio=float(aspect_ratio))
         st.plotly_chart(fig_top, use_container_width=True)
 
     st.markdown("### Stack stats")
-    bpp_w_m, _ = bpp_outer_dimensions_m(assembly)
+    bpp_w_m, bpp_h_m = bpp_outer_dimensions_m(assembly)
+    aw_m, ah_m = active_dimensions_m(assembly)
     stack_h_mm = total_stack_height_m(assembly) * 1000.0
     stack_m_kg = total_stack_mass_kg(assembly)
     r_bpp = bpp_resistance_ohm_m2(assembly)
@@ -662,14 +684,85 @@
     k1, k2, k3, k4 = st.columns(4)
     k1.metric("Stack height", f"{stack_h_mm:.1f} mm")
     k2.metric("Stack mass (approx.)", f"{stack_m_kg:.2f} kg")
-    k3.metric("BPP outer edge", f"{bpp_w_m * 1000.0:.1f} mm")
+    k3.metric("BPP outer", f"{bpp_w_m * 1000.0:.1f} × {bpp_h_m * 1000.0:.1f} mm")
     k4.metric("Open-area ratio", f"{oar * 100:.0f} %")
 
     st.caption(
-        f"Effective r_bpp from assembly: {r_bpp * 1e4:.3f} mΩ·cm² "
+        f"Active area: {aw_m * 1000:.1f} × {ah_m * 1000:.1f} mm "
+        f"(aspect ratio {aspect_ratio:.2f}). "
+        f"Effective r_bpp: {r_bpp * 1e4:.3f} mΩ·cm² "
         f"(ρ·t of {assembly.bipolar_plate_spec().material}) — active in Polarization tab."
     )
 
+    st.divider()
+    st.markdown("### Flow field — pressure drop & pump power")
+    st.caption(
+        "Laminar ΔP via Darcy-Weisbach with Shah & London (1978) f·Re correlation "
+        "for rectangular channels. Volumetric flow from stoichiometry "
+        "(λ · I / (2·F) · M_H₂O / ρ)."
+    )
+
+    fc1, fc2 = st.columns(2)
+    with fc1:
+        stoich_lambda = st.slider(
+            "Stoichiometric ratio λ",
+            min_value=1.0,
+            max_value=200.0,
+            value=50.0,
+            step=1.0,
+            help="Water feed = λ · stoichiometric minimum. Typical PEM-EC: 10–100.",
+        )
+    with fc2:
+        eta_pump = st.slider(
+            "Pump efficiency η_pump",
+            min_value=0.10,
+            max_value=0.90,
+            value=0.50,
+            step=0.05,
+            help="Commercial membrane/centrifugal pumps for EC service: 0.3–0.7.",
+        )
+
+    current_per_cell_a = j_op_si * area_si  # I = j · A (cells in series → same I)
+    try:
+        dp_result = assembly_pressure_drop(
+            assembly,
+            current_a=current_per_cell_a,
+            temperature_k=t_kelvin,
+            stoich_ratio=stoich_lambda,
+        )
+        pump_total_w = assembly_pump_power_w(
+            assembly,
+            current_a=current_per_cell_a,
+            temperature_k=t_kelvin,
+            stoich_ratio=stoich_lambda,
+            eta_pump=eta_pump,
+        )
+        pump_frac = (
+            pump_total_w / (stack_p["p_electric_kw"] * 1000.0)
+            if stack_p["p_electric_kw"] > 0
+            else 0.0
+        )
+
+        f1, f2, f3, f4 = st.columns(4)
+        f1.metric("ΔP per cell", f"{dp_result.dp_pa / 1000:.2f} kPa")
+        f2.metric("Flow velocity", f"{dp_result.velocity_m_s * 100:.1f} cm/s")
+        f3.metric("Reynolds", f"{dp_result.reynolds:.0f}")
+        f4.metric("Pump power (stack)", f"{pump_total_w:.1f} W")
+
+        st.caption(
+            f"{dp_result.n_channels} channel(s), "
+            f"path length {dp_result.path_length_m * 1000:.1f} mm, "
+            f"D_h = {dp_result.hydraulic_diameter_m * 1e6:.0f} µm, "
+            f"f = {dp_result.friction_factor:.3f}. "
+            f"Pump parasitic: {pump_frac * 100:.2f} % of stack electrical power."
+        )
+    except ValueError as err:
+        st.warning(
+            f"Pressure-drop model out of range: {err}. "
+            "v0.5 covers laminar only (Re < 2000). Try lower current, larger channels, "
+            "or a parallel flow pattern."
+        )
+
     st.divider()
     st.markdown("**Save config**")
     import json as _json