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

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

@@ -43,15 +43,15 @@ def _get_gds_layer_number(layer_level: LayerLevel) -> int | None:
     if hasattr(layer, "layer"):
         inner = layer.layer
         if hasattr(inner, "layer"):
-            return int(inner.layer)
+            return int(inner.layer)  # type: ignore[arg-type]
         if isinstance(inner, int):
             return int(inner)
 
     # Handle enum with value
     if hasattr(layer, "value"):
         if isinstance(layer.value, tuple):
-            return int(layer.value[0])
-        return int(layer.value)
+            return int(layer.value[0])  # type: ignore[arg-type]
+        return int(layer.value)  # type: ignore[arg-type]
 
     return None
 

gsim/gcloud.py

@@ -16,17 +16,74 @@ Usage:
 
 from __future__ import annotations
 
-import zipfile
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from gdsfactoryplus import sim  # type: ignore[import-untyped]
+from gdsfactoryplus import sim
 
 if TYPE_CHECKING:
     from collections.abc import Callable
     from typing import Literal
 
 
+def _handle_failed_job(job, output_dir: Path, verbose: bool) -> None:
+    """Handle a failed simulation job by downloading logs and raising informative error.
+
+    Args:
+        job: The finished Job object with non-zero exit code
+        output_dir: Directory to download logs to
+        verbose: Whether to print progress
+
+    Raises:
+        RuntimeError: Always raised with detailed error information
+    """
+    error_parts = [
+        f"Simulation failed with exit code {job.exit_code}",
+        f"Status: {job.status.value}",
+    ]
+
+    if job.status_reason:
+        error_parts.append(f"Reason: {job.status_reason}")
+    if job.detail_reason:
+        error_parts.append(f"Details: {job.detail_reason}")
+
+    # Try to download logs even though job failed
+    try:
+        if job.download_urls:
+            if verbose:
+                print("Downloading logs from failed job...")  # noqa: T201
+
+            raw_results = sim.download_results(job, output_dir=output_dir)
+
+            # Flatten results to find all files
+            all_files: dict[str, Path] = {}
+            for result_path in raw_results.values():
+                if result_path.is_dir():
+                    for file_path in result_path.rglob("*"):
+                        if file_path.is_file() and not file_path.name.startswith("."):
+                            all_files[file_path.name] = file_path
+                else:
+                    all_files[result_path.name] = result_path
+
+            # Look for log files and display them
+            log_files = ["palace.log", "stdout.log", "stderr.log", "output.log"]
+            for log_name in log_files:
+                if log_name in all_files:
+                    content = all_files[log_name].read_text()
+                    error_parts.append(f"\n--- {log_name} (last 100 lines) ---")
+                    lines = content.strip().split("\n")
+                    error_parts.append("\n".join(lines[-100:]))
+                    break
+
+            if verbose and all_files:
+                print(f"Logs downloaded to {output_dir}")  # noqa: T201
+
+    except Exception as e:
+        error_parts.append(f"(Failed to download logs: {e})")
+
+    raise RuntimeError("\n".join(error_parts))
+
+
 def _get_job_definition(job_type: str):
     """Get JobDefinition enum value by name."""
     job_type_upper = job_type.upper()
@@ -37,7 +94,7 @@ def _get_job_definition(job_type: str):
 
 
 def upload_simulation_dir(input_dir: str | Path, job_type: str):
-    """Zip all files in a directory and upload for simulation.
+    """Upload a simulation directory for cloud execution.
 
     Args:
         input_dir: Directory containing simulation files
@@ -47,21 +104,8 @@ def upload_simulation_dir(input_dir: str | Path, job_type: str):
         PreJob object from gdsfactoryplus
     """
     input_dir = Path(input_dir)
-    zip_path = Path("_gsim_upload.zip")
-
-    try:
-        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_STORED) as zf:
-            for file in input_dir.rglob("*"):
-                if file.is_file():
-                    zf.write(file, arcname=file.relative_to(input_dir))
-
-        job_definition = _get_job_definition(job_type)
-        pre_job = sim.upload_simulation(path=zip_path, job_definition=job_definition)
-    finally:
-        if zip_path.exists():
-            zip_path.unlink()
-
-    return pre_job
+    job_definition = _get_job_definition(job_type)
+    return sim.upload_simulation(path=input_dir, job_definition=job_definition)
 
 
 def run_simulation(
@@ -125,18 +169,27 @@ def run_simulation(
 
     # Check status
     if finished_job.exit_code != 0:
-        raise RuntimeError(
-            f"Simulation failed with exit code {finished_job.exit_code}. "
-            f"Status: {finished_job.status.value}"
-        )
+        _handle_failed_job(finished_job, output_dir, verbose)
 
     # Download
-    results = sim.download_results(finished_job)
+    raw_results = sim.download_results(finished_job)
+
+    # Flatten results: gdsfactoryplus returns extracted directories,
+    # but we want a dict of filename -> Path for individual files
+    results: dict[str, Path] = {}
+    for result_path in raw_results.values():
+        if result_path.is_dir():
+            # Recursively find all files in the extracted directory
+            for file_path in result_path.rglob("*"):
+                if file_path.is_file() and not file_path.name.startswith("."):
+                    results[file_path.name] = file_path
+        else:
+            results[result_path.name] = result_path
 
     if verbose and results:
+        # Find common parent directory for display
         first_path = next(iter(results.values()))
-        download_dir = first_path.parent
-        print(f"Downloaded {len(results)} files to {download_dir}")  # noqa: T201
+        print(f"Downloaded {len(results)} files to {first_path.parent}")  # noqa: T201
 
     return results
 

gsim/palace/__init__.py

@@ -4,46 +4,61 @@ This module provides a comprehensive API for setting up and running
 electromagnetic simulations using the Palace solver with gdsfactory components.
 
 Features:
+    - Problem-specific simulation classes (DrivenSim, EigenmodeSim, ElectrostaticSim)
     - Layer stack extraction from PDK
     - Port configuration (inplane, via, CPW)
     - Mesh generation with COMSOL-style presets
     - Palace config file generation
 
 Usage:
-    from gsim.palace import (
-        get_stack, configure_inplane_port, configure_via_port,
-        extract_ports, generate_mesh
-    )
-
-    # 1. Get layer stack from active PDK
-    stack = get_stack()
-
-    # 2. Configure ports on component
-    # Inplane port (horizontal, on single layer - for CPW gaps)
-    configure_inplane_port(c.ports['o1'], layer='topmetal2', length=5.0)
-    configure_inplane_port(c.ports['o2'], layer='topmetal2', length=5.0)
-
-    # Via port (vertical, between two layers - for microstrip feed)
-    configure_via_port(c.ports['feed'], from_layer='metal1', to_layer='topmetal2')
-
-    # 3. Extract configured ports
-    ports = extract_ports(c, stack)
-
-    # 4. Generate mesh
-    result = generate_mesh(
-        component=c,
-        stack=stack,
-        ports=ports,
-        output_dir="./simulation",
-    )
+    from gsim.palace import DrivenSim
+
+    # Create and configure simulation
+    sim = DrivenSim()
+    sim.set_geometry(component)
+    sim.set_stack(air_above=300.0)
+    sim.add_cpw_port("P2", "P1", layer="topmetal2", length=5.0)
+    sim.set_driven(fmin=1e9, fmax=100e9)
+
+    # Generate mesh and run
+    sim.mesh("./sim", preset="fine")
+    results = sim.simulate()
 """
 
 from __future__ import annotations
 
 from functools import partial
 
+# Common components (shared with FDTD)
+from gsim.common import Geometry, LayerStack, Stack
+
+# Stack utilities (from common, shared with FDTD)
+from gsim.common.stack import (
+    MATERIALS_DB,
+    Layer,
+    MaterialProperties,
+    StackLayer,
+    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,
+)
 from gsim.gcloud import print_job_summary
 from gsim.gcloud import run_simulation as _run_simulation
+
+# New simulation classes (composition, no inheritance)
+from gsim.palace.driven import DrivenSim
+from gsim.palace.eigenmode import EigenmodeSim
+from gsim.palace.electrostatic import ElectrostaticSim
+
+# Mesh utilities
 from gsim.palace.mesh import (
     GroundPlane,
     MeshConfig,
@@ -51,6 +66,29 @@ from gsim.palace.mesh import (
     MeshResult,
     generate_mesh,
 )
+
+# Models (new submodule)
+from gsim.palace.models import (
+    CPWPortConfig,
+    DrivenConfig,
+    EigenmodeConfig,
+    ElectrostaticConfig,
+    GeometryConfig,
+    MagnetostaticConfig,
+    MaterialConfig,
+    NumericalConfig,
+    PortConfig,
+    SimulationResult,
+    TerminalConfig,
+    TransientConfig,
+    ValidationResult,
+    WavePortConfig,
+)
+from gsim.palace.models import (
+    MeshConfig as MeshConfigModel,
+)
+
+# Port utilities
 from gsim.palace.ports import (
     PalacePort,
     PortGeometry,
@@ -60,41 +98,43 @@ from gsim.palace.ports import (
     configure_via_port,
     extract_ports,
 )
-from gsim.palace.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,
-)
+
+# Visualization
 from gsim.viz import plot_mesh
 
 __all__ = [
     "MATERIALS_DB",
+    "CPWPortConfig",
+    "DrivenConfig",
+    "DrivenSim",
+    "EigenmodeConfig",
+    "EigenmodeSim",
+    "ElectrostaticConfig",
+    "ElectrostaticSim",
+    "Geometry",
+    "GeometryConfig",
     "GroundPlane",
     "Layer",
     "LayerStack",
+    "MagnetostaticConfig",
+    "MaterialConfig",
     "MaterialProperties",
     "MeshConfig",
+    "MeshConfigModel",
     "MeshPreset",
     "MeshResult",
+    "NumericalConfig",
     "PalacePort",
+    "PortConfig",
     "PortGeometry",
     "PortType",
+    "SimulationResult",
+    "Stack",
     "StackLayer",
+    "TerminalConfig",
+    "TransientConfig",
     "ValidationResult",
+    "WavePortConfig",
     "configure_cpw_port",
     "configure_inplane_port",
     "configure_via_port",