Enhance solidmodel boundary methods (#56)

* Enhance get_boundary and add set_periodic function

* Fix formatting

* Update docs and changelog

* Fix bugs and add tests for get_boundary

* Add test for set_periodic

* Add test for get_physical_group_bounding_box

* Address PR feedback

Author: simlapointe

CHANGELOG.md

@@ -4,6 +4,10 @@ The format of this changelog is based on
 [Keep a Changelog](https://keepachangelog.com/), and this project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## Upcoming
+
+  - Added `set_periodic!` to `SolidModels` to enable periodic meshes.
+
 ## 1.2.0 (2025-04-28)
 
   - Composite components can define `_build_subcomponents` to return a `NamedTuple` with keys that differ from component names

docs/src/solidmodels.md

@@ -60,6 +60,7 @@ Other operations:
     SolidModels.remove_group!
     SolidModels.restrict_to_volume!
     SolidModels.revolve!
+    SolidModels.set_periodic!
     SolidModels.translate!
 ```
 

src/solidmodels/postrender.jl

@@ -809,8 +809,8 @@ function fragment_geom!(
 end
 
 """
-    get_boundary(group::AbstractPhysicalGroup; combined=true, oriented=true, recursive=false)
-    get_boundary(sm::SolidModel, groupname, dim=2; combined=true, oriented=true, recursive=false)
+    get_boundary(group::AbstractPhysicalGroup; combined=true, oriented=true, recursive=false, direction="all", position="all")
+    get_boundary(sm::SolidModel, groupname, dim=2; combined=true, oriented=true, recursive=false, direction="all", position="all")
 
 Get the boundary of the model entities in `group`, given as a vector of (dim, tag) tuples.
 
@@ -821,14 +821,19 @@ Return tags multiplied by the sign of the boundary entity if `oriented` is true.
 
 Apply the boundary operator recursively down to dimension 0 (i.e. to points) if `recursive`
 is true.
+
+If `direction` is specified, return only the boundaries perperdicular to the x, y, or z axis. If `position` is also specified,
+return only the boundaries at the min or max position along the specified `direction`.
 """
 function get_boundary(
     sm::SolidModel,
     group,
     dim=2;
     combined=true,
     oriented=true,
-    recursive=false
+    recursive=false,
+    direction="all",
+    position="all"
 )
     if !hasgroup(sm, group, dim)
         @info "get_boundary(sm, $group, $dim): ($group, $dim) is not a physical group, thus has no boundary."
@@ -838,16 +843,129 @@ function get_boundary(
         sm[group, dim];
         combined=combined,
         oriented=oriented,
-        recursive=recursive
+        recursive=recursive,
+        direction=direction,
+        position=position
     )
 end
 function get_boundary(
     group::AbstractPhysicalGroup;
     combined=true,
     oriented=true,
-    recursive=false
+    recursive=false,
+    direction="all",
+    position="all"
+)
+    all_bc_entities = gmsh.model.getBoundary(dimtags(group), combined, oriented, recursive)
+    if direction == "all"
+        return all_bc_entities
+    else
+        if lowercase(direction) ∉ ["all", "x", "y", "z"]
+            @info "get_boundary(sm, $group): direction $direction is not all, X, Y, or Z, thus has no boundary."
+            return Tuple{Int32, Int32}[]
+        end
+        if lowercase(position) ∉ ["all", "min", "max"]
+            @info "get_boundary(sm, $group): position $position is not all, min, or max, thus has no boundary."
+            return Tuple{Int32, Int32}[]
+        end
+        direction_map = Dict("x" => 1, "y" => 2, "z" => 3)
+        direction_id = direction_map[lowercase(direction)]
+        bboxes = Dict()
+        for (dim, tag) in all_bc_entities
+            bboxes[tag] = gmsh.model.getBoundingBox(dim, abs(tag))
+        end
+        target_min = minimum(bbox[direction_id] for bbox in values(bboxes))
+        target_max = maximum(bbox[direction_id + 3] for bbox in values(bboxes))
+
+        bc_entities = []
+        for (dim, tag) in all_bc_entities
+            bbox = bboxes[tag]
+            min_val = bbox[direction_id]
+            max_val = bbox[direction_id + 3]
+
+            # Check if the boundary is perpendicular to the direction
+            !isapprox(min_val, max_val, atol=1e-6) && continue
+
+            # Check if at domain min/max position
+            if lowercase(position) == "min" || lowercase(position) == "all"
+                isapprox(min_val, target_min, atol=1e-6) && push!(bc_entities, (dim, tag))
+            end
+            if lowercase(position) == "max" || lowercase(position) == "all"
+                isapprox(max_val, target_max, atol=1e-6) && push!(bc_entities, (dim, tag))
+            end
+        end
+        return unique(bc_entities)
+    end
+end
+
+function get_bounding_box(dim, tags)
+    xmin, ymin, zmin, xmax, ymax, zmax = gmsh.model.getBoundingBox(dim, tags[1])
+
+    for tag in tags[2:end]
+        x_min, y_min, z_min, x_max, y_max, z_max = gmsh.model.getBoundingBox(dim, tag)
+        xmin = min(xmin, x_min)
+        ymin = min(ymin, y_min)
+        zmin = min(zmin, z_min)
+        xmax = max(xmax, x_max)
+        ymax = max(ymax, y_max)
+        zmax = max(zmax, z_max)
+    end
+
+    return (xmin, ymin, zmin, xmax, ymax, zmax)
+end
+
+"""
+    set_periodic!(group1::AbstractPhysicalGroup, group2::AbstractPhysicalGroup; dim=2)
+    set_periodic!(sm, group1, group2, d1=2, d2=2)
+
+Set the model entities in `group1` and `group2` to be periodic. Only supports `d1` = `d2` = 2
+and surfaces in both groups need to be parallel and axis-aligned.
+"""
+function set_periodic!(
+    sm::SolidModel,
+    group1::Union{String, Symbol},
+    group2::Union{String, Symbol},
+    d1=2,
+    d2=2
 )
-    return gmsh.model.getBoundary(dimtags(group), combined, oriented, recursive)
+    if (d1 != 2 || d2 != 2)
+        @info "set_periodic!(sm, $group1, $group2, $d1, $d2) only supports d1 = d2 = 2."
+        return Tuple{Int32, Int32}[]
+    end
+    return set_periodic!(sm[group1, d1], sm[group2, d2]; dim=d1)
+end
+
+function set_periodic!(group1::AbstractPhysicalGroup, group2::AbstractPhysicalGroup; dim=2)
+    tags1 = [dt[2] for dt in dimtags(group1)]
+    tags2 = [dt[2] for dt in dimtags(group2)]
+
+    bbox1 = get_bounding_box(dim, tags1)
+    bbox2 = get_bounding_box(dim, tags2)
+
+    # Check if surfaces are aligned with x, y, or z axis
+    plane1 = [isapprox(bbox1[i], bbox1[i + 3], atol=1e-6) for i = 1:3]
+    plane2 = [isapprox(bbox2[i], bbox2[i + 3], atol=1e-6) for i = 1:3]
+
+    # Set periodicity if both surfaces are perpendicular to the same axis
+    dist = [0.0, 0.0, 0.0]
+    for i = 1:3
+        if plane1[i] && plane2[i]
+            dist[i] = bbox1[i] - bbox2[i]
+        end
+    end
+    if isapprox(sum(abs.(dist)), 0.0) || count(!iszero, dist) > 1
+        @info "set_periodic! only supports distinct parallel axis-aligned surfaces."
+        return Tuple{Int32, Int32}[]
+    end
+
+    gmsh.model.mesh.set_periodic(
+        dim,
+        tags1,
+        tags2,
+        [1, 0, 0, dist[1], 0, 1, 0, dist[2], 0, 0, 1, dist[3], 0, 0, 0, 1]
+    )
+
+    return vcat(dimtags(group1), dimtags(group2))
 end
 
 """

test/test_solidmodel.jl

@@ -218,9 +218,47 @@ import DeviceLayout.SolidModels.STP_UNIT
         isapprox.([x0, y0, x1, y1], ustrip.(STP_UNIT, [x0d, y0d, x1d, y1d]), atol=1e-6)
     )
     sm["test_bdy"] = SolidModels.get_boundary(sm["test", 2])
+    sm["test_bdy_xmin"] =
+        SolidModels.get_boundary(sm["test", 2]; direction="X", position="min")
+    sm["test_bdy_xmax"] =
+        SolidModels.get_boundary(sm["test", 2]; direction="X", position="max")
+    sm["test_bdy_ymin"] =
+        SolidModels.get_boundary(sm["test", 2]; direction="Y", position="min")
+    sm["test_bdy_ymax"] =
+        SolidModels.get_boundary(sm["test", 2]; direction="Y", position="max")
+    sm["test_bdy_zmin"] =
+        SolidModels.get_boundary(sm["test", 2]; direction="Z", position="min")
+    sm["test_bdy_zmax"] =
+        SolidModels.get_boundary(sm["test", 2]; direction="Z", position="max")
+
+    @test isempty(
+        @test_logs (
+            :info,
+            "get_boundary(sm, test, 3): (test, 3) is not a physical group, thus has no boundary."
+        ) SolidModels.get_boundary(sm, "test", 3)
+    )
+    @test isempty(
+        @test_logs (
+            :info,
+            "get_boundary(sm, Physical Group test of dimension 2 with 4 entities): direction a is not all, X, Y, or Z, thus has no boundary."
+        ) SolidModels.get_boundary(sm["test", 2]; direction="a", position="min")
+    )
+    @test isempty(
+        @test_logs (
+            :info,
+            "get_boundary(sm, Physical Group test of dimension 2 with 4 entities): position no is not all, min, or max, thus has no boundary."
+        ) SolidModels.get_boundary(sm["test", 2]; direction="X", position="no")
+    )
+
     SolidModels.remove_group!(sm, "test", 2; recursive=false)
     @test !SolidModels.hasgroup(sm, "test", 2)
     @test !isempty(SolidModels.dimtags(sm["test_bdy", 1]))
+    @test !isempty(SolidModels.dimtags(sm["test_bdy_xmin", 1]))
+    @test !isempty(SolidModels.dimtags(sm["test_bdy_xmax", 1]))
+    @test !isempty(SolidModels.dimtags(sm["test_bdy_ymin", 1]))
+    @test !isempty(SolidModels.dimtags(sm["test_bdy_ymax", 1]))
+    @test !isempty(SolidModels.dimtags(sm["test_bdy_zmin", 1]))
+    @test !isempty(SolidModels.dimtags(sm["test_bdy_zmax", 1]))
 
     @test SolidModels.dimtags(get(sm, "foo", 2, sm["test_bdy", 1])) ==
           SolidModels.dimtags(sm["test_bdy", 1])
@@ -961,6 +999,38 @@ import DeviceLayout.SolidModels.STP_UNIT
     sm = test_sm()
     render!(sm, cs) # runs without error
 
+    # Use get_boundary, get_bounding_box, and set_periodic!
+    cs = CoordinateSystem("test", nm)
+    place!(cs, centered(Rectangle(500μm, 100μm)), :l1)
+    postrender_ops = [("ext", SolidModels.extrude_z!, (:l1, 20μm))]
+    sm = SolidModel("test"; overwrite=true)
+    zmap = (m) -> (0μm)
+    render!(sm, cs, zmap=zmap, postrender_ops=postrender_ops)
+    sm["Xmin"] = SolidModels.get_boundary(sm["ext", 3]; direction="X", position="min")
+    sm["Xmax"] = SolidModels.get_boundary(sm["ext", 3]; direction="X", position="max")
+    sm["Ymax"] = SolidModels.get_boundary(sm["ext", 3]; direction="Y", position="max")
+    @test isempty(
+        @test_logs (
+            :info,
+            "set_periodic!(sm, Xmin, Xmax, 1, 1) only supports d1 = d2 = 2."
+        ) SolidModels.set_periodic!(sm, "Xmin", "Xmax", 1, 1)
+    )
+    @test isempty(
+        @test_logs (
+            :info,
+            "set_periodic! only supports distinct parallel axis-aligned surfaces."
+        ) SolidModels.set_periodic!(sm, "Xmin", "Ymax")
+    )
+    @test all(
+        isapprox.(
+            SolidModels.get_bounding_box(2, [3, 5]),
+            ustrip.(STP_UNIT, (-250μm, -50μm, 0μm, 250μm, 50μm, 20μm)),
+            atol=1e-6
+        )
+    )
+    periodic_tags = SolidModels.set_periodic!(sm["Xmin", 2], sm["Xmax", 2])
+    @test !isempty(periodic_tags)
+
     # TODO: Composing OptionalStyle
 
     # Explicitly MeshSized Path.