ignore optics if no platform

Author: networmix

ngraph/explorer.py

@@ -270,8 +270,14 @@ def set_node_counts(n: TreeNode):
 
         # 2) Accumulate node capex/power and validate hardware capacity vs attached links
         #    Also validate that sum of endpoint optics usage does not exceed node port count
+        #    Track which nodes actually have chassis/hardware assigned; optics at a link
+        #    endpoint should contribute cost/power only when the endpoint node has
+        #    hardware. Without node hardware, optics cannot be installed and should be
+        #    ignored in aggregation and capacity validation.
+        node_has_hw: Dict[str, bool] = {}
         for nd in self.network.nodes.values():
             comp, hw_count = resolve_node_hardware(nd.attrs, self.components_library)
+            node_has_hw[nd.name] = comp is not None
             if nd.attrs.get("hardware") and comp is None:
                 logger.warning(
                     "Node '%s' references unknown node hardware component '%s'.",
@@ -427,7 +433,9 @@ def set_node_counts(n: TreeNode):
                         dst_name,
                     )
 
-                if src_comp is not None:
+                # Optics contribute only if the endpoint node has hardware
+                src_endpoint_has_hw = node_has_hw.get(src, False)
+                if src_comp is not None and src_endpoint_has_hw:
                     # For BOM, apply ceiling for exclusive use
                     src_cnt_bom = float(int(src_cnt) if src_exclusive else src_cnt)
                     src_cost, src_power, src_cap = totals_with_multiplier(
@@ -436,15 +444,21 @@ def set_node_counts(n: TreeNode):
                 else:
                     src_cost, src_power, src_cap = 0.0, 0.0, 0.0
                     src_cnt_bom = 0.0
+                    # Prevent BOM accumulation below
+                    if not src_endpoint_has_hw:
+                        src_comp = None
 
-                if dst_comp is not None:
+                dst_endpoint_has_hw = node_has_hw.get(dst, False)
+                if dst_comp is not None and dst_endpoint_has_hw:
                     dst_cnt_bom = float(int(dst_cnt) if dst_exclusive else dst_cnt)
                     dst_cost, dst_power, dst_cap = totals_with_multiplier(
                         dst_comp, dst_cnt
                     )
                 else:
                     dst_cost, dst_power, dst_cap = 0.0, 0.0, 0.0
                     dst_cnt_bom = 0.0
+                    if not dst_endpoint_has_hw:
+                        dst_comp = None
 
                 link_cost = src_cost + dst_cost
                 link_power = src_power + dst_power

ngraph/workflow/cost_power_efficiency.py

@@ -263,6 +263,12 @@ def _link_enabled(link_obj: Any) -> bool:
                 # Reuse the same selection as links_for_sum to ensure endpoint-enabled check
                 links_iter = links_for_sum
 
+            # Precompute which nodes have chassis/hardware; optics are ignored when absent
+            node_has_hw: Dict[str, bool] = {}
+            for nd in network.nodes.values():
+                nd_comp, _nd_cnt = resolve_node_hardware(nd.attrs, library)
+                node_has_hw[nd.name] = nd_comp is not None
+
             for lk in links_iter:
                 (src_end, dst_end, per_end) = resolve_link_end_components(
                     lk.attrs, library
@@ -278,14 +284,20 @@ def _totals_with_max(c, n) -> tuple[float, float, float, float]:
                     power_max = float(c.total_power_max() * n)
                     return capex, power, cap, power_max
 
-                # Compute endpoints
-                src_capex, src_power, src_cap, src_power_max = _totals_with_max(
-                    src_comp, src_cnt
-                )
+                # Compute endpoints; ignore optics if the endpoint node has no hardware
+                if src_comp is not None and node_has_hw.get(lk.source, False):
+                    _, src_power, src_cap, src_power_max = _totals_with_max(
+                        src_comp, src_cnt
+                    )
+                else:
+                    src_power, src_cap, src_power_max = 0.0, 0.0, 0.0
 
-                dst_capex, dst_power, dst_cap, dst_power_max = _totals_with_max(
-                    dst_comp, dst_cnt
-                )
+                if dst_comp is not None and node_has_hw.get(lk.target, False):
+                    _, dst_power, dst_cap, dst_power_max = _totals_with_max(
+                        dst_comp, dst_cnt
+                    )
+                else:
+                    dst_power, dst_cap, dst_power_max = 0.0, 0.0, 0.0
 
                 # Aggregate per-link
                 power_watts = float(src_power + dst_power)
@@ -305,12 +317,14 @@ def _totals_with_max(c, n) -> tuple[float, float, float, float]:
                         "source": {
                             "component": src_comp.name
                             if src_comp is not None
+                            and node_has_hw.get(lk.source, False)
                             else None,
                             "count": float(src_cnt),
                         },
                         "target": {
                             "component": dst_comp.name
                             if dst_comp is not None
+                            and node_has_hw.get(lk.target, False)
                             else None,
                             "count": float(dst_cnt),
                         },