Upload 9 files

.gitignore

@@ -0,0 +1,2 @@
+API
+API.py

API

@@ -0,0 +1 @@
+API = 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

API.py

@@ -0,0 +1,2 @@
+def API():
+    return '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'

chip_routing.py

@@ -0,0 +1,372 @@
+"""
+chip_routing_cuopt.py
+─────────────────────────────────────────────────────────────────────────────
+Real-world chip routing optimizer using NVIDIA cuOpt.
+
+Context
+───────
+In chip/PCB routing, we model the problem as a Vehicle Routing Problem (VRP):
+  • "Vehicles"  → routing agents (one per metal layer: M1, M2, …)
+  • "Tasks"     → signal nets / vias that must be connected
+  • "Locations" → grid nodes on the routing fabric
+  • "Cost"      → wire length + layer-change penalty + congestion weight
+  • "Capacity"  → track utilization budget per routing channel
+
+Layers
+  Layer 1 (M1) – horizontal preferred  (lower resistance for power rails)
+  Layer 2 (M2) – vertical preferred    (signal routing)
+
+The cost matrix encodes Manhattan distance + congestion surcharge between
+every pair of grid nodes.  Travel-time matrix models signal delay (RC).
+
+Usage
+─────
+  pip install requests
+  python chip_routing_cuopt.py
+
+Output
+──────
+  Prints the optimised route sequence per layer-agent with estimated
+  wire-length and timing slack.
+"""
+
+import json
+import sys
+import time
+
+import requests
+
+import API
+
+# ─── Configuration ───────────────────────────────────────────────────────────
+
+API_KEY = API.API()
+#print(API_KEY)
+INVOKE_URL      = "https://optimize.api.nvidia.com/v1/nvidia/cuopt"
+FETCH_URL_FMT   = "https://optimize.api.nvidia.com/v1/status/{}"
+POLL_INTERVAL_S = 1.0   # seconds between status polls
+MAX_WAIT_S      = 120   # give up after this many seconds
+
+HEADERS = {
+    "Authorization": f"Bearer {API_KEY}",
+    "Accept":        "application/json",
+    "Content-Type":  "application/json",
+}
+
+# ─── Chip / Grid Definition ──────────────────────────────────────────────────
+
+# 5×5 routing grid  →  25 nodes, indexed row-major: node = row*5 + col
+GRID_ROWS = 5
+GRID_COLS = 5
+N_NODES   = GRID_ROWS * GRID_COLS          # 25
+
+# Metal layers modelled as separate "vehicle types" in cuOpt
+LAYERS = {
+    "M1": 1,   # horizontal preferred – lower unit cost on H-edges
+    "M2": 2,   # vertical preferred   – lower unit cost on V-edges
+}
+
+# Congestion map: (node_index) → surcharge added to every edge touching it.
+# Represents hot-spots from prior global routing passes.
+CONGESTION = {
+    6:  2,   # centre-left cluster
+    7:  3,
+    12: 4,   # middle – heavily congested
+    13: 3,
+    18: 2,
+}
+
+# Signal nets to route: each net needs a connection visit at its sink node.
+# Format: (net_id, source_node, sink_node, demand_M1, demand_M2, earliest, latest)
+NETS = [
+    # net_id   src  sink  d_M1 d_M2  tw_early  tw_late
+    ("CLK",     0,   24,   1,   1,      0,        8),
+    ("VDD",     0,   20,   2,   1,      0,        9),
+    ("DATA_A",  4,   16,   1,   1,      1,        7),
+    ("DATA_B",  4,   21,   1,   1,      1,        8),
+    ("RESET",   0,   14,   1,   1,      0,        6),
+    ("OUT_X",  20,   24,   1,   1,      2,        9),
+    ("OUT_Y",   5,   23,   1,   1,      2,        9),
+]
+
+# Router agents: one per layer.  They start / end at node 0 (top-left pad ring).
+ROUTERS = [
+    # router_id   layer   cap_M1  cap_M2  time_window  max_cost  max_time
+    ("M1_router", "M1",    6,      4,     (0, 10),      30,       12),
+    ("M2_router", "M2",    4,      6,     (0, 10),      30,       12),
+]
+
+# ─── Cost / Delay Matrix Builder ─────────────────────────────────────────────
+
+def node_to_rc(n: int):
+    return divmod(n, GRID_COLS)   # (row, col)
+
+def manhattan(a: int, b: int) -> int:
+    r1, c1 = node_to_rc(a)
+    r2, c2 = node_to_rc(b)
+    return abs(r1 - r2) + abs(c1 - c2)
+
+def edge_congestion(a: int, b: int) -> int:
+    """Sum congestion surcharges for endpoints."""
+    return CONGESTION.get(a, 0) + CONGESTION.get(b, 0)
+
+def build_cost_matrix(layer_id: int) -> list[list[int]]:
+    """
+    Cost = Manhattan distance + congestion penalty.
+    M1 (layer 1) pays extra for vertical moves (prefers horizontal).
+    M2 (layer 2) pays extra for horizontal moves (prefers vertical).
+    """
+    n = N_NODES
+    mat = [[0] * n for _ in range(n)]
+    for a in range(n):
+        for b in range(n):
+            if a == b:
+                continue
+            ra, ca = node_to_rc(a)
+            rb, cb = node_to_rc(b)
+            h_dist = abs(ca - cb)
+            v_dist = abs(ra - rb)
+            if layer_id == 1:                # M1 horizontal preferred
+                layer_penalty = v_dist       # penalise vertical hops
+            else:                            # M2 vertical preferred
+                layer_penalty = h_dist       # penalise horizontal hops
+            base = h_dist + v_dist + layer_penalty
+            cong = edge_congestion(a, b)
+            mat[a][b] = max(1, base + cong)
+    return mat
+
+def build_delay_matrix() -> list[list[int]]:
+    """
+    Signal delay ∝ wire length (RC).  Congestion adds extra delay (buffering).
+    Layer-independent for timing analysis.
+    """
+    n = N_NODES
+    mat = [[0] * n for _ in range(n)]
+    for a in range(n):
+        for b in range(n):
+            if a == b:
+                continue
+            dist = manhattan(a, b)
+            cong = edge_congestion(a, b) // 2   # partial delay impact
+            mat[a][b] = max(1, dist + cong)
+    return mat
+
+# ─── cuOpt Payload Builder ────────────────────────────────────────────────────
+
+def build_payload() -> dict:
+    cost_M1 = build_cost_matrix(layer_id=1)
+    cost_M2 = build_cost_matrix(layer_id=2)
+    delay    = build_delay_matrix()
+
+    # cuOpt expects matrices keyed by vehicle-type id (as string)
+    cost_matrix_data = {
+        "1": cost_M1,   # M1_router
+        "2": cost_M2,   # M2_router
+    }
+    delay_matrix_data = {
+        "1": delay,
+        "2": delay,
+    }
+
+    n_routers = len(ROUTERS)
+    n_nets    = len(NETS)
+
+    # Fleet (routing agents / layers)
+    # cuOpt capacities shape: [n_capacity_dims][n_vehicles]
+    vehicle_locations  = [[0, 0]] * n_routers          # start + end at node 0
+    vehicle_ids        = [r[0] for r in ROUTERS]
+    capacities         = [
+        [r[2] for r in ROUTERS],   # dim-0: M1 track budget per router
+        [r[3] for r in ROUTERS],   # dim-1: M2 track budget per router
+    ]
+    vehicle_time_wins  = [list(r[4]) for r in ROUTERS]
+    vehicle_max_costs  = [r[5] for r in ROUTERS]
+    vehicle_max_times  = [r[6] for r in ROUTERS]
+    vehicle_types      = [LAYERS[r[1]] for r in ROUTERS]
+
+    # Tasks (nets to route)
+    task_locations = [n[2] for n in NETS]          # sink nodes
+    task_ids       = [n[0] for n in NETS]
+    # cuOpt demand shape: [n_capacity_dims][n_tasks]
+    demand         = [
+        [net[3] for net in NETS],  # dim-0: M1 track demand per net  (index 3)
+        [net[4] for net in NETS],  # dim-1: M2 track demand per net  (index 4)
+    ]
+    task_tw        = [[n[5], n[6]] for n in NETS]
+    service_times  = [0] * n_nets  # routing is instantaneous post-opt
+
+    payload = {
+        "action": "cuOpt_OptimizedRouting",
+        "data": {
+            "cost_matrix_data":         {"data": cost_matrix_data},
+            "travel_time_matrix_data":  {"data": delay_matrix_data},
+            "fleet_data": {
+                "vehicle_locations":    vehicle_locations,
+                "vehicle_ids":          vehicle_ids,
+                "capacities":           capacities,
+                "vehicle_time_windows": vehicle_time_wins,
+                "vehicle_types":        vehicle_types,
+                "vehicle_max_costs":    vehicle_max_costs,
+                "vehicle_max_times":    vehicle_max_times,
+                "skip_first_trips":  [False] * n_routers,
+                "drop_return_trips": [True]  * n_routers,  # no need to return to origin
+                "min_vehicles":      1,
+            },
+            "task_data": {
+                "task_locations":    task_locations,
+                "task_ids":          task_ids,
+                "demand":            demand,
+                "task_time_windows": task_tw,
+                "service_times":     service_times,
+            },
+            "solver_config": {
+                "time_limit": 5,        # seconds – increase for larger chips
+                "objectives": {
+                    "cost":                    2,   # minimise wire length + congestion
+                    "travel_time":             1,   # minimise signal delay
+                    "variance_route_size":     1,   # balance load across layers
+                    "variance_route_service_time": 0,
+                    "prize":                   0,
+                },
+                "verbose_mode":  False,
+                "error_logging": True,
+            },
+        },
+        "client_version": "chip_router_v1.0",
+    }
+    return payload
+
+# ─── Result Interpreter ───────────────────────────────────────────────────────
+
+def interpret_results(response_body: dict):
+    """Pretty-print the optimised routing schedule."""
+    print("\n" + "═" * 60)
+    print("  CHIP ROUTING OPTIMISATION RESULTS")
+    print("═" * 60)
+
+    if "error" in response_body:
+        print(f"  ✗ Solver error: {response_body['error']}")
+        return
+
+    # Dump raw response if --debug flag passed
+    if "--debug" in sys.argv:
+        print(json.dumps(response_body, indent=2))
+
+    routes = response_body.get("response", {}).get("solver_response", {})
+    if not routes:
+        print("  No routes returned.")
+        print(json.dumps(response_body, indent=2))
+        return
+
+    vehicle_data   = routes.get("vehicle_data", {})
+    # solution_cost holds the actual total objective value
+    solution_cost  = routes.get("solution_cost", routes.get("total_objective", 0))
+    router_by_name = {r[0]: r for r in ROUTERS}
+
+    # Build task lookup: task string id → net name
+    # cuOpt uses the task_ids we supplied, but also inserts "Depot" entries
+    task_name_map  = {n[0]: n[0] for n in NETS}   # "CLK" -> "CLK", etc.
+
+    # Compute real wire costs from the cost matrices we built
+    cost_M1 = build_cost_matrix(layer_id=1)
+    cost_M2 = build_cost_matrix(layer_id=2)
+    layer_cost_matrix = {"M1": cost_M1, "M2": cost_M2}
+
+    total_wirelength = 0
+
+    for veh_id, data in vehicle_data.items():
+        router      = router_by_name.get(str(veh_id))
+        router_name = router[0] if router else str(veh_id)
+        layer_name  = router[1] if router else "?"
+        cmat        = layer_cost_matrix.get(layer_name, cost_M1)
+
+        task_seq    = data.get("task_id",       [])
+        route_nodes = data.get("route",         [])
+        arrivals    = data.get("arrival_stamp", [])
+
+        # Filter out depot stops (task id == "Depot" or node == 0 at start/end)
+        stops = []
+        for idx, t in enumerate(task_seq):
+            node = route_nodes[idx] if idx < len(route_nodes) else None
+            arr  = arrivals[idx]    if idx < len(arrivals)    else "?"
+            if str(t) == "Depot":
+                continue
+            stops.append((t, node, arr))
+
+        # Compute actual wire length for this router's path
+        wire_cost = 0
+        if len(stops) > 1:
+            for i in range(len(stops) - 1):
+                a = stops[i][1]
+                b = stops[i+1][1]
+                if a is not None and b is not None:
+                    wire_cost += cmat[int(a)][int(b)]
+        # Add depot→first and last→depot legs
+        if stops:
+            wire_cost += cmat[0][int(stops[0][1])]
+            # drop_return_trips=True so no return leg
+
+        total_wirelength += wire_cost
+
+        print(f"\n  ┌─ {router_name}  [{layer_name}]")
+        print(f"  │  Wire length (cost units) : {wire_cost}")
+        print(f"  │  Nets routed : {len(stops)}")
+
+        if not stops:
+            print("  │  (no nets assigned)")
+        else:
+            print("  │  Net sequence:")
+            for seq_i, (t, node, arr) in enumerate(stops):
+                net_name = task_name_map.get(str(t), str(t))
+                r, c     = node_to_rc(int(node)) if node is not None else ("?", "?")
+                # Timing slack = latest_allowed - actual_arrival
+                net_def  = next((n for n in NETS if n[0] == net_name), None)
+                slack    = f"{net_def[6] - float(arr):+.1f}" if net_def and arr != "?" else "?"
+                print(f"  │    [{seq_i+1}] {net_name:<10} → node {node:>2}  "
+                      f"(grid {r},{c})  arrival={arr:<5}  slack={slack}")
+        print("  └" + "─" * 50)
+
+    print(f"\n  ► Total wire length  : {total_wirelength} cost-units")
+    print(f"  ► Solver objective   : {solution_cost}")
+    print(f"  ► Grid size          : {GRID_ROWS}×{GRID_COLS}")
+    print(f"  ► Nets routed        : {len(NETS)}  |  Layers: {len(ROUTERS)}")
+    print("═" * 60 + "\n")
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+def main():
+    print("Building cost matrices …")
+    payload = build_payload()
+
+    # Optionally dump the payload for inspection
+    if "--dump" in sys.argv:
+        print(json.dumps(payload, indent=2))
+        return
+
+    print("Submitting to NVIDIA cuOpt …")
+    session  = requests.Session()
+    response = session.post(INVOKE_URL, headers=HEADERS, json=payload, timeout=30)
+
+    # Poll for async completion
+    elapsed = 0
+    while response.status_code == 202:
+        req_id    = response.headers.get("NVCF-REQID")
+        fetch_url = FETCH_URL_FMT.format(req_id)
+        print(f"  Waiting for result (req={req_id[:8]}…) [{elapsed}s]")
+        time.sleep(POLL_INTERVAL_S)
+        elapsed  += POLL_INTERVAL_S
+        response  = session.get(fetch_url, headers=HEADERS, timeout=30)
+        if elapsed > MAX_WAIT_S:
+            sys.exit("ERROR: Timed out waiting for cuOpt result.")
+
+    try:
+        response.raise_for_status()
+    except requests.HTTPError as exc:
+        sys.exit(f"HTTP error: {exc}\nBody: {response.text}")
+
+    response_body = response.json()
+    interpret_results(response_body)
+
+
+if __name__ == "__main__":
+    main()

chip_routingv2.py

@@ -0,0 +1,780 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+@Author  : Mihir Mithani
+@Date    : 08-05-2026 , 10:44
+@File    : chip_routingv2.py
+@Desc    : 
+"""
+"""
+chip_routing_cuopt.py
+─────────────────────────────────────────────────────────────────────────────
+Interactive chip routing optimizer using NVIDIA cuOpt.
+
+Features
+────────
+  • User enters grid dimensions (m × n) via GUI
+  • Click cells to select them, then name the component placed there
+  • Create connection pairs by clicking source → sink cells
+  • Runs cuOpt VRP solver to find optimal routing
+  • Visualises the routed result on the grid
+
+Usage
+─────
+  pip install requests
+  python chip_routing_cuopt.py
+
+  Set your API key in the NVIDIA_API_KEY variable below (or via env var).
+"""
+
+import time
+import tkinter as tk
+from tkinter import messagebox, simpledialog
+
+import requests
+
+import API
+
+# ─── API Configuration ────────────────────────────────────────────────────────
+
+NVIDIA_API_KEY = API.API()
+INVOKE_URL = "https://optimize.api.nvidia.com/v1/nvidia/cuopt"
+FETCH_URL_FMT = "https://optimize.api.nvidia.com/v1/status/{}"
+POLL_INTERVAL_S = 1.2
+MAX_WAIT_S = 120
+
+HEADERS = {
+    "Authorization": f"Bearer {NVIDIA_API_KEY}",
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+}
+
+# ─── Colors ───────────────────────────────────────────────────────────────────
+
+CLR_BG = "#0f1117"
+CLR_PANEL = "#1a1d27"
+CLR_BORDER = "#2e3248"
+CLR_ACCENT = "#5b6af0"
+CLR_ACCENT2 = "#a78bfa"
+CLR_TEXT = "#e8eaf6"
+CLR_MUTED = "#6b7280"
+CLR_CELL_EMPTY = "#1e2133"
+CLR_CELL_COMP = "#1e2d50"
+CLR_CELL_DEPOT = "#2d1e50"
+CLR_CELL_SELA = "#1e3b2a"  # source (green tint)
+CLR_CELL_SELB = "#3b2a1e"  # sink (amber tint)
+CLR_CELL_ROUTED = "#1a3320"
+CLR_CELL_HOVER = "#252840"
+CLR_SUCCESS = "#34d399"
+CLR_WARNING = "#fbbf24"
+CLR_DANGER = "#f87171"
+CLR_NET_COLORS = [
+    "#5b6af0", "#a78bfa", "#34d399", "#fbbf24", "#f87171",
+    "#38bdf8", "#fb7185", "#4ade80", "#facc15", "#818cf8",
+]
+
+CELL_W = 90
+CELL_H = 60
+PAD = 12
+
+
+# ─── Matrix Builders ──────────────────────────────────────────────────────────
+
+def node_to_rc(n, cols):
+    return divmod(n, cols)
+
+
+def manhattan(a, b, cols):
+    r1, c1 = node_to_rc(a, cols)
+    r2, c2 = node_to_rc(b, cols)
+    return abs(r1 - r2) + abs(c1 - c2)
+
+
+def build_cost_matrix(rows, cols, layer_id):
+    n = rows * cols
+    mat = []
+    for a in range(n):
+        row = []
+        ra, ca = node_to_rc(a, cols)
+        for b in range(n):
+            if a == b:
+                row.append(0)
+                continue
+            rb, cb = node_to_rc(b, cols)
+            hd = abs(ca - cb)
+            vd = abs(ra - rb)
+            penalty = vd if layer_id == 1 else hd
+            row.append(max(1, hd + vd + penalty))
+        mat.append(row)
+    return mat
+
+
+def build_delay_matrix(rows, cols):
+    n = rows * cols
+    mat = []
+    for a in range(n):
+        row = []
+        for b in range(n):
+            if a == b:
+                row.append(0)
+            else:
+                row.append(max(1, manhattan(a, b, cols)))
+        mat.append(row)
+    return mat
+
+
+def build_payload(rows, cols, pairs):
+    n_nets = len(pairs)
+    max_t = rows * cols + 4
+    cap = n_nets + 4
+
+    cost_m1 = build_cost_matrix(rows, cols, 1)
+    cost_m2 = build_cost_matrix(rows, cols, 2)
+    delay = build_delay_matrix(rows, cols)
+
+    return {
+        "action": "cuOpt_OptimizedRouting",
+        "data": {
+            "cost_matrix_data": {"data": {"1": cost_m1, "2": cost_m2}},
+            "travel_time_matrix_data": {"data": {"1": delay, "2": delay}},
+            "fleet_data": {
+                "vehicle_locations": [[0, 0], [0, 0]],
+                "vehicle_ids": ["M1_router", "M2_router"],
+                "capacities": [[cap, cap], [cap, cap]],
+                "vehicle_time_windows": [[0, max_t], [0, max_t]],
+                "vehicle_types": [1, 2],
+                "vehicle_max_costs": [rows * cols * 6, rows * cols * 6],
+                "vehicle_max_times": [max_t, max_t],
+                "skip_first_trips": [False, False],
+                "drop_return_trips": [True, True],
+                "min_vehicles": 1,
+            },
+            "task_data": {
+                "task_locations": [p["sink"] for p in pairs],
+                "task_ids": [p["name"] for p in pairs],
+                "demand": [[1] * n_nets, [1] * n_nets],
+                "task_time_windows": [[0, max_t]] * n_nets,
+                "service_times": [0] * n_nets,
+            },
+            "solver_config": {
+                "time_limit": 5,
+                "objectives": {
+                    "cost": 2,
+                    "travel_time": 1,
+                    "variance_route_size": 1,
+                    "variance_route_service_time": 0,
+                    "prize": 0,
+                },
+                "verbose_mode": False,
+                "error_logging": True,
+            },
+        },
+        "client_version": "chip_router_interactive_v2",
+    }
+
+
+def call_cuopt(payload):
+    session = requests.Session()
+    response = session.post(INVOKE_URL, headers=HEADERS, json=payload, timeout=30)
+    elapsed = 0
+    while response.status_code == 202:
+        req_id = response.headers.get("NVCF-REQID", "")
+        fetch_url = FETCH_URL_FMT.format(req_id)
+        time.sleep(POLL_INTERVAL_S)
+        elapsed += POLL_INTERVAL_S
+        if elapsed > MAX_WAIT_S:
+            raise TimeoutError("cuOpt request timed out")
+        response = session.get(fetch_url, headers=HEADERS, timeout=30)
+    response.raise_for_status()
+    return response.json()
+
+
+# ─── Main Application ─────────────────────────────────────────────────────────
+
+class ChipRoutingApp(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("Chip Routing Optimizer · cuOpt")
+        self.configure(bg=CLR_BG)
+        self.resizable(True, True)
+        self.geometry("1100x750")
+
+        # State
+        self.rows = 0
+        self.cols = 0
+        self.components = {}  # node_idx → component name
+        self.pairs = []  # list of dicts {name, src, sink, src_name, sink_name}
+        self.sel_cell = None  # currently selected cell (editing mode)
+        self.pair_src = None  # first cell picked in pair mode
+        self.mode = "edit"  # "edit" | "pair" | "result"
+        self.cell_btns = {}  # node_idx → canvas item ids
+        self.net_colors = {}  # pair name → color
+
+        self._build_ui()
+
+    # ── UI Construction ───────────────────────────────────────────────────────
+
+    def _build_ui(self):
+        # Left panel
+        self.left = tk.Frame(self, bg=CLR_PANEL, width=260)
+        self.left.pack(side=tk.LEFT, fill=tk.Y, padx=(0, 0))
+        self.left.pack_propagate(False)
+        self._build_left_panel()
+
+        # Right canvas area
+        self.right = tk.Frame(self, bg=CLR_BG)
+        self.right.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        # Canvas with scrollbars
+        self.canvas_frame = tk.Frame(self.right, bg=CLR_BG)
+        self.canvas_frame.pack(fill=tk.BOTH, expand=True, padx=PAD, pady=PAD)
+
+        self.hscroll = tk.Scrollbar(self.canvas_frame, orient=tk.HORIZONTAL)
+        self.vscroll = tk.Scrollbar(self.canvas_frame, orient=tk.VERTICAL)
+        self.canvas = tk.Canvas(
+            self.canvas_frame,
+            bg=CLR_BG,
+            highlightthickness=0,
+            xscrollcommand=self.hscroll.set,
+            yscrollcommand=self.vscroll.set,
+        )
+        self.hscroll.config(command=self.canvas.xview)
+        self.vscroll.config(command=self.canvas.yview)
+        self.hscroll.pack(side=tk.BOTTOM, fill=tk.X)
+        self.vscroll.pack(side=tk.RIGHT, fill=tk.Y)
+        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        # Status bar
+        self.status_var = tk.StringVar(value="Enter grid dimensions and click Build.")
+        self.status_bar = tk.Label(
+            self.right, textvariable=self.status_var,
+            bg=CLR_PANEL, fg=CLR_MUTED, font=("Consolas", 10),
+            anchor=tk.W, padx=12, pady=6,
+        )
+        self.status_bar.pack(fill=tk.X, side=tk.BOTTOM)
+
+    def _build_left_panel(self):
+        lp = self.left
+        tk.Label(lp, text="CHIP ROUTER", bg=CLR_PANEL, fg=CLR_ACCENT,
+                 font=("Consolas", 13, "bold")).pack(pady=(18, 2))
+        tk.Label(lp, text="cuOpt VRP Engine", bg=CLR_PANEL, fg=CLR_MUTED,
+                 font=("Consolas", 9)).pack(pady=(0, 16))
+
+        self._sep(lp)
+
+        # ── Step 1: Grid dims ─────────────────────────────────────────────
+        tk.Label(lp, text="① GRID DIMENSIONS", bg=CLR_PANEL, fg=CLR_TEXT,
+                 font=("Consolas", 10, "bold")).pack(anchor=tk.W, padx=14, pady=(10, 4))
+
+        df = tk.Frame(lp, bg=CLR_PANEL)
+        df.pack(fill=tk.X, padx=14, pady=4)
+        tk.Label(df, text="Rows (m)", bg=CLR_PANEL, fg=CLR_MUTED,
+                 font=("Consolas", 9)).grid(row=0, column=0, sticky=tk.W)
+        self.rows_var = tk.IntVar(value=4)
+        tk.Spinbox(df, from_=2, to=12, textvariable=self.rows_var, width=5,
+                   bg=CLR_CELL_EMPTY, fg=CLR_TEXT, insertbackground=CLR_TEXT,
+                   buttonbackground=CLR_BORDER, relief=tk.FLAT).grid(row=0, column=1, padx=6)
+        tk.Label(df, text="Cols (n)", bg=CLR_PANEL, fg=CLR_MUTED,
+                 font=("Consolas", 9)).grid(row=1, column=0, sticky=tk.W, pady=(4, 0))
+        self.cols_var = tk.IntVar(value=5)
+        tk.Spinbox(df, from_=2, to=12, textvariable=self.cols_var, width=5,
+                   bg=CLR_CELL_EMPTY, fg=CLR_TEXT, insertbackground=CLR_TEXT,
+                   buttonbackground=CLR_BORDER, relief=tk.FLAT).grid(row=1, column=1, padx=6, pady=(4, 0))
+
+        self._btn(lp, "▶  BUILD GRID", self._on_build, CLR_ACCENT)
+
+        self._sep(lp)
+
+        # ── Step 2: Component placement ───────────────────────────────────
+        tk.Label(lp, text="② PLACE COMPONENTS", bg=CLR_PANEL, fg=CLR_TEXT,
+                 font=("Consolas", 10, "bold")).pack(anchor=tk.W, padx=14, pady=(10, 4))
+        tk.Label(lp, text="Click any cell to select it,\nthen name the component below.",
+                 bg=CLR_PANEL, fg=CLR_MUTED, font=("Consolas", 8),
+                 justify=tk.LEFT).pack(anchor=tk.W, padx=14)
+
+        cf = tk.Frame(lp, bg=CLR_PANEL)
+        cf.pack(fill=tk.X, padx=14, pady=6)
+        tk.Label(cf, text="Name", bg=CLR_PANEL, fg=CLR_MUTED,
+                 font=("Consolas", 9)).pack(side=tk.LEFT)
+        self.comp_var = tk.StringVar()
+        self.comp_entry = tk.Entry(cf, textvariable=self.comp_var, width=14,
+                                   bg=CLR_CELL_EMPTY, fg=CLR_TEXT, relief=tk.FLAT,
+                                   insertbackground=CLR_TEXT, font=("Consolas", 10))
+        self.comp_entry.pack(side=tk.LEFT, padx=(6, 0))
+        self.comp_entry.bind("<Return>", lambda _: self._on_place_comp())
+
+        bf = tk.Frame(lp, bg=CLR_PANEL)
+        bf.pack(fill=tk.X, padx=14)
+        self._btn_small(bf, "Place", self._on_place_comp, CLR_SUCCESS, side=tk.LEFT)
+        self._btn_small(bf, "Clear", self._on_clear_comp, CLR_DANGER, side=tk.LEFT)
+
+        self.sel_label = tk.Label(lp, text="No cell selected", bg=CLR_PANEL,
+                                  fg=CLR_MUTED, font=("Consolas", 8))
+        self.sel_label.pack(anchor=tk.W, padx=14, pady=(4, 0))
+
+        self._sep(lp)
+
+        # ── Step 3: Wire pairs ────────────────────────────────────────────
+        tk.Label(lp, text="③ WIRE PAIRS", bg=CLR_PANEL, fg=CLR_TEXT,
+                 font=("Consolas", 10, "bold")).pack(anchor=tk.W, padx=14, pady=(10, 4))
+        tk.Label(lp, text="Click to toggle pair mode.",
+                 bg=CLR_PANEL, fg=CLR_MUTED, font=("Consolas", 8),
+                 justify=tk.LEFT).pack(anchor=tk.W, padx=14)
+
+        self.pair_mode_btn = tk.Button(
+            lp, text="⛓  ENTER PAIR MODE", font=("Consolas", 9, "bold"),
+            bg=CLR_CELL_EMPTY, fg=CLR_ACCENT2, relief=tk.FLAT,
+            activebackground=CLR_BORDER, activeforeground=CLR_ACCENT2,
+            command=self._toggle_pair_mode, cursor="hand2",
+        )
+        self.pair_mode_btn.pack(fill=tk.X, padx=14, pady=(6, 4))
+
+        self.pair_status_lbl = tk.Label(lp, text="", bg=CLR_PANEL,
+                                        fg=CLR_WARNING, font=("Consolas", 8))
+        self.pair_status_lbl.pack(anchor=tk.W, padx=14)
+
+        # Pair list
+        self.pair_list_frame = tk.Frame(lp, bg=CLR_PANEL)
+        self.pair_list_frame.pack(fill=tk.X, padx=14, pady=4)
+
+        self._sep(lp)
+
+        # ── Step 4: Route ─────────────────────────────────────────────────
+        tk.Label(lp, text="④ ROUTE", bg=CLR_PANEL, fg=CLR_TEXT,
+                 font=("Consolas", 10, "bold")).pack(anchor=tk.W, padx=14, pady=(10, 4))
+        self._btn(lp, "⚡  RUN CUOPT", self._on_run, CLR_ACCENT2)
+        self._btn(lp, "↺  RESET ALL", self._on_reset, CLR_MUTED)
+
+    def _sep(self, parent):
+        tk.Frame(parent, bg=CLR_BORDER, height=1).pack(fill=tk.X, padx=0, pady=4)
+
+    def _btn(self, parent, text, cmd, color):
+        tk.Button(
+            parent, text=text, font=("Consolas", 9, "bold"),
+            bg=color, fg=CLR_BG, relief=tk.FLAT,
+            activebackground=color, activeforeground=CLR_BG,
+            command=cmd, cursor="hand2", padx=6, pady=6,
+        ).pack(fill=tk.X, padx=14, pady=4)
+
+    def _btn_small(self, parent, text, cmd, color, side=tk.LEFT):
+        tk.Button(
+            parent, text=text, font=("Consolas", 8),
+            bg=color, fg=CLR_BG, relief=tk.FLAT,
+            activebackground=color, activeforeground=CLR_BG,
+            command=cmd, cursor="hand2", padx=6, pady=3,
+        ).pack(side=side, padx=(0, 4))
+
+    # ── Grid Drawing ──────────────────────────────────────────────────────────
+
+    def _on_build(self):
+        self.rows = self.rows_var.get()
+        self.cols = self.cols_var.get()
+        self.components = {}
+        self.pairs = []
+        self.sel_cell = None
+        self.pair_src = None
+        self.mode = "edit"
+        self.net_colors = {}
+        self.pair_mode_btn.config(text="⛓  ENTER PAIR MODE", bg=CLR_CELL_EMPTY, fg=CLR_ACCENT2)
+        self._render_grid()
+        self._refresh_pair_list()
+        self._set_status(f"Grid {self.rows}×{self.cols} built. Click cells to name components.")
+
+    def _render_grid(self, routed_nodes=None, route_assignments=None):
+        self.canvas.delete("all")
+        self.cell_items = {}  # node → (rect_id, text_id, sub_id)
+        routed_nodes = routed_nodes or {}
+        route_assignments = route_assignments or {}
+
+        total_w = self.cols * CELL_W + PAD * 2
+        total_h = self.rows * CELL_H + PAD * 2
+        self.canvas.config(scrollregion=(0, 0, total_w, total_h))
+
+        for r in range(self.rows):
+            for c in range(self.cols):
+                n = r * self.cols + c
+                x0 = PAD + c * CELL_W
+                y0 = PAD + r * CELL_H
+                x1 = x0 + CELL_W - 2
+                y1 = y0 + CELL_H - 2
+                cx = (x0 + x1) / 2
+                cy = (y0 + y1) / 2
+
+                color = self._cell_color(n, routed_nodes)
+                rid = self.canvas.create_rectangle(
+                    x0, y0, x1, y1, fill=color, outline=CLR_BORDER,
+                    width=1, tags=(f"cell_{n}", "cell"),
+                )
+                # node index label (bottom-right)
+                self.canvas.create_text(
+                    x1 - 3, y1 - 2, text=f"{r},{c}",
+                    fill=CLR_MUTED, font=("Consolas", 7), anchor=tk.SE,
+                    tags=(f"cell_{n}",),
+                )
+                # component name
+                label = "DEPOT" if n == 0 else self.components.get(n, "")
+                lcolor = CLR_ACCENT2 if n == 0 else CLR_TEXT
+                tid = self.canvas.create_text(
+                    cx, cy - 4, text=label,
+                    fill=lcolor, font=("Consolas", 9, "bold"),
+                    width=CELL_W - 8, anchor=tk.CENTER,
+                    tags=(f"cell_{n}",),
+                )
+                # net assignment (result mode)
+                sub = ""
+                if n in route_assignments:
+                    sub = route_assignments[n]
+                sid = self.canvas.create_text(
+                    cx, y1 - 10, text=sub,
+                    fill=CLR_SUCCESS, font=("Consolas", 7),
+                    width=CELL_W - 6, anchor=tk.CENTER,
+                    tags=(f"cell_{n}",),
+                )
+                self.cell_items[n] = (rid, tid, sid)
+
+                # bind clicks
+                for tag_id in (rid, tid, sid):
+                    self.canvas.tag_bind(tag_id, "<Button-1>",
+                                         lambda e, nd=n: self._on_cell_click(nd))
+                    self.canvas.tag_bind(tag_id, "<Enter>",
+                                         lambda e, nd=n: self._on_cell_hover(nd, True))
+                    self.canvas.tag_bind(tag_id, "<Leave>",
+                                         lambda e, nd=n: self._on_cell_hover(nd, False))
+
+        # Draw pair source lines (in pair mode, show pairs as arrows)
+        if self.mode in ("pair", "edit"):
+            self._draw_pair_arrows()
+
+    def _draw_pair_arrows(self):
+        self.canvas.delete("arrow")
+        for i, p in enumerate(self.pairs):
+            color = self.net_colors.get(p["name"], CLR_NET_COLORS[i % len(CLR_NET_COLORS)])
+            sr, sc = node_to_rc(p["src"], self.cols)
+            dr, dc = node_to_rc(p["sink"], self.cols)
+            sx = PAD + sc * CELL_W + CELL_W // 2
+            sy = PAD + sr * CELL_H + CELL_H // 2
+            dx = PAD + dc * CELL_W + CELL_W // 2
+            dy = PAD + dr * CELL_H + CELL_H // 2
+            self.canvas.create_line(
+                sx, sy, dx, dy, fill=color, width=2,
+                arrow=tk.LAST, arrowshape=(8, 10, 4),
+                dash=(4, 3), tags="arrow",
+            )
+            mx, my = (sx + dx) / 2, (sy + dy) / 2
+            self.canvas.create_text(
+                mx, my - 8, text=p["name"],
+                fill=color, font=("Consolas", 7, "bold"),
+                tags="arrow",
+            )
+
+    def _cell_color(self, n, routed_nodes):
+        if n == 0:
+            return CLR_CELL_DEPOT
+        if n in routed_nodes:
+            return CLR_CELL_ROUTED
+        if n == self.pair_src:
+            return CLR_CELL_SELB
+        if n == self.sel_cell:
+            return CLR_CELL_SELB
+        if n in self.components:
+            return CLR_CELL_COMP
+        return CLR_CELL_EMPTY
+
+    def _recolor_cell(self, n, color=None):
+        if n not in self.cell_items:
+            return
+        rid = self.cell_items[n][0]
+        c = color or self._cell_color(n, {})
+        self.canvas.itemconfig(rid, fill=c)
+
+    def _on_cell_hover(self, n, entering):
+        if n not in self.cell_items:
+            return
+        if entering:
+            cur = self.canvas.itemcget(self.cell_items[n][0], "fill")
+            if cur == CLR_CELL_EMPTY:
+                self.canvas.itemconfig(self.cell_items[n][0], fill=CLR_CELL_HOVER)
+        else:
+            self._recolor_cell(n)
+
+    # ── Cell Click Logic ──────────────────────────────────────────────────────
+
+    def _on_cell_click(self, n):
+        if self.mode == "edit":
+            # deselect previous
+            if self.sel_cell is not None:
+                self._recolor_cell(self.sel_cell)
+            self.sel_cell = n
+            self._recolor_cell(n, CLR_CELL_SELB)
+            r, c = node_to_rc(n, self.cols)
+            name = self.components.get(n, "")
+            self.comp_var.set(name)
+            self.comp_entry.focus_set()
+            if n == 0:
+                self.sel_label.config(text=f"Cell ({r},{c}) — depot/origin")
+            else:
+                self.sel_label.config(
+                    text=f"Cell ({r},{c}){' · ' + name if name else ' — unnamed'}"
+                )
+            self._set_status(f"Selected ({r},{c}). Type a name and press Enter or Place.")
+
+        elif self.mode == "pair":
+            if self.pair_src is None:
+                # pick source
+                self.pair_src = n
+                self._recolor_cell(n, CLR_CELL_SELB)
+                r, c = node_to_rc(n, self.cols)
+                name = self.components.get(n, "DEPOT" if n == 0 else f"node{n}")
+                self.pair_status_lbl.config(
+                    text=f"Source: {name} ({r},{c}). Now pick sink →"
+                )
+            else:
+                if n == self.pair_src:
+                    self._recolor_cell(n)
+                    self.pair_src = None
+                    self.pair_status_lbl.config(text="Source cleared. Pick again.")
+                    return
+                # ask for net name
+                default_name = f"NET{len(self.pairs)}"
+                net_name = simpledialog.askstring(
+                    "Net name",
+                    f"Name for this connection\n(src→sink):",
+                    initialvalue=default_name,
+                    parent=self,
+                )
+                if not net_name:
+                    net_name = default_name
+                net_name = net_name.strip().upper().replace(" ", "_")
+
+                src_name = self.components.get(self.pair_src, "DEPOT" if self.pair_src == 0 else f"node{self.pair_src}")
+                sink_name = self.components.get(n, "DEPOT" if n == 0 else f"node{n}")
+
+                ci = len(self.pairs) % len(CLR_NET_COLORS)
+                self.net_colors[net_name] = CLR_NET_COLORS[ci]
+
+                self.pairs.append({
+                    "name": net_name,
+                    "src": self.pair_src,
+                    "sink": n,
+                    "src_name": src_name,
+                    "sink_name": sink_name,
+                })
+
+                self._recolor_cell(self.pair_src)
+                self.pair_src = None
+                self.pair_status_lbl.config(text=f"Pair '{net_name}' added. Pick next source →")
+                self._refresh_pair_list()
+                self._draw_pair_arrows()
+                self._set_status(f"Pair '{net_name}' added. {len(self.pairs)} pair(s) total.")
+
+    # ── Component Editing ─────────────────────────────────────────────────────
+
+    def _on_place_comp(self):
+        if self.sel_cell is None or self.sel_cell == 0:
+            self._set_status("Select a non-depot cell first.")
+            return
+        name = self.comp_var.get().strip()
+        if not name:
+            self._set_status("Enter a component name first.")
+            return
+        self.components[self.sel_cell] = name
+        # update canvas text
+        if self.sel_cell in self.cell_items:
+            self.canvas.itemconfig(self.cell_items[self.sel_cell][1], text=name)
+            self._recolor_cell(self.sel_cell, CLR_CELL_COMP)
+        r, c = node_to_rc(self.sel_cell, self.cols)
+        self._set_status(f"Placed '{name}' at ({r},{c}).")
+        # also refresh any pairs that reference this node
+        for p in self.pairs:
+            if p["src"] == self.sel_cell:
+                p["src_name"] = name
+            if p["sink"] == self.sel_cell:
+                p["sink_name"] = name
+        self._refresh_pair_list()
+
+    def _on_clear_comp(self):
+        if self.sel_cell is None or self.sel_cell == 0:
+            return
+        self.components.pop(self.sel_cell, None)
+        if self.sel_cell in self.cell_items:
+            self.canvas.itemconfig(self.cell_items[self.sel_cell][1], text="")
+            self._recolor_cell(self.sel_cell, CLR_CELL_SELB)
+        self.comp_var.set("")
+        self._set_status("Component cleared.")
+
+    # ── Pair Mode ─────────────────────────────────────────────────────────────
+
+    def _toggle_pair_mode(self):
+        if self.rows == 0:
+            self._set_status("Build a grid first.")
+            return
+        if self.mode == "edit":
+            self.mode = "pair"
+            self.pair_mode_btn.config(
+                text="✕  EXIT PAIR MODE", bg=CLR_ACCENT2, fg=CLR_BG
+            )
+            self.pair_status_lbl.config(text="Click a source cell →")
+            self._set_status("Pair mode: click source, then sink to create a connection.")
+        else:
+            self.mode = "edit"
+            self.pair_src = None
+            self.pair_mode_btn.config(
+                text="⛓  ENTER PAIR MODE", bg=CLR_CELL_EMPTY, fg=CLR_ACCENT2
+            )
+            self.pair_status_lbl.config(text="")
+            self._render_grid()
+            self._set_status("Back to edit mode.")
+
+    def _refresh_pair_list(self):
+        for w in self.pair_list_frame.winfo_children():
+            w.destroy()
+        for i, p in enumerate(self.pairs):
+            color = self.net_colors.get(p["name"], CLR_ACCENT)
+            row = tk.Frame(self.pair_list_frame, bg=CLR_CELL_EMPTY)
+            row.pack(fill=tk.X, pady=2)
+            tk.Label(row, text="●", bg=CLR_CELL_EMPTY, fg=color,
+                     font=("Consolas", 9)).pack(side=tk.LEFT, padx=(4, 2))
+            tk.Label(row, text=f"{p['name']}: {p['src_name']}→{p['sink_name']}",
+                     bg=CLR_CELL_EMPTY, fg=CLR_TEXT,
+                     font=("Consolas", 8), anchor=tk.W).pack(side=tk.LEFT, fill=tk.X, expand=True)
+            tk.Button(row, text="✕", bg=CLR_CELL_EMPTY, fg=CLR_DANGER,
+                      font=("Consolas", 8), relief=tk.FLAT, cursor="hand2",
+                      command=lambda idx=i: self._remove_pair(idx)).pack(side=tk.RIGHT, padx=2)
+
+    def _remove_pair(self, idx):
+        if 0 <= idx < len(self.pairs):
+            self.pairs.pop(idx)
+            self._refresh_pair_list()
+            self._draw_pair_arrows()
+
+    # ── Run cuOpt ─────────────────────────────────────────────────────────────
+
+    def _on_run(self):
+        if self.rows == 0:
+            messagebox.showerror("No grid", "Build a grid first.")
+            return
+        if not self.pairs:
+            messagebox.showerror("No pairs", "Create at least one wire pair first.")
+            return
+
+        self._set_status("⏳ Building matrices and submitting to cuOpt…")
+        self.update()
+
+        try:
+            payload = build_payload(self.rows, self.cols, self.pairs)
+            body = call_cuopt(payload)
+            self._show_results(body)
+        except Exception as e:
+            self._set_status(f"ERROR: {e}")
+            messagebox.showerror("cuOpt error", str(e))
+
+    def _show_results(self, body):
+        routes = body.get("response", {}).get("solver_response", {})
+        vehicle_data = routes.get("vehicle_data", {})
+        obj = routes.get("solution_cost", routes.get("total_objective", "—"))
+
+        routed_nodes = {}  # node → list of net names
+        route_assignment = {}  # node → short label string
+
+        result_lines = [f"Solver objective: {obj}\n"]
+
+        for vid, data in vehicle_data.items():
+            task_seq = data.get("task_id", [])
+            route_nodes = data.get("route", [])
+            arrivals = data.get("arrival_stamp", [])
+
+            stops = []
+            for i, t in enumerate(task_seq):
+                if str(t) == "Depot":
+                    continue
+                node = route_nodes[i] if i < len(route_nodes) else None
+                arr = arrivals[i] if i < len(arrivals) else "?"
+                stops.append((str(t), int(node) if node is not None else None, arr))
+                if node is not None:
+                    n = int(node)
+                    routed_nodes.setdefault(n, []).append(str(t))
+
+            layer = "M1" if "M1" in str(vid) else "M2"
+            result_lines.append(f"── {vid} [{layer}]  ({len(stops)} nets)")
+            for net_name, node, arr in stops:
+                pair = next((p for p in self.pairs if p["name"] == net_name), None)
+                src = pair["src"] if pair else 0
+                r1, c1 = node_to_rc(src, self.cols)
+                r2, c2 = node_to_rc(node, self.cols) if node is not None else ("?", "?")
+                slack = "?"
+                if pair:
+                    lat = pair.get("late", self.rows * self.cols + 4)
+                    slack = f"{lat - float(arr):+.1f}" if arr != "?" else "?"
+                result_lines.append(
+                    f"  {net_name:<12} ({r1},{c1})→({r2},{c2})  "
+                    f"arr={arr if arr != '?' else '?':<5}  slack={slack}"
+                )
+            result_lines.append("")
+
+        # Build route_assignment label per node
+        for node, nets in routed_nodes.items():
+            route_assignment[node] = ",".join(nets)
+
+        self.mode = "result"
+        self._render_grid(routed_nodes=set(routed_nodes.keys()),
+                          route_assignments=route_assignment)
+
+        # Show result window
+        self._show_result_window("\n".join(result_lines))
+        self._set_status(f"Routing complete. Objective={obj}. Routed {len(self.pairs)} net(s).")
+
+    def _show_result_window(self, text):
+        win = tk.Toplevel(self)
+        win.title("Routing Results")
+        win.configure(bg=CLR_BG)
+        win.geometry("540x420")
+
+        tk.Label(win, text="ROUTING RESULTS", bg=CLR_BG, fg=CLR_ACCENT,
+                 font=("Consolas", 12, "bold")).pack(pady=(14, 4))
+
+        frame = tk.Frame(win, bg=CLR_BG)
+        frame.pack(fill=tk.BOTH, expand=True, padx=14, pady=(0, 14))
+
+        sb = tk.Scrollbar(frame)
+        sb.pack(side=tk.RIGHT, fill=tk.Y)
+
+        txt = tk.Text(frame, bg=CLR_PANEL, fg=CLR_TEXT, font=("Consolas", 9),
+                      relief=tk.FLAT, yscrollcommand=sb.set, wrap=tk.NONE)
+        txt.pack(fill=tk.BOTH, expand=True)
+        sb.config(command=txt.yview)
+        txt.insert(tk.END, text)
+        txt.config(state=tk.DISABLED)
+
+        tk.Button(win, text="Close", bg=CLR_ACCENT, fg=CLR_BG,
+                  font=("Consolas", 9, "bold"), relief=tk.FLAT,
+                  command=win.destroy, cursor="hand2").pack(pady=(0, 12))
+
+    # ── Reset ─────────────────────────────────────────────────────────────────
+
+    def _on_reset(self):
+        self.components = {}
+        self.pairs = []
+        self.sel_cell = None
+        self.pair_src = None
+        self.mode = "edit"
+        self.net_colors = {}
+        self.pair_mode_btn.config(text="⛓  ENTER PAIR MODE", bg=CLR_CELL_EMPTY, fg=CLR_ACCENT2)
+        self.pair_status_lbl.config(text="")
+        self.sel_label.config(text="No cell selected")
+        self.comp_var.set("")
+        if self.rows:
+            self._render_grid()
+        self._refresh_pair_list()
+        self._set_status("Reset. Place components and re-wire pairs.")
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+
+    def _set_status(self, msg):
+        self.status_var.set(f"  {msg}")
+
+
+# ─── Entry Point ──────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    app = ChipRoutingApp()
+    app.mainloop()

chip_routingv3.py

@@ -0,0 +1,911 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+@Author  : Mihir Mithani
+@Date    : 08-05-2026 , 10:57
+@File    : chip_routingv3.py
+@Desc    : 
+"""
+"""
+chip_routing_cuopt.py
+─────────────────────────────────────────────────────────────────────────────
+Interactive chip routing optimizer with REAL PCB-style routing.
+
+Routing engine
+──────────────
+  • Octilinear A* pathfinding — only 90° and 45° turns, like real EDA tools
+  • Sequential net routing with incremental blocking so wires NEVER share
+    grid edges or cross each other
+  • Via dots drawn at every bend
+  • Solid lines for orthogonal (90°) hops, dashed for diagonal (45°) hops
+  • cuOpt VRP used to find the optimal ORDER to route nets
+    (minimises total wire length globally)
+
+Usage
+─────
+  pip install requests
+  python chip_routing_cuopt.py
+
+Set NVIDIA_API_KEY env-var or edit the constant below.
+"""
+
+import heapq
+import time
+import tkinter as tk
+from tkinter import messagebox, simpledialog
+
+import requests
+
+import API
+
+# ─── API ──────────────────────────────────────────────────────────────────────
+NVIDIA_API_KEY = API.API()
+INVOKE_URL = "https://optimize.api.nvidia.com/v1/nvidia/cuopt"
+FETCH_URL_FMT = "https://optimize.api.nvidia.com/v1/status/{}"
+POLL_INTERVAL = 1.2
+MAX_WAIT = 120
+
+HEADERS = {
+    "Authorization": f"Bearer {NVIDIA_API_KEY}",
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+}
+
+# ─── Theme ────────────────────────────────────────────────────────────────────
+T = {
+    "bg": "#0a0c14",
+    "panel": "#10131f",
+    "panel2": "#14192a",
+    "border": "#1e2440",
+    "accent": "#4f6ef7",
+    "accent2": "#c084fc",
+    "text": "#dde1f5",
+    "muted": "#4a5275",
+    "cell_empty": "#0e1120",
+    "cell_comp": "#0e2040",
+    "cell_depot": "#1a0e40",
+    "cell_sel": "#0e3020",
+    "cell_hover": "#161c38",
+    "ok": "#22d3a0",
+    "warn": "#facc15",
+    "danger": "#f87171",
+}
+
+NET_COLORS = [
+    "#4f6ef7", "#22d3a0", "#facc15", "#f87171", "#c084fc",
+    "#fb923c", "#38bdf8", "#f472b6", "#a3e635", "#e879f9",
+]
+
+CELL_W = 72
+CELL_H = 50
+GPAD = 14
+
+# ─── Octilinear A* ────────────────────────────────────────────────────────────
+# 8 directions: N, S, E, W, NE, NW, SE, SW
+DIRS = [
+    (0, 1, 1.0),
+    (0, -1, 1.0),
+    (1, 0, 1.0),
+    (-1, 0, 1.0),
+    (1, 1, 1.414),
+    (1, -1, 1.414),
+    (-1, 1, 1.414),
+    (-1, -1, 1.414),
+]
+
+
+def astar(src_rc, dst_rc, rows, cols, blocked: set, comp_nodes: set):
+    """
+    Octilinear A* path from src_rc to dst_rc.
+    blocked    : cells occupied by previously routed wires (interior points)
+    comp_nodes : cells containing a component — impassable unless src/dst
+    Returns list of (r,c) from src to dst inclusive, or None.
+    """
+    passable = {src_rc, dst_rc}
+    walls = (blocked | comp_nodes) - passable
+
+    sr, sc = src_rc
+    dr, dc = dst_rc
+
+    def h(r, c):
+        return max(abs(r - dr), abs(c - dc))  # Chebyshev — admissible
+
+    # heap: (f, g, r, c, parent)
+    heap = [(h(sr, sc), 0.0, sr, sc, None)]
+    came = {}
+    gscore = {(sr, sc): 0.0}
+
+    while heap:
+        f, g, r, c, parent = heapq.heappop(heap)
+        node = (r, c)
+        if node in came:
+            continue
+        came[node] = parent
+
+        if node == (dr, dc):
+            path = []
+            cur = node
+            while cur is not None:
+                path.append(cur)
+                cur = came[cur]
+            path.reverse()
+            return path
+
+        for ddr, ddc, cost in DIRS:
+            nr, nc = r + ddr, c + ddc
+            if not (0 <= nr < rows and 0 <= nc < cols):
+                continue
+            if (nr, nc) in walls:
+                continue
+            # diagonal squeeze-through check
+            if abs(ddr) == 1 and abs(ddc) == 1:
+                if (r + ddr, c) in walls and (r, c + ddc) in walls:
+                    continue
+            ng = g + cost
+            if ng < gscore.get((nr, nc), 1e18):
+                gscore[(nr, nc)] = ng
+                heapq.heappush(heap, (ng + h(nr, nc), ng, nr, nc, node))
+
+    return None
+
+
+def route_all_nets(pairs, rows, cols, components, order=None):
+    """
+    Route nets in the given order using sequential A* with incremental blocking.
+    Returns dict: net_name -> list of (r,c)
+    """
+
+    def n2rc(n):
+        return (n // cols, n % cols)
+
+    comp_nodes = {n2rc(n) for n in components}
+    blocked = set()  # interior cells already used by prior nets
+    results = {}
+
+    if order is None:
+        order = list(range(len(pairs)))
+
+    for idx in order:
+        p = pairs[idx]
+        src = n2rc(p["src"])
+        dst = n2rc(p["sink"])
+        path = astar(src, dst, rows, cols, blocked, comp_nodes)
+
+        if path is None:
+            # rip-up fallback: ignore wire blocking, respect only components
+            path = astar(src, dst, rows, cols, set(), comp_nodes)
+
+        results[p["name"]] = path or []
+
+        if path:
+            # block interior cells (not endpoints) for subsequent nets
+            for cell in path[1:-1]:
+                blocked.add(cell)
+
+    return results
+
+
+# ─── cuOpt helpers ────────────────────────────────────────────────────────────
+
+def _cost_matrix(rows, cols, layer_id):
+    n = rows * cols
+    mat = []
+    for a in range(n):
+        ra, ca = divmod(a, cols)
+        row = []
+        for b in range(n):
+            if a == b:
+                row.append(0)
+                continue
+            rb, cb = divmod(b, cols)
+            hd = abs(ca - cb)
+            vd = abs(ra - rb)
+            pen = vd if layer_id == 1 else hd
+            row.append(max(1, hd + vd + pen))
+        mat.append(row)
+    return mat
+
+
+def _delay_matrix(rows, cols):
+    n = rows * cols
+    mat = []
+    for a in range(n):
+        ra, ca = divmod(a, cols)
+        row = []
+        for b in range(n):
+            if a == b:
+                row.append(0)
+            else:
+                rb, cb = divmod(b, cols)
+                row.append(max(1, abs(ra - rb) + abs(ca - cb)))
+        mat.append(row)
+    return mat
+
+
+def cuopt_net_order(rows, cols, pairs):
+    """
+    Call cuOpt to get the optimal routing order for the nets.
+    Returns (order: list[int], raw_body: dict).
+    Falls back to Manhattan-distance greedy if API fails.
+    """
+    n_nets = len(pairs)
+    max_t = rows * cols + 4
+    cap = n_nets + 4
+
+    payload = {
+        "action": "cuOpt_OptimizedRouting",
+        "data": {
+            "cost_matrix_data": {"data": {"1": _cost_matrix(rows, cols, 1),
+                                          "2": _cost_matrix(rows, cols, 2)}},
+            "travel_time_matrix_data": {"data": {"1": _delay_matrix(rows, cols),
+                                                 "2": _delay_matrix(rows, cols)}},
+            "fleet_data": {
+                "vehicle_locations": [[0, 0], [0, 0]],
+                "vehicle_ids": ["M1_router", "M2_router"],
+                "capacities": [[cap, cap], [cap, cap]],
+                "vehicle_time_windows": [[0, max_t], [0, max_t]],
+                "vehicle_types": [1, 2],
+                "vehicle_max_costs": [rows * cols * 8, rows * cols * 8],
+                "vehicle_max_times": [max_t, max_t],
+                "skip_first_trips": [False, False],
+                "drop_return_trips": [True, True],
+                "min_vehicles": 1,
+            },
+            "task_data": {
+                "task_locations": [p["sink"] for p in pairs],
+                "task_ids": [p["name"] for p in pairs],
+                "demand": [[1] * n_nets, [1] * n_nets],
+                "task_time_windows": [[0, max_t]] * n_nets,
+                "service_times": [0] * n_nets,
+            },
+            "solver_config": {
+                "time_limit": 5,
+                "objectives": {
+                    "cost": 2,
+                    "travel_time": 1,
+                    "variance_route_size": 1,
+                    "variance_route_service_time": 0,
+                    "prize": 0,
+                },
+                "verbose_mode": False,
+                "error_logging": True,
+            },
+        },
+        "client_version": "chip_router_v3",
+    }
+
+    session = requests.Session()
+    resp = session.post(INVOKE_URL, headers=HEADERS, json=payload, timeout=30)
+    elapsed = 0
+    while resp.status_code == 202:
+        req_id = resp.headers.get("NVCF-REQID", "")
+        time.sleep(POLL_INTERVAL)
+        elapsed += POLL_INTERVAL
+        if elapsed > MAX_WAIT:
+            raise TimeoutError("cuOpt timed out")
+        resp = session.get(FETCH_URL_FMT.format(req_id), headers=HEADERS, timeout=30)
+    resp.raise_for_status()
+
+    body = resp.json()
+    vdata = body.get("response", {}).get("solver_response", {}).get("vehicle_data", {})
+    names = []
+    for vd in vdata.values():
+        for t in vd.get("task_id", []):
+            if str(t) != "Depot":
+                names.append(str(t))
+
+    name_to_idx = {p["name"]: i for i, p in enumerate(pairs)}
+    order = [name_to_idx[n] for n in names if n in name_to_idx]
+    for i in range(len(pairs)):
+        if i not in order:
+            order.append(i)
+    return order, body
+
+
+# ─── GUI ──────────────────────────────────────────────────────────────────────
+
+class App(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("Chip Routing Optimizer — cuOpt + A*")
+        self.configure(bg=T["bg"])
+        self.geometry("1220x820")
+        self.resizable(True, True)
+
+        self.rows = 0
+        self.cols = 0
+        self.components = {}  # node_idx -> name
+        self.pairs = []  # [{name, src, sink, src_name, sink_name}]
+        self.routes = {}  # name -> [(r,c),...]
+        self.net_colors = {}  # name -> color
+        self.sel_cell = None
+        self.pair_src = None
+        self.mode = "edit"
+        self.cell_items = {}  # node -> (rect, text, coord, sub)
+
+        self._build_ui()
+
+    # ── UI build ──────────────────────────────────────────────────────────────
+
+    def _build_ui(self):
+        self.left = tk.Frame(self, bg=T["panel"], width=248)
+        self.left.pack(side=tk.LEFT, fill=tk.Y)
+        self.left.pack_propagate(False)
+        self._build_panel()
+
+        right = tk.Frame(self, bg=T["bg"])
+        right.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        cf = tk.Frame(right, bg=T["bg"])
+        cf.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+        hs = tk.Scrollbar(cf, orient=tk.HORIZONTAL)
+        vs = tk.Scrollbar(cf, orient=tk.VERTICAL)
+        self.canvas = tk.Canvas(cf, bg=T["bg"], highlightthickness=0,
+                                xscrollcommand=hs.set, yscrollcommand=vs.set)
+        hs.config(command=self.canvas.xview)
+        vs.config(command=self.canvas.yview)
+        hs.pack(side=tk.BOTTOM, fill=tk.X)
+        vs.pack(side=tk.RIGHT, fill=tk.Y)
+        self.canvas.pack(fill=tk.BOTH, expand=True)
+
+        self.status_var = tk.StringVar(value="Enter grid dimensions and click Build.")
+        tk.Label(right, textvariable=self.status_var,
+                 bg=T["panel2"], fg=T["muted"],
+                 font=("Courier", 9), anchor=tk.W, padx=10, pady=5
+                 ).pack(fill=tk.X, side=tk.BOTTOM)
+
+    def _lbl(self, p, text, fg=None, size=9, bold=False):
+        tk.Label(p, text=text, bg=T["panel"],
+                 fg=fg or T["muted"],
+                 font=("Courier", size, "bold" if bold else "normal"),
+                 anchor=tk.W).pack(fill=tk.X, padx=12, pady=(2, 0))
+
+    def _sep(self, p):
+        tk.Frame(p, bg=T["border"], height=1).pack(fill=tk.X, pady=5)
+
+    def _btn(self, p, text, cmd, bg, fg=None, pady=6):
+        tk.Button(p, text=text, font=("Courier", 9, "bold"),
+                  bg=bg, fg=fg or T["bg"], relief=tk.FLAT,
+                  activebackground=bg, activeforeground=fg or T["bg"],
+                  command=cmd, cursor="hand2", pady=pady
+                  ).pack(fill=tk.X, padx=12, pady=3)
+
+    def _build_panel(self):
+        p = self.left
+        tk.Label(p, text="CHIP ROUTER", bg=T["panel"], fg=T["accent"],
+                 font=("Courier", 12, "bold")).pack(pady=(16, 1))
+        tk.Label(p, text="cuOpt order  ·  A* octilinear paths",
+                 bg=T["panel"], fg=T["muted"], font=("Courier", 7)).pack(pady=(0, 10))
+        self._sep(p)
+
+        # ① Grid
+        self._lbl(p, "① GRID SIZE", T["text"], 9, True)
+        gf = tk.Frame(p, bg=T["panel"]);
+        gf.pack(fill=tk.X, padx=12, pady=4)
+        for row_i, (lbl, var_name, default) in enumerate(
+                [("Rows", "rows_var", 6), ("Cols", "cols_var", 8)]):
+            tk.Label(gf, text=lbl, bg=T["panel"], fg=T["muted"],
+                     font=("Courier", 8)).grid(row=row_i, column=0, sticky=tk.W, pady=2)
+            v = tk.IntVar(value=default)
+            setattr(self, var_name, v)
+            tk.Spinbox(gf, from_=2, to=20, textvariable=v, width=5,
+                       bg=T["cell_empty"], fg=T["text"], relief=tk.FLAT,
+                       insertbackground=T["text"], buttonbackground=T["border"]
+                       ).grid(row=row_i, column=1, padx=8, pady=2)
+        self._btn(p, "▶  BUILD GRID", self._on_build, T["accent"])
+
+        self._sep(p)
+
+        # ② Components
+        self._lbl(p, "② PLACE COMPONENTS", T["text"], 9, True)
+        self._lbl(p, "Click cell → type name → Place")
+        ef = tk.Frame(p, bg=T["panel"]);
+        ef.pack(fill=tk.X, padx=12, pady=4)
+        tk.Label(ef, text="Name:", bg=T["panel"], fg=T["muted"],
+                 font=("Courier", 8)).pack(side=tk.LEFT)
+        self.comp_var = tk.StringVar()
+        self.comp_entry = tk.Entry(ef, textvariable=self.comp_var, width=13,
+                                   bg=T["cell_empty"], fg=T["text"], relief=tk.FLAT,
+                                   insertbackground=T["text"], font=("Courier", 9))
+        self.comp_entry.pack(side=tk.LEFT, padx=(4, 0))
+        self.comp_entry.bind("<Return>", lambda _: self._on_place())
+        bf = tk.Frame(p, bg=T["panel"]);
+        bf.pack(fill=tk.X, padx=12, pady=(0, 4))
+        for txt, cmd, col in [("Place", self._on_place, T["ok"]),
+                              ("Clear", self._on_clear, T["danger"])]:
+            tk.Button(bf, text=txt, font=("Courier", 8), bg=col, fg=T["bg"],
+                      relief=tk.FLAT, command=cmd, cursor="hand2",
+                      padx=8, pady=2).pack(side=tk.LEFT, padx=(0, 4))
+        self.sel_lbl = tk.Label(p, text="No cell selected",
+                                bg=T["panel"], fg=T["muted"],
+                                font=("Courier", 7), anchor=tk.W)
+        self.sel_lbl.pack(fill=tk.X, padx=12)
+
+        self._sep(p)
+
+        # ③ Pairs
+        self._lbl(p, "③ WIRE PAIRS", T["text"], 9, True)
+        self._lbl(p, "Toggle mode → click src → click sink")
+        self.pair_btn = tk.Button(
+            p, text="⛓  ENTER PAIR MODE",
+            font=("Courier", 8, "bold"),
+            bg=T["cell_empty"], fg=T["accent2"], relief=tk.FLAT,
+            activebackground=T["border"], activeforeground=T["accent2"],
+            command=self._toggle_pair, cursor="hand2", pady=4)
+        self.pair_btn.pack(fill=tk.X, padx=12, pady=4)
+        self.pair_hint = tk.Label(p, text="", bg=T["panel"], fg=T["warn"],
+                                  font=("Courier", 7), anchor=tk.W)
+        self.pair_hint.pack(fill=tk.X, padx=12)
+        self.pair_list_frame = tk.Frame(p, bg=T["panel"])
+        self.pair_list_frame.pack(fill=tk.X, padx=12, pady=4)
+
+        self._sep(p)
+
+        # ④ Route
+        self._lbl(p, "④ ROUTE", T["text"], 9, True)
+        self._btn(p, "⚡  RUN CUOPT + A*", self._on_run, T["accent2"])
+        self._btn(p, "↺  RESET", self._on_reset, T["muted"])
+
+        self._sep(p)
+        self._lbl(p, "LEGEND", T["muted"], 7, True)
+        for label, color in [
+            ("Orthogonal wire (90°)", T["accent"]),
+            ("Diagonal wire  (45°)", T["ok"]),
+            ("Via / bend point", T["warn"]),
+            ("Component cell", T["cell_comp"]),
+            ("Depot / origin", T["cell_depot"]),
+        ]:
+            lf = tk.Frame(p, bg=T["panel"]);
+            lf.pack(fill=tk.X, padx=12, pady=1)
+            tk.Canvas(lf, width=10, height=10, bg=color, highlightthickness=0
+                      ).pack(side=tk.LEFT)
+            tk.Label(lf, text=f" {label}", bg=T["panel"], fg=T["muted"],
+                     font=("Courier", 7)).pack(side=tk.LEFT)
+
+    # ── Grid draw ─────────────────────────────────────────────────────────────
+
+    def _render_grid(self):
+        self.canvas.delete("all")
+        self.cell_items = {}
+
+        tw = self.cols * CELL_W + GPAD * 2
+        th = self.rows * CELL_H + GPAD * 2
+        self.canvas.config(scrollregion=(0, 0, tw, th))
+
+        for r in range(self.rows):
+            for c in range(self.cols):
+                n = r * self.cols + c
+                x0 = GPAD + c * CELL_W
+                y0 = GPAD + r * CELL_H
+                x1 = x0 + CELL_W - 1
+                y1 = y0 + CELL_H - 1
+                cx = (x0 + x1) / 2
+                cy = (y0 + y1) / 2
+
+                col = self._cell_bg(n)
+                rid = self.canvas.create_rectangle(
+                    x0, y0, x1, y1, fill=col, outline=T["border"],
+                    width=1, tags=(f"c{n}", "cell"))
+
+                lbl = "DEPOT" if n == 0 else self.components.get(n, "")
+                lclr = T["accent2"] if n == 0 else (T["accent"] if lbl else T["muted"])
+                tid = self.canvas.create_text(
+                    cx, cy - 3, text=lbl,
+                    fill=lclr, font=("Courier", 8, "bold"),
+                    width=CELL_W - 6, anchor=tk.CENTER, tags=(f"c{n}",))
+
+                cid = self.canvas.create_text(
+                    x1 - 3, y1 - 3, text=f"{r},{c}",
+                    fill=T["muted"], font=("Courier", 6),
+                    anchor=tk.SE, tags=(f"c{n}",))
+
+                self.cell_items[n] = (rid, tid, cid)
+
+                for item in (rid, tid, cid):
+                    self.canvas.tag_bind(item, "<Button-1>",
+                                         lambda e, nd=n: self._click(nd))
+                    self.canvas.tag_bind(item, "<Enter>",
+                                         lambda e, nd=n: self._hover(nd, True))
+                    self.canvas.tag_bind(item, "<Leave>",
+                                         lambda e, nd=n: self._hover(nd, False))
+
+        self._redraw_routes()
+
+    def _cell_bg(self, n):
+        if n == 0:               return T["cell_depot"]
+        if n == self.pair_src:   return "#1a3040"
+        if n == self.sel_cell:   return T["cell_sel"]
+        if n in self.components: return T["cell_comp"]
+        return T["cell_empty"]
+
+    def _recolor(self, n):
+        if n in self.cell_items:
+            self.canvas.itemconfig(self.cell_items[n][0], fill=self._cell_bg(n))
+
+    def _hover(self, n, on):
+        if n not in self.cell_items:
+            return
+        cur = self.canvas.itemcget(self.cell_items[n][0], "fill")
+        if on and cur == T["cell_empty"]:
+            self.canvas.itemconfig(self.cell_items[n][0], fill=T["cell_hover"])
+        else:
+            self._recolor(n)
+
+    # ── Route drawing — the key visual part ───────────────────────────────────
+
+    def _redraw_routes(self):
+        self.canvas.delete("route")
+        self.canvas.delete("via")
+
+        for i, p in enumerate(self.pairs):
+            name = p["name"]
+            color = self.net_colors.get(name, NET_COLORS[i % len(NET_COLORS)])
+            path = self.routes.get(name)
+
+            if path and len(path) >= 2:
+                # Draw each hop as a line segment
+                for seg in range(len(path) - 1):
+                    r1, c1 = path[seg]
+                    r2, c2 = path[seg + 1]
+                    dr = r2 - r1
+                    dc = c2 - c1
+                    is45 = abs(dr) == 1 and abs(dc) == 1
+
+                    px1 = GPAD + c1 * CELL_W + CELL_W // 2
+                    py1 = GPAD + r1 * CELL_H + CELL_H // 2
+                    px2 = GPAD + c2 * CELL_W + CELL_W // 2
+                    py2 = GPAD + r2 * CELL_H + CELL_H // 2
+
+                    # Solid for 90°, short-dash for 45°
+                    dash = (5, 2) if is45 else ()
+                    self.canvas.create_line(
+                        px1, py1, px2, py2,
+                        fill=color, width=3, dash=dash,
+                        capstyle=tk.ROUND, joinstyle=tk.ROUND,
+                        tags="route")
+
+                # Via dots at every direction change (bend)
+                for seg in range(1, len(path) - 1):
+                    r0, c0 = path[seg - 1]
+                    r1, c1 = path[seg]
+                    r2, c2 = path[seg + 1]
+                    if (r1 - r0, c1 - c0) != (r2 - r1, c2 - c1):
+                        vx = GPAD + c1 * CELL_W + CELL_W // 2
+                        vy = GPAD + r1 * CELL_H + CELL_H // 2
+                        self.canvas.create_oval(
+                            vx - 5, vy - 5, vx + 5, vy + 5,
+                            fill=T["warn"], outline=T["bg"], width=1,
+                            tags="via")
+
+                # Source terminal (large filled circle)
+                sr0, sc0 = path[0]
+                sx = GPAD + sc0 * CELL_W + CELL_W // 2
+                sy = GPAD + sr0 * CELL_H + CELL_H // 2
+                self.canvas.create_oval(sx - 6, sy - 6, sx + 6, sy + 6,
+                                        fill=color, outline=T["bg"], width=1,
+                                        tags="via")
+
+                # Sink terminal
+                er0, ec0 = path[-1]
+                ex = GPAD + ec0 * CELL_W + CELL_W // 2
+                ey = GPAD + er0 * CELL_H + CELL_H // 2
+                self.canvas.create_oval(ex - 6, ey - 6, ex + 6, ey + 6,
+                                        fill=color, outline=T["bg"], width=1,
+                                        tags="via")
+                # Arrow head at sink to show direction
+                self.canvas.create_oval(ex - 3, ey - 3, ex + 3, ey + 3,
+                                        fill=T["bg"], outline="",
+                                        tags="via")
+
+                # Net label at midpoint
+                mid = len(path) // 2
+                mr, mc = path[mid]
+                mx = GPAD + mc * CELL_W + CELL_W // 2
+                my = GPAD + mr * CELL_H + CELL_H // 2
+                self.canvas.create_text(mx, my - 10, text=name,
+                                        fill=color, font=("Courier", 7, "bold"),
+                                        tags="route")
+
+            else:
+                # No routed path yet — draw a dashed preview arrow
+                sr, sc = divmod(p["src"], self.cols)
+                dr_, dc_ = divmod(p["sink"], self.cols)
+                sx = GPAD + sc * CELL_W + CELL_W // 2
+                sy = GPAD + sr * CELL_H + CELL_H // 2
+                dx = GPAD + dc_ * CELL_W + CELL_W // 2
+                dy = GPAD + dr_ * CELL_H + CELL_H // 2
+                self.canvas.create_line(
+                    sx, sy, dx, dy,
+                    fill=color, width=1, dash=(3, 4),
+                    arrow=tk.LAST, arrowshape=(7, 9, 3),
+                    tags="route")
+                mx_, my_ = (sx + dx) / 2, (sy + dy) / 2
+                self.canvas.create_text(mx_, my_ - 7, text=name,
+                                        fill=color, font=("Courier", 7),
+                                        tags="route")
+
+        self.canvas.tag_raise("route")
+        self.canvas.tag_raise("via")
+
+    # ── Cell click ────────────────────────────────────────────────────────────
+
+    def _click(self, n):
+        if self.mode == "edit":
+            if self.sel_cell is not None:
+                self._recolor(self.sel_cell)
+            self.sel_cell = n
+            self._recolor(n)
+            r, c = divmod(n, self.cols)
+            nm = self.components.get(n, "")
+            self.comp_var.set(nm)
+            self.comp_entry.focus_set()
+            if n == 0:
+                self.sel_lbl.config(text=f"({r},{c}) — depot/origin")
+            else:
+                self.sel_lbl.config(text=f"({r},{c}) · {nm or 'unnamed'}")
+            self._set_status(f"Selected ({r},{c}). Type name + Enter to place.")
+
+        elif self.mode == "pair":
+            if self.pair_src is None:
+                self.pair_src = n
+                self._recolor(n)
+                r, c = divmod(n, self.cols)
+                nm = self.components.get(n, "DEPOT" if n == 0 else f"node{n}")
+                self.pair_hint.config(text=f"Src: {nm} ({r},{c}) → now pick sink")
+            else:
+                if n == self.pair_src:
+                    self._recolor(n)
+                    self.pair_src = None
+                    self.pair_hint.config(text="Cleared. Pick source again.")
+                    return
+                def_name = f"NET{len(self.pairs)}"
+                net_name = simpledialog.askstring(
+                    "Net name", "Name for this wire connection:",
+                    initialvalue=def_name, parent=self)
+                if not net_name:
+                    net_name = def_name
+                net_name = net_name.strip().upper().replace(" ", "_")
+                src_name = self.components.get(self.pair_src,
+                                               "DEPOT" if self.pair_src == 0 else f"N{self.pair_src}")
+                sink_name = self.components.get(n,
+                                                "DEPOT" if n == 0 else f"N{n}")
+                ci = len(self.pairs) % len(NET_COLORS)
+                self.net_colors[net_name] = NET_COLORS[ci]
+                self.pairs.append({"name": net_name, "src": self.pair_src,
+                                   "sink": n, "src_name": src_name,
+                                   "sink_name": sink_name})
+                prev = self.pair_src
+                self.pair_src = None
+                self._recolor(prev)
+                self.pair_hint.config(text=f"'{net_name}' added. Pick next src →")
+                self._refresh_pairs()
+                self._redraw_routes()
+                self._set_status(f"Pair '{net_name}' added ({len(self.pairs)} total).")
+
+    # ── Component actions ─────────────────────────────────────────────────────
+
+    def _on_place(self):
+        if self.sel_cell is None or self.sel_cell == 0:
+            self._set_status("Select a non-depot cell first.")
+            return
+        name = self.comp_var.get().strip()
+        if not name:
+            self._set_status("Enter a component name.")
+            return
+        self.components[self.sel_cell] = name
+        if self.sel_cell in self.cell_items:
+            self.canvas.itemconfig(self.cell_items[self.sel_cell][1],
+                                   text=name, fill=T["accent"])
+            self._recolor(self.sel_cell)
+        r, c = divmod(self.sel_cell, self.cols)
+        self._set_status(f"Placed '{name}' at ({r},{c}).")
+        for p in self.pairs:
+            if p["src"] == self.sel_cell: p["src_name"] = name
+            if p["sink"] == self.sel_cell: p["sink_name"] = name
+        self._refresh_pairs()
+
+    def _on_clear(self):
+        if self.sel_cell is None or self.sel_cell == 0:
+            return
+        self.components.pop(self.sel_cell, None)
+        if self.sel_cell in self.cell_items:
+            self.canvas.itemconfig(self.cell_items[self.sel_cell][1], text="")
+            self._recolor(self.sel_cell)
+        self.comp_var.set("")
+
+    # ── Pair mode ─────────────────────────────────────────────────────────────
+
+    def _toggle_pair(self):
+        if not self.rows:
+            self._set_status("Build a grid first.")
+            return
+        if self.mode == "edit":
+            self.mode = "pair"
+            self.pair_btn.config(text="✕  EXIT PAIR MODE",
+                                 bg=T["accent2"], fg=T["bg"])
+            self.pair_hint.config(text="Click a source cell →")
+            self._set_status("Pair mode: click source, then sink to add a wire pair.")
+        else:
+            self.mode = "edit"
+            if self.pair_src is not None:
+                self._recolor(self.pair_src)
+            self.pair_src = None
+            self.pair_btn.config(text="⛓  ENTER PAIR MODE",
+                                 bg=T["cell_empty"], fg=T["accent2"])
+            self.pair_hint.config(text="")
+            self._set_status("Edit mode.")
+
+    def _refresh_pairs(self):
+        for w in self.pair_list_frame.winfo_children():
+            w.destroy()
+        for i, p in enumerate(self.pairs):
+            color = self.net_colors.get(p["name"], NET_COLORS[i % len(NET_COLORS)])
+            row = tk.Frame(self.pair_list_frame, bg=T["panel2"])
+            row.pack(fill=tk.X, pady=1)
+            tk.Canvas(row, width=8, height=8, bg=color, highlightthickness=0
+                      ).pack(side=tk.LEFT, padx=(4, 3), pady=3)
+            tk.Label(row,
+                     text=f"{p['name']}: {p['src_name']} → {p['sink_name']}",
+                     bg=T["panel2"], fg=T["text"],
+                     font=("Courier", 7), anchor=tk.W
+                     ).pack(side=tk.LEFT, fill=tk.X, expand=True)
+            tk.Button(row, text="✕", bg=T["panel2"], fg=T["danger"],
+                      font=("Courier", 7), relief=tk.FLAT, cursor="hand2",
+                      command=lambda idx=i: self._remove_pair(idx)
+                      ).pack(side=tk.RIGHT, padx=2)
+
+    def _remove_pair(self, idx):
+        if 0 <= idx < len(self.pairs):
+            name = self.pairs[idx]["name"]
+            self.pairs.pop(idx)
+            self.routes.pop(name, None)
+            self._refresh_pairs()
+            self._redraw_routes()
+
+    # ── Run routing ───────────────────────────────────────────────────────────
+
+    def _on_run(self):
+        if not self.rows:
+            messagebox.showerror("No grid", "Build a grid first.")
+            return
+        if not self.pairs:
+            messagebox.showerror("No pairs", "Add at least one wire pair.")
+            return
+
+        self._set_status("Sending net list to NVIDIA cuOpt to optimise routing order…")
+        self.update()
+
+        try:
+            order, cuopt_body = cuopt_net_order(self.rows, self.cols, self.pairs)
+        except Exception as e:
+            self._set_status(f"cuOpt error: {e}  — falling back to greedy order.")
+            order = list(range(len(self.pairs)))
+            cuopt_body = {}
+
+        self._set_status(
+            f"Running A* octilinear router for {len(self.pairs)} nets…")
+        self.update()
+
+        self.routes = route_all_nets(
+            self.pairs, self.rows, self.cols, self.components, order=order)
+
+        self._render_grid()
+
+        routed = sum(1 for v in self.routes.values() if v)
+        self._set_status(
+            f"Done. {routed}/{len(self.pairs)} nets routed. "
+            f"Solid = 90°, dashed = 45°, yellow dot = via/bend.")
+
+        self._show_result_popup()
+
+    def _show_result_popup(self):
+        win = tk.Toplevel(self)
+        win.title("Routing Results")
+        win.configure(bg=T["bg"])
+        win.geometry("580x460")
+
+        tk.Label(win, text="ROUTING RESULTS", bg=T["bg"], fg=T["accent"],
+                 font=("Courier", 11, "bold")).pack(pady=(14, 6))
+
+        frm = tk.Frame(win, bg=T["bg"])
+        frm.pack(fill=tk.BOTH, expand=True, padx=14)
+        sb = tk.Scrollbar(frm);
+        sb.pack(side=tk.RIGHT, fill=tk.Y)
+        txt = tk.Text(frm, bg=T["panel"], fg=T["text"], font=("Courier", 8),
+                      relief=tk.FLAT, yscrollcommand=sb.set)
+        txt.pack(fill=tk.BOTH, expand=True)
+        sb.config(command=txt.yview)
+
+        total = 0
+        for i, p in enumerate(self.pairs):
+            path = self.routes.get(p["name"], [])
+            wire_len = len(path) - 1 if path else 0
+            total += wire_len
+
+            # count bends
+            bends = 0
+            for seg in range(1, len(path) - 1):
+                r0, c0 = path[seg - 1]
+                r1, c1 = path[seg]
+                r2, c2 = path[seg + 1]
+                if (r1 - r0, c1 - c0) != (r2 - r1, c2 - c1):
+                    bends += 1
+
+            # count 45° hops
+            diag45 = sum(
+                1 for s in range(len(path) - 1)
+                if abs(path[s][0] - path[s + 1][0]) == 1
+                and abs(path[s][1] - path[s + 1][1]) == 1
+            )
+            ortho = wire_len - diag45
+
+            status = "ROUTED  " if path else "UNROUTED"
+            src_rc = divmod(p["src"], self.cols)
+            sink_rc = divmod(p["sink"], self.cols)
+            line = (
+                f"[{status}] {p['name']:<12}  "
+                f"{p['src_name']:<10} ({src_rc[0]},{src_rc[1]}) "
+                f"→ {p['sink_name']:<10} ({sink_rc[0]},{sink_rc[1]})\n"
+                f"          wire: {wire_len} hops "
+                f"({ortho} ortho + {diag45} diag)   "
+                f"bends: {bends}\n\n"
+            )
+            txt.insert(tk.END, line)
+
+        txt.insert(tk.END, f"Total wire length : {total} hops\n")
+        txt.config(state=tk.DISABLED)
+
+        tk.Button(win, text="Close", bg=T["accent"], fg=T["bg"],
+                  font=("Courier", 9, "bold"), relief=tk.FLAT,
+                  command=win.destroy, cursor="hand2", pady=6
+                  ).pack(pady=(8, 14))
+
+    # ── Build / Reset ─────────────────────────────────────────────────────────
+
+    def _on_build(self):
+        self.rows = max(2, min(20, self.rows_var.get()))
+        self.cols = max(2, min(20, self.cols_var.get()))
+        self.components = {}
+        self.pairs = []
+        self.routes = {}
+        self.net_colors = {}
+        self.sel_cell = None
+        self.pair_src = None
+        self.mode = "edit"
+        self.pair_btn.config(text="⛓  ENTER PAIR MODE",
+                             bg=T["cell_empty"], fg=T["accent2"])
+        self.pair_hint.config(text="")
+        self.sel_lbl.config(text="No cell selected")
+        self.comp_var.set("")
+        self._render_grid()
+        self._refresh_pairs()
+        self._set_status(
+            f"Grid {self.rows}×{self.cols} ready. "
+            "Click cells to place components.")
+
+    def _on_reset(self):
+        self.components = {}
+        self.pairs = []
+        self.routes = {}
+        self.net_colors = {}
+        self.sel_cell = None
+        self.pair_src = None
+        self.mode = "edit"
+        self.pair_btn.config(text="⛓  ENTER PAIR MODE",
+                             bg=T["cell_empty"], fg=T["accent2"])
+        self.pair_hint.config(text="")
+        self.sel_lbl.config(text="No cell selected")
+        self.comp_var.set("")
+        if self.rows:
+            self._render_grid()
+        self._refresh_pairs()
+        self._set_status("Reset. Place components and create wire pairs.")
+
+    def _set_status(self, msg):
+        self.status_var.set(f"  {msg}")
+
+
+# ─── Entry ────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    App().mainloop()

client.py

@@ -0,0 +1,262 @@
+import requests
+import API
+invoke_url = "https://optimize.api.nvidia.com/v1/nvidia/cuopt"
+fetch_url_format = "https://optimize.api.nvidia.com/v1/status/"
+
+API = API.API()
+headers = {
+    "Authorization": f"Bearer {API}",
+    "Accept": "application/json",
+}
+
+payload = {
+  "action": "cuOpt_OptimizedRouting",
+  "data": {
+    "cost_waypoint_graph_data": None,
+    "travel_time_waypoint_graph_data": None,
+    "cost_matrix_data": {
+      "data": {
+        "1": [
+          [
+            0,
+            1,
+            1
+          ],
+          [
+            1,
+            0,
+            1
+          ],
+          [
+            1,
+            1,
+            0
+          ]
+        ],
+        "2": [
+          [
+            0,
+            1,
+            1
+          ],
+          [
+            1,
+            0,
+            1
+          ],
+          [
+            1,
+            2,
+            0
+          ]
+        ]
+      }
+    },
+    "travel_time_matrix_data": {
+      "data": {
+        "1": [
+          [
+            0,
+            1,
+            1
+          ],
+          [
+            1,
+            0,
+            1
+          ],
+          [
+            1,
+            1,
+            0
+          ]
+        ],
+        "2": [
+          [
+            0,
+            1,
+            1
+          ],
+          [
+            1,
+            0,
+            1
+          ],
+          [
+            1,
+            2,
+            0
+          ]
+        ]
+      }
+    },
+    "fleet_data": {
+      "vehicle_locations": [
+        [
+          0,
+          0
+        ],
+        [
+          0,
+          0
+        ]
+      ],
+      "vehicle_ids": [
+        "veh-1",
+        "veh-2"
+      ],
+      "capacities": [
+        [
+          2,
+          2
+        ],
+        [
+          4,
+          1
+        ]
+      ],
+      "vehicle_time_windows": [
+        [
+          0,
+          10
+        ],
+        [
+          0,
+          10
+        ]
+      ],
+      "vehicle_break_time_windows": [
+        [
+          [
+            1,
+            2
+          ],
+          [
+            2,
+            3
+          ]
+        ]
+      ],
+      "vehicle_break_durations": [
+        [
+          1,
+          1
+        ]
+      ],
+      "vehicle_break_locations": [
+        0,
+        1
+      ],
+      "vehicle_types": [
+        1,
+        2
+      ],
+      "vehicle_order_match": [
+        {
+          "order_ids": [
+            0
+          ],
+          "vehicle_id": 0
+        },
+        {
+          "order_ids": [
+            1
+          ],
+          "vehicle_id": 1
+        }
+      ],
+      "skip_first_trips": [
+        True,
+        False
+      ],
+      "drop_return_trips": [
+        True,
+        False
+      ],
+      "min_vehicles": 2,
+      "vehicle_max_costs": [
+        7,
+        10
+      ],
+      "vehicle_max_times": [
+        7,
+        10
+      ]
+    },
+    "task_data": {
+      "task_locations": [
+        1,
+        2
+      ],
+      "task_ids": [
+        "Task-A",
+        "Task-B"
+      ],
+      "demand": [
+        [
+          1,
+          1
+        ],
+        [
+          3,
+          1
+        ]
+      ],
+      "task_time_windows": [
+        [
+          0,
+          5
+        ],
+        [
+          3,
+          9
+        ]
+      ],
+      "service_times": [
+        0,
+        0
+      ],
+      "order_vehicle_match": [
+        {
+          "order_id": 0,
+          "vehicle_ids": [
+            0
+          ]
+        },
+        {
+          "order_id": 1,
+          "vehicle_ids": [
+            1
+          ]
+        }
+      ]
+    },
+    "solver_config": {
+      "time_limit": 1,
+      "objectives": {
+        "cost": 1,
+        "travel_time": 0,
+        "variance_route_size": 0,
+        "variance_route_service_time": 0,
+        "prize": 0
+      },
+      "verbose_mode": False,
+      "error_logging": True
+    }
+  },
+  "client_version": ""
+}
+
+# re-use connections
+session = requests.Session()
+
+response = session.post(invoke_url, headers=headers, json=payload)
+
+while response.status_code == 202:
+    request_id = response.headers.get("NVCF-REQID")
+    fetch_url = fetch_url_format + request_id
+    response = session.get(fetch_url, headers=headers)
+
+response.raise_for_status()
+response_body = response.json()
+print(response_body)

requirements.txt

@@ -0,0 +1,3 @@
+requests~=2.33.1
+fastapi~=0.136.1
+uvicorn[standard]

requirenments.txt

@@ -0,0 +1 @@
+requests>=2.28.0