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

gsim/palace/eigenmode.py

@@ -8,11 +8,8 @@ from __future__ import annotations
 
 import logging
 import tempfile
-import warnings
 from pathlib import Path
-
-logger = logging.getLogger(__name__)
-from typing import TYPE_CHECKING, Any, Literal
+from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
 
@@ -29,16 +26,14 @@ from gsim.palace.models import (
     ValidationResult,
 )
 
-if TYPE_CHECKING:
-    from gdsfactory.component import Component
+logger = logging.getLogger(__name__)
 
 
 class EigenmodeSim(PalaceSimMixin, BaseModel):
     """Eigenmode simulation for finding resonant frequencies.
 
     This class configures and runs eigenmode simulations to find
-    resonant frequencies and mode shapes of structures. Uses composition
-    (no inheritance) with shared Geometry and Stack components from gsim.common.
+    resonant frequencies and mode shapes of structures.
 
     Example:
         >>> from gsim.palace import EigenmodeSim
@@ -48,7 +43,8 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
         >>> sim.set_stack(air_above=300.0)
         >>> sim.add_port("o1", layer="topmetal2", length=5.0)
         >>> sim.set_eigenmode(num_modes=10, target=50e9)
-        >>> sim.mesh("./sim", preset="default")
+        >>> sim.set_output_dir("./sim")
+        >>> sim.mesh(preset="default")
         >>> results = sim.simulate()
 
     Attributes:
@@ -89,66 +85,7 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
     _configured_ports: bool = PrivateAttr(default=False)
 
     # -------------------------------------------------------------------------
-    # Geometry methods
-    # -------------------------------------------------------------------------
-
-    def set_geometry(self, component: Component) -> None:
-        """Set the gdsfactory component for simulation.
-
-        Args:
-            component: gdsfactory Component to simulate
-
-        Example:
-            >>> sim.set_geometry(my_component)
-        """
-        self.geometry = Geometry(component=component)
-
-    @property
-    def component(self) -> Component | None:
-        """Get the current component (for backward compatibility)."""
-        return self.geometry.component if self.geometry else None
-
-    @property
-    def _component(self) -> Component | None:
-        """Internal component access (backward compatibility)."""
-        return self.component
-
-    # -------------------------------------------------------------------------
-    # Stack methods
-    # -------------------------------------------------------------------------
-
-    def set_stack(
-        self,
-        *,
-        yaml_path: str | Path | None = None,
-        air_above: float = 200.0,
-        substrate_thickness: float = 2.0,
-        include_substrate: bool = False,
-        **kwargs,
-    ) -> None:
-        """Configure the layer stack.
-
-        Args:
-            yaml_path: Path to custom YAML stack file
-            air_above: Air box height above top metal in um
-            substrate_thickness: Thickness below z=0 in um
-            include_substrate: Include lossy silicon substrate
-            **kwargs: Additional args passed to extract_layer_stack
-
-        Example:
-            >>> sim.set_stack(air_above=300.0, substrate_thickness=2.0)
-        """
-        self._stack_kwargs = {
-            "yaml_path": yaml_path,
-            "air_above": air_above,
-            "substrate_thickness": substrate_thickness,
-            "include_substrate": include_substrate,
-            **kwargs,
-        }
-        self.stack = None
-
-    # -------------------------------------------------------------------------
-    # Port methods
+    # Port methods (Eigenmode can have ports for Q-factor calculation)
     # -------------------------------------------------------------------------
 
     def add_port(
@@ -259,86 +196,11 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
             tolerance=tolerance,
         )
 
-    # -------------------------------------------------------------------------
-    # Material methods
-    # -------------------------------------------------------------------------
-
-    def set_material(
-        self,
-        name: str,
-        *,
-        type: Literal["conductor", "dielectric", "semiconductor"] | None = None,
-        conductivity: float | None = None,
-        permittivity: float | None = None,
-        loss_tangent: float | None = None,
-    ) -> None:
-        """Override or add material properties.
-
-        Args:
-            name: Material name
-            type: Material type (conductor, dielectric, semiconductor)
-            conductivity: Conductivity in S/m (for conductors)
-            permittivity: Relative permittivity (for dielectrics)
-            loss_tangent: Dielectric loss tangent
-
-        Example:
-            >>> sim.set_material("aluminum", type="conductor", conductivity=3.8e7)
-        """
-        if type is None:
-            if conductivity is not None and conductivity > 1e4:
-                type = "conductor"
-            elif permittivity is not None:
-                type = "dielectric"
-            else:
-                type = "dielectric"
-
-        self.materials[name] = MaterialConfig(
-            type=type,
-            conductivity=conductivity,
-            permittivity=permittivity,
-            loss_tangent=loss_tangent,
-        )
-
-    def set_numerical(
-        self,
-        *,
-        order: int = 2,
-        tolerance: float = 1e-6,
-        max_iterations: int = 400,
-        solver_type: Literal["Default", "SuperLU", "STRUMPACK", "MUMPS"] = "Default",
-        preconditioner: Literal["Default", "AMS", "BoomerAMG"] = "Default",
-        device: Literal["CPU", "GPU"] = "CPU",
-        num_processors: int | None = None,
-    ) -> None:
-        """Configure numerical solver parameters.
-
-        Args:
-            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)
-
-        Example:
-            >>> sim.set_numerical(order=3, tolerance=1e-8)
-        """
-        self.numerical = NumericalConfig(
-            order=order,
-            tolerance=tolerance,
-            max_iterations=max_iterations,
-            solver_type=solver_type,
-            preconditioner=preconditioner,
-            device=device,
-            num_processors=num_processors,
-        )
-
     # -------------------------------------------------------------------------
     # Validation
     # -------------------------------------------------------------------------
 
-    def validate(self) -> ValidationResult:
+    def validate_config(self) -> ValidationResult:
         """Validate the simulation configuration.
 
         Returns:
@@ -360,18 +222,19 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
         # Eigenmode simulations may not require ports
         if not self.ports and not self.cpw_ports:
             warnings_list.append(
-                "No ports configured. Eigenmode will find all modes without port loading."
+                "No ports configured. Eigenmode finds all modes without port loading."
             )
 
         # Validate port configurations
         for port in self.ports:
             if port.geometry == "inplane" and port.layer is None:
                 errors.append(f"Port '{port.name}': inplane ports require 'layer'")
-            if port.geometry == "via":
-                if port.from_layer is None or port.to_layer is None:
-                    errors.append(
-                        f"Port '{port.name}': via ports require 'from_layer' and 'to_layer'"
-                    )
+            if port.geometry == "via" and (
+                port.from_layer is None or port.to_layer is None
+            ):
+                errors.append(
+                    f"Port '{port.name}': via ports require 'from_layer' and 'to_layer'"
+                )
 
         valid = len(errors) == 0
         return ValidationResult(valid=valid, errors=errors, warnings=warnings_list)
@@ -380,22 +243,7 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
     # Internal helpers
     # -------------------------------------------------------------------------
 
-    def _resolve_stack(self) -> LayerStack:
-        """Resolve the layer stack from PDK or YAML."""
-        from gsim.common.stack import get_stack
-
-        yaml_path = self._stack_kwargs.pop("yaml_path", None)
-        legacy_stack = get_stack(yaml_path=yaml_path, **self._stack_kwargs)
-        self._stack_kwargs["yaml_path"] = yaml_path
-
-        for name, props in self.materials.items():
-            legacy_stack.materials[name] = props.to_dict()
-
-        self.stack = legacy_stack
-
-        return legacy_stack
-
-    def _configure_ports_on_component(self, stack: LayerStack) -> None:
+    def _configure_ports_on_component(self, stack: LayerStack) -> None:  # noqa: ARG002
         """Configure ports on the component."""
         from gsim.palace.ports import (
             configure_cpw_port,
@@ -423,7 +271,7 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
                     f"Available: {[p.name for p in component.ports]}"
                 )
 
-            if port_config.geometry == "inplane":
+            if port_config.geometry == "inplane" and port_config.layer is not None:
                 configure_inplane_port(
                     gf_port,
                     layer=port_config.layer,
@@ -431,7 +279,9 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
                     impedance=port_config.impedance,
                     excited=port_config.excited,
                 )
-            elif port_config.geometry == "via":
+            elif port_config.geometry == "via" and (
+                port_config.from_layer is not None and port_config.to_layer is not None
+            ):
                 configure_via_port(
                     gf_port,
                     from_layer=port_config.from_layer,
@@ -466,57 +316,6 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
 
         self._configured_ports = True
 
-    def _build_mesh_config(
-        self,
-        preset: Literal["coarse", "default", "fine"] | None,
-        refined_mesh_size: float | None,
-        max_mesh_size: float | None,
-        margin: float | None,
-        air_above: float | None,
-        fmax: float | None,
-        show_gui: bool,
-    ) -> MeshConfig:
-        """Build mesh config from preset with optional overrides."""
-        if preset == "coarse":
-            mesh_config = MeshConfig.coarse()
-        elif preset == "fine":
-            mesh_config = MeshConfig.fine()
-        else:
-            mesh_config = MeshConfig.default()
-
-        overrides = []
-        if preset is not None:
-            if refined_mesh_size is not None:
-                overrides.append(f"refined_mesh_size={refined_mesh_size}")
-            if max_mesh_size is not None:
-                overrides.append(f"max_mesh_size={max_mesh_size}")
-            if margin is not None:
-                overrides.append(f"margin={margin}")
-            if air_above is not None:
-                overrides.append(f"air_above={air_above}")
-            if fmax is not None:
-                overrides.append(f"fmax={fmax}")
-
-            if overrides:
-                warnings.warn(
-                    f"Preset '{preset}' values overridden by: {', '.join(overrides)}",
-                    stacklevel=4,
-                )
-
-        if refined_mesh_size is not None:
-            mesh_config.refined_mesh_size = refined_mesh_size
-        if max_mesh_size is not None:
-            mesh_config.max_mesh_size = max_mesh_size
-        if margin is not None:
-            mesh_config.margin = margin
-        if air_above is not None:
-            mesh_config.air_above = air_above
-        if fmax is not None:
-            mesh_config.fmax = fmax
-        mesh_config.show_gui = show_gui
-
-        return mesh_config
-
     def _generate_mesh_internal(
         self,
         output_dir: Path,
@@ -609,11 +408,9 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
 
         component = self.geometry.component if self.geometry else None
 
-        validation = self.validate()
+        validation = self.validate_config()
         if not validation.valid:
-            raise ValueError(
-                f"Invalid configuration:\n" + "\n".join(validation.errors)
-            )
+            raise ValueError("Invalid configuration:\n" + "\n".join(validation.errors))
 
         mesh_config = self._build_mesh_config(
             preset=preset,
@@ -648,37 +445,12 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
                 config=legacy_mesh_config,
             )
 
-    # -------------------------------------------------------------------------
-    # Convenience methods
-    # -------------------------------------------------------------------------
-
-    def show_stack(self) -> None:
-        """Print the layer stack table."""
-        from gsim.common.stack import print_stack_table
-
-        if self.stack is None:
-            self._resolve_stack()
-
-        if self.stack is not None:
-            print_stack_table(self.stack)
-
-    def plot_stack(self) -> None:
-        """Plot the layer stack visualization."""
-        from gsim.common.stack import plot_stack
-
-        if self.stack is None:
-            self._resolve_stack()
-
-        if self.stack is not None:
-            plot_stack(self.stack)
-
     # -------------------------------------------------------------------------
     # Mesh generation
     # -------------------------------------------------------------------------
 
     def mesh(
         self,
-        output_dir: str | Path,
         *,
         preset: Literal["coarse", "default", "fine"] | None = None,
         refined_mesh_size: float | None = None,
@@ -690,25 +462,37 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
         model_name: str = "palace",
         verbose: bool = True,
     ) -> SimulationResult:
-        """Generate the mesh and configuration files.
+        """Generate the mesh for Palace simulation.
+
+        Requires set_output_dir() to be called first.
 
         Args:
-            output_dir: Directory for output files
             preset: Mesh quality preset ("coarse", "default", "fine")
-            refined_mesh_size: Mesh size near conductors (um)
-            max_mesh_size: Max mesh size in air/dielectric (um)
-            margin: XY margin around design (um)
-            air_above: Air above top metal (um)
-            fmax: Max frequency for mesh sizing (Hz)
+            refined_mesh_size: Mesh size near conductors (um), overrides preset
+            max_mesh_size: Max mesh size in air/dielectric (um), overrides preset
+            margin: XY margin around design (um), overrides preset
+            air_above: Air above top metal (um), overrides preset
+            fmax: Max frequency for mesh sizing (Hz), overrides preset
             show_gui: Show gmsh GUI during meshing
             model_name: Base name for output files
             verbose: Print progress messages
 
         Returns:
-            SimulationResult with mesh and config paths
+            SimulationResult with mesh path
+
+        Raises:
+            ValueError: If output_dir not set or configuration is invalid
+
+        Example:
+            >>> sim.set_output_dir("./sim")
+            >>> result = sim.mesh(preset="fine")
+            >>> print(f"Mesh saved to: {result.mesh_path}")
         """
         from gsim.palace.ports import extract_ports
 
+        if self._output_dir is None:
+            raise ValueError("Output directory not set. Call set_output_dir() first.")
+
         component = self.geometry.component if self.geometry else None
 
         mesh_config = self._build_mesh_config(
@@ -721,15 +505,11 @@ class EigenmodeSim(PalaceSimMixin, BaseModel):
             show_gui=show_gui,
         )
 
-        validation = self.validate()
+        validation = self.validate_config()
         if not validation.valid:
-            raise ValueError(
-                f"Invalid configuration:\n" + "\n".join(validation.errors)
-            )
+            raise ValueError("Invalid configuration:\n" + "\n".join(validation.errors))
 
-        output_dir = Path(output_dir)
-        output_dir.mkdir(parents=True, exist_ok=True)
-        self._output_dir = output_dir
+        output_dir = self._output_dir
 
         stack = self._resolve_stack()