Hello,

I would like to model a 2DEG under a magnetic field and have been investigating 
the spin_orbit.py code.

I would like to modify this code so that it utilises real units and models upon 
a to-scale lattice. However, I am a little bit unclear as to how to progress.

I noticed in the base code we have a = 1, t = 1 and hbar = 2 (seen from the 
Pauli spin matrices which normally have hbar/2 as a coefficient in front). To 
represent the real life scenario of a lattice with constant a = 5E-10 m, would 
we do the following:

  *   a = 5E-10 m
  *   hbar =  1.05457E-34 J s (standard SI units)
  *   m_electron = 9.109E-31 kg (standard SI units)
  *   t = hbar ^ 2 / (2 * m_electron * a^2)

and then just substitute these values into the rest of the code?

I get the result of 0 conductivity for the lead voltages -0.046 to 0.105V (code 
shows "energies=[0.01 * i*t - 0.3*t for i in range(100)]"). I also get this for 
-0.0046 to 0.0105V and for -0.46 - 1.05V. Do these results seem right?

I have attached my code with these substitutions and the results.

Many thanks,
Nathaniel Seil

# Tutorial 2.3.1. Matrix structure of on-site and hopping elements
# ================================================================
#
# Physics background
# ------------------
#  Gaps in quantum wires with spin-orbit coupling and Zeeman splititng,
#  as theoretically predicted in
#   http://prl.aps.org/abstract/PRL/v90/i25/e256601
#  and (supposedly) experimentally oberved in
#   http://www.nature.com/nphys/journal/v6/n5/abs/nphys1626.html
#
# Kwant features highlighted
# --------------------------
#  - Numpy matrices as values in Builder

# Modified by Nathaniel Seil on 24/7/2020 to simulate 1000 x 30 array of basic atoms.
import kwant

# For plotting
from matplotlib import pyplot

# For matrix support
import tinyarray

import numpy as np

# define Pauli-matrices for convenience
hbar = 1.054571628E-34 # J s
sigma_0 = hbar/2 * tinyarray.array([[1, 0], [0, 1]])
sigma_x = hbar/2 * tinyarray.array([[0, 1], [1, 0]])
sigma_y = hbar/2 * tinyarray.array([[0, -1j], [1j, 0]])
sigma_z = hbar/2 * tinyarray.array([[1, 0], [0, -1]])


def make_system(t=1.0, alpha=0.5, e_z=0.0, W=10, L=30): # default e_z = 0.08
    # Start with an empty tight-binding system and a single square lattice.
    # `a` is the lattice constant (by default set to 1 for simplicity).
    a = 5E-10 #metres
    lat = kwant.lattice.square(a)

    syst = kwant.Builder()

    #### Define the scattering region. ####
    syst[(lat(x, y) for x in range(L) for y in range(W))] = \
        4 * t * sigma_0 + e_z * sigma_z
    # above is non-derivative components.

    syst[kwant.builder.HoppingKind((1, 0), lat, lat)] = \
        -t * sigma_0 + 1j * alpha * sigma_y / 2
    # hoppings in y-directions
    syst[kwant.builder.HoppingKind((0, 1), lat, lat)] = \
        -t * sigma_0 - 1j * alpha * sigma_x / 2

    #### Define the left lead. ####
    lead = kwant.Builder(kwant.TranslationalSymmetry((-1*a, 0)))

    lead[(lat(0, j) for j in range(W))] = 4 * t * sigma_0 + e_z * sigma_z
    # hoppings in x-direction
    lead[kwant.builder.HoppingKind((1, 0), lat, lat)] = \
        -t * sigma_0 + 1j * alpha * sigma_y / 2
    # hoppings in y-directions
    lead[kwant.builder.HoppingKind((0, 1), lat, lat)] = \
        -t * sigma_0 - 1j * alpha * sigma_x / 2

    #### Attach the leads and return the finalized system. ####
    syst.attach_lead(lead)
    syst.attach_lead(lead.reversed())

    return syst


def plot_conductance(syst, energies):
    # Compute conductance
    data = []
    for energy in energies:
        smatrix = kwant.smatrix(syst, energy)
        data.append(smatrix.transmission(1, 0))

    pyplot.figure()
    pyplot.plot(energies, data)
    pyplot.xlabel("energy [t]")
    pyplot.ylabel("conductance [e^2/h]")
#    pyplot.show()
    pyplot.savefig("author_demo_conductance.png")

def main():
    a = 5E-10 # metres
    hbar = 1.054571628E-34 # J s
    m_electron = 9.109E-31 # kg
    B = 0.001 # Teslas
    c = 2.99792458E+8 # m/s
    echarge = 1.602E-19 # C
    e_z = 2.0023/2 * hbar * echarge * B / (m_electron * c) # Hydrogen
    W = 30
    L = 1000
    alpha = 0.5
    t = (hbar ** 2)/(2*m_electron*(a**2))
    syst = make_system(t, alpha, e_z, W, L)

    # Check that the system looks as intended.
    kwant.plot(syst)

    # Finalize the system.
    syst = syst.finalized()

    # We should see non-monotonic conductance steps.
    energies=[0.01 * i*t - 0.3*t for i in range(100)]
    energies = np.array(energies)
    voltages = energies/echarge
    print(voltages)
    plot_conductance(syst, energies=energies)


# Call the main function if the script gets executed (as opposed to imported).
# See <http://docs.python.org/library/__main__.html>.
if __name__ == '__main__':
    main()

Reply via email to