Add systematic single-channel tests

Author: gpeairs

Project.toml

@@ -4,13 +4,11 @@ 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"
@@ -45,7 +43,6 @@ SchematicGraphMakieExt = "GraphMakie"
 [compat]
 Accessors = "0.1"
 Aqua = "0.8"
-BipartiteMatching = "0.1.1"
 Cairo = "1.0"
 Clipper = "0.6"
 ColorSchemes = "3"

src/paths/channels.jl

@@ -106,15 +106,43 @@ function _route!(p::Path{T}, p1::Point, α1, rule::AbstractChannelRouting,
             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
+            push!(p, Node(track_path_seg, sty), reconcile=false) # p0, α0 reconciled by construction
+            p[end-1].next = p[end]
+            p[end].prev = p[end-1]
+            # Note `auto_curvature` BSpline uses curvature from end of previous segment
+            # and is not reconciled with the new node
+            # But we can do this ourselves
+            _reconcile_curvature!(p[end-1], next_entry_rule)
             empty!(waypoints)
         end
     end
     # Exit
     route!(p, p1, α1, exit_rule(rule), sty; waypoints)
+    _reconcile_curvature!(p[end], exit_rule(rule))
     return
 end
 
+function _reconcile_curvature!(n::Node{T}, rule::RouteRule) where {T} end
+function _reconcile_curvature!(n::Node{T}, rule::BSplineRouting) where {T}
+    !rule.auto_curvature && return
+    κ0 = if n.prev === n
+        0.0 / oneunit(T)
+    else
+        signed_curvature(segment(n.prev), pathlength(segment(n.prev)))
+    end
+    κ1 = if n.next === n
+        0.0 / oneunit(T)
+    else 
+        signed_curvature(segment(n.next), zero(coordinatetype(n)))
+    end
+    _set_endpoints_curvature!(segment(n), κ0, κ1)
+    if rule.auto_speed
+        _optimize_bspline!(segment(n); endpoints_curvature=(κ0, κ1))
+    else
+        _update_interpolation!(segment(n))
+    end
+end
+
 struct SingleChannelRouting{T} <: AbstractChannelRouting
     channel::RouteChannel{T}
     transition_rules::Tuple{<:RouteRule,<:RouteRule}

src/paths/paths.jl

@@ -697,7 +697,6 @@ 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.α

src/paths/segments/bspline_optimization.jl

@@ -18,10 +18,13 @@ function _optimize_bspline!(b::BSpline; endpoints_curvature=nothing)
 end
 
 function _set_endpoints_curvature!(::BSpline, ::Nothing; add_points=false) end
+function _set_endpoints_curvature!(b::BSpline, κ0κ1; add_points=false)
+    return _set_endpoints_curvature!(b, κ0κ1[1], κ0κ1[2]; add_points)
+end
 
 function _set_endpoints_curvature!(
     b::BSpline{T},
-    κ0=0.0 / oneunit(T),
+    κ0::Union{Float64, DeviceLayout.InverseLength}=0.0 / oneunit(T),
     κ1=κ0;
     add_points=false
 ) where {T}

test/coverage/Project.toml

@@ -1,3 +1,4 @@
 [deps]
+DeviceLayout = "ebf59a4a-04ec-49d7-8cd4-c9382ceb8e85"
 LocalCoverage = "5f6e1e16-694c-5876-87ef-16b5274f298e"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

test/runtests.jl

@@ -30,6 +30,7 @@ include("test_entity.jl")
 include("test_intersection.jl")
 include("test_shapes.jl")
 include("test_routes.jl")
+include("test_channels.jl")
 include("test_texts.jl")
 include("test_pointinpoly.jl")
 include("test_solidmodel.jl")

test/test_channels.jl

@@ -1,15 +1,52 @@
-using Revise
-using Graphs
-using FileIO
-import DeviceLayout.Paths: RouteChannel, ChannelRouter, assign_channels!, assign_tracks!, visualize_router_state
+import DeviceLayout.Paths: RouteChannel
 
-# @testset "Channels" begin    
-    ### Unit tests
-
-    ### Integration tests
+function test_single_channel_reversals(r, seg, sty)    
+    paths = test_single_channel(r, seg, sty;
+        reverse_channel=false, reverse_paths=false)
+    paths_revch = test_single_channel(r, seg, sty;
+        reverse_channel=true, reverse_paths=false)
+    paths_revp = test_single_channel(r, seg, sty;
+        reverse_channel=false, reverse_paths=true)
+    paths_rev_ch_p = test_single_channel(r, seg, sty;
+        reverse_channel=true, reverse_paths=true)
+    # Segments are approximately the same when channel is reversed
+    for (pa1, pa2) in zip(paths, paths_revch)
+        for (n1, n2) in zip(pa1, pa2)
+            @test p0(n1.seg) ≈ p0(n2.seg) atol=1nm
+            @test p1(n1.seg) ≈ p1(n2.seg) atol=1nm
+            @test isapprox_angle(α0(n1.seg), α0(n2.seg), atol=1e-6)
+            @test isapprox_angle(α1(n1.seg), α1(n2.seg), atol=1e-6)
+            @test pathlength(n1.seg) ≈ pathlength(n2.seg) atol=1nm
+        end
+    end
+    for (pa1, pa2) in zip(paths_revp, paths_rev_ch_p)
+        for (n1, n2) in zip(pa1, pa2)
+            @test p0(n1.seg) ≈ p0(n2.seg) atol=1nm
+            @test p1(n1.seg) ≈ p1(n2.seg) atol=1nm
+            @test isapprox_angle(α0(n1.seg), α0(n2.seg), atol=1e-6)
+            @test isapprox_angle(α1(n1.seg), α1(n2.seg), atol=1e-6)
+            @test pathlength(n1.seg) ≈ pathlength(n2.seg) atol=1nm
+        end
+    end
+    # Segments are approximately reversed when paths are reversed
+    for (pa1, pa2) in zip(paths, paths_revp)
+        for (n1, n2) in zip(pa1, reverse(pa2.nodes))
+            @test p0(n1.seg) ≈ p1(n2.seg) atol=1nm
+            @test p1(n1.seg) ≈ p0(n2.seg) atol=1nm
+            @test isapprox_angle(α0(n1.seg), α1(n2.seg) + 180°, atol=1e-6)
+            @test isapprox_angle(α1(n1.seg), α0(n2.seg) + 180°, atol=1e-6)
+            @test pathlength(n1.seg) ≈ pathlength(n2.seg) atol=1nm
+            # Some reversed paths are visibly different with taper trace and auto_speed (1um length difference)
+            # because the asymmetry causes speed optimization to find a different optimum
+            # depending on which is t0 and which is t1. So we use manual speed
+            # (also because it runs faster and we don't need to test auto further)
+        end
+    end
+    return paths
+end
 
-# end
-function test_single(transition_rule, channel_segment, channel_style; reverse_channel=false, reverse_paths=false)
+function test_single_channel(transition_rule, channel_segment, channel_style;
+        reverse_channel=false, reverse_paths=false)
     channel = Path(0.0μm, 0.0μm)
     if channel_segment == Paths.Straight
         straight!(channel, 1mm, channel_style)
@@ -54,29 +91,45 @@ function test_single(transition_rule, channel_segment, channel_style; reverse_ch
 
     paths = [Path(p, α0=α0) for (p, α0) in zip(p0s, α0s)]
     tracks = reverse_channel ? reverse(eachindex(paths)) : eachindex(paths)
+    styles = [Paths.Trace(2μm); fill(Paths.CPW(2μm, 2μm), length(paths))]
 
     rule = Paths.SingleChannelRouting(Paths.RouteChannel(channel), transition_rule, 50.0μm)
     setindex!.(Ref(rule.segment_tracks), tracks, paths)
-    for (track, pa, p1, α1) in zip(tracks, paths, p1s, α1s)
+    for (pa, p1, α1, sty) in zip(paths, p1s, α1s, styles)
         route!(pa, p1, α1, rule, Paths.CPW(2μm, 2μm))
     end
-
-    c = Cell("test", nm);
-    render!.(c, paths, GDSMeta(), atol=1μm);
-    render!(c, channel, GDSMeta(2));
-    save("test.gds", c)
+    return paths
 end
-transition_rules = [
-    Paths.BSplineRouting(auto_speed=true, auto_curvature=true)
-    Paths.StraightAnd90(min_bend_radius=25μm) # Can only be used with straight and trace if any paths enter from the sides, no curves or tapers
-]
-channel_segments = [
-    Paths.Straight,
-    Paths.Turn,
-    Paths.BSpline,
-    Paths.CompoundSegment
-]
-channel_styles = [
-    Paths.Trace(100μm),
-    Paths.TaperTrace(100μm, 50μm)
-]
+
+@testset "Channels" begin
+    ### Single-channel integration tests
+    ## Geometry-level routing
+    # StraightAnd90 only works with straight channel
+    transition_rules = [
+        Paths.StraightAnd90(min_bend_radius=25μm) # Can only be used with straight and trace if any paths enter from the sides, no curves or tapers
+        Paths.BSplineRouting(endpoints_speed=150μm, auto_curvature=true)
+    ]
+    channel_segments = [
+        Paths.Straight,
+        Paths.Turn,
+        Paths.BSpline,
+        Paths.CompoundSegment
+    ]
+    channel_styles = [
+        Paths.Trace(100μm),
+        Paths.TaperTrace(100μm, 50μm)
+    ]
+    @testset "Straight" begin
+        rule = transition_rules[1]
+        paths = test_single_channel_reversals(rule, channel_segments[1], channel_styles[1])
+        @test isempty(Intersect.intersections(paths...))
+    end
+    rule = transition_rules[2] # BSpline rule for all-angle transitions
+    for segtype in channel_segments[2:end]
+        @testset "$segtype channel" begin
+            for sty in channel_styles
+                test_single_channel_reversals(rule, segtype, sty)
+            end
+        end
+    end
+end