Repository: qiskit-community/qiskit-metal (language: python)

Issue:
Fgnyilmaz transmon pocket teeth
<!--
⚠️ If you do not respect this template, your pull request will be closed.
⚠️ Your pull request title should be short detailed and understandable for all.
⚠️ Also, please add it in the CHANGELOG file under Unreleased section.
⚠️ If your pull request fixes an open issue, please link to the issue.

✅ I have added the tests to cover my changes.
✅ I have updated the documentation accordingly.
✅ I have read the CONTRIBUTING document.
-->


### What are the issues this pull addresses (issue numbers / links)?


### Did you add tests to cover your changes (yes/no)?

### Did you update the documentation accordingly (yes/no)?

### Did you read the CONTRIBUTING document (yes/no)?

### Summary



### Details and comments





Discussion / hints:
[![CLA assistant check](https://cla-assistant.io/pull/badge/signed)](https://cla-assistant.io/Qiskit/qiskit-metal?pullRequest=684) <br/>All committers have signed the CLA.

Fix patch:
diff --git a/QComponent_Qubit_Transmon_Pocket_Teeth.PNG b/QComponent_Qubit_Transmon_Pocket_Teeth.PNG
deleted file mode 100644
index f9266f960..000000000
Binary files a/QComponent_Qubit_Transmon_Pocket_Teeth.PNG and /dev/null differ
diff --git a/docs/_utility/generate_images.ipynb b/docs/_utility/generate_images.ipynb
index 177fe25a7..3576aee05 100644
--- a/docs/_utility/generate_images.ipynb
+++ b/docs/_utility/generate_images.ipynb
@@ -82,6 +82,7 @@
     "from qiskit_metal.qlibrary.qubits.transmon_pocket import TransmonPocket\n",
     "from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL\n",
     "from qiskit_metal.qlibrary.qubits.transmon_pocket_6 import TransmonPocket6\n",
+    "from qiskit_metal.qlibrary.qubits.transmon_pocket_teeth import TransmonPocketTeeth\n",
     "\n",
     "import shutil, os"
    ]
@@ -211,7 +212,8 @@
     "create_image(TransmonInterdigitated, 'transmoninterdigitated', 'TransmonInterdigitated.png')\n",
     "create_image(TransmonPocket, 'transmonpocket', 'TransmonPocket.png')\n",
     "create_image(TransmonPocketCL, 'transmonpocketcl', 'TransmonPocketCL.png')\n",
-    "create_image(TransmonPocket6, 'transmonpocket6', 'TransmonPocket6.png')"
+    "create_image(TransmonPocket6, 'transmonpocket6', 'TransmonPocket6.png')\n",
+    "create_image(TransmonPocketTeeth, 'transmonpocketteeth', 'Transmon_Pocket_Teeth.png')"
    ]
   },
   {
diff --git a/docs/apidocs/Transmon_Pocket_Teeth.png b/docs/apidocs/Transmon_Pocket_Teeth.png
new file mode 100644
index 000000000..05eb8fed1
Binary files /dev/null and b/docs/apidocs/Transmon_Pocket_Teeth.png differ
diff --git a/docs/apidocs/qiskit_metal.qlibrary.TransmonPocketTeeth.rst b/docs/apidocs/qiskit_metal.qlibrary.TransmonPocketTeeth.rst
new file mode 100644
index 000000000..cf2b547b1
--- /dev/null
+++ b/docs/apidocs/qiskit_metal.qlibrary.TransmonPocketTeeth.rst
@@ -0,0 +1,67 @@
+﻿
+
+TransmonPocketTeeth
+=========================================
+
+.. currentmodule:: qiskit_metal.qlibrary
+
+.. autoclass:: TransmonPocketTeeth
+   :no-members:
+   :no-inherited-members:
+   :no-special-members:
+
+   
+   
+
+   .. rubric:: Attributes
+
+   .. autosummary::
+      :toctree: ../stubs/
+   
+      TransmonPocketTeeth.TOOLTIP
+      TransmonPocketTeeth.class_name
+      TransmonPocketTeeth.component_metadata
+      TransmonPocketTeeth.default_options
+      TransmonPocketTeeth.design
+      TransmonPocketTeeth.id
+      TransmonPocketTeeth.logger
+      TransmonPocketTeeth.name
+      TransmonPocketTeeth.options
+      TransmonPocketTeeth.pin_names
+      TransmonPocketTeeth.qgeometry_types
+   
+   
+
+   
+   
+
+   .. rubric:: Methods
+
+   .. autosummary::
+      :toctree: ../stubs/
+   
+      TransmonPocketTeeth.add_dependency
+      TransmonPocketTeeth.add_pin
+      TransmonPocketTeeth.add_qgeometry
+      TransmonPocketTeeth.connect_components_already_in_design
+      TransmonPocketTeeth.delete
+      TransmonPocketTeeth.get_pin
+      TransmonPocketTeeth.get_template_options
+      TransmonPocketTeeth.make
+      TransmonPocketTeeth.make_connection_pad
+      TransmonPocketTeeth.make_connection_pads
+      TransmonPocketTeeth.make_pocket
+      TransmonPocketTeeth.parse_options
+      TransmonPocketTeeth.parse_value
+      TransmonPocketTeeth.populate_to_track_table_usage
+      TransmonPocketTeeth.qgeometry_bounds
+      TransmonPocketTeeth.qgeometry_dict
+      TransmonPocketTeeth.qgeometry_list
+      TransmonPocketTeeth.qgeometry_plot
+      TransmonPocketTeeth.qgeometry_table
+      TransmonPocketTeeth.rebuild
+      TransmonPocketTeeth.to_script
+   
+
+   
+   
\ No newline at end of file
diff --git a/docs/circuit-examples/A.Qubits/010-Transmon_floating_teeth.ipynb b/docs/circuit-examples/A.Qubits/010-Transmon_floating_teeth.ipynb
new file mode 100644
index 000000000..e1f65e570
--- /dev/null
+++ b/docs/circuit-examples/A.Qubits/010-Transmon_floating_teeth.ipynb
@@ -0,0 +1,395 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Single Transmon - Floating with teeth \n",
+    "\n",
+    "We'll be creating a 2D design and adding a single transmon qcomponent with teeth.\n",
+    "\n",
+    " Create a standard pocket transmon qubit with teeth for a ground plane,\n",
+    "        with two pads connected by a junction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# So, let us dive right in. For convenience, let's begin by enabling\n",
+    "# automatic reloading of modules when they change.\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import qiskit_metal as metal\n",
+    "from qiskit_metal import designs, draw\n",
+    "from qiskit_metal import MetalGUI, Dict, open_docs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Each time you create a new quantum circuit design, \n",
+    "# you start by instantiating a QDesign class. \n",
+    "\n",
+    "# The design class `DesignPlanar` is best for 2D circuit designs.\n",
+    "\n",
+    "design = designs.DesignPlanar()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Launch Qiskit Metal GUI to interactively view, edit, and simulate QDesign: Metal GUI\n",
+    "gui = MetalGUI(design)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# To force overwrite a QComponent with an existing name.  \n",
+    "# This is useful when re-running cells in a notebook. \n",
+    "design.overwrite_enabled = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A transmon qubit with teeth\n",
+    "You can create a ready-made transmon qubit with teeth from the QComponent Library, `qiskit_metal.qlibrary.qubits`. \n",
+    "`transmon_pocket_teeth.py` is the file containing our qubit so `transmon_pocket_teeth` is the module we import. \n",
+    "The `TransmonPocketTeeth` class is our transmon qubit. Like all quantum components, `TransmonPocketTeeth` inherits from `QComponent`. \n",
+    "\n",
+    " Connector lines can be added using the `connection_pads` dictionary. \n",
+    " Each connector pad has a name and a list of default properties."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'pos_x': '0um',\n",
+       " 'pos_y': '0um',\n",
+       " 'connection_pads': {},\n",
+       " '_default_connection_pads': {'pad_gap': '15um',\n",
+       "  'pad_width': '125um',\n",
+       "  'pad_height': '30um',\n",
+       "  'pad_cpw_shift': '0um',\n",
+       "  'pad_cpw_extent': '25um',\n",
+       "  'cpw_width': '10um',\n",
+       "  'cpw_gap': '6um',\n",
+       "  'cpw_extend': '100um',\n",
+       "  'pocket_extent': '5um',\n",
+       "  'pocket_rise': '0um',\n",
+       "  'loc_W': '+1',\n",
+       "  'loc_H': '+1'},\n",
+       " 'chip': 'main',\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",
+       " 'coupled_pad_height': '150um',\n",
+       " 'coupled_pad_width': '20um',\n",
+       " 'coupled_pad_gap': '40um',\n",
+       " 'orientation': '0',\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": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from qiskit_metal.qlibrary.qubits.transmon_pocket_teeth import TransmonPocketTeeth\n",
+    "\n",
+    "# Be aware of the default_options that can be overridden by user.\n",
+    "TransmonPocketTeeth.get_template_options(design)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transmon_options = dict(\n",
+    "    pos_x = '1mm',\n",
+    "    pos_y = '2mm',\n",
+    "    orientation = '90',\n",
+    "    \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', pad_height='60um'),\n",
+    "        c = dict(loc_W=+1, loc_H=+1, pad_width='110um', cpw_extend = '50um')\n",
+    "    ),\n",
+    "    \n",
+    "    gds_cell_name='FakeJunction_01',\n",
+    ")\n",
+    "\n",
+    "# Create a new Transmon Pocket object with name 'Q1' \n",
+    "q1 = TransmonPocketTeeth(design, 'Q1', options=transmon_options)\n",
+    "\n",
+    "gui.rebuild()  # rebuild the design and plot \n",
+    "gui.autoscale() # resize GUI to see QComponent \n",
+    "gui.zoom_on_components(['Q1']) #Can also gui.zoom_on_components([q1.name]) \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's see what the Q1 object looks like"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[95m\u001b[1mname:    \u001b[94m\u001b[1mQ1\u001b[0m\n",
+       "\u001b[95m\u001b[1mclass:   \u001b[94m\u001b[1mTransmonPocketTeeth   \u001b[0m\n",
+       "\u001b[95m\u001b[1moptions: \u001b[0m\n",
+       "  'pos_x'             : '1mm',                        \n",
+       "  'pos_y'             : '2mm',                        \n",
+       "  \u001b[1m'connection_pads'   \u001b[0m: {\n",
+       "       \u001b[1m'a'                 \u001b[0m: {\n",
+       "            'pad_gap'           : '15um',                       \n",
+       "            'pad_width'         : '70um',                       \n",
+       "            'pad_height'        : '30um',                       \n",
+       "            'pad_cpw_shift'     : '0um',                        \n",
+       "            'pad_cpw_extent'    : '25um',                       \n",
+       "            'cpw_width'         : '10um',                       \n",
+       "            'cpw_gap'           : '6um',                        \n",
+       "            'cpw_extend'        : '50um',                       \n",
+       "            'pocket_extent'     : '5um',                        \n",
+       "            'pocket_rise'       : '0um',                        \n",
+       "            'loc_W'             : 1,                            \n",
+       "            'loc_H'             : -1,                           \n",
+       "                             },\n",
+       "       \u001b[1m'b'                 \u001b[0m: {\n",
+       "            'pad_gap'           : '15um',                       \n",
+       "            'pad_width'         : '125um',                      \n",
+       "            'pad_height'        : '60um',                       \n",
+       "            'pad_cpw_shift'     : '0um',                        \n",
+       "            'pad_cpw_extent'    : '25um',                       \n",
+       "            'cpw_width'         : '10um',                       \n",
+       "            'cpw_gap'           : '6um',                        \n",
+       "            'cpw_extend'        : '50um',                       \n",
+       "            'pocket_extent'     : '5um',                        \n",
+       "            'pocket_rise'       : '0um',                        \n",
+       "            'loc_W'             : -1,                           \n",
+       "            'loc_H'             : -1,                           \n",
+       "                             },\n",
+       "       \u001b[1m'c'                 \u001b[0m: {\n",
+       "            'pad_gap'           : '15um',                       \n",
+       "            'pad_width'         : '110um',                      \n",
+       "            'pad_height'        : '30um',                       \n",
+       "            'pad_cpw_shift'     : '0um',                        \n",
+       "            'pad_cpw_extent'    : '25um',                       \n",
+       "            'cpw_width'         : '10um',                       \n",
+       "            'cpw_gap'           : '6um',                        \n",
+       "            'cpw_extend'        : '50um',                       \n",
+       "            'pocket_extent'     : '5um',                        \n",
+       "            'pocket_rise'       : '0um',                        \n",
+       "            'loc_W'             : 1,                            \n",
+       "            'loc_H'             : 1,                            \n",
+       "                             },\n",
+       "                        },\n",
+       "  'chip'              : 'main',                       \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",
+       "  'coupled_pad_height': '150um',                      \n",
+       "  'coupled_pad_width' : '20um',                       \n",
+       "  'coupled_pad_gap'   : '40um',                       \n",
+       "  'orientation'       : '90',                         \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'     : 'FakeJunction_01',            \n",
+       "\u001b[95m\u001b[1mmodule:  \u001b[94m\u001b[1mqiskit_metal.qlibrary.qubits.transmon_pocket_teeth\u001b[0m\n",
+       "\u001b[95m\u001b[1mid:      \u001b[94m\u001b[1m1\u001b[0m"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "q1 #print Q1 information"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Save screenshot as a .png formatted file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "width": 500
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gui.screenshot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "tags": [
+     "nbsphinx-thumbnail"
+    ]
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "width": 500
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Screenshot the canvas only as a .png formatted file.\n",
+    "gui.figure.savefig('shot.png')\n",
+    "\n",
+    "from IPython.display import Image, display\n",
+    "_disp_ops = dict(width=500)\n",
+    "display(Image('shot.png', **_disp_ops))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Closing the Qiskit Metal GUI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gui.main_window.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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
+}
diff --git a/qiskit_metal/qlibrary/__init__.py b/qiskit_metal/qlibrary/__init__.py
index a95735049..47d0c4380 100644
--- a/qiskit_metal/qlibrary/__init__.py
+++ b/qiskit_metal/qlibrary/__init__.py
@@ -114,6 +114,7 @@
     TransmonPocket
     TransmonPocketCL
     TransmonPocket6
+    TransmonPocketTeeth
     TunableCoupler01
 
 
@@ -168,5 +169,6 @@
     from .qubits.transmon_pocket import TransmonPocket
     from .qubits.transmon_pocket_cl import TransmonPocketCL
     from .qubits.transmon_pocket_6 import TransmonPocket6
+    from .qubits.transmon_pocket_teeth import TransmonPocketTeeth
 
     from .tlines import anchored_path
diff --git a/transmon_pocket_teeth.py b/qiskit_metal/qlibrary/qubits/transmon_pocket_teeth.py
similarity index 78%
rename from transmon_pocket_teeth.py
rename to qiskit_metal/qlibrary/qubits/transmon_pocket_teeth.py
index 408a44d6b..16c3f3b4b 100644
--- a/transmon_pocket_teeth.py
+++ b/qiskit_metal/qlibrary/qubits/transmon_pocket_teeth.py
@@ -12,26 +12,8 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-
 # Contributers: Figen YILMAZ, Li-Chieh Hsiao, Dr Christian K Andersen
-
-"""Transmon Pocket 6.
-
-.. code-block::
-     _________________________________
-    |______ ____    _|_    __________|          
-    |      |____|  |___|   |____|    |
-    |        __________________      |
-    |       |                  |     |
-    |       |__________________|     |
-    |                 |              |
-    |                 x              |
-    |        _________|________      |
-    |       |                  |     |
-    |       |__________________|     |
-    |        ______                  |
-    |_______|______|                 |
-    |________________________________|
+"""Transmon Pocket Teeth.
 """
 
 import numpy as np
@@ -46,8 +28,7 @@ class TransmonPocketTeeth(BaseQubit):
     Inherits `BaseQubit` class
 
     Description:
-        Create a standard pocket transmon qubit for a ground plane.
-        Can have variable number of connection pads, up to 6. 
+        Create a standard pocket transmon qubit for a ground plane with teeth
         Here we use the 'Teeth' shape which ones connected to top pad and one connection pad.
 
     Options:
@@ -55,6 +36,7 @@ class TransmonPocketTeeth(BaseQubit):
         (e.g., '30um')
 
     Pocket:
+        * chip               - the chip
         * pos_x / pos_y      - where the center of the pocket should be located on chip
           (where the 'junction' is)
         * pad_gap            - the distance between the two charge islands, which is also the
@@ -112,7 +94,7 @@ class TransmonPocketTeeth(BaseQubit):
                                             +1
 
     .. image::
-        QComponent_Qubit_Transmon_Pocket_Teeth.png
+        Transmon_Pocket_Teeth.png
     """
 
     #_img = 'transmon_pocket1.png'
@@ -128,9 +110,11 @@ class TransmonPocketTeeth(BaseQubit):
         pad_height='90um',
         pocket_width='650um',
         pocket_height='650um',
-        coupled_pad_height='150um', # coupled_pad belongs to the teeth part and both teeth will have the same height. Teeth are symetric. 
-        coupled_pad_width='20um',   # Again for the teeth, the part on the same pad will have the same width. 
-        coupled_pad_gap='40um',     # One can arrange the gap between the teeth.
+        coupled_pad_height=
+        '150um',  # coupled_pad belongs to the teeth part and both teeth will have the same height. Teeth are symetric. 
+        coupled_pad_width=
+        '20um',  # Again for the teeth, the part on the same pad will have the same width. 
+        coupled_pad_gap='40um',  # One can arrange the gap between the teeth.
 
         # 90 has dipole aligned along the +X axis,
         # while 0 has dipole aligned along the +Y axis
@@ -158,7 +142,7 @@ class TransmonPocketTeeth(BaseQubit):
                               _qgeometry_table_junction='True')
     """Component metadata"""
 
-    TOOLTIP = """Transmon pocket with 6 connection pads."""
+    TOOLTIP = """Transmon pocket with teeth pads."""
 
     def make(self):
         """Define the way the options are turned into QGeometry.
@@ -177,44 +161,68 @@ def make_pocket(self):
 
         # self.p allows us to directly access parsed values (string -> numbers) form the user option
         p = self.p
-      #  pcop = self.p.coupled_pads[name]  # parser on connector options
+        #  pcop = self.p.coupled_pads[name]  # parser on connector options
 
         # since we will reuse these options, parse them once and define them as variables
         pad_width = p.pad_width
         pad_height = p.pad_height
         pad_gap = p.pad_gap
-        coupled_pad_height = p.coupled_pad_height 
-        coupled_pad_width = p.coupled_pad_width 
+        coupled_pad_height = p.coupled_pad_height
+        coupled_pad_width = p.coupled_pad_width
         coupled_pad_gap = p.coupled_pad_gap
 
-                                 
-
         # make the pads as rectangles (shapely polygons)
         pad = draw.rectangle(pad_width, pad_height)
-              
+
         pad_top = draw.translate(pad, 0, +(pad_height + pad_gap) / 2.)
         # Here, you make your pads round. Not sharp shape on the left and right sides and also this should be the same for the bottom pad as the top pad.
-        circ_left_top = draw.Point(-pad_width/2., +(pad_height + pad_gap) / 2.).buffer(pad_height/2, resolution=16, cap_style=CAP_STYLE.round)
-        circ_right_top = draw.Point(pad_width/2., +(pad_height + pad_gap) / 2.).buffer(pad_height/2, resolution=16, cap_style=CAP_STYLE.round)
-        # In here you create the teeth part and then you union them as one with the pad. Teeth only belong to top pad. 
-        coupled_pad = draw.rectangle(coupled_pad_width, coupled_pad_height+pad_height)
-        coupler_pad_round = draw.Point(0., (coupled_pad_height+pad_height)/2).buffer(coupled_pad_width/2, resolution=16, cap_style=CAP_STYLE.round)
+        circ_left_top = draw.Point(-pad_width / 2., +(pad_height + pad_gap) /
+                                   2.).buffer(pad_height / 2,
+                                              resolution=16,
+                                              cap_style=CAP_STYLE.round)
+        circ_right_top = draw.Point(pad_width / 2., +(pad_height + pad_gap) /
+                                    2.).buffer(pad_height / 2,
+                                               resolution=16,
+                                               cap_style=CAP_STYLE.round)
+        # In here you create the teeth part and then you union them as one with the pad. Teeth only belong to top pad.
+        coupled_pad = draw.rectangle(coupled_pad_width,
+                                     coupled_pad_height + pad_height)
+        coupler_pad_round = draw.Point(0., (coupled_pad_height + pad_height) /
+                                       2).buffer(coupled_pad_width / 2,
+                                                 resolution=16,
+                                                 cap_style=CAP_STYLE.round)
         coupled_pad = draw.union(coupled_pad, coupler_pad_round)
-        coupled_pad_left = draw.translate(coupled_pad, -(coupled_pad_width/2. + coupled_pad_gap/2.), +coupled_pad_height/2. +pad_height + pad_gap/2.-pad_height/2 )
-        coupled_pad_right = draw.translate(coupled_pad, (coupled_pad_width/2. + coupled_pad_gap/2.), +coupled_pad_height/2. +pad_height + pad_gap/2.-pad_height/2 )
+        coupled_pad_left = draw.translate(
+            coupled_pad, -(coupled_pad_width / 2. + coupled_pad_gap / 2.),
+            +coupled_pad_height / 2. + pad_height + pad_gap / 2. -
+            pad_height / 2)
+        coupled_pad_right = draw.translate(
+            coupled_pad, (coupled_pad_width / 2. + coupled_pad_gap / 2.),
+            +coupled_pad_height / 2. + pad_height + pad_gap / 2. -
+            pad_height / 2)
         pad_top_tmp = draw.union([circ_left_top, pad_top, circ_right_top])
         # The coupler pads are only created if low_W=0 and low_H=+1
         for name in self.options.connection_pads:
-            if self.options.connection_pads[name]['loc_W']==0 and self.options.connection_pads[name]['loc_H']==+1:
-                pad_top_tmp = draw.union([circ_left_top, coupled_pad_left, pad_top, coupled_pad_right, circ_right_top])
+            if self.options.connection_pads[name][
+                    'loc_W'] == 0 and self.options.connection_pads[name][
+                        'loc_H'] == +1:
+                pad_top_tmp = draw.union([
+                    circ_left_top, coupled_pad_left, pad_top, coupled_pad_right,
+                    circ_right_top
+                ])
         pad_top = pad_top_tmp
         # Round part for the bottom pad. And again you should unite all of them.
         pad_bot = draw.translate(pad, 0, -(pad_height + pad_gap) / 2.)
-        circ_left_bot = draw.Point(-pad_width/2, -(pad_height + pad_gap) / 2.).buffer(pad_height/2, resolution=16, cap_style=CAP_STYLE.round)
-        circ_right_bot = draw.Point(pad_width/2, -(pad_height + pad_gap) / 2.).buffer(pad_height/2, resolution=16, cap_style=CAP_STYLE.round)
+        circ_left_bot = draw.Point(-pad_width / 2, -(pad_height + pad_gap) /
+                                   2.).buffer(pad_height / 2,
+                                              resolution=16,
+                                              cap_style=CAP_STYLE.round)
+        circ_right_bot = draw.Point(pad_width / 2, -(pad_height + pad_gap) /
+                                    2.).buffer(pad_height / 2,
+                                               resolution=16,
+                                               cap_style=CAP_STYLE.round)
         pad_bot = draw.union([pad_bot, circ_left_bot, circ_right_bot])
 
-    
         rect_jj = draw.LineString([(0, -pad_gap / 2), (0, +pad_gap / 2)])
         # the draw.rectangle representing the josephson junction
         # rect_jj = draw.rectangle(p.inductor_width, pad_gap)
diff --git a/tutorials/Appendix C Circuit examples/A. Qubits/010-Transmon_floating_teeth.ipynb b/tutorials/Appendix C Circuit examples/A. Qubits/010-Transmon_floating_teeth.ipynb
new file mode 100644
index 000000000..13a37bcf7
--- /dev/null
+++ b/tutorials/Appendix C Circuit examples/A. Qubits/010-Transmon_floating_teeth.ipynb
@@ -0,0 +1,224 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Single Transmon - Floating with teeth \n",
+    "\n",
+    "We'll be creating a 2D design and adding a single transmon qcomponent with teeth.\n",
+    "\n",
+    " Create a standard pocket transmon qubit with teeth for a ground plane,\n",
+    "        with two pads connected by a junction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# So, let us dive right in. For convenience, let's begin by enabling\n",
+    "# automatic reloading of modules when they change.\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import qiskit_metal as metal\n",
+    "from qiskit_metal import designs, draw\n",
+    "from qiskit_metal import MetalGUI, Dict, open_docs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Each time you create a new quantum circuit design, \n",
+    "# you start by instantiating a QDesign class. \n",
+    "\n",
+    "# The design class `DesignPlanar` is best for 2D circuit designs.\n",
+    "\n",
+    "design = designs.DesignPlanar()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Launch Qiskit Metal GUI to interactively view, edit, and simulate QDesign: Metal GUI\n",
+    "gui = MetalGUI(design)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# To force overwrite a QComponent with an existing name.  \n",
+    "# This is useful when re-running cells in a notebook. \n",
+    "design.overwrite_enabled = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A transmon qubit with teeth\n",
+    "You can create a ready-made transmon qubit with teeth from the QComponent Library, `qiskit_metal.qlibrary.qubits`. \n",
+    "`transmon_pocket_teeth.py` is the file containing our qubit so `transmon_pocket_teeth` is the module we import. \n",
+    "The `TransmonPocketTeeth` class is our transmon qubit. Like all quantum components, `TransmonPocketTeeth` inherits from `QComponent`. \n",
+    "\n",
+    " Connector lines can be added using the `connection_pads` dictionary. \n",
+    " Each connector pad has a name and a list of default properties."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit_metal.qlibrary.qubits.transmon_pocket_teeth import TransmonPocketTeeth\n",
+    "\n",
+    "# Be aware of the default_options that can be overridden by user.\n",
+    "TransmonPocketTeeth.get_template_options(design)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transmon_options = dict(\n",
+    "    pos_x = '1mm',\n",
+    "    pos_y = '2mm',\n",
+    "    orientation = '90',\n",
+    "    \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', pad_height='60um'),\n",
+    "        c = dict(loc_W=+1, loc_H=+1, pad_width='110um', cpw_extend = '50um')\n",
+    "    ),\n",
+    "    \n",
+    "    gds_cell_name='FakeJunction_01',\n",
+    ")\n",
+    "\n",
+    "# Create a new Transmon Pocket object with name 'Q1' \n",
+    "q1 = TransmonPocketTeeth(design, 'Q1', options=transmon_options)\n",
+    "\n",
+    "gui.rebuild()  # rebuild the design and plot \n",
+    "gui.autoscale() # resize GUI to see QComponent \n",
+    "gui.zoom_on_components(['Q1']) #Can also gui.zoom_on_components([q1.name]) \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's see what the Q1 object looks like"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q1 #print Q1 information"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Save screenshot as a .png formatted file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "gui.screenshot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "tags": [
+     "nbsphinx-thumbnail"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "# Screenshot the canvas only as a .png formatted file.\n",
+    "gui.figure.savefig('shot.png')\n",
+    "\n",
+    "from IPython.display import Image, display\n",
+    "_disp_ops = dict(width=500)\n",
+    "display(Image('shot.png', **_disp_ops))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Closing the Qiskit Metal GUI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gui.main_window.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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
+}


Test patch:
diff --git a/qiskit_metal/tests/test_qlibrary_1_instantiate.py b/qiskit_metal/tests/test_qlibrary_1_instantiate.py
index e233bc99c..020664231 100644
--- a/qiskit_metal/tests/test_qlibrary_1_instantiate.py
+++ b/qiskit_metal/tests/test_qlibrary_1_instantiate.py
@@ -55,6 +55,7 @@
 from qiskit_metal.qlibrary.qubits.transmon_pocket import TransmonPocket
 from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
 from qiskit_metal.qlibrary.qubits.transmon_pocket_6 import TransmonPocket6
+from qiskit_metal.qlibrary.qubits.transmon_pocket_teeth import TransmonPocketTeeth
 from qiskit_metal.qlibrary.couplers.tunable_coupler_01 import TunableCoupler01
 from qiskit_metal import designs
 from qiskit_metal.qlibrary._template import MyQComponent
@@ -787,6 +788,32 @@ def test_qlibrary_qubits_transmon_pocket_6(self):
             self.fail(
                 "TransmonPocket6(design, \"my_name3\", options={}, make=False)")
 
+    def test_qlibrary_qubits_transmon_pocket_teeth(self):
+        """Test the instantiation of TransmonPocketTeeth."""
+        design = designs.DesignPlanar()
+        try:
+            TransmonPocketTeeth
+        except Exception:
+            self.fail("TransmonPocketTeeth failed")
+
+        try:
+            TransmonPocketTeeth(design, "my_name")
+        except Exception:
+            self.fail("TransmonPocketTeeth(design, \"my_name\") failed")
+
+        try:
+            TransmonPocketTeeth(design, "my_name2", options={})
+        except Exception:
+            self.fail(
+                "TransmonPocketTeeth(design, \"my_name2\", options={}) failed")
+
+        try:
+            TransmonPocketTeeth(design, "my_name3", options={}, make=False)
+        except Exception:
+            self.fail(
+                "TransmonPocketTeeth(design, \"my_name3\", options={}, make=False)"
+            )
+
     def test_qlibrary_qubits_tunable_coupler_01(self):
         """Test the instantiation of TunableCoupler01."""
         design = designs.DesignPlanar()
diff --git a/qiskit_metal/tests/test_qlibrary_2_options.py b/qiskit_metal/tests/test_qlibrary_2_options.py
index 4601fc3e7..d2dbe62b6 100644
--- a/qiskit_metal/tests/test_qlibrary_2_options.py
+++ b/qiskit_metal/tests/test_qlibrary_2_options.py
@@ -48,6 +48,7 @@
 from qiskit_metal.qlibrary.qubits import transmon_pocket
 from qiskit_metal.qlibrary.qubits import transmon_pocket_cl
 from qiskit_metal.qlibrary.qubits.transmon_pocket_6 import TransmonPocket6
+from qiskit_metal.qlibrary.qubits.transmon_pocket_teeth import TransmonPocketTeeth
 from qiskit_metal.qlibrary.couplers.tunable_coupler_01 import TunableCoupler01
 from qiskit_metal.qlibrary import _template
 from qiskit_metal.tests.assertions import AssertionsMixin
@@ -411,6 +412,50 @@ def test_qlibrary_transmon_pocket_6_options(self):
         self.assertEqual(options['_default_connection_pads']['loc_W'], '+1')
         self.assertEqual(options['_default_connection_pads']['loc_H'], '+1')
 
+    def test_qlibrary_transmon_pocket_teeth_options(self):
+        """Test that default_options of transmon_pocket_teeth were not accidentally changed."""
+        # Setup expected test results
+        design = designs.DesignPlanar()
+        transmon_pocket_teeth = TransmonPocketTeeth(design, 'my_name')
+        options = transmon_pocket_teeth.default_options
+
+        self.assertEqual(len(options), 14)
+        self.assertEqual(options['chip'], 'main')
+        self.assertEqual(options['pos_x'], '0um')
+        self.assertEqual(options['pos_y'], '0um')
+        self.assertEqual(options['pad_gap'], '30um')
+        self.assertEqual(options['inductor_width'], '20um')
+        self.assertEqual(options['pad_width'], '455um')
+        self.assertEqual(options['pad_height'], '90um')
+        self.assertEqual(options['pocket_width'], '650um')
+        self.assertEqual(options['pocket_height'], '650um')
+        self.assertEqual(options['coupled_pad_height'], '150um')
+        self.assertEqual(options['coupled_pad_width'], '20um')
+        self.assertEqual(options['coupled_pad_gap'], '40um')
+        self.assertEqual(options['orientation'], '0')
+
+        self.assertEqual(len(options['_default_connection_pads']), 12)
+        self.assertEqual(options['_default_connection_pads']['pad_gap'], '15um')
+        self.assertEqual(options['_default_connection_pads']['pad_width'],
+                         '125um')
+        self.assertEqual(options['_default_connection_pads']['pad_height'],
+                         '30um')
+        self.assertEqual(options['_default_connection_pads']['pad_cpw_shift'],
+                         '0um')
+        self.assertEqual(options['_default_connection_pads']['pad_cpw_extent'],
+                         '25um')
+        self.assertEqual(options['_default_connection_pads']['cpw_width'],
+                         '10um')
+        self.assertEqual(options['_default_connection_pads']['cpw_gap'], '6um')
+        self.assertEqual(options['_default_connection_pads']['cpw_extend'],
+                         '100um')
+        self.assertEqual(options['_default_connection_pads']['pocket_extent'],
+                         '5um')
+        self.assertEqual(options['_default_connection_pads']['pocket_rise'],
+                         '0um')
+        self.assertEqual(options['_default_connection_pads']['loc_W'], '+1')
+        self.assertEqual(options['_default_connection_pads']['loc_H'], '+1')
+
     def test_qlibrary_tunable_coupler_01_options(self):
         """Test that default_options of tunable_coupler_01 were not accidentally changed."""
         # Setup expected test results
diff --git a/qiskit_metal/tests/test_qlibrary_3_functionality.py b/qiskit_metal/tests/test_qlibrary_3_functionality.py
index 5c3bbfdb0..b7d789c3f 100644
--- a/qiskit_metal/tests/test_qlibrary_3_functionality.py
+++ b/qiskit_metal/tests/test_qlibrary_3_functionality.py
@@ -47,6 +47,7 @@
 from qiskit_metal.qlibrary.qubits import transmon_cross
 from qiskit_metal.qlibrary.qubits import transmon_cross_fl
 from qiskit_metal.qlibrary.qubits import transmon_pocket_6
+from qiskit_metal.qlibrary.qubits.transmon_pocket_teeth import TransmonPocketTeeth
 from qiskit_metal.qlibrary.couplers import tunable_coupler_01
 from qiskit_metal.tests.assertions import AssertionsMixin
 
@@ -336,6 +337,16 @@ def test_qlibrary_transmon_pocket_6_component_metadata(self):
         self.assertEqual(metadata['_qgeometry_table_path'], 'True')
         self.assertEqual(metadata['_qgeometry_table_junction'], 'True')
 
+    def test_qlibrary_transmon_pocket_teeth_component_metadata(self):
+        """Test component_metadata in qubits.transmon_pcket_teeth.py."""
+        component = TransmonPocketTeeth
+        metadata = component.component_metadata
+        self.assertEqual(len(metadata), 4)
+        self.assertEqual(metadata['short_name'], 'Pocket')
+        self.assertEqual(metadata['_qgeometry_table_poly'], 'True')
+        self.assertEqual(metadata['_qgeometry_table_path'], 'True')
+        self.assertEqual(metadata['_qgeometry_table_junction'], 'True')
+
     def test_qlibrary_transmon_coupler_01_component_metadata(self):
         """Test component_metadata in qubits.tunable_coupler_01.py."""
         component = tunable_coupler_01.TunableCoupler01