Everything current: pid-designer connections, the engine work after #72, feed-twin

EngineDesign/backend/routers/evaluate.py

@@ -20,7 +20,9 @@
 class StabilityOverrides(BaseModel):
     """Optional forward-mode knobs for rich stability re-evaluation."""
     eta_inj_O: float | None = Field(default=None, gt=0, le=0.6, description="Oxidizer ΔP_inj/Pc")
-    smd_um: float | None = Field(default=None, gt=0, le=200, description="Oxidizer spray SMD [µm]")
+    smd_um: float | None = Field(default=None, gt=0, le=400, description="Oxidizer spray SMD [µm]")
+    smd_F_um: float | None = Field(default=None, gt=0, le=400, description="Fuel spray SMD [µm]")
+    eta_inj_F: float | None = Field(default=None, gt=0, le=0.6, description="Fuel ΔP_inj/Pc")
     n_interaction: float | None = Field(default=None, gt=0, le=2, description="Combustion interaction index n")
     chi_acoustic: float | None = Field(default=None, gt=0, le=1, description="Acoustic sensitive-fraction χ")
     time_lag_model: Literal["leonardi_dtl", "d2_law"] | None = Field(

EngineDesign/backend/routers/optimizer.py

@@ -42,6 +42,43 @@ def layer1_design_is_valid(results: Dict[str, Any]) -> tuple[bool, list]:
         if (key.endswith("_check_passed") or key.endswith("_gate_passed")) and passed is False:
             reasons.append(f"{key} = False")
     return (not reasons), reasons
+
+
+def merge_design_requirements(
+    old: Optional[Dict[str, Any]], incoming: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Lay a (possibly partial) requirements payload over the requirements already loaded.
+
+    A key ABSENT from ``incoming`` keeps its current value. A key sent as an explicit
+    ``None`` is cleared. Those are different intents -- a form that only knows a dozen
+    fields must not, by not mentioning them, reset the ~100 ``layer1_*`` knobs, the injector
+    face limits and the pinned seed to schema defaults. It did: the save route rebuilt
+    ``design_requirements`` from the payload alone, and the next run optimised a different
+    problem than the one the file described. ``frozen_parameters`` merges key by key with the
+    same null-clears rule, as it already did.
+    """
+    merged: Dict[str, Any] = dict(old or {})
+    prev_fp = merged.get("frozen_parameters")
+    old_fp: Dict[str, Any] = (
+        {k: v for k, v in prev_fp.items() if v is not None} if isinstance(prev_fp, dict) else {}
+    )
+    for key, value in incoming.items():
+        if key != "frozen_parameters":
+            merged[key] = value
+    if "frozen_parameters" in incoming:
+        new_fp = incoming.get("frozen_parameters")
+        fp = dict(old_fp)
+        for k, v in (new_fp.items() if isinstance(new_fp, dict) else ()):
+            if v is None:
+                fp.pop(k, None)
+            else:
+                fp[k] = v
+        merged["frozen_parameters"] = fp if fp else None
+    elif old_fp:
+        merged["frozen_parameters"] = old_fp
+    elif "frozen_parameters" in merged:
+        merged["frozen_parameters"] = None
+    return merged
 from engine.pipeline.config_schemas import DesignRequirementsConfig
 from engine.optimizer.layers.layer1_static_optimization import run_layer1_optimization
 from engine.optimizer.layers.layer2_pressure import run_layer2_pressure
@@ -132,26 +169,12 @@ async def save_design_requirements(
         )
 
     try:
-        # Merge frozen_parameters so a partial UI payload cannot silently drop YAML pins.
-        req_in = dict(request.requirements)
+        # Overlay the payload on what is loaded; a partial payload must not reset the rest.
         old_dr = session.app_state.config.design_requirements
-        old_fp: dict = {}
-        if old_dr is not None and old_dr.frozen_parameters is not None:
-            old_fp = old_dr.frozen_parameters.model_dump(exclude_none=True)
-        if "frozen_parameters" not in req_in:
-            if old_fp:
-                req_in["frozen_parameters"] = old_fp
-        else:
-            new_fp = req_in.get("frozen_parameters")
-            if not isinstance(new_fp, dict):
-                new_fp = {}
-            merged_fp = dict(old_fp)
-            for k, v in new_fp.items():
-                if v is None:
-                    merged_fp.pop(k, None)
-                else:
-                    merged_fp[k] = v
-            req_in["frozen_parameters"] = merged_fp if merged_fp else None
+        req_in = merge_design_requirements(
+            old_dr.model_dump() if old_dr is not None else None,
+            dict(request.requirements),
+        )
 
         # Validate requirements using Pydantic
         requirements = DesignRequirementsConfig(**req_in)

EngineDesign/configs/default.yaml

@@ -22,9 +22,14 @@ fluids:
     specific_heat: 2300.0
     thermal_conductivity: 0.15
     temperature: 90.0
-    latent_heat: null
-    boiling_point: null
-    molecular_weight: null
+    # Stability-only inputs (droplet vaporization lag); the forward performance path does not read
+    # them, so filling them in cannot move thrust/Isp or the golden anchors. Left null, the chug
+    # model silently substituted these same handbook numbers on every evaluation of the default
+    # config and reported three fallbacks it should never have needed.
+    latent_heat: 213000.0     # J/kg, NIST oxygen at 1 atm
+    boiling_point: 90.19      # K,    NIST oxygen at 1 atm
+    molecular_weight: 32.0    # g/mol
+    bulk_modulus_pa: 1500000000.0   # order-of-magnitude LOX; refine via water-hammer test T5
 injector:
   type: impinging
   geometry: