Dear Sir,
I am a PhD student of Hong Kong University of Science and Technology. I
want to use KWANT to caculate Hall resistance of a Hall bar structure.We
can get the conductance between 6 electrodes, but how to get hall
resistance? Can you give me some help? Thank you very much.
Best Regards,
Zhang Bing
Dear kwant users,
we have posted new instructions for installing kwant on Windows on the
kwant website: http://www.kwant-project.org/install
The old instructions do not work any more, as the format of the python
packages on Christoph Gohlke's webpage have changed.
Best regards,
the kwant team
Dear Christoph,
I use the following construction to connect the incommensurate
lattices: lat_e (graphene) and lat_e1 (square)
for x in list(lat_e1.shape(rectangle1, (0, 0))()):
for neighbour in lat_e.sublattices[0].n_closest(x.pos):
sys[(x, lat_e.sublattices[0](*neighbour))] = t01
for neighbour in lat_e.sublattices[1].n_closest(x.pos):
sys[(x, lat_e.sublattices[1](*neighbour))] = t01
I hope it's clear why I want to improve n_closest
Probably I can do that myself.
The above construction may indeed be in the core of readymade function
to connect
the two lattices.
Best wishes,
Sergey
Dear Joe,
Thanks, it is very useful for me. I want to know more about how the
transmission is related to the wave vector kx, because I want to calculate
the transmission contributed from some scale like kx=0~pi. So, how can i
know the wave vector for "2" in S10[3, 2] ? I tried "modes =
Smatrix.lead_info", it seems that it does not give the kx information. I
can take graphene as an example, we have two valleys K and K' in graphene.
Since the wave vectors kx for the two valleys are different, we can
calculate the transmission contributed from K valley and K' valley
separately, but of course we need to know "transmission-mode-kx" first.
Maybe this can be easily solved in another way.
Kwok-Long Lee
On Fri, Feb 6, 2015 at 8:03 PM, <kwant-discuss-request(a)kwant-project.org>
wrote:
> Send Kwant-discuss mailing list submissions to
> kwant-discuss(a)kwant-project.org
>
> To subscribe or unsubscribe via the World Wide Web, visit
> https://mailman-mail5.webfaction.com/listinfo/kwant-discuss
> or, via email, send a message with subject or body 'help' to
> kwant-discuss-request(a)kwant-project.org
>
> You can reach the person managing the list at
> kwant-discuss-owner(a)kwant-project.org
>
> When replying, please edit your Subject line so it is more specific
> than "Re: Contents of Kwant-discuss digest..."
>
>
> Today's Topics:
>
> 1. Transmission of each propagating mode (Lee Kwok-Long)
> 2. Re: Transmission of each propagating mode (Joseph Weston)
>
>
> ----------------------------------------------------------------------
>
> Message: 1
> Date: Fri, 6 Feb 2015 16:43:23 +0800
> From: Lee Kwok-Long <kwoklonglee(a)gmail.com>
> To: kwant-discuss(a)kwant-project.org
> Subject: [Kwant] Transmission of each propagating mode
> Message-ID:
> <
> CAMzfLzK0z7uFZGB54o71i8yr0hb2hf1D9GXxEhckubFYuQC5_g(a)mail.gmail.com>
> Content-Type: text/plain; charset="utf-8"
>
> Dear all,
> I want to calculate the transmission of each propagating mode separately,
> but I do not know how the propagating modes are related to the scattering
> matrix. For example, we can read from the bandstructure and find a mode at
> E=0.2，kx=0.95pi, how to find the transmission for this mode. Or, we have
> the transmission and how to find the contributions from each mode? Thanks
> in advance!
> Kwok-Long Lee
>
Dear Colleagues,
I want to measure the decay of wave-function in magnetic field. For
that I create a 2D shape
and want to attach a 1D lead to only one internal lattice site of a 2D
shape. (imagine, that this 1D chain
is pointing in the third direction, although this embedding does not
matter for physics)
Does this make sense?
There is a technical problem that 1D families differ from 2D ones and
I get a message:
"ValueError: Sites with site families (kwant.lattice.Monatomic([[1.0]],
[0.0], ''),) do not appear in the system, hence the system does not
interrupt the lead." <mailto:kwant-discuss@kwant-project.org>
Any hints?
Thank you,
Sergey
Dear Authors,
It would be convenient to improve the method
kwant.lattice.Monatomic.n_closest
to include an argument "range"
or even two arguments: range_min = 0 and range_max
so that it returns the sites within a range from the given point.
This is useful to e.g. specify the hoppings between incommensurate
lattices.
Thanks,
Sergey
Thanks a lot for you package which is rather intuitive in using!
Could you please help with understanding of the wave function which KWANT
gives?
I could not understand what kwant.wave_function gives as an output:
-- how to distinguish between the modes which are propagating in the leads
and which are decaying in the leads?
kwant.wave_function gives an answer at any energy.
(1)For example, how do get the density in some transport setup? Is this
example correct?
def Fermi(energy, T, mu):
f = 1./(1. + math.exp ( (energy - mu) / T) )
return f
def density(sys,energy,lead_nr):
wf = kwant.wave_function(sys,energy)
return (abs(wf(lead_nr))**2).sum(axis=0)
numleads = 2
Tmu = numpy.array([[Tleft,muleft],[Tright,muright]])
#assuming that this range of energies encompasses well the chemical
potential range
de = 0.05
nenergies = 100
energies=[de * (i - nenergies/2) for i in xrange(nenergies)]
for energy in energies:
for num_lead in xrange(numleads):
d = d + Fermi(energy, Tmu[num_lead]) * density(sys, energy,
num_lead)
d = d * de
(2) Another example which I do not understand properly is about transport
through a translationally invariant 2d bar.
>From physical reasoning, I would expect that the current through each link
in the direction of the current is the same.
So I tried to apply the formula (11) from the NJP-introduction to KWANT.
But I get a very different looking answers, comparing to scattering matrix
approach, as well as current throught different links in the direction of
the current is different. Why are these two answers so different and one is
not oscillating, and another is so much depends on energy?
(In 1d the comparission works well)
def Fermi(energy, T, mu):
f = 1./(1. + math.exp ( (energy - mu) / T) )
return f
#potentials in the leads
muleft = -2.
muright = 2.
mu = 0
Tleft = 0.1
Tright = 0.1
#potentials and temepratures of all leads
muTAll = []
muTAll.append([muleft,Tleft])
muTAll.append([muright,Tright])
energies = []
data = []
nenergies = 300
de = 0.032424
CurrentWave = []
CurrentLandauer = []
t = 1.
W = 6
L = 10
numleads = 2
numsite = (L-1)* W
sys = BuildSystem(t, W, L,mu,mu,mu)
#beginning and end of stm link in terms of program;
x=[]
for i1 in xrange(numsite):
x.append(sys.sites[i1].pos)
beg=[]
for i1 in xrange(numsite):
if x[i1] == [1,1]:
beg.append(i1)
end=[]
for i1 in xrange(numsite):
if x[i1] == [2,1]:
end.append(i1)
print beg, end
for imu in xrange(1):
sysFinal = BuildSystem(t, W, L, mu, mu, mu)
for ienergy in xrange(nenergies):
energy = de * ienergy - nenergies * de / 2.
energies.append(energy)
wf = kwant.wave_function(sysFinal,energy)
smatrix = kwant.smatrix(sysFinal, energy)
#wave function based calculation which can be used for any correlation
function
#iterating over number of leads
wfInside = numpy.zeros(numsite)
#wave function inside of the system
for p in xrange( numleads):
wave = wf(p)
lenwave = wave.shape [0]
for ipsi in xrange(lenwave):
wfInside = wfInside + Fermi(energy,
muTAll[p][1],muTAll[p][0] ) * wave[ipsi]
ProbeCurrent = wfInside[beg] * wfInside[end].conjugate() -
wfInside[end] * wfInside[beg].conjugate()
CurrentWave.append( ProbeCurrent[0].imag)
#Getting wave function is done
#transmission based calculation
t10 = smatrix.transmission(1, 0)
data.append(t10)
t2 = t10 * (Fermi(energy, muTAll[1][1],muTAll[1][0] ) -
Fermi(energy, muTAll[0][1],muTAll[0][0] ))
CurrentLandauer.append(t2)
plt.figure()
plt.plot(energies, CurrentLandauer)
plt.plot(energies, CurrentWave)
plt.xlabel("energy [t]")
plt.ylabel("conductance [e^2/h]")
plt.show()
def BuildSystem(t, W, L, mu, muleft, muright):
sys = kwant.Builder()
#DEFINING THE SYSTEM
a=1.
lat = kwant.lattice.square(a)
for i in xrange(L-1):
for j in xrange(W):
sys[lat(i,j)] = mu
if j > 0:
sys[lat(i,j), lat(i,j-1)] = -t
if i > 0:
sys[lat(i,j), lat(i-1,j)] = -t
#ATTACHING LEADS
#lead is pointing away from scattering region
sym_left_lead = kwant.TranslationalSymmetry((-a,0))
left_lead = kwant.Builder(sym_left_lead)
for j in xrange(W):
left_lead[lat(0,j)] = muleft
if j > 0:
#modeling large band-width in the leads, that is why 10. t
left_lead[lat(0,j), lat(0,j-1)] = - t
left_lead[lat(1,j), lat(0,j)] = - t
sys.attach_lead(left_lead)
sym_right_lead = kwant.TranslationalSymmetry((a,0))
right_lead = kwant.Builder(sym_right_lead)
for j in xrange(W):
numx = L-2
right_lead[lat(numx,j)] = muright
if j > 0:
#modeling large band-width in the leads, that is why 10. t
right_lead[lat(numx,j), lat(numx,j-1)] = - t
right_lead[lat(numx,j), lat(numx+1,j)] = - t
sys.attach_lead(right_lead)
sysFinal = sys.finalized()
t2 = time.clock()
return sysFinal
Greetings all,
I have a question regarding using kwant for very large systems. In my
research I am trying to model graphene-based devices on the order of L = W
= 500 nm. I encounter a problem when trying to simulate electron density in
these devices with Kwant.
The errors I get look like this:
Faulting application name: python.exe, version: 0.0.0.0, time stamp:
0x5488acd7
Faulting module name: _mumps.pyd, version: 0.0.0.0, time stamp: 0x54d2a92a
Exception code: 0xc00000fd
Fault offset: 0x000000000076e357
Faulting process id: 0x5018
Faulting application start time: 0x01d0811ecc4f2ba7
Faulting application path:
C:\WinPython-64bit-2.7.9.4\python-2.7.9.amd64\python.exe
Faulting module path:
C:\WinPython-64bit-2.7.9.4\python-2.7.9.amd64\lib\site-packages\kwant\linalg\_mumps.pyd
Report Id: d70446a6-ed26-11e4-9806-b8ac6f4eb471
A little info on the system: I am running 64 bit python installed from the
WinPython package. The IDE is Spyder. I've gotten all of the example codes
to work as well as several of my own (albeit for smaller versions of the
systems we would like to study).
>From the error and doing some testing with the code, I've devised that it
must be a problem occuring solver itself. I have enough memory to build the
system and I am pretty sure I am not running out of memory during the
actual solving, although I am not positive. I am wondering if the mumps
routine could be breaking for very large systems? When I run my code on a
laptop with much less ram (~60 gb for the desktop vs 4 gb on the laptop) I
end up with a memory error instead of a kernel crash.
I've attached a modified version of one of the tutorial codes, where I have
added in a LDOS/electron density calculation and increased the dimensions
of the simulation to 500x1000. The code successfully finalizes the device
on my machine, but crashes the python kernel during the actual calculation.
I can get more ram for the machine if necessary, but I want to make sure
that it isn't a problem related to the solver before sending the purchase
order to my advisor.
Kwant seems extremely nice so we're hoping to use it in our research in the
future! It is a lot better than the NEGF code I strung together in matlab!
Thank you!
Sam LaGasse
Dear Sir,
Thank you for the reply.
The main motivation of my question was ----
How the Hamiltonian of the scattering region is going into the 'sys'?
If I want to check the Hamiltonian with the help of
Hamiltonian_submatrix(), from the output matrix I am unable to understand
how the onsite and hopping terms are positioned in that matrix.
I read the post about 'Site position in hamiltonian matrix', but still I'm
not getting this.
With regards,
Sudin
Hi Sam,
I just ran the code you gave, uncommenting the LDOS calculation. It went
fine, no crash. My system is Debian GNU/Linux (Testing release) with Python
2.7.9 and Kwant version 1.0.1. My computer (laptop) has 8 Gb of RAM.
FYI, I already performed several simulations of systems containing around
10^5 sites without any issue.
Best,
Benoit
On Tue, Apr 28, 2015 at 1:08 AM, Sam LaGasse <lagassesam(a)gmail.com> wrote:
> Greetings all,
>
> I have a question regarding using kwant for very large systems. In my
> research I am trying to model graphene-based devices on the order of L = W
> = 500 nm. I encounter a problem when trying to simulate electron density in
> these devices with Kwant.
>
> The errors I get look like this:
>
> Faulting application name: python.exe, version: 0.0.0.0, time stamp:
> 0x5488acd7
> Faulting module name: _mumps.pyd, version: 0.0.0.0, time stamp: 0x54d2a92a
> Exception code: 0xc00000fd
> Fault offset: 0x000000000076e357
> Faulting process id: 0x5018
> Faulting application start time: 0x01d0811ecc4f2ba7
> Faulting application path:
> C:\WinPython-64bit-2.7.9.4\python-2.7.9.amd64\python.exe
> Faulting module path:
> C:\WinPython-64bit-2.7.9.4\python-2.7.9.amd64\lib\site-packages\kwant\linalg\_mumps.pyd
> Report Id: d70446a6-ed26-11e4-9806-b8ac6f4eb471
>
> A little info on the system: I am running 64 bit python installed from
> the WinPython package. The IDE is Spyder. I've gotten all of the example
> codes to work as well as several of my own (albeit for smaller versions of
> the systems we would like to study).
>
> From the error and doing some testing with the code, I've devised that
> it must be a problem occuring solver itself. I have enough memory to build
> the system and I am pretty sure I am not running out of memory during the
> actual solving, although I am not positive. I am wondering if the mumps
> routine could be breaking for very large systems? When I run my code on a
> laptop with much less ram (~60 gb for the desktop vs 4 gb on the laptop) I
> end up with a memory error instead of a kernel crash.
>
> I've attached a modified version of one of the tutorial codes, where I
> have added in a LDOS/electron density calculation and increased the
> dimensions of the simulation to 500x1000. The code successfully finalizes
> the device on my machine, but crashes the python kernel during the actual
> calculation.
>
> I can get more ram for the machine if necessary, but I want to make sure
> that it isn't a problem related to the solver before sending the purchase
> order to my advisor.
>
> Kwant seems extremely nice so we're hoping to use it in our research in
> the future! It is a lot better than the NEGF code I strung together in
> matlab!
>
> Thank you!
>
> Sam LaGasse
>
