{ "cells": [ { "cell_type": "raw", "id": "1f3e1570", "metadata": { "tags": [ "remove-cell" ] }, "source": [ "/// script\n", "requires-python = \">=3.12,<3.15\"\n", "dependencies = [\n", " \"qpdk[models] @ git+https://github.com/gdsfactory/quantum-rf-pdk.git\",\n", " \"gplugins[elmer] @ git+https://github.com/gdsfactory/gplugins.git@c3372b97a50cda44043603f80c955edcf028a7fb\",\n", "]\n", "///" ] }, { "cell_type": "markdown", "id": "cc87a30d", "metadata": {}, "source": [ "# Elmer Capacitance Extraction of an Interdigital Capacitor\n", "\n", "::::{admonition} Required extras\n", ":class: tip\n", "\n", "This notebook needs the `models` extra and the Elmer driver from `gplugins`:\n", "\n", "```bash\n", "uv add \"qpdk[models]\" \"gplugins[elmer] @ git+https://github.com/gdsfactory/gplugins.git@c3372b97a50cda44043603f80c955edcf028a7fb\"\n", "# or with pip:\n", "pip install \"qpdk[models]\" \"gplugins[elmer] @ git+https://github.com/gdsfactory/gplugins.git@c3372b97a50cda44043603f80c955edcf028a7fb\"\n", "```\n", "\n", "The driver was merged in [gplugins PR #781](https://github.com/gdsfactory/gplugins/pull/781).\n", "These commands pin the revision used for the saved result until a release includes\n", "the `elmer` extra.\n", "\n", "**Elmer is an external solver.** `ElmerGrid` and `ElmerSolver` must be available on your\n", "`PATH`; `ElmerSolver_mpi` is also needed when `QPDK_ELMER_PROCESSES` exceeds 1. They\n", "are not pip-installable. See the\n", "[Elmer FEM installation guide](https://www.elmerfem.org/blog/binaries/) for binaries and\n", "container options.\n", "\n", "See the {ref}`extras reference ` for what each qpdk extra installs.\n", "::::\n", "\n", "This notebook runs a quasi-static electrostatic solve with Elmer FEM for two\n", "interdigital terminals surrounded by a finite grounded M1 region. Elmer solves\n", "$\\nabla \\cdot (\\epsilon \\nabla \\phi) = 0$ with a fixed potential on each metal\n", "terminal. Elmer's `.dat` result is the lumped (circuit) capacitance matrix;\n", "`gplugins` converts it to a Maxwell matrix, with negative off-diagonal entries, in\n", "`ElectrostaticResults`.\n", "\n", "The reported number comes from a mesh-convergence study. The geometry, the layer stack\n", "and the simulation domain are held fixed, the mesh is refined over five factors, and\n", "the finest mesh supplies the final value. A separate lateral-pad comparison checks how\n", "much that value depends on the outer boundary of the finite domain.\n", "\n", "The saved output uses cubic elements and a 0.5 % refinement check. When\n", "`GITHUB_ACTIONS` is set, CI runs one coarse first-order solve and checks the matrix;\n", "it skips refinement and domain studies. Set `QPDK_ELMER_CI_FAST=1` to use the same\n", "smoke profile locally. The cubic profile is memory intensive." ] }, { "cell_type": "markdown", "id": "5adb0aba", "metadata": {}, "source": [ "## Physics\n", "\n", "An interdigital capacitor (IDC) is two interleaved combs of metal fingers. Each comb is\n", "a separate terminal. A nearby M1 region is a third conductor held at zero potential.\n", "We extract the terminal-to-terminal coupling and each terminal's capacitance to ground.\n", "\n", "For $N$ conductors Elmer's `.dat` result is the lumped (circuit) capacitance\n", "matrix. `gplugins` converts it to the Maxwell form $C$ reported in\n", "`ElectrostaticResults`, defined by $Q_i = \\sum_j C_{ij} V_j$ with negative\n", "off-diagonal entries:\n", "\n", "$$ C_{ij} = -C_{ij}^{\\text{mutual}} \\quad (i \\neq j). $$\n", "\n", "With the ground fixed at zero, the reduced two-terminal matrix has\n", "$C_{12}^{\\text{mutual}} = -C_{12}$ and\n", "$C_{1\\text{g}} = C_{11} + C_{12}$,\n", "$C_{2\\text{g}} = C_{22} + C_{21}$. Thus each diagonal includes coupling to the\n", "other terminal and to ground. All Elmer output is in SI units (farads); we convert\n", "to femtofarads below.\n", "\n", "This is a 3D FEM result only. It is **not benchmarked against an analytic IDC model**,\n", "and no analytic formula is evaluated here. The check below compares the last two\n", "mesh results; their difference is not a bound on absolute model error." ] }, { "cell_type": "markdown", "id": "f7abc75a", "metadata": {}, "source": [ "## Setup and Imports" ] }, { "cell_type": "code", "execution_count": 1, "id": "d747815d", "metadata": { "tags": [ "hide-input", "hide-output" ] }, "outputs": [], "source": [ "import sys\n", "\n", "if \"google.colab\" in sys.modules:\n", " import subprocess\n", "\n", " print(\"Running in Google Colab. Installing QPDK...\")\n", " subprocess.check_call([\n", " sys.executable,\n", " \"-m\",\n", " \"pip\",\n", " \"install\",\n", " \"-q\",\n", " \"qpdk[models] @ git+https://github.com/gdsfactory/quantum-rf-pdk.git\",\n", " \"gplugins[elmer] @ git+https://github.com/gdsfactory/gplugins.git@c3372b97a50cda44043603f80c955edcf028a7fb\",\n", " ])" ] }, { "cell_type": "code", "execution_count": 2, "id": "46a7011b", "metadata": { "tags": [ "hide-input", "hide-output" ] }, "outputs": [], "source": [ "# CI executes this notebook headless with MPLBACKEND=Agg, which would drop the\n", "# convergence figure from the saved output, so pin the backend that renders figures\n", "# inline.\n", "import matplotlib\n", "\n", "matplotlib.use(\"module://matplotlib_inline.backend_inline\")" ] }, { "cell_type": "code", "execution_count": 3, "id": "af4fc557", "metadata": { "tags": [ "hide-input", "hide-output" ] }, "outputs": [], "source": [ "import os\n", "import tempfile\n", "from dataclasses import dataclass\n", "from pathlib import Path\n", "from typing import Any\n", "\n", "import gdsfactory as gf\n", "import numpy as np\n", "from gplugins.elmer import run_capacitive_simulation_elmer\n", "from matplotlib import font_manager, pyplot as plt\n", "from matplotlib.patches import Patch, Polygon as MplPolygon\n", "from meshwell.resolution import ConstantInField\n", "\n", "from qpdk import PDK\n", "from qpdk.cells.capacitor import interdigital_capacitor\n", "from qpdk.config import PATH\n", "from qpdk.tech import LAYER, get_layer_material_properties, material_properties\n", "\n", "PDK.activate()" ] }, { "cell_type": "code", "execution_count": 4, "id": "cb3796cc", "metadata": { "tags": [ "hide-input", "hide-output" ] }, "outputs": [], "source": [ "for style_source in (PATH.repo / \"docs\" / \"qpdk.mplstyle\", \"qpdk\"):\n", " try:\n", " plt.style.use(style_source)\n", " except OSError:\n", " continue\n", " break\n", "\n", "for font_path in (PATH.repo / \"build\" / \"docs-fonts\").glob(\"*\"):\n", " if font_path.suffix.lower() in {\".otf\", \".ttf\"}:\n", " font_manager.fontManager.addfont(str(font_path))\n", "\n", "installed_fonts = {font.name for font in font_manager.fontManager.ttflist}\n", "plt.rcParams[\"font.sans-serif\"] = [\n", " name\n", " for name in (\"Inter\", \"Outfit\", \"DejaVu Sans\", \"Helvetica\", \"Arial\")\n", " if name in installed_fonts\n", "] + [\"sans-serif\"]\n", "\n", "try:\n", " from IPython import get_ipython\n", "\n", " if get_ipython() is not None:\n", " from matplotlib_inline.backend_inline import set_matplotlib_formats\n", "\n", " plt.rcParams[\"svg.fonttype\"] = \"path\"\n", " set_matplotlib_formats(\"svg\", \"png\")\n", "except ImportError:\n", " pass # Plain Python runs do not need IPython display formats." ] }, { "cell_type": "markdown", "id": "bfdee871", "metadata": { "lines_to_next_cell": 2 }, "source": [ "## Simulation Geometry\n", "\n", "We use the QPDK `interdigital_capacitor` geometry with\n", "a small number of fingers to keep the mesh and solve affordable.\n", "\n", "![Two isolated IDC combs inside a grounded M1 frame and finite dielectric domain](figures/elmer-idc-ground.svg)\n", "\n", "Three details matter for a valid capacitance extraction:\n", "\n", "1. **Two isolated terminals.** The capacitor must present two disconnected metal\n", " polygons. QPDK's IDC draws its metal on `M1_DRAW` (the additive mask). We omit its\n", " default local etch rectangle so the two combs remain separate.\n", "2. **Grounded chip metal.** A disconnected M1 frame surrounds the combs across a\n", " 10 µm etched clearance. We draw it on `M1_DRAW` and etch the full simulation\n", " outline. QPDK's derived `M1` rule, `SIM_AREA - (M1_ETCH - M1_DRAW)`, then leaves\n", " exactly the two ported combs and the unported frame. The Elmer driver grounds\n", " unported conductors. The frame's outer edge stays fixed 45 µm from the IDC.\n", "3. **A domain outline for the dielectrics.** The substrate and air prisms are built from\n", " the same outline on the non-fabrication `SIM_AREA` layer.\n", "\n", "The lateral pad is fixed for the whole study at `domain_pad=90.0` μm, which puts the\n", "outer boundary beyond the fixed ground frame. The outer substrate and vacuum faces\n", "use Elmer's natural zero-normal-flux boundary condition, so\n", "the finite domain still affects the extracted value; the lateral-pad comparison below\n", "quantifies that effect separately from mesh convergence." ] }, { "cell_type": "code", "execution_count": 5, "id": "2c8f18f7", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "findfont: Failed to find font weight bold, now using 400.\n" ] }, { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", " \n", " \n", " \n", " \n", " 2026-09-26T13:19:18.430716\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.11.1, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Bounding box: (-108,-103;108,103)\n", "Terminals: ['o1', 'o2']\n" ] } ], "source": [ "@gf.cell\n", "def interdigital_capacitor_for_elmer(\n", " fingers: int = 4,\n", " finger_length: float = 20.0,\n", " finger_gap: float = 2.0,\n", " thickness: float = 5.0,\n", " ground_clearance: float = 10.0,\n", " ground_outer_pad: float = 45.0,\n", " domain_pad: float = 90.0,\n", ") -> gf.Component:\n", " \"\"\"Two-terminal IDC with a separate grounded M1 frame.\n", "\n", " Args:\n", " fingers: Total number of interleaved fingers.\n", " finger_length: Length of each finger in μm.\n", " finger_gap: Gap between adjacent fingers in μm.\n", " thickness: Finger width in μm.\n", " ground_clearance: Etched clearance from the IDC bounding box to ground in μm.\n", " ground_outer_pad: Outer edge of the grounded frame from the IDC in μm.\n", " domain_pad: Lateral padding of the dielectric simulation domain in μm.\n", "\n", " Returns:\n", " Component with two ported combs, one unported M1 ground frame, and a\n", " `SIM_AREA` outline for the dielectric domain.\n", "\n", " Raises:\n", " ValueError: If the ground clearance, ground extent, and domain are not nested.\n", " \"\"\"\n", " if not 0 < ground_clearance < ground_outer_pad < domain_pad:\n", " raise ValueError(\"Require 0 < ground_clearance < ground_outer_pad < domain_pad\")\n", "\n", " c = gf.Component()\n", " idc = c << interdigital_capacitor(\n", " fingers=fingers,\n", " finger_length=finger_length,\n", " finger_gap=finger_gap,\n", " thickness=thickness,\n", " etch_layer=None, # keep the two combs as separate M1_DRAW polygons\n", " )\n", " c.add_ports(idc.ports)\n", "\n", " c.flatten()\n", " device = c.bbox()\n", " ground_inner = device.enlarged(ground_clearance, ground_clearance)\n", " ground_outer = device.enlarged(ground_outer_pad, ground_outer_pad)\n", " domain = device.enlarged(domain_pad, domain_pad)\n", " ground_sections = (\n", " (\n", " ground_outer.left,\n", " ground_outer.bottom,\n", " ground_outer.right,\n", " ground_inner.bottom,\n", " ),\n", " (ground_outer.left, ground_inner.top, ground_outer.right, ground_outer.top),\n", " (ground_outer.left, ground_inner.bottom, ground_inner.left, ground_inner.top),\n", " (ground_inner.right, ground_inner.bottom, ground_outer.right, ground_inner.top),\n", " )\n", " for section in ground_sections:\n", " c.kdb_cell.shapes(LAYER.M1_DRAW).insert(gf.kdb.DBox(*section))\n", " c.kdb_cell.shapes(LAYER.SIM_AREA).insert(domain)\n", " c.kdb_cell.shapes(LAYER.M1_ETCH).insert(domain)\n", " return c\n", "\n", "\n", "component = interdigital_capacitor_for_elmer()\n", "colors = plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"]\n", "ground_color, signal_color = colors[:2]\n", "metal_shapes = []\n", "for polygon in component.get_polygons(by=\"name\", layers=[LAYER.M1_DRAW])[\"M1_DRAW\"]:\n", " metal = polygon.to_dtype(component.kcl.dbu)\n", " vertices = [(point.x, point.y) for point in metal.each_point_hull()]\n", " is_signal = any(\n", " metal.bbox().contains(gf.kdb.DPoint(*port.center)) for port in component.ports\n", " )\n", " metal_shapes.append((vertices, is_signal))\n", "\n", "_, (ax_domain, ax_device) = plt.subplots(1, 2, figsize=(9.0, 4.2), layout=\"constrained\")\n", "for ax in (ax_domain, ax_device):\n", " for vertices, is_signal in metal_shapes:\n", " ax.add_patch(\n", " MplPolygon(\n", " vertices,\n", " facecolor=signal_color if is_signal else ground_color,\n", " edgecolor=\"none\",\n", " )\n", " )\n", " ax.set_aspect(\"equal\")\n", " ax.set_xlabel(\"x (µm)\")\n", " ax.set_ylabel(\"y (µm)\")\n", "\n", "domain = component.bbox()\n", "ax_domain.plot(\n", " [domain.left, domain.right, domain.right, domain.left, domain.left],\n", " [domain.bottom, domain.bottom, domain.top, domain.top, domain.bottom],\n", " linestyle=\"--\",\n", " color=\"0.4\",\n", ")\n", "ax_domain.set_xlim(domain.left - 5, domain.right + 5)\n", "ax_domain.set_ylim(domain.bottom - 5, domain.top + 5)\n", "ax_domain.set_title(\"Full dielectric domain\")\n", "ax_domain.legend(\n", " handles=[\n", " Patch(facecolor=signal_color, label=\"Signal terminals\"),\n", " Patch(facecolor=ground_color, label=\"Grounded M1\"),\n", " ],\n", " loc=\"upper right\",\n", ")\n", "\n", "ax_device.set_xlim(-38, 38)\n", "ax_device.set_ylim(-35, 35)\n", "ax_device.set_title(\"IDC and ground clearance\")\n", "for port in component.ports:\n", " ax_device.plot(*port.center, marker=\"o\", color=signal_color)\n", " ax_device.annotate(\n", " port.name,\n", " port.center,\n", " xytext=(0, 7),\n", " textcoords=\"offset points\",\n", " ha=\"center\",\n", " )\n", "plt.show()\n", "print(f\"Bounding box: {component.bbox()}\")\n", "print(f\"Terminals: {[port.name for port in component.ports]}\")" ] }, { "cell_type": "markdown", "id": "d06f990a", "metadata": {}, "source": [ "## Layer Stack and Materials\n", "\n", "We start from `PDK.layer_stack`, which the Palace capacitor optimization notebook\n", "also uses. We retain the three levels needed here, including the derived `M1` rule.\n", "The PDK specifies the Nb film thickness and every material. We only truncate the\n", "substrate and vacuum heights to $60\\,\\text{μm}$ and $40\\,\\text{μm}$ for this finite\n", "simulation domain; the full PDK values are printed below. The vacuum starts at the\n", "substrate surface to fill the gaps beside\n", "the film; [meshwell](https://github.com/simbilod/meshwell) cuts the higher-priority\n", "metal out of that prism. We check lateral-domain sensitivity below, but do not\n", "quantify the effect of these vertical truncations.\n", "\n", "Material permittivities come from the QPDK technology definition\n", "(`qpdk.tech.material_properties`), looked up from each level's material; the niobium\n", "film is treated as a perfect conductor." ] }, { "cell_type": "code", "execution_count": 6, "id": "b3e64567", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Layer stack:\n", " M1: z = +0.00 … +0.20 µm, material = Nb\n", " Substrate: z = -60.00 … +0.00 µm, material = Si\n", " Vacuum: z = +0.00 … +40.00 µm, material = vacuum\n" ] } ], "source": [ "SUBSTRATE_DOMAIN_UM = 60.0\n", "VACUUM_DOMAIN_UM = 40.0\n", "\n", "layer_stack = PDK.layer_stack.model_copy(deep=True)\n", "layer_stack.layers = {\n", " name: layer_stack.layers[name] for name in (\"M1\", \"Substrate\", \"Vacuum\")\n", "}\n", "layer_stack.layers[\"Substrate\"].zmin = -SUBSTRATE_DOMAIN_UM\n", "layer_stack.layers[\"Substrate\"].thickness = SUBSTRATE_DOMAIN_UM\n", "layer_stack.layers[\"Vacuum\"].zmin = 0.0\n", "layer_stack.layers[\"Vacuum\"].thickness = VACUUM_DOMAIN_UM\n", "\n", "material_spec = material_properties\n", "\n", "print(\"Layer stack (full PDK thickness in brackets):\")\n", "for name, level in layer_stack.layers.items():\n", " epsilon_r = get_layer_material_properties(name, layer_stack)[\n", " \"relative_permittivity\"\n", " ]\n", " print(\n", " f\" {name:>9}: z = {level.zmin:+.2f} … {level.zmin + level.thickness:+.2f} µm \"\n", " f\"({PDK.layer_stack.layers[name].thickness:g} µm), \"\n", " f\"material = {level.material}, εr = {epsilon_r:g}\"\n", " )" ] }, { "cell_type": "markdown", "id": "e3ef4044", "metadata": {}, "source": [ "## Mesh Settings\n", "\n", "`mesh_parameters` is forwarded to [meshwell's mesh function](https://simbilod.github.io/meshwell/02_intro_meshwell.html#cad-mesh).\n", "Its [`resolution_specs` API](https://simbilod.github.io/meshwell/21_resolution_advanced.html)\n", "maps each physical prism name to a list of resolution objects. The driver splits\n", "the ported metal into `M1@o1` and `M1@o2`; the unported `M1` frame is ground.\n", "[`ConstantInField`](https://simbilod.github.io/meshwell/20_resolution_basic.html)\n", "pins an element size. The terminal surfaces resolve the 2 µm finger gaps, while\n", "ground edges and the bulk dielectric can be coarser.\n", "\n", "`BASE_MESH_LENGTHS_UM` holds the nominal (factor 1.0) lengths, and\n", "`mesh_parameters_for_factor` scales every one of them by the same factor: a smaller\n", "factor refines the whole mesh uniformly, while the geometry, the layer stack and the\n", "domain stay untouched." ] }, { "cell_type": "code", "execution_count": 7, "id": "f8583827", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Nominal default characteristic length: 8.00 µm\n", " M1@o1: 0.50 µm (curves), 0.50 µm (surfaces)\n", " M1@o2: 0.50 µm (curves), 0.50 µm (surfaces)\n", " M1: 2.00 µm (curves)\n", " Substrate: 3.00 µm (surfaces), 8.00 µm (volumes)\n", " Vacuum: 3.00 µm (surfaces), 8.00 µm (volumes)\n" ] } ], "source": [ "BASE_MESH_LENGTHS_UM = {\n", " \"default\": 8.0, # μm, everywhere not covered by a more specific spec\n", " \"terminal\": 0.5, # μm, terminal edges and faces\n", " \"ground_edges\": 2.0, # μm, boundary of the grounded M1 frame\n", " \"dielectric_surfaces\": 3.0, # μm, substrate and vacuum interfaces\n", " \"dielectric_volumes\": 8.0, # μm, substrate and vacuum bulk\n", "}\n", "\n", "\n", "def mesh_parameters_for_factor(mesh_factor: float) -> dict[str, Any]:\n", " \"\"\"Mesh parameters with every base length scaled by ``mesh_factor``.\n", "\n", " Args:\n", " mesh_factor: Multiplier applied to all mesh lengths. ``1.0`` is the nominal\n", " mesh, smaller values refine it.\n", "\n", " Returns:\n", " Keyword arguments for :func:`meshwell.mesh.mesh`.\n", "\n", " Raises:\n", " ValueError: If ``mesh_factor`` is not positive.\n", " \"\"\"\n", " if not mesh_factor > 0:\n", " raise ValueError(f\"mesh_factor must be positive, got {mesh_factor}\")\n", "\n", " scaled = {\n", " name: length * mesh_factor for name, length in BASE_MESH_LENGTHS_UM.items()\n", " }\n", " resolution_specs: dict[str, list[ConstantInField]] = {}\n", " for terminal in (\"M1@o1\", \"M1@o2\"):\n", " resolution_specs[terminal] = [\n", " ConstantInField(resolution=scaled[\"terminal\"], apply_to=\"curves\"),\n", " ConstantInField(resolution=scaled[\"terminal\"], apply_to=\"surfaces\"),\n", " ]\n", " resolution_specs[\"M1\"] = [\n", " ConstantInField(resolution=scaled[\"ground_edges\"], apply_to=\"curves\")\n", " ]\n", " for dielectric in (\"Substrate\", \"Vacuum\"):\n", " resolution_specs[dielectric] = [\n", " ConstantInField(\n", " resolution=scaled[\"dielectric_surfaces\"], apply_to=\"surfaces\"\n", " ),\n", " ConstantInField(\n", " resolution=scaled[\"dielectric_volumes\"], apply_to=\"volumes\"\n", " ),\n", " ]\n", " return {\n", " \"default_characteristic_length\": scaled[\"default\"],\n", " \"resolution_specs\": resolution_specs,\n", " \"background_tag\": \"Vacuum\",\n", " }\n", "\n", "\n", "nominal_mesh = mesh_parameters_for_factor(1.0)\n", "print(\n", " f\"Nominal default characteristic length: \"\n", " f\"{nominal_mesh['default_characteristic_length']:.2f} µm\"\n", ")\n", "for prism, specs in nominal_mesh[\"resolution_specs\"].items():\n", " sizes = \", \".join(f\"{spec.resolution:.2f} µm ({spec.apply_to})\" for spec in specs)\n", " print(f\" {prism:>10}: {sizes}\")" ] }, { "cell_type": "markdown", "id": "33bc48eb", "metadata": {}, "source": [ "## Solve at Each Mesh Factor\n", "\n", "Every solve below uses the same component, layer stack, materials and domain; only the\n", "mesh factor changes. The run profile controls these settings:\n", "\n", "- Finite element order is the polynomial degree of the basis used to approximate the\n", " potential within an element; see [MFEM's basis-function reference](https://mfem.org/basis-functions/).\n", " The saved study uses cubic (`element_order=3`) functions. CI uses one coarse\n", " first-order (`element_order=1`) solve to validate the pipeline, not to report a\n", " converged capacitance.\n", "- `QPDK_ELMER_PROCESSES` selects MPI ranks for the default profile (1 by default).\n", " CI runs serially.\n", "- The default profile raises the linear-iteration cap to 3500: the cubic basis needs more\n", " iterations per solve than the driver's default of 500, which CI keeps.\n", "\n", "`solve_idc` runs one solve into a fresh scratch directory and returns the reduced\n", "Maxwell matrix in fF. Each comb carries a port; the separate unported M1 frame is\n", "fixed at zero potential." ] }, { "cell_type": "code", "execution_count": 8, "id": "81990633", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Elmer notebook run mode: high accuracy (element_order=3, tolerance=0.5 %, n_processes=32)\n" ] } ], "source": [ "IS_CI = (\n", " os.environ.get(\"GITHUB_ACTIONS\") == \"true\"\n", " or os.environ.get(\"QPDK_ELMER_CI_FAST\") == \"1\"\n", ")\n", "RUN_MODE = \"CI smoke\" if IS_CI else \"high accuracy\"\n", "MESH_FACTORS = (1.5,) if IS_CI else (0.5, 0.4, 0.35, 0.3, 0.25)\n", "ELEMENT_ORDER = 1 if IS_CI else 3\n", "CONVERGENCE_TOLERANCE = 0.005\n", "MAX_LINEAR_ITERATIONS = 500 if IS_CI else 3500\n", "N_PROCESSES = 1 if IS_CI else int(os.environ.get(\"QPDK_ELMER_PROCESSES\", \"1\"))\n", "\n", "if IS_CI:\n", " print(\n", " f\"Elmer notebook run mode: {RUN_MODE} \"\n", " f\"(element_order={ELEMENT_ORDER}, mesh factor {MESH_FACTORS[0]:g}, \"\n", " f\"n_processes={N_PROCESSES})\"\n", " )\n", "else:\n", " print(\n", " f\"Elmer notebook run mode: {RUN_MODE} \"\n", " f\"(element_order={ELEMENT_ORDER}, \"\n", " f\"tolerance={100 * CONVERGENCE_TOLERANCE:.1f} %, \"\n", " f\"n_processes={N_PROCESSES})\"\n", " )\n", "\n", "\n", "@dataclass(slots=True, frozen=True)\n", "class MeshSolve:\n", " \"\"\"One independently remeshed electrostatic solve.\"\"\"\n", "\n", " label: str\n", " mesh_factor: float\n", " capacitance_ff: np.ndarray\n", " mutual_ff: float\n", "\n", " @property\n", " def ground_ff(self) -> np.ndarray:\n", " \"\"\"Capacitance from each terminal to the grounded M1 frame in fF.\"\"\"\n", " return self.capacitance_ff.sum(axis=1)\n", "\n", "\n", "def solve_idc(component: gf.Component, mesh_factor: float, label: str) -> MeshSolve:\n", " \"\"\"Solve the capacitor on a mesh scaled by ``mesh_factor``.\n", "\n", " Args:\n", " component: Two-terminal IDC with an unported ground and `SIM_AREA` outline.\n", " mesh_factor: Multiplier on every base mesh length; smaller is finer.\n", " label: Name for this solve, used in tables and error messages.\n", "\n", " Returns:\n", " The reduced Maxwell matrix in fF, mutual coupling, and ground coupling.\n", "\n", " Raises:\n", " ValueError: If the component ports are not named ``o1`` and ``o2``.\n", " \"\"\"\n", " simulation_folder = Path(\n", " tempfile.mkdtemp(prefix=\"qpdk_elmer_interdigital_capacitor_\")\n", " )\n", " print(f\"{label}: solving\")\n", " results = run_capacitive_simulation_elmer(\n", " component,\n", " element_order=ELEMENT_ORDER,\n", " n_processes=N_PROCESSES,\n", " layer_stack=layer_stack,\n", " material_spec=material_spec,\n", " simulation_folder=simulation_folder,\n", " mesh_parameters=mesh_parameters_for_factor(mesh_factor),\n", " simulator_params={\"linear_system_max_iterations\": MAX_LINEAR_ITERATIONS},\n", " )\n", "\n", " terminals = tuple(port.name for port in component.ports)\n", " if terminals != (\"o1\", \"o2\"):\n", " raise ValueError(f\"{label}: unexpected terminals {terminals}\")\n", " capacitance_ff = (\n", " np.array([\n", " [results.capacitance_matrix[i, j] for j in terminals] for i in terminals\n", " ])\n", " * 1e15\n", " ) # F -> fF\n", " return MeshSolve(\n", " label=label,\n", " mesh_factor=mesh_factor,\n", " capacitance_ff=capacitance_ff,\n", " mutual_ff=-float(capacitance_ff[0, 1]),\n", " )" ] }, { "cell_type": "code", "execution_count": 9, "id": "9a0928ad", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mesh factor 0.5: solving\n", "MAIN: *** Elmer Solver: ALL DONE ***\n", "mesh factor 0.4: solving\n", "MAIN: *** Elmer Solver: ALL DONE ***\n", "mesh factor 0.35: solving\n", "MAIN: *** Elmer Solver: ALL DONE ***\n", "mesh factor 0.3: solving\n", "MAIN: *** Elmer Solver: ALL DONE ***\n", "mesh factor 0.25: solving\n", "MAIN: *** Elmer Solver: ALL DONE ***\n" ] } ], "source": [ "mesh_results = [\n", " solve_idc(component, factor, f\"mesh factor {factor:g}\") for factor in MESH_FACTORS\n", "]" ] }, { "cell_type": "markdown", "id": "1b8c4470", "metadata": {}, "source": [ "## Capacitance Matrix\n", "\n", "The reduced Maxwell matrix is assembled in port order, so its rows and columns\n", "are `o1` and `o2` while the unported ground is held at zero. The final values\n", "come from the finest mesh, the last element of `mesh_results`." ] }, { "cell_type": "code", "execution_count": 10, "id": "004551e0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final Maxwell capacitance matrix (fF):\n", "[[10.8269732 -5.70786783]\n", " [-5.70786783 10.82559906]]\n", "\n", "Capacitance matrix indexed by ('o1', 'o2')\n" ] } ], "source": [ "finest = mesh_results[-1]\n", "terminals = tuple(port.name for port in component.ports)\n", "\n", "print(\"Final Maxwell capacitance matrix (fF):\")\n", "print(finest.capacitance_ff)\n", "print(f\"\\nCapacitance matrix indexed by {terminals}\")" ] }, { "cell_type": "markdown", "id": "1949eff2", "metadata": {}, "source": [ "The off-diagonal entry gives mutual coupling as $-C_{12}$. The diagonal entries\n", "include coupling to both the other terminal and ground. Their row sums give the\n", "separate ground capacitances $C_{1\\text{g}}$ and $C_{2\\text{g}}$." ] }, { "cell_type": "code", "execution_count": 11, "id": "b0410dcb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final off-diagonal C12: -5.708 fF\n", "Final mutual capacitance C12_mutual = -C12: 5.708 fF\n", "Final terminal o1 to ground: 5.119 fF\n", "Final terminal o2 to ground: 5.118 fF\n", "Final reported mutual capacitance: 5.708 fF (element_order=3, mesh factor 0.25)\n" ] } ], "source": [ "print(f\"Final off-diagonal C12: {finest.capacitance_ff[0, 1]:.3f} fF\")\n", "print(f\"Final mutual capacitance C12_mutual = -C12: {finest.mutual_ff:.3f} fF\")\n", "print(f\"Final terminal o1 to ground: {finest.ground_ff[0]:.3f} fF\")\n", "print(f\"Final terminal o2 to ground: {finest.ground_ff[1]:.3f} fF\")\n", "value_label = (\n", " \"CI smoke mutual capacitance\" if IS_CI else \"Final reported mutual capacitance\"\n", ")\n", "print(\n", " f\"{value_label}: {finest.mutual_ff:.3f} fF \"\n", " f\"(element_order={ELEMENT_ORDER}, mesh factor {finest.mesh_factor:g})\"\n", ")" ] }, { "cell_type": "markdown", "id": "d9e0b545", "metadata": {}, "source": [ "## Mesh Convergence\n", "\n", "The five saved solves are **independent remeshes**, not Elmer nonlinear iteration\n", "counts: their factors are 0.5, 0.4, 0.35, 0.3 and 0.25. Nothing is continued from\n", "one solve to the next, and no field solution is reused, so the pass number is only\n", "an index into the refinement sequence. CI runs one coarse solve and skips this study.\n", "\n", "The upper panel shows mutual and terminal-to-ground capacitances. The lower panel\n", "shows the largest relative change among those three quantities from the previous\n", "pass. The last two changes must stay below `CONVERGENCE_TOLERANCE` (0.5 % in the\n", "saved run). This is a refinement check, not an absolute error bound; independent\n", "remeshes need not change the result monotonically." ] }, { "cell_type": "code", "execution_count": 12, "id": "24d6e4ad", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", " \n", " \n", " \n", " \n", " 2026-09-26T15:23:48.443780\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.11.1, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "pass factor mutual_fF o1-ground_fF o2-ground_fF max_change_pct\n", " 1 0.5 5.809 5.140 5.140 n/a\n", " 2 0.4 5.770 5.131 5.131 0.672\n", " 3 0.35 5.749 5.126 5.126 0.376\n", " 4 0.3 5.730 5.122 5.122 0.321\n", " 5 0.25 5.708 5.119 5.118 0.390\n", "Mesh convergence check passed: final changes 0.321 % and 0.390 % <= tolerance 0.5 %\n" ] } ], "source": [ "if IS_CI:\n", " print(\"CI smoke profile: mesh convergence is checked by the saved study\")\n", "else:\n", " passes = np.arange(1, len(mesh_results) + 1)\n", " capacitances_ff = np.array([\n", " [result.mutual_ff, *result.ground_ff] for result in mesh_results\n", " ])\n", " relative_change = np.full_like(capacitances_ff, np.nan)\n", " relative_change[1:] = (\n", " np.abs(np.diff(capacitances_ff, axis=0)) / capacitances_ff[:-1]\n", " )\n", " max_change = np.max(relative_change[1:], axis=1)\n", "\n", " _, (ax_value, ax_change) = plt.subplots(\n", " 2, 1, sharex=True, figsize=(6.0, 5.0), layout=\"constrained\"\n", " )\n", " for column, label, marker in zip(\n", " range(3),\n", " (\"o1–o2 mutual\", \"o1–ground\", \"o2–ground\"),\n", " (\"o\", \"s\", \"^\"),\n", " strict=True,\n", " ):\n", " ax_value.plot(passes, capacitances_ff[:, column], marker=marker, label=label)\n", " ax_value.set_ylabel(\"Capacitance (fF)\")\n", " ax_value.legend()\n", "\n", " ax_change.plot(passes[1:], 100 * max_change, marker=\"s\", linestyle=\"--\")\n", " ax_change.axhline(\n", " 100 * CONVERGENCE_TOLERANCE,\n", " color=\"tab:red\",\n", " linestyle=\":\",\n", " label=f\"tolerance {100 * CONVERGENCE_TOLERANCE:.1f} %\",\n", " )\n", " ax_change.set_xticks(passes)\n", " ax_change.set_xlabel(\"Pass number (independently remeshed solve)\")\n", " ax_change.set_ylabel(\"Largest change from\\nprevious pass (%)\")\n", " ax_change.legend()\n", " plt.show()\n", "\n", " print(\n", " f\"{'pass':>4} {'factor':>7} {'mutual_fF':>10} \"\n", " f\"{'o1-ground_fF':>12} {'o2-ground_fF':>12} {'max_change_pct':>14}\"\n", " )\n", " for index, result in enumerate(mesh_results, start=1):\n", " change_text = \"n/a\" if index == 1 else f\"{100 * max_change[index - 2]:.3f}\"\n", " print(\n", " f\"{index:>4} {result.mesh_factor:>7g} {result.mutual_ff:>10.3f} \"\n", " f\"{result.ground_ff[0]:>12.3f} {result.ground_ff[1]:>12.3f} \"\n", " f\"{change_text:>14}\"\n", " )\n", "\n", " final_changes = max_change[-2:]\n", " if not (final_changes <= CONVERGENCE_TOLERANCE).all():\n", " raise ValueError(\n", " f\"the last two mesh refinements changed a capacitance by \"\n", " f\"{100 * final_changes[0]:.3f} % and {100 * final_changes[1]:.3f} %, \"\n", " f\"above CONVERGENCE_TOLERANCE = \"\n", " f\"{100 * CONVERGENCE_TOLERANCE:.1f} %; refine the mesh further\"\n", " )\n", " print(\n", " f\"Mesh convergence check passed: final changes \"\n", " f\"{100 * final_changes[0]:.3f} % and {100 * final_changes[1]:.3f} % \"\n", " f\"<= tolerance {100 * CONVERGENCE_TOLERANCE:.1f} %\"\n", " )" ] }, { "cell_type": "markdown", "id": "0cd1a4a4", "metadata": {}, "source": [ "## Lateral Domain Sensitivity\n", "\n", "CI skips this comparison; the saved cubic study includes it.\n", "\n", "Mesh convergence above holds the domain fixed at `domain_pad=90.0` μm. This separate\n", "check asks how much the three reported capacitances depend on the outer boundary:\n", "we rebuild the same capacitor with a 60 μm lateral pad, keep the ground frame,\n", "element order, and finest mesh factor fixed, and compare against the pad-90 μm\n", "result from the final pass.\n", "\n", "Changing the pad also changes the mesh, so the difference mixes the domain effect with\n", "a discretization effect. This is a sensitivity check between two finite domains: it is\n", "**not** a proof that the 90 μm boundary is converged to an infinite domain, and it says\n", "nothing about vertical truncation or absolute accuracy." ] }, { "cell_type": "code", "execution_count": 13, "id": "240a53d0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pad 60 μm, finest mesh: solving\n", "MAIN: *** Elmer Solver: ALL DONE ***\n", "mutual: pad 60 = 5.714 fF, pad 90 = 5.708 fF, change = 0.11%\n", "o1–ground: pad 60 = 5.113 fF, pad 90 = 5.119 fF, change = 0.12%\n", "o2–ground: pad 60 = 5.114 fF, pad 90 = 5.118 fF, change = 0.08%\n", "Lateral-domain sensitivity check passed: change <= 1 %\n" ] } ], "source": [ "narrow: MeshSolve | None = None\n", "if IS_CI:\n", " print(\"CI smoke profile: lateral-domain sensitivity is checked by the saved study\")\n", "else:\n", " component_narrow = interdigital_capacitor_for_elmer(domain_pad=60.0)\n", " narrow = solve_idc(component_narrow, finest.mesh_factor, \"pad 60 μm, finest mesh\")\n", " wide = finest\n", "\n", " quantities = (\"mutual\", \"o1–ground\", \"o2–ground\")\n", " narrow_values = np.array([narrow.mutual_ff, *narrow.ground_ff])\n", " wide_values = np.array([wide.mutual_ff, *wide.ground_ff])\n", " domain_change = np.abs(wide_values - narrow_values) / narrow_values\n", " for label, small, large, change in zip(\n", " quantities, narrow_values, wide_values, domain_change, strict=True\n", " ):\n", " print(\n", " f\"{label}: pad 60 = {small:.3f} fF, pad 90 = {large:.3f} fF, change = {change:.2%}\"\n", " )\n", " if domain_change.max() > 0.01:\n", " raise ValueError(\n", " f\"lateral-pad check changed capacitance by {domain_change.max():.2%}\"\n", " )\n", " print(\"Lateral-domain sensitivity check passed: change <= 1 %\")" ] }, { "cell_type": "markdown", "id": "19e2e17e", "metadata": {}, "source": [ "## Sanity Checks\n", "\n", "Every solve must give a finite, symmetric Maxwell matrix with a positive diagonal,\n", "negative off-diagonal, and positive row sums. Those row sums are the capacitances\n", "to the grounded M1 frame. The broad 5-40 fF mutual range is a regression guard\n", "against order-of-magnitude errors, not a claim about model accuracy." ] }, { "cell_type": "code", "execution_count": 14, "id": "68503cb2", "metadata": { "tags": [ "hide-input", "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "All checks passed.\n" ] } ], "source": [ "results_to_check = mesh_results if narrow is None else [*mesh_results, narrow]\n", "for result in results_to_check:\n", " matrix = result.capacitance_ff\n", " if not np.isfinite(matrix).all():\n", " raise ValueError(f\"{result.label}: matrix has non-finite entries\")\n", " if not np.allclose(matrix, matrix.T, rtol=1e-2, atol=1e-3):\n", " raise ValueError(f\"{result.label}: matrix is not symmetric\")\n", " if not (np.diag(matrix) > 0).all():\n", " raise ValueError(f\"{result.label}: matrix diagonal must be positive\")\n", " if matrix[0, 1] >= 0 or matrix[1, 0] >= 0:\n", " raise ValueError(f\"{result.label}: Maxwell off-diagonals must be negative\")\n", " if not 5.0 < result.mutual_ff < 40.0:\n", " raise ValueError(\n", " f\"{result.label}: mutual capacitance outside 5-40 fF: {result.mutual_ff}\"\n", " )\n", " if not (result.ground_ff > 0).all():\n", " raise ValueError(\n", " f\"{result.label}: terminal-to-ground capacitance must be positive\"\n", " )\n", "\n", "print(\"All checks passed.\")" ] }, { "cell_type": "markdown", "id": "2fdb1b06", "metadata": {}, "source": [ "## Summary\n", "\n", "The saved notebook reports the quasi-static capacitance of a grounded QPDK\n", "interdigital capacitor from the finest mesh of the high accuracy Elmer study\n", "(cubic elements, 0.5 % refinement tolerance):\n", "\n", "- Built a two-terminal geometry from `qpdk.cells.capacitor.interdigital_capacitor`,\n", " with the two `M1_DRAW` combs and a disconnected grounded M1 frame. The PDK's\n", " derived `M1` rule produces all three conductors.\n", "- Fixed the domain at a 90 μm lateral pad with a 60 μm substrate and a 40 μm vacuum,\n", " and fixed the ground frame's outer edge 45 μm from the IDC. We solved with cubic\n", " (third-order) elements on five independently generated meshes\n", " (factors 0.5, 0.4, 0.35, 0.3, 0.25).\n", "- Converted Elmer's lumped result to the reduced 2x2 Maxwell matrix, taking mutual\n", " capacitance as $-C_{12}$ and terminal-to-ground values as its row sums.\n", "- Required the two final successive changes in all three capacitances to stay below\n", " 0.5 %, and reported the finest-mesh values.\n", "- Required the 60 μm against 90 μm lateral-pad comparison at the finest mesh to change\n", " each capacitance by no more than 1 %, as a finite-domain sensitivity check.\n", "\n", "The result is a 3D FEM number only, not benchmarked against an analytic IDC model. The\n", "refinement tolerance measures change between meshes, not absolute accuracy, and the\n", "lateral-pad comparison is a sensitivity check between two finite domains, not a\n", "convergence proof for an unbounded one. Vertical truncation is not checked here.\n", "\n", "CI executes one coarse first-order solve and checks the matrix to verify that the\n", "pipeline runs end to end. It does not repeat the convergence or domain checks and\n", "does not reproduce the numbers above.\n", "\n", "The same layout can be swept or optimized by varying `fingers`, `finger_length` and\n", "`finger_gap` in `interdigital_capacitor_for_elmer` and re-running the solve." ] } ], "metadata": { "jupytext": { "main_language": "python" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.14" } }, "nbformat": 4, "nbformat_minor": 5 }