Dear sir,

That is exactly what I am looking for.
But in my case Hamiltonian is not polynomial in k. It contains Sine and
Cosine terms. It's a tight binding Hamiltonian having coupling  terms like
sigma_x *Sin(kx)+ sigma_y *sin(ky) and mass term in the trignometric form.
So, can I proceed by writing the trignometric terms in some lower order
polynomial terms? Does that make sense?
Please make some comment regarding this.
Thank you very much.









Naveen
Department of Physics & Astrophysics
University of Delhi
New Delhi-110007

On Wed, Sep 11, 2019, 22:18 Anton Akhmerov <[email protected]>
wrote:

> Dear Naveen,
>
> If you are dealing with a continuum Hamiltonian (so a polynomial in
> k-space), then there is a recent addition to Kwant, that allows to
> compute Landau levels. Please check out if this tutorial is what you
> are looking for:
>
> https://kwant-project.org/doc/dev/tutorial/magnetic_field#adding-magnetic-field
> (if you click the "activate thebelab" button, you can also play around
> with the code in your browser).
>
> If that suits your needs, you'd need to either install a development
> version of Kwant or just get this file:
>
> https://gitlab.kwant-project.org/kwant/kwant/blob/master/kwant/continuum/landau_levels.py
>
> Let me know if that answers your question,
> Anton
>
> On Wed, 11 Sep 2019 at 18:39, Naveen Yadav <[email protected]>
> wrote:
> >
> > Dear sir,
> >
> > I understood that this code is off no use. The leads are useless here.
> > Actually, I want to plot the Landau fan. Can KWANT  do the job here?
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> > Naveen
> > Department of Physics & Astrophysics
> > University of Delhi
> > New Delhi-110007
> >
> > On Mon, Sep 9, 2019, 00:50 Abbout Adel <[email protected]> wrote:
> >>
> >> Dear Naveen,
> >>
> >> If your concern is the program which is slow, that is not an issue
> since it takes just few minutes.
> >> Now, if you are talking about the result, I want to be sure that you
> notice that your system is not infinite as you claim in your email.
> >> You can check that by adding extra cells from the lead"
> syst.attach_lead(lead, add_cells=10)
> >> Actually, in your case, the presence of the leads is useless since at
> the end, you are just diagonalizing the Hamiltonian of the central system.
> >> If you want to study an infinite system in x and y, you need to look at
> the module "wraparound" and the example of graphene that is in the archive
> of kwant.
> >> For the magnetic field, you can use the Pierls substitution. check for
> example this paper [1]
> >>
> >> You can also think about the use of continuous Hamiltonian in kwant.
> You may find it very useful [2]
> >> I hope this helps.
> >>
> >> Regards,
> >> Adel
> >>
> >>
> >> [1]  https://arxiv.org/pdf/1601.06507.pdf
> >> [2] https://kwant-project.org/doc/1/tutorial/discretize
> >>
> >> On Sun, Sep 8, 2019 at 6:16 PM Naveen Yadav <[email protected]>
> wrote:
> >>>
> >>> Dear Sir,
> >>> Thanks for the tips. As you told, I have tried in other way also but I
> am getting the same result which are very tedious. I don't know where is
> fault.
> >>> Now the code looks like
> >>>
> >>> import kwant
> >>> import scipy.sparse.linalg as sla
> >>> import matplotlib.pyplot as plt
> >>> import tinyarray
> >>> import numpy as np
> >>> from numpy import cos, sin, pi
> >>> import cmath
> >>> from cmath import exp
> >>>
> >>> 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(a=1, L=30, W=10, H=10, t=1.0, t_x=1.0, t_y=1.0,
> t_z=1.0, lamda=0.1, beta=1.05):
> >>>     def onsite(site):
> >>>         return (t_z * cos(beta) + 2 * t) * sigma_z
> >>>
> >>>     def hoppingx(site0, site1):
> >>>         return (-0.5 * t * sigma_z - 0.5 * 1j * t_x * sigma_x)
> >>>
> >>>     def hoppingy(site0, site1):
> >>>         return -0.5 * t * sigma_z - 0.5 * 1j * t_y * sigma_y
> >>>
> >>>     def hoppingz(site0, site1, B):
> >>>         y = site1.pos[1]
> >>>         return (-0.5 * t_z * sigma_z - 0.5 * 1j * lamda * sigma_0) *
> exp(2 * pi * 1j * B * a * (y-40))
> >>>
> >>>
> >>>     syst = kwant.Builder()
> >>>     lat = kwant.lattice.cubic(a)
> >>>     syst[(lat(z, y, x) for z in range(H) for y in range(W) for x in
> range(L))] = onsite
> >>>     syst[kwant.builder.HoppingKind((1, 0, 0), lat, lat)] = hoppingz
> >>>     syst[kwant.builder.HoppingKind((0, 1, 0), lat, lat)] = hoppingy
> >>>     syst[kwant.builder.HoppingKind((0, 0, 1), lat, lat)] = hoppingx
> >>>
> >>>     lead1=kwant.Builder(kwant.TranslationalSymmetry((0,-a,0)))
> >>>     lead1[(lat(z,y,x)  for z in range(H)for y in range(W)for x in
> range(L))]=onsite
> >>>     lead1[kwant.builder.HoppingKind((1, 0, 0), lat, lat)] = hoppingz
> >>>     lead1[kwant.builder.HoppingKind((0, 1, 0), lat, lat)] = hoppingy
> >>>     lead1[kwant.builder.HoppingKind((0, 0, 1), lat, lat)] = hoppingx
> >>>
> >>>     syst.attach_lead(lead1)
> >>>     syst.attach_lead(lead1.reversed())
> >>>
> >>>     lead2=kwant.Builder(kwant.TranslationalSymmetry((-a,0,0)))
> >>>     lead2[(lat(z,y,x)  for z in range(H)for y in range(W)for x in
> range(L))]=onsite
> >>>     lead2[kwant.builder.HoppingKind((1, 0, 0), lat, lat)] = hoppingz
> >>>     lead2[kwant.builder.HoppingKind((0, 1, 0), lat, lat)] = hoppingy
> >>>     lead2[kwant.builder.HoppingKind((0, 0, 1), lat, lat)] = hoppingx
> >>>
> >>>     syst.attach_lead(lead2)
> >>>     syst.attach_lead(lead2.reversed())
> >>>     syst = syst.finalized()
> >>>     return syst
> >>>
> >>> def analyze_system(syst, Bfields):
> >>>     syst = make_system()
> >>>     kwant.plot(syst)
> >>>     energies = []
> >>>     for B in Bfields:
> >>>         #print(B)
> >>>         ham_mat = syst.hamiltonian_submatrix(params=dict(B=B),
> sparse=True)
> >>>         ev, evec = sla.eigsh(ham_mat.tocsc(), k=20, sigma=0)
> >>>         energies.append(ev)
> >>>     #print (energies)
> >>>
> >>>     plt.figure()
> >>>     plt.plot(Bfields, energies)
> >>>     plt.xlabel("magnetic field [${10^-3 h/e}$]")
> >>>     plt.ylabel("energy [t]")
> >>>
> >>>     plt.ylim(0, 0.11)
> >>>     plt.show()
> >>> def main():
> >>>     syst = make_system()
> >>>     analyze_system(syst, [B * 0.00002 for B in range(101)])
> >>> main()
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> Naveen
> >>> Department of Physics & Astrophysics
> >>> University of Delhi
> >>> New Delhi-110007
> >>>
> >>> On Sun, Sep 8, 2019, 17:37 Abbout Adel <[email protected]> wrote:
> >>>>
> >>>> Dear Naveen,
> >>>>
> >>>> Your program works fine. You have just a small problem of plotting.
> You can solve that by changing "plt.show"  by "plt.show()".
> >>>>
> >>>> Think about putting  print (B) inside the loop when you debug your
> program. That will help you for example to see if the program is running
> well, and you  can detect what may be wrong.
> >>>> Think also about returning Energies in your function. This way you
> can try potting the result outside the function you called.  Don't hesitate
> to put some extra lines in your program to follow the progress when you
> think that there is a problem.
> >>>>
> >>>>
> >>>> I hope this helps.
> >>>> Regards,
> >>>> Adel
> >>>>
> >>>> On Thu, Sep 5, 2019 at 7:32 PM Naveen Yadav <[email protected]>
> wrote:
> >>>>>
> >>>>> Dear Sir,
> >>>>>
> >>>>> I am trying to plot the energy as a function of magnetic field for a
> 3D case, but I am getting tedious results. The system is infinite in two
> directions and has some width in the third direction. Please have a look at
> the code attached below. I tried a lot but failed. Is the code correct or I
> am wrong somewhere.
> >>>>> Thank you.
> >>>>>
> >>>>>
> >>>>> import kwant
> >>>>> import scipy.sparse.linalg as sla
> >>>>> import matplotlib.pyplot as plt
> >>>>> import tinyarray
> >>>>> import numpy as np
> >>>>> from numpy import cos, sin, pi
> >>>>> import cmath
> >>>>> from cmath import exp
> >>>>>
> >>>>> 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(a=1, L=30, W=10, H=10, t=1.0, t_x=1.0, t_y=1.0,
> t_z=1.0, lamda=0.1, beta=1.05):
> >>>>>     def onsite(site):
> >>>>>         return (t_z * cos(beta) + 2 * t) * sigma_z
> >>>>>
> >>>>>     def hoppingx(site0, site1):
> >>>>>         return (-0.5 * t * sigma_z - 0.5 * 1j * t_x * sigma_x)
> >>>>>
> >>>>>     def hoppingy(site0, site1):
> >>>>>         return -0.5 * t * sigma_z - 0.5 * 1j * t_y * sigma_y
> >>>>>
> >>>>>     def hoppingz(site0, site1, B):
> >>>>>         y = site1.pos[1]
> >>>>>         return (-0.5 * t_z * sigma_z - 0.5 * 1j * lamda * sigma_0) *
> exp(2 * pi * 1j * B * a * (y-40))
> >>>>>
> >>>>>
> >>>>>     syst = kwant.Builder()
> >>>>>     lat = kwant.lattice.cubic(a)
> >>>>>     syst[(lat(z, y, x) for z in range(H) for y in range(W) for x in
> range(L))] = onsite
> >>>>>     syst[kwant.builder.HoppingKind((1, 0, 0), lat, lat)] = hoppingz
> >>>>>     syst[kwant.builder.HoppingKind((0, 1, 0), lat, lat)] = hoppingy
> >>>>>     syst[kwant.builder.HoppingKind((0, 0, 1), lat, lat)] = hoppingx
> >>>>>
> >>>>>     lead1=kwant.Builder(kwant.TranslationalSymmetry((0,-a,0)))
> >>>>>     lead1[(lat(z,y,x)  for z in range(H)for y in range(W)for x in
> range(L))]=onsite
> >>>>>     lead1[kwant.builder.HoppingKind((1, 0, 0), lat, lat)] = hoppingz
> >>>>>     lead1[kwant.builder.HoppingKind((0, 1, 0), lat, lat)] = hoppingy
> >>>>>     lead1[kwant.builder.HoppingKind((0, 0, 1), lat, lat)] = hoppingx
> >>>>>
> >>>>>     syst.attach_lead(lead1)
> >>>>>     syst.attach_lead(lead1.reversed())
> >>>>>
> >>>>>     lead2=kwant.Builder(kwant.TranslationalSymmetry((-a,0,0)))
> >>>>>     lead2[(lat(z,y,x)  for z in range(H)for y in range(W)for x in
> range(L))]=onsite
> >>>>>     lead2[kwant.builder.HoppingKind((1, 0, 0), lat, lat)] = hoppingz
> >>>>>     lead2[kwant.builder.HoppingKind((0, 1, 0), lat, lat)] = hoppingy
> >>>>>     lead2[kwant.builder.HoppingKind((0, 0, 1), lat, lat)] = hoppingx
> >>>>>
> >>>>>     syst.attach_lead(lead2)
> >>>>>     syst.attach_lead(lead2.reversed())
> >>>>>     syst = syst.finalized()
> >>>>>     return syst
> >>>>>
> >>>>> def analyze_system():
> >>>>>     syst = make_system()
> >>>>>     kwant.plot(syst)
> >>>>>     Bfields = np.linspace(0, 0.002, 100)
> >>>>>     energies = []
> >>>>>     for B in Bfields:
> >>>>>         ham_mat = syst.hamiltonian_submatrix(params=dict(B=B),
> sparse=True)
> >>>>>         ev, evec = sla.eigsh(ham_mat.tocsc(), k=20, sigma=0)
> >>>>>         energies.append(ev)
> >>>>>     #print(energies)
> >>>>>
> >>>>>     plt.figure()
> >>>>>     plt.plot(Bfields, energies)
> >>>>>     plt.xlabel("magnetic field [${10^-3 h/e}$]")
> >>>>>     plt.ylabel("energy [t]")
> >>>>>
> >>>>>     plt.ylim(0, 0.11)
> >>>>>     plt.show
> >>>>> def main():
> >>>>>     syst = make_system()
> >>>>>     analyze_system()
> >>>>> main()
> >>>>>
> >>>>>
> >>>>>
> >>>>>
> >>>>> --
> >>>>>
> >>>>>
> >>>>> With Best Regards
> >>>>> NAVEEN YADAV
> >>>>> Ph.D Research Scholar
> >>>>> Deptt. Of Physics & Astrophysics
> >>>>> University Of Delhi.
> >>>>
> >>>>
> >>>>
> >>>> --
> >>>> Abbout Adel
> >>
> >>
> >>
> >> --
> >> Abbout Adel
>

Reply via email to