combaero-gui 0.2.0__py3-none-any.whl

combaero_gui-0.2.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: combaero-gui
+Version: 0.2.0
+Summary: CombAero Network GUI — React/FastAPI desktop application
+Author-email: thiemom <2641939+thiemom@users.noreply.github.com>
+License: MIT
+Project-URL: Homepage, https://github.com/thiemom/combaero
+Project-URL: Repository, https://github.com/thiemom/combaero
+Project-URL: Bug Tracker, https://github.com/thiemom/combaero/issues
+Project-URL: Changelog, https://github.com/thiemom/combaero/blob/main/CHANGELOG.md
+Keywords: aerodynamics,combustion,aerothermal,propulsion,gui,network
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: pydantic
+Requires-Dist: pandas
+Requires-Dist: combaero~=0.2
+
+# CombAero Network Designer GUI
+
+**Interactive design and diagnostic environment for fluid-thermal networks.**
+
+The CombAero GUI allows for rapid construction of complex aerospace networks using a drag-and-drop interface powered by React Flow and a high-performance C++ backend.
+
+## Quick Start
+
+### 1. Environment Setup
+Ensure the GUI components are installed:
+```bash
+uv pip install -e ".[gui]"
+```
+
+### 2. Launch
+The GUI can be launched with a single command:
+```bash
+combaero-gui
+```
+This starts both the FastAPI backend and the Vite-based frontend.
+
+## Key Workflows
+
+- **Build**: Drag nodes (Plenums, Boundaries) and elements (Orifices, Channels) from the sidebar.
+- **Connect**: Click and drag from node handles to element ports.
+- **Solve**: Click the **Solve** button in the header. Successful solves turn node borders green.
+- **Inspect**: Click on any node or element to view real-time diagnostics in the Inspector sidebar.
+
+---
+
+## Agent Reference (UI Automation Map)
+
+For agents with screen control (multimodal LLMs), the following selectors and IDs are provided to assist in navigation:
+
+| UI Component | Selector / ID | Description |
+| :--- | :--- | :--- |
+| **Solve Button** | `#solve-btn` | Triggers the network solve. |
+| **Inspector Sidebar** | `.inspector-panel` | Properties for selected node/element. |
+| **Network Canvas** | `#rf-canvas` | The main React Flow workspace. |
+| **Node (General)** | `.react-flow__node` | Any node on the canvas. |
+| **Solved Indicator** | `.solved-status-ok` | Appears on nodes after a successful solve. |
+| **Error Console** | `#error-output` | Displays solver convergence failures. |
+
+> [!TIP]
+> **Automation Hint**: To add a node via script, use the `gui.backend` API or generate a network JSON and load it via `File -> Import`.
+
+## Technical Reference
+For internal data structures and JSON schemas, see [docs/GUI_TECHNICAL.md](../docs/GUI_TECHNICAL.md).

combaero_gui-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gui/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gui/backend/graph_builder.py,sha256=4HpY5dQFkeBDVRzR1AU9A27e4-YfSqcimvPNWhkRsOE,16815
+gui/backend/main.py,sha256=sv4YBiMDM8UC2xwaUUJzNCjzj5aQlEzYbvvpoNcv1gQ,12681
+gui/backend/schemas.py,sha256=KWtaAkEukLLQAzK-3SFUwwHL-rnqNqinfTktrqz6PjQ,9577
+gui/backend/units.py,sha256=TiUR93ffHE_YlnNhjaIVxH8VhiXQny3cqVRIw-fxuF8,3318
+combaero_gui-0.2.0.dist-info/METADATA,sha256=awJV4DNleCPvr_UKNw0w0wFb-zVGtXQRFC_R7N0y6k8,2938
+combaero_gui-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+combaero_gui-0.2.0.dist-info/entry_points.txt,sha256=LpbuqFqQX0xAVvATI-7bH0DLyp1A77d2cupUJPUzNMs,61
+combaero_gui-0.2.0.dist-info/top_level.txt,sha256=3YomgRPcdOHZ7RJGM04iRwXaP3X7OdcEO_G3JfYoHio,4
+combaero_gui-0.2.0.dist-info/RECORD,,

combaero_gui-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

combaero_gui-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+combaero-gui = gui.backend.main:run_server

combaero_gui-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gui

gui/backend/graph_builder.py

@@ -0,0 +1,443 @@
+from combaero.network import (
+    AreaChangeElement,
+    ChannelElement,
+    CombustorNode,
+    ConstantFractionLoss,
+    ConstantHeadLoss,
+    ConvectiveSurface,
+    DimpledModel,
+    FlowNetwork,
+    ImpingementModel,
+    LinearThetaFractionLoss,
+    LinearThetaHeadLoss,
+    LosslessConnectionElement,
+    MassFlowBoundary,
+    MomentumChamberNode,
+    OrificeElement,
+    PinFinModel,
+    PlenumNode,
+    PressureBoundary,
+    PressureLossElement,
+    RibbedModel,
+    SmoothModel,
+    ThermalWall,
+    WallLayer,
+)
+
+from .schemas import (
+    AreaChangeData,
+    ChannelData,
+    CombustorData,
+    CompositionData,
+    ConstantFractionLossData,
+    ConstantHeadLossData,
+    DimpledModelData,
+    DiscreteLossData,
+    ImpingementModelData,
+    LinearThetaFractionLossData,
+    LinearThetaHeadLossData,
+    MassBoundaryData,
+    MomentumChamberData,
+    NetworkGraphSchema,
+    OrificeData,
+    PinFinModelData,
+    PlenumData,
+    PressureBoundaryData,
+    RibbedModelData,
+    SmoothModelData,
+    ThermalWallData,
+)
+
+
+def build_pressure_loss(data, area: float = 0.1):
+    """Converts PressureLossData schema to a pressure-loss callable."""
+    if data is None:
+        return None
+    t = getattr(data, "type", None)
+    if isinstance(data, ConstantFractionLossData) or t == "constant_fraction":
+        return ConstantFractionLoss(xi=data.xi)
+    if isinstance(data, LinearThetaFractionLossData) or t == "linear_theta_fraction":
+        return LinearThetaFractionLoss(k=data.k, xi0=data.xi0)
+    if isinstance(data, ConstantHeadLossData) or t == "constant_head":
+        return ConstantHeadLoss(zeta=data.zeta, area=area)
+    if isinstance(data, LinearThetaHeadLossData) or t == "linear_theta_head":
+        return LinearThetaHeadLoss(k=data.k, zeta0=data.zeta0, area=area)
+    return None
+
+
+def map_surface_model(data):
+    """Maps UI SurfaceModelData to combaero.network models."""
+    if isinstance(data, SmoothModelData) or data.type == "smooth":
+        return SmoothModel()
+    elif isinstance(data, RibbedModelData) or data.type == "ribbed":
+        return RibbedModel(
+            e_D=data.e_D,
+            pitch_to_height=data.pitch_to_height,
+            alpha_deg=data.alpha_deg,
+        )
+    elif isinstance(data, DimpledModelData) or data.type == "dimpled":
+        return DimpledModel(
+            d_Dh=data.d_Dh,
+            h_d=data.h_d,
+            S_d=data.S_d,
+        )
+    elif isinstance(data, PinFinModelData) or data.type == "pin_fin":
+        return PinFinModel(
+            pin_diameter=data.pin_diameter,
+            channel_height=data.channel_height,
+            S_D=data.S_D,
+            X_D=data.X_D,
+            N_rows=data.N_rows,
+            is_staggered=data.is_staggered,
+        )
+    elif isinstance(data, ImpingementModelData) or data.type == "impingement":
+        return ImpingementModel(
+            d_jet=data.d_jet,
+            z_D=data.z_D,
+            x_D=data.x_D,
+            y_D=data.y_D,
+            A_target=data.A_target,
+            Cd_jet=data.Cd_jet,
+        )
+    return SmoothModel()
+
+
+def resolve_composition(comp: CompositionData, T: float, P: float) -> list[float]:
+    """
+    Converts UI CompositionData into a mass fraction list (Y)
+    using combaero.species utilities.
+    """
+    import combaero as cb
+
+    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)
+    elif comp.source == "fuel":
+        # Default fuel to CH4 for now, or use a specific fuel if provided
+        Y = cb.species.pure_species("CH4")
+        Y = cb.species.to_mass(Y)
+    elif comp.source == "custom" and comp.custom_fractions:
+        vec = cb.species.from_mapping(comp.custom_fractions)
+        Y = cb.species.to_mass(vec) if comp.mode == "mole" else vec
+    else:
+        Y = cb.species.dry_air_mass()
+
+    return [float(y) for y in Y]
+
+
+def _expand_initial_guess(short_guess: dict, prefix: str) -> dict:
+    """Translate short GUI guess keys (``P``, ``T``, ``m_dot``) into the fully
+    qualified solver unknown names (e.g. ``"plenum1.P"``). ``P`` and ``T`` are
+    broadcast to both static and total variants because the solver exposes
+    them as separate unknowns on some node types; the solver silently ignores
+    entries that do not correspond to an actual unknown.
+    Any key already containing a ``.`` is passed through unchanged so that
+    hand-authored qualified guesses still work. Explicit short keys
+    (e.g. ``Pt``) take precedence over broadcast values from ``P``/``T``.
+    """
+    if not short_guess:
+        return {}
+    result: dict = {}
+    # Pass 1 — broadcast P and T to both static and total variants.
+    for key, val in short_guess.items():
+        if "." in key:
+            continue
+        if key == "P":
+            result[f"{prefix}.P"] = val
+            result[f"{prefix}.Pt"] = val
+        elif key == "T":
+            result[f"{prefix}.T"] = val
+            result[f"{prefix}.Tt"] = val
+    # Pass 2 — explicit short keys (Pt, Tt, m_dot, X[i], etc.)
+    # are applied after the broadcast so they win on conflict.
+    for key, val in short_guess.items():
+        if "." in key:
+            result[key] = val
+            continue
+        if key in ("P", "T"):
+            continue  # already handled in pass 1
+        result[f"{prefix}.{key}"] = val
+    return result
+
+
+def _build_discrete_loss_correlation(
+    corr_type: str,
+    xi: float,
+    k: float,
+    xi0: float,
+    zeta: float,
+    zeta0: float,
+    area: float,
+):
+    """Build a pressure loss correlation object from discrete loss params."""
+    if corr_type == "constant_fraction":
+        return ConstantFractionLoss(xi=xi)
+    if corr_type == "linear_theta_fraction":
+        return LinearThetaFractionLoss(k=k, xi0=xi0)
+    if corr_type == "constant_head":
+        return ConstantHeadLoss(zeta=zeta, area=area)
+    if corr_type == "linear_theta_head":
+        return LinearThetaHeadLoss(k=k, zeta0=zeta0, area=area)
+    return ConstantFractionLoss(xi=xi)
+
+
+def build_network_from_schema(schema: NetworkGraphSchema) -> FlowNetwork:
+    net = FlowNetwork()
+    nodes_map = {}  # ID -> Physical Node
+    plenum_node_ids: set[str] = set()
+    element_nodes = []  # List of node schemas that are actually elements
+
+    # 1. First Pass: Create Physical Nodes
+    for node_schema in schema.nodes:
+        node_id = node_schema.id
+        node_data = node_schema.data
+        node_type = node_schema.type
+
+        if node_type == "plenum":
+            data = PlenumData(**node_data)
+            node = PlenumNode(node_id)
+            node.initial_guess = _expand_initial_guess(data.initial_guess, 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)
+            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)
+            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)
+            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)
+            nodes_map[node_id] = node
+        elif node_type == "combustor":
+            data = CombustorData(**node_data)
+            node = CombustorNode(
+                node_id,
+                method=data.method,
+                area=data.area,
+                Dh=data.Dh,
+                surface=ConvectiveSurface(
+                    area=data.area,
+                    model=map_surface_model(data.surface),
+                    Nu_multiplier=data.Nu_multiplier,
+                    f_multiplier=data.f_multiplier,
+                ),
+            )
+            node.initial_guess = _expand_initial_guess(data.initial_guess, node_id)
+            net.add_node(node)
+            nodes_map[node_id] = node
+        elif node_type == "momentum_chamber":
+            data = MomentumChamberData(**node_data)
+            node = MomentumChamberNode(
+                node_id,
+                area=data.area,
+                surface=ConvectiveSurface(
+                    area=data.area,
+                    model=map_surface_model(data.surface),
+                    Nu_multiplier=data.Nu_multiplier,
+                    f_multiplier=data.f_multiplier,
+                ),
+            )
+            node.initial_guess = _expand_initial_guess(data.initial_guess, node_id)
+            net.add_node(node)
+            nodes_map[node_id] = node
+        elif node_type == "probe":
+            pass  # Display-only diagnostic nodes -- not part of the solver graph
+        else:
+            # This is an element node (Channel, Orifice, etc.)
+            element_nodes.append(node_schema)
+
+    element_ids = {node.id for node in element_nodes}
+
+    # 1b. Create implicit junction nodes for element -> element visual links.
+    edge_junction_map: dict[tuple[str, str], str] = {}
+    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:
+            junction_id = f"__junction__{edge.source}__{edge.target}"
+            if junction_id not in nodes_map:
+                junction_node = MomentumChamberNode(junction_id)
+                net.add_node(junction_node)
+                nodes_map[junction_id] = junction_node
+            edge_junction_map[(edge.source, edge.target)] = junction_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
+
+        source_id = None
+        target_id = None
+        incoming_count = 0
+        outgoing_count = 0
+
+        for edge in schema.edges:
+            if edge.data and edge.data.get("type") == "thermal":
+                continue
+            if edge.target == elem_id:
+                incoming_count += 1
+                if incoming_count > 1:
+                    raise ValueError(f"Element '{elem_id}' has multiple upstream links.")
+                if edge.source in nodes_map:
+                    source_id = edge.source
+                elif edge.source in element_ids:
+                    source_id = edge_junction_map.get((edge.source, elem_id))
+            if edge.source == elem_id:
+                outgoing_count += 1
+                if outgoing_count > 1:
+                    raise ValueError(f"Element '{elem_id}' has multiple downstream links.")
+                if edge.target in nodes_map:
+                    target_id = edge.target
+                elif edge.target in element_ids:
+                    target_id = edge_junction_map.get((elem_id, edge.target))
+
+        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
+            elem = ChannelElement(
+                elem_id,
+                from_node=source_id,
+                to_node=target_id,
+                length=data.L,
+                diameter=data.D,
+                roughness=data.roughness,
+                surface=ConvectiveSurface(
+                    area=conv_area,
+                    model=map_surface_model(data.surface),
+                    Nu_multiplier=data.Nu_multiplier,
+                    f_multiplier=data.f_multiplier,
+                ),
+            )
+            regime = (
+                data.regime if data.regime != "default" else schema.solver_settings.global_regime
+            )
+            elem.regime = regime
+            elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            net.add_element(elem)
+        elif elem_type == "orifice":
+            data = OrificeData(**elem_data)
+            elem = OrificeElement(
+                elem_id,
+                from_node=source_id,
+                to_node=target_id,
+                diameter=data.diameter,
+                Cd=data.Cd,
+                correlation=data.correlation,
+                plate_thickness=data.plate_thickness,
+                edge_radius=data.edge_radius,
+            )
+            regime = (
+                data.regime if data.regime != "default" else schema.solver_settings.global_regime
+            )
+            elem.regime = regime
+            elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            net.add_element(elem)
+        elif elem_type == "area_change":
+            data = AreaChangeData(**elem_data)
+            elem = AreaChangeElement(
+                id=elem_id,
+                from_node=source_id,
+                to_node=target_id,
+                F0=data.F0,
+                F1=data.F1,
+                model_type=data.model_type,
+                length=data.length,
+                D_h=data.D_h,
+            )
+            elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            net.add_element(elem)
+        elif elem_type == "lossless_connection":
+            elem = LosslessConnectionElement(elem_id, from_node=source_id, to_node=target_id)
+            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
+            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
+            correlation = _build_discrete_loss_correlation(
+                data.correlation_type, data.xi, data.k, data.xi0, data.zeta, data.zeta0, area
+            )
+            theta_source = data.theta_source if data.theta_source not in (None, "none") else None
+            surface = ConvectiveSurface(
+                area=area,
+                model=map_surface_model(data.surface),
+                Nu_multiplier=data.Nu_multiplier,
+                f_multiplier=data.f_multiplier,
+            )
+            elem = PressureLossElement(
+                elem_id,
+                from_node=source_id,
+                to_node=target_id,
+                correlation=correlation,
+                theta_source=theta_source,
+                area=area,
+                surface=surface,
+            )
+            elem.initial_guess = _expand_initial_guess(data.initial_guess, elem_id)
+            net.add_element(elem)
+
+    # 3. Third Pass: Auto-connections
+    for edge in schema.edges:
+        if (
+            edge.source in nodes_map
+            and edge.target in nodes_map
+            and not (edge.data or {}).get("type")
+        ):
+            auto_id = f"__auto_link__{edge.source}__{edge.target}"
+            if auto_id not in net.elements:
+                elem = LosslessConnectionElement(
+                    auto_id, from_node=edge.source, to_node=edge.target
+                )
+                net.add_element(elem)
+
+    # 4. Fourth Pass: Thermal Walls
+    for edge in schema.edges:
+        if edge.data and edge.data.get("type") == "thermal":
+            if edge.source in plenum_node_ids or edge.target in plenum_node_ids:
+                continue
+            wall_id = edge.id
+            data = ThermalWallData(**edge.data)
+
+            # Build layers list
+            layers = []
+            if data.layers:
+                # New multi-layer format
+                layers = [
+                    WallLayer(
+                        thickness=L.thickness, conductivity=L.conductivity, material=L.material
+                    )
+                    for L in data.layers
+                ]
+            else:
+                # Legacy scalar format
+                t = data.thickness if data.thickness is not None else 0.003
+                k = data.conductivity if data.conductivity is not None else 20.0
+                layers = [WallLayer(thickness=t, conductivity=k)]
+
+            net.add_wall(
+                ThermalWall(
+                    id=wall_id,
+                    element_a=edge.source,
+                    element_b=edge.target,
+                    layers=layers,
+                    contact_area=data.area,
+                    R_fouling=data.R_fouling,
+                )
+            )
+            net.thermal_coupling_enabled = True
+
+    return net

gui/backend/main.py

@@ -0,0 +1,359 @@
+import asyncio
+import io
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+
+import combaero as cb
+from combaero.network import NetworkSolver
+
+from .graph_builder import build_network_from_schema
+from .schemas import (
+    ElementResult,
+    NetworkGraphSchema,
+    NodeResult,
+    SolveResponse,
+    StateResult,
+)
+
+app = FastAPI(title="CombAero Network GUI API")
+
+# Configure CORS for local development (Vite typically runs on 5173)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173", "http://127.0.0.1:5173"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+async def root():
+    return {
+        "message": "CombAero Network GUI API is running",
+        "docs": "/docs",
+        "health": "/health",
+        "metadata": ["/metadata/species", "/metadata/presets", "/metadata/materials"],
+    }
+
+
+@app.get("/metadata/species")
+async def get_species():
+    """Returns available species metadata from the C++ core."""
+
+    return {
+        "names": cb.species.names,
+        "molar_masses": cb.species._default_locator.molar_masses.tolist(),
+    }
+
+
+@app.get("/metadata/presets")
+async def get_presets():
+    """Returns available composition presets."""
+    return {
+        "sources": ["dry_air", "humid_air", "fuel", "custom"],
+        "modes": ["mole", "mass"],
+    }
+
+
+@app.get("/metadata/materials")
+async def get_materials():
+    """Returns available wall materials from the database."""
+    return {
+        "names": cb.list_materials(),
+    }
+
+
+# Module-level persistence for warm-starting the solver across requests.
+_continuation_state: dict | None = None
+
+
+def _solve_sync(schema: NetworkGraphSchema):
+    """
+    Synchronous helper to build and solve the network.
+    Runs in a separate thread to avoid blocking the FastAPI event loop.
+    """
+    global _continuation_state
+    net = build_network_from_schema(schema)
+    solver = NetworkSolver(net)
+    x0 = None
+    if schema.solver_settings.init_strategy == "continuation" and _continuation_state:
+        # Check topology fingerprint
+        solver._build_x0()
+        if _continuation_state["unknown_names"] != list(solver.unknown_names):
+            raise ValueError(
+                "Topology mismatch: the current network unknowns do not match "
+                "the saved continuation state. Please run a 'Default' solve first."
+            )
+
+        # Safety Reset: Check if initial guesses have changed
+        current_guesses = {n.id: n.data.get("initial_guess", {}) for n in schema.nodes}
+        if _continuation_state.get("initial_guesses") != current_guesses:
+            raise ValueError(
+                "Initial guess mismatch: user overrides have changed since the last solve. "
+                "Please run a 'Default' solve to incorporate these changes."
+            )
+
+        x0 = _continuation_state["x"]
+
+    result = solver.solve(
+        method=schema.solver_settings.method,
+        init_strategy=schema.solver_settings.init_strategy,
+        timeout=schema.solver_settings.timeout,
+        x0=x0,
+    )
+    success = bool(result.get("__success__", False))
+
+    if success:
+        _continuation_state = {
+            "x": result["__x_solution__"],
+            "unknown_names": result["__unknown_names__"],
+            "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
+
+    return result, node_results, element_results, edge_results, net
+
+
+@app.post("/solve", response_model=SolveResponse)
+async def solve(schema: NetworkGraphSchema):
+    # Hard async-level deadline: even if a single C++ Fanno/RK4 step blocks,
+    # the event loop stays alive for health checks and subsequent requests.
+    # Add a 10 s buffer on top of the solver's own soft timeout.
+    soft_timeout = schema.solver_settings.timeout or 180.0
+    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(
+            asyncio.to_thread(_solve_sync, schema),
+            timeout=hard_timeout,
+        )
+
+        return SolveResponse(
+            success=result.get("__success__", False),
+            message=result.get("__message__", "Solve completed"),
+            final_norm=result.get("__final_norm__"),
+            node_results=node_results,
+            element_results=element_results,
+            edge_results=edge_results,
+        )
+    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.",
+        ) from None
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+@app.post("/export")
+async def export_results(schema: NetworkGraphSchema):
+    soft_timeout = schema.solver_settings.timeout or 180.0
+    hard_timeout = soft_timeout + 10.0
+    try:
+        # Solve quickly to get states
+        _, node_results, element_results, edge_results, _ = 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})
+
+        # Stream as CSV
+        stream = io.StringIO()
+        df.to_csv(stream, index=False)
+
+        return StreamingResponse(
+            iter([stream.getvalue()]),
+            media_type="text/csv",
+            headers={"Content-Disposition": "attachment; filename=combaero_results.csv"},
+        )
+    except TimeoutError:
+        raise HTTPException(
+            status_code=504,
+            detail=f"Export solve exceeded the hard timeout of {hard_timeout:.0f}s.",
+        ) from None
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+@app.get("/solver/continuation_available")
+async def get_continuation_available():
+    """Returns whether a converged state exists for continuation."""
+    return {"available": _continuation_state is not None}
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+def run_server(host: str = "127.0.0.1", port: int = 8000) -> None:
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)

gui/backend/schemas.py

@@ -0,0 +1,340 @@
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class SmoothModelData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["smooth"] = "smooth"
+
+
+class RibbedModelData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["ribbed"] = "ribbed"
+    e_D: float = 0.05
+    pitch_to_height: float = 10.0
+    alpha_deg: float = 90.0
+
+
+class DimpledModelData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["dimpled"] = "dimpled"
+    d_Dh: float = 0.2
+    h_d: float = 0.15
+    S_d: float = 2.0
+
+
+class PinFinModelData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["pin_fin"] = "pin_fin"
+    pin_diameter: float = 0.005
+    channel_height: float = 0.01  # [m]
+    S_D: float = 2.5
+    X_D: float = 2.5
+    N_rows: int = 10
+    is_staggered: bool = True
+
+
+class ImpingementModelData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["impingement"] = "impingement"
+    d_jet: float = 0.002
+    z_D: float = 4.0
+    x_D: float = 6.0
+    y_D: float = 6.0
+    A_target: float = 0.01
+    Cd_jet: float = 0.8
+
+
+SurfaceModelData = (
+    SmoothModelData | RibbedModelData | DimpledModelData | PinFinModelData | ImpingementModelData
+)
+
+
+# --- Node Data Definitions ---
+
+
+class PlenumData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+    label: str | None = None
+
+
+class CompositionData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    mode: Literal["mole", "mass"] = "mole"
+    source: Literal["dry_air", "humid_air", "fuel", "custom"] = "dry_air"
+    custom_fractions: dict[str, float] | None = None
+    relative_humidity: float = 0.6  # [0-1] for humid_air
+    ambient_T: float = 288.15
+    ambient_P: float = 101325.0
+
+
+class MassBoundaryData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    m_dot: float = 1.0
+    Tt: float = 300.0
+    composition: CompositionData = Field(default_factory=CompositionData)
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+    label: str | None = None
+
+
+class PressureBoundaryData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    Pt: float = 101325.0
+    Tt: float = 300.0
+    composition: CompositionData = Field(default_factory=CompositionData)
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+    label: str | None = None
+
+
+class ConstantFractionLossData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["constant_fraction"] = "constant_fraction"
+    xi: float = 0.03
+
+
+class LinearThetaFractionLossData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["linear_theta_fraction"] = "linear_theta_fraction"
+    k: float = 0.5
+    xi0: float = 0.02
+
+
+class ConstantHeadLossData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["constant_head"] = "constant_head"
+    zeta: float = 5.0
+
+
+class LinearThetaHeadLossData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["linear_theta_head"] = "linear_theta_head"
+    k: float = 1.0
+    zeta0: float = 3.0
+
+
+PressureLossData = (
+    ConstantFractionLossData
+    | LinearThetaFractionLossData
+    | ConstantHeadLossData
+    | LinearThetaHeadLossData
+)
+
+
+class CombustorData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    method: Literal["complete", "equilibrium"] = "complete"
+    area: float = 0.1
+    Dh: float | None = None
+    surface: SurfaceModelData = Field(default_factory=SmoothModelData)
+    Nu_multiplier: float = 1.0
+    f_multiplier: float = 1.0
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+    label: str | None = None
+
+
+class MomentumChamberData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    area: float = 0.1
+    Dh: float = 0.1
+    surface: SurfaceModelData = Field(default_factory=SmoothModelData)
+    Nu_multiplier: float = 1.0
+    f_multiplier: float = 1.0
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+    label: str | None = None
+
+
+# --- Element Data Definitions ---
+
+
+class ChannelData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    L: float = 1.0
+    D: float = 0.1
+    roughness: float = 1e-5
+    surface: SurfaceModelData = Field(default_factory=SmoothModelData)
+    Nu_multiplier: float = 1.0
+    f_multiplier: float = 1.0
+    regime: Literal["default", "incompressible", "compressible"] = "default"
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+    label: str | None = None
+
+
+class OrificeData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    diameter: float = 0.08
+    Cd: float = 0.6
+    correlation: Literal[
+        "ReaderHarrisGallagher", "Stolz", "Miller", "ThickPlate", "RoundedEntry", "fixed"
+    ] = "ReaderHarrisGallagher"
+    plate_thickness: float = 0.0  # t [m]
+    edge_radius: float = 0.0  # r [m]
+    regime: Literal["default", "incompressible", "compressible"] = "default"
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+    label: str | None = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def migrate_area_to_diameter(cls, data: dict) -> dict:
+        if isinstance(data, dict) and "area" in data and "diameter" not in data:
+            import math
+
+            area_val = data.pop("area")
+            if area_val > 0:
+                data["diameter"] = math.sqrt(4.0 * area_val / math.pi)
+        return data
+
+
+class AreaChangeData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    model_type: Literal["sharp", "conical"] = "sharp"
+    F0: float = 0.01
+    F1: float = 0.02
+    length: float | None = None
+    D_h: float = 0.0
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+    label: str | None = None
+
+
+class LosslessConnectionData(BaseModel):
+    pass
+
+
+class DiscreteLossData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    correlation_type: Literal[
+        "constant_fraction", "constant_head", "linear_theta_fraction", "linear_theta_head"
+    ] = "constant_fraction"
+    xi: float = 0.03
+    k: float = 0.001
+    xi0: float = 0.02
+    zeta: float = 1.0
+    zeta0: float = 1.0
+    area: float | None = None
+    theta_source: str | None = None
+    surface: SurfaceModelData = Field(default_factory=SmoothModelData)
+    Nu_multiplier: float = 1.0
+    f_multiplier: float = 1.0
+    label: str | None = None
+    initial_guess: dict[str, float] = Field(default_factory=dict)
+
+
+class WallLayerData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    thickness: float = 0.003
+    conductivity: float = 20.0
+    material: str = "generic"
+
+
+class ThermalWallData(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["thermal"] = "thermal"
+    # Support both single-layer (legacy) and multi-layer
+    thickness: float | None = None
+    conductivity: float | None = None
+    layers: list[WallLayerData] | None = None
+    area: float | None = 0.05
+    R_fouling: float = 0.0
+
+    @model_validator(mode="before")
+    @classmethod
+    def migrate_legacy_fields(cls, data: dict) -> dict:
+        if isinstance(data, dict) and ("layers" not in data or data["layers"] is None):
+            # If we have legacy fields but no layers, migrate them
+            t = data.get("thickness", 0.003)
+            k = data.get("conductivity", 20.0)
+            # Ensure they are not None
+            t = t if t is not None else 0.003
+            k = k if k is not None else 20.0
+            data["layers"] = [{"thickness": t, "conductivity": k}]
+        return data
+
+
+class SolverSettings(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    global_regime: Literal["incompressible", "compressible"] = "incompressible"
+    init_strategy: Literal["default", "incompressible_warmstart", "homotopy", "continuation"] = (
+        "default"
+    )
+    method: Literal[
+        "hybr",
+        "lm",
+        "broyden1",
+        "broyden2",
+        "anderson",
+        "linearmixing",
+        "diagbroyden",
+        "excitingmixing",
+        "krylov",
+        "df-sane",
+    ] = "hybr"
+    timeout: float | None = 180.0
+
+
+# --- React Flow Wrapper Schemas ---
+
+
+class NodePosition(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    x: float
+    y: float
+
+
+class ReactFlowNode(BaseModel):
+    id: str
+    type: str
+    position: NodePosition
+    data: dict
+
+
+class ReactFlowEdge(BaseModel):
+    id: str
+    source: str
+    target: str
+    type: str | None = None
+    data: dict | None = None
+
+
+class NetworkGraphSchema(BaseModel):
+    nodes: list[ReactFlowNode]
+    edges: list[ReactFlowEdge]
+    solver_settings: SolverSettings = Field(default_factory=SolverSettings)
+
+
+# --- Results Schemas ---
+
+
+class StateResult(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    T: float
+    P: float
+    Pt: float | None = None
+    Tt: float | None = None
+    rho: float | None = None
+    h: float | None = None
+    s: float | None = None
+    mach: float | None = None
+    Y: list[float]
+    X: list[float] | None = None
+
+
+class NodeResult(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    state: StateResult
+    success: bool = True
+
+
+class ElementResult(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    m_dot: float
+    success: bool = True
+
+
+class SolveResponse(BaseModel):
+    success: bool
+    message: str = ""
+    final_norm: float | None = None
+    node_results: dict[str, NodeResult] = {}
+    element_results: dict[str, ElementResult] = {}
+    edge_results: dict[str, dict] = {}

gui/backend/units.py

@@ -0,0 +1,135 @@
+"""Unit catalogue for result-export column headers.
+
+Mirrors the labels/units of the frontend ``QUANTITY_CATALOGUE`` so the CSV
+produced by ``/export`` is self-describing (``P [Pa]``, ``T [K]`` …).
+
+Keep this module dependency-free; it is imported by ``main.py`` during the
+CSV-streaming response.
+"""
+
+import re
+
+# ---------------------------------------------------------------------------
+# Scalar quantity → unit mapping
+# ---------------------------------------------------------------------------
+
+UNIT_MAP: dict[str, str] = {
+    # --- Thermodynamic state ---
+    "T": "K",
+    "T_total": "K",
+    "T_in": "K",
+    "T_out": "K",
+    "Tt_in": "K",
+    "Tt_out": "K",
+    "T_aw": "K",
+    "T_hot": "K",
+    "T_interface": "K",
+    "P": "Pa",
+    "P_total": "Pa",
+    "P_in": "Pa",
+    "P_out": "Pa",
+    "Pt_in": "Pa",
+    "Pt_out": "Pa",
+    "dP": "Pa",
+    "dPt": "Pa",
+    "pr_total": "-",
+    "pr_static": "-",
+    # --- Flow ---
+    "m_dot": "kg/s",
+    "velocity": "m/s",
+    "v": "m/s",
+    "a": "m/s",
+    "mach": "-",
+    "mach_in": "-",
+    "mach_out": "-",
+    "mach_throat": "-",
+    "mach_loss_ref": "-",
+    # --- Node stagnation ---
+    "Tt": "K",
+    "Pt": "Pa",
+    # --- Transport ---
+    "mu": "Pa·s",
+    "k": "W/m/K",
+    "nu": "m²/s",
+    "Pr": "-",
+    "Re": "-",
+    "Dh": "m",
+    # --- Thermo per-mass (node/element state) ---
+    "rho": "kg/m³",
+    "h": "J/kg",
+    "s": "J/kg/K",
+    "u": "J/kg",
+    "cp": "J/kg/K",
+    "cv": "J/kg/K",
+    "gamma": "-",
+    "mw": "kg/mol",
+    # --- Thermo reference-state block (Phase 2, element inlet state) ---
+    "rho_ref": "kg/m³",
+    "h_ref": "J/kg",
+    "s_ref": "J/kg/K",
+    "u_ref": "J/kg",
+    "cp_ref": "J/kg/K",
+    "cv_ref": "J/kg/K",
+    "gamma_ref": "-",
+    "a_ref": "m/s",
+    "mw_ref": "kg/mol",
+    "mu_ref": "Pa·s",
+    "k_ref": "W/m/K",
+    "nu_ref": "m²/s",
+    "Pr_ref": "-",
+    # --- Heat transfer ---
+    "Nu": "-",
+    "htc": "W/m²/K",
+    "h_a": "W/m²/K",
+    "h_b": "W/m²/K",
+    "Q": "W",
+    # --- Element diagnostics ---
+    "xi": "-",
+    "theta": "-",
+    "zeta": "-",
+    "ratio": "-",  # AreaChangeElement (renamed to area_ratio in Phase 2)
+    "area_ratio": "-",  # Phase 2 name
+    "is_correlation": "-",
+    "f": "-",
+    "Cd": "-",
+    "phi": "-",
+    # --- Geometry ---
+    "area": "m²",
+    "diameter": "m",
+    "length": "m",
+    "roughness": "m",
+}
+
+# Composition keys render as ``Y[<label>] [-]``. ``<label>`` may be a species
+# name (e.g. ``N2``, ``H2O``, ``CH4``) or a numeric index for forward
+# compatibility with older exports.
+_COMPOSITION_RE = re.compile(r"^[YX]\[[A-Za-z0-9_+\-()]+\]$")
+
+
+def label_with_unit(column: str) -> str:
+    """Return ``'<column> [<unit>]'`` when a unit is known, else ``column``.
+
+    Meta columns such as ``id``, ``type``, ``label``, ``kind``, ``success``
+    and ``is_boundary`` are passed through unchanged.
+    """
+    if column in _META_COLUMNS:
+        return column
+    if column in UNIT_MAP:
+        return f"{column} [{UNIT_MAP[column]}]"
+    if _COMPOSITION_RE.match(column):
+        return f"{column} [-]"
+    return column
+
+
+_META_COLUMNS: frozenset[str] = frozenset(
+    {
+        "id",
+        "label",
+        "type",
+        "kind",
+        "success",
+        "is_boundary",
+        "combustion_method",
+        "ref_location",
+    }
+)