Simulation Classes¶

DrivenSim ¶

Bases: PalaceSimMixin, BaseModel

Frequency-domain driven simulation for S-parameter extraction.

This class configures and runs driven simulations that sweep through frequencies to compute S-parameters. Uses composition (no inheritance) with shared Geometry and Stack components from gsim.common.

Example

from gsim.palace import DrivenSim
sim = DrivenSim()
sim.set_geometry(component)
sim.set_stack(air_above=300.0)
sim.add_cpw_port("o1", layer="topmetal2", s_width=10, gap_width=6)
sim.add_cpw_port("o2", layer="topmetal2", s_width=10, gap_width=6)
sim.set_driven(fmin=1e9, fmax=100e9, num_points=40)
sim.set_output_dir("./sim")
sim.mesh(preset="default")
results = sim.run()

Attributes:

geometry (Geometry | None) –

Wrapped gdsfactory Component (from common)
stack (LayerStack | None) –

Layer stack configuration (from common)
ports (list[PortConfig]) –

List of single-element port configurations
cpw_ports (list[CPWPortConfig]) –

List of CPW (two-element) port configurations
driven (DrivenConfig) –

Driven simulation configuration (frequencies, etc.)
mesh (SimulationResult) –

Mesh configuration
materials (dict[str, MaterialConfig]) –

Material property overrides
numerical (NumericalConfig) –

Numerical solver configuration

Methods:

set_driven –

Configure driven (frequency sweep) simulation.
add_port –

Add a single-element lumped port.
add_cpw_port –

Add a coplanar waveguide (CPW) port.
mesh –

Generate the mesh for Palace simulation.
preview –

Preview the mesh without running simulation.
validate_config –

Validate the simulation configuration.
write_config –

Write Palace config.json after mesh generation.
run –

Run simulation on GDSFactory+ cloud.
start –

Start cloud execution for this sim's uploaded job.
upload –

Prepare config, upload to the cloud. Does NOT start execution.
get_status –

Get the current status of this sim's cloud job.
wait_for_results –

Wait for this sim's cloud job, download and parse results.

set_driven ¶

set_driven(
    *,
    fmin: float = 1000000000.0,
    fmax: float = 100000000000.0,
    num_points: int = 40,
    scale: Literal["linear", "log"] = "linear",
    adaptive_tol: float = 0.02,
    adaptive_max_samples: int = 20,
    compute_s_params: bool = True,
    reference_impedance: float = 50.0,
    excitation_port: str | None = None,
    save_step: int = 0,
    save_fields_at: list[float] | None = None,
) -> None

Configure driven (frequency sweep) simulation.

Parameters:

fmin (float, default: 1000000000.0 ) –

Minimum frequency in Hz
fmax (float, default: 100000000000.0 ) –

Maximum frequency in Hz
num_points (int, default: 40 ) –

Number of frequency points
scale (Literal['linear', 'log'], default: 'linear' ) –

"linear" or "log" frequency spacing
adaptive_tol (float, default: 0.02 ) –

Relative error tolerance (unitless fraction) for adaptive frequency sampling. Palace builds a reduced-order model from a few full solves and interpolates the rest. 0 = disabled (full solve at every point), 0.02 = 2% error (fast default), 1e-3 = 0.1% (accurate), 1e-4 = publication quality.
adaptive_max_samples (int, default: 20 ) –

Maximum number of additional frequency points that adaptive refinement may insert between the points defined by fmin, fmax, and num_points.
compute_s_params (bool, default: True ) –

Compute S-parameters
reference_impedance (float, default: 50.0 ) –

Reference impedance for S-params (Ohms)
excitation_port (str | None, default: None ) –

Port to excite (None = first port)
save_step (int, default: 0 ) –

Save fields every N frequency steps for ParaView (0 = disabled)
save_fields_at (list[float] | None, default: None ) –

Specific frequencies (Hz) at which to save fields

Example

sim.set_driven(fmin=1e9, fmax=100e9, num_points=40)

add_port ¶

add_port(
    name: str,
    *,
    layer: str | None = None,
    from_layer: str | None = None,
    to_layer: str | None = None,
    length: float | None = None,
    impedance: float = 50.0,
    resistance: float | None = None,
    inductance: float | None = None,
    capacitance: float | None = None,
    excited: bool = True,
    geometry: Literal["inplane", "via"] = "inplane",
) -> None

Add a single-element lumped port.

Parameters:

name (str) –

Port name (must match component port name)
layer (str | None, default: None ) –

Target layer for inplane ports
from_layer (str | None, default: None ) –

Bottom layer for via ports
to_layer (str | None, default: None ) –

Top layer for via ports
length (float | None, default: None ) –

Port extent along direction (um)
impedance (float, default: 50.0 ) –

Port impedance (Ohms)
resistance (float | None, default: None ) –

Series resistance (Ohms)
inductance (float | None, default: None ) –

Series inductance (H)
capacitance (float | None, default: None ) –

Shunt capacitance (F)
excited (bool, default: True ) –

Whether this port is excited
geometry (Literal['inplane', 'via'], default: 'inplane' ) –

Port geometry type ("inplane" or "via")

Example

sim.add_port("o1", layer="topmetal2", length=5.0)
sim.add_port(
"feed", from_layer="metal1", to_layer="topmetal2", geometry="via"
)

add_cpw_port ¶

add_cpw_port(
    name: str,
    *,
    layer: str,
    s_width: float,
    gap_width: float,
    length: float = 0.1,
    offset: float = 0.0,
    impedance: float = 50.0,
    excited: bool = True,
) -> None

Add a coplanar waveguide (CPW) port.

CPW ports consist of two elements (upper and lower gaps) that are excited with opposite E-field directions to create the CPW mode.

Place a single gdsfactory port at the center of the signal conductor. The two gap element surfaces are computed from s_width and gap_width.

Lumped ports assume a uniform E-field across the port surface. For CPW gaps, larger port lengths increase the mismatch between this uniform assumption and the actual concentrated field at gap edges, introducing spurious insertion loss. Reducing the port length minimizes this mismatch. The result converges for length ≤ 0.1 µm and is mesh-independent (verified across coarse, default, and fine presets).

Parameters:

name (str) –

Port name (must match a component port at the signal center)
layer (str) –

Target conductor layer (e.g., "topmetal2")
s_width (float) –

Width of the signal (center) conductor (um)
gap_width (float) –

Width of each gap between signal and ground (um)
length (float, default: 0.1 ) –

Port extent along direction (um)
offset (float, default: 0.0 ) –

Shift the port inward along the waveguide (um). Positive moves away from the boundary, into the conductor.
impedance (float, default: 50.0 ) –

Port impedance (Ohms)
excited (bool, default: True ) –

Whether this port is excited

Example

sim.add_cpw_port("left", layer="topmetal2", s_width=20, gap_width=15)

mesh ¶

mesh(
    *,
    preset: Literal["coarse", "default", "graded", "fine"] | None = None,
    refined_mesh_size: float | None = None,
    max_mesh_size: float | None = None,
    margin: float | None = None,
    airbox_margin: float | None = None,
    fmax: float | None = None,
    planar_conductors: bool | None = None,
    show_gui: bool = False,
    model_name: str = "palace",
    verbose: bool = True,
) -> SimulationResult

Generate the mesh for Palace simulation.

Only generates the mesh file (palace.msh). Config is generated separately with write_config().

Requires set_output_dir() to be called first.

Parameters:

preset (Literal['coarse', 'default', 'graded', 'fine'] | None, default: None ) –

Mesh quality preset ("coarse", "default", "graded", "fine")
refined_mesh_size (float | None, default: None ) –

Mesh size near conductors (um), overrides preset
max_mesh_size (float | None, default: None ) –

Max mesh size in air/dielectric (um), overrides preset
margin (float | None, default: None ) –

XY margin around design (um), overrides preset
airbox_margin (float | None, default: None ) –

Extra airbox around stack (um); 0 = disabled
fmax (float | None, default: None ) –

Max frequency for mesh sizing (Hz), overrides preset
planar_conductors (bool | None, default: None ) –

Treat conductors as 2D PEC surfaces
show_gui (bool, default: False ) –

Show gmsh GUI during meshing
model_name (str, default: 'palace' ) –

Base name for output files
verbose (bool, default: True ) –

Print progress messages

Returns:

SimulationResult –

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", planar_conductors=True)
print(f"Mesh saved to: {result.mesh_path}")

preview ¶

preview(
    *,
    preset: Literal["coarse", "default", "graded", "fine"] | None = None,
    refined_mesh_size: float | None = None,
    max_mesh_size: float | None = None,
    margin: float | None = None,
    airbox_margin: float | None = None,
    fmax: float | None = None,
    planar_conductors: bool | None = None,
    show_gui: bool = True,
) -> None

Preview the mesh without running simulation.

Opens the gmsh GUI to visualize the mesh interactively.

Parameters:

preset (Literal['coarse', 'default', 'graded', 'fine'] | None, default: None ) –

Mesh quality preset ("coarse", "default", "graded", "fine")
refined_mesh_size (float | None, default: None ) –

Mesh size near conductors (um)
max_mesh_size (float | None, default: None ) –

Max mesh size in air/dielectric (um)
margin (float | None, default: None ) –

XY margin around design (um)
airbox_margin (float | None, default: None ) –

Extra airbox around stack (um); 0 = disabled
fmax (float | None, default: None ) –

Max frequency for mesh sizing (Hz)
planar_conductors (bool | None, default: None ) –

Treat conductors as 2D PEC surfaces
show_gui (bool, default: True ) –

Show gmsh GUI for interactive preview

Example

sim.preview(preset="fine", planar_conductors=True, show_gui=True)

validate_config ¶

validate_config() -> ValidationResult

Validate the simulation configuration.

Returns:

ValidationResult –

ValidationResult with validation status and messages

write_config ¶

write_config() -> Path

Write Palace config.json after mesh generation.

Use this when mesh() was called with write_config=False.

Returns:

Path –

Path to the generated config.json

Raises:

ValueError –

If mesh() hasn't been called yet

Example

result = sim.mesh("./sim", write_config=False)
config_path = sim.write_config()

run ¶

run(
    parent_dir: str | Path | None = None,
    *,
    verbose: Literal["quiet", "status", "full"] = "status",
    wait: bool = True,
) -> dict[str, Path] | str

Run simulation on GDSFactory+ cloud.

Requires mesh() to be called first. Automatically calls write_config() if config.json hasn't been written yet.

Parameters:

parent_dir (str | Path | None, default: None ) –

Where to create the sim directory. Defaults to the current working directory.
verbose (Literal['quiet', 'status', 'full'], default: 'status' ) –

"quiet" no output, "status" status line, "full" stream solver logs.
wait (bool, default: True ) –

If True (default), block until results are ready. If False, upload + start and return the job_id.

Returns:

dict[str, Path] | str –

dict[str, Path] of output files when wait=True,
dict[str, Path] | str –

or job_id string when wait=False.

Raises:

ValueError –

If output_dir not set or mesh not generated
RuntimeError –

If simulation fails

Example

results = sim.run()
print(f"S-params saved to: {results['port-S.csv']}")

start ¶

start(*, verbose: bool = True) -> None

Start cloud execution for this sim's uploaded job.

Raises:

ValueError –

If :meth:upload has not been called.

upload ¶

upload(*, verbose: bool = True) -> str

Prepare config, upload to the cloud. Does NOT start execution.

Requires :meth:set_output_dir and :meth:mesh to have been called first.

Parameters:

verbose (bool, default: True ) –

Print progress messages.

Returns:

str –

job_id string for use with :meth:start, :meth:get_status,
or ( str ) –

func:gsim.wait_for_results.

get_status ¶

get_status() -> str

Get the current status of this sim's cloud job.

Returns:

str –

Status string ("created", "queued", "running",
str –

"completed", "failed").

Raises:

ValueError –

If no job has been submitted yet.

wait_for_results ¶

wait_for_results(
    *,
    verbose: Literal["quiet", "status", "full"] = "status",
    parent_dir: str | Path | None = None,
) -> Any

Wait for this sim's cloud job, download and parse results.

Parameters:

verbose (Literal['quiet', 'status', 'full'], default: 'status' ) –

"quiet" no output, "status" status line, "full" stream solver logs.
parent_dir (str | Path | None, default: None ) –

Where to create the sim-data directory.

Returns:

Any –

Parsed result (typically dict[str, Path] of output files).

Raises:

ValueError –

If no job has been submitted yet.

EigenmodeSim ¶

Bases: PalaceSimMixin, BaseModel

Eigenmode simulation for finding resonant frequencies.

This class configures and runs eigenmode simulations to find resonant frequencies and mode shapes of structures.

Example

from gsim.palace import EigenmodeSim
sim = EigenmodeSim()
sim.set_geometry(component)
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.set_output_dir("./sim")
sim.mesh(preset="default")
results = sim.run()

Attributes:

geometry (Geometry | None) –

Wrapped gdsfactory Component (from common)
stack (LayerStack | None) –

Layer stack configuration (from common)
ports (list[PortConfig]) –

List of single-element port configurations
cpw_ports (list[CPWPortConfig]) –

List of CPW (two-element) port configurations
eigenmode (EigenmodeConfig) –

Eigenmode simulation configuration
materials (dict[str, MaterialConfig]) –

Material property overrides
numerical (NumericalConfig) –

Numerical solver configuration

Methods:

set_eigenmode –

Configure eigenmode simulation.
add_port –

Add a single-element lumped port.
add_cpw_port –

Add a coplanar waveguide (CPW) port.
mesh –

Generate the mesh for Palace simulation.
preview –

Preview the mesh without running simulation.
validate_config –

Validate the simulation configuration.
run –

Run eigenmode simulation on GDSFactory+ cloud.

set_eigenmode ¶

set_eigenmode(
    *,
    num_modes: int = 10,
    target: float | None = None,
    tolerance: float = 1e-06,
    save: int = 0,
) -> None

Configure eigenmode simulation.

Parameters:

num_modes (int, default: 10 ) –

Number of modes to find
target (float | None, default: None ) –

Target frequency in Hz for mode search
tolerance (float, default: 1e-06 ) –

Eigenvalue solver tolerance
save (int, default: 0 ) –

Number of eigenmodes to save as ParaView fields (0 = disabled)

Example

sim.set_eigenmode(num_modes=10, target=50e9)

add_port ¶

add_port(
    name: str,
    *,
    layer: str | None = None,
    from_layer: str | None = None,
    to_layer: str | None = None,
    length: float | None = None,
    impedance: float = 50.0,
    resistance: float | None = None,
    inductance: float | None = None,
    capacitance: float | None = None,
    excited: bool = True,
    geometry: Literal["inplane", "via"] = "inplane",
) -> None

Add a single-element lumped port.

Parameters:

name (str) –

Port name (must match component port name)
layer (str | None, default: None ) –

Target layer for inplane ports
from_layer (str | None, default: None ) –

Bottom layer for via ports
to_layer (str | None, default: None ) –

Top layer for via ports
length (float | None, default: None ) –

Port extent along direction (um)
impedance (float, default: 50.0 ) –

Port impedance (Ohms)
resistance (float | None, default: None ) –

Series resistance (Ohms)
inductance (float | None, default: None ) –

Series inductance (H)
capacitance (float | None, default: None ) –

Shunt capacitance (F)
excited (bool, default: True ) –

Whether this port is excited
geometry (Literal['inplane', 'via'], default: 'inplane' ) –

Port geometry type ("inplane" or "via")

Example

sim.add_port("o1", layer="topmetal2", length=5.0)
sim.add_port(
"junction", layer="SUPERCONDUCTOR", length=5.0, inductance=10e-9
)

add_cpw_port ¶

add_cpw_port(
    name: str,
    *,
    layer: str,
    s_width: float,
    gap_width: float,
    length: float,
    offset: float = 0.0,
    impedance: float = 50.0,
    excited: bool = True,
) -> None

Add a coplanar waveguide (CPW) port.

Parameters:

name (str) –

Name of the port on the component (at signal center)
layer (str) –

Target conductor layer
s_width (float) –

Signal conductor width (um)
gap_width (float) –

Gap width between signal and ground (um)
length (float) –

Port extent along direction (um)
offset (float, default: 0.0 ) –

Shift port inward along the waveguide (um). Positive moves away from the boundary, into the conductor.
impedance (float, default: 50.0 ) –

Port impedance (Ohms)
excited (bool, default: True ) –

Whether this port is excited

Example

sim.add_cpw_port(
"o1", layer="topmetal2", s_width=10, gap_width=6, length=5
)

mesh ¶

mesh(
    *,
    preset: Literal["coarse", "default", "graded", "fine"] | None = None,
    refined_mesh_size: float | None = None,
    max_mesh_size: float | None = None,
    margin: float | None = None,
    airbox_margin: float | None = None,
    fmax: float | None = None,
    planar_conductors: bool | None = None,
    show_gui: bool = False,
    model_name: str = "palace",
    verbose: bool = True,
) -> SimulationResult

Generate the mesh for Palace simulation.

Requires set_output_dir() to be called first.

Parameters:

preset (Literal['coarse', 'default', 'graded', 'fine'] | None, default: None ) –

Mesh quality preset ("coarse", "default", "graded", "fine")
refined_mesh_size (float | None, default: None ) –

Mesh size near conductors (um), overrides preset
max_mesh_size (float | None, default: None ) –

Max mesh size in air/dielectric (um), overrides preset
margin (float | None, default: None ) –

XY margin around design (um), overrides preset
airbox_margin (float | None, default: None ) –

Extra airbox around stack (um); 0 = disabled
fmax (float | None, default: None ) –

Max frequency for mesh sizing (Hz), overrides preset
planar_conductors (bool | None, default: None ) –

Treat conductors as 2D PEC surfaces
show_gui (bool, default: False ) –

Show gmsh GUI during meshing
model_name (str, default: 'palace' ) –

Base name for output files
verbose (bool, default: True ) –

Print progress messages

Returns:

SimulationResult –

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", planar_conductors=True)
print(f"Mesh saved to: {result.mesh_path}")

preview ¶

preview(
    *,
    preset: Literal["coarse", "default", "graded", "fine"] | None = None,
    refined_mesh_size: float | None = None,
    max_mesh_size: float | None = None,
    margin: float | None = None,
    airbox_margin: float | None = None,
    fmax: float | None = None,
    planar_conductors: bool | None = None,
    show_gui: bool = True,
) -> None

Preview the mesh without running simulation.

Parameters:

preset (Literal['coarse', 'default', 'graded', 'fine'] | None, default: None ) –

Mesh quality preset ("coarse", "default", "graded", "fine")
refined_mesh_size (float | None, default: None ) –

Mesh size near conductors (um)
max_mesh_size (float | None, default: None ) –

Max mesh size in air/dielectric (um)
margin (float | None, default: None ) –

XY margin around design (um)
airbox_margin (float | None, default: None ) –

Extra airbox around stack (um); 0 = disabled
fmax (float | None, default: None ) –

Max frequency for mesh sizing (Hz)
planar_conductors (bool | None, default: None ) –

Treat conductors as 2D PEC surfaces
show_gui (bool, default: True ) –

Show gmsh GUI for interactive preview

Example

sim.preview(preset="fine", planar_conductors=True, show_gui=True)

validate_config ¶

validate_config() -> ValidationResult

Validate the simulation configuration.

Returns:

ValidationResult –

ValidationResult with validation status and messages

run ¶

run(output_dir: str | Path | None = None, *, verbose: bool = True) -> dict[str, Path]

Run eigenmode simulation on GDSFactory+ cloud.

Parameters:

output_dir (str | Path | None, default: None ) –

Directory containing mesh files
verbose (bool, default: True ) –

Print progress messages

Returns:

dict[str, Path] –

Dict mapping result filenames to local paths

Raises:

NotImplementedError –

Eigenmode is not yet fully implemented

ElectrostaticSim ¶

Bases: PalaceSimMixin, BaseModel

Electrostatic simulation for capacitance matrix extraction.

This class configures and runs electrostatic simulations to extract the capacitance matrix between conductor terminals. Unlike driven and eigenmode simulations, this does not use ports.

Example

from gsim.palace import ElectrostaticSim
sim = ElectrostaticSim()
sim.set_geometry(component)
sim.set_stack(air_above=300.0)
sim.add_terminal("T1", layer="topmetal2")
sim.add_terminal("T2", layer="topmetal2")
sim.set_electrostatic()
sim.set_output_dir("./sim")
sim.mesh(preset="default")
results = sim.run()

Attributes:

geometry (Geometry | None) –

Wrapped gdsfactory Component (from common)
stack (LayerStack | None) –

Layer stack configuration (from common)
terminals (list[TerminalConfig]) –

List of terminal configurations
electrostatic (ElectrostaticConfig) –

Electrostatic simulation configuration
materials (dict[str, MaterialConfig]) –

Material property overrides
numerical (NumericalConfig) –

Numerical solver configuration

Methods:

set_electrostatic –

Configure electrostatic simulation.
add_terminal –

Add a terminal for capacitance extraction.
mesh –

Generate the mesh for Palace simulation.
preview –

Preview the mesh without running simulation.
validate_config –

Validate the simulation configuration.
run –

Run electrostatic simulation on GDSFactory+ cloud.

set_electrostatic ¶

set_electrostatic(*, save_fields: int = 0) -> None

Configure electrostatic simulation.

Parameters:

save_fields (int, default: 0 ) –

Number of field solutions to save

Example

sim.set_electrostatic(save_fields=1)

add_terminal ¶

add_terminal(name: str, *, layer: str) -> None

Add a terminal for capacitance extraction.

Terminals define conductor surfaces for capacitance matrix extraction.

Parameters:

name (str) –

Terminal name
layer (str) –

Target conductor layer

Example

sim.add_terminal("T1", layer="topmetal2")
sim.add_terminal("T2", layer="topmetal2")

mesh ¶

mesh(
    *,
    preset: Literal["coarse", "default", "graded", "fine"] | None = None,
    refined_mesh_size: float | None = None,
    max_mesh_size: float | None = None,
    margin: float | None = None,
    airbox_margin: float | None = None,
    fmax: float | None = None,
    planar_conductors: bool | None = None,
    show_gui: bool = False,
    model_name: str = "palace",
    verbose: bool = True,
) -> SimulationResult

Generate the mesh for Palace simulation.

Requires set_output_dir() to be called first.

Parameters:

preset (Literal['coarse', 'default', 'graded', 'fine'] | None, default: None ) –

Mesh quality preset ("coarse", "default", "graded", "fine")
refined_mesh_size (float | None, default: None ) –

Mesh size near conductors (um), overrides preset
max_mesh_size (float | None, default: None ) –

Max mesh size in air/dielectric (um), overrides preset
margin (float | None, default: None ) –

XY margin around design (um), overrides preset
airbox_margin (float | None, default: None ) –

Extra airbox around stack (um); 0 = disabled
fmax (float | None, default: None ) –

Max frequency for mesh sizing (Hz) - less relevant for electrostatic
planar_conductors (bool | None, default: None ) –

Treat conductors as 2D PEC surfaces
show_gui (bool, default: False ) –

Show gmsh GUI during meshing
model_name (str, default: 'palace' ) –

Base name for output files
verbose (bool, default: True ) –

Print progress messages

Returns:

SimulationResult –

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", planar_conductors=True)
print(f"Mesh saved to: {result.mesh_path}")

preview ¶

preview(
    *,
    preset: Literal["coarse", "default", "graded", "fine"] | None = None,
    refined_mesh_size: float | None = None,
    max_mesh_size: float | None = None,
    margin: float | None = None,
    airbox_margin: float | None = None,
    fmax: float | None = None,
    planar_conductors: bool | None = None,
    show_gui: bool = True,
) -> None

Preview the mesh without running simulation.

Parameters:

preset (Literal['coarse', 'default', 'graded', 'fine'] | None, default: None ) –

Mesh quality preset ("coarse", "default", "graded", "fine")
refined_mesh_size (float | None, default: None ) –

Mesh size near conductors (um)
max_mesh_size (float | None, default: None ) –

Max mesh size in air/dielectric (um)
margin (float | None, default: None ) –

XY margin around design (um)
airbox_margin (float | None, default: None ) –

Extra airbox around stack (um); 0 = disabled
fmax (float | None, default: None ) –

Max frequency for mesh sizing (Hz)
planar_conductors (bool | None, default: None ) –

Treat conductors as 2D PEC surfaces
show_gui (bool, default: True ) –

Show gmsh GUI for interactive preview

Example

sim.preview(preset="fine", planar_conductors=True, show_gui=True)

validate_config ¶

validate_config() -> ValidationResult

Validate the simulation configuration.

Returns:

ValidationResult –

ValidationResult with validation status and messages

run ¶

run(output_dir: str | Path | None = None, *, verbose: bool = True) -> dict[str, Path]

Run electrostatic simulation on GDSFactory+ cloud.

Parameters:

output_dir (str | Path | None, default: None ) –

Directory containing mesh files
verbose (bool, default: True ) –

Print progress messages

Returns:

dict[str, Path] –

Dict mapping result filenames to local paths

Raises:

NotImplementedError –

Electrostatic is not yet fully implemented

Mesh¶

MeshConfig `dataclass` ¶

MeshConfig(
    refined_mesh_size: float = 5.0,
    max_mesh_size: float = 300.0,
    cells_per_wavelength: int = 10,
    margin: float = 50.0,
    airbox_margin: float = 0.0,
    ground_plane: GroundPlane | None = None,
    fmax: float = 100000000000.0,
    boundary_conditions: list[str] | None = None,
    planar_conductors: bool = False,
    refine_from_curves: bool = False,
    merge_via_distance: float = 2.0,
    show_gui: bool = False,
    preview_only: bool = False,
)

Configuration for mesh generation.

Use class methods for quick presets

MeshConfig.coarse() - Fast iteration (~2.5 elem/λ) MeshConfig.default() - Balanced (~5 elem/λ) MeshConfig.graded() - Default sizes + refined near conductor edges MeshConfig.fine() - High accuracy (~10 elem/λ)

Or customize directly

MeshConfig(refined_mesh_size=3.0, max_mesh_size=200.0)

Methods:

coarse –

Fast mesh for quick iteration (~2.5 elements per wavelength).
default –

Balanced mesh (~5 elements per wavelength).
fine –

High accuracy mesh (~10 elements per wavelength).
graded –

Default mesh sizes with refinement near conductor edges.

coarse `classmethod` ¶

coarse(**kwargs) -> MeshConfig

Fast mesh for quick iteration (~2.5 elements per wavelength).

default `classmethod` ¶

default(**kwargs) -> MeshConfig

Balanced mesh (~5 elements per wavelength).

fine `classmethod` ¶

fine(**kwargs) -> MeshConfig

High accuracy mesh (~10 elements per wavelength).

graded `classmethod` ¶

graded(**kwargs) -> MeshConfig

Default mesh sizes with refinement near conductor edges.

GroundPlane `dataclass` ¶

GroundPlane(layer_name: str, oversize: float = 50.0)

Ground plane configuration for microstrip structures.

generate_mesh ¶

generate_mesh(
    component,
    stack: LayerStack,
    ports: list[PalacePort],
    output_dir: str | Path,
    config: MeshConfig | None = None,
    model_name: str = "palace",
    driven_config: DrivenConfig | None = None,
    write_config: bool = True,
    pec_blocks: list[PECBlockConfig] | None = None,
) -> MeshResult

Generate mesh for Palace EM simulation.

Parameters:

component –

gdsfactory Component
stack (LayerStack) –

LayerStack from palace-api
ports (list[PalacePort]) –

List of PalacePort objects (single and multi-element)
output_dir (str | Path) –

Directory for output files
config (MeshConfig | None, default: None ) –

MeshConfig with mesh parameters
model_name (str, default: 'palace' ) –

Base name for output files (default: "mesh" -> mesh.msh)
driven_config (DrivenConfig | None, default: None ) –

Optional DrivenConfig for frequency sweep settings
write_config (bool, default: True ) –

Whether to write config.json (default True)

Returns:

MeshResult –

MeshResult with mesh path and metadata

Stack¶

LayerStack ¶

Bases: BaseModel

Complete layer stack for Palace simulation.

Layer ¶

Bases: BaseModel

Layer information for Palace simulation.

Palace

Simulation Classes¶

DrivenSim ¶

set_driven ¶

add_port ¶

add_cpw_port ¶

mesh ¶

preview ¶

validate_config ¶

write_config ¶

run ¶

start ¶

upload ¶

get_status ¶

wait_for_results ¶

EigenmodeSim ¶

set_eigenmode ¶

add_port ¶

add_cpw_port ¶

mesh ¶

preview ¶

validate_config ¶

run ¶

ElectrostaticSim ¶

set_electrostatic ¶

add_terminal ¶

mesh ¶

preview ¶

validate_config ¶

run ¶

Mesh¶

MeshConfig dataclass ¶

coarse classmethod ¶

default classmethod ¶

fine classmethod ¶

graded classmethod ¶

GroundPlane dataclass ¶

generate_mesh ¶

Stack¶

LayerStack ¶

Layer ¶

MeshConfig `dataclass` ¶

coarse `classmethod` ¶

default `classmethod` ¶

fine `classmethod` ¶

graded `classmethod` ¶

GroundPlane `dataclass` ¶