diff --git a/nbs/palace_2d_twmzm.ipynb b/nbs/palace_2d_twmzm.ipynb new file mode 100644 index 00000000..c49ed70a --- /dev/null +++ b/nbs/palace_2d_twmzm.ipynb @@ -0,0 +1,4587 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0", + "metadata": {}, + "source": [ + "# Palace 2D Mode Analysis: Travelling-Wave Mach-Zehnder Modulator\n", + "\n", + "This notebook builds a simplified cross-section of a Travelling-Wave Mach-Zehnder Modulator (TW-MZM) with a PN-junction embedded in a rib waveguide, using CPW electrodes for RF modulation.\n", + "\n", + "**Cross-section geometry (from literature):**\n", + "- **SOI substrate**: 220 nm Si on 2 um buried oxide (BOX)\n", + "- **Rib waveguide**: 400 nm width, 90 nm slab height\n", + "- **CPW electrodes**: Aluminium, 1 um thick, signal width $w=20$ um, gap $g=20$ um\n", + "- **PN junction**: Centred in the rib with P+/N+ contact regions in the slab\n", + "\n", + "We use `BoundaryModeSim` (Palace 2D eigenmode solver) to compute both RF and optical modes.\n", + "\n", + "**Requirements:**\n", + "- gdsfactory + generic PDK (`gf.gpdk`)\n", + "- A Palace binary resolved internally by `run_local()` (e.g. `palace-toolkit-cpu`, `PALACE_BIN`, or `palace` on PATH)\n", + "- [GDSFactory+](https://gdsfactory.com) account only for cloud runs\n", + "\n", + "**Workflow:** parameters are grouped next to the stage they configure — geometry & materials, then RF, then optical.\n" + ] + }, + { + "cell_type": "markdown", + "id": "1", + "metadata": {}, + "source": [ + "## Geometry & materials parameters\n", + "\n", + "Define the layout dimensions, the substrate/metal stack, and the doping\n", + "(geometry + material) for the rib and graded slab regions. These are consumed\n", + "by the geometry build and by\n", + "`gsim.common.cross_section.build_doped_cross_section()`.\n", + "\n", + "The generic helpers used here are PDK-agnostic — no hardcoded values live in\n", + "the notebook.\n", + "\n", + "**Layer assignments (gpdk):**\n", + "- `WG` (1,0): Waveguide core (220 nm Si, 400 nm wide)\n", + "- `SLAB90` (3,0): 90 nm slab regions\n", + "- `N` (20,0) / `P` (21,0): PN junction doping\n", + "- `NPP` (24,0) / `PP` (23,0): N+/P+ graded contact doping (via `make_doping_profile`)\n", + "- `M1` (41,0): CPW electrodes (Al, 1 um thick)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Geometry & materials parameters\n", + "# =============================================================================\n", + "\n", + "# --- Device / rib geometry (um) ---------------------------------------------\n", + "RIB_WIDTH = 0.4 # rib waveguide width\n", + "RIB_HEIGHT = 0.22 # rib waveguide height (z)\n", + "SLAB_THICKNESS = 0.09 # slab height (z) on each side of the rib\n", + "SLAB_HALF = 50.0 # slab half-width (y, on each side of the rib)\n", + "SIG_WIDTH = 20.0 # CPW signal electrode width\n", + "GAP_WIDTH = 20.0 # CPW signal-to-ground gap\n", + "GND_WIDTH = 40.0 # CPW ground electrode width\n", + "LENGTH = 10.0 # layout length along the propagation axis (x)\n", + "TOTAL_HALF = SIG_WIDTH / 2 + GAP_WIDTH + GND_WIDTH # lateral half-extent\n", + "RIB_CENTER_Y = -(SIG_WIDTH / 2 + GAP_WIDTH / 2) # rib centre y (=-20)\n", + "\n", + "VIA_SIZE = 2.7 # via_stack footprint (square)\n", + "VIA_S_TO_P_Y = -9.0 # via from signal to P+ contact (y)\n", + "VIA_G_TO_N_Y = -29.0 # via from ground to N+ contact (y)\n", + "\n", + "# --- Substrate stack (um) -----------------------------------------------------\n", + "BOX_THICKNESS = 2.0 # buried-oxide thickness (below z=0)\n", + "METAL1_ZMIN = 1.1 # metal1 bottom (top of the oxide stack)\n", + "METAL1_THICKNESS = 1.0 # CPW electrode thickness on metal1\n", + "\n", + "# --- PN junction / doping material model -------------------------------------\n", + "SI_PERMITTIVITY = 11.9\n", + "FMAX_RF_MATERIAL = 200e9 # validity range of the constant-eps doping models (Hz)\n", + "RIB_DOPING_SIGMA = 1.6e3 # p_rib / n_rib junction conductivity (S/m)\n", + "\n", + "# Graded slab doping {side: [(width_um, sigma_S_per_m), ...]}, from the rib edge.\n", + "DOPING_PROFILE = {\n", + " \"upper\": [(2.0, 2.0e4), (2.0, 8.0e4)], # P+ graded (toward signal)\n", + " \"lower\": [(2.0, 2.0e4), (2.0, 8.0e4)], # N+ graded (toward ground)\n", + "}\n", + "DOPING_SIDES = { # config passed to make_doping_profile()\n", + " \"upper\": {\"base_layer\": (23, 0), \"name_prefix\": \"pp_slab_\", \"sign\": 1},\n", + " \"lower\": {\"base_layer\": (24, 0), \"name_prefix\": \"npp_slab_\", \"sign\": -1},\n", + "}\n", + "\n", + "# --- Cross-section plane ------------------------------------------------------\n", + "CROSS_SECTION_AXIS = \"x\"\n", + "CROSS_SECTION_VALUE = 0.0" + ] + }, + { + "cell_type": "markdown", + "id": "3", + "metadata": {}, + "source": [ + "## Build TW-MZM cross-section geometry\n", + "\n", + "The 3D layout component is sliced at $x=0$ for 2D mode analysis. The graded\n", + "doping regions are created with `make_doping_profile()` (no hardcoded geometry).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import gdsfactory as gf\n", + "\n", + "from gsim.common.cross_section import build_optical_cross_section\n", + "from gsim.common.stack.doping import make_doping_profile\n", + "\n", + "gf.gpdk.PDK.activate()\n", + "\n", + "LAYER = gf.gpdk.LAYER\n", + "\n", + "\n", + "def centered_rect(wx: float, wy: float, layer) -> gf.Component:\n", + " r = gf.Component()\n", + " r << gf.c.rectangle((wx, wy), centered=True, layer=layer)\n", + " return r\n", + "\n", + "\n", + "def _add_device_core(comp: gf.Component) -> None:\n", + " \"\"\"Rib + slab + PN junction — shared by the RF and optical components.\n", + "\n", + " The P/N rectangles are the same \"doping profile\" polygons in both, so the\n", + " optical cross-section still shows the junction shape. The optical stack\n", + " maps all four regions to plain silicon.\n", + " \"\"\"\n", + " # 1. Rib waveguide core (PN junction sits inside it)\n", + " wg = comp << centered_rect(LENGTH, RIB_WIDTH, LAYER.WG)\n", + " wg.y = RIB_CENTER_Y\n", + "\n", + " # 2. Slab (90 nm)\n", + " slab = comp << centered_rect(LENGTH, 2 * SLAB_HALF + RIB_WIDTH, LAYER.SLAB90)\n", + " slab.y = 0.0\n", + "\n", + " # 3. PN junction (P above / N below the rib centre)\n", + " p_half = comp << gf.c.rectangle((LENGTH, RIB_WIDTH / 2), layer=LAYER.P)\n", + " p_half.y = RIB_CENTER_Y + RIB_WIDTH / 4\n", + " n_half = comp << gf.c.rectangle((LENGTH, RIB_WIDTH / 2), layer=LAYER.N)\n", + " n_half.y = RIB_CENTER_Y - RIB_WIDTH / 4\n", + "\n", + "\n", + "def _build_rf_component() -> tuple[gf.Component, dict]:\n", + " \"\"\"Full TW-MZM cross-section: device core + graded doping + CPW + vias.\"\"\"\n", + " comp = gf.Component()\n", + " _add_device_core(comp)\n", + "\n", + " # 4. Graded N+/P+ slab doping (contiguous, no gaps)\n", + " doping_result = make_doping_profile(\n", + " comp,\n", + " length=LENGTH,\n", + " rib_center_y=RIB_CENTER_Y,\n", + " rib_width=RIB_WIDTH,\n", + " profile=DOPING_PROFILE,\n", + " sides=DOPING_SIDES,\n", + " zmin=0.0,\n", + " zmax=SLAB_THICKNESS,\n", + " permittivity=SI_PERMITTIVITY,\n", + " fmax=FMAX_RF_MATERIAL,\n", + " )\n", + "\n", + " # 5. CPW electrodes (M1)\n", + " comp << centered_rect(LENGTH, SIG_WIDTH, LAYER.M1)\n", + " gnd_top = comp << centered_rect(LENGTH, GND_WIDTH, LAYER.M1)\n", + " gnd_top.y = SIG_WIDTH / 2 + GAP_WIDTH + GND_WIDTH / 2\n", + " gnd_bot = comp << centered_rect(LENGTH, GND_WIDTH, LAYER.M1)\n", + " gnd_bot.y = -(SIG_WIDTH / 2 + GAP_WIDTH + GND_WIDTH / 2)\n", + "\n", + " # 6. Vias at x=0 (signal-to-P+, ground-to-N+)\n", + " via_s_to_p = comp << gf.c.via_stack(\n", + " layers=(\"SLAB90\", \"M1\"), vias=(\"viac\", None), size=(VIA_SIZE, VIA_SIZE)\n", + " )\n", + " via_s_to_p.x = 0.0\n", + " via_s_to_p.y = VIA_S_TO_P_Y\n", + "\n", + " via_g_to_n = comp << gf.c.via_stack(\n", + " layers=(\"SLAB90\", \"M1\"), vias=(\"viac\", None), size=(VIA_SIZE, VIA_SIZE)\n", + " )\n", + " via_g_to_n.x = 0.0\n", + " via_g_to_n.y = VIA_G_TO_N_Y\n", + "\n", + " return comp, doping_result\n", + "\n", + "\n", + "def _build_optical_component() -> gf.Component:\n", + " \"\"\"Optical-only cross-section: rib + slab + PN junction (all silicon).\n", + "\n", + " No electrodes, vias, or graded doping — the optical mode sees a single\n", + " homogeneous Si body embedded in the uniform SiO2 cladding stack.\n", + " \"\"\"\n", + " comp = gf.Component()\n", + " _add_device_core(comp)\n", + " return comp\n", + "\n", + "\n", + "# --- RF component (electrodes, vias, graded doping) ------------------------\n", + "comp, doping_result = _build_rf_component()\n", + "\n", + "# --- Optical component (rib + slab + PN junction only) ---------------------\n", + "comp_optical = _build_optical_component()\n", + "\n", + "# -- Plot ----------------------------------------------------------------------\n", + "_cc = comp.copy()\n", + "_cc.draw_ports()\n", + "_cc.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "5", + "metadata": {}, + "source": [ + "## Inspect 2D cross-section\n", + "\n", + "The reusable `gsim.common.cross_section.build_doped_cross_section()` helper\n", + "assembles the base PDK stack, overrides `metal1`, registers the gradient doping\n", + "and PN-junction rib layers, and extracts the 2D cross-section at $x=0$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO M1 updated: zmin=1.1, zmax=2.1, thickness=1.0\n", + "INFO Stack: generic\n", + "INFO Layers: ['box', 'clad', 'core', 'deep_etch', 'ge', 'heater', 'metal1', 'metal2', 'metal3', 'n_rib', 'nitride', 'npp_slab_0', 'npp_slab_1', 'p_rib', 'pp_slab_0', 'pp_slab_1', 'shallow_etch', 'slab150', 'slab90', 'undercut', 'via1', 'via2', 'via_contact']\n", + "INFO Cross materials: ['n_rib', 'npp_slab_0', 'npp_slab_1', 'p_rib', 'pp_slab_0', 'pp_slab_1']\n", + "INFO Dielectrics: [{'name': 'oxide', 'zmin': -2.0, 'zmax': 5.2, 'material': 'sio2'}, {'name': 'passive', 'zmin': 5.2, 'zmax': 5.6000000000000005, 'material': 'passive'}]\n", + "INFO \n", + "INFO Cross-section x=0.0 intersects 13 layer regions:\n", + "INFO core material=si y=[ -20.200, -19.800] z=[ 0.000, 0.220]\n", + "INFO slab90 material=si y=[ -50.200, 50.200] z=[ 0.000, 0.090]\n", + "INFO via_contact material=Aluminum y=[ -29.350, -28.650] z=[ 0.090, 1.100]\n", + "INFO via_contact material=Aluminum y=[ -9.350, -8.650] z=[ 0.090, 1.100]\n", + "INFO metal1 material=Aluminum y=[ -70.000, -27.650] z=[ 1.100, 2.100]\n", + "INFO metal1 material=Aluminum y=[ -10.350, 10.000] z=[ 1.100, 2.100]\n", + "INFO metal1 material=Aluminum y=[ 30.000, 70.000] z=[ 1.100, 2.100]\n", + "INFO pp_slab_0 material=pp_slab_0 y=[ -19.800, -17.800] z=[ 0.000, 0.090]\n", + "INFO pp_slab_1 material=pp_slab_1 y=[ -17.800, -15.800] z=[ 0.000, 0.090]\n", + "INFO npp_slab_0 material=npp_slab_0 y=[ -22.200, -20.200] z=[ 0.000, 0.090]\n", + "INFO npp_slab_1 material=npp_slab_1 y=[ -24.200, -22.200] z=[ 0.000, 0.090]\n", + "INFO p_rib material=p_rib y=[ -20.000, -19.800] z=[ 0.000, 0.220]\n", + "INFO n_rib material=n_rib y=[ -20.200, -20.000] z=[ 0.000, 0.220]\n" + ] + } + ], + "source": [ + "# Make the helper's diagnostics visible\n", + "import logging\n", + "\n", + "logging.basicConfig(level=logging.INFO, format=\"%(levelname)s %(message)s\")\n", + "\n", + "from gsim.common.cross_section import build_doped_cross_section\n", + "\n", + "stack, section = build_doped_cross_section(\n", + " comp,\n", + " axis=CROSS_SECTION_AXIS,\n", + " value=CROSS_SECTION_VALUE,\n", + " substrate_thickness=BOX_THICKNESS,\n", + " metal1=(METAL1_ZMIN, METAL1_THICKNESS),\n", + " doping=doping_result,\n", + " rib_layers=[\n", + " (\"p_rib\", LAYER.P, RIB_DOPING_SIGMA),\n", + " (\"n_rib\", LAYER.N, RIB_DOPING_SIGMA),\n", + " ],\n", + " rib_height=RIB_HEIGHT,\n", + " permittivity=SI_PERMITTIVITY,\n", + " fmax=FMAX_RF_MATERIAL,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "3a9abd45", + "metadata": {}, + "source": [ + "## Optical-only cross-section\n", + "\n", + "The optical analysis uses a simplified component: the same rib + slab + PN\n", + "junction (identical \"doping profile\" polygons) but **no** electrodes, vias, or\n", + "graded doping. Every device region maps to plain silicon, so the optical mode\n", + "sees one homogeneous Si body embedded in a uniform SiO2 cladding.\n", + "\n", + "`gsim.common.cross_section.build_optical_cross_section()` assembles the\n", + "minimal all-dielectric `LayerStack` and extracts the 2D cross-section at $x=0$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7474139a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO Stack: optical\n", + "INFO Layers: ['core', 'n_rib', 'p_rib', 'slab']\n", + "INFO Device material: si\n", + "INFO Cladding material: sio2\n", + "INFO Dielectrics: [{'name': 'oxide', 'zmin': -2.0, 'zmax': 3.0, 'material': 'sio2'}]\n", + "INFO \n", + "INFO Cross-section x=0.0 intersects 4 layer regions:\n", + "INFO core material=si y=[ -20.200, -19.800] z=[ 0.000, 0.220]\n", + "INFO slab material=si y=[ -50.200, 50.200] z=[ 0.000, 0.090]\n", + "INFO p_rib material=si y=[ -20.000, -19.800] z=[ 0.000, 0.220]\n", + "INFO n_rib material=si y=[ -20.200, -20.000] z=[ 0.000, 0.220]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optical stack layers: ['core', 'n_rib', 'p_rib', 'slab']\n", + "Optical cladding: [{'name': 'oxide', 'zmin': -2.0, 'zmax': 3.0, 'material': 'sio2'}]\n" + ] + } + ], + "source": [ + "# Uniform SiO2 cladding height above z=0 (um)\n", + "OPT_CLAD_TOP = 3.0\n", + "\n", + "stack_opt, section_opt = build_optical_cross_section(\n", + " comp_optical,\n", + " axis=CROSS_SECTION_AXIS,\n", + " value=CROSS_SECTION_VALUE,\n", + " device_layers={\n", + " \"core\": (LAYER.WG, 0.0, RIB_HEIGHT),\n", + " \"slab\": (LAYER.SLAB90, 0.0, SLAB_THICKNESS),\n", + " \"p_rib\": (LAYER.P, 0.0, RIB_HEIGHT),\n", + " \"n_rib\": (LAYER.N, 0.0, RIB_HEIGHT),\n", + " },\n", + " substrate_thickness=BOX_THICKNESS,\n", + " cladding_top=OPT_CLAD_TOP,\n", + ")\n", + "\n", + "print(\"Optical stack layers:\", sorted(stack_opt.layers.keys()))\n", + "print(\"Optical cladding:\", stack_opt.dielectrics)" + ] + }, + { + "cell_type": "markdown", + "id": "71bcea16", + "metadata": {}, + "source": [ + "### Optical cross-section plot\n", + "\n", + "The PN junction still shows its P/N profile, but both regions and the slab are\n", + "the same silicon material." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "518d76a7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from gsim.palace import plot_plane_section\n", + "\n", + "PLOT_ZOOM_OPT = {\"h_range\": (-4.0, 4.0), \"v_range\": (-0.6, 1.5)}\n", + "PLOT_COLORS_OPT = {\n", + " \"core\": \"#c0392b\", # rib Si\n", + " \"slab\": \"#e67e22\", # slab Si\n", + " \"p_rib\": \"#2980b9\", # PN junction P region (Si)\n", + " \"n_rib\": \"#27ae60\", # PN junction N region (Si)\n", + "}\n", + "PLOT_TITLE_OPT = (\n", + " \"Optical cross-section: rib + slab + PN junction (all Si, SiO2 cladding)\"\n", + ")\n", + "\n", + "plot_plane_section(\n", + " section_opt,\n", + " colors=PLOT_COLORS_OPT,\n", + " h_range=PLOT_ZOOM_OPT[\"h_range\"],\n", + " v_range=PLOT_ZOOM_OPT[\"v_range\"],\n", + " title=PLOT_TITLE_OPT,\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9a8a7a82", + "metadata": {}, + "source": [ + "### Optical material properties (1550 nm)\n", + "\n", + "The PDK stack materials resolve to their Sellmeier optical constants at the\n", + "simulation wavelength. The Palace boundary-mode config generator evaluates\n", + "dispersion at `F_OPT` automatically; the values below are for reference." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "22caa2d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "si @ 1.55 um: eps=12.0946 n=3.4777\n", + "sio2 @ 1.55 um: eps=2.0852 n=1.4440\n" + ] + } + ], + "source": [ + "import math\n", + "\n", + "from gsim.common.stack.materials import resolve_material_at_wavelength\n", + "\n", + "LAMBDA_OPT = 1.55 # reference wavelength (um)\n", + "\n", + "si_opt = resolve_material_at_wavelength(\"si\", LAMBDA_OPT)\n", + "sio2_opt = resolve_material_at_wavelength(\"sio2\", LAMBDA_OPT)\n", + "print(\n", + " f\"si @ {LAMBDA_OPT:.2f} um: eps={si_opt.permittivity_scalar:.4f} n={math.sqrt(si_opt.permittivity_scalar):.4f}\"\n", + ")\n", + "print(\n", + " f\"sio2 @ {LAMBDA_OPT:.2f} um: eps={sio2_opt.permittivity_scalar:.4f} n={math.sqrt(sio2_opt.permittivity_scalar):.4f}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7", + "metadata": {}, + "source": [ + "## Plot the 2D cross-section\n", + "\n", + "The physical-group regions are rendered with the reusable\n", + "`gsim.palace.plot_plane_section()`. The full layout spans ~140 um, so we zoom\n", + "on the central region to show the rib, PN junction, graded doping and vias.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8", + "metadata": {}, + "outputs": [], + "source": [ + "# --- Cross-section plot parameters (physical-group regions) ---------------\n", + "PLOT_ZOOM = {\"h_range\": (-15.0, 15.0), \"v_range\": (-0.5, 5.0)}\n", + "PLOT_COLORS = {\n", + " \"core\": \"#c0392b\", # rib Si -- red\n", + " \"slab90\": \"#e67e22\", # slab Si -- orange\n", + " \"p_rib\": \"#2980b9\", # P doping -- blue\n", + " \"pp_slab_0\": \"#8e44ad\", # P+ graded inner -- purple\n", + " \"pp_slab_1\": \"#a569bd\", # P+ graded outer -- light purple\n", + " \"n_rib\": \"#27ae60\", # N doping -- green\n", + " \"npp_slab_0\": \"#4460ad\", # N+ graded inner -- indigo\n", + " \"npp_slab_1\": \"#5b7dcf\", # N+ graded outer -- light indigo\n", + " \"metal1\": \"#7f8c8d\", # CPW electrodes (Al) -- grey\n", + " \"metal2\": \"#7f8c8d\",\n", + " \"metal3\": \"#7f8c8d\",\n", + " \"via_contact\": \"#f1c40f\", # via -- gold\n", + " \"via1\": \"#f1c40f\",\n", + " \"via2\": \"#f1c40f\",\n", + "}\n", + "PLOT_TITLE = \"TW-MZM cross-section (zoomed on rib + doping + signal electrode)\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from gsim.palace import plot_plane_section\n", + "\n", + "plot_plane_section(\n", + " section,\n", + " colors=PLOT_COLORS,\n", + " h_range=PLOT_ZOOM[\"h_range\"],\n", + " v_range=PLOT_ZOOM[\"v_range\"],\n", + " title=PLOT_TITLE,\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "10", + "metadata": {}, + "source": [ + "## RF simulation (50 GHz)\n", + "\n", + "Configure the 50 GHz BoundaryMode run: simulation airbox, mesh, number of\n", + "modes, output directory, and the field quantities to plot.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "11", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# RF parameters (50 GHz BoundaryMode run)\n", + "# =============================================================================\n", + "\n", + "# --- Simulation box (airbox + mesh margins, um) -----------------------------\n", + "AIRBOX = {\"margin_x\": 50.0, \"margin_y\": 50.0, \"z_above\": 100.0, \"z_below\": 100.0}\n", + "MESH_MARGIN_X = 0.0\n", + "MESH_MARGIN_Y = 50.0\n", + "\n", + "# --- RF solver settings -----------------------------------------------------\n", + "F_RF = 50e9\n", + "NUM_RF_MODES = 2\n", + "RF_OUTPUT_DIR = \"./palace-sim-mzm-pn\"\n", + "RF_MESH = {\n", + " \"preset\": \"default\",\n", + " \"refined_mesh_size\": 0.05,\n", + " \"max_mesh_size\": 40.0,\n", + " \"fmax\": 150e9,\n", + "}\n", + "\n", + "# --- RF post-processing -----------------------------------------------------\n", + "RF_FIELD = \"E_real\"\n", + "RF_FIELD_TITLE = \"RF Mode |E| at x=0 (50 GHz)\"\n", + "RIB_PHYSICAL_GROUPS = [\n", + " \"n_rib\",\n", + " \"npp_slab_0\",\n", + " \"npp_slab_1\",\n", + " \"p_rib\",\n", + " \"pp_slab_0\",\n", + " \"pp_slab_1\",\n", + "]\n", + "\n", + "# --- PN junction lumped model -------------------------------------------------\n", + "PN_JUNCTION_CAPACITANCE = 1e-15 # F, on the p_rib / n_rib interface" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "12", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO Generating mesh in palace-sim-mzm-pn\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO Extracting geometry...\n", + "INFO Polygons: 17\n", + "INFO Bbox: (-5.0, -70.0, 10.0, 70.0)\n", + "INFO Building native 2D BoundaryMode geometry...\n", + "INFO Filtered 14 internal conductor curves for 'metal1' (2 remaining)\n", + "INFO Filtered 6 internal conductor curves for 'via_contact' (2 remaining)\n", + "INFO Generating native 2D BoundaryMode mesh...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2D domain groups: ['n_rib', 'npp_slab_0', 'npp_slab_1', 'p_rib', 'passive', 'pp_slab_0', 'pp_slab_1', 'sio2', 'slab90', 'air']\n", + " Bounding box: 340.000 x 208.600 x 0.000 um\n", + " Nodes: 42,253\n", + " Elements: 103,726\n", + " Domain groups: 10\n", + " Conductor surfaces:2\n", + " Interface surfaces:17\n", + " Est. ND-space DOFs (order 2): ~622,356\n", + " Est. H1-space DOFs (order 2): ~622,356\n", + " Est. total DOFs: ~1,244,712\n" + ] + } + ], + "source": [ + "from gsim.palace import BoundaryModeSim\n", + "\n", + "# -- Boundary 2D simulation setup (RF) ----------------------------------\n", + "sim = BoundaryModeSim()\n", + "sim.set_output_dir(RF_OUTPUT_DIR)\n", + "sim.set_stack(stack)\n", + "sim.set_airbox(**AIRBOX)\n", + "sim.set_geometry(comp)\n", + "\n", + "sim.set_cross_section(f\"{CROSS_SECTION_AXIS}={CROSS_SECTION_VALUE}\")\n", + "sim.set_boundary_mode(freq=F_RF, num_modes=NUM_RF_MODES, save=2)\n", + "\n", + "# -- Mesh ---------------------------------------------------------------------\n", + "sim.mesh(\n", + " preset=RF_MESH[\"preset\"],\n", + " refined_mesh_size=RF_MESH[\"refined_mesh_size\"],\n", + " max_mesh_size=RF_MESH[\"max_mesh_size\"],\n", + " fmax=RF_MESH[\"fmax\"],\n", + " margin_x=MESH_MARGIN_X,\n", + " margin_y=MESH_MARGIN_Y,\n", + ")\n", + "\n", + "# Show the 2D domain groups created by the solver\n", + "domain_groups = list(sim._last_mesh_result.groups[\"volumes\"].keys())\n", + "print(\"2D domain groups:\", domain_groups)\n", + "sim.print_mesh_stats()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO Solid plot: using 1 surface cell blocks\n", + "INFO awaiting runner setup\n", + "INFO awaiting site startup\n", + "INFO Print WSLINK_READY_MSG\n", + "INFO Schedule auto shutdown with timeout 0\n", + "INFO awaiting running future\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b63ec5af348f44efb65c940d2aee74a1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Widget(value='