69 lines
2.7 KiB
Markdown
69 lines
2.7 KiB
Markdown
# inire: Auto-Routing for Photonic and RF Integrated Circuits
|
|
|
|
`inire` is a high-performance auto-router designed specifically for the physical constraints of photonic and RF integrated circuits. It utilizes a Hybrid State-Lattice A* search combined with "Negotiated Congestion" (PathFinder) to route multiple nets while maintaining strict geometric fidelity and clearance.
|
|
|
|
## Key Features
|
|
|
|
* **Hybrid State-Lattice Search**: Routes using discrete 90° bends and parametric S-bends, ensuring manufacturing-stable paths.
|
|
* **Negotiated Congestion**: Iteratively resolves multi-net bottlenecks by inflating costs in high-traffic regions.
|
|
* **Analytic Correctness**: Every move is verified against an R-Tree spatial index of obstacles and other paths.
|
|
* **1nm Precision**: All coordinates and ports are snapped to a 1nm manufacturing grid.
|
|
* **Safety & Proximity**: Incorporates a "Danger Map" (pre-computed distance transform) to maintain optimal spacing and reduce crosstalk.
|
|
* **Locked Paths**: Supports treating existing geometries as fixed obstacles for incremental routing sessions.
|
|
|
|
## Installation
|
|
|
|
`inire` requires Python 3.11+. You can install the dependencies using `uv` (recommended) or `pip`:
|
|
|
|
```bash
|
|
# Using uv
|
|
uv sync
|
|
|
|
# Using pip
|
|
pip install numpy scipy shapely rtree matplotlib
|
|
```
|
|
|
|
## Quick Start
|
|
|
|
```python
|
|
from inire.geometry.primitives import Port
|
|
from inire.geometry.collision import CollisionEngine
|
|
from inire.router.danger_map import DangerMap
|
|
from inire.router.cost import CostEvaluator
|
|
from inire.router.astar import AStarRouter
|
|
from inire.router.pathfinder import PathFinder
|
|
|
|
# 1. Setup Environment
|
|
engine = CollisionEngine(clearance=2.0)
|
|
danger_map = DangerMap(bounds=(0, 0, 1000, 1000))
|
|
danger_map.precompute([]) # Add polygons here for obstacles
|
|
|
|
# 2. Configure Router
|
|
evaluator = CostEvaluator(engine, danger_map)
|
|
router = AStarRouter(evaluator)
|
|
pf = PathFinder(router, evaluator)
|
|
|
|
# 3. Define Netlist
|
|
netlist = {
|
|
"net1": (Port(0, 0, 0), Port(100, 50, 0)),
|
|
}
|
|
|
|
# 4. Route
|
|
results = pf.route_all(netlist, {"net1": 2.0})
|
|
|
|
if results["net1"].is_valid:
|
|
print("Successfully routed net1!")
|
|
```
|
|
|
|
## Architecture
|
|
|
|
`inire` operates on a **State-Lattice** defined by $(x, y, \theta)$. From any state, the router expands via three primary "Move" types:
|
|
1. **Straights**: Variable-length segments.
|
|
2. **90° Bends**: Fixed-radius PDK cells.
|
|
3. **Parametric S-Bends**: Procedural arcs for bridging small lateral offsets ($O < 2R$).
|
|
|
|
For multi-net problems, the **PathFinder** loop handles rip-up and reroute logic, ensuring that paths find the globally optimal configuration without crossings.
|
|
|
|
## License
|
|
|
|
This project is licensed under the GNU Affero General Public License v3. See `LICENSE.md` for details.
|