tcad scripts

.gitignore

@@ -171,3 +171,12 @@ cython_debug/
 *.DS_Store
 .DS_Store
 *Thumbs.db
+
+# Possible generated files
+*.cmd
+*.tcl
+*.tdr
+*.log
+*.BAK
+*.sav
+*.plt

.pre-commit-config.yaml

@@ -56,5 +56,6 @@ repos:
     rev: v2.2.6
     hooks:
       - id: codespell
+        args: ["--skip=*svisual.py"]
         additional_dependencies:
           - tomli

gplugins/gmsh/parse_gds.py

@@ -61,6 +61,25 @@ def cleanup_component(component, layer_stack, round_tol=2, simplify_tol=1e-2):
     }
 
 
+def cleanup_component_layermap(component, layermap, round_tol=2, simplify_tol=1e-2):
+    """Process component polygons before processing.
+
+    Uses layermap (design layers) names.
+    """
+    layer_dict = vars(layermap)
+
+    return {
+        layer: fuse_polygons(
+            component,
+            layername,
+            layer,
+            round_tol=round_tol,
+            simplify_tol=simplify_tol,
+        )
+        for layername, layer in layer_dict.items()
+    }
+
+
 def to_polygons(geometries):
     for geometry in geometries:
         if isinstance(geometry, Polygon):

gplugins/gmsh/uz_xsection_mesh.py

@@ -26,12 +26,14 @@
 def get_u_bounds_polygons(
     polygons: MultiPolygon | list[Polygon],
     xsection_bounds: tuple[tuple[float, float], tuple[float, float]],
+    u_offset: float = 0.0,
 ):
     """Performs the bound extraction given a (Multi)Polygon or [Polygon] and cross-sectional line coordinates.
 
     Args:
         layer_polygons_dict: dict containing layernames: shapely polygons pairs
         xsection_bounds: ( (x1,y1), (x2,y2) ), with x1,y1 beginning point of cross-sectional line and x2,y2 the end.
+        u_offset: amount to offset the returned polygons in the lateral dimension
 
     Returns: list of bounding box coordinates (u1,u2)) in xsection line coordinates (distance from xsection_bounds[0]).
     """
@@ -51,7 +53,12 @@ def get_u_bounds_polygons(
                 bounds = entry.bounds
                 p1 = Point([bounds[0], bounds[1]])
                 p2 = Point([bounds[2], bounds[3]])
-                return_list.append([linestart.distance(p1), linestart.distance(p2)])
+                return_list.append(
+                    [
+                        linestart.distance(p1) + u_offset,
+                        linestart.distance(p2) + u_offset,
+                    ]
+                )
     return return_list
 
 

gplugins/sentaurus/mask_sde.py

@@ -0,0 +1,119 @@
+import operator
+from functools import reduce
+
+import shapely
+from gdsfactory.typings import Layer, LayerSpecs, List
+
+
+def get_mask_polygons(
+    layer_polygons_dict,
+    layer,
+    layers_or,
+    layers_and,
+    layers_diff,
+    layers_xor,
+    buffer_tol=1e-3,
+):
+    """(3D simulations) Returns mask polygons for the combination of layers."""
+    layer_polygons = layer_polygons_dict[layer]
+
+    for or_layer in layers_or:
+        layer_polygons = layer_polygons | layer_polygons_dict[or_layer]
+    for and_layer in layers_and:
+        layer_polygons = layer_polygons & layer_polygons_dict[and_layer]
+    for diff_layer in layers_diff:
+        layer_polygons = layer_polygons - layer_polygons_dict[diff_layer]
+    for xor_layer in layers_xor:
+        layer_polygons = layer_polygons ^ layer_polygons_dict[xor_layer]
+
+    return layer_polygons.buffer(-buffer_tol, join_style=2).buffer(
+        buffer_tol, join_style=2
+    )
+
+
+def add_mask_polygons(layer_polygons):
+    """Returns polygons strings for 3D masks."""
+    return_str_lines = []
+    for _i, polygon in enumerate(
+        layer_polygons.geoms if hasattr(layer_polygons, "geoms") else [layer_polygons]
+    ):
+        if not polygon.is_empty:
+            coordinates_x = [x for x, y in polygon.exterior.coords][:-1]
+            coordinates_y = [y for x, y in polygon.exterior.coords][:-1]
+            coordinates = reduce(operator.add, zip(coordinates_x, coordinates_y))
+            segments = ""
+            for coordinate in coordinates:
+                segments += f"{coordinate:1.3f} "
+            line = f"(list {segments})"
+            return_str_lines.append(line)
+    return return_str_lines
+
+
+def get_sentaurus_mask_3D(
+    layer_polygons_dict,
+    name: str,
+    layer: Layer = None,
+    layers_or: LayerSpecs = None,
+    layers_and: LayerSpecs = None,
+    layers_diff: LayerSpecs = None,
+    layers_xor: LayerSpecs = None,
+) -> List[str]:
+    """Returns the 3D Sentaurus mask script line for the given layer + extra layers.
+
+    Arguments:
+        layer_polygons_dict: dict of layernames --> shapely (multi)polygons
+        name: name of the mask
+        layer: main layer for this mask
+        layers_or: other layers' polygons to union with layer polygons
+        layers_diff: other layers' polygons to diff with layer polygons
+        layers_and: other layers' polygons to intersect with layer polygons
+        layers_xor: other layers' polygons to exclusive or with layer polygons
+    """
+
+    return_str = ""
+
+    layers_or = layers_or or []
+    layers_and = layers_and or []
+    layers_diff = layers_diff or []
+    layers_xor = layers_xor or []
+
+    if layer is None:
+        return []
+    else:
+        layer_polygons = get_mask_polygons(
+            layer_polygons_dict=layer_polygons_dict,
+            layer=layer,
+            layers_or=layers_or,
+            layers_and=layers_and,
+            layers_diff=layers_diff,
+            layers_xor=layers_xor,
+        )
+
+    # Add mask step
+    return_str += f'(sdepe:generate-mask "{name}" (list\n'
+    polygon_strings = add_mask_polygons(layer_polygons)
+    for i, polygon_string in enumerate(polygon_strings):
+        return_str += polygon_string
+        if i < len(polygon_strings):
+            return_str += "\n"
+    return_str += "))\n"
+
+    if layer_polygons:
+        exists = True
+    else:
+        exists = False
+
+    return return_str, exists
+
+
+if __name__ == "__main__":
+    test_polygon = shapely.Polygon([(0, 0), (0, 1), (1, 1), (1, 0)])
+
+    test_layer_polygons_dict = {}
+    test_layer_polygons_dict[(10, 0)] = test_polygon
+
+    print(
+        get_sentaurus_mask_3D(
+            test_layer_polygons_dict, layer=(10, 0), name="test_layer"
+        )
+    )