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

gsim/palace/mesh/generator.py

@@ -18,8 +18,9 @@ import gmsh
 from . import gmsh_utils
 
 if TYPE_CHECKING:
+    from gsim.palace.models import DrivenConfig
     from gsim.palace.ports.config import PalacePort
-    from gsim.palace.stack import LayerStack
+    from gsim.common.stack import LayerStack
 
 from gsim.palace.ports.config import PortGeometry
 
@@ -42,6 +43,12 @@ class MeshResult:
     mesh_path: Path
     config_path: Path | None = None
     port_info: list = field(default_factory=list)
+    mesh_stats: dict = field(default_factory=dict)
+    # Data needed for deferred config generation
+    groups: dict = field(default_factory=dict)
+    output_dir: Path | None = None
+    model_name: str = "palace"
+    fmax: float = 100e9
 
 
 def extract_geometry(component, stack: LayerStack) -> GeometryData:
@@ -680,8 +687,39 @@ def _generate_palace_config(
     output_path: Path,
     model_name: str,
     fmax: float,
+    driven_config: DrivenConfig | None = None,
 ) -> Path:
-    """Generate Palace config.json file."""
+    """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",
@@ -706,18 +744,7 @@ def _generate_palace_config(
             },
             "Order": 2,
             "Device": "CPU",
-            "Driven": {
-                "Samples": [
-                    {
-                        "Type": "Linear",
-                        "MinFreq": 1e9 / 1e9,
-                        "MaxFreq": fmax / 1e9,
-                        "FreqStep": fmax / 40e9,
-                        "SaveStep": 0,
-                    }
-                ],
-                "AdaptiveTol": 2e-2,
-            },
+            "Driven": solver_driven,
         },
     }
 
@@ -831,6 +858,103 @@ def _generate_palace_config(
     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,
@@ -843,6 +967,8 @@ def generate_mesh(
     air_margin: float = 50.0,
     fmax: float = 100e9,
     show_gui: bool = False,
+    driven_config: DrivenConfig | None = None,
+    write_config: bool = True,
 ) -> MeshResult:
     """Generate mesh for Palace EM simulation.
 
@@ -858,6 +984,8 @@ def generate_mesh(
         air_margin: Air box margin (um)
         fmax: Max frequency for config (Hz)
         show_gui: Show gmsh GUI during meshing
+        driven_config: Optional DrivenConfig for frequency sweep settings
+        write_config: Whether to write config.json (default True)
 
     Returns:
         MeshResult with paths and metadata
@@ -928,6 +1056,9 @@ def generate_mesh(
         logger.info("Generating mesh...")
         gmsh.model.mesh.generate(3)
 
+        # Collect mesh statistics
+        mesh_stats = _collect_mesh_stats()
+
         # Save mesh
         gmsh.option.setNumber("Mesh.Binary", 0)
         gmsh.option.setNumber("Mesh.SaveAll", 0)
@@ -936,21 +1067,71 @@ def generate_mesh(
 
         logger.info("Mesh saved: %s", msh_path)
 
-        # Generate config
-        logger.info("Generating Palace config...")
-        config_path = _generate_palace_config(
-            groups, ports, port_info, stack, output_dir, model_name, fmax
-        )
+        # Generate config if requested
+        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
+            )
 
     finally:
         gmsh.clear()
         gmsh.finalize()
 
-    # Build result
+    # Build result (store groups for deferred config generation)
     result = MeshResult(
         mesh_path=msh_path,
         config_path=config_path,
         port_info=port_info,
+        mesh_stats=mesh_stats,
+        groups=groups,
+        output_dir=output_dir,
+        model_name=model_name,
+        fmax=fmax,
     )
 
     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

gsim/palace/mesh/pipeline.py

@@ -12,8 +12,9 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from gsim.common.stack import LayerStack
+    from gsim.palace.models import DrivenConfig
     from gsim.palace.ports.config import PalacePort
-    from gsim.palace.stack.extractor import LayerStack
 
 from gsim.palace.mesh.generator import generate_mesh as gen_mesh
 
@@ -138,6 +139,15 @@ class MeshResult:
     # Port metadata
     port_info: list = field(default_factory=list)
 
+    # Mesh statistics
+    mesh_stats: dict = field(default_factory=dict)
+
+    # Data needed for deferred config generation
+    groups: dict = field(default_factory=dict)
+    output_dir: Path | None = None
+    model_name: str = "palace"
+    fmax: float = 100e9
+
 
 def generate_mesh(
     component,
@@ -146,6 +156,8 @@ def generate_mesh(
     output_dir: str | Path,
     config: MeshConfig | None = None,
     model_name: str = "palace",
+    driven_config: DrivenConfig | None = None,
+    write_config: bool = True,
 ) -> MeshResult:
     """Generate mesh for Palace EM simulation.
 
@@ -156,6 +168,8 @@ def generate_mesh(
         output_dir: Directory for output files
         config: MeshConfig with mesh parameters
         model_name: Base name for output files (default: "mesh" -> mesh.msh)
+        driven_config: Optional DrivenConfig for frequency sweep settings
+        write_config: Whether to write config.json (default True)
 
     Returns:
         MeshResult with mesh path and metadata
@@ -178,6 +192,8 @@ def generate_mesh(
         air_margin=config.margin,
         fmax=config.fmax,
         show_gui=config.show_gui,
+        driven_config=driven_config,
+        write_config=write_config,
     )
 
     # Convert to pipeline's MeshResult format
@@ -185,4 +201,9 @@ def generate_mesh(
         mesh_path=result.mesh_path,
         config_path=result.config_path,
         port_info=result.port_info,
+        mesh_stats=result.mesh_stats,
+        groups=result.groups,
+        output_dir=result.output_dir,
+        model_name=result.model_name,
+        fmax=result.fmax,
     )

gsim/palace/models/__init__.py

@@ -0,0 +1,60 @@
+"""Pydantic models for Palace EM simulation configuration.
+
+This module provides Pydantic v2 models for configuring Palace simulations,
+offering validation, serialization, and a clean API.
+
+Submodules:
+    - geometry: GeometryConfig
+    - stack: MaterialConfig (Layer/Stack are in gsim.common.stack)
+    - ports: PortConfig, CPWPortConfig, TerminalConfig, WavePortConfig
+    - mesh: MeshConfig
+    - numerical: NumericalConfig
+    - problems: DrivenConfig, EigenmodeConfig, ElectrostaticConfig, etc.
+    - results: SimulationResult, ValidationResult
+"""
+
+from __future__ import annotations
+
+from gsim.palace.models.geometry import GeometryConfig
+from gsim.palace.models.mesh import MeshConfig
+from gsim.palace.models.numerical import NumericalConfig
+from gsim.palace.models.ports import (
+    CPWPortConfig,
+    PortConfig,
+    TerminalConfig,
+    WavePortConfig,
+)
+from gsim.palace.models.problems import (
+    DrivenConfig,
+    EigenmodeConfig,
+    ElectrostaticConfig,
+    MagnetostaticConfig,
+    TransientConfig,
+)
+from gsim.palace.models.results import SimulationResult, ValidationResult
+from gsim.palace.models.stack import MaterialConfig
+
+__all__ = [
+    # Geometry
+    "GeometryConfig",
+    # Stack
+    "MaterialConfig",
+    # Ports
+    "CPWPortConfig",
+    "PortConfig",
+    "TerminalConfig",
+    "WavePortConfig",
+    # Mesh
+    "MeshConfig",
+    # Numerical
+    "NumericalConfig",
+    # Problems
+    "DrivenConfig",
+    "EigenmodeConfig",
+    "ElectrostaticConfig",
+    "MagnetostaticConfig",
+    "TransientConfig",
+    # Results
+    "SimulationResult",
+    "ValidationResult",
+]

gsim/palace/models/geometry.py

@@ -0,0 +1,34 @@
+"""Geometry configuration models for Palace simulations.
+
+This module contains Pydantic models for geometry-related settings.
+Note: The actual gdsfactory Component is stored directly on the simulation
+classes since it's not serializable with Pydantic.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class GeometryConfig(BaseModel):
+    """Configuration for geometry settings.
+
+    This model stores metadata about the component being simulated.
+    The actual Component object is stored separately on simulation classes.
+
+    Attributes:
+        component_name: Name of the component being simulated
+        bounds: Bounding box as (xmin, ymin, xmax, ymax)
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    component_name: str | None = None
+    bounds: tuple[float, float, float, float] | None = Field(
+        default=None, description="Bounding box (xmin, ymin, xmax, ymax)"
+    )
+
+
+__all__ = [
+    "GeometryConfig",
+]

gsim/palace/models/mesh.py

@@ -0,0 +1,95 @@
+"""Mesh configuration models for Palace simulations.
+
+This module contains Pydantic models for mesh generation configuration.
+"""
+
+from __future__ import annotations
+
+from typing import Self
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class MeshConfig(BaseModel):
+    """Configuration for mesh generation with COMSOL-style presets.
+
+    Attributes:
+        refined_mesh_size: Mesh size near conductors (um)
+        max_mesh_size: Maximum mesh size in air/dielectric (um)
+        cells_per_wavelength: Number of mesh cells per wavelength
+        margin: XY margin around design (um)
+        air_above: Air above top metal (um)
+        fmax: Maximum frequency for mesh sizing (Hz)
+        boundary_conditions: List of boundary conditions for each face
+        show_gui: Show gmsh GUI during meshing
+        preview_only: Generate preview only, don't save mesh
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    refined_mesh_size: float = Field(default=5.0, gt=0)
+    max_mesh_size: float = Field(default=300.0, gt=0)
+    cells_per_wavelength: int = Field(default=10, ge=1)
+    margin: float = Field(default=50.0, ge=0)
+    air_above: float = Field(default=100.0, ge=0)
+    fmax: float = Field(default=100e9, gt=0)
+    boundary_conditions: list[str] | None = None
+    show_gui: bool = False
+    preview_only: bool = False
+
+    @model_validator(mode="after")
+    def set_default_boundary_conditions(self) -> Self:
+        """Set default boundary conditions if not provided."""
+        if self.boundary_conditions is None:
+            self.boundary_conditions = ["ABC", "ABC", "ABC", "ABC", "ABC", "ABC"]
+        return self
+
+    @classmethod
+    def coarse(cls, **kwargs) -> Self:
+        """Fast mesh for quick iteration (~2.5 elements per wavelength).
+
+        This preset is suitable for initial debugging and quick checks.
+        Not recommended for accurate results.
+        """
+        defaults = {
+            "refined_mesh_size": 10.0,
+            "max_mesh_size": 600.0,
+            "cells_per_wavelength": 5,
+        }
+        defaults.update(kwargs)
+        return cls(**defaults)
+
+    @classmethod
+    def default(cls, **kwargs) -> Self:
+        """Balanced mesh matching COMSOL defaults (~5 elements per wavelength).
+
+        This preset provides a good balance between accuracy and computation time.
+        Suitable for most simulations.
+        """
+        defaults = {
+            "refined_mesh_size": 5.0,
+            "max_mesh_size": 300.0,
+            "cells_per_wavelength": 10,
+        }
+        defaults.update(kwargs)
+        return cls(**defaults)
+
+    @classmethod
+    def fine(cls, **kwargs) -> Self:
+        """High accuracy mesh (~10 elements per wavelength).
+
+        This preset provides higher accuracy at the cost of increased
+        computation time. Use for final production simulations.
+        """
+        defaults = {
+            "refined_mesh_size": 2.0,
+            "max_mesh_size": 70.0,
+            "cells_per_wavelength": 20,
+        }
+        defaults.update(kwargs)
+        return cls(**defaults)
+
+
+__all__ = [
+    "MeshConfig",
+]

gsim/palace/models/numerical.py

@@ -0,0 +1,66 @@
+"""Numerical solver configuration models for Palace simulations.
+
+This module contains Pydantic models for numerical solver settings.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class NumericalConfig(BaseModel):
+    """Numerical solver configuration.
+
+    Attributes:
+        order: Finite element order (1-4)
+        tolerance: Linear solver tolerance
+        max_iterations: Maximum solver iterations
+        solver_type: Linear solver type
+        preconditioner: Preconditioner type
+        device: Compute device (CPU or GPU)
+        num_processors: Number of processors (None = auto)
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    # Element order
+    order: int = Field(default=2, ge=1, le=4)
+
+    # Linear solver
+    tolerance: float = Field(default=1e-6, gt=0)
+    max_iterations: int = Field(default=400, ge=1)
+    solver_type: Literal["Default", "SuperLU", "STRUMPACK", "MUMPS"] = "Default"
+
+    # Preconditioner
+    preconditioner: Literal["Default", "AMS", "BoomerAMG"] = "Default"
+
+    # Device
+    device: Literal["CPU", "GPU"] = "CPU"
+
+    # Partitioning
+    num_processors: int | None = None  # None = auto
+
+    def to_palace_config(self) -> dict:
+        """Convert to Palace JSON config format."""
+        config = {
+            "Order": self.order,
+            "Solver": {
+                "Tolerance": self.tolerance,
+                "MaxIterations": self.max_iterations,
+            },
+        }
+
+        if self.solver_type != "Default":
+            config["Solver"]["Type"] = self.solver_type
+
+        if self.preconditioner != "Default":
+            config["Solver"]["Preconditioner"] = self.preconditioner
+
+        return config
+
+
+__all__ = [
+    "NumericalConfig",
+]