First steps in kwant: Setting up a simple system and computing transport
Transport through a quantum wire
As first example, we compute the transmission probability through a two-dimensional quantum wire. For this we use a tight-binding model representing the two-dimensional Schroedinger equation
H = \frac{-\hbar^2}{2 m} (\partial_x^2+\partial_y^2) + V(y)
with a hard wall confinement V(y) in y-direction.
In order to use kwant, we need to import it:
Enabling kwant is as easy as this [1] !
The first step is now the definition of the system with scattering region and leads. For this we make use of the ~kwant.builder.Builder type that allows to define a system in a convenient way. We need to create an instance of it:
Observe that we just accessed ~kwant.builder.Builder by the name
kwant.Builder. We could have just as well written
kwant.builder.Builder instead. kwant consists of a number of sub-packages
that are all covered in the :doc:`reference documentation
<../reference/index>`. For convenience, some of the most widely-used members
of the sub-packages are also accessible directly through the top-level kwant
package.
Apart from ~kwant.builder.Builder we also need to specify what kind of sites we want to add to the system. Here we work with a square lattice. For simplicity, we set the lattice constant to unity:
Since we work with a square lattice, we label the points with two
integer coordinates (i, j). ~kwant.builder.Builder then
allows us to add matrix elements corresponding to lattice points:
sys[lat(i, j)] = ... sets the on-site energy for the point (i, j),
and sys[lat(i1, j1), lat(i2, j2)] = ... the hopping matrix element
from point (i2, j2) to point (i1, j1).
Note that we need to specify sites for ~kwant.builder.Builder
in the form lat(i, j). The lattice object lat does the
translation from integer coordinates to proper site format
needed in Builder (more about that in the technical details below).
We now build a rectangular scattering region that is W lattice points wide and L lattice points long:
Next, we define the leads. Leads are also constructed using ~kwant.builder.Builder, but in this case, the system must have a translational symmetry:
Here, the ~kwant.builder.Builder takes a translational symmetry as the
optional parameter. Note that the (real-space) vector (-a, 0) defining the
translational symmetry must point in a direction away from the scattering
region, into the lead -- hence, lead 0 [2] will be the left lead, extending
to infinity to the left.
For the lead itself it is enough to add the points of one unit cell as well as the hoppings inside one unit cell and to the next unit cell of the lead. For a square lattice, and a lead in y-direction the unit cell is simply a vertical line of points:
Note that here it doesn't matter if you add the hoppings to the next or the previous unit cell -- the translational symmetry takes care of that.
We also want to add a lead on the right side. The only difference to the left lead is that the vector of the translational symmetry must point to the right, the remaining code is the same:
Note that here we added points with x-coordinate 0, just as for the left lead. You might object that the right lead should be placed L (or L+1?) points to the right with respect to the left lead. In fact, you do not need to worry about that. The ~kwant.builder.Builder with ~kwant.lattice.TranslationalSymmetry represents a lead which is infinitely extended. These isolated, infinite leads can then be simply attached at the right position using:
More details about attaching leads can be found in the tutorial :ref:`tutorial-abring`.
Now we have finished building our system! We plot it, to make sure we didn't make any mistakes:
This should bring up this picture:
The system is represented in the usual way for tight-binding systems: dots represent the lattice points (i, j), and for every nonzero hopping element between points there is a line connecting these points. From the leads, only a few (default 2) unit cells are shown, with fading color.
In order to use our system for a transport calculation, we need to finalize it
Having successfully created a system, we now can immediately start to compute its conductance as a function of energy:
We use kwant.solve which is a short name for kwant.solvers.default.solve
of the default solver module kwant.solvers.default. kwant.solve computes
the scattering matrix smatrix solving a sparse linear system. smatrix
itself allows to directly compute the total transmission probability from lead
0 to lead 1 as smatrix.transmission(1, 0).
Finally we can use matplotlib to make a plot of the computed data (although writing to file and using an external viewer such as gnuplot or xmgrace is just as viable)
This should yield the result
We see a conductance quantized in units of e^2/h, increasing in steps as the energy is increased. The value of the conductance is determined by the number of occupied subbands that increases with energy.
Footnotes
| [1] | http://xkcd.com/353/ |
| [2] | Leads are numbered in the python convention, starting from 0. |
The same but different: Alternative system building
kwant is very flexible, and often allows you more than one way to build up your system. The reason is that ~kwant.builder.Builder is essentially just a container, and allows for different ways to be filled. Here we present a more compact rewrite of the previous example (still with the same results).
Also, the previous example was written in the form of a pythons script with little structure, and everything governed by global variables. This is OK for such a simple example, but for larger projects it makes sense to structure different functionality into different functional entities. In this example we therefore also aim at more structure.
We begin the program collecting all imports in the beginning of the file and put the build-up of the system into a separate function make_system:
Previously, the scattering region was build using two for-loops.
Instead, we now write:
Here, all lattice points are added at once in the first line. The
construct ((i, j) for i in xrange(L) for j in xrange(W)) is a
generator that iterates over all points in the rectangle as did the
two for-loops in the previous example. In fact, a
~kwant.builder.Builder can not only be indexed by a single
lattice point -- it also allows for lists of points, or, as in this
example, a generator (as is also used in list comprehensions in
python).
Having added all lattice points in one line, we now turn to the hoppings. In this case, an iterable like for the lattice points becomes a bit cumbersome, and we use instead another feature of kwant:
In regular lattices, hoppings form large groups such that hoppings within a
group can be transformed into one another by lattice translations. In order to
allow to easily manipulate such hoppings, an object
~kwant.builder.HoppingKind is provided. When given a ~kwant.builder.Builder as
an argument, ~kwant.builder.HoppingKind yields all the hoppings of a
certain kind that can be added to this builder without adding new sites. When
~kwant.builder.HoppingKind is given to ~kwant.builder.Builder as a key, it
means that something is done to all the possible hoppings of this kind. A list
of ~kwant.builder.HoppingKind objects corresponding to nearest neighbors in
pre-defined lattices in kwant (that is ~kwant.lattice.chain,
~kwant.lattice.square, and ~kwant.lattice.honeycomb) is stored in
lat.nearest. sys[lat.nearest] = -t then sets all of those hopping
matrix elements at once. More detailed example of using
~kwant.builder.HoppingKind directly will be provided in
:ref:`tutorial_spinorbit`.
The leads can be constructed in an analogous way:
Note that in the previous example, we essentially used the same code for the right and the left lead, the only difference was the direction of the translational symmetry vector. The ~kwant.builder.Builder used for the lead provides a method ~kwant.builder.Builder.reversed that returns a copy of the lead, but with it's translational vector reversed. This can thus be used to obtain a lead pointing in the opposite direction, i.e. makes a right lead from a left lead:
The remainder of the code is identical to the previous example (except for a bit of reorganization into functions):
and
Finally, we use a python trick to make our example usable both
as a script, as well as allowing it to be imported as a module.
We collect all statements that should be executed in the script
in a main-function:
Finally, we use the following python construct [3] that executes
main if the program is used as a script (i.e. executed as
python tutorial1b.py):
If the example however is imported using import tutorial1b,
main is not executed automatically. Instead, you can execute it
manually using tutorial1b.main(). On the other hand, you also
have access to the other functions, make_system and
plot_conductance, and can thus play with the parameters.
The result of the example should be identical to the previous one.
Footnotes
| [3] | http://docs.python.org/library/__main__.html |