dear sir,

I have tried it for 3D BHZ model but it is not working. Does it work for
only 2D system.


On Thu, Sep 12, 2019 at 1:54 PM Anton Akhmerov <anton.akhmerov...@gmail.com>
wrote:

> Great,
>
> Just to add a concluding remark: Landau fan requires a continuum
> approximation of the Hamiltonian. If you start with a tight-binding
> Hamiltonian you'd get fractal spectrum and the Hofstadter butterfly
> instead.
>
> Happy Kwanting,
> Anton
>
> On Thu, 12 Sep 2019 at 10:09, Naveen Yadav <naveengunwa...@gmail.com>
> wrote:
> >
> > The second problem is solved. I got the landau fan for BHZ model.
> > Thank you for the support.
> >
> >
> > On Thu, Sep 12, 2019, 12:46 Naveen Yadav <naveengunwa...@gmail.com>
> wrote:
> >>
> >> Dear sir,
> >>
> >> I have updated KWANT, but it shows the AttributeError: module
> 'kwant.continuum' has no attribute 'discretize_landau'. And in browser
> also, it is showing the same error. I have downloaded the landau_levels.py
> file and put it into the continuum folder. But it is not working.
> >>
> >>
> >> On Wed, Sep 11, 2019, 23:47 Naveen Yadav <naveengunwa...@gmail.com>
> wrote:
> >>>
> >>> 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 <
> anton.akhmerov...@gmail.com> 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 <naveengunwa...@gmail.com>
> 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 <abbout.a...@gmail.com>
> 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 <
> naveengunwa...@gmail.com> 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 <abbout.a...@gmail.com>
> 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 <
> naveengunwa...@gmail.com> 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
>


-- 


With Best Regards
NAVEEN YADAV
Ph.D Research Scholar
Deptt. Of Physics & Astrophysics
University Of Delhi.

Reply via email to