ex07 works

examples/07_large_scale_routing.py

@@ -6,7 +6,7 @@ from inire.router.astar import AStarRouter
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
-from inire.utils.visualization import plot_routing_results, plot_danger_map, plot_expanded_nodes
+from inire.utils.visualization import plot_routing_results, plot_danger_map, plot_expanded_nodes, plot_expansion_density
 from shapely.geometry import box
 
 def main() -> None:
@@ -27,10 +27,10 @@ def main() -> None:
     danger_map = DangerMap(bounds=bounds)
     danger_map.precompute(obstacles)
 
-    evaluator = CostEvaluator(engine, danger_map, greedy_h_weight=1.5, unit_length_cost=0.5, bend_penalty=100.0, sbend_penalty=200.0, congestion_penalty=100.0)
+    evaluator = CostEvaluator(engine, danger_map, greedy_h_weight=2.0, unit_length_cost=0.1, bend_penalty=100.0, sbend_penalty=200.0, congestion_penalty=20.0)
 
-    router = AStarRouter(evaluator, node_limit=1000000, snap_size=5.0)
-    pf = PathFinder(router, evaluator, max_iterations=10, base_congestion_penalty=100.0)
+    router = AStarRouter(evaluator, node_limit=2000000, snap_size=5.0, bend_radii=[50.0], sbend_radii=[50.0], use_analytical_sbends=False)
+    pf = PathFinder(router, evaluator, max_iterations=50, base_congestion_penalty=20.0, congestion_multiplier=1.2)
 
     # 2. Define Netlist
     netlist = {}
@@ -49,36 +49,115 @@ def main() -> None:
 
     net_widths = {nid: 2.0 for nid in netlist}
 
-    def iteration_callback(idx, current_results):
-        print(f"  Iteration {idx} finished. Successes: {sum(1 for r in current_results.values() if r.is_valid)}/{len(netlist)}")
-        print(pf.router.get_metrics_summary())
-        pf.router.reset_metrics()
-        # fig, ax = plot_routing_results(current_results, obstacles, bounds, netlist=netlist)
-        # plot_danger_map(danger_map, ax=ax)
-        # fig.savefig(f"examples/07_iteration_{idx:02d}.png")
-        # import matplotlib.pyplot as plt
-        # plt.close(fig)
-
     # 3. Route
     print(f"Routing {len(netlist)} nets through 200um bottleneck...")
+    
+    iteration_stats = []
+
+    def iteration_callback(idx, current_results):
+        successes = sum(1 for r in current_results.values() if r.is_valid)
+        total_collisions = sum(r.collisions for r in current_results.values())
+        total_nodes = pf.router.metrics['nodes_expanded']
+        
+        # Identify Hotspots
+        hotspots = {}
+        overlap_matrix = {} # (net_a, net_b) -> count
+        
+        for nid, res in current_results.items():
+            if res.path:
+                for comp in res.path:
+                    for poly in comp.geometry:
+                        # Check what it overlaps with
+                        overlaps = engine.dynamic_index.intersection(poly.bounds)
+                        for other_obj_id in overlaps:
+                            other_nid, other_poly = engine.dynamic_geometries[other_obj_id]
+                            if other_nid != nid:
+                                if poly.intersects(other_poly):
+                                    # Record hotspot
+                                    cx, cy = poly.centroid.x, poly.centroid.y
+                                    grid_key = (int(cx/20)*20, int(cy/20)*20)
+                                    hotspots[grid_key] = hotspots.get(grid_key, 0) + 1
+                                    
+                                    # Record pair
+                                    pair = tuple(sorted((nid, other_nid)))
+                                    overlap_matrix[pair] = overlap_matrix.get(pair, 0) + 1
+
+        print(f"  Iteration {idx} finished. Successes: {successes}/{len(netlist)}, Collisions: {total_collisions}")
+        if overlap_matrix:
+            top_pairs = sorted(overlap_matrix.items(), key=lambda x: x[1], reverse=True)[:3]
+            print(f"  Top Conflicts: {top_pairs}")
+        if hotspots:
+            top_hotspots = sorted(hotspots.items(), key=lambda x: x[1], reverse=True)[:3]
+            print(f"  Top Hotspots: {top_hotspots}")
+        
+        # Adaptive Greediness: Decay from 2.0 to 1.1 over 25 iterations
+        new_greedy = max(1.1, 2.0 - ((idx + 1) / 25.0))
+        evaluator.greedy_h_weight = new_greedy
+        print(f"  Adaptive Greedy Weight for Next Iteration: {new_greedy:.3f}")
+
+        iteration_stats.append({
+            'Iteration': idx,
+            'Success': successes,
+            'Congestion': total_collisions,
+            'Nodes': total_nodes
+        })
+        
+        # Save plots only for certain iterations to save time
+        if idx % 20 == 0 or idx == pf.max_iterations - 1:
+            # Save a plot of this iteration's result
+            fig, ax = plot_routing_results(current_results, obstacles, bounds, netlist=netlist)
+            plot_danger_map(danger_map, ax=ax)
+            
+            # Overlay failures: show where they stopped
+            for nid, res in current_results.items():
+                if not res.is_valid and res.path:
+                    last_p = res.path[-1].end_port
+                    target_p = netlist[nid][1]
+                    dist = abs(last_p.x - target_p.x) + abs(last_p.y - target_p.y)
+                    ax.scatter(last_p.x, last_p.y, color='red', marker='x', s=100)
+                    ax.text(last_p.x, last_p.y, f" {nid} (rem: {dist:.0f}um)", color='red', fontsize=8)
+            
+            fig.savefig(f"examples/07_iteration_{idx:02d}.png")
+            import matplotlib.pyplot as plt
+            plt.close(fig)
+
+            # Plot Expansion Density if data is available
+            if pf.accumulated_expanded_nodes:
+                 fig_d, ax_d = plot_expansion_density(pf.accumulated_expanded_nodes, bounds)
+                 fig_d.savefig(f"examples/07_iteration_{idx:02d}_density.png")
+                 plt.close(fig_d)
+        
+        pf.router.reset_metrics()
+
     import cProfile, pstats
     profiler = cProfile.Profile()
     profiler.enable()
     t0 = time.perf_counter()
-    results = pf.route_all(netlist, net_widths, store_expanded=True, iteration_callback=iteration_callback)
+    results = pf.route_all(netlist, net_widths, store_expanded=True, iteration_callback=iteration_callback, shuffle_nets=True, seed=42)
     t1 = time.perf_counter()
     profiler.disable()
+    
+    # ... (rest of the code)
     stats = pstats.Stats(profiler).sort_stats('tottime')
     stats.print_stats(20)
     print(f"Routing took {t1-t0:.4f}s")
 
     # 4. Check Results
+    print("\n--- Iteration Summary ---")
+    print(f"{'Iter':<5} | {'Success':<8} | {'Congest':<8} | {'Nodes':<10}")
+    print("-" * 40)
+    for s in iteration_stats:
+        print(f"{s['Iteration']:<5} | {s['Success']:<8} | {s['Congestion']:<8} | {s['Nodes']:<10}")
+    
     success_count = sum(1 for res in results.values() if res.is_valid)
-    print(f"Routed {success_count}/{len(netlist)} nets successfully.")
+    print(f"\nFinal: Routed {success_count}/{len(netlist)} nets successfully.")
     
     for nid, res in results.items():
+        target_p = netlist[nid][1]
         if not res.is_valid:
-            print(f"  FAILED: {nid}")
+            last_p = res.path[-1].end_port if res.path else netlist[nid][0]
+            dist = abs(last_p.x - target_p.x) + abs(last_p.y - target_p.y)
+            print(f"  FAILED: {nid} (Stopped {dist:.1f}um from target)")
         else:
             types = [move.move_type for move in res.path]
             from collections import Counter