gsim 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

gsim/palace/mesh/generator.py

@@ -6,7 +6,6 @@ replacing the gds2palace backend with a cleaner implementation.
 
 from __future__ import annotations
 
-import json
 import logging
 import math
 from dataclasses import dataclass, field
@@ -16,26 +15,28 @@ from typing import TYPE_CHECKING
 import gmsh
 
 from . import gmsh_utils
+from .config_generator import (
+    collect_mesh_stats,
+    generate_palace_config,
+    write_config,
+)
+from .geometry import (
+    GeometryData,
+    add_dielectrics,
+    add_metals,
+    add_ports,
+    extract_geometry,
+)
+from .groups import assign_physical_groups
 
 if TYPE_CHECKING:
+    from gsim.common.stack import LayerStack
     from gsim.palace.models import DrivenConfig
     from gsim.palace.ports.config import PalacePort
-    from gsim.common.stack import LayerStack
-
-from gsim.palace.ports.config import PortGeometry
 
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class GeometryData:
-    """Container for geometry data extracted from component."""
-
-    polygons: list  # List of (layer_num, pts_x, pts_y) tuples
-    bbox: tuple[float, float, float, float]  # (xmin, ymin, xmax, ymax)
-    layer_bboxes: dict  # layer_num -> (xmin, ymin, xmax, ymax)
-
-
 @dataclass
 class MeshResult:
     """Result from mesh generation."""
@@ -51,567 +52,6 @@ class MeshResult:
     fmax: float = 100e9
 
 
-def extract_geometry(component, stack: LayerStack) -> GeometryData:
-    """Extract polygon geometry from a gdsfactory component.
-
-    Args:
-        component: gdsfactory Component
-        stack: LayerStack for layer mapping
-
-    Returns:
-        GeometryData with polygons and bounding boxes
-    """
-    polygons = []
-    global_bbox = [math.inf, math.inf, -math.inf, -math.inf]
-    layer_bboxes = {}
-
-    # Get polygons from component
-    polygons_by_index = component.get_polygons()
-
-    # Build layer_index -> GDS tuple mapping
-    layout = component.kcl.layout
-    index_to_gds = {}
-    for layer_index in range(layout.layers()):
-        if layout.is_valid_layer(layer_index):
-            info = layout.get_info(layer_index)
-            index_to_gds[layer_index] = (info.layer, info.datatype)
-
-    # Build GDS tuple -> layer number mapping
-    gds_to_layernum = {}
-    for layer_data in stack.layers.values():
-        gds_tuple = tuple(layer_data.gds_layer)
-        gds_to_layernum[gds_tuple] = gds_tuple[0]
-
-    # Convert polygons
-    for layer_index, polys in polygons_by_index.items():
-        gds_tuple = index_to_gds.get(layer_index)
-        if gds_tuple is None:
-            continue
-
-        layernum = gds_to_layernum.get(gds_tuple)
-        if layernum is None:
-            continue
-
-        for poly in polys:
-            # Convert klayout polygon to lists (nm -> um)
-            points = list(poly.each_point_hull())
-            if len(points) < 3:
-                continue
-
-            pts_x = [pt.x / 1000.0 for pt in points]
-            pts_y = [pt.y / 1000.0 for pt in points]
-
-            polygons.append((layernum, pts_x, pts_y))
-
-            # Update bounding boxes
-            xmin, xmax = min(pts_x), max(pts_x)
-            ymin, ymax = min(pts_y), max(pts_y)
-
-            global_bbox[0] = min(global_bbox[0], xmin)
-            global_bbox[1] = min(global_bbox[1], ymin)
-            global_bbox[2] = max(global_bbox[2], xmax)
-            global_bbox[3] = max(global_bbox[3], ymax)
-
-            if layernum not in layer_bboxes:
-                layer_bboxes[layernum] = [xmin, ymin, xmax, ymax]
-            else:
-                bbox = layer_bboxes[layernum]
-                bbox[0] = min(bbox[0], xmin)
-                bbox[1] = min(bbox[1], ymin)
-                bbox[2] = max(bbox[2], xmax)
-                bbox[3] = max(bbox[3], ymax)
-
-    return GeometryData(
-        polygons=polygons,
-        bbox=(global_bbox[0], global_bbox[1], global_bbox[2], global_bbox[3]),
-        layer_bboxes=layer_bboxes,
-    )
-
-
-def _get_layer_info(stack: LayerStack, gds_layer: int) -> dict | None:
-    """Get layer info from stack by GDS layer number."""
-    for name, layer in stack.layers.items():
-        if layer.gds_layer[0] == gds_layer:
-            return {
-                "name": name,
-                "zmin": layer.zmin,
-                "zmax": layer.zmax,
-                "thickness": layer.zmax - layer.zmin,
-                "material": layer.material,
-                "type": layer.layer_type,
-            }
-    return None
-
-
-def _add_metals(
-    kernel,
-    geometry: GeometryData,
-    stack: LayerStack,
-) -> dict:
-    """Add metal and via geometries to gmsh.
-
-    Creates extruded volumes for vias and shells (surfaces) for conductors.
-
-    Returns:
-        Dict with layer_name -> list of (surface_tags_xy, surface_tags_z) for
-        conductors, or volume_tags for vias.
-    """
-    # layer_name -> {"volumes": [], "surfaces_xy": [], "surfaces_z": []}
-    metal_tags = {}
-
-    # Group polygons by layer
-    polygons_by_layer = {}
-    for layernum, pts_x, pts_y in geometry.polygons:
-        if layernum not in polygons_by_layer:
-            polygons_by_layer[layernum] = []
-        polygons_by_layer[layernum].append((pts_x, pts_y))
-
-    # Process each layer
-    for layernum, polys in polygons_by_layer.items():
-        layer_info = _get_layer_info(stack, layernum)
-        if layer_info is None:
-            continue
-
-        layer_name = layer_info["name"]
-        layer_type = layer_info["type"]
-        zmin = layer_info["zmin"]
-        thickness = layer_info["thickness"]
-
-        if layer_type not in ("conductor", "via"):
-            continue
-
-        if layer_name not in metal_tags:
-            metal_tags[layer_name] = {
-                "volumes": [],
-                "surfaces_xy": [],
-                "surfaces_z": [],
-            }
-
-        for pts_x, pts_y in polys:
-            # Create extruded polygon
-            surfacetag = gmsh_utils.create_polygon_surface(kernel, pts_x, pts_y, zmin)
-            if surfacetag is None:
-                continue
-
-            if thickness > 0:
-                result = kernel.extrude([(2, surfacetag)], 0, 0, thickness)
-                volumetag = result[1][1]
-
-                if layer_type == "via":
-                    # Keep vias as volumes
-                    metal_tags[layer_name]["volumes"].append(volumetag)
-                else:
-                    # For conductors, get shell surfaces and remove volume
-                    _, surfaceloops = kernel.getSurfaceLoops(volumetag)
-                    if surfaceloops:
-                        metal_tags[layer_name]["volumes"].append(
-                            (volumetag, surfaceloops[0])
-                        )
-                    kernel.remove([(3, volumetag)])
-
-    kernel.removeAllDuplicates()
-    kernel.synchronize()
-
-    return metal_tags
-
-
-def _add_dielectrics(
-    kernel,
-    geometry: GeometryData,
-    stack: LayerStack,
-    margin: float,
-    air_margin: float,
-) -> dict:
-    """Add dielectric boxes and airbox to gmsh.
-
-    Returns:
-        Dict with material_name -> list of volume_tags
-    """
-    dielectric_tags = {}
-
-    # Get overall geometry bounds
-    xmin, ymin, xmax, ymax = geometry.bbox
-    xmin -= margin
-    ymin -= margin
-    xmax += margin
-    ymax += margin
-
-    # Track overall z range
-    z_min_all = math.inf
-    z_max_all = -math.inf
-
-    # Sort dielectrics by z (top to bottom for correct layering)
-    sorted_dielectrics = sorted(
-        stack.dielectrics, key=lambda d: d["zmax"], reverse=True
-    )
-
-    # Add dielectric boxes
-    offset = 0
-    offset_delta = margin / 20
-
-    for dielectric in sorted_dielectrics:
-        material = dielectric["material"]
-        d_zmin = dielectric["zmin"]
-        d_zmax = dielectric["zmax"]
-
-        z_min_all = min(z_min_all, d_zmin)
-        z_max_all = max(z_max_all, d_zmax)
-
-        if material not in dielectric_tags:
-            dielectric_tags[material] = []
-
-        # Create box with slight offset to avoid mesh issues
-        box_tag = gmsh_utils.create_box(
-            kernel,
-            xmin - offset,
-            ymin - offset,
-            d_zmin,
-            xmax + offset,
-            ymax + offset,
-            d_zmax,
-        )
-        dielectric_tags[material].append(box_tag)
-
-        # Alternate offset to avoid coincident faces
-        offset = offset_delta if offset == 0 else 0
-
-    # Add surrounding airbox
-    air_xmin = xmin - air_margin
-    air_ymin = ymin - air_margin
-    air_xmax = xmax + air_margin
-    air_ymax = ymax + air_margin
-    air_zmin = z_min_all - air_margin
-    air_zmax = z_max_all + air_margin
-
-    airbox_tag = kernel.addBox(
-        air_xmin,
-        air_ymin,
-        air_zmin,
-        air_xmax - air_xmin,
-        air_ymax - air_ymin,
-        air_zmax - air_zmin,
-    )
-    dielectric_tags["airbox"] = [airbox_tag]
-
-    kernel.synchronize()
-
-    return dielectric_tags
-
-
-def _add_ports(
-    kernel,
-    ports: list[PalacePort],
-    stack: LayerStack,
-) -> tuple[dict, list]:
-    """Add port surfaces to gmsh.
-
-    Args:
-        kernel: gmsh kernel
-        ports: List of PalacePort objects (single or multi-element)
-        stack: Layer stack
-
-    Returns:
-        (port_tags dict, port_info list)
-
-    For single-element ports: port_tags["P{num}"] = [surface_tag]
-    For multi-element ports: port_tags["P{num}"] = [surface_tag, surface_tag, ...]
-    """
-    port_tags = {}  # "P{num}" -> [surface_tag(s)]
-    port_info = []
-    port_num = 1
-
-    for port in ports:
-        if port.multi_element:
-            # Multi-element port (CPW)
-            if port.layer is None or port.centers is None or port.directions is None:
-                continue
-            target_layer = stack.layers.get(port.layer)
-            if target_layer is None:
-                continue
-
-            z = target_layer.zmin
-            hw = port.width / 2
-            hl = (port.length or port.width) / 2
-
-            # Determine axis from orientation
-            angle = port.orientation % 360
-            is_y_axis = 45 <= angle < 135 or 225 <= angle < 315
-
-            surfaces = []
-            for cx, cy in port.centers:
-                if is_y_axis:
-                    surf = gmsh_utils.create_port_rectangle(
-                        kernel, cx - hw, cy - hl, z, cx + hw, cy + hl, z
-                    )
-                else:
-                    surf = gmsh_utils.create_port_rectangle(
-                        kernel, cx - hl, cy - hw, z, cx + hl, cy + hw, z
-                    )
-                surfaces.append(surf)
-
-            port_tags[f"P{port_num}"] = surfaces
-
-            port_info.append(
-                {
-                    "portnumber": port_num,
-                    "Z0": port.impedance,
-                    "type": "cpw",
-                    "elements": [
-                        {"surface_idx": i, "direction": port.directions[i]}
-                        for i in range(len(port.centers))
-                    ],
-                    "width": port.width,
-                    "length": port.length or port.width,
-                    "zmin": z,
-                    "zmax": z,
-                }
-            )
-
-        elif port.geometry == PortGeometry.VIA:
-            # Via port: vertical between two layers
-            if port.from_layer is None or port.to_layer is None:
-                continue
-            from_layer = stack.layers.get(port.from_layer)
-            to_layer = stack.layers.get(port.to_layer)
-            if from_layer is None or to_layer is None:
-                continue
-
-            x, y = port.center
-            hw = port.width / 2
-
-            if from_layer.zmin < to_layer.zmin:
-                zmin = from_layer.zmax
-                zmax = to_layer.zmin
-            else:
-                zmin = to_layer.zmax
-                zmax = from_layer.zmin
-
-            # Create vertical port surface
-            if port.direction in ("x", "-x"):
-                surfacetag = gmsh_utils.create_port_rectangle(
-                    kernel, x, y - hw, zmin, x, y + hw, zmax
-                )
-            else:
-                surfacetag = gmsh_utils.create_port_rectangle(
-                    kernel, x - hw, y, zmin, x + hw, y, zmax
-                )
-
-            port_tags[f"P{port_num}"] = [surfacetag]
-            port_info.append(
-                {
-                    "portnumber": port_num,
-                    "Z0": port.impedance,
-                    "type": "via",
-                    "direction": "Z",
-                    "length": zmax - zmin,
-                    "width": port.width,
-                    "xmin": x - hw if port.direction in ("y", "-y") else x,
-                    "xmax": x + hw if port.direction in ("y", "-y") else x,
-                    "ymin": y - hw if port.direction in ("x", "-x") else y,
-                    "ymax": y + hw if port.direction in ("x", "-x") else y,
-                    "zmin": zmin,
-                    "zmax": zmax,
-                }
-            )
-
-        else:
-            # Inplane port: horizontal on single layer
-            if port.layer is None:
-                continue
-            target_layer = stack.layers.get(port.layer)
-            if target_layer is None:
-                continue
-
-            x, y = port.center
-            hw = port.width / 2
-            z = target_layer.zmin
-
-            hl = (port.length or port.width) / 2
-            if port.direction in ("x", "-x"):
-                surfacetag = gmsh_utils.create_port_rectangle(
-                    kernel, x - hl, y - hw, z, x + hl, y + hw, z
-                )
-                length = 2 * hl
-                width = port.width
-            else:
-                surfacetag = gmsh_utils.create_port_rectangle(
-                    kernel, x - hw, y - hl, z, x + hw, y + hl, z
-                )
-                length = port.width
-                width = 2 * hl
-
-            port_tags[f"P{port_num}"] = [surfacetag]
-            port_info.append(
-                {
-                    "portnumber": port_num,
-                    "Z0": port.impedance,
-                    "type": "lumped",
-                    "direction": port.direction.upper(),
-                    "length": length,
-                    "width": width,
-                    "xmin": x - hl if port.direction in ("x", "-x") else x - hw,
-                    "xmax": x + hl if port.direction in ("x", "-x") else x + hw,
-                    "ymin": y - hw if port.direction in ("x", "-x") else y - hl,
-                    "ymax": y + hw if port.direction in ("x", "-x") else y + hl,
-                    "zmin": z,
-                    "zmax": z,
-                }
-            )
-
-        port_num += 1
-
-    kernel.synchronize()
-
-    return port_tags, port_info
-
-
-def _assign_physical_groups(
-    kernel,
-    metal_tags: dict,
-    dielectric_tags: dict,
-    port_tags: dict,
-    port_info: list,
-    geom_dimtags: list,
-    geom_map: list,
-    _stack: LayerStack,
-) -> dict:
-    """Assign physical groups after fragmenting.
-
-    Args:
-        kernel: gmsh kernel
-        metal_tags: Metal layer tags
-        dielectric_tags: Dielectric material tags
-        port_tags: Port surface tags (may have multiple surfaces for CPW)
-        port_info: Port metadata including type info
-        geom_dimtags: Dimension tags from fragmentation
-        geom_map: Geometry map from fragmentation
-        _stack: Layer stack (unused; reserved for future material metadata)
-
-    Returns:
-        Dict with group info for config file generation
-    """
-    groups = {
-        "volumes": {},
-        "conductor_surfaces": {},
-        "port_surfaces": {},
-        "boundary_surfaces": {},
-    }
-
-    # Assign volume groups for dielectrics
-    for material_name, tags in dielectric_tags.items():
-        new_tags = gmsh_utils.get_tags_after_fragment(
-            tags, geom_dimtags, geom_map, dimension=3
-        )
-        if new_tags:
-            # Only take first N tags (same as original count)
-            new_tags = new_tags[: len(tags)]
-            phys_group = gmsh_utils.assign_physical_group(3, new_tags, material_name)
-            groups["volumes"][material_name] = {
-                "phys_group": phys_group,
-                "tags": new_tags,
-            }
-
-    # Assign surface groups for conductors
-    for layer_name, tag_info in metal_tags.items():
-        if tag_info["volumes"]:
-            all_xy_tags = []
-            all_z_tags = []
-
-            for item in tag_info["volumes"]:
-                if isinstance(item, tuple):
-                    _volumetag, surface_tags = item
-                    # Get updated surface tags after fragment
-                    new_surface_tags = gmsh_utils.get_tags_after_fragment(
-                        surface_tags, geom_dimtags, geom_map, dimension=2
-                    )
-
-                    # Separate xy and z surfaces
-                    for tag in new_surface_tags:
-                        if gmsh_utils.is_vertical_surface(tag):
-                            all_z_tags.append(tag)
-                        else:
-                            all_xy_tags.append(tag)
-
-            if all_xy_tags:
-                phys_group = gmsh_utils.assign_physical_group(
-                    2, all_xy_tags, f"{layer_name}_xy"
-                )
-                groups["conductor_surfaces"][f"{layer_name}_xy"] = {
-                    "phys_group": phys_group,
-                    "tags": all_xy_tags,
-                }
-
-            if all_z_tags:
-                phys_group = gmsh_utils.assign_physical_group(
-                    2, all_z_tags, f"{layer_name}_z"
-                )
-                groups["conductor_surfaces"][f"{layer_name}_z"] = {
-                    "phys_group": phys_group,
-                    "tags": all_z_tags,
-                }
-
-    # Assign port surface groups
-    for port_name, tags in port_tags.items():
-        # Find corresponding port_info entry
-        port_num = int(port_name[1:])  # "P1" -> 1
-        info = next((p for p in port_info if p["portnumber"] == port_num), None)
-
-        if info and info.get("type") == "cpw":
-            # CPW port: create separate physical group for each element
-            element_phys_groups = []
-            for i, tag in enumerate(tags):
-                new_tag_list = gmsh_utils.get_tags_after_fragment(
-                    [tag], geom_dimtags, geom_map, dimension=2
-                )
-                if new_tag_list:
-                    elem_name = f"{port_name}_E{i}"
-                    phys_group = gmsh_utils.assign_physical_group(
-                        2, new_tag_list, elem_name
-                    )
-                    element_phys_groups.append(
-                        {
-                            "phys_group": phys_group,
-                            "tags": new_tag_list,
-                            "direction": info["elements"][i]["direction"],
-                        }
-                    )
-
-            groups["port_surfaces"][port_name] = {
-                "type": "cpw",
-                "elements": element_phys_groups,
-            }
-        else:
-            # Regular single-element port
-            new_tags = gmsh_utils.get_tags_after_fragment(
-                tags, geom_dimtags, geom_map, dimension=2
-            )
-            if new_tags:
-                phys_group = gmsh_utils.assign_physical_group(2, new_tags, port_name)
-                groups["port_surfaces"][port_name] = {
-                    "phys_group": phys_group,
-                    "tags": new_tags,
-                }
-
-    # Assign boundary surfaces (from airbox)
-    if "airbox" in groups["volumes"]:
-        airbox_tags = groups["volumes"]["airbox"]["tags"]
-        if airbox_tags:
-            _, simulation_boundary = kernel.getSurfaceLoops(airbox_tags[0])
-            if simulation_boundary:
-                boundary_tags = list(next(iter(simulation_boundary)))
-                phys_group = gmsh_utils.assign_physical_group(
-                    2, boundary_tags, "Absorbing_boundary"
-                )
-                groups["boundary_surfaces"]["absorbing"] = {
-                    "phys_group": phys_group,
-                    "tags": boundary_tags,
-                }
-
-    kernel.synchronize()
-
-    return groups
-
-
 def _setup_mesh_fields(
     kernel,
     groups: dict,
@@ -620,7 +60,16 @@ def _setup_mesh_fields(
     refined_cellsize: float,
     max_cellsize: float,
 ) -> None:
-    """Set up mesh refinement fields."""
+    """Set up mesh refinement fields.
+
+    Args:
+        kernel: gmsh OCC kernel
+        groups: Physical group information
+        geometry: Extracted geometry data
+        stack: LayerStack with material properties
+        refined_cellsize: Fine mesh size near conductors (um)
+        max_cellsize: Coarse mesh size in air/dielectric (um)
+    """
     # Collect boundary lines from conductor surfaces
     boundary_lines = []
     for surface_info in groups["conductor_surfaces"].values():
@@ -679,282 +128,6 @@ def _setup_mesh_fields(
         gmsh_utils.finalize_mesh_fields(field_ids)
 
 
-def _generate_palace_config(
-    groups: dict,
-    ports: list[PalacePort],
-    port_info: list,
-    stack: LayerStack,
-    output_path: Path,
-    model_name: str,
-    fmax: float,
-    driven_config: DrivenConfig | None = None,
-) -> Path:
-    """Generate Palace config.json file.
-
-    Args:
-        groups: Physical group information from mesh generation
-        ports: List of PalacePort objects
-        port_info: Port metadata list
-        stack: Layer stack for material properties
-        output_path: Output directory path
-        model_name: Base name for output files
-        fmax: Maximum frequency (Hz) - used as fallback if driven_config not provided
-        driven_config: Optional DrivenConfig for frequency sweep settings
-    """
-    # Use driven_config if provided, otherwise fall back to legacy parameters
-    if driven_config is not None:
-        solver_driven = driven_config.to_palace_config()
-    else:
-        # Legacy behavior - compute from fmax
-        freq_step = fmax / 40e9
-        solver_driven = {
-            "Samples": [
-                {
-                    "Type": "Linear",
-                    "MinFreq": 1.0,  # 1 GHz
-                    "MaxFreq": fmax / 1e9,
-                    "FreqStep": freq_step,
-                    "SaveStep": 0,
-                }
-            ],
-            "AdaptiveTol": 0.02,
-        }
-
-    config: dict[str, object] = {
-        "Problem": {
-            "Type": "Driven",
-            "Verbose": 3,
-            "Output": f"output/{model_name}",
-        },
-        "Model": {
-            "Mesh": f"{model_name}.msh",
-            "L0": 1e-6,  # um
-            "Refinement": {
-                "UniformLevels": 0,
-                "Tol": 1e-2,
-                "MaxIts": 0,
-            },
-        },
-        "Solver": {
-            "Linear": {
-                "Type": "Default",
-                "KSPType": "GMRES",
-                "Tol": 1e-6,
-                "MaxIts": 400,
-            },
-            "Order": 2,
-            "Device": "CPU",
-            "Driven": solver_driven,
-        },
-    }
-
-    # Build domains section
-    materials: list[dict[str, object]] = []
-    for material_name, info in groups["volumes"].items():
-        mat_props = stack.materials.get(material_name, {})
-        mat_entry: dict[str, object] = {"Attributes": [info["phys_group"]]}
-
-        if material_name == "airbox":
-            mat_entry["Permittivity"] = 1.0
-            mat_entry["LossTan"] = 0.0
-        else:
-            mat_entry["Permittivity"] = mat_props.get("permittivity", 1.0)
-            sigma = mat_props.get("conductivity", 0.0)
-            if sigma > 0:
-                mat_entry["Conductivity"] = sigma
-            else:
-                mat_entry["LossTan"] = mat_props.get("loss_tangent", 0.0)
-
-        materials.append(mat_entry)
-
-    config["Domains"] = {
-        "Materials": materials,
-        "Postprocessing": {"Energy": [], "Probe": []},
-    }
-
-    # Build boundaries section
-    conductors: list[dict[str, object]] = []
-    for name, info in groups["conductor_surfaces"].items():
-        # Extract layer name from "layer_xy" or "layer_z"
-        layer_name = name.rsplit("_", 1)[0]
-        layer = stack.layers.get(layer_name)
-        if layer:
-            mat_props = stack.materials.get(layer.material, {})
-            conductors.append(
-                {
-                    "Attributes": [info["phys_group"]],
-                    "Conductivity": mat_props.get("conductivity", 5.8e7),
-                    "Thickness": layer.zmax - layer.zmin,
-                }
-            )
-
-    lumped_ports: list[dict[str, object]] = []
-    port_idx = 1
-
-    for port in ports:
-        port_key = f"P{port_idx}"
-        if port_key in groups["port_surfaces"]:
-            port_group = groups["port_surfaces"][port_key]
-
-            if port.multi_element:
-                # Multi-element port (CPW)
-                if port_group.get("type") == "cpw":
-                    elements = [
-                        {
-                            "Attributes": [elem["phys_group"]],
-                            "Direction": elem["direction"],
-                        }
-                        for elem in port_group["elements"]
-                    ]
-
-                    lumped_ports.append(
-                        {
-                            "Index": port_idx,
-                            "R": port.impedance,
-                            "Excitation": port_idx if port.excited else False,
-                            "Elements": elements,
-                        }
-                    )
-            else:
-                # Single-element port
-                direction = (
-                    "Z" if port.geometry == PortGeometry.VIA else port.direction.upper()
-                )
-                lumped_ports.append(
-                    {
-                        "Index": port_idx,
-                        "R": port.impedance,
-                        "Direction": direction,
-                        "Excitation": port_idx if port.excited else False,
-                        "Attributes": [port_group["phys_group"]],
-                    }
-                )
-        port_idx += 1
-
-    boundaries: dict[str, object] = {
-        "Conductivity": conductors,
-        "LumpedPort": lumped_ports,
-    }
-
-    if "absorbing" in groups["boundary_surfaces"]:
-        boundaries["Absorbing"] = {
-            "Attributes": [groups["boundary_surfaces"]["absorbing"]["phys_group"]],
-            "Order": 2,
-        }
-
-    config["Boundaries"] = boundaries
-
-    # Write config file
-    config_path = output_path / "config.json"
-    with config_path.open("w") as f:
-        json.dump(config, f, indent=4)
-
-    # Write port information file
-    port_info_path = output_path / "port_information.json"
-    port_info_struct = {"ports": port_info, "unit": 1e-6, "name": model_name}
-    with port_info_path.open("w") as f:
-        json.dump(port_info_struct, f, indent=4)
-
-    return config_path
-
-
-def _collect_mesh_stats() -> dict:
-    """Collect mesh statistics from gmsh after mesh generation."""
-    stats = {}
-
-    # Get bounding box
-    try:
-        xmin, ymin, zmin, xmax, ymax, zmax = gmsh.model.getBoundingBox(-1, -1)
-        stats["bbox"] = {
-            "xmin": xmin,
-            "ymin": ymin,
-            "zmin": zmin,
-            "xmax": xmax,
-            "ymax": ymax,
-            "zmax": zmax,
-        }
-    except Exception:
-        pass
-
-    # Get node count
-    try:
-        node_tags, _, _ = gmsh.model.mesh.getNodes()
-        stats["nodes"] = len(node_tags)
-    except Exception:
-        pass
-
-    # Get element counts and collect tet tags for quality
-    tet_tags = []
-    try:
-        element_types, element_tags, _ = gmsh.model.mesh.getElements()
-        total_elements = sum(len(tags) for tags in element_tags)
-        stats["elements"] = total_elements
-
-        # Count tetrahedra (type 4) and save tags
-        for etype, tags in zip(element_types, element_tags):
-            if etype == 4:  # 4-node tetrahedron
-                stats["tetrahedra"] = len(tags)
-                tet_tags = list(tags)
-    except Exception:
-        pass
-
-    # Get mesh quality for tetrahedra
-    if tet_tags:
-        # Gamma: inscribed/circumscribed radius ratio (shape quality)
-        try:
-            qualities = gmsh.model.mesh.getElementQualities(tet_tags, "gamma")
-            if len(qualities) > 0:
-                stats["quality"] = {
-                    "min": round(min(qualities), 3),
-                    "max": round(max(qualities), 3),
-                    "mean": round(sum(qualities) / len(qualities), 3),
-                }
-        except Exception:
-            pass
-
-        # SICN: Signed Inverse Condition Number (negative = invalid element)
-        try:
-            sicn = gmsh.model.mesh.getElementQualities(tet_tags, "minSICN")
-            if len(sicn) > 0:
-                sicn_min = min(sicn)
-                invalid_count = sum(1 for s in sicn if s < 0)
-                stats["sicn"] = {
-                    "min": round(sicn_min, 3),
-                    "mean": round(sum(sicn) / len(sicn), 3),
-                    "invalid": invalid_count,
-                }
-        except Exception:
-            pass
-
-        # Edge lengths
-        try:
-            min_edges = gmsh.model.mesh.getElementQualities(tet_tags, "minEdge")
-            max_edges = gmsh.model.mesh.getElementQualities(tet_tags, "maxEdge")
-            if len(min_edges) > 0 and len(max_edges) > 0:
-                stats["edge_length"] = {
-                    "min": round(min(min_edges), 3),
-                    "max": round(max(max_edges), 3),
-                }
-        except Exception:
-            pass
-
-    # Get physical groups with tags
-    try:
-        groups = {"volumes": [], "surfaces": []}
-        for dim, tag in gmsh.model.getPhysicalGroups():
-            name = gmsh.model.getPhysicalName(dim, tag)
-            entry = {"name": name, "tag": tag}
-            if dim == 3:
-                groups["volumes"].append(entry)
-            elif dim == 2:
-                groups["surfaces"].append(entry)
-        stats["groups"] = groups
-    except Exception:
-        pass
-
-    return stats
-
-
 def generate_mesh(
     component,
     stack: LayerStack,
@@ -1017,13 +190,13 @@ def generate_mesh(
     try:
         # Add geometry
         logger.info("Adding metals...")
-        metal_tags = _add_metals(kernel, geometry, stack)
+        metal_tags = add_metals(kernel, geometry, stack)
 
         logger.info("Adding ports...")
-        port_tags, port_info = _add_ports(kernel, ports, stack)
+        port_tags, port_info = add_ports(kernel, ports, stack)
 
         logger.info("Adding dielectrics...")
-        dielectric_tags = _add_dielectrics(kernel, geometry, stack, margin, air_margin)
+        dielectric_tags = add_dielectrics(kernel, geometry, stack, margin, air_margin)
 
         # Fragment geometry
         logger.info("Fragmenting geometry...")
@@ -1031,7 +204,7 @@ def generate_mesh(
 
         # Assign physical groups
         logger.info("Assigning physical groups...")
-        groups = _assign_physical_groups(
+        groups = assign_physical_groups(
             kernel,
             metal_tags,
             dielectric_tags,
@@ -1057,7 +230,7 @@ def generate_mesh(
         gmsh.model.mesh.generate(3)
 
         # Collect mesh statistics
-        mesh_stats = _collect_mesh_stats()
+        mesh_stats = collect_mesh_stats()
 
         # Save mesh
         gmsh.option.setNumber("Mesh.Binary", 0)
@@ -1071,8 +244,15 @@ def generate_mesh(
         config_path = None
         if write_config:
             logger.info("Generating Palace config...")
-            config_path = _generate_palace_config(
-                groups, ports, port_info, stack, output_dir, model_name, fmax, driven_config
+            config_path = generate_palace_config(
+                groups,
+                ports,
+                port_info,
+                stack,
+                output_dir,
+                model_name,
+                fmax,
+                driven_config,
             )
 
     finally:
@@ -1094,44 +274,5 @@ def generate_mesh(
     return result
 
 
-def write_config(
-    mesh_result: MeshResult,
-    stack: LayerStack,
-    ports: list[PalacePort],
-    driven_config: DrivenConfig | None = None,
-) -> Path:
-    """Write Palace config.json from a MeshResult.
-
-    Use this to generate config separately after mesh().
-
-    Args:
-        mesh_result: Result from generate_mesh(write_config=False)
-        stack: LayerStack for material properties
-        ports: List of PalacePort objects
-        driven_config: Optional DrivenConfig for frequency sweep settings
-
-    Returns:
-        Path to the generated config.json
-
-    Example:
-        >>> result = sim.mesh(output_dir, write_config=False)
-        >>> config_path = write_config(result, stack, ports, driven_config)
-    """
-    if not mesh_result.groups:
-        raise ValueError("MeshResult has no groups data. Was it generated with write_config=False?")
-
-    config_path = _generate_palace_config(
-        groups=mesh_result.groups,
-        ports=ports,
-        port_info=mesh_result.port_info,
-        stack=stack,
-        output_path=mesh_result.output_dir,
-        model_name=mesh_result.model_name,
-        fmax=mesh_result.fmax,
-        driven_config=driven_config,
-    )
-
-    # Update the mesh_result with the config path
-    mesh_result.config_path = config_path
-
-    return config_path
+# Re-export write_config from config_generator for backward compatibility
+__all__ = ["GeometryData", "MeshResult", "generate_mesh", "write_config"]