I searched a lot and got the answer!
Here it is some links that helped me
Some exemples links:
https://kwant-project.org/doc/1/tutorial/spin_potential_shape.html?highlight=spin
https://kwant-project.org/doc/1/_downloads/spin_orbit.py
https://kwant-project.org/doc/1/tutorial/superconductors.html?highlight=norbs
Some forum threads links:
https://www.mail-archive.com/kwant-discuss@kwant-project.org/msg01353.html
https://kwant-discuss.kwant-project.narkive.com/96MScaQw/kwant-spin-currents-using-greens-functions#post4

Summarizing: To obtain spin up-up, up-down, down-up and down-down 
transmissions, it is required use norbs = 2 in a lattice construction and make 
the scattering matrix ordered.
Attention in lat and lead declaration
Code exemple:

import kwant
import numpy as np

# For plotting
from matplotlib import pyplot

# For matrix support
import tinyarray

# define Pauli-matrices for convenience
sigma_0 = tinyarray.array([[1, 0], [0, 1]])
sigma_x = tinyarray.array([[0, 1], [1, 0]])
sigma_y = tinyarray.array([[0, -1j], [1j, 0]])
sigma_z = tinyarray.array([[1, 0], [0, -1]])


def make_system(t=1.0, alpha=0.5, e_z=0.08, W=10, L=30):
    # Start with an empty tight-binding system and a single square lattice.
    # `a` is the lattice constant (by default set to 1 for simplicity).
    lat = kwant.lattice.square(norbs = 2) # these orbitals will be one to spin 
up and one to spin down

    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
    # hoppings in x-direction
    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, 0)), 
conservation_law=-sigma_z) # this sorts the blocks: "up" modes come first, and 
then the "down"

    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 = [] #total transmission
    data_uu = [] #up-up transmission
    data_ud = [] #up-down  transmission
    data_du = [] #down-up  transmission
    data_du = [] #down-up  transmission

    for energy in energies:
        smatrix = kwant.smatrix(syst, energy)
        t = np.matrix(smat.submatrix(1, 0)) #transmission block
        tt = np.matmul(t, t.getH()) #t*t_dagger matrix in case of especific 
cases, i prefer work with this form 
        data.append(smatrix.transmission(1, 0)) # transmission lead 0 to lead 1
        data_uu.append(smatrix.transmission((1,0), (0,0))) # transmission lead 
0 up to lead 1 up
        data_ud.append(smatrix.transmission((1,1), (0,0))) # transmission lead 
0 up to lead 1 down
        data_du.append(smatrix.transmission((1,0), (0,1))) # transmission lead 
0 down to lead 1 up
        data_dd.append(smatrix.transmission((1,0), (0,0))) # transmission lead 
0 down to lead 1 down

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

    pyplot.figure()
    pyplot.plot(energies, data_uu)
    pyplot.xlabel("energy [t]")
    pyplot.ylabel("up-up conductance [e^2/h]")
    pyplot.show()

    pyplot.figure()
    pyplot.plot(energies, data_ud)
    pyplot.xlabel("energy [t]")
    pyplot.ylabel("up-down conductance [e^2/h]")
    pyplot.show()

    pyplot.figure()
    pyplot.plot(energies, data_du)
    pyplot.xlabel("energy [t]")
    pyplot.ylabel("down-up conductance [e^2/h]")
    pyplot.show()

    pyplot.figure()
    pyplot.plot(energies, data_dd)
    pyplot.xlabel("energy [t]")
    pyplot.ylabel("down-down conductance [e^2/h]")
    pyplot.show()


def main():
    syst = make_system()

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

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

    # We should see non-monotonic conductance steps.
    plot_conductance(syst, energies=[0.01 * i - 0.3 for i in range(100)])


# 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()

Hope it helps!

Reply via email to