Manual channel routing prototype

Author: gpeairs

Project.toml

@@ -4,11 +4,13 @@ version = "1.4.2"
 
 [deps]
 Accessors = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697"
+BipartiteMatching = "79040ab4-24c8-4c92-950c-d48b5991a0f6"
 Cairo = "159f3aea-2a34-519c-b102-8c37f9878175"
 Clipper = "c8f6d549-b3ab-5508-a0d1-48fe138e8cc1"
 ColorSchemes = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
 CoordinateTransformations = "150eb455-5306-5404-9cee-2592286d6298"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"
 FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 Gmsh = "705231aa-382f-11e9-3f0c-b7cb4346fdeb"
@@ -43,6 +45,7 @@ SchematicGraphMakieExt = "GraphMakie"
 [compat]
 Accessors = "0.1"
 Aqua = "0.8"
+BipartiteMatching = "0.1.1"
 Cairo = "1.0"
 Clipper = "0.6"
 ColorSchemes = "3"

src/DeviceLayout.jl

@@ -191,7 +191,7 @@ Return the coordinate type of the geometry.
 coordinatetype(::Type{S}) where {T, S <: AbstractGeometry{T}} = T
 coordinatetype(::S) where {T, S <: AbstractGeometry{T}} = T
 coordinatetype(::AbstractArray{S}) where {T, S <: AbstractGeometry{T}} = T
-coordinatetype(iterable) = promote_type(coordinatetype.(iterable))
+coordinatetype(iterable) = promote_type(coordinatetype.(iterable)...)
 
 # Entity interface
 include("entities.jl")

src/hooks.jl

@@ -4,6 +4,7 @@
 Contains information describing how one component can attach to others.
 """
 abstract type Hook{T} <: AbstractGeometry{T} end
+getp(h::Hook) = h.p
 
 """
     PointHook(p::Point, in_direction)

src/paths/channels.jl

@@ -0,0 +1,148 @@
+"""
+    RouteChannel{T} <: AbstractComponent{T}
+    RouteChannel(pa::Path)
+"""
+struct RouteChannel{T} <: AbstractComponent{T}
+    path::Path{T}
+    node::Node{T} # path as single node
+    capacity::Int # Currently unused
+end
+
+function RouteChannel(pa::Path{T}, capacity=0) where {T}
+    length(nodes(pa)) != 1 && return RouteChannel{T}(pa, simplify(pa), capacity)
+    return RouteChannel{T}(pa, only(nodes(pa)), capacity)
+end
+
+# Return a node corresponding to the section of the channel that the segment actually runs through
+function segment_channel_section(ch::RouteChannel{T}, wireseg_start, wireseg_stop, prev_width, next_width; margin=zero(T)) where {T}
+    d = wireseg_stop - wireseg_start
+    # Adjust for margins and track vs channel direction to get the channel node section used by actual segment
+    if abs(d) <= 2*margin + prev_width + next_width
+        # handle case where margin consumes entire segment
+        # Just have a zero length Straight at the midpoint
+        track_mid = (wireseg_start + wireseg_stop)/2
+        midpoint = ch.node.seg(track_mid)
+        middir = direction(ch.node.seg, track_mid)
+        channel_section = Node(Straight(zero(T), midpoint, middir), SimpleTrace(width(ch.node.sty, track_mid)))
+    elseif d > zero(d) # segment is along channel direction
+        channel_section = split(ch.node,
+            [wireseg_start + margin + prev_width/2,
+             wireseg_stop - margin - next_width/2])[2]
+    elseif d < zero(d) # segment is counter to channel direction
+        channel_section = reverse(split(ch.node,
+            [wireseg_stop + margin + next_width/2,
+             wireseg_start - margin - prev_width/2])[2])
+    end
+    return channel_section
+end
+
+function track_path_segment(n_tracks, channel_section, track_idx; reversed=false)
+    return offset(channel_section.seg,
+        track_section_offset(n_tracks, width(channel_section.sty), track_idx; reversed))
+end
+
+function track_section_offset(n_tracks, section_width::Coordinate, track_idx; reversed=false)
+    # (spacing) * number of tracks away from middle track
+    sgn = reversed ? -1 : 1
+    spacing = section_width / (n_tracks + 1)
+    return sgn * spacing * (track_idx - (1 + n_tracks) / 2)
+end
+
+function track_section_offset(n_tracks, section_width::Function, track_idx; reversed=false)
+    # (spacing) * number of tracks away from middle track
+    return t -> (reversed ? -1 : 1) * (section_width(t) / (n_tracks + 1)) * (track_idx - (1 + n_tracks) / 2)
+end
+
+reverse(n::Node) = Paths.Node(reverse(n.seg), reverse(n.sty, pathlength(n.seg)))
+######## Methods required to use segments and styles as RouteChannels
+function reverse(b::BSpline{T}) where {T}
+    p = reverse(b.p)
+    t0 = RotationPi()(b.t1)
+    t1 = RotationPi()(b.t0)
+    # Use true t range for interpolations defined by points that have been scaled out of [0,1]
+    tmin = b.r.ranges[1][1]
+    tmax = b.r.ranges[1][end]
+    (tmin == 0 && tmax == 1) && return BSpline(p, t0, t1)
+    p0 = b.p1
+    p1 = b.p0
+    r = Interpolations.scale(
+        interpolate(p, Interpolations.BSpline(Cubic(NeumannBC(t0, t1)))),
+        range(1-tmax, stop=1-tmin, length=length(p))
+    )
+    α0 = rotated_direction(b.α1, RotationPi())
+    α1 = rotated_direction(b.α0, RotationPi())
+    return BSpline(p, t0, t1, r, p0, p1, α0, α1)
+end
+reverse(s::Turn) = Turn(-s.α, s.r, p1(s), α1(s) + 180°)
+reverse(s::Straight) = Straight(s.l, p1(s), s.α0 + 180°)
+# Reversing a GeneralTrace requires knowing its length, so we'll require that as an argument even if unused
+reverse(s::TaperTrace{T}, l) where {T} = TaperTrace{T}(s.width_end, s.width_start, s.length)
+reverse(s::SimpleTrace, l) = s
+reverse(s::GeneralTrace, l) = GeneralTrace(t -> width(s, l - t))
+# Define methods for CPW even though they're not allowed for channels
+reverse(s::TaperCPW{T}, l) where {T} = TaperCPW{T}(s.trace_end, s.gap_end, s.trace_start, s.gap_start, s.length)
+reverse(s::SimpleCPW, l) = s
+reverse(s::GeneralCPW, l) = GeneralCPW(t -> trace(s, l - t), t -> gap(s, l - t))
+# For compound segments, reverse the individual sections and reverse their order
+# Keep the same tag so if a compound segment/style pair matched before they will still match
+reverse(s::CompoundSegment) = CompoundSegment(reverse(reverse.(s.segments)), s.tag)
+function reverse(s::CompoundStyle{T}, l) where {T}
+    lengths = reverse(diff(s.tgrid))
+    CompoundStyle{T}(reverse(reverse.(s.styles, lengths)), cumsum(reverse(lengths)), s.tag)
+end
+
+abstract type AbstractMultiRouting <: RouteRule end
+
+abstract type AbstractChannelRouting <: AbstractMultiRouting end
+
+function _route!(p::Path{T}, p1::Point, α1, rule::AbstractChannelRouting, 
+                    sty, waypoints, waydirs) where {T}
+    # Track segments for each channel
+    track_path_segs = track_path_segments(rule, p, p1)
+    waypoints = Point{T}[] # Segments too short for margins will just become waypoints for transitions
+    # Add segments and transitions
+    for (track_path_seg, next_entry_rule) in zip(track_path_segs, entry_rules(rule))
+        if iszero(pathlength(track_path_seg)) # Was too short for margins
+            push!(waypoints, p0(track_path_seg))
+        else
+            route!(p, p0(track_path_seg), α0(track_path_seg), next_entry_rule, sty; waypoints)
+            push!(p, Node(track_path_seg, sty), reconcile=false) # already reconciled by construction
+            empty!(waypoints)
+        end
+    end
+    # Exit
+    route!(p, p1, α1, exit_rule(rule), sty; waypoints)
+    return
+end
+
+struct SingleChannelRouting{T} <: AbstractChannelRouting
+    channel::RouteChannel{T}
+    transition_rules::Tuple{<:RouteRule,<:RouteRule}
+    transition_margins::Tuple{T,T}
+    segment_tracks::Dict{Path{T}, Int}
+end
+function SingleChannelRouting(ch::RouteChannel{T}, rule::RouteRule, margin::T) where {T}
+    return SingleChannelRouting{T}(ch, (rule, rule), (margin, margin), Dict{Path{T}, Int}())
+end
+entry_rules(scr::SingleChannelRouting) = [first(scr.transition_rules)]
+exit_rule(scr::SingleChannelRouting) = last(scr.transition_rules)
+entry_margin(scr::SingleChannelRouting) = first(scr.transition_margins)
+exit_margin(scr::SingleChannelRouting) = last(scr.transition_margins)
+num_tracks(scr::SingleChannelRouting) = maximum(values(scr.segment_tracks))
+track_idx(scr, pa) = scr.segment_tracks[pa]
+function set_track!(scr, pa, track_idx)
+    scr.segment_tracks[pa] = track_idx
+end
+
+function track_path_segments(rule::SingleChannelRouting, pa::Path, endpt)
+    wireseg_start = pathlength_nearest(rule.channel.node.seg, p1(pa))
+    wireseg_stop = pathlength_nearest(rule.channel.node.seg, endpt)
+    return [track_path_segment(num_tracks(rule),
+        segment_channel_section(rule.channel, wireseg_start, wireseg_stop, 2*entry_margin(rule), 2*exit_margin(rule)),
+            track_idx(rule, pa),
+            reversed=wireseg_start > wireseg_stop)]
+end
+
+function _update_with_graph!(rule::SingleChannelRouting, route_node, graph; track=num_tracks(rule)+1, kwargs...)
+    set_track!(rule, route_node.component._path, track)
+end

src/paths/contstyles/strands.jl

@@ -32,7 +32,7 @@ extent(s::GeneralStrands, t) =
 offset(s::GeneralStrands, t) = s.offset(t)
 width(s::GeneralStrands, t) = s.width(t)
 spacing(s::GeneralStrands, t) = s.spacing(t)
-num(s::GeneralStrands, t) = s.num
+num(s::GeneralStrands, t...) = s.num
 translate(s::GeneralStrands, t) =
     GeneralStrands(x -> s.offset(x + t), x -> s.width(x + t), x -> s.spacing(x + t), s.num)
 

src/paths/contstyles/tapers.jl

@@ -17,6 +17,8 @@ copy(x::TaperTrace{T}) where {T} = TaperTrace{T}(x.width_start, x.width_end, x.l
 extent(s::TaperTrace, t) = 0.5 * width(s, t)
 width(s::TaperTrace, t) =
     (1 - uconvert(NoUnits, t / s.length)) * s.width_start + t / s.length * s.width_end
+width(s::TaperTrace) = t -> width(s, t)
+trace(s::TaperTrace, t) = width(s, t)
 
 function pin(s::TaperTrace{T}; start=nothing, stop=nothing) where {T}
     iszero(s.length) && error("cannot `pin`; length of $s not yet determined.")

src/paths/contstyles/trace.jl

@@ -12,7 +12,9 @@ struct GeneralTrace{T} <: Trace{false}
 end
 copy(x::GeneralTrace) = GeneralTrace(x.width)
 extent(s::GeneralTrace, t) = 0.5 * s.width(t)
+extent(s::GeneralTrace) = t -> 0.5 * s.width(t)
 width(s::GeneralTrace, t) = s.width(t)
+width(s::GeneralTrace) = s.width
 trace(s::GeneralTrace, t) = s.width(t)
 translate(s::GeneralTrace, t) = GeneralTrace(x -> s.width(x + t))
 

src/paths/paths.jl

@@ -26,7 +26,8 @@ import Base:
     intersect!,
     show,
     summary,
-    dims2string
+    dims2string,
+    reverse
 
 import Base.Iterators
 
@@ -48,6 +49,7 @@ import DeviceLayout:
     Hook,
     Meta,
     PointHook,
+    Polygon,
     Polygons,
     Reflection,
     Rotation,
@@ -350,7 +352,7 @@ Return `s` on `seg` that minimizes `norm(seg(s) - pt)`.
 """
 function pathlength_nearest(seg::Paths.Segment{T}, pt::Point) where {T}
     errfunc(s) = ustrip(unit(T), norm(seg(s * pathlength(seg)) - pt))
-    return Optim.minimizer(optimize(errfunc, 0.0, 1.0))[1] * oneunit(T)
+    return Optim.minimizer(optimize(errfunc, 0.0, 1.0))[1] * pathlength(seg)
 end
 
 """
@@ -694,6 +696,9 @@ include("segments/bspline_optimization.jl")
 
 include("routes.jl")
 
+include("channels.jl")
+include("channel_routers.jl")
+
 function change_handedness!(seg::Union{Turn, Corner})
     return seg.α = -seg.α
 end

src/paths/routes.jl

@@ -610,3 +610,6 @@ function _route_leg!(
     turn!(p, 45° * sign(perp), bend_r, seg_sty[2])
     return d_diag > zero(dx) && straight!(p, d_diag, seg_sty[3])
 end
+
+function _update_with_plan!(rule::RouteRule, route_node, schematic) end
+function _update_with_graph!(rule::RouteRule, route_node, graph; kwargs...) end

src/paths/segments/compound.jl

@@ -28,7 +28,7 @@ end
 copy(s::CompoundSegment) = (typeof(s))(s.segments, s.tag)
 CompoundSegment(nodes::AbstractVector{Node{T}}, tag=gensym()) where {T} =
     CompoundSegment{T}(map(segment, nodes), tag)
-CompoundSegment(segments::AbstractVector{Segment{T}}, tag=gensym()) where {T} =
+CompoundSegment(segments::AbstractVector{<:Segment{T}}, tag=gensym()) where {T} =
     CompoundSegment{T}(segments, tag)
 
 convert(::Type{CompoundSegment{T}}, x::CompoundSegment) where {T} =