{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Create a QComponent - Basic"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now that you have become familiar with Qiskit Metal and feel comfortable using the available aspects and functionality, the next step is learning how to make your own circuit component in Metal.\n",
"\n",
"We will start off by going over the sample `my_qcomponent` in `qiskit_metal>qlibrary>user_components` as a basis, which we will walk through below."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Reviewing my_qcomponent"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# -*- coding: utf-8 -*-\n",
"\n",
"# This code is part of Qiskit.\n",
"#\n",
"# (C) Copyright IBM 2017, 2021.\n",
"#\n",
"# This code is licensed under the Apache License, Version 2.0. You may\n",
"# obtain a copy of this license in the LICENSE.txt file in the root directory\n",
"# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.\n",
"#\n",
"# Any modifications or derivative works of this code must retain this\n",
"# copyright notice, and modified files need to carry a notice indicating\n",
"# that they have been altered from the originals."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Always be sure to include the proper copyright and license information, and give yourself credit for any components you create!"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from qiskit_metal import draw, Dict\n",
"from qiskit_metal.toolbox_metal import math_and_overrides\n",
"from qiskit_metal.qlibrary.core import QComponent"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Import any classes or functions you will be wanting to use when creating your component. The geometries in Metal are shapely objects, which can be readily generated and manipulated through functions in `draw`. Mathematical functions can be accessed via `math_and_overrides`. Any imports that are part of the Metal requirement list can also be used.\n",
"\n",
"The key import is what the parent class of your new component will be. For this example, we are using `QComponent` as the parent for `MyQComponent`, which is the base component class in Metal and contains a great deal of automated functionality. All component hierarchy must have QComponent as the top base class."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['TOOLTIP',\n",
" '__class__',\n",
" '__delattr__',\n",
" '__dict__',\n",
" '__dir__',\n",
" '__doc__',\n",
" '__eq__',\n",
" '__format__',\n",
" '__ge__',\n",
" '__getattribute__',\n",
" '__gt__',\n",
" '__hash__',\n",
" '__i_am_component__',\n",
" '__init__',\n",
" '__init_subclass__',\n",
" '__le__',\n",
" '__lt__',\n",
" '__module__',\n",
" '__ne__',\n",
" '__new__',\n",
" '__reduce__',\n",
" '__reduce_ex__',\n",
" '__repr__',\n",
" '__setattr__',\n",
" '__sizeof__',\n",
" '__str__',\n",
" '__subclasshook__',\n",
" '__weakref__',\n",
" '_add_to_design',\n",
" '_check_pin_inputs',\n",
" '_delete_evaluation',\n",
" '_gather_all_children_metadata',\n",
" '_gather_all_children_options',\n",
" '_get_specific_table_values_from_renderers',\n",
" '_get_table_values_from_renderers',\n",
" '_get_unique_class_name',\n",
" '_is_name_used',\n",
" '_register_class_with_design',\n",
" 'add_dependency',\n",
" 'add_pin',\n",
" 'add_qgeometry',\n",
" 'class_name',\n",
" 'component_metadata',\n",
" 'connect_components_already_in_design',\n",
" 'default_options',\n",
" 'delete',\n",
" 'design',\n",
" 'get_pin',\n",
" 'get_template_options',\n",
" 'id',\n",
" 'logger',\n",
" 'make',\n",
" 'name',\n",
" 'options',\n",
" 'parse_options',\n",
" 'parse_value',\n",
" 'pin_names',\n",
" 'populate_to_track_table_usage',\n",
" 'qgeometry_bounds',\n",
" 'qgeometry_dict',\n",
" 'qgeometry_list',\n",
" 'qgeometry_plot',\n",
" 'qgeometry_table',\n",
" 'qgeometry_types',\n",
" 'rebuild']"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dir(QComponent)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`MyQComponent` creates a simple rectangle of a variable width, height, position and orientation."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"class MyQComponent(QComponent):\n",
" \"\"\"\n",
" Use this class as a template for your components - have fun\n",
" \n",
" Description:\n",
" \n",
" Options:\n",
" \"\"\"\n",
"\n",
" # Edit these to define your own tempate options for creation\n",
" # Default drawing options\n",
" default_options = Dict(width='500um',\n",
" height='300um',\n",
" pos_x='0um',\n",
" pos_y='0um',\n",
" orientation='0',\n",
" layer='1')\n",
" \"\"\"Default drawing options\"\"\"\n",
"\n",
" # Name prefix of component, if user doesn't provide name\n",
" component_metadata = Dict(short_name='component',\n",
" _qgeometry_table_poly='True')\n",
" \"\"\"Component metadata\"\"\"\n",
" \n",
" def make(self):\n",
" \"\"\"Convert self.options into QGeometry.\"\"\"\n",
"\n",
" p = self.parse_options() # Parse the string options into numbers\n",
"\n",
" # EDIT HERE - Replace the following with your code\n",
" # Create some raw geometry\n",
" # Use autocompletion for the `draw.` module (use tab key)\n",
" rect = draw.rectangle(p.width, p.height, p.pos_x, p.pos_y)\n",
" \n",
" rect = draw.rotate(rect, p.orientation)\n",
" rect = draw.translate(rect,p.pos_x,p.pos_y)\n",
" \n",
" geom = {'my_polygon': rect}\n",
" self.add_qgeometry('poly', geom, layer=p.layer, subtract=False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The docstring at the start of the class should clearly explain what the component is, what the parameterized values of the component refer to (in a sense the 'inputs'), and any other information you believe would be relevant for a user making use of your component.\n",
"\n",
"`default_options` is a dictionary to be included in the class of all components. The keywords, of type string, in the default dictionary are the parameters the front-end user is allowed to modify. The keywords in the above indicate that the width and height can be modified via the components options, but have a default value of 500um and 300 um respectively. Further, the position and orientation can also be changed. The `layer` is an expected keyword in a default dictionary, as it is used by renderers to help determine further properties of the `qgeometry` of the component when rendered, eg. GDS QRenderer uses the layer # to define which layer the qgeometry is on.\n",
"\n",
"`component_metadata` is a dictionary which contains some important pieces of information, such as the default/shorthand name of the component (`short_name`), or indicating what types of qgeometry tables are included in this component, eg. `_qgeometry_table_poly='True'`.\n",
"The `component_metadata` must contain the flags for each type of qgeometry table being used via `add_qgeometry` methods at the end of the `make()` function, in order for renderer options to be updated correctly. Currently the options are:\n",
"\n",
"`_qgeometry_table_path='True'`\n",
"\n",
"`_qgeometry_table_poly='True'`\n",
"\n",
"`_qgeometry_table_junction='True'`\n",
"\n",
"\n",
"The `make()` method is where the actual generation of the component's layout is written. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### The make() method"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Although not required, a good first line is `p = self.parse_options()` to cut down on your amount of typing. The `parse_options()` translates the keywords in `self.options` from strings into their appropriate value with respect to the prefix included, e.g.,`p.width`=> \"500um\" -> 0.0005\n",
"\n",
"Following this, all code generating the shapely geometries that are to represent your circuit layout should be written, via the `draw` module or even written in directly. It is a good practice to play around with the geometries in a jupyter notebook first for quick visual feedback, such as:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"draw.rectangle(1,2,0,0)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"draw.rotate(draw.rectangle(1,2,0,0), 45)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Or for a little more complexity:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"face = draw.shapely.geometry.Point(0, 0).buffer(1)\n",
"eye = draw.shapely.geometry.Point(0, 0).buffer(0.2)\n",
"eye_l = draw.translate(eye, -0.4, 0.4)\n",
"eye_r = draw.translate(eye, 0.4, 0.4)\n",
"\n",
"smile = draw.shapely.geometry.Point(0, 0).buffer(0.8)\n",
"cut_sq = draw.shapely.geometry.box(-1, -0.3, 1, 1)\n",
"smile = draw.subtract(smile, cut_sq)\n",
"face = draw.subtract(face, smile)\n",
"face = draw.subtract(face, eye_r)\n",
"face = draw.subtract(face, eye_l)\n",
"face"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Once you are happy with your geometries, and have them properly parameterized to allow the Front End User as much customization of your component as you wish, it is time to convert the geometries into Metal `qgeometries` via `add_qgeometry`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### add_qgeometry"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"import qiskit_metal as metal\n",
"?metal.qlibrary.core.QComponent.add_qgeometry"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`add_qgeometry` is the method by which the shapely geometries you have drawn are converted into Metal qgeometries, the format which allows for the easy translatability between different renderers and the variable representation of quantum elements such as Josephson junctions.\n",
"\n",
"Currently there are three kinds of qgeometries, `path`, `poly` and `junction`.\n",
"`path` -> shapely LineString\n",
"`poly` -> any other shapely geometry (currently)\n",
"`junction` -> shapely LineString\n",
"\n",
"Both `path` and `junction` also take and input of `width`, with is added to the qgeometry table to inform renderers of, as an example, how much to buffer the LineString of a cpw transmission line to turn it into a proper 2D sheet.\n",
"\n",
"`subtract` indicates this qgeometry is to be subtracted from the ground plane of that layer#. A ground plane is automatically included for that layer at the dimension of the chip size if any qgeometry has `subtract = True`. As an example, a cpw transmission line's dielectric gap could be drawn by using the same LineString as previously, having the `width = cpw_width + 2*cpw_gap` and setting `subtract = True`.\n",
"\n",
"`fillet` is an option that informs a renderer that the vertices of this qgeometry are to be filleted by that value (eg. `fillet = \"100um\"`). "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### add_pin"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"?metal.qlibrary.core.QComponent.add_pin"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The final step for creating your QComponent is adding of pins. This is not necessarily a requirement for your component, but to have full functionality with Metal and be able to make use of auto-routing components with it, you will want to indicate where the \"ports\" of your component are.\n",
"\n",
"Following from the above docstring, pins can be added from two coordinates indicating either an orthogonal vector to the port plane of your component, or a tangent to the port plane of your component. For the former, you want the vector to be pointing to the middle point of your intended plane, with the latter being across the length of your intended plane (as indicated in the above figure). The `width` should be the size of the plane (say, in the case of a CPW transmission line, the trace width), with the `gap` following the same logic (though this value can be ignored for any non-coplanar structure). "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"Below is a simple QComponent that implements everything we have reviewed."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"from qiskit_metal import draw, Dict\n",
"from qiskit_metal.toolbox_metal import math_and_overrides\n",
"from qiskit_metal.qlibrary.core import QComponent\n",
"\n",
"class MySimpleGapCapacitor(QComponent):\n",
" \"\"\"\n",
" Inherits 'QComponent' class.\n",
" \n",
" Description:\n",
" A simple CPW style gap capacitor, with endcap islands each coupled to their own\n",
" cpw transmission line that ends in a pin.\n",
" \n",
" Options:\n",
" * cpw_width: width of the cpw trace of the transmission line\n",
" * cpw_gap: dielectric gap of the cpw transmission line\n",
" * cap_width: width of the gap capacitor (size of the charge islands)\n",
" * cap_gap: dielectric space between the two islands\n",
" * pos_x/_y: position of the capacitor on chip\n",
" * orientation: 0-> is parallel to x-axis, with orientation (in degrees) counterclockwise.\n",
" * layer: the layer number for the layout \n",
" \n",
" \n",
" \"\"\"\n",
"\n",
" # Edit these to define your own tempate options for creation\n",
" # Default drawing options\n",
" default_options = Dict(cpw_width='15um',\n",
" cpw_gap='9um',\n",
" cap_width='35um',\n",
" cap_gap='3um',\n",
" pos_x='0um',\n",
" pos_y='0um',\n",
" orientation='0',\n",
" layer='1')\n",
" \"\"\"Default drawing options\"\"\"\n",
"\n",
" # Name prefix of component, if user doesn't provide name\n",
" component_metadata = Dict(short_name='component', \n",
" _qgeometry_table_poly='True',\n",
" _qgeometry_table_path='True')\n",
" \"\"\"Component metadata\"\"\"\n",
" \n",
" def make(self):\n",
" \"\"\"Convert self.options into QGeometry.\"\"\"\n",
"\n",
" p = self.parse_options() # Parse the string options into numbers\n",
"\n",
" pad = draw.rectangle(p.cpw_width, p.cap_width, 0, 0)\n",
" pad_left = draw.translate(pad,-(p.cpw_width+p.cap_gap)/2,0)\n",
" pad_right = draw.translate(pad,(p.cpw_width+p.cap_gap)/2,0)\n",
" pad_etch = draw.rectangle(2*p.cpw_gap+2*p.cpw_width+p.cap_gap,2*p.cpw_gap+p.cap_width)\n",
" cpw_left = draw.shapely.geometry.LineString([[-(p.cpw_width+p.cap_gap/2),0],[-(p.cpw_width*3 +p.cap_gap/2),0]])\n",
" cpw_right = draw.shapely.geometry.LineString([[(p.cpw_width+p.cap_gap/2),0],[(p.cpw_width*3 +p.cap_gap/2),0]])\n",
" \n",
" geom_list = [pad_left,pad_right,cpw_left,cpw_right,pad_etch]\n",
" geom_list = draw.rotate(geom_list,p.orientation)\n",
" geom_list = draw.translate(geom_list,p.pos_x,p.pos_y)\n",
" [pad_left,pad_right,cpw_left,cpw_right,pad_etch] = geom_list\n",
"\n",
" self.add_qgeometry('path', {'cpw_left':cpw_left, 'cpw_right':cpw_right}, layer=p.layer, width = p.cpw_width)\n",
" self.add_qgeometry('path', {'cpw_left_etch':cpw_left, 'cpw_right_etch':cpw_right}, layer=p.layer, width = p.cpw_width+2*p.cpw_gap, subtract=True)\n",
" self.add_qgeometry('poly', {'pad_left':pad_left, 'pad_right':pad_right}, layer=p.layer)\n",
" self.add_qgeometry('poly', {'pad_etch':pad_etch}, layer=p.layer, subtract=True)\n",
" \n",
" self.add_pin('cap_left', cpw_left.coords, width = p.cpw_width, gap = p.cpw_gap, input_as_norm=True)\n",
" self.add_pin('cap_right', cpw_right.coords, width = p.cpw_width, gap = p.cpw_gap, input_as_norm=True)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"design = metal.designs.DesignPlanar()\n",
"\n",
"gui = metal.MetalGUI(design)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"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": [
"my_cap = MySimpleGapCapacitor(design,'my_cap')\n",
"gui.rebuild()\n",
"gui.autoscale()\n",
"gui.screenshot()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You should now see *my_cap* in the Metal gui. One can work on the layout of the component through these cells by changing the above class, such as how the parameterized values are used. By enabling `overwrite_enabled` (which should normally be kept to False), the code can quickly be iterated through until you, the component designer, is happy with the qcomponent you have just created."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"design.overwrite_enabled = True"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We will delve into more complex QComponent topics in the next notebook, `Creating a QComponent - Advanced` \n",
"\n",
"Use the command below to close Metal GUI."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"gui.main_window.close()"
]
}
],
"metadata": {
"celltoolbar": "Tags",
"kernelspec": {
"display_name": "Python 3",
"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.7.8"
}
},
"nbformat": 4,
"nbformat_minor": 4
}