combaero-gui 0.3.1.dev2__tar.gz → 0.4.2__tar.gz

{combaero_gui-0.3.1.dev2 → combaero_gui-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: combaero-gui
-Version: 0.3.1.dev2
+Version: 0.4.2
 Summary: CombAero Network GUI — React/FastAPI desktop application
 Author-email: thiemom <2641939+thiemom@users.noreply.github.com>
 License: MIT
@@ -21,7 +21,7 @@ Requires-Dist: fastapi
 Requires-Dist: uvicorn
 Requires-Dist: pydantic
 Requires-Dist: pandas
-Requires-Dist: combaero~=0.3
+Requires-Dist: combaero~=0.4
 Provides-Extra: gui
 
 # CombAero Network Designer GUI

{combaero_gui-0.3.1.dev2 → combaero_gui-0.4.2}/backend/graph_builder.py

@@ -22,11 +22,12 @@ from combaero.network import (
     PressureLossElement,
     RibbedModel,
     SmoothModel,
-    TeeJunctionElement,
     ThermalWall,
     VortexElement,
     WallLayer,
+    WallNode,
 )
+from combaero.network.mpce_v2_element import ConstantKTeeElement, MPCEv2Element
 
 from .schemas import (
     AreaChangeData,
@@ -42,6 +43,7 @@ from .schemas import (
     LinearThetaHeadLossData,
     MassBoundaryData,
     MomentumChamberData,
+    MPCETeeData,
     NetworkGraphSchema,
     OrificeData,
     PinFinModelData,
@@ -49,9 +51,9 @@ from .schemas import (
     PressureBoundaryData,
     RibbedModelData,
     SmoothModelData,
-    TeeJunctionData,
     ThermalWallData,
     VortexData,
+    WallData,
 )
 
 
@@ -194,9 +196,14 @@ def _guess_from_prior_result(node_data: dict, prefix: str) -> dict:
     solves on a difficult network benefit from accumulated Newton progress.
     Works for both pressure-node results (state.P/T/Pt/Tt) and element
     results (m_dot stored at the top level).
+
+    Only CONVERGED prior results are used: the best iterate of a failed
+    solve is stored too, and seeding from it parks Newton at the stall
+    point -- one failed solve (e.g. a timeout) would otherwise poison
+    every subsequent run of a network that converges fine from cold.
     """
     prior = node_data.get("result")
-    if not prior:
+    if not prior or not prior.get("success"):
         return {}
     short: dict[str, float] = {}
     state = prior.get("state")
@@ -235,6 +242,93 @@ def _build_discrete_loss_correlation(
     return ConstantFractionLoss(xi=xi)
 
 
+def _channel_D_at_tee_port(
+    schema_edges,
+    schema_nodes,
+    tee_id: str,
+    port: str,
+) -> float | None:
+    """Return the inner diameter [m] of a channel directly connected to a tee port.
+
+    The user-facing schema connects channels straight to tee handles (the
+    port-MCN is auto-inserted at network-build time, not at schema level).
+    Used by ``mpce_tee`` dispatch to inherit ``F_C`` / ``F_branch``
+    from the connected channel geometry when the
+    user has not explicitly set them. Returns None when no channel is
+    directly connected (e.g., plenum, boundary, multi-hop).
+    """
+    src_handle = f"port-{port}-source"
+    tgt_handle = f"port-{port}-target"
+    for edge in schema_edges:
+        if edge.data and edge.data.get("type") == "thermal":
+            continue
+        neighbour_id: str | None = None
+        if edge.source == tee_id and edge.sourceHandle == src_handle:
+            neighbour_id = edge.target
+        elif edge.target == tee_id and edge.targetHandle == tgt_handle:
+            neighbour_id = edge.source
+        if neighbour_id is None:
+            continue
+        neighbour = next((n for n in schema_nodes if n.id == neighbour_id), None)
+        if neighbour is None or neighbour.type != "channel":
+            continue
+        d = neighbour.data.get("D") if isinstance(neighbour.data, dict) else None
+        if d is None:
+            continue
+        try:
+            d_val = float(d)
+        except (TypeError, ValueError):
+            continue
+        if d_val > 0.0:
+            return d_val
+    return None
+
+
+def _resolve_tee_areas(
+    schema_edges,
+    schema_nodes,
+    tee_id: str,
+    F_C_explicit: float | None,
+    F_branch_explicit: float | None,
+    psi_fallback: float,
+) -> tuple[float, float, float]:
+    """Resolve (F_C, F_branch, psi) for a 3-port tee, applying inheritance.
+
+    Precedence:
+      1. Explicit user-set value (non-null) wins.
+      2. Channel D at the connected port (auto-inherited).
+      3. Fallback: F_C=0.01 m^2, F_branch derived from psi_fallback.
+
+    Returns (F_C, F_branch, psi) all resolved to concrete floats.
+    """
+    F_C = F_C_explicit
+    if F_C is None:
+        # Try common port first, then straight (both are F_C in Bassett/Idelchik
+        # geometry where F_s = F_c by definition).
+        for port in ("common", "straight"):
+            d = _channel_D_at_tee_port(schema_edges, schema_nodes, tee_id, port)
+            if d is not None:
+                F_C = _math.pi / 4.0 * d * d
+                break
+    if F_C is None:
+        F_C = 0.01  # ultimate default for a fully disconnected tee
+
+    F_branch = F_branch_explicit
+    if F_branch is None:
+        d = _channel_D_at_tee_port(schema_edges, schema_nodes, tee_id, "branch")
+        if d is not None:
+            F_branch = _math.pi / 4.0 * d * d
+
+    if F_branch is not None and F_branch > 0.0:
+        psi = F_C / F_branch
+    else:
+        # No branch channel; use stored psi to derive F_branch
+        psi = max(float(psi_fallback), 1e-12)
+        F_branch = F_C / psi
+
+    return F_C, F_branch, psi
+
+
 def _port_from_handle(handle: str | None) -> str | None:
     """Extract port name from a tee handle string.
 
@@ -256,6 +350,7 @@ def _find_tee_port(
     port: str,
     nodes_map: dict,
     tee_port_node_map: dict | None = None,
+    wall_edge_remap: dict | None = None,
 ) -> str:
     """Return the physical-node ID connected to a named tee port.
 
@@ -276,6 +371,8 @@ def _find_tee_port(
         else:
             continue
         if nid in nodes_map:
+            if wall_edge_remap and edge.id in wall_edge_remap:
+                return wall_edge_remap[edge.id]
             return nid
         if tee_port_node_map and (tee_id, port) in tee_port_node_map:
             return tee_port_node_map[(tee_id, port)]
@@ -335,7 +432,7 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
                 area=data.area,
                 Dh=data.Dh,
                 surface=ConvectiveSurface(
-                    area=data.area,
+                    area=data.area or 0.0,
                     model=map_surface_model(data.surface),
                     Nu_multiplier=data.Nu_multiplier
                     * (schema.solver_settings.Nu_multiplier or 1.0),
@@ -352,8 +449,9 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
             node = MomentumChamberNode(
                 node_id,
                 area=data.area,
+                Dh=data.Dh,
                 surface=ConvectiveSurface(
-                    area=data.area,
+                    area=data.area or 0.0,
                     model=map_surface_model(data.surface),
                     Nu_multiplier=data.Nu_multiplier
                     * (schema.solver_settings.Nu_multiplier or 1.0),
@@ -367,12 +465,18 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
             nodes_map[node_id] = node
         elif node_type == "probe":
             pass  # Display-only diagnostic nodes -- not part of the solver graph
+        elif node_type == "wall":
+            data = WallData(**node_data)
+            node = WallNode(node_id)
+            node.initial_guess = _expand_initial_guess(data.initial_guess, node_id)
+            net.add_node(node)
+            nodes_map[node_id] = node
         else:
             # This is an element node (Channel, Orifice, etc.)
             element_nodes.append(node_schema)
 
     element_ids = {node.id for node in element_nodes}
-    tee_ids = {node.id for node in element_nodes if node.type == "tee_junction"}
+    tee_ids = {node.id for node in element_nodes if node.type == "mpce_tee"}
 
     # 1b. Create implicit junction nodes for element -> element visual links.
     # For direct element<->element connections we auto-insert a MomentumChamberNode.
@@ -398,58 +502,138 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
             edge_junction_map[(edge.source, edge.target)] = junction_id
 
         elif src_tee and tgt_elem:
-            # Tee port → element (e.g. tee.common-source → channel): auto-insert PlenumNode
+            # Tee port → element (e.g. tee.common-source → channel): auto-insert MomentumChamberNode
+            # so that Pt != P_static and velocity is correctly accounted for.
             port = _port_from_handle(edge.sourceHandle)
             if port and (edge.source, port) not in tee_port_node_map:
                 jid = f"__tee_jct__{edge.source}_{port}"
                 if jid not in nodes_map:
-                    jn = PlenumNode(jid)
+                    jn = MomentumChamberNode(jid)
                     net.add_node(jn)
                     nodes_map[jid] = jn
                 tee_port_node_map[(edge.source, port)] = jid
                 edge_junction_map[(edge.source, edge.target)] = jid
 
         elif src_elem and tgt_tee:
-            # Element → tee port (e.g. channel → tee.straight-target): auto-insert PlenumNode
+            # Element → tee port (e.g. channel → tee.straight-target): auto-insert MomentumChamberNode
             port = _port_from_handle(edge.targetHandle)
             if port and (edge.target, port) not in tee_port_node_map:
                 jid = f"__tee_jct__{edge.target}_{port}"
                 if jid not in nodes_map:
-                    jn = PlenumNode(jid)
+                    jn = MomentumChamberNode(jid)
                     net.add_node(jn)
                     nodes_map[jid] = jn
                 tee_port_node_map[(edge.target, port)] = jid
                 edge_junction_map[(edge.source, edge.target)] = jid
 
+    # Pre-scan: for each edge whose target is a WallNode, the 2nd+ connection
+    # gets its own clone so the solver enforces m_dot=0 per branch individually
+    # (not just sum(m_dot)=0, which allows non-zero flows to cancel).
+    # This covers both regular elements and tee junction port connections.
+    _wall_edge_remap: dict[str, str] = {}  # edge_id -> effective target node_id
+    _wall_target_count: dict[str, int] = {}
+    for _edge in schema.edges:
+        if _edge.data and _edge.data.get("type") == "thermal":
+            continue
+        _tgt = _edge.target
+        if isinstance(nodes_map.get(_tgt), WallNode):
+            _wall_target_count[_tgt] = _wall_target_count.get(_tgt, 0) + 1
+            if _wall_target_count[_tgt] > 1:
+                _n = _wall_target_count[_tgt]
+                _clone_id = f"{_tgt}_w{_n}"
+                _clone = WallNode(_clone_id)
+                net.add_node(_clone)
+                nodes_map[_clone_id] = _clone
+                _wall_edge_remap[_edge.id] = _clone_id
+
     # 2. Second Pass: Create Elements
     for elem_node_schema in element_nodes:
         elem_id = elem_node_schema.id
         elem_data = elem_node_schema.data
         elem_type = elem_node_schema.type
 
-        # 3-port element: bypass the 2-port source/target logic entirely.
-        if elem_type == "tee_junction":
-            _d = TeeJunctionData(**elem_data)
-            _tee = TeeJunctionElement(
-                id=elem_id,
-                common_node=_find_tee_port(
-                    schema.edges, elem_id, "common", nodes_map, tee_port_node_map
-                ),
-                straight_node=_find_tee_port(
-                    schema.edges, elem_id, "straight", nodes_map, tee_port_node_map
-                ),
-                branch_node=_find_tee_port(
-                    schema.edges, elem_id, "branch", nodes_map, tee_port_node_map
-                ),
-                theta=_math.radians(_d.theta_deg),
-                F_C=_d.F_C,
-                psi=_d.psi,
-                tee_type=_d.tee_type,
+        # 3-port element (Mynard-based). The flow_direction field constrains
+        # which side is upstream.
+        if elem_type == "mpce_tee":
+            _md = MPCETeeData(**elem_data)
+            # Resolve areas with inheritance precedence (see _resolve_tee_areas).
+            _F_C, _A_branch, _psi = _resolve_tee_areas(
+                schema.edges,
+                schema.nodes,
+                elem_id,
+                F_C_explicit=_md.F_C,
+                F_branch_explicit=_md.F_branch,
+                psi_fallback=_md.psi,
+            )
+
+            _common = _find_tee_port(
+                schema.edges, elem_id, "common", nodes_map, tee_port_node_map, _wall_edge_remap
             )
-            _tee.initial_guess = _expand_initial_guess(_d.initial_guess, elem_id)
-            if not _tee.initial_guess:
-                _tee.initial_guess = _guess_from_prior_result(elem_data, elem_id)
-            net.add_element(_tee)
+            _straight = _find_tee_port(
+                schema.edges, elem_id, "straight", nodes_map, tee_port_node_map, _wall_edge_remap
+            )
+            _branch = _find_tee_port(
+                schema.edges, elem_id, "branch", nodes_map, tee_port_node_map, _wall_edge_remap
+            )
+
+            # Branch (separating): single inlet at common, two outlets.
+            # Merge (joining): two inlets at straight+branch, single outlet at common.
+            if _md.flow_direction == "branch":
+                _inlets = [_common]
+                _outlets = [_straight, _branch]
+                _inlet_angles = [0.0]
+                _outlet_angles = [0.0, _md.theta_deg]
+                _port_areas = [_F_C, _F_C, _A_branch]
+            else:  # "merge"
+                _inlets = [_straight, _branch]
+                _outlets = [_common]
+                _inlet_angles = [0.0, _md.theta_deg]
+                _outlet_angles = [0.0]
+                _port_areas = [_F_C, _A_branch, _F_C]
+
+            # strict=False: strict mode raises whenever a Newton ITERATE
+            # (not the converged answer) explores a wrong-sign port
+            # m_dot, killing GUI solves that would otherwise converge
+            # ("Unexpected error during residual evaluation"). Soft mode
+            # lets the solver explore; the post-solve
+            # verify_solution_consistent guard in NetworkSolver rejects
+            # any wrong-direction artifact root at convergence.
+            if _md.junction_model == "constant_k":
+                # Simplest-model tier: fixed handbook K per non-common
+                # port, referenced to the common-leg dynamic head. Port
+                # order is inlets first: branch = [common, straight,
+                # branch]; merge = [straight, branch, common].
+                if _md.flow_direction == "branch":
+                    _k_ports = {1: _md.K_straight, 2: _md.K_branch}
+                else:
+                    _k_ports = {0: _md.K_straight, 1: _md.K_branch}
+                _mpce = ConstantKTeeElement(
+                    id=elem_id,
+                    inlet_nodes=_inlets,
+                    outlet_nodes=_outlets,
+                    inlet_angles_deg=_inlet_angles,
+                    outlet_angles_deg=_outlet_angles,
+                    port_areas=_port_areas,
+                    flow_direction=_md.flow_direction,
+                    strict=False,
+                    K_ports=_k_ports,
+                )
+            else:
+                _mpce = MPCEv2Element(
+                    id=elem_id,
+                    inlet_nodes=_inlets,
+                    outlet_nodes=_outlets,
+                    inlet_angles_deg=_inlet_angles,
+                    outlet_angles_deg=_outlet_angles,
+                    port_areas=_port_areas,
+                    flow_direction=_md.flow_direction,
+                    strict=False,
+                    joining_etransfer_alpha=_md.joining_etransfer_alpha,
+                )
+            _mpce.initial_guess = _expand_initial_guess(_md.initial_guess, elem_id)
+            if not _mpce.initial_guess:
+                _mpce.initial_guess = _guess_from_prior_result(elem_data, elem_id)
+            net.add_element(_mpce)
             continue
 
         source_id = None
@@ -473,7 +657,7 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
                 if outgoing_count > 1:
                     raise ValueError(f"Element '{elem_id}' has multiple downstream links.")
                 if edge.target in nodes_map:
-                    target_id = edge.target
+                    target_id = _wall_edge_remap.get(edge.id, edge.target)
                 elif edge.target in element_ids:
                     target_id = edge_junction_map.get((elem_id, edge.target))
 
@@ -482,13 +666,15 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
 
         if elem_type == "channel":
             data = ChannelData(**elem_data)
-            conv_area = 3.1415926535 * data.D * data.L
+            # conv_area is deferred to 0 when D=None; resolve_topology updates it
+            conv_area = (3.1415926535 * data.D * data.L) if data.D is not None else 0.0
             elem = ChannelElement(
                 elem_id,
                 from_node=source_id,
                 to_node=target_id,
                 length=data.L,
                 diameter=data.D,
+                Dh=data.Dh,
                 roughness=data.roughness,
                 friction_model=data.friction_model,
                 surface=ConvectiveSurface(
@@ -548,17 +734,26 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
             net.add_element(elem)
         elif elem_type == "discrete_loss":
             data = DiscreteLossData(**elem_data)
-            # Infer area from upstream node if not explicitly set
-            area = data.area
+            # area=None signals "inherit from upstream element in resolve_topology".
+            # Use a quick node-area lookup only when data.area is explicitly set or
+            # the upstream node exposes a non-zero area (combustor / momentum chamber).
+            area: float | None = data.area
             if area is None and source_id in nodes_map:
-                area = getattr(nodes_map[source_id], "area", 0.1)
-            area = area if area and area > 0 else 0.1
+                node_area = getattr(nodes_map[source_id], "area", None)
+                if node_area and node_area > 0:
+                    area = node_area
             correlation = _build_discrete_loss_correlation(
-                data.correlation_type, data.xi, data.k, data.xi0, data.zeta, data.zeta0, area
+                data.correlation_type,
+                data.xi,
+                data.k,
+                data.xi0,
+                data.zeta,
+                data.zeta0,
+                area if area and area > 0 else 0.1,
             )
             theta_source = data.theta_source if data.theta_source not in (None, "none") else None
             surface = ConvectiveSurface(
-                area=area,
+                area=area if area and area > 0 else 0.0,
                 model=map_surface_model(data.surface),
                 Nu_multiplier=data.Nu_multiplier,
                 f_multiplier=data.f_multiplier,

{combaero_gui-0.3.1.dev2 → combaero_gui-0.4.2}/backend/main.py

@@ -128,7 +128,8 @@ def _solve_sync(schema: NetworkGraphSchema):
         }
 
     node_results, element_results, edge_results = _build_result_objects(result, net)
-    return result, node_results, element_results, edge_results, net
+    diag = getattr(solver, "_diagnostic_data", {})
+    return result, node_results, element_results, edge_results, net, diag
 
 
 @app.post("/solve", response_model=SolveResponse)
@@ -140,7 +141,7 @@ async def solve(schema: NetworkGraphSchema):
     hard_timeout = soft_timeout + 10.0
     try:
         # Offload CPU-bound C++ solver to a worker thread
-        result, node_results, element_results, edge_results, _ = await asyncio.wait_for(
+        result, node_results, element_results, edge_results, _, diag = await asyncio.wait_for(
             asyncio.to_thread(_solve_sync, schema),
             timeout=hard_timeout,
         )
@@ -152,12 +153,17 @@ async def solve(schema: NetworkGraphSchema):
             node_results=node_results,
             element_results=element_results,
             edge_results=edge_results,
+            convergence_history=diag.get("convergence_history", []),
+            worst_residuals=diag.get("worst_residuals", []),
+            solver_settings_used=diag.get("solver_settings_used", {}),
+            lm_started_at_eval=diag.get("lm_started_at_eval"),
         )
     except TimeoutError:
         raise HTTPException(
             status_code=504,
             detail=f"Solver exceeded the hard timeout of {hard_timeout:.0f}s. "
-            "Try a shorter timeout, a simpler network, or the homotopy init strategy.",
+            "Try raising the solver timeout, simplifying the network, or a "
+            "different init strategy.",
         ) from None
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e)) from e

{combaero_gui-0.3.1.dev2 → combaero_gui-0.4.2}/backend/runner.py

@@ -230,8 +230,6 @@ class NetworkResult:
         with all available diagnostic quantities.  Column names carry unit
         annotations matching the GUI export (e.g. ``'P [Pa]'``, ``'T [K]'``).
         """
-        from combaero.network.components import TeeJunctionElement as _TeeJE
-
         _BOUNDARY_KINDS = {"mass_boundary", "pressure_boundary"}
         species_labels: list[str] = list(cb.species.names)
         data: list[dict] = []
@@ -261,22 +259,6 @@ class NetworkResult:
 
         for elem_id, res in self._element_results.items():
             elem_data = res.model_dump()
-            elem_obj = self._net.elements.get(elem_id)
-            if isinstance(elem_obj, _TeeJE):
-                common_res = self._node_results.get(elem_obj.common_node)
-                if common_res:
-                    common_state = common_res.state.model_dump()
-                    Y = common_state.pop("Y", [])
-                    X = common_state.pop("X", None) or []
-                    for k, v in common_state.items():
-                        if v is not None:
-                            elem_data[k] = v
-                    for i, y_val in enumerate(Y):
-                        name = species_labels[i] if i < len(species_labels) else str(i)
-                        elem_data[f"Y[{name}]"] = y_val
-                    for i, x_val in enumerate(X):
-                        name = species_labels[i] if i < len(species_labels) else str(i)
-                        elem_data[f"X[{name}]"] = x_val
             data.append(
                 {
                     "type": "element",

{combaero_gui-0.3.1.dev2 → combaero_gui-0.4.2}/backend/schemas.py

@@ -88,6 +88,12 @@ class PressureBoundaryData(BaseModel):
     label: str | None = None
 
 
+class WallData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    label: str | None = None
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+
+
 class ConstantFractionLossData(BaseModel):
     model_config = ConfigDict(extra="ignore")
     type: Literal["constant_fraction"] = "constant_fraction"
@@ -125,7 +131,7 @@ PressureLossData = (
 class CombustorData(BaseModel):
     model_config = ConfigDict(extra="ignore")
     method: Literal["complete", "equilibrium"] = "complete"
-    area: float = 0.1
+    area: float | None = None  # None = derive from Dh (pi/4 * Dh^2)
     Dh: float | None = None
     surface: SurfaceModelData = Field(default_factory=SmoothModelData)
     Nu_multiplier: float = 1.0
@@ -136,8 +142,8 @@ class CombustorData(BaseModel):
 
 class MomentumChamberData(BaseModel):
     model_config = ConfigDict(extra="ignore")
-    area: float = 0.1
-    Dh: float = 0.1
+    area: float | None = None  # None = derive from Dh (pi/4 * Dh^2)
+    Dh: float | None = None  # None = inherit from upstream channel (Dh = D)
     surface: SurfaceModelData = Field(default_factory=SmoothModelData)
     Nu_multiplier: float = 1.0
     f_multiplier: float = 1.0
@@ -151,7 +157,8 @@ class MomentumChamberData(BaseModel):
 class ChannelData(BaseModel):
     model_config = ConfigDict(extra="ignore")
     L: float = 1.0
-    D: float = 0.1
+    D: float | None = None  # None = inherit from upstream element geometry
+    Dh: float | None = None  # None = circular (Dh = D); override for non-circular ducts
     roughness: float = 1e-5
     friction_model: Literal["haaland", "serghides", "colebrook", "petukhov"] = "haaland"
     surface: SurfaceModelData = Field(default_factory=SmoothModelData)
@@ -164,7 +171,7 @@ class ChannelData(BaseModel):
 
 class OrificeData(BaseModel):
     model_config = ConfigDict(extra="ignore")
-    diameter: float = 0.08
+    diameter: float | None = None  # None = inherit from upstream channel
     Cd: float = 0.6
     correlation: Literal[
         "ReaderHarrisGallagher", "Stolz", "Miller", "ThickPlate", "RoundedEntry", "fixed"
@@ -190,8 +197,8 @@ class OrificeData(BaseModel):
 class AreaChangeData(BaseModel):
     model_config = ConfigDict(extra="ignore")
     model_type: Literal["sharp", "conical"] = "sharp"
-    F0: float = 0.01
-    F1: float = 0.02
+    F0: float | None = None  # None = inherit from upstream channel (A = pi/4*D^2)
+    F1: float | None = None  # None = inherit from downstream channel
     length: float | None = None
     D_h: float = 0.0
     initial_guess: dict[str, float] = Field(default_factory=dict)
@@ -202,13 +209,35 @@ class LosslessConnectionData(BaseModel):
     pass
 
 
-class TeeJunctionData(BaseModel):
+class MPCETeeData(BaseModel):
+    """Mynard-based multi-port chamber tee element with constrained topology.
+
+    3-port junction using Mynard's Unified0D pseudosupplier residual. The
+    ``flow_direction`` field declares whether this junction is a merge
+    (joining flow, 2 inlets + 1 outlet) or a branch (separating flow,
+    1 inlet + 2 outlets); the runtime element raises if the observed
+    flow pattern disagrees.
+    """
+
     model_config = ConfigDict(extra="ignore")
     label: str | None = None
-    tee_type: str = "merging"  # "merging" | "branching"
+    flow_direction: Literal["merge", "branch"] = "branch"
+    # Junction closure model. "mynard" (default) is the full Unified0D
+    # pseudosupplier physics; "constant_k" is the simplest-model tier:
+    # fixed handbook loss coefficients referenced to the common-leg
+    # dynamic head (Idelchik convention), K independent of the split.
+    junction_model: Literal["mynard", "constant_k"] = "mynard"
+    K_straight: float = 0.4  # constant_k only: straight-arm loss coeff [-]
+    K_branch: float = 1.0  # constant_k only: branch-arm loss coeff [-]
     theta_deg: float = 90.0  # branch angle [deg], converted to radians in graph_builder
-    F_C: float = 0.01  # common-arm area [m^2]
-    psi: float = 1.0  # F_C / F_S area ratio
+    F_C: float | None = None  # None = inherit from common/straight-arm channel
+    F_branch: float | None = None  # None = inherit from branch-arm channel
+    psi: float = 1.0  # fallback ratio used only when F_branch is None and not inherited
+    # Joining-side etransfer correction scale (combaero extension to faithful
+    # Mynard). Default 0.2 calibrated against Bassett K11/K12 analytical +
+    # Idelchik 1966 tabulated values. Set to 0.0 to disable the correction
+    # (faithful Mynard); set to a custom value for re-calibrated workflows.
+    joining_etransfer_alpha: float | None = None
     initial_guess: dict[str, float] = Field(default_factory=dict)
 
 
@@ -276,9 +305,14 @@ class ThermalWallData(BaseModel):
 class SolverSettings(BaseModel):
     model_config = ConfigDict(extra="ignore")
     global_regime: Literal["incompressible", "compressible"] = "incompressible"
-    init_strategy: Literal["default", "incompressible_warmstart", "homotopy", "continuation"] = (
-        "default"
-    )
+    init_strategy: Literal[
+        "default",
+        "analytical_pt_prop",
+        "incompressible_warmstart",
+        "outletref_warmstart",
+        "homotopy",
+        "continuation",
+    ] = "default"
     method: Literal[
         "hybr",
         "lm",
@@ -375,6 +409,17 @@ class ElementResult(BaseModel):
     success: bool = True
 
 
+class ConvergencePoint(BaseModel):
+    eval: int
+    t: float
+    norm: float
+
+
+class WorstResidual(BaseModel):
+    name: str
+    residual: float
+
+
 class SolveResponse(BaseModel):
     success: bool
     message: str = ""
@@ -382,3 +427,7 @@ class SolveResponse(BaseModel):
     node_results: dict[str, NodeResult] = {}
     element_results: dict[str, ElementResult] = {}
     edge_results: dict[str, dict] = {}
+    convergence_history: list[ConvergencePoint] = []
+    worst_residuals: list[WorstResidual] = []
+    solver_settings_used: dict = {}
+    lm_started_at_eval: int | None = None

{combaero_gui-0.3.1.dev2 → combaero_gui-0.4.2}/combaero_gui.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: combaero-gui
-Version: 0.3.1.dev2
+Version: 0.4.2
 Summary: CombAero Network GUI — React/FastAPI desktop application
 Author-email: thiemom <2641939+thiemom@users.noreply.github.com>
 License: MIT
@@ -21,7 +21,7 @@ Requires-Dist: fastapi
 Requires-Dist: uvicorn
 Requires-Dist: pydantic
 Requires-Dist: pandas
-Requires-Dist: combaero~=0.3
+Requires-Dist: combaero~=0.4
 Provides-Extra: gui
 
 # CombAero Network Designer GUI