first_steps.rst

First steps: setting up a simple system and computing conductance

Discretization of a Schrödinger Hamiltonian

As first example, we compute the transmission probability through a two-dimensional quantum wire. The wire is described by the two-dimensional Schrödinger equation

H = \frac{-\hbar^2}{2m}(\partial_x^2 + \partial_y^2) + V(y)

with a hard-wall confinement V(y) in the y-direction.

To be able to implement the quantum wire with Kwant, the continuous Hamiltonian H has to be discretized thus turning it into a tight-binding model. For simplicity, we discretize H on the sites of a square lattice with lattice constant a. Each site with the integer lattice coordinates (i, j) has the real-space coordinates (x, y) = (ai, aj).

Introducing the discretized positional states

\ket{i, j} \equiv \ket{ai, aj} = \ket{x, y}

the second-order differential operators can be expressed in the limit a \to 0 as

\partial_x^2 = \frac{1}{a^2} \sum_{i, j} \left(\ket{i+1, j}\bra{i, j} +
\ket{i, j}\bra{i+1, j} -2 \ket{i, j}\bra{i, j} \right),

and an equivalent expression for \partial_y^2. Subsitituting them in the Hamiltonian gives us

H = \sum_{i,j} \big[ \left(V(ai, aj) + 4t\right)\ket{i,j}\bra{i,j}
- t \big( \ket{i+1,j}\bra{i,j} + \ket{i,j}\bra{i+1,j}
+ \ket{i,j+1}\bra{i,j} + \ket{i,j}\bra{i,j+1} \big) \big]

with

t = \frac{\hbar^2}{2ma^2}.

For finite a, this discretized Hamiltonian approximates the continuous one to any required accuracy. The approximation is good for all quantum states with a wave length considerably larger than a.

The remainder of this section demonstrates how to realize the discretized Hamiltonian in Kwant and how to perform transmission calculations. For simplicity, we choose to work in such units that t = a = 1.

Transport through a quantum wire

In order to use Kwant, we need to import it:

Enabling Kwant is as easy as this [1] !

The first step is now to define 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: syst[lat(i, j)] = ... sets the on-site energy for the point (i, j), and syst[lat(i1, j1), lat(i2, j2)] = ... the hopping matrix element from point (i2, j2) to point (i1, j1). In specifying norbs=1 in the definition of the lattice we tell Kwant that there is 1 degree of freedom per lattice site.

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:

Observe how the above code corresponds directly to the terms of the discretized Hamiltonian: "On-site Hamiltonian" implements

\sum_{i,j} \left(V(ai, aj) + 4t\right)\ket{i,j}\bra{i,j}

(with zero potential). "Hopping in x-direction" implements

\sum_{i,j} -t \big( \ket{i+1,j}\bra{i,j} + \ket{i,j}\bra{i+1,j} \big),

and "Hopping in y-direction" implements

\sum_{i,j} -t \big( \ket{i,j+1}\bra{i,j} + \ket{i,j}\bra{i,j+1} \big).

The hard-wall confinement is realized by not having hoppings (and sites) beyond a certain region of space.

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 ~kwant.lattice.TranslationalSymmetry 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. The isolated, infinite is attached at the correct position using

This call returns the lead number which will be used to refer to the lead when computing transmissions (further down in this tutorial). More details about attaching leads can be found in the tutorial :ref:`tutorial-abring`.

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.

Now we have finished building our system! We plot it, to make sure we didn't make any mistakes:

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.smatrix which is a short name for kwant.solvers.default.smatrix of the default solver module kwant.solvers.default. kwant.smatrix 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). The numbering used to refer to the leads here is the same as the numbering assigned by the call to ~kwant.builder.Builder.attach_lead earlier in the tutorial.

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)

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]	https://xkcd.com/353/

[2]	Leads are numbered in the python convention, starting from 0.

Building the same system with less code

Kwant allows for more than one way to build a system. The reason is that ~kwant.builder.Builder is essentially just a container that can be filled in different ways. 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 Python script with little structure, and with everything governed by global variables. This is OK for such a simple example, but for larger projects it makes sense to partition the code into separate 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 defining the a square lattice and empty scattering region.

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 range(L) for j in range(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 lattices in Kwant is obtained using lat.neighbors(). syst[lat.neighbors()] = -t then sets all of those hopping matrix elements at once. In order to set values for all the nth-nearest neighbors at once, one can similarly use syst[lat.neighbors(n)] = -t. More detailed example of using ~kwant.builder.HoppingKind directly will be provided in :ref:`tutorial_spinorbit`.

The left lead is constructed in an analogous way:

The previous example duplicated almost identical code for the left and the right lead. The only difference was the direction of the translational symmetry vector. Here, we only construct the left lead, and use the method ~kwant.builder.Builder.reversed of ~kwant.builder.Builder to obtain a copy of a lead pointing in the opposite direction. Both leads are attached as before:

The remainder of the script proceeds identically. We first finalize the system:

and then calculate the transmission and plot:

Tips for organizing your simulation scripts

The above two examples illustrate some of the core features of Kwant, however the code was presented in a style which is good for exposition, but which is bad for making your code understandable and reusable. In this example we will lay out some best practices for writing your own simulation scripts.

In the above examples we constructed a single Kwant system, using global variables for parameters such as the lattice constant and the length and width of the system. Instead, it is preferable to create a function that you can call, and which will return a Kwant Builder:

By encapsulating system creation within make_system we document our code by telling readers that this is how we create a system, and that creating a system depends on these parameters (the length and width of the system, in this case, as well as the lattice constant and the value for the hopping parameter). By defining a function we also ensure that we can consistently create different systems (e.g. of different sizes) of the same type (rectangular slab).

We similarly encapsulate the part of the script that does computation and plotting into a function plot_conductance: