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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: combaero-gui
-Version: 0.2.6
+Version: 0.3.1.dev2
 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.2
+Requires-Dist: combaero~=0.3
 Provides-Extra: gui
 
 # CombAero Network Designer GUI

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

@@ -1,3 +1,5 @@
+import math as _math
+
 from combaero.network import (
     AreaChangeElement,
     ChannelElement,
@@ -20,7 +22,9 @@ from combaero.network import (
     PressureLossElement,
     RibbedModel,
     SmoothModel,
+    TeeJunctionElement,
     ThermalWall,
+    VortexElement,
     WallLayer,
 )
 
@@ -45,7 +49,9 @@ from .schemas import (
     PressureBoundaryData,
     RibbedModelData,
     SmoothModelData,
+    TeeJunctionData,
     ThermalWallData,
+    VortexData,
 )
 
 
@@ -102,7 +108,9 @@ def map_surface_model(data):
     return SmoothModel()
 
 
-def resolve_composition(comp: CompositionData, T: float, P: float) -> list[float]:
+def resolve_composition(
+    comp: CompositionData, T: float, P: float, solver_settings=None
+) -> list[float]:
     """
     Converts UI CompositionData into a mass fraction list (Y)
     using combaero.species utilities.
@@ -112,8 +120,23 @@ def resolve_composition(comp: CompositionData, T: float, P: float) -> list[float
     if comp.source == "dry_air":
         Y = cb.species.dry_air_mass()
     elif comp.source == "humid_air":
-        # humid_air_mass takes ambient T, P, RH
-        Y = cb.species.humid_air_mass(comp.ambient_T, comp.ambient_P, comp.relative_humidity)
+        s = solver_settings
+        ambient_T = (
+            comp.ambient_T
+            if comp.ambient_T is not None
+            else (s.ambient_T if s is not None and s.ambient_T is not None else 288.15)
+        )
+        ambient_P = (
+            comp.ambient_P
+            if comp.ambient_P is not None
+            else (s.ambient_P if s is not None and s.ambient_P is not None else 101325.0)
+        )
+        ambient_RH = (
+            comp.relative_humidity
+            if comp.relative_humidity is not None
+            else (s.ambient_RH if s is not None and s.ambient_RH is not None else 0.6)
+        )
+        Y = cb.species.humid_air_mass(ambient_T, ambient_P, ambient_RH)
     elif comp.source == "fuel":
         # Default fuel to CH4 for now, or use a specific fuel if provided
         Y = cb.species.pure_species("CH4")
@@ -162,6 +185,35 @@ def _expand_initial_guess(short_guess: dict, prefix: str) -> dict:
     return result
 
 
+def _guess_from_prior_result(node_data: dict, prefix: str) -> dict:
+    """Build an initial-guess dict from a prior solve result stored in node_data.
+
+    The GUI frontend writes the last solve result into node_data["result"].
+    When data.initial_guess is empty (no explicit user override), this
+    provides a warm-start from the previously found state so that repeated
+    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).
+    """
+    prior = node_data.get("result")
+    if not prior:
+        return {}
+    short: dict[str, float] = {}
+    state = prior.get("state")
+    if state:
+        if (p := state.get("P")) is not None:
+            short["P"] = float(p)
+        if (t := state.get("T")) is not None:
+            short["T"] = float(t)
+        if (pt := state.get("Pt")) is not None:
+            short["Pt"] = float(pt)
+        if (tt := state.get("Tt")) is not None:
+            short["Tt"] = float(tt)
+    if (m_dot := prior.get("m_dot")) is not None:
+        short["m_dot"] = float(m_dot)
+    return _expand_initial_guess(short, prefix)
+
+
 def _build_discrete_loss_correlation(
     corr_type: str,
     xi: float,
@@ -183,6 +235,61 @@ def _build_discrete_loss_correlation(
     return ConstantFractionLoss(xi=xi)
 
 
+def _port_from_handle(handle: str | None) -> str | None:
+    """Extract port name from a tee handle string.
+
+    'port-common-source' -> 'common', 'port-branch-target' -> 'branch', etc.
+    Returns None for non-tee handles.
+    """
+    if (
+        handle
+        and handle.startswith("port-")
+        and (handle.endswith("-source") or handle.endswith("-target"))
+    ):
+        return handle.split("-")[1]
+    return None
+
+
+def _find_tee_port(
+    edges: list,
+    tee_id: str,
+    port: str,
+    nodes_map: dict,
+    tee_port_node_map: dict | None = None,
+) -> str:
+    """Return the physical-node ID connected to a named tee port.
+
+    Checks both edge directions: tee as source (sourceHandle == port-X-source)
+    and tee as target (targetHandle == port-X-target).
+    Falls back to *tee_port_node_map* for auto-created junction nodes when an
+    element is connected directly to a tee port without an explicit plenum.
+    """
+    src_handle = f"port-{port}-source"
+    tgt_handle = f"port-{port}-target"
+    for edge in edges:
+        if edge.data and edge.data.get("type") == "thermal":
+            continue
+        if edge.source == tee_id and edge.sourceHandle == src_handle:
+            nid = edge.target
+        elif edge.target == tee_id and edge.targetHandle == tgt_handle:
+            nid = edge.source
+        else:
+            continue
+        if nid in nodes_map:
+            return nid
+        if tee_port_node_map and (tee_id, port) in tee_port_node_map:
+            return tee_port_node_map[(tee_id, port)]
+        raise ValueError(
+            f"Tee '{tee_id}' port '{port}' connects to '{nid}', which is not a "
+            "physical node (plenum or boundary). All tee ports must connect directly "
+            "to plena or boundaries."
+        )
+    raise ValueError(
+        f"Tee '{tee_id}' port '{port}' is not connected. "
+        "All three tee ports (common, straight, branch) must be wired to a node."
+    )
+
+
 def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
     net = FlowNetwork()
     nodes_map = {}  # ID -> Physical Node
@@ -199,19 +306,23 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
             data = PlenumData(**node_data)
             node = PlenumNode(node_id)
             node.initial_guess = _expand_initial_guess(data.initial_guess, node_id)
+            if not node.initial_guess:
+                node.initial_guess = _guess_from_prior_result(node_data, node_id)
             net.add_node(node)
             nodes_map[node_id] = node
             plenum_node_ids.add(node_id)
         elif node_type == "mass_boundary":
             data = MassBoundaryData(**node_data)
-            Y = resolve_composition(data.composition, data.Tt, 101325.0)
+            Y = resolve_composition(data.composition, data.Tt, 101325.0, schema.solver_settings)
             node = MassFlowBoundary(node_id, m_dot=data.m_dot, Tt=data.Tt, Y=Y)
             node.initial_guess = _expand_initial_guess(data.initial_guess, node_id)
+            if not node.initial_guess:
+                node.initial_guess = _guess_from_prior_result(node_data, node_id)
             net.add_node(node)
             nodes_map[node_id] = node
         elif node_type == "pressure_boundary":
             data = PressureBoundaryData(**node_data)
-            Y = resolve_composition(data.composition, data.Tt, data.Pt)
+            Y = resolve_composition(data.composition, data.Tt, data.Pt, schema.solver_settings)
             node = PressureBoundary(node_id, Pt=data.Pt, Tt=data.Tt, Y=Y)
             node.initial_guess = _expand_initial_guess(data.initial_guess, node_id)
             net.add_node(node)
@@ -226,11 +337,14 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
                 surface=ConvectiveSurface(
                     area=data.area,
                     model=map_surface_model(data.surface),
-                    Nu_multiplier=data.Nu_multiplier,
-                    f_multiplier=data.f_multiplier,
+                    Nu_multiplier=data.Nu_multiplier
+                    * (schema.solver_settings.Nu_multiplier or 1.0),
+                    f_multiplier=data.f_multiplier * (schema.solver_settings.f_multiplier or 1.0),
                 ),
             )
             node.initial_guess = _expand_initial_guess(data.initial_guess, node_id)
+            if not node.initial_guess:
+                node.initial_guess = _guess_from_prior_result(node_data, node_id)
             net.add_node(node)
             nodes_map[node_id] = node
         elif node_type == "momentum_chamber":
@@ -241,11 +355,14 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
                 surface=ConvectiveSurface(
                     area=data.area,
                     model=map_surface_model(data.surface),
-                    Nu_multiplier=data.Nu_multiplier,
-                    f_multiplier=data.f_multiplier,
+                    Nu_multiplier=data.Nu_multiplier
+                    * (schema.solver_settings.Nu_multiplier or 1.0),
+                    f_multiplier=data.f_multiplier * (schema.solver_settings.f_multiplier or 1.0),
                 ),
             )
             node.initial_guess = _expand_initial_guess(data.initial_guess, node_id)
+            if not node.initial_guess:
+                node.initial_guess = _guess_from_prior_result(node_data, node_id)
             net.add_node(node)
             nodes_map[node_id] = node
         elif node_type == "probe":
@@ -255,13 +372,24 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
             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"}
 
     # 1b. Create implicit junction nodes for element -> element visual links.
+    # For direct element<->element connections we auto-insert a MomentumChamberNode.
+    # For direct element<->tee-port connections we auto-insert a PlenumNode so that
+    # users don't need to manually place a plenum on every tee arm.
     edge_junction_map: dict[tuple[str, str], str] = {}
+    tee_port_node_map: dict[tuple[str, str], str] = {}  # (tee_id, port) -> node_id
     for edge in schema.edges:
         if edge.data and edge.data.get("type") == "thermal":
             continue
-        if edge.source in element_ids and edge.target in element_ids:
+        src_elem = edge.source in element_ids
+        tgt_elem = edge.target in element_ids
+        src_tee = edge.source in tee_ids
+        tgt_tee = edge.target in tee_ids
+
+        if src_elem and tgt_elem and not src_tee and not tgt_tee:
+            # Standard element-to-element: auto-insert MomentumChamberNode
             junction_id = f"__junction__{edge.source}__{edge.target}"
             if junction_id not in nodes_map:
                 junction_node = MomentumChamberNode(junction_id)
@@ -269,10 +397,60 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
                 nodes_map[junction_id] = junction_node
             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
+            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)
+                    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
+            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)
+                    net.add_node(jn)
+                    nodes_map[jid] = jn
+                tee_port_node_map[(edge.target, port)] = jid
+                edge_junction_map[(edge.source, edge.target)] = jid
+
     # 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,
+            )
+            _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)
+            continue
 
         source_id = None
         target_id = None
@@ -302,7 +480,6 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
         if not source_id or not target_id:
             raise ValueError(f"Element '{elem_id}' is not fully connected.")
 
-        elem_type = elem_node_schema.type
         if elem_type == "channel":
             data = ChannelData(**elem_data)
             conv_area = 3.1415926535 * data.D * data.L
@@ -313,11 +490,13 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
                 length=data.L,
                 diameter=data.D,
                 roughness=data.roughness,
+                friction_model=data.friction_model,
                 surface=ConvectiveSurface(
                     area=conv_area,
                     model=map_surface_model(data.surface),
-                    Nu_multiplier=data.Nu_multiplier,
-                    f_multiplier=data.f_multiplier,
+                    Nu_multiplier=data.Nu_multiplier
+                    * (schema.solver_settings.Nu_multiplier or 1.0),
+                    f_multiplier=data.f_multiplier * (schema.solver_settings.f_multiplier or 1.0),
                 ),
             )
             regime = (
@@ -325,6 +504,8 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
             )
             elem.regime = regime
             elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            if not elem.initial_guess:
+                elem.initial_guess = _guess_from_prior_result(elem_data, elem_id)
             net.add_element(elem)
         elif elem_type == "orifice":
             data = OrificeData(**elem_data)
@@ -343,6 +524,8 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
             )
             elem.regime = regime
             elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            if not elem.initial_guess:
+                elem.initial_guess = _guess_from_prior_result(elem_data, elem_id)
             net.add_element(elem)
         elif elem_type == "area_change":
             data = AreaChangeData(**elem_data)
@@ -357,6 +540,8 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
                 D_h=data.D_h,
             )
             elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            if not elem.initial_guess:
+                elem.initial_guess = _guess_from_prior_result(elem_data, elem_id)
             net.add_element(elem)
         elif elem_type == "lossless_connection":
             elem = LosslessConnectionElement(elem_id, from_node=source_id, to_node=target_id)
@@ -388,6 +573,29 @@ def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
                 surface=surface,
             )
             elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            if not elem.initial_guess:
+                elem.initial_guess = _guess_from_prior_result(elem_data, elem_id)
+            net.add_element(elem)
+        elif elem_type == "vortex":
+            data = VortexData(**elem_data)
+            omega = (
+                data.omega_rpm
+                if data.omega_rpm is not None
+                else (schema.solver_settings.omega_rpm or 0.0)
+            )
+            elem = VortexElement(
+                elem_id,
+                from_node=source_id,
+                to_node=target_id,
+                r_c=data.r_c,
+                r_out=data.r_out,
+                r_in=data.r_in,
+                omega_rpm=float(omega),
+                n=data.n,
+            )
+            elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            if not elem.initial_guess:
+                elem.initial_guess = _guess_from_prior_result(elem_data, elem_id)
             net.add_element(elem)
 
     # 3. Third Pass: Auto-connections

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

@@ -11,12 +11,10 @@ import combaero as cb
 from combaero.network import NetworkSolver
 
 from .graph_builder import build_network_from_schema
+from .runner import NetworkResult, _build_result_objects, _schema_maps
 from .schemas import (
-    ElementResult,
     NetworkGraphSchema,
-    NodeResult,
     SolveResponse,
-    StateResult,
 )
 
 _FRONTEND_DIST = Path(__file__).parent.parent / "frontend" / "dist"
@@ -129,62 +127,7 @@ def _solve_sync(schema: NetworkGraphSchema):
             "initial_guesses": {n.id: n.data.get("initial_guess", {}) for n in schema.nodes},
         }
 
-    node_results = {}
-    for node_id in net.nodes:
-        # Pull all node diagnostics and state variables directly from sol_dict
-        # flat keys are like node_id.T, node_id.P, node_id.mach, node_id.rho, etc.
-        prefix = f"{node_id}."
-        node_vals = {k[len(prefix) :]: v for k, v in result.items() if k.startswith(prefix)}
-
-        # Handle composition lists (Y and X)
-        y_vals = []
-        x_vals = []
-        i = 0
-        while f"Y[{i}]" in node_vals:
-            y_vals.append(float(node_vals.pop(f"Y[{i}]")))
-            if f"X[{i}]" in node_vals:
-                x_vals.append(float(node_vals.pop(f"X[{i}]")))
-            i += 1
-
-        state_res = StateResult(
-            T=float(node_vals.pop("T", 300.0)),
-            P=float(node_vals.pop("P", 101325.0)),
-            Pt=node_vals.pop("Pt", None),
-            Tt=node_vals.pop("Tt", None),
-            Y=y_vals,
-            X=x_vals or None,
-            **node_vals,  # All remaining diagnostics (rho, mach, mu, k, etc.)
-        )
-        node_results[node_id] = NodeResult(state=state_res, success=success)
-
-    element_results = {}
-    elem_diags = result.get("__element_diag__", {})
-    for elem_id in net.elements:
-        m_dot = float(result.get(f"{elem_id}.m_dot", 0.0))
-        # Pull element diagnostics from the structured dict aggregated by solve()
-        diag = elem_diags.get(elem_id, {}).copy()
-        diag.pop("m_dot", None)
-        element_results[elem_id] = ElementResult(m_dot=m_dot, success=success, **diag)
-
-    edge_results = {}
-
-    def _safe_float(v):
-        try:
-            if isinstance(v, (list, tuple, dict)):
-                return v
-            return float(v)
-        except (TypeError, ValueError):
-            return v
-
-    for edge_id in net.walls:
-        edge_keys = {
-            k.split(".", 1)[1]: _safe_float(v)
-            for k, v in result.items()
-            if k.startswith(f"{edge_id}.")
-        }
-        if edge_keys:
-            edge_results[edge_id] = edge_keys
-
+    node_results, element_results, edge_results = _build_result_objects(result, net)
     return result, node_results, element_results, edge_results, net
 
 
@@ -228,115 +171,24 @@ async def export_results(schema: NetworkGraphSchema):
     hard_timeout = soft_timeout + 10.0
     try:
         # Solve quickly to get states
-        _, node_results, element_results, edge_results, _ = await asyncio.wait_for(
+        raw, node_results, element_results, edge_results, net = await asyncio.wait_for(
             asyncio.to_thread(_solve_sync, schema),
             timeout=hard_timeout,
         )
 
-        # Convert to DataFrame
-        import pandas as pd
-
-        # Build unified id_to_label map from nodes, edges, and auto-links
-        id_to_label = {}
-        # Map each schema node/edge id to its declared ``type`` so the CSV can
-        # preserve specific-kind information (plenum vs combustor vs
-        # discrete_loss, …) needed for later round-trips or sweep workflows.
-        id_to_kind: dict[str, str] = {}
-        for n in schema.nodes:
-            id_to_label[n.id] = n.data.get("label") or ""
-            id_to_kind[n.id] = n.type
-        for e in schema.edges:
-            lbl = (e.data or {}).get("label") or ""
-            id_to_label[e.id] = lbl
-            id_to_kind[e.id] = (e.data or {}).get("type") or "flow"
-            # Also map solver auto-link IDs
-            auto_id = f"__auto_link__{e.source}__{e.target}"
-            id_to_label[auto_id] = lbl
-            id_to_kind[auto_id] = "lossless_connection"
-
-        _BOUNDARY_KINDS = {"mass_boundary", "pressure_boundary"}
-
-        # Per-node combustion method (empty string for non-combustor rows).
-        id_to_method: dict[str, str] = {}
-        for n in schema.nodes:
-            if n.type == "combustor":
-                id_to_method[n.id] = n.data.get("method", "complete")
-
-        # Species labels for composition column headers (``Y[N2]`` not ``Y[0]``).
-        import combaero as cb
-
-        species_labels: list[str] = list(cb.species.names)
-
-        data = []
-
-        # 1. Process Nodes
-        for node_id, res in node_results.items():
-            # Include all fields from StateResult (rho, mach, k, etc.)
-            state_data = res.state.model_dump()
-            # Handle Y/X list expansion
-            Y = state_data.pop("Y", [])
-            X = state_data.pop("X", None)
-
-            kind = id_to_kind.get(node_id, "")
-            base_data = {
-                "type": "node",
-                "kind": kind,
-                "is_boundary": kind in _BOUNDARY_KINDS,
-                "combustion_method": id_to_method.get(node_id, ""),
-                "id": node_id,
-                "label": id_to_label.get(node_id, ""),
-                **state_data,
-            }
-            # Flatten species fractions with species-name indexing.
-            for i, y_val in enumerate(Y):
-                name = species_labels[i] if i < len(species_labels) else str(i)
-                base_data[f"Y[{name}]"] = y_val
-            if X:
-                for i, x_val in enumerate(X):
-                    name = species_labels[i] if i < len(species_labels) else str(i)
-                    base_data[f"X[{name}]"] = x_val
-
-            data.append(base_data)
-
-        # 2. Process Flow Elements
-        for elem_id, res in element_results.items():
-            # Include all analytic/diagnostic fields (Re, Nu, h, q_dot, f, etc.)
-            elem_data = res.model_dump()
-            data.append(
-                {
-                    "type": "element",
-                    "kind": id_to_kind.get(elem_id, ""),
-                    "is_boundary": False,
-                    "combustion_method": "",
-                    "id": elem_id,
-                    "label": id_to_label.get(elem_id, ""),
-                    **elem_data,
-                }
-            )
-
-        # 3. Process Thermal Walls (edge_results)
-        for wall_id, res in edge_results.items():
-            # thermal wall results are already a dict from _solve_sync
-            data.append(
-                {
-                    "type": "thermal_wall",
-                    "kind": "thermal_wall",
-                    "is_boundary": False,
-                    "combustion_method": "",
-                    "id": wall_id,
-                    "label": id_to_label.get(wall_id, ""),
-                    **res,
-                }
-            )
-
-        df = pd.DataFrame(data)
-
-        # Rename columns with unit annotations (e.g. ``P`` -> ``P [Pa]``).
-        # Meta columns (``id``, ``type``, ``kind``, ``is_boundary``, ...) are
-        # passed through unchanged; unknown columns also remain untouched.
-        from gui.backend.units import label_with_unit
-
-        df = df.rename(columns={col: label_with_unit(col) for col in df.columns})
+        id_to_label, id_to_kind, id_to_method = _schema_maps(schema)
+        result_obj = NetworkResult(
+            raw=raw,
+            node_results=node_results,
+            element_results=element_results,
+            edge_results=edge_results,
+            net=net,
+            schema=schema,
+            id_to_label=id_to_label,
+            id_to_kind=id_to_kind,
+            id_to_method=id_to_method,
+        )
+        df = result_obj.to_dataframe()
 
         # Stream as CSV
         stream = io.StringIO()