inire/examples/07_large_scale_routing.py

import time

from shapely.geometry import box

from inire import (
    NetSpec,
    Port,
    RoutingProblem,
    RoutingResult,
)
from inire.router._stack import build_routing_stack
from inire.utils.visualization import plot_expanded_nodes, plot_routing_results


def main() -> None:
    print("Running Example 07: Fan-Out (10 Nets, 50um Radius)...")

    bounds = (0, 0, 1000, 1000)
    obstacles = [
        box(450, 0, 550, 400),
        box(450, 600, 550, 1000),
    ]

    num_nets = 10
    start_x = 50
    start_y_base = 500 - (num_nets * 10.0) / 2.0
    end_x = 950
    end_y_base = 100
    end_y_pitch = 800.0 / (num_nets - 1)

    netlist: dict[str, tuple[Port, Port]] = {}
    for index in range(num_nets):
        start_y = int(round(start_y_base + index * 10.0))
        end_y = int(round(end_y_base + index * end_y_pitch))
        netlist[f"net_{index:02d}"] = (Port(start_x, start_y, 0), Port(end_x, end_y, 0))

    problem = RoutingProblem(
        bounds=bounds,
        nets=tuple(NetSpec(net_id, start, target, width=2.0) for net_id, (start, target) in netlist.items()),
        static_obstacles=tuple(obstacles),
        clearance=6.0,
    )
    from inire import CongestionOptions, DiagnosticsOptions, ObjectiveWeights, RoutingOptions, SearchOptions

    options = RoutingOptions(
        search=SearchOptions(
            node_limit=2_000_000,
            bend_radii=(50.0,),
            sbend_radii=(50.0,),
            greedy_h_weight=1.5,
            bend_clip_margin=10.0,
        ),
        objective=ObjectiveWeights(
            unit_length_cost=0.1,
            bend_penalty=100.0,
            sbend_penalty=400.0,
        ),
        congestion=CongestionOptions(
            max_iterations=15,
            base_penalty=100.0,
            multiplier=1.4,
            net_order="shortest",
            shuffle_nets=True,
            seed=42,
        ),
        diagnostics=DiagnosticsOptions(capture_expanded=True),
    )
    stack = build_routing_stack(problem, options)
    evaluator = stack.evaluator
    finder = stack.finder
    metrics = finder.metrics

    iteration_stats: list[dict[str, int]] = []

    def iteration_callback(iteration: int, current_results: dict[str, RoutingResult]) -> None:
        successes = sum(1 for result in current_results.values() if result.is_valid)
        total_collisions = sum(result.collisions for result in current_results.values())
        total_nodes = metrics.nodes_expanded
        print(f"  Iteration {iteration} finished. Successes: {successes}/{len(netlist)}, Collisions: {total_collisions}")
        new_greedy = max(1.1, 1.5 - ((iteration + 1) / 10.0) * 0.4)
        evaluator.greedy_h_weight = new_greedy
        print(f"  Adaptive Greedy Weight for Next Iteration: {new_greedy:.3f}")
        iteration_stats.append(
            {
                "Iteration": iteration,
                "Success": successes,
                "Congestion": total_collisions,
                "Nodes": total_nodes,
            }
        )
        metrics.reset_per_route()

    print(f"Routing {len(netlist)} nets through 200um bottleneck...")
    start_time = time.perf_counter()
    results = finder.route_all(iteration_callback=iteration_callback)
    end_time = time.perf_counter()

    print(f"Routing took {end_time - start_time:.4f}s")
    print("\n--- Iteration Summary ---")
    print(f"{'Iter':<5} | {'Success':<8} | {'Congest':<8} | {'Nodes':<10}")
    print("-" * 43)
    for stats in iteration_stats:
        print(f"{stats['Iteration']:<5} | {stats['Success']:<8} | {stats['Congestion']:<8} | {stats['Nodes']:<10}")

    success_count = sum(1 for result in results.values() if result.is_valid)
    print(f"\nFinal: Routed {success_count}/{len(netlist)} nets successfully.")
    for net_id, result in results.items():
        if not result.is_valid:
            print(f"  FAILED: {net_id}, collisions={result.collisions}")
        else:
            print(f"  {net_id}: SUCCESS")

    fig, ax = plot_routing_results(results, list(obstacles), bounds, netlist=netlist)
    plot_expanded_nodes(list(finder.accumulated_expanded_nodes), ax=ax)
    fig.savefig("examples/07_large_scale_routing.png")
    print("Saved plot to examples/07_large_scale_routing.png")


if __name__ == "__main__":
    main()