{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Design a 4 qubit full chip" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Creates a complete quantum chip and exports it to GDS." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Preparations" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The next cell enables [module automatic reload](https://ipython.readthedocs.io/en/stable/config/extensions/autoreload.html?highlight=autoreload). Your notebook will be able to pick up code updates made to the qiskit-metal (or other) module code." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%reload_ext autoreload\n", "%autoreload 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Import key libraries and open the Metal GUI. Also, we configure the notebook to enable overwriting of existing components." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from collections import OrderedDict\n", "\n", "from qiskit_metal import designs, draw\n", "from qiskit_metal import MetalGUI, Dict, Headings\n", "\n", "design = designs.DesignPlanar()\n", "gui = MetalGUI(design)\n", "\n", "# if you disable the next line, then you will need to delete a component [.delete()] before recreating it\n", "design.overwrite_enabled = True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Import components that will be necessary for the design." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL\n", "from qiskit_metal.qlibrary.tlines.meandered import RouteMeander\n", "from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors\n", "from qiskit_metal.qlibrary.tlines.pathfinder import RoutePathfinder\n", "from qiskit_metal.qlibrary.terminations.launchpad_wb import LaunchpadWirebond\n", "from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Let's design the core of the chip" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Setup the design-wide default settings for trace width and trace gap. These can be customized later for individual transmission lines." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "design.variables['cpw_width'] = '10 um'\n", "design.variables['cpw_gap'] = '6 um'\n", "design._chips['main']['size']['size_x'] = '9mm'\n", "design._chips['main']['size']['size_y'] = '6.5mm'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need 4 transmons with 3 connection pads each and a chargeline. Let's explore the options of one transmon" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'pos_x': '0.0um',\n", " 'pos_y': '0.0um',\n", " 'orientation': '0.0',\n", " 'chip': 'main',\n", " 'layer': '1',\n", " 'connection_pads': {},\n", " '_default_connection_pads': {'pad_gap': '15um',\n", " 'pad_width': '125um',\n", " 'pad_height': '30um',\n", " 'pad_cpw_shift': '5um',\n", " 'pad_cpw_extent': '25um',\n", " 'cpw_width': 'cpw_width',\n", " 'cpw_gap': 'cpw_gap',\n", " 'cpw_extend': '100um',\n", " 'pocket_extent': '5um',\n", " 'pocket_rise': '65um',\n", " 'loc_W': '+1',\n", " 'loc_H': '+1'},\n", " 'pad_gap': '30um',\n", " 'inductor_width': '20um',\n", " 'pad_width': '455um',\n", " 'pad_height': '90um',\n", " 'pocket_width': '650um',\n", " 'pocket_height': '650um',\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': '0',\n", " 'cl_off_center': '50um',\n", " 'hfss_wire_bonds': False,\n", " 'q3d_wire_bonds': False,\n", " 'hfss_inductance': '10nH',\n", " 'hfss_capacitance': 0,\n", " 'hfss_resistance': 0,\n", " 'hfss_mesh_kw_jj': 7e-06,\n", " 'q3d_inductance': '10nH',\n", " 'q3d_capacitance': 0,\n", " 'q3d_resistance': 0,\n", " 'q3d_mesh_kw_jj': 7e-06,\n", " 'gds_cell_name': 'my_other_junction'}" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "TransmonPocketCL.get_template_options(design)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We want to change the `pad_width` for these transmons, as well as define the 3 connection pads and chargeline.\n", "\n", "To apply the same modifications to all 4 transmons, we define a single option-dictionary to pass to all transmons at the monent of creation." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "transmon_options = dict(\n", " connection_pads=dict(\n", " a = dict(loc_W=+1, loc_H=-1, pad_width='70um', cpw_extend = '50um'), \n", " b = dict(loc_W=-1, loc_H=-1, pad_width='125um', cpw_extend = '50um'),\n", " c = dict(loc_W=-1, loc_H=+1, pad_width='110um', cpw_extend = '50um')\n", " ),\n", " gds_cell_name='FakeJunction_01',\n", " cl_off_center = '-50um',\n", " cl_pocket_edge = '180'\n", ")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now create the 4 transmons by specifying the desired coordinates and orientations." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "offset_tm = 69 #we the transmon slightly out of center-line\n", "\n", "q1 = TransmonPocketCL(design, 'Q1', options = dict(\n", " pos_x='+2420um', pos_y=f'{offset_tm}um', **transmon_options))\n", "q2 = TransmonPocketCL(design, 'Q2', options = dict(\n", " pos_x='0um', pos_y='-857.6um', orientation = '270', **transmon_options))\n", "q3 = TransmonPocketCL(design, 'Q3', options = dict(\n", " pos_x='-2420um', pos_y=f'{offset_tm}um', orientation = '180', **transmon_options))\n", "q4 = TransmonPocketCL(design, 'Q4', options = dict(\n", " pos_x='0um', pos_y='+857.6um', orientation = '90', **transmon_options))\n", "\n", "gui.rebuild()\n", "gui.autoscale()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's now connect the transmons with transmission lines. We want to have an \"exact length\" transmission line, so we will use the `RouteMeander`. Let's first observe what the default options are." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'chip': 'main',\n", " 'layer': '1',\n", " 'pin_inputs': {'start_pin': {'component': '', 'pin': ''},\n", " 'end_pin': {'component': '', 'pin': ''}},\n", " 'fillet': '0',\n", " 'lead': {'start_straight': '0mm',\n", " 'end_straight': '0mm',\n", " 'start_jogged_extension': '',\n", " 'end_jogged_extension': ''},\n", " 'total_length': '7mm',\n", " 'trace_width': 'cpw_width',\n", " 'meander': {'spacing': '200um', 'asymmetry': '0um'},\n", " 'snap': 'true',\n", " 'prevent_short_edges': 'true',\n", " 'hfss_wire_bonds': False,\n", " 'q3d_wire_bonds': False}" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "RouteMeander.get_template_options(design)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We want to globally override the default lead (straight initial segment leaving the transmon) and the default fillet (corner rounding radius). Let's collect this information in one dictionary." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "fillet='99.99um'\n", "cpw_options = Dict(\n", " lead=Dict(\n", " start_straight='100um',\n", " end_straight='250um'),\n", " fillet=fillet\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We then want each transmission line to be connected to different pins and to have different lengths and asymmetry w.r.t their centerline. Let's collect this information in other dictionaries. Before doing that, to manage the dictionaries in a simpler way, we redefine the `RouteMeander` signature by wrapping it into a convenient method named `connect`" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def connect(cpw_name: str, pin1_comp_name: str, pin1_comp_pin: str, pin2_comp_name: str, pin2_comp_pin: str,\n", " length: str, asymmetry='0 um'):\n", " \"\"\"Connect two pins with a CPW.\"\"\"\n", " myoptions = Dict(\n", " pin_inputs=Dict(\n", " start_pin=Dict(\n", " component=pin1_comp_name,\n", " pin=pin1_comp_pin),\n", " end_pin=Dict(\n", " component=pin2_comp_name,\n", " pin=pin2_comp_pin)),\n", " total_length=length)\n", " myoptions.update(cpw_options)\n", " myoptions.meander.asymmetry = asymmetry\n", " return RouteMeander(design, cpw_name, myoptions)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now proceed and define the meanders following the signature: `connect(cpw_name, pin1_comp_name, pin1_comp_pin, pin2_comp_name, pin2_comp_pin, length, asymmetry)`" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "asym = 500\n", "cpw1 = connect('cpw1', 'Q1', 'c', 'Q4', 'b', '9000um', f'-{asym-1.25*offset_tm}um')\n", "cpw2 = connect('cpw2', 'Q3', 'b', 'Q4', 'c', '9000um', f'+{asym-1.25*offset_tm}um')\n", "cpw3 = connect('cpw3', 'Q3', 'c', 'Q2', 'b', '9000um', f'-{asym+0.75*offset_tm}um')\n", "cpw4 = connect('cpw4', 'Q1', 'b', 'Q2', 'c', '9000um', f'+{asym+0.75*offset_tm}um')\n", "\n", "gui.rebuild()\n", "gui.autoscale()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Let's now connect the core elements to the launchpads" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First we setup the launchpad location and orientation." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# V1 - Corners\n", "p1_c = LaunchpadWirebond(design, 'P1_C', options = dict(pos_x='3545um', pos_y='2812um', orientation='270', lead_length='0um'))\n", "p2_c = LaunchpadWirebond(design, 'P2_C', options = dict(pos_x='3545um', pos_y='-2812um', orientation='90', lead_length='0um'))\n", "p3_c = LaunchpadWirebond(design, 'P3_C', options = dict(pos_x='-3545um', pos_y='-2812um', orientation='90', lead_length='0um'))\n", "p4_c = LaunchpadWirebond(design, 'P4_C', options = dict(pos_x='-3545um', pos_y='2812um', orientation='270', lead_length='0um'))\n", "\n", "# V2\n", "p1_q = LaunchpadWirebondCoupled(design, 'P1_Q', options = dict(pos_x='4020um', pos_y='0', orientation='180', lead_length='30um'))\n", "p2_q = LaunchpadWirebondCoupled(design, 'P2_Q', options = dict(pos_x='-990um', pos_y='-2812um', orientation='90', lead_length='30um'))\n", "p3_q = LaunchpadWirebondCoupled(design, 'P3_Q', options = dict(pos_x='-4020um', pos_y='0', orientation='0', lead_length='30um'))\n", "p4_q = LaunchpadWirebondCoupled(design, 'P4_Q', options = dict(pos_x='990um', pos_y='2812um', orientation='270', lead_length='30um'))\n", "\n", "gui.rebuild()\n", "gui.autoscale()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then we route. First the V2 launchpads - Exchange Coupler Lines to Edges." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "asym = 150\n", "cpw_options = Dict(\n", " lead=Dict(\n", " start_straight='430um',\n", " end_straight='0um'),\n", " fillet=fillet\n", " )\n", "ol1 = connect('ol1', 'Q1', 'a', 'P1_Q', 'tie', '8.6 mm', f'+{asym}um')\n", "ol3 = connect('ol3', 'Q3', 'a', 'P3_Q', 'tie', '8.6 mm', f'+{asym}um')\n", "\n", "asym = 200\n", "cpw_options = Dict(\n", " lead=Dict(\n", " start_straight='535um',\n", " end_straight='0um'),\n", " fillet=fillet\n", " )\n", "ol2 = connect('ol2', 'Q2', 'a', 'P2_Q', 'tie', '8.6 mm', f'+{asym}um')\n", "ol4 = connect('ol4', 'Q4', 'a', 'P4_Q', 'tie', '8.6 mm', f'+{asym}um')\n", "\n", "gui.rebuild()\n", "gui.autoscale()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally we route the V1 launchpads - Chargelines to Corners." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We create the transmission lines between the corner launchpads and the qubit charge lines." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "from collections import OrderedDict\n", "jogsA_in = OrderedDict()\n", "jogsA_in[0] = [\"L\", '200um']\n", "\n", "options_line_cl1 = {'pin_inputs': \n", " {'start_pin': {'component': 'Q1', 'pin': 'Charge_Line'}, \n", " 'end_pin': {'component': 'P1_C', 'pin': 'tie'}},\n", " 'lead': {'start_straight': '120um', 'end_straight': '225um','start_jogged_extension': jogsA_in},\n", " 'fillet': fillet\n", " }\n", "cl1 = RouteAnchors(design, 'line_cl1', options_line_cl1)\n", "\n", "options_line_cl3 = {'pin_inputs': \n", " {'start_pin': {'component': 'Q3', 'pin': 'Charge_Line'}, \n", " 'end_pin': {'component': 'P3_C', 'pin': 'tie'}},\n", " 'lead': {'start_straight': '120um', 'end_straight': '225um', 'start_jogged_extension': jogsA_in},\n", " 'fillet': fillet\n", " }\n", "cl3 = RouteAnchors(design, 'line_cl3', options_line_cl3)\n", "\n", "gui.rebuild()\n", "gui.autoscale()" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "jogsB_in = OrderedDict()\n", "jogsB_in[0] = [\"L\", '300um']\n", "\n", "anchors2c = OrderedDict()\n", "anchors2c[0] = np.array([2, -2.5])\n", "\n", "options_line_cl2 = {'pin_inputs': \n", " {'start_pin': {'component': 'Q2', 'pin': 'Charge_Line'}, \n", " 'end_pin': {'component': 'P2_C', 'pin': 'tie'}},\n", " 'lead': {'start_straight': '200um', 'end_straight': '225um',\n", " 'start_jogged_extension': jogsB_in},\n", " 'anchors': anchors2c,\n", " 'fillet': fillet\n", " }\n", "\n", "cl2 = RouteAnchors(design, 'line_cl2', options_line_cl2)\n", "\n", "anchors4c = OrderedDict()\n", "anchors4c[0] = np.array([-2, 2.5])\n", "\n", "options_line_cl4 = {'pin_inputs': \n", " {'start_pin': {'component': 'Q4', 'pin': 'Charge_Line'}, \n", " 'end_pin': {'component': 'P4_C', 'pin': 'tie'}},\n", " 'lead': {'start_straight': '200um', 'end_straight': '225um',\n", " 'start_jogged_extension': jogsB_in},\n", " 'anchors': anchors4c,\n", " 'fillet': fillet\n", " }\n", "\n", "cl4 = RouteAnchors(design, 'line_cl4', options_line_cl4)\n", "\n", "gui.rebuild()\n", "gui.autoscale()" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "tags": [ "nbsphinx-thumbnail" ] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": { "image/png": { "width": 500 } }, "output_type": "display_data" } ], "source": [ "gui.screenshot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Export to GDS" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "QDesign enables GDS renderer during init. Let's see what the avilable option defaults are." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "{'short_segments_to_not_fillet': 'True',\n", " 'check_short_segments_by_scaling_fillet': '2.0',\n", " 'gds_unit': 0.001,\n", " 'ground_plane': 'True',\n", " 'negative_mask': {'main': []},\n", " 'fabricate': 'False',\n", " 'corners': 'circular bend',\n", " 'tolerance': '0.00001',\n", " 'precision': '0.000000001',\n", " 'width_LineString': '10um',\n", " 'path_filename': '../resources/Fake_Junctions.GDS',\n", " 'junction_pad_overlap': '5um',\n", " 'max_points': '199',\n", " 'cheese': {'datatype': '100',\n", " 'shape': '0',\n", " 'cheese_0_x': '25um',\n", " 'cheese_0_y': '25um',\n", " 'cheese_1_radius': '100um',\n", " 'view_in_file': {'main': {1: True}},\n", " 'delta_x': '100um',\n", " 'delta_y': '100um',\n", " 'edge_nocheese': '200um'},\n", " 'no_cheese': {'datatype': '99',\n", " 'buffer': '25um',\n", " 'cap_style': '2',\n", " 'join_style': '2',\n", " 'view_in_file': {'main': {1: True}}},\n", " 'bounding_box_scale_x': '1.2',\n", " 'bounding_box_scale_y': '1.2'}" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a_gds = design.renderers.gds\n", "\n", "a_gds.options" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "a_gds.options['no_cheese']['buffer'] = '50um'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Correct the path to point to the junction GDS that we intend to include in the output GDS. Then stream out all components in the design." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a_gds.options['path_filename'] = '../../../tutorials/resources/Fake_Junctions.GDS'\n", "a_gds.export_to_gds(\"Full_chip_design.gds\")" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gui.main_window.close()" ] } ], "metadata": { "celltoolbar": "Tags", "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.9.9" } }, "nbformat": 4, "nbformat_minor": 4 }