junction_array_capacitance_to_GND.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [
     4,
     7,
     10
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: TkAgg\n"
     ]
    }
   ],
   "source": [
    "%matplotlib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def get_cap_series(C1, C2):\n",
    "     return C1*C2 / (C1 + C2)\n",
    " \n",
    "def get_cap_parallel(C1, C2):\n",
    "    return C1 + C2\n",
    "\n",
    "def get_junction_chain_capacitance(Cj1, Cj2, Cj_gnd, n, C_load):\n",
    "    \"\"\"\n",
    "    Calculate the capacitance of a junction array to GND.\n",
    "    Note the connecting leads at the beginning and end are not included. \n",
    "            n=1           n=2       ...  n=N\n",
    "            Cj1     Cj2   Cj1     Cj2    Cj1\n",
    "         ---||-----||-----||-----||  ... ||--- \n",
    "                |      |                    |\n",
    "                =      = Cj_GND             =   C_load(only last one)\n",
    "                |      |                    |\n",
    "         ------------------------------------- GND\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    Cj1 : float\n",
    "        Junction capacitance. 50~100 fF/um^2\n",
    "    Cj2 : float\n",
    "        parasitic junction capacitance\n",
    "    Cj_gnd : float\n",
    "        capacitance between a parasitic junction and GND\n",
    "    n : int\n",
    "        number of junctions.\n",
    "    C_load : float\n",
    "        capacitance of load to GND\n",
    "    Returns\n",
    "    -------\n",
    "    float\n",
    "        capacitance\n",
    "\n",
    "    \"\"\"\n",
    "         \n",
    "    if not isinstance(n, int):\n",
    "        raise TypeError('n must be integer!!!')\n",
    "    if n==1:\n",
    "        return get_cap_series(Cj1, C_load)\n",
    "    else:\n",
    "        C_n_minus_1 = get_junction_chain_capacitance(Cj1, Cj2, Cj_gnd, n-1, C_load)\n",
    "        C_n = get_cap_series(Cj1, get_cap_parallel(\n",
    "            Cj_gnd, get_cap_series(Cj2, get_cap_parallel(\n",
    "                Cj_gnd,C_n_minus_1))))\n",
    "        return C_n\n",
    "    \n",
    "def get_single_JJ_capacitance(Cj1, Cj2, Cj_gnd, C_load):\n",
    "    \"\"\"\n",
    "    Calculate the capacitance of a single JJ + two leads to GND for three cases.\n",
    "    Most likely, the third one would be the right one.\n",
    "                    Cj1          Cj2               \n",
    "         ----------||------------||--------------\n",
    "              |           |           |         |\n",
    "              = 2*Cj_gnd  = Cj_gnd    = Cj_gnd  = C_load\n",
    "              |           |           |         |   \n",
    "         ----------------------------------------------- GND\n",
    "    \n",
    "                    Cj2          Cj1   \n",
    "         ----------||------------||---------------\n",
    "              |           |           |          |        \n",
    "              = Cj_gnd    = Cj_gnd    = 2*Cj_gnd = C_load\n",
    "              |           |           |          |          \n",
    "         ----------------------------------------------- GND\n",
    "    \n",
    "                    Cj1               \n",
    "         ----------||------------------\n",
    "              |           |           |\n",
    "              = 2*Cj_gnd  = 2*Cj_gnd  = C_load\n",
    "              |           |           |          \n",
    "         ----------------------------------------------- GND\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    Cj1 : float\n",
    "        Junction capacitance. 50~100 fF/um^2\n",
    "    Cj2 : float\n",
    "        parasitic junction capacitance\n",
    "    Cj_gnd : float\n",
    "        capacitance between a parasitic junction and GND\n",
    "    C_load : float\n",
    "        capacitance of load to GND\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    float\n",
    "        capacitance\n",
    "\n",
    "    \"\"\"\n",
    "    a0 = get_cap_parallel(Cj_gnd, C_load)        \n",
    "    a1 = get_cap_series(Cj2, a0)\n",
    "    a2 = get_cap_parallel(Cj_gnd, a1)\n",
    "    a3 = get_cap_series(Cj1, a2)\n",
    "    a4 = get_cap_parallel(2*Cj_gnd, a3)\n",
    "        \n",
    "    b0 = get_cap_parallel(2*Cj_gnd, C_load)        \n",
    "    b1 = get_cap_series(Cj1, b0)\n",
    "    b2 = get_cap_parallel(Cj_gnd, b1)\n",
    "    b3 = get_cap_series(Cj2, b2)\n",
    "    b4 = get_cap_parallel(Cj_gnd, b3)\n",
    "        \n",
    "    c0 = get_cap_parallel(2*Cj_gnd, C_load)        \n",
    "    c1 = get_cap_series(Cj1, c0)\n",
    "    c2 = get_cap_parallel(2*Cj_gnd, c1)\n",
    "  \n",
    "    \n",
    "    return a4, b4, c2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Junction array behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f61a7014ca0>"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Cj1 = 10  # fF\n",
    "Cj2_list = Cj1 * np.array([2,5,10,20])\n",
    "Cj_gnd_list = np.linspace(0.01, 100, 51)\n",
    "C_load = 1\n",
    "n = 10\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize=(8,6))\n",
    "for Cj2 in Cj2_list:\n",
    "    island_cap_list = [get_junction_chain_capacitance(Cj1, Cj2, Cj_gnd, n, C_load) for Cj_gnd in Cj_gnd_list]\n",
    "    ax.plot(Cj_gnd_list, island_cap_list, label=f'Cj2={Cj2} fF')\n",
    "ax.set_xlabel('Cj_gnd (fF)',fontsize=18)\n",
    "ax.set_ylabel(r'Total capacitance (fF)',fontsize=18)\n",
    "ax.tick_params(axis='x', labelsize=18)\n",
    "ax.tick_params(axis='y', labelsize=18)\n",
    "ax.set_title(f'Cj1 = {Cj1:.1f} fF, # of junction = {n}, C_load={C_load:.1f} fF', fontsize=18)\n",
    "ax.grid()\n",
    "ax.legend(fontsize=18, loc=4)\n",
    "\n",
    "Cj1 = 10  # fF\n",
    "Cj2 = Cj1 * 10\n",
    "Cj_gnd_list = [0.05, 0.1, 0.5, 1, 5 ] #np.linspace(0.01, 10, 11)\n",
    "n_list  = range(1, 20)\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize=(8,6))\n",
    "for Cj_gnd in Cj_gnd_list:\n",
    "    island_cap_list = [get_junction_chain_capacitance(Cj1, Cj2, Cj_gnd, n, C_load) for n in n_list]\n",
    "    ax.plot(n_list, island_cap_list, '-o', label=f'Cj_gnd={Cj_gnd} fF')\n",
    "ax.set_xlabel('# of junctions',fontsize=18)\n",
    "ax.set_ylabel(r'Total capacitance (fF)',fontsize=18)\n",
    "ax.tick_params(axis='x', labelsize=18)\n",
    "ax.tick_params(axis='y', labelsize=18)\n",
    "ax.set_xlim([0,20.5])\n",
    "ax.set_title(f'Cj1 = {Cj1:.1f} fF, Cj2 = {Cj2:.1f} fF, C_load={C_load:.1f} fF', fontsize=18)\n",
    "ax.grid()\n",
    "ax.legend(fontsize=18, loc=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.242128925892423"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Cj1  = 10\n",
    "Cj2 = 100\n",
    "Cj_gnd = 0.35\n",
    "C_load = 50\n",
    "n = 10\n",
    "get_junction_chain_capacitance(Cj1, Cj2, Cj_gnd,n, C_load)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Single JJ behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f61a426fdc0>"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Cj1  = 1.4\n",
    "Cj2 = 14\n",
    "Cj_gnd_list = np.array([0.1, 0.5, 1,2])\n",
    "C_load_list = np.linspace(0.01,5, 101)\n",
    "get_single_JJ_capacitance(Cj1, Cj2, Cj_gnd, C_load)\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize=(8,6))\n",
    "for Cj_gnd in Cj_gnd_list:\n",
    "    cap = np.array([get_single_JJ_capacitance(Cj1, Cj2, Cj_gnd, C_load)[2] for C_load in C_load_list])\n",
    "    ax.plot(C_load_list, cap, label=f'Cj_gnd={Cj_gnd:.1f}')\n",
    "ax.set_xlabel('C_load (fF)',fontsize=18)\n",
    "ax.set_ylabel(r'Total capacitance (fF)',fontsize=18)\n",
    "ax.tick_params(axis='x', labelsize=18)\n",
    "ax.tick_params(axis='y', labelsize=18)\n",
    "ax.set_title(f'Cj1 = {Cj1:.1f} fF', fontsize=18)\n",
    "ax.grid()\n",
    "ax.legend(fontsize=18, loc=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Single JJ + junction array arm capacitance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7ff17ef3efd0>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# small JJ\n",
    "Cj1_s = 1.7\n",
    "Cj2_s = 2*Cj1_s\n",
    "Cj_gnd_s = 0.05\n",
    "\n",
    "# junction array\n",
    "Cj1_a = 10\n",
    "Cj2_a = 2*Cj1_a\n",
    "Cj_gnd_a = 0.05\n",
    "n = 10\n",
    "\n",
    "C_pad = 0.5 # capacitance of pad to gnd that connects small JJ and junction arraay\n",
    "C_load = 50  # capacitance of whatever connected at the end of either small jj or array.\n",
    "\n",
    "# define sweep\n",
    "# sweep_list = np.linspace(0.1, 100, 201)\n",
    "sweep_list = np.linspace(0.01, 1, 101)\n",
    "# sweep_str = 'C_load'\n",
    "# sweep_str = 'Cj_gnd_a, Cj_gnd_s'\n",
    "sweep_str = 'Cj_gnd_a'\n",
    "# C_load = sweep_list\n",
    "Cj_gnd_a = sweep_list\n",
    "# Cj_gnd_s = sweep_list\n",
    "\n",
    "JJ_array = get_junction_chain_capacitance(Cj1_a, Cj2_a, Cj_gnd_a, n, C_load)\n",
    "single_and_array = get_single_JJ_capacitance(Cj1_s, Cj2_s, Cj_gnd_s\n",
    "                                             , get_cap_parallel(C_pad, JJ_array)\n",
    "                                            )[2]\n",
    "\n",
    "single_JJ = get_single_JJ_capacitance(Cj1_s, Cj2_s, Cj_gnd_s, C_load)[2]\n",
    "array_and_single = get_junction_chain_capacitance(Cj1_a, Cj2_a, Cj_gnd_a, n\n",
    "                                                  , get_cap_parallel(C_pad, single_JJ)\n",
    "                                                 )\n",
    "\n",
    "# plot\n",
    "fig, ax = plt.subplots(1,1, figsize=(9,7))\n",
    "ax.plot(sweep_list, single_and_array, label=f'single + array')\n",
    "ax.plot(sweep_list, array_and_single, label=f'array + single')\n",
    "ax.set_xlabel(sweep_str + ' (fF)',fontsize=18)\n",
    "ax.set_ylabel(r'Total capacitance (fF)',fontsize=18)\n",
    "ax.tick_params(axis='x', labelsize=18)\n",
    "ax.tick_params(axis='y', labelsize=18)\n",
    "ax.set_title(f'small JJ, Cj1 = {Cj1_s:.1f} fF, Cj2 = {Cj1_s:.1f} fF\\n \\\n",
    "            array, Cj1 = {Cj1_a:.1f} fF, Cj2 = {Cj2_a:.1f} fF, n = {n}\\n \\\n",
    "            C_pad = {C_pad:.1f}, C_load = {C_load:.1f}', fontsize=18)\n",
    "ax.grid()\n",
    "ax.legend(fontsize=18, loc=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "single + array = 1.218 fF\n"
     ]
    }
   ],
   "source": [
    "# small JJ\n",
    "Cj1_s = 1.7\n",
    "Cj2_s = 20 * Cj1_s\n",
    "Cj_gnd_s = 0.15\n",
    "\n",
    "# junction array\n",
    "Cj1_a = 10\n",
    "Cj2_a = 2 *  Cj2_a\n",
    "Cj_gnd_a = 0.15\n",
    "n = 10\n",
    "\n",
    "C_pad = 0\n",
    "C_load = 50  # capacitance of whatever connected at the end.\n",
    "\n",
    "C_center_island = 0.5\n",
    "\n",
    "JJ_array = get_junction_chain_capacitance(Cj1_a,Cj2_a,Cj_gnd_a, n, C_load)\n",
    "single_and_array = get_single_JJ_capacitance(Cj1_s, Cj2_s, Cj_gnd_s\n",
    "                                             , get_cap_parallel(C_pad, JJ_array)\n",
    "                                            )[2]\n",
    "\n",
    "single_JJ = get_single_JJ_capacitance(Cj1_s, Cj2_s, Cj_gnd_s,C_load)[2]\n",
    "array_and_single = get_junction_chain_capacitance(Cj1_a, Cj2_a, Cj_gnd_a, n\n",
    "                                                  , get_cap_parallel(C_pad, single_JJ)\n",
    "                                                 )\n",
    "\n",
    "print(f'single + array = {single_and_array:.3f} fF')\n",
    "# print(f'center island =  {C_center_island:.3f} fF')\n",
    "# print(f'total = {single_and_array+C_center_island:.3f} fF\\n')\n",
    "      \n",
    "# print(f'array + single = {array_and_single:.3f} fF')\n",
    "# print(f'center island =  {C_center_island:.3f} fF')\n",
    "# print(f'total = {array_and_single+C_center_island:.3f} fF')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.constants import h, e, k, hbar, epsilon_0\n",
    "\n",
    "def K_to_C(temperature):\n",
    "    \"\"\" Kelvin to capacitance assuming 2e charging energy\"\"\"\n",
    "    energy = k * temperature\n",
    "    \n",
    "    return (2*e)**2/2/energy\n",
    "\n",
    "def C_to_K(cap):\n",
    "    \"\"\" Capacitance to Kelvin assuming 2e charging energy\"\"\"\n",
    "    charging_energy = (2*e)**2 / 2/cap\n",
    "    \n",
    "    return charging_energy / k\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.3240617425915424"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C_to_K((1.6)*1e-15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.4719999999999995"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.6+1.218*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}