mxpic_router/builder.py

@@ -12,6 +12,7 @@ from .technology import apply_technology_manifest, load_technology_manifest
 ROUTE_MIN_SPACING = 10.0
 ROUTE_ENDPOINT_SPACING_IGNORE = ROUTE_MIN_SPACING * 2.0
 ROUTE_SPACING_GEOMETRY_ADJUSTMENT_ENABLED = False
+ROUTE_SBEND_GROUP_SPAN_GRID = 100.0
 
 
 def build_project_gds(
@@ -370,7 +371,7 @@ def _assign_sbend_lstart_spacing(plans: list) -> None:
     for group in groups.values():
         if len(group) < 2:
             continue
-        axis = _dominant_spacing_axis(group[0]["points"][0], group[0]["points"][-1])
+        axis = _sbend_forward_axis(group[0])
         coord_key = "y" if axis == "horizontal" else "x"
         step = _sbend_lstart_step(group)
         for plan, rank in _sbend_lstart_ranks(group, coord_key):
@@ -386,16 +387,16 @@ def _sbend_lstart_ranks(group: list, coord_key: str) -> list:
     deltas = [_route_coord_delta(plan, coord_key) for plan in group]
     nonzero_deltas = [delta for delta in deltas if abs(delta) > 1e-9]
     if nonzero_deltas and all(delta > 0 for delta in nonzero_deltas):
-        ordered = sorted(group, key=lambda plan: _route_mid_coord(plan, coord_key))
+        ordered = sorted(group, key=lambda plan: _route_start_coord(plan, coord_key), reverse=True)
-        return [(plan, len(ordered) - index) for index, plan in enumerate(ordered)]
+        return [(plan, index + 1) for index, plan in enumerate(ordered)]
     if nonzero_deltas and all(delta < 0 for delta in nonzero_deltas):
-        ordered = sorted(group, key=lambda plan: _route_mid_coord(plan, coord_key), reverse=True)
+        ordered = sorted(group, key=lambda plan: _route_start_coord(plan, coord_key), reverse=True)
         return [(plan, len(ordered) - index) for index, plan in enumerate(ordered)]
 
-    center = sum(_route_mid_coord(plan, coord_key) for plan in group) / len(group)
+    center = sum(_route_start_coord(plan, coord_key) for plan in group) / len(group)
-    distances = sorted({round(abs(_route_mid_coord(plan, coord_key) - center), 6) for plan in group})
+    distances = sorted({round(abs(_route_start_coord(plan, coord_key) - center), 6) for plan in group})
     return [
-        (plan, distances.index(round(abs(_route_mid_coord(plan, coord_key) - center), 6)) + 1)
+        (plan, distances.index(round(abs(_route_start_coord(plan, coord_key) - center), 6)) + 1)
         for plan in group
     ]
 
@@ -408,15 +409,58 @@ def _route_coord_delta(plan: dict, coord_key: str) -> float:
 
 def _sbend_spacing_group_key(plan: dict):
     link = plan["link"]
-    axis = _dominant_spacing_axis(plan["points"][0], plan["points"][-1])
+    axis = _sbend_forward_axis(plan)
+    main_key = "x" if axis == "horizontal" else "y"
+    main_delta = _route_coord_delta(plan, main_key)
+    explicit_group = _link_explicit_route_group(link)
+    if explicit_group:
+        route_scope = ("explicit", explicit_group)
+    else:
+        route_scope = (
+            "span",
+            _sbend_span_bucket(plan["points"][0][main_key]),
+            _sbend_span_bucket(plan["points"][-1][main_key]),
+        )
     return (
         axis,
+        _route_direction_sign(main_delta),
+        route_scope,
         str(link.xsection or ""),
         _safe_float(link.width, 0.0),
         _safe_float(link.radius, 0.0),
     )
 
 
+def _sbend_forward_axis(plan: dict) -> str:
+    angle = _pin_angle(plan["pin1"])
+    if angle is None:
+        angle = _pin_angle(plan["pin2"])
+    if angle is None:
+        return _dominant_spacing_axis(plan["points"][0], plan["points"][-1])
+    normalized = angle % 180
+    if abs(normalized) <= 45 or abs(normalized - 180) <= 45:
+        return "horizontal"
+    if abs(normalized - 90) <= 45:
+        return "vertical"
+    return _dominant_spacing_axis(plan["points"][0], plan["points"][-1])
+
+
+def _link_explicit_route_group(link: LinkSpec) -> str:
+    return str(getattr(link, "route_group", "") or "").strip()
+
+
+def _route_direction_sign(delta: float) -> int:
+    if delta > 1e-9:
+        return 1
+    if delta < -1e-9:
+        return -1
+    return 0
+
+
+def _sbend_span_bucket(value: float) -> int:
+    return round(float(value) / ROUTE_SBEND_GROUP_SPAN_GRID)
+
+
 def _route_group_needs_spacing(group: list) -> bool:
     check_points = [_route_spacing_check_points(plan["points"]) for plan in group]
     threshold = _sbend_lstart_step(group)
@@ -433,6 +477,10 @@ def _route_mid_coord(plan: dict, coord_key: str) -> float:
     return (float(start[coord_key]) + float(end[coord_key])) / 2.0
 
 
+def _route_start_coord(plan: dict, coord_key: str) -> float:
+    return float(plan["points"][0][coord_key])
+
+
 def _route_spacing_reference_points(link: LinkSpec, pin1, pin2) -> list:
     if len(link.points or []) >= 2:
         return _route_points_with_pin_endpoints(link.points, pin1, pin2)

mxpic_router/eda_loader.py

@@ -53,6 +53,8 @@ class LinkSpec:
     width: Optional[float] = None
     radius: Optional[float] = None
     routing_type: str = "euler_bend"
+    bundle: str = ""
+    route_group: str = ""
     points: List[Dict[str, float]] = field(default_factory=list)
 
 
@@ -150,6 +152,15 @@ def parse_cell_dict(data: dict) -> CellSpec:
                 width=_optional_float(link_data.get("width"), bundle.width),
                 radius=_optional_float(link_data.get("radius"), bundle.radius),
                 routing_type=str(link_data.get("routing_type") or bundle.routing_type),
+                bundle=bundle.name,
+                route_group=str(
+                    link_data.get("route_group")
+                    or link_data.get("routeGroup")
+                    or link_data.get("group")
+                    or link_data.get("bundle_group")
+                    or link_data.get("bundleGroup")
+                    or ""
+                ),
                 points=_points(link_data.get("points")),
             ))
         spec.bundles[bundle.name] = bundle