2.3.transport_through_barrier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transport through a barrier\n",
    "\n",
    "All systems so far had a flat potential.  In this notebook, we will change this.\n",
    "\n",
    "Basic setup (like in the previous notebook):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "autoscroll": "json-false",
    "collapsed": false,
    "ein.tags": [
     "worksheet-0"
    ]
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import kwant\n",
    "%run matplotlib_setup.ipy\n",
    "from matplotlib import pyplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lat = kwant.lattice.square()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"MOSFET\" toy model\n",
    "\n",
    "Let's construct a system like the wire of the previous notebook, except that the scattering region will have a higher (but still flat) potential.\n",
    "\n",
    "The leads are unchanged, so we take the following function directly from the previous notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "autoscroll": "json-false",
    "collapsed": false,
    "ein.tags": [
     "worksheet-0"
    ]
   },
   "outputs": [],
   "source": [
    "def make_lead_x(W=10, t=1):\n",
    "    syst = kwant.Builder(kwant.TranslationalSymmetry([-1, 0]))\n",
    "    syst[(lat(0, y) for y in range(W))] = 4 * t\n",
    "    syst[lat.neighbors()] = -t\n",
    "    return syst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": [
     "worksheet-0"
    ]
   },
   "source": [
    "The next one is slightly modified: the onsite value is now no longer a constant but a *value function*.\n",
    "\n",
    "Kwant’s value functions are used when there are parameters to the Hamiltonian.  Kwant will call them only when a calculation is requested, at the last possible moment.  The onsite function always take one arguments (the site), and an arbitrary number of parameters that are supplied by the user.  Here, there is only one such parameter: `V`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "autoscroll": "json-false",
    "collapsed": false,
    "ein.tags": [
     "worksheet-0"
    ]
   },
   "outputs": [],
   "source": [
    "def make_wire_with_flat_potential(W=10, L=2, t=1):\n",
    "    def onsite(s, V):\n",
    "        return (4 - V) * t\n",
    "\n",
    "    # Construct the scattering region.\n",
    "    sr = kwant.Builder()\n",
    "    sr[(lat(x, y) for x in range(L) for y in range(W))] = onsite\n",
    "    sr[lat.neighbors()] = -t\n",
    "\n",
    "    # Build and attach lead from both sides.\n",
    "    lead = make_lead_x(W, t)\n",
    "    sr.attach_lead(lead)\n",
    "    sr.attach_lead(lead.reversed())\n",
    "\n",
    "    return sr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function also needs to be modified slightly: instead of plotting transmission as a function of energy, it plots transmission as the function of the Hamiltonian parameter, for a fixed energy.\n",
    "\n",
    "Observe how `args=[param]` is used to pass the user-specified Hamiltonian parameters to `kwant.smatrix`.  `args` must be a sequence of parameters, even if it's only a single one in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "autoscroll": "json-false",
    "collapsed": false,
    "ein.tags": [
     "worksheet-0"
    ]
   },
   "outputs": [],
   "source": [
    "def plot_transmission(syst, energy, params):\n",
    "    # Compute conductance\n",
    "    trans = []\n",
    "    for param in params:\n",
    "        smatrix = kwant.smatrix(syst, energy, args=[param])\n",
    "        trans.append(smatrix.transmission(1, 0))\n",
    "    pyplot.plot(params, trans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's put the above functions to some use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_syst = make_wire_with_flat_potential()\n",
    "kwant.plot(_syst)\n",
    "_syst = _syst.finalized()\n",
    "kwant.plotter.bands(_syst.leads[0])\n",
    "plot_transmission(_syst, 1, np.linspace(-2, 0, 51))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Your turn!\n",
    "Play with the parameters (width of the barrier, voltage range, etc.) and see how this affects the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum point contact\n",
    "\n",
    "What will happen if we open a hole in the potential barrier?  This time we will try to use a more realistic potential.\n",
    "\n",
    "The following cell defines the potential that we are going to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import atan2, pi, sqrt\n",
    "\n",
    "def rectangular_gate_pot(distance, left, right, bottom, top):\n",
    "    \"\"\"Compute the potential of a rectangular gate.\n",
    "    \n",
    "    The gate hovers at the given distance over the plane where the\n",
    "    potential is evaluated.\n",
    "    \n",
    "    Based on J. Appl. Phys. 77, 4504 (1995)\n",
    "    http://dx.doi.org/10.1063/1.359446\n",
    "    \"\"\"\n",
    "    d, l, r, b, t = distance, left, right, bottom, top\n",
    "\n",
    "    def g(u, v):\n",
    "        return atan2(u * v, d * sqrt(u**2 + v**2 + d**2)) / (2 * pi)\n",
    "\n",
    "    def func(x, y, voltage):\n",
    "        return voltage * (g(x-l, y-b) + g(x-l, t-y) +\n",
    "                          g(r-x, y-b) + g(r-x, t-y))\n",
    "\n",
    "    return func\n",
    "\n",
    "_gate1 = rectangular_gate_pot(10, 20, 50, -50, 15)\n",
    "_gate2 = rectangular_gate_pot(10, 20, 50, 25, 90)\n",
    "def qpc_potential(site, V):\n",
    "    x, y = site.pos\n",
    "    return _gate1(x, y, V) + _gate2(x, y, V)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below is almost like `make_wire_with_flat_potential`.  The difference is that it can be tuned to use a general potential using its first parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "autoscroll": "json-false",
    "collapsed": false,
    "ein.tags": [
     "worksheet-0"
    ]
   },
   "outputs": [],
   "source": [
    "def make_barrier(pot, W=40, L=70, t=1):\n",
    "    def onsite(*args):\n",
    "        return 4 * t - pot(*args)\n",
    "\n",
    "    # Construct the scattering region.\n",
    "    sr = kwant.Builder()\n",
    "    sr[(lat(x, y) for x in range(L) for y in range(W))] = onsite\n",
    "    sr[lat.neighbors()] = -t\n",
    "\n",
    "    # Build and attach lead from both sides.\n",
    "    lead = make_lead_x(W, t)\n",
    "    sr.attach_lead(lead)\n",
    "    sr.attach_lead(lead.reversed())\n",
    "\n",
    "    return sr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's construct the system and plot the potential.  The lambda expression is used to fix the gate voltage to a particular value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "qpc = make_barrier(qpc_potential)\n",
    "kwant.plot(qpc);\n",
    "kwant.plotter.map(qpc, lambda s: qpc_potential(s, 1));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get an idea of the involved energy scales it's useful to plot the band structure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fqpc = qpc.finalized()\n",
    "kwant.plotter.bands(fqpc.leads[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's plot transmission as a function of the gate voltage.  We see the hallmark of the QPC: conductance quantization.  It's similar to what we saw in the clean wire, but now much more \"realistic\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plot_transmission(fqpc, 0.3, np.linspace(-1, 0, 101))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Your turn!\n",
    "Play with the parameters?  For example, what happens if you make the QPC potential \"shorter\"?"
   ]
  }
 ],
 "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.5.1+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}