{ "cells": [ { "cell_type": "markdown", "id": "3f7a1912", "metadata": {}, "source": [ "# 1.4 Saving Your Chip Design\n", "\n", "By the end of this tutorial you will know how to:\n", "\n", "1. **Export a design to a Python script** with ``to_python_script()`` โ€” for reproducibility, version control, and CI replay.\n", "2. **Export to GDS** for fabrication, and visually inspect the result.\n", "\n", "We start from the full 2-qubit chip built in [tutorial 1.2](./1.1-Quick-start.ipynb). The block below is exactly what ``design.to_python_script()`` produces โ€” a self-contained Python definition you can version-control, share, and replay." ] }, { "cell_type": "markdown", "id": "871a5ed8", "metadata": {}, "source": [ "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/qiskit-community/qiskit-metal/blob/main/tutorials/1%20Overview/1.4%20Saving%20Your%20Chip%20Design.ipynb)\n", "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/qiskit-community/qiskit-metal/main?labpath=tutorials%2F1%20Overview%2F1.4%20Saving%20Your%20Chip%20Design.ipynb)\n", "\n", "> ๐Ÿ’ก **Running in Colab or Binder?** Skip the desktop GUI install โ€” the cell below grabs the lite (no-Qt) wheel, and `qm.gui(design)` auto-picks an inline matplotlib viewer with the same API (`gui.rebuild()`, `gui.screenshot()`, `gui.edit_component(...)`) as the desktop `MetalGUI`." ] }, { "cell_type": "code", "execution_count": 1, "id": "5cbb6035", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:33.919912Z", "iopub.status.busy": "2026-08-09T22:26:33.919701Z", "iopub.status.idle": "2026-08-09T22:26:33.926681Z", "shell.execute_reply": "2026-08-09T22:26:33.925637Z" } }, "outputs": [], "source": [ "# In Colab / Binder, uncomment to install Quantum Metal (lite, no Qt).\n", "# Locally you should already have it via `pip install quantum-metal` or\n", "# `pip install 'quantum-metal[gui]'` for the desktop GUI.\n", "# !pip install -q quantum-metal" ] }, { "cell_type": "code", "execution_count": 2, "id": "81b3554c", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:33.929780Z", "iopub.status.busy": "2026-08-09T22:26:33.929555Z", "iopub.status.idle": "2026-08-09T22:26:36.556656Z", "shell.execute_reply": "2026-08-09T22:26:36.556265Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Design ready: 15 components\n" ] } ], "source": [ "# === Design reproduced from tutorial 1.2 via design.to_python_script() ===\n", "from qiskit_metal import designs, Dict\n", "from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL\n", "from qiskit_metal.qlibrary.tlines.pathfinder import RoutePathfinder\n", "from qiskit_metal.qlibrary.tlines.meandered import RouteMeander\n", "from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital\n", "from qiskit_metal.qlibrary.terminations.launchpad_wb import LaunchpadWirebond\n", "\n", "design = designs.DesignPlanar()\n", "design.overwrite_enabled = True\n", "\n", "Q1 = TransmonPocketCL(\n", " design,\n", " \"Q1\",\n", " options=dict(\n", " pos_x=\"0.7mm\",\n", " pos_y=\"0mm\",\n", " orientation=\"0\",\n", " pad_gap=\"30um\",\n", " inductor_width=\"20um\",\n", " pad_width=\"425 um\",\n", " pad_height=\"90um\",\n", " pocket_width=\"650um\",\n", " pocket_height=\"650um\",\n", " gds_cell_name=\"FakeJunction_01\",\n", " make_CL=True,\n", " cl_gap=\"6um\",\n", " cl_width=\"10um\",\n", " cl_length=\"20um\",\n", " cl_ground_gap=\"6um\",\n", " cl_pocket_edge=\"180\",\n", " cl_off_center=\"50um\",\n", " connection_pads=dict(\n", " readout=dict(\n", " loc_W=1,\n", " loc_H=1,\n", " pad_gap=\"15um\",\n", " pad_width=\"125um\",\n", " pad_height=\"30um\",\n", " cpw_extend=\"100um\",\n", " pocket_extent=\"5um\",\n", " pocket_rise=\"65um\",\n", " ),\n", " bus=dict(\n", " loc_W=-1,\n", " loc_H=-1,\n", " pad_gap=\"15um\",\n", " pad_width=\"125um\",\n", " pad_height=\"30um\",\n", " cpw_extend=\"100um\",\n", " pocket_extent=\"5um\",\n", " pocket_rise=\"65um\",\n", " ),\n", " ),\n", " ),\n", " make=True,\n", ")\n", "\n", "Q2 = TransmonPocketCL(\n", " design,\n", " \"Q2\",\n", " options=dict(\n", " pos_x=\"-0.7mm\",\n", " pos_y=\"0mm\",\n", " orientation=\"180\",\n", " pad_gap=\"30um\",\n", " inductor_width=\"20um\",\n", " pad_width=\"425 um\",\n", " pad_height=\"90um\",\n", " pocket_width=\"650um\",\n", " pocket_height=\"650um\",\n", " gds_cell_name=\"FakeJunction_01\",\n", " make_CL=True,\n", " cl_gap=\"6um\",\n", " cl_width=\"10um\",\n", " cl_length=\"20um\",\n", " cl_ground_gap=\"6um\",\n", " cl_pocket_edge=\"180\",\n", " cl_off_center=\"50um\",\n", " connection_pads=dict(\n", " readout=dict(\n", " loc_W=1,\n", " loc_H=1,\n", " pad_gap=\"15um\",\n", " pad_width=\"125um\",\n", " pad_height=\"30um\",\n", " cpw_extend=\"100um\",\n", " pocket_extent=\"5um\",\n", " pocket_rise=\"65um\",\n", " ),\n", " bus=dict(\n", " loc_W=-1,\n", " loc_H=-1,\n", " pad_gap=\"15um\",\n", " pad_width=\"125um\",\n", " pad_height=\"30um\",\n", " cpw_extend=\"100um\",\n", " pocket_extent=\"5um\",\n", " pocket_rise=\"65um\",\n", " ),\n", " ),\n", " ),\n", " make=True,\n", ")\n", "\n", "Bus_Q1_Q2 = RoutePathfinder(\n", " design,\n", " \"Bus_Q1_Q2\",\n", " options=dict(\n", " pin_inputs=dict(\n", " start_pin=dict(component=\"Q1\", pin=\"bus\"),\n", " end_pin=dict(component=\"Q2\", pin=\"bus\"),\n", " ),\n", " fillet=\"99um\",\n", " total_length=\"7mm\",\n", " layer=\"1\",\n", " lead=dict(start_straight=\"0mm\", end_straight=\"250um\"),\n", " advanced=dict(avoid_collision=\"true\"),\n", " step_size=\"0.25mm\",\n", " ),\n", ")\n", "\n", "Cap_Q1 = Cap3Interdigital(\n", " design,\n", " \"Cap_Q1\",\n", " options=dict(\n", " layer=\"1\",\n", " pos_x=\"2.5mm\",\n", " pos_y=\"0.25mm\",\n", " orientation=\"90\",\n", " trace_width=\"10um\",\n", " finger_length=\"40um\",\n", " ),\n", ")\n", "Cap_Q2 = Cap3Interdigital(\n", " design,\n", " \"Cap_Q2\",\n", " options=dict(\n", " layer=\"1\",\n", " pos_x=\"-2.5mm\",\n", " pos_y=\"-0.25mm\",\n", " orientation=\"-90\",\n", " trace_width=\"10um\",\n", " finger_length=\"40um\",\n", " ),\n", ")\n", "\n", "Readout_Q1 = RouteMeander(\n", " design,\n", " \"Readout_Q1\",\n", " options=dict(\n", " pin_inputs=dict(\n", " start_pin=dict(component=\"Q1\", pin=\"readout\"),\n", " end_pin=dict(component=\"Cap_Q1\", pin=\"a\"),\n", " ),\n", " fillet=\"99um\",\n", " total_length=\"5mm\",\n", " layer=\"1\",\n", " lead=dict(start_straight=\"0.325mm\", end_straight=\"125um\"),\n", " meander=dict(spacing=\"200um\", asymmetry=\"-50um\"),\n", " ),\n", ")\n", "Readout_Q2 = RouteMeander(\n", " design,\n", " \"Readout_Q2\",\n", " options=dict(\n", " pin_inputs=dict(\n", " start_pin=dict(component=\"Q2\", pin=\"readout\"),\n", " end_pin=dict(component=\"Cap_Q2\", pin=\"a\"),\n", " ),\n", " fillet=\"99um\",\n", " total_length=\"6mm\",\n", " layer=\"1\",\n", " lead=dict(start_straight=\"0.325mm\", end_straight=\"125um\"),\n", " meander=dict(spacing=\"200um\", asymmetry=\"-50um\"),\n", " ),\n", ")\n", "\n", "for name, px, py, ori in [\n", " (\"Launch_Q1_Read\", \"3.5mm\", \"0um\", \"180\"),\n", " (\"Launch_Q2_Read\", \"-3.5mm\", \"0um\", \"0\"),\n", " (\"Launch_Q1_CL\", \"1.35mm\", \"-2.5mm\", \"90\"),\n", " (\"Launch_Q2_CL\", \"-1.35mm\", \"2.5mm\", \"-90\"),\n", "]:\n", " LaunchpadWirebond(\n", " design,\n", " name,\n", " options=dict(\n", " layer=\"1\",\n", " pos_x=px,\n", " pos_y=py,\n", " orientation=ori,\n", " trace_width=\"cpw_width\",\n", " trace_gap=\"cpw_gap\",\n", " lead_length=\"25um\",\n", " ),\n", " )\n", "\n", "for name, src_comp, src_pin, dst_comp, dst_pin, length in [\n", " (\"TL_Q1\", \"Launch_Q1_Read\", \"tie\", \"Cap_Q1\", \"b\", \"7mm\"),\n", " (\"TL_Q2\", \"Launch_Q2_Read\", \"tie\", \"Cap_Q2\", \"b\", \"7mm\"),\n", " (\"TL_Q1_CL\", \"Launch_Q1_CL\", \"tie\", \"Q1\", \"Charge_Line\", \"7mm\"),\n", " (\"TL_Q2_CL\", \"Launch_Q2_CL\", \"tie\", \"Q2\", \"Charge_Line\", \"7mm\"),\n", "]:\n", " RoutePathfinder(\n", " design,\n", " name,\n", " options=dict(\n", " pin_inputs=dict(\n", " start_pin=dict(component=src_comp, pin=src_pin),\n", " end_pin=dict(component=dst_comp, pin=dst_pin),\n", " ),\n", " fillet=\"99um\",\n", " total_length=length,\n", " layer=\"1\",\n", " lead=dict(start_straight=\"0mm\", end_straight=\"150um\"),\n", " advanced=dict(avoid_collision=\"true\"),\n", " step_size=\"0.25mm\",\n", " ),\n", " )\n", "\n", "print(f\"Design ready: {len(design.components)} components\")" ] }, { "cell_type": "code", "execution_count": 3, "id": "d5d9da7f", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:36.559195Z", "iopub.status.busy": "2026-08-09T22:26:36.559096Z", "iopub.status.idle": "2026-08-09T22:26:36.560976Z", "shell.execute_reply": "2026-08-09T22:26:36.560598Z" } }, "outputs": [], "source": [ "import qiskit_metal as qm\n", "\n", "# On local desktop, qm.gui(design) opens the interactive MetalGUI so you\n", "# can inspect/edit this design as you work through the rest of the\n", "# notebook -- everything below also works with just qm.view(design) if\n", "# you'd rather stay headless (e.g. Colab/Binder, or no display).\n", "gui = qm.gui(design)\n", "\n", "if hasattr(gui, \"load_stylesheet\"):\n", " gui.load_stylesheet(\"metal_dark\")" ] }, { "cell_type": "code", "execution_count": 4, "id": "8cee3ab3", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:36.562134Z", "iopub.status.busy": "2026-08-09T22:26:36.562060Z", "iopub.status.idle": "2026-08-09T22:26:36.795073Z", "shell.execute_reply": "2026-08-09T22:26:36.793904Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "import qiskit_metal as qm\n", "\n", "fig_full = qm.view(design, figsize=(9, 9), title=\"Full 2-qubit chip\")\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(13, 6))\n", "qm.view(design, components=[\"Q1\"], title=\"Q1 โ€” FakeJunction_01\", ax=axes[0])\n", "qm.view(design, components=[\"Q2\"], title=\"Q2 โ€” FakeJunction_01\", ax=axes[1])\n", "plt.tight_layout()\n", "plt.close(fig)\n", "\n", "display(fig_full)\n", "display(fig)" ] }, { "cell_type": "code", "execution_count": 5, "id": "760009da", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:36.801579Z", "iopub.status.busy": "2026-08-09T22:26:36.801313Z", "iopub.status.idle": "2026-08-09T22:26:36.832283Z", "shell.execute_reply": "2026-08-09T22:26:36.829390Z" } }, "outputs": [ { "data": { "text/plain": [ "'\\nfrom qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL\\n\\nfrom qiskit_metal.qlibrary.tlines.meandered import RouteMeander\\n\\nfrom qiskit_metal.qlibrary.tlines.pathfinder import RoutePathfinder\\n\\nfrom qiskit_metal.qlibrary.terminations.launchpad_wb import LaunchpadWirebond\\n\\nfrom qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital\\n\\nimport qiskit_metal\\nfrom qiskit_metal import designs, MetalGUI\\n\\ndesign = designs.DesignPlanar()\\n\\ngui = MetalGUI(design)\\n\\n\\n\\n # WARNING\\n#options_connection_pads failed to have a value\\nQ1 = TransmonPocketCL(\\ndesign,\\nname=\\'Q1\\',\\noptions={\\'cl_pocket_edge\\': \\'180\\',\\n \\'connection_pads\\': {\\'bus\\': {\\'cpw_extend\\': \\'100um\\',\\n \\'cpw_gap\\': \\'cpw_gap\\',\\n \\'cpw_width\\': \\'cpw_width\\',\\n \\'loc_H\\': -1,\\n \\'loc_W\\': -1,\\n \\'pad_cpw_extent\\': \\'25um\\',\\n \\'pad_cpw_shift\\': \\'5um\\',\\n \\'pad_gap\\': \\'15um\\',\\n \\'pad_height\\': \\'30um\\',\\n \\'pad_width\\': \\'125um\\',\\n \\'pocket_extent\\': \\'5um\\',\\n \\'pocket_rise\\': \\'65um\\'},\\n \\'readout\\': {\\'cpw_extend\\': \\'100um\\',\\n \\'cpw_gap\\': \\'cpw_gap\\',\\n \\'cpw_width\\': \\'cpw_width\\',\\n \\'loc_H\\': 1,\\n \\'loc_W\\': 1,\\n \\'pad_cpw_extent\\': \\'25um\\',\\n \\'pad_cpw_shift\\': \\'5um\\',\\n \\'pad_gap\\': \\'15um\\',\\n \\'pad_height\\': \\'30um\\',\\n \\'pad_width\\': \\'125um\\',\\n \\'pocket_extent\\': \\'5um\\',\\n \\'pocket_rise\\': \\'65um\\'}},\\n \\'gds_cell_name\\': \\'FakeJunction_01\\',\\n \\'orientation\\': \\'0\\',\\n \\'pad_width\\': \\'425 um\\',\\n \\'pos_x\\': \\'0.7mm\\',\\n \\'pos_y\\': \\'0mm\\'}\\n)\\n\\n\\n\\n\\n\\n # WARNING\\n#options_connection_pads failed to have a value\\nQ2 = TransmonPocketCL(\\ndesign,\\nname=\\'Q2\\',\\noptions={\\'cl_pocket_edge\\': \\'180\\',\\n \\'connection_pads\\': {\\'bus\\': {\\'cpw_extend\\': \\'100um\\',\\n \\'cpw_gap\\': \\'cpw_gap\\',\\n \\'cpw_width\\': \\'cpw_width\\',\\n \\'loc_H\\': -1,\\n \\'loc_W\\': -1,\\n \\'pad_cpw_extent\\': \\'25um\\',\\n \\'pad_cpw_shift\\': \\'5um\\',\\n \\'pad_gap\\': \\'15um\\',\\n \\'pad_height\\': \\'30um\\',\\n \\'pad_width\\': \\'125um\\',\\n \\'pocket_extent\\': \\'5um\\',\\n \\'pocket_rise\\': \\'65um\\'},\\n \\'readout\\': {\\'cpw_extend\\': \\'100um\\',\\n \\'cpw_gap\\': \\'cpw_gap\\',\\n \\'cpw_width\\': \\'cpw_width\\',\\n \\'loc_H\\': 1,\\n \\'loc_W\\': 1,\\n \\'pad_cpw_extent\\': \\'25um\\',\\n \\'pad_cpw_shift\\': \\'5um\\',\\n \\'pad_gap\\': \\'15um\\',\\n \\'pad_height\\': \\'30um\\',\\n \\'pad_width\\': \\'125um\\',\\n \\'pocket_extent\\': \\'5um\\',\\n \\'pocket_rise\\': \\'65um\\'}},\\n \\'gds_cell_name\\': \\'FakeJunction_01\\',\\n \\'orientation\\': \\'180\\',\\n \\'pad_width\\': \\'425 um\\',\\n \\'pos_x\\': \\'-0.7mm\\',\\n \\'pos_y\\': \\'0mm\\'}\\n)\\n\\n\\n\\n\\nBus_Q1_Q2 = RoutePathfinder(\\ndesign,\\nname=\\'Bus_Q1_Q2\\',\\noptions={\\'_actual_length\\': \\'0.8550176727053895 \\'\\n \\'mm\\',\\n \\'fillet\\': \\'99um\\',\\n \\'lead\\': {\\'end_jogged_extension\\': \\'\\',\\n \\'end_straight\\': \\'250um\\',\\n \\'start_jogged_extension\\': \\'\\',\\n \\'start_straight\\': \\'0mm\\'},\\n \\'pin_inputs\\': {\\'end_pin\\': {\\'component\\': \\'Q2\\',\\n \\'pin\\': \\'bus\\'},\\n \\'start_pin\\': {\\'component\\': \\'Q1\\',\\n \\'pin\\': \\'bus\\'}},\\n \\'trace_gap\\': \\'cpw_gap\\'},\\n\\ntype=\\'CPW\\',\\n)\\n\\n\\n\\n\\nCap_Q1 = Cap3Interdigital(\\ndesign,\\nname=\\'Cap_Q1\\',\\noptions={\\'finger_length\\': \\'40um\\',\\n \\'orientation\\': \\'90\\',\\n \\'pos_x\\': \\'2.5mm\\',\\n \\'pos_y\\': \\'0.25mm\\'},\\n\\ncomponent_template=None,\\n)\\n\\n\\n\\n\\nCap_Q2 = Cap3Interdigital(\\ndesign,\\nname=\\'Cap_Q2\\',\\noptions={\\'finger_length\\': \\'40um\\',\\n \\'orientation\\': \\'-90\\',\\n \\'pos_x\\': \\'-2.5mm\\',\\n \\'pos_y\\': \\'-0.25mm\\'},\\n\\ncomponent_template=None,\\n)\\n\\n\\n\\n\\nReadout_Q1 = RouteMeander(\\ndesign,\\nname=\\'Readout_Q1\\',\\noptions={\\'_actual_length\\': \\'5.000000000000001 \\'\\n \\'mm\\',\\n \\'fillet\\': \\'99um\\',\\n \\'lead\\': {\\'end_jogged_extension\\': \\'\\',\\n \\'end_straight\\': \\'125um\\',\\n \\'start_jogged_extension\\': \\'\\',\\n \\'start_straight\\': \\'0.325mm\\'},\\n \\'meander\\': {\\'asymmetry\\': \\'-50um\\',\\n \\'spacing\\': \\'200um\\'},\\n \\'pin_inputs\\': {\\'end_pin\\': {\\'component\\': \\'Cap_Q1\\',\\n \\'pin\\': \\'a\\'},\\n \\'start_pin\\': {\\'component\\': \\'Q1\\',\\n \\'pin\\': \\'readout\\'}},\\n \\'total_length\\': \\'5mm\\',\\n \\'trace_gap\\': \\'cpw_gap\\'},\\n\\ntype=\\'CPW\\',\\n)\\n\\n\\n\\n\\nReadout_Q2 = RouteMeander(\\ndesign,\\nname=\\'Readout_Q2\\',\\noptions={\\'_actual_length\\': \\'5.999999999999999 \\'\\n \\'mm\\',\\n \\'fillet\\': \\'99um\\',\\n \\'lead\\': {\\'end_jogged_extension\\': \\'\\',\\n \\'end_straight\\': \\'125um\\',\\n \\'start_jogged_extension\\': \\'\\',\\n \\'start_straight\\': \\'0.325mm\\'},\\n \\'meander\\': {\\'asymmetry\\': \\'-50um\\',\\n \\'spacing\\': \\'200um\\'},\\n \\'pin_inputs\\': {\\'end_pin\\': {\\'component\\': \\'Cap_Q2\\',\\n \\'pin\\': \\'a\\'},\\n \\'start_pin\\': {\\'component\\': \\'Q2\\',\\n \\'pin\\': \\'readout\\'}},\\n \\'total_length\\': \\'6mm\\',\\n \\'trace_gap\\': \\'cpw_gap\\'},\\n\\ntype=\\'CPW\\',\\n)\\n\\n\\n\\n\\nLaunch_Q1_Read = LaunchpadWirebond(\\ndesign,\\nname=\\'Launch_Q1_Read\\',\\noptions={\\'orientation\\': \\'180\\',\\n \\'pos_x\\': \\'3.5mm\\',\\n \\'pos_y\\': \\'0um\\'},\\n\\ncomponent_template=None,\\n)\\n\\n\\n\\n\\nLaunch_Q2_Read = LaunchpadWirebond(\\ndesign,\\nname=\\'Launch_Q2_Read\\',\\noptions={\\'orientation\\': \\'0\\',\\n \\'pos_x\\': \\'-3.5mm\\',\\n \\'pos_y\\': \\'0um\\'},\\n\\ncomponent_template=None,\\n)\\n\\n\\n\\n\\nLaunch_Q1_CL = LaunchpadWirebond(\\ndesign,\\nname=\\'Launch_Q1_CL\\',\\noptions={\\'orientation\\': \\'90\\',\\n \\'pos_x\\': \\'1.35mm\\',\\n \\'pos_y\\': \\'-2.5mm\\'},\\n\\ncomponent_template=None,\\n)\\n\\n\\n\\n\\nLaunch_Q2_CL = LaunchpadWirebond(\\ndesign,\\nname=\\'Launch_Q2_CL\\',\\noptions={\\'orientation\\': \\'-90\\',\\n \\'pos_x\\': \\'-1.35mm\\',\\n \\'pos_y\\': \\'2.5mm\\'},\\n\\ncomponent_template=None,\\n)\\n\\n\\n\\n\\nTL_Q1 = RoutePathfinder(\\ndesign,\\nname=\\'TL_Q1\\',\\noptions={\\'_actual_length\\': \\'1.0750176727053897 \\'\\n \\'mm\\',\\n \\'fillet\\': \\'99um\\',\\n \\'lead\\': {\\'end_jogged_extension\\': \\'\\',\\n \\'end_straight\\': \\'150um\\',\\n \\'start_jogged_extension\\': \\'\\',\\n \\'start_straight\\': \\'0mm\\'},\\n \\'pin_inputs\\': {\\'end_pin\\': {\\'component\\': \\'Cap_Q1\\',\\n \\'pin\\': \\'b\\'},\\n \\'start_pin\\': {\\'component\\': \\'Launch_Q1_Read\\',\\n \\'pin\\': \\'tie\\'}},\\n \\'trace_gap\\': \\'cpw_gap\\'},\\n\\ntype=\\'CPW\\',\\n)\\n\\n\\n\\n\\nTL_Q2 = RoutePathfinder(\\ndesign,\\nname=\\'TL_Q2\\',\\noptions={\\'_actual_length\\': \\'1.0750176727053897 \\'\\n \\'mm\\',\\n \\'fillet\\': \\'99um\\',\\n \\'lead\\': {\\'end_jogged_extension\\': \\'\\',\\n \\'end_straight\\': \\'150um\\',\\n \\'start_jogged_extension\\': \\'\\',\\n \\'start_straight\\': \\'0mm\\'},\\n \\'pin_inputs\\': {\\'end_pin\\': {\\'component\\': \\'Cap_Q2\\',\\n \\'pin\\': \\'b\\'},\\n \\'start_pin\\': {\\'component\\': \\'Launch_Q2_Read\\',\\n \\'pin\\': \\'tie\\'}},\\n \\'trace_gap\\': \\'cpw_gap\\'},\\n\\ntype=\\'CPW\\',\\n)\\n\\n\\n\\n\\nTL_Q1_CL = RoutePathfinder(\\ndesign,\\nname=\\'TL_Q1_CL\\',\\noptions={\\'_actual_length\\': \\'2.610508836352695 \\'\\n \\'mm\\',\\n \\'fillet\\': \\'99um\\',\\n \\'lead\\': {\\'end_jogged_extension\\': \\'\\',\\n \\'end_straight\\': \\'150um\\',\\n \\'start_jogged_extension\\': \\'\\',\\n \\'start_straight\\': \\'0mm\\'},\\n \\'pin_inputs\\': {\\'end_pin\\': {\\'component\\': \\'Q1\\',\\n \\'pin\\': \\'Charge_Line\\'},\\n \\'start_pin\\': {\\'component\\': \\'Launch_Q1_CL\\',\\n \\'pin\\': \\'tie\\'}},\\n \\'trace_gap\\': \\'cpw_gap\\'},\\n\\ntype=\\'CPW\\',\\n)\\n\\n\\n\\n\\nTL_Q2_CL = RoutePathfinder(\\ndesign,\\nname=\\'TL_Q2_CL\\',\\noptions={\\'_actual_length\\': \\'2.610508836352695 \\'\\n \\'mm\\',\\n \\'fillet\\': \\'99um\\',\\n \\'lead\\': {\\'end_jogged_extension\\': \\'\\',\\n \\'end_straight\\': \\'150um\\',\\n \\'start_jogged_extension\\': \\'\\',\\n \\'start_straight\\': \\'0mm\\'},\\n \\'pin_inputs\\': {\\'end_pin\\': {\\'component\\': \\'Q2\\',\\n \\'pin\\': \\'Charge_Line\\'},\\n \\'start_pin\\': {\\'component\\': \\'Launch_Q2_CL\\',\\n \\'pin\\': \\'tie\\'}},\\n \\'trace_gap\\': \\'cpw_gap\\'},\\n\\ntype=\\'CPW\\',\\n)\\n\\n\\n\\ngui.rebuild()\\ngui.autoscale()\\n\\n# Keep the MetalGUI window open when this file is run as a standalone script\\n# (``python my_chip_design.py``). Without an event loop the process exits\\n# immediately and the window disappears.\\n#\\n# Guarded on __main__ so that importing this file -- or executing it inside a\\n# session that already runs a Qt loop (Jupyter/IPython with ``%gui qt``) --\\n# does not block the caller. ``gui.qApp`` may be None if no QApplication could\\n# be created (e.g. a headless machine), so check before calling into it.\\nif __name__ == \"__main__\" and gui.qApp is not None:\\n gui.qApp.exec()\\n'" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "design.to_python_script()" ] }, { "cell_type": "markdown", "id": "a005811d", "metadata": {}, "source": [ "## Saving with `to_python_script()`\n", "\n", "`design.to_python_script()` serialises the entire design state โ€” every component, every option, every route โ€” into a self-contained Python script. Running that script recreates the design identically, with no dependency on the original notebook session.\n", "\n", "**When to use it:**\n", "- **Version control** โ€” commit the `.py` file alongside your notebook; diffs are readable\n", "- **Sharing** โ€” send the script to a collaborator who can reproduce the exact design\n", "- **Headless / batch** โ€” run the script in CI or a parameter sweep without launching the GUI\n", "- **Long-term archiving** โ€” the script is plain Python, readable years later without notebook tooling\n", "\n", "The output prints to the cell below. Copy it into the cell underneath and run it to verify it reproduces your design cleanly." ] }, { "cell_type": "markdown", "id": "e614c57e", "metadata": {}, "source": [ "### Replay the saved script\n", "\n", "Copy the output from the cell above into a fresh code cell (or a `.py` file) and run it. It should rebuild the full design without any of the intermediate cells above.\n", "\n", "You can also save it directly to a file:\n", "\n", "```python\n", "import pathlib\n", "\n", "script = design.to_python_script() # returns the script as a string\n", "pathlib.Path(\"my_chip_design.py\").write_text(script)\n", "print(\"Saved to my_chip_design.py\")\n", "```\n", "\n", "Then replay from the command line:\n", "\n", "```bash\n", "python my_chip_design.py\n", "```\n", "\n", "> **Tip:** the script is deterministic โ€” running it twice produces the same geometry. This makes it safe to use as a fixture in automated tests or as input to a parameter sweep." ] }, { "cell_type": "markdown", "id": "30460f25", "metadata": {}, "source": [ "## Exporting to GDS\n", "\n", "`to_python_script()` captures your design intent; GDS export produces the fabrication mask. The GDS renderer handles junction placement, ground-plane cheesing, and layer assignment.\n", "\n", "```python\n", "gds = design.renderers.gds\n", "\n", "# Point to a GDS file containing your Josephson junction cells.\n", "# The file can use any unit (ยตm, nm, mm) โ€” the renderer auto-scales.\n", "gds.options.path_filename = \"../resources/Fake_Junctions.GDS\"\n", "\n", "# Control whether cheese/no-cheese geometry appears in the output.\n", "# {1: False} = process layer 1 but suppress cheese holes from the file.\n", "# Using Dict(main={}) omits the layer entirely and triggers a warning.\n", "gds.options.cheese.view_in_file = Dict(main={1: False})\n", "gds.options.no_cheese.view_in_file = Dict(main={1: False})\n", "\n", "gds.export_to_gds(\"my_chip.gds\")\n", "```\n", "\n", "After export, inspect the result:\n", "\n", "```python\n", "import gdstk\n", "\n", "lib = gdstk.read_gds(\"my_chip.gds\")\n", "\n", "# show=True embeds an SVG preview directly in this cell output.\n", "# Increase scale for a larger chip; increase width to fill the cell.\n", "gds.debug_summarize_gds_library(lib, show=True, scale=100, width=900)\n", "```\n", "\n", "### Junction units\n", "\n", "The qubit components in this design use `gds_cell_name` to name the junction placeholder:\n", "\n", "| Qubit | `gds_cell_name` |\n", "|-------|----------------|\n", "| Q1 | `FakeJunction_01` |\n", "| Q2 | `FakeJunction_02` |\n", "\n", "These names must match cells inside the GDS file pointed to by `path_filename`. The renderer reads the file's `unit` field and rescales all junction geometry automatically โ€” a junction file in nm, ยตm, or any other unit will land at the correct physical size. See **1.1 Quick start โ†’ Render to GDS** for a full walkthrough including layer options and the debug summary tool.\n", "\n", "### What's next\n", "\n", "- **1.1 Quick start** โ€” run and visualise this design without the Qt GUI\n", "- **2 From components to chip** โ€” multi-qubit designs, CPW routing, and design variables\n", "- **3 Renderers** โ€” HFSS, Q3D, GDS, and gmsh/Elmer in depth" ] }, { "cell_type": "code", "execution_count": 6, "id": "3c244cef-b426-4784-911d-d36b4e20eb9a", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:36.835486Z", "iopub.status.busy": "2026-08-09T22:26:36.835300Z", "iopub.status.idle": "2026-08-09T22:26:36.900249Z", "shell.execute_reply": "2026-08-09T22:26:36.899067Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "04:26PM 36s WARNING [import_junction_gds_file]: Not able to find file:\"../resources/Fake_Junctions.GDS\". Not used to replace junction. Checked directory:\"/Users/zlatkominev/CODE_REPOS/quantum_hardware_all/qiskit-metal/docs/tut/resources\".\n" ] }, { "data": { "text/plain": [ "1" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit_metal import Dict, open_docs\n", "\n", "gds = design.renderers.gds\n", "\n", "# Point to a GDS file containing your Josephson junction cells.\n", "# The file can use any unit (ยตm, nm, mm) โ€” the renderer auto-scales.\n", "gds.options.path_filename = \"../resources/Fake_Junctions.GDS\"\n", "\n", "# Control whether cheese/no-cheese geometry appears in the output.\n", "# {1: False} = process layer 1 but suppress cheese holes from the file.\n", "# Using Dict(main={}) omits the layer entirely and triggers a warning.\n", "gds.options.cheese.view_in_file = Dict(main={1: False})\n", "gds.options.no_cheese.view_in_file = Dict(main={1: False})\n", "\n", "gds.export_to_gds(\"my_chip.gds\")" ] }, { "cell_type": "code", "execution_count": 7, "id": "47d96d2e-6fea-4ede-aeb9-ffca207e6915", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:36.902103Z", "iopub.status.busy": "2026-08-09T22:26:36.902011Z", "iopub.status.idle": "2026-08-09T22:26:36.910244Z", "shell.execute_reply": "2026-08-09T22:26:36.909524Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
LayerDTypeDescriptionPolygonsPaths
10metal (boolean result)39 poly0 paths
110component polygon input28 poly0 paths
111CPW FlexPath trace42 poly0 paths
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "=== GDS LIBRARY SUMMARY ===\n", "name: library\n", "unit: 0.001\n", "precision: 1e-09\n", "cells: 4\n", "\n", "CELLS:\n", " - TOP geom=True bbox=((-4.5, -3.0), (4.5, 3.0))\n", " - TOP_main geom=True bbox=((-4.5, -3.0), (4.5, 3.0))\n", " - TOP_main_1 geom=True bbox=((-4.5, -3.0), (4.5, 3.0))\n", " - ground_main_1 geom=True bbox=((-4.5, -3.0), (4.5, 3.0))\n", "\n", "LAYER / DATATYPE USAGE:\n", " layer dtype polys paths\n", " ----- ----- ----- -----\n", " 1 0 39 0\n", " 1 10 28 0\n", " 1 11 42 0\n", "\n", "=== END SUMMARY ===\n", "\n" ] } ], "source": [ "import gdstk\n", "\n", "lib = gdstk.read_gds(\"my_chip.gds\")\n", "\n", "# show=True embeds an SVG preview directly in this cell output.\n", "# Increase scale for a larger chip; increase width to fill the cell.\n", "gds.debug_summarize_gds_library(lib, show=True, scale=100, width=900)" ] }, { "cell_type": "markdown", "id": "0348dfe6", "metadata": {}, "source": [ "### GDS layer legend\n", "\n", "The renderer writes geometry across several **layer / datatype** pairs.\n", "The layer number matches the `layer` option on each component (default `1`).\n", "The datatype encodes how the geometry was produced:\n", "\n", "| Layer | Datatype | Content |\n", "|-------|----------|---------|\n", "| 1 | 0 | **Final metal pattern** โ€” post-boolean result (chip outline, ground plane, qubit pockets merged into a single mask) |\n", "| 1 | 10 | **Component polygons** โ€” individual pad, pocket, and junction-extension-pad outlines before the boolean merge |\n", "| 1 | 11 | **CPW traces** โ€” `FlexPath` geometry for routes, transmission lines, and connectors |\n", "| 53 | 0 | **Junction primary layer** โ€” polygons from the imported junction GDS file (`FakeJunction_01/02`) |\n", "| 54 | 0 | **Junction secondary layer** โ€” second contact layer from the same junction GDS file |\n", "\n", "> **Layers 53 and 54 are whatever layers your junction file uses.** If you supply\n", "> your own junction GDS, its layer numbers will appear here instead. Use KLayout's\n", "> layer panel (right-hand side) to toggle each layer on/off and identify them.\n", "\n", "The `plot_gds_zoom` panels below colour each `(layer, datatype)` pair distinctly,\n", "making it easy to see where the junction sits relative to the qubit pads.\n" ] }, { "cell_type": "markdown", "id": "2c97fcee", "metadata": {}, "source": [ "### Zooming into junction pads in GDS\n", "\n", "``debug_summarize_gds_library`` gives a chip-level overview. To inspect individual junctions at fabrication scale, ``gds.plot_gds_zoom`` clips a small window out of the flattened GDS and renders it with matplotlib โ€” no KLayout required.\n", "\n", "It works by calling ``top.get_polygons(depth=None)`` to flatten the full cell hierarchy, filtering to a bounding box around your target, then drawing each polygon coloured by ``(layer, datatype)``.\n", "\n", "> **Matplotlib backend note:** when ``qm.gui(design)`` returns the desktop ``MetalGUI`` (Qt path), matplotlib's backend is ``Qt6Agg`` โ€” ``plt.subplots()`` then opens a Qt window instead of rendering inline. The ``%matplotlib inline`` cell below resets to the static ``Agg`` backend. With the headless viewer this isn't needed; the inline backend is already active." ] }, { "cell_type": "code", "execution_count": 8, "id": "e635be1c-547d-47f9-a2af-bd536837c6da", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:36.911423Z", "iopub.status.busy": "2026-08-09T22:26:36.911345Z", "iopub.status.idle": "2026-08-09T22:26:36.913241Z", "shell.execute_reply": "2026-08-09T22:26:36.912893Z" } }, "outputs": [], "source": [ "# Reset to the static Agg backend so plots render inline.\n", "# Needed because MetalGUI (used above) initialises PySide6 which can\n", "# switch matplotlib to Qt6Agg. See the note in the markdown cell above.\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 9, "id": "81267beb", "metadata": { "execution": { "iopub.execute_input": "2026-08-09T22:26:36.914570Z", "iopub.status.busy": "2026-08-09T22:26:36.914495Z", "iopub.status.idle": "2026-08-09T22:26:37.041855Z", "shell.execute_reply": "2026-08-09T22:26:37.041450Z" }, "nbsphinx-thumbnail": {} }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "# Zoom into each qubit โ€” 200 ยตm window centred on the junction.\n", "# Q1 sits at (0.70, 0) mm (orientation 0ยฐ) โ†’ junction cell rotated 90ยฐ โ†’ vertical\n", "# Q2 sits at (โˆ’0.70, 0) mm (orientation 180ยฐ) โ†’ junction cell rotated โˆ’90ยฐ โ†’ vertical\n", "fig, axes = plt.subplots(1, 2, figsize=(13, 6))\n", "fig.suptitle(\"GDS junction pad zoom โ€” 200 ยตm window\", fontsize=13)\n", "\n", "gds.plot_gds_zoom(\n", " lib,\n", " center_mm=(0.70, 0.0),\n", " span_mm=0.10,\n", " title=\"Q1 โ€” FakeJunction_01 at (0.7, 0) mm\",\n", " ax=axes[0],\n", ")\n", "gds.plot_gds_zoom(\n", " lib,\n", " center_mm=(-0.70, 0.0),\n", " span_mm=0.10,\n", " title=\"Q2 โ€” FakeJunction_02 at (โˆ’0.7, 0) mm\",\n", " ax=axes[1],\n", ")\n", "\n", "plt.tight_layout()\n", "# plt.close(fig)\n", "# fig" ] }, { "cell_type": "markdown", "id": "b7e4c9d2-viewer", "metadata": {}, "source": [ "## Viewing your GDS file\n", "\n", "Once you have a `.gds` file, you'll want to inspect it visually โ€” zoom into junction pads, verify layer colours, check that routes don't collide. Several free tools can do this on every platform.\n", "\n", "---\n", "\n", "### KLayout (recommended)\n", "\n", "[KLayout](https://www.klayout.de) is the industry-standard open-source GDS/OASIS viewer and editor. It handles multi-layer designs, has a Python scripting console, and runs on **Windows, macOS, and Linux**.\n", "\n", "**Install:**\n", "\n", "| Platform | Method |\n", "|----------|---------|\n", "| **macOS** | `brew install --cask klayout` โ€” or download the `.dmg` from [klayout.de/build.html](https://www.klayout.de/build.html) |\n", "| **Windows** | Download the `.exe` installer from [klayout.de/build.html](https://www.klayout.de/build.html) |\n", "| **Linux** | `.rpm` / `.deb` packages available, or `conda install -c conda-forge klayout` |\n", "\n", "**Open your file:**\n", "\n", "```bash\n", "# From the terminal โ€” opens KLayout with the file loaded\n", "klayout my_chip.gds\n", "```\n", "\n", "Or launch KLayout and use **File โ†’ Open**.\n", "\n", "**Key things to check:**\n", "- **Layer panel** (right side) โ€” toggle layers on/off to isolate metal, junctions, cheese holes\n", "- **Ruler tool** (`R`) โ€” measure distances in design units\n", "- **Zoom to fit** (`F`) โ€” see the full chip at once\n", "- **Zoom into junction pads** โ€” verify physical size matches your design (30 ยตm ร— 3 ยตm for the fake junctions here)\n", "\n", "---\n", "\n", "### Quick in-notebook preview (no install needed)\n", "\n", "You already have `gdstk` and the `debug_summarize_gds_library` tool. For a fast sanity check without leaving Jupyter:\n", "\n", "```python\n", "import gdstk\n", "lib = gdstk.read_gds(\"my_chip.gds\")\n", "gds.debug_summarize_gds_library(lib, show=True, scale=100, width=900)\n", "```\n", "\n", "This embeds an SVG overview directly in the cell output and saves with the notebook. Good for a quick geometry and layer check; use KLayout for detailed inspection.\n", "\n", "---\n", "\n", "### Other free viewers\n", "\n", "| Tool | Platform | Notes |\n", "|------|----------|-------|\n", "| [gdstk](https://heitzmann.github.io/gdstk/) | Python (all platforms) | Programmatic; `cell.write_svg()` for per-cell previews |\n", "| [Magic VLSI](http://opencircuitdesign.com/magic/) | Linux / macOS | Full DRC + extraction; steeper learning curve |\n", "| [GDS3D](https://github.com/trilomix/GDS3D) | Windows / Linux | 3D visualisation of GDS layers |\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "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.11.14" } }, "nbformat": 4, "nbformat_minor": 5 }