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

gsim/__init__.py

@@ -9,7 +9,7 @@ Currently includes:
 
 from __future__ import annotations
 
-__version__ = "0.0.0"
+__version__ = "0.0.2"
 
 __all__ = [
     "__version__",

gsim/common/__init__.py

@@ -0,0 +1,61 @@
+"""Common components shared between Palace and FDTD solvers.
+
+This module provides shared data models and utilities that can be used
+across different electromagnetic solvers (Palace, FDTD, etc.).
+
+Classes:
+    Geometry: Wrapper for gdsfactory Component with computed properties
+    LayerStack: Layer stack data model with extraction from PDK
+"""
+
+from __future__ import annotations
+
+from gsim.common.geometry import Geometry
+from gsim.common.stack import (
+    MATERIALS_DB,
+    Layer,
+    LayerStack,
+    MaterialProperties,
+    StackLayer,
+    ValidationResult,
+    extract_from_pdk,
+    extract_layer_stack,
+    get_material_properties,
+    get_stack,
+    load_stack_yaml,
+    material_is_conductor,
+    material_is_dielectric,
+    parse_layer_stack,
+    plot_stack,
+    print_stack,
+    print_stack_table,
+)
+
+# Alias for backward compatibility
+Stack = LayerStack
+
+__all__ = [
+    # Geometry
+    "Geometry",
+    # Stack (LayerStack is the primary name, Stack is an alias)
+    "LayerStack",
+    "Stack",
+    "Layer",
+    "StackLayer",
+    "ValidationResult",
+    # Stack functions
+    "get_stack",
+    "load_stack_yaml",
+    "extract_from_pdk",
+    "extract_layer_stack",
+    "parse_layer_stack",
+    "print_stack",
+    "print_stack_table",
+    "plot_stack",
+    # Materials
+    "MATERIALS_DB",
+    "MaterialProperties",
+    "get_material_properties",
+    "material_is_conductor",
+    "material_is_dielectric",
+]

gsim/common/geometry.py

@@ -0,0 +1,76 @@
+"""Geometry wrapper for gdsfactory components.
+
+This module provides a Geometry class that wraps gdsfactory Components
+with computed properties useful for simulation setup.
+"""
+
+from __future__ import annotations
+
+from functools import cached_property
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Geometry(BaseModel):
+    """Shared geometry wrapper for gdsfactory Component.
+
+    This class wraps a gdsfactory Component and provides computed properties
+    that are useful for simulation setup (bounds, ports, etc.).
+
+    Attributes:
+        component: The wrapped gdsfactory Component
+
+    Example:
+        >>> from gdsfactory.components import straight
+        >>> c = straight(length=100)
+        >>> geom = Geometry(component=c)
+        >>> print(geom.bounds)
+        (0.0, -0.25, 100.0, 0.25)
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    component: Any  # gdsfactory Component (Any to avoid import issues)
+
+    @cached_property
+    def bounds(self) -> tuple[float, float, float, float]:
+        """Get bounding box (xmin, ymin, xmax, ymax) in um."""
+        bbox = self.component.dbbox()
+        return (bbox.left, bbox.bottom, bbox.right, bbox.top)
+
+    @cached_property
+    def ports(self) -> list:
+        """Get list of ports on the component."""
+        return list(self.component.ports)
+
+    @cached_property
+    def port_names(self) -> list[str]:
+        """Get list of port names."""
+        return [p.name for p in self.component.ports]
+
+    @property
+    def width(self) -> float:
+        """Get width (x-extent) of geometry in um."""
+        xmin, _, xmax, _ = self.bounds
+        return xmax - xmin
+
+    @property
+    def height(self) -> float:
+        """Get height (y-extent) of geometry in um."""
+        _, ymin, _, ymax = self.bounds
+        return ymax - ymin
+
+    def get_port(self, name: str) -> Any:
+        """Get a port by name.
+
+        Args:
+            name: Port name to find
+
+        Returns:
+            Port object if found, None otherwise
+        """
+        for port in self.component.ports:
+            if port.name == name:
+                return port
+        return None

gsim/{palace → common}/stack/__init__.py

@@ -1,8 +1,11 @@
-"""Layer stack extraction and parsing for Palace EM simulation.
+"""Layer stack extraction and parsing for EM simulation.
+
+This module provides stack extraction functionality that can be shared
+between different solvers (Palace, FDTD, etc.).
 
 Usage:
     # From PDK module (preferred, no file needed)
-    from gsim.palace.stack import get_stack
+    from gsim.common.stack import get_stack
     stack = get_stack(pdk=ihp)
 
     # From YAML file (for custom/tweaked stacks)
@@ -19,21 +22,21 @@ from pathlib import Path
 import gdsfactory as gf
 import yaml
 
-from gsim.palace.stack.extractor import (
+from gsim.common.stack.extractor import (
     Layer,
     LayerStack,
     ValidationResult,
     extract_from_pdk,
     extract_layer_stack,
 )
-from gsim.palace.stack.materials import (
+from gsim.common.stack.materials import (
     MATERIALS_DB,
     MaterialProperties,
     get_material_properties,
     material_is_conductor,
     material_is_dielectric,
 )
-from gsim.palace.stack.visualization import (
+from gsim.common.stack.visualization import (
     StackLayer,
     parse_layer_stack,
     plot_stack,

gsim/{palace → common}/stack/extractor.py

@@ -7,15 +7,15 @@ that can be used for Palace EM simulation.
 from __future__ import annotations
 
 import logging
-from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 import yaml
 from gdsfactory.technology import LayerLevel
 from gdsfactory.technology import LayerStack as GfLayerStack
+from pydantic import BaseModel, ConfigDict, Field
 
-from gsim.palace.stack.materials import (
+from gsim.common.stack.materials import (
     MATERIALS_DB,
     get_material_properties,
 )
@@ -23,20 +23,18 @@ from gsim.palace.stack.materials import (
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class Layer:
+class Layer(BaseModel):
     """Layer information for Palace simulation."""
 
+    model_config = ConfigDict(validate_assignment=True)
+
     name: str
     gds_layer: tuple[int, int]  # (layer, datatype)
     zmin: float  # um
     zmax: float  # um
     thickness: float  # um
     material: str
-    layer_type: str  # "conductor", "via", "dielectric", "substrate"
-
-    # Mesh resolution control
-    # Options: "fine", "medium", "coarse" or a float in um
+    layer_type: Literal["conductor", "via", "dielectric", "substrate"]
     mesh_resolution: str | float = "medium"
 
     def get_mesh_size(self, base_size: float = 1.0) -> float:
@@ -56,7 +54,7 @@ class Layer:
             "medium": base_size,
             "coarse": base_size * 2.0,
         }
-        return resolution_map.get(self.mesh_resolution, base_size)
+        return resolution_map.get(str(self.mesh_resolution), base_size)
 
     def to_dict(self) -> dict:
         """Convert to dictionary for YAML output."""
@@ -71,13 +69,14 @@ class Layer:
         }
 
 
-@dataclass
-class ValidationResult:
+class ValidationResult(BaseModel):
     """Result of stack validation."""
 
+    model_config = ConfigDict(validate_assignment=True)
+
     valid: bool
-    errors: list[str] = field(default_factory=list)
-    warnings: list[str] = field(default_factory=list)
+    errors: list[str] = Field(default_factory=list)
+    warnings: list[str] = Field(default_factory=list)
 
     def __bool__(self) -> bool:
         return self.valid
@@ -97,18 +96,19 @@ class ValidationResult:
         return "\n".join(lines)
 
 
-@dataclass
-class LayerStack:
+class LayerStack(BaseModel):
     """Complete layer stack for Palace simulation."""
 
-    pdk_name: str
+    model_config = ConfigDict(validate_assignment=True)
+
+    pdk_name: str = "unknown"
     units: str = "um"
-    layers: dict[str, Layer] = field(default_factory=dict)
-    materials: dict[str, dict] = field(default_factory=dict)
-    dielectrics: list[dict] = field(default_factory=list)
-    simulation: dict = field(default_factory=dict)
+    layers: dict[str, Layer] = Field(default_factory=dict)
+    materials: dict[str, dict] = Field(default_factory=dict)
+    dielectrics: list[dict] = Field(default_factory=list)
+    simulation: dict = Field(default_factory=dict)
 
-    def validate(self, tolerance: float = 0.001) -> ValidationResult:
+    def validate_stack(self, tolerance: float = 0.001) -> ValidationResult:
         """Validate the layer stack for simulation readiness.
 
         Checks:
@@ -132,7 +132,6 @@ class LayerStack:
         # Collect materials from layers
         for name, layer in self.layers.items():
             materials_used.add(layer.material)
-            # Check for invalid thickness
             if layer.thickness < 0:
                 errors.append(
                     f"Layer '{name}' has negative thickness: {layer.thickness}"
@@ -165,10 +164,8 @@ class LayerStack:
 
         # 2. Check z-axis continuity of dielectrics
         if self.dielectrics:
-            # Sort dielectrics by zmin
             sorted_dielectrics = sorted(self.dielectrics, key=lambda d: d["zmin"])
 
-            # Check for gaps between dielectric regions
             for i in range(len(sorted_dielectrics) - 1):
                 current = sorted_dielectrics[i]
                 next_d = sorted_dielectrics[i + 1]
@@ -181,13 +178,11 @@ class LayerStack:
                         f"(zmin={next_d['zmin']:.4f}): gap={gap:.4f} um"
                     )
                 elif gap < -tolerance:
-                    # Overlap - this might be intentional
                     warnings.append(
                         f"Z-axis overlap between '{current['name']}' and "
                         f"'{next_d['name']}': overlap={-gap:.4f} um"
                     )
 
-            # Get overall dielectric envelope
             z_min_dielectric = sorted_dielectrics[0]["zmin"]
             z_max_dielectric = sorted_dielectrics[-1]["zmax"]
         else:
@@ -281,61 +276,43 @@ class LayerStack:
 
 
 def _get_gds_layer_tuple(layer_level: LayerLevel) -> tuple[int, int]:
-    """Extract GDS layer tuple from LayerLevel.
-
-    The layer can be specified in various ways in gdsfactory:
-    - tuple: (8, 0)
-    - int: 8
-    - LogicalLayer with nested layer enum
-    - kfactory LayerEnum with .layer and .datatype
-    """
+    """Extract GDS layer tuple from LayerLevel."""
     layer: Any = layer_level.layer
 
-    # Handle different layer specifications
     if isinstance(layer, tuple):
         return (int(layer[0]), int(layer[1]))
 
     if isinstance(layer, int):
         return (int(layer), 0)
 
-    # Handle LogicalLayer (gdsfactory.technology.layer_stack.LogicalLayer)
-    # Structure: layer_level.layer (LogicalLayer) -> .layer (Enum) -> .layer/.datatype
-    # (int)
     if hasattr(layer, "layer"):
         inner = layer.layer
-        # Check if inner has layer/datatype (kfactory/gdsfactory enum)
         if hasattr(inner, "layer") and hasattr(inner, "datatype"):
             return (int(inner.layer), int(inner.datatype))
-        # Check if inner itself has the values
         if isinstance(inner, int):
             datatype = getattr(layer, "datatype", 0)
             return (int(inner), int(datatype) if datatype else 0)
-        # Recurse one more level if needed
         if hasattr(inner, "layer"):
             innermost = inner.layer
             if isinstance(innermost, int):
                 datatype = getattr(inner, "datatype", 0)
                 return (int(innermost), int(datatype) if datatype else 0)
 
-    # Direct enum with layer/datatype
     if hasattr(layer, "layer") and hasattr(layer, "datatype"):
         return (int(layer.layer), int(layer.datatype))
 
-    # Enum with tuple value
     if hasattr(layer, "value"):
         if isinstance(layer.value, tuple):
             return (int(layer.value[0]), int(layer.value[1]))
         if isinstance(layer.value, int):
             return (int(layer.value), 0)
 
-    # String format "8/0"
     if isinstance(layer, str):
         if "/" in layer:
             parts = layer.split("/")
             return (int(parts[0]), int(parts[1]))
         return (0, 0)
 
-    # Fallback
     try:
         return (int(layer), 0)
     except (TypeError, ValueError):
@@ -343,34 +320,24 @@ def _get_gds_layer_tuple(layer_level: LayerLevel) -> tuple[int, int]:
         return (0, 0)
 
 
-def _classify_layer_type(layer_name: str, material: str) -> str:
-    """Classify a layer as conductor, via, dielectric, or substrate.
-
-    Args:
-        layer_name: Name of the layer (e.g., "metal1", "via1", "substrate")
-        material: Material name
-
-    Returns:
-        Layer type string
-    """
+def _classify_layer_type(
+    layer_name: str, material: str
+) -> Literal["conductor", "via", "dielectric", "substrate"]:
+    """Classify a layer as conductor, via, dielectric, or substrate."""
     name_lower = layer_name.lower()
     material_lower = material.lower()
 
-    # Check for via layers
     if "via" in name_lower:
         return "via"
 
-    # Check for metal layers
     if any(
         m in name_lower for m in ["metal", "topmetal", "m1", "m2", "m3", "m4", "m5"]
     ):
         return "conductor"
 
-    # Check for substrate
     if "substrate" in name_lower or name_lower == "sub":
         return "substrate"
 
-    # Check by material
     props = get_material_properties(material)
     if props:
         if props.type == "conductor":
@@ -380,15 +347,12 @@ def _classify_layer_type(layer_name: str, material: str) -> str:
         if props.type == "dielectric":
             return "dielectric"
 
-    # Check for common conductor materials
     if material_lower in ["aluminum", "copper", "tungsten", "gold", "al", "cu", "w"]:
         return "conductor"
 
-    # Check for poly
     if "poly" in name_lower:
         return "conductor"
 
-    # Default to dielectric
     return "dielectric"
 
 
@@ -408,41 +372,28 @@ def extract_layer_stack(
         substrate_thickness: Thickness of substrate in um (default: 2.0)
         air_above: Height of air box above top metal in um (default: 200)
         boundary_margin: Lateral margin from GDS bbox in um (default: 30)
-        include_substrate: Whether to include lossy substrate (default: False).
-            When False, matches gds2palace "nosub" behavior for RF simulation.
+        include_substrate: Whether to include lossy substrate (default: False)
 
     Returns:
         LayerStack object for Palace simulation
     """
     stack = LayerStack(pdk_name=pdk_name)
 
-    # Track z-range for dielectric regions
     z_min_overall = float("inf")
     z_max_overall = float("-inf")
-
-    # Collect materials used
     materials_used: set[str] = set()
 
-    # Extract each layer
     for layer_name, layer_level in gf_layer_stack.layers.items():
-        # Get layer properties
         zmin = layer_level.zmin if layer_level.zmin is not None else 0.0
         thickness = layer_level.thickness if layer_level.thickness is not None else 0.0
         zmax = zmin + thickness
         material = layer_level.material if layer_level.material else "unknown"
-
-        # Get GDS layer tuple
         gds_layer = _get_gds_layer_tuple(layer_level)
-
-        # Classify layer type
         layer_type = _classify_layer_type(layer_name, material)
 
-        # Skip substrate layers when include_substrate=False (matches gds2palace
-        # "nosub").
         if layer_type == "substrate" and not include_substrate:
             continue
 
-        # Create layer
         layer = Layer(
             name=layer_name,
             gds_layer=gds_layer,
@@ -456,34 +407,27 @@ def extract_layer_stack(
         stack.layers[layer_name] = layer
         materials_used.add(material)
 
-        # Update z-range (only for non-substrate layers to get metal stack extent)
         if layer_type != "substrate":
             z_min_overall = min(z_min_overall, zmin)
             z_max_overall = max(z_max_overall, zmax)
 
-    # Add material properties
     for material in materials_used:
         props = get_material_properties(material)
         if props:
             stack.materials[material] = props.to_dict()
         else:
-            # Unknown material - add placeholder
             stack.materials[material] = {
                 "type": "unknown",
                 "note": "Material not in database, please add properties manually",
             }
 
-    # Always add air for the air box
     if "air" not in stack.materials:
         stack.materials["air"] = MATERIALS_DB["air"].to_dict()
 
-    # Add SiO2 for inter-layer dielectric if not present
     if "SiO2" not in stack.materials:
         stack.materials["SiO2"] = MATERIALS_DB["SiO2"].to_dict()
 
-    # Generate dielectric regions
     if include_substrate:
-        # 1. Substrate below z=0 (lossy silicon)
         stack.dielectrics.append(
             {
                 "name": "substrate",
@@ -496,12 +440,8 @@ def extract_layer_stack(
             stack.materials["silicon"] = MATERIALS_DB["silicon"].to_dict()
         oxide_zmin = 0.0
     else:
-        # No substrate - extend oxide down slightly (matches gds2palace "nosub")
-        # This provides a dielectric spacing below the bottom metal
         oxide_zmin = -substrate_thickness
 
-    # 2. Inter-layer dielectric (simplified: one big oxide region)
-    # In reality, should fill gaps between metals
     stack.dielectrics.append(
         {
             "name": "oxide",
@@ -511,8 +451,7 @@ def extract_layer_stack(
         }
     )
 
-    # 3. Passivation layer on top of oxide (matches gds2palace IHP SG13G2)
-    passive_thickness = 0.4  # um, from gds2palace XML
+    passive_thickness = 0.4
     stack.dielectrics.append(
         {
             "name": "passive",
@@ -524,7 +463,6 @@ def extract_layer_stack(
     if "passive" not in stack.materials:
         stack.materials["passive"] = MATERIALS_DB["passive"].to_dict()
 
-    # 4. Air above passivation
     stack.dielectrics.append(
         {
             "name": "air_box",
@@ -534,7 +472,6 @@ def extract_layer_stack(
         }
     )
 
-    # Simulation settings
     stack.simulation = {
         "boundary_margin": boundary_margin,
         "air_above": air_above,
@@ -560,42 +497,31 @@ def extract_from_pdk(
     Returns:
         LayerStack object for Palace simulation
     """
-    # Get PDK name - handle both module and Pdk object
     pdk_name = "unknown"
 
-    # Direct .name attribute (gdsfactory Pdk object)
     if hasattr(pdk_module, "name") and isinstance(pdk_module.name, str):
         pdk_name = pdk_module.name
-    # Module with PDK.name
     elif hasattr(pdk_module, "PDK") and hasattr(pdk_module.PDK, "name"):
         pdk_name = pdk_module.PDK.name
-    # Module __name__
     elif hasattr(pdk_module, "__name__"):
         pdk_name = pdk_module.__name__
 
-    # Get layer stack from PDK - handle both module and Pdk object
     gf_layer_stack = None
 
-    # Direct layer_stack attribute (gdsfactory Pdk object)
     if hasattr(pdk_module, "layer_stack") and pdk_module.layer_stack is not None:
         gf_layer_stack = pdk_module.layer_stack
-    # Module with LAYER_STACK
     elif hasattr(pdk_module, "LAYER_STACK"):
         gf_layer_stack = pdk_module.LAYER_STACK
-    # Module with get_layer_stack()
     elif hasattr(pdk_module, "get_layer_stack"):
         gf_layer_stack = pdk_module.get_layer_stack()
-    # Module with PDK.layer_stack
     elif hasattr(pdk_module, "PDK") and hasattr(pdk_module.PDK, "layer_stack"):
         gf_layer_stack = pdk_module.PDK.layer_stack
 
     if gf_layer_stack is None:
         raise ValueError(f"Could not find layer stack in PDK: {pdk_module}")
 
-    # Extract
     stack = extract_layer_stack(gf_layer_stack, pdk_name=pdk_name, **kwargs)
 
-    # Write to file if path provided
     if output_path:
         stack.to_yaml(output_path)
 

gsim/{palace → common}/stack/materials.py

@@ -6,17 +6,20 @@ This database provides the EM properties needed for Palace simulation.
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from typing import Literal
 
+from pydantic import BaseModel, ConfigDict, Field
 
-@dataclass
-class MaterialProperties:
+
+class MaterialProperties(BaseModel):
     """EM properties for a material."""
 
-    type: str  # "conductor", "dielectric", "semiconductor"
-    conductivity: float | None = None  # S/m (for conductors)
-    permittivity: float | None = None  # relative permittivity
-    loss_tangent: float | None = None  # dielectric loss tangent
+    model_config = ConfigDict(validate_assignment=True)
+
+    type: Literal["conductor", "dielectric", "semiconductor"]
+    conductivity: float | None = Field(default=None, ge=0)  # S/m (for conductors)
+    permittivity: float | None = Field(default=None, ge=1.0)  # relative permittivity
+    loss_tangent: float | None = Field(default=None, ge=0, le=1)
 
     def to_dict(self) -> dict[str, object]:
         """Convert to dictionary for YAML output."""
@@ -29,6 +32,20 @@ class MaterialProperties:
             d["loss_tangent"] = self.loss_tangent
         return d
 
+    @classmethod
+    def conductor(cls, conductivity: float = 5.8e7) -> "MaterialProperties":
+        """Create a conductor material."""
+        return cls(type="conductor", conductivity=conductivity)
+
+    @classmethod
+    def dielectric(
+        cls, permittivity: float, loss_tangent: float = 0.0
+    ) -> "MaterialProperties":
+        """Create a dielectric material."""
+        return cls(
+            type="dielectric", permittivity=permittivity, loss_tangent=loss_tangent
+        )
+
 
 # Material properties database
 # Sources:
@@ -38,7 +55,7 @@ MATERIALS_DB: dict[str, MaterialProperties] = {
     # Conductors (conductivity in S/m)
     "aluminum": MaterialProperties(
         type="conductor",
-        conductivity=3.77e7,  # S/m
+        conductivity=3.77e7,
     ),
     "copper": MaterialProperties(
         type="conductor",
@@ -64,7 +81,7 @@ MATERIALS_DB: dict[str, MaterialProperties] = {
     "SiO2": MaterialProperties(
         type="dielectric",
         permittivity=4.1,  # Matches gds2palace IHP SG13G2
-        loss_tangent=0.0,  # Matches gds2palace (no loss)
+        loss_tangent=0.0,
     ),
     "passive": MaterialProperties(
         type="dielectric",
@@ -100,7 +117,7 @@ MATERIALS_DB: dict[str, MaterialProperties] = {
     "si": MaterialProperties(
         type="semiconductor",
         permittivity=11.9,
-        conductivity=2.0,  # ~50 Ω·cm substrate (matches gds2palace)
+        conductivity=2.0,
     ),
 }
 
@@ -130,7 +147,6 @@ def get_material_properties(material_name: str) -> MaterialProperties | None:
     Returns:
         MaterialProperties if found, None otherwise
     """
-    # Normalize name
     name_lower = material_name.lower().strip()
 
     # Check direct match