def dos2d(h,use_kpm=True,scale=10.,nk=20,npol=100,ntries=100,delta=None, ndos=100): """ Calculate density of states of a 1d system""" if h.dimensionality!=2: raise # only for 2d ks = [] for ik in np.linspace(0.,1.,nk,endpoint=False): for jk in np.linspace(0.,1.,nk,endpoint=False): ks.append(np.array([ik,jk])) # add point if not use_kpm: # conventional method hkgen = h.get_hk_gen() # get generator delta = 16./(nk*h.intra.shape[0]) # smoothing calculate_dos_hkgen(hkgen,ks,ndos=ndos,delta=delta) # conventiona algorithm else: # use the kpm h.turn_sparse() # turn the hamiltonian sparse hkgen = h.get_hk_gen() # get generator mus = np.array([0.0j for i in range(2*npol)]) # initialize polynomials import kpm for k in ks: # loop over kpoints hk = hkgen(k) # hamiltonian mus += kpm.random_trace(hk/scale,ntries=ntries,n=npol) mus /= len(ks) # normalize by the number of kpoints xs = np.linspace(-0.9,0.9,npol) # x points ys = kpm.generate_profile(mus,xs) # generate the profile write_dos(xs*scale,ys) # write in file return
def kdos1d_sites(h, sites=[0], scale=10., nk=100, npol=100, kshift=0., ewindow=None, info=False): """ Calculate kresolved density of states of a 1d system for a certain orbitals""" if h.dimensionality != 1: raise # only for 1d ks = np.linspace(0., 1., nk) # number of kpoints h.turn_sparse() # turn the hamiltonian sparse hkgen = h.get_hk_gen() # get generator if ewindow is None: xs = np.linspace(-0.9, 0.9, nk) # x points else: xs = np.linspace(-ewindow / scale, ewindow / scale, nk) # x points import kpm write_kdos() # initialize file for k in ks: # loop over kpoints mus = np.array([0.0j for i in range(2 * npol)]) # initialize polynomials hk = hkgen(k + kshift) # hamiltonian for isite in sites: mus += kpm.local_dos(hk / scale, i=isite, n=npol) ys = kpm.generate_profile(mus, xs) # generate the profile write_kdos(k, xs * scale, ys, new=False) # write in file (append) if info: print("Done", k)
def dos0d_kpm(h, use_kpm=True, scale=10, npol=100, ntries=100): """ Calculate density of states of a 1d system""" if h.dimensionality != 0: raise # only for 0d if not use_kpm: raise # only using KPM h.turn_sparse() # turn the hamiltonian sparse mus = np.array([0.0j for i in range(2 * npol)]) # initialize polynomials import kpm mus = kpm.random_trace(h.intra / scale, ntries=ntries, n=npol) xs = np.linspace(-0.9, 0.9, 4 * npol) # x points ys = kpm.generate_profile(mus, xs) # generate the profile write_dos(xs * scale, ys) # write in file
def dos0d_kpm(h,use_kpm=True,scale=10,npol=100,ntries=100,fun=None): """ Calculate density of states of a 1d system""" if h.dimensionality!=0: raise # only for 0d if not use_kpm: raise # only using KPM h.turn_sparse() # turn the hamiltonian sparse mus = np.array([0.0j for i in range(2*npol)]) # initialize polynomials import kpm mus = kpm.random_trace(h.intra/scale,ntries=ntries,n=npol,fun=fun) xs = np.linspace(-0.9,0.9,4*npol) # x points ys = kpm.generate_profile(mus,xs) # generate the profile write_dos(xs*scale,ys) # write in file
def dos2d(h, use_kpm=False, scale=10., nk=100, ntries=1, delta=None, ndos=500, numw=20, random=True, kpm_window=1.0): """ Calculate density of states of a 2d system""" if h.dimensionality != 2: raise # only for 2d ks = [] from klist import kmesh ks = kmesh(h.dimensionality, nk=nk) if random: ks = [np.random.random(2) for ik in ks] print("Random k-mesh") if not use_kpm: # conventional method hkgen = h.get_hk_gen() # get generator if delta is None: delta = 6. / nk # conventiona algorithm calculate_dos_hkgen(hkgen, ks, ndos=ndos, delta=delta, is_sparse=h.is_sparse, numw=numw) else: # use the kpm npol = ndos // 10 h.turn_sparse() # turn the hamiltonian sparse hkgen = h.get_hk_gen() # get generator mus = np.array([0.0j for i in range(2 * npol)]) # initialize polynomials import kpm tr = timing.Testimator("DOS") ik = 0 for k in ks: # loop over kpoints # print("KPM DOS at k-point",k) ik += 1 tr.remaining(ik, len(ks)) if random: kr = np.random.random(2) print("Random sampling in DOS") hk = hkgen(kr) # hamiltonian else: hk = hkgen(k) # hamiltonian mus += kpm.random_trace(hk / scale, ntries=ntries, n=npol) mus /= len(ks) # normalize by the number of kpoints xs = np.linspace(-0.9, 0.9, ndos) * kpm_window # x points ys = kpm.generate_profile(mus, xs) # generate the profile write_dos(xs * scale, ys) # write in file return (xs, ys)
def dos0d_sites(h,sites=[0],scale=10.,npol=500,ewindow=None,refine_e=1.0): """ Calculate density of states of a 1d system for a certain orbitals""" if h.dimensionality!=0: raise # only for 1d h.turn_sparse() # turn the hamiltonian sparse mus = np.array([0.0j for i in range(2*npol)]) # initialize polynomials import kpm hk = h.intra # hamiltonian for isite in sites: mus += kpm.local_dos(hk/scale,i=isite,n=npol) if ewindow is None: xs = np.linspace(-0.9,0.9,int(npol*refine_e)) # x points else: xs = np.linspace(-ewindow/scale,ewindow/scale,npol) # x points ys = kpm.generate_profile(mus,xs) # generate the profile write_dos(xs*scale,ys) # write in file
def dos1d(h,use_kpm=True,scale=10.,nk=100,npol=100,ntries=100): """ Calculate density of states of a 1d system""" if h.dimensionality!=1: raise # only for 1d if not use_kpm: raise # only using KPM ks = np.linspace(0.,1.,nk,endpoint=False) # number of kpoints h.turn_sparse() # turn the hamiltonian sparse hkgen = h.get_hk_gen() # get generator mus = np.array([0.0j for i in range(2*npol)]) # initialize polynomials import kpm for k in ks: # loop over kpoints hk = hkgen(k) # hamiltonian mus += kpm.random_trace(hk/scale,ntries=ntries,n=npol) mus /= nk # normalize by the number of kpoints xs = np.linspace(-0.9,0.9,4*npol) # x points ys = kpm.generate_profile(mus,xs) # generate the profile write_dos(xs*scale,ys) # write in file
def dos1d(h, use_kpm=True, scale=10., nk=100, npol=100, ntries=100): """ Calculate density of states of a 1d system""" if h.dimensionality != 1: raise # only for 1d if not use_kpm: raise # only using KPM ks = np.linspace(0., 1., nk, endpoint=False) # number of kpoints h.turn_sparse() # turn the hamiltonian sparse hkgen = h.get_hk_gen() # get generator mus = np.array([0.0j for i in range(2 * npol)]) # initialize polynomials import kpm for k in ks: # loop over kpoints hk = hkgen(k) # hamiltonian mus += kpm.random_trace(hk / scale, ntries=ntries, n=npol) mus /= nk # normalize by the number of kpoints xs = np.linspace(-0.9, 0.9, 4 * npol) # x points ys = kpm.generate_profile(mus, xs) # generate the profile write_dos(xs * scale, ys) # write in file
def dos1d_sites(h,sites=[0],scale=10.,nk=100,npol=100,info=False,ewindow=None): """ Calculate density of states of a 1d system for a certain orbitals""" if h.dimensionality!=1: raise # only for 1d ks = np.linspace(0.,1.,nk,endpoint=False) # number of kpoints h.turn_sparse() # turn the hamiltonian sparse hkgen = h.get_hk_gen() # get generator mus = np.array([0.0j for i in range(2*npol)]) # initialize polynomials import kpm for k in ks: # loop over kpoints hk = hkgen(k) # hamiltonian for isite in sites: mus += kpm.local_dos(hk/scale,i=isite,n=npol) if info: print("Done",k) mus /= nk # normalize by the number of kpoints if ewindow is None: xs = np.linspace(-0.9,0.9,npol) # x points else: xs = np.linspace(-ewindow/scale,ewindow/scale,npol) # x points ys = kpm.generate_profile(mus,xs) # generate the profile write_dos(xs*scale,ys) # write in file
def kdos1d_sites(h,sites=[0],scale=10.,nk=100,npol=100,kshift=0., ewindow=None,info=False): """ Calculate kresolved density of states of a 1d system for a certain orbitals""" if h.dimensionality!=1: raise # only for 1d ks = np.linspace(0.,1.,nk) # number of kpoints h.turn_sparse() # turn the hamiltonian sparse hkgen = h.get_hk_gen() # get generator if ewindow is None: xs = np.linspace(-0.9,0.9,nk) # x points else: xs = np.linspace(-ewindow/scale,ewindow/scale,nk) # x points import kpm write_kdos() # initialize file for k in ks: # loop over kpoints mus = np.array([0.0j for i in range(2*npol)]) # initialize polynomials hk = hkgen(k+kshift) # hamiltonian for isite in sites: mus += kpm.local_dos(hk/scale,i=isite,n=npol) ys = kpm.generate_profile(mus,xs) # generate the profile write_kdos(k,xs*scale,ys,new=False) # write in file (append) if info: print "Done",k
def dos1d_sites(h, sites=[0], scale=10., nk=100, npol=100, info=False, ewindow=None): """ Calculate density of states of a 1d system for a certain orbitals""" if h.dimensionality != 1: raise # only for 1d ks = np.linspace(0., 1., nk, endpoint=False) # number of kpoints h.turn_sparse() # turn the hamiltonian sparse hkgen = h.get_hk_gen() # get generator mus = np.array([0.0j for i in range(2 * npol)]) # initialize polynomials import kpm for k in ks: # loop over kpoints hk = hkgen(k) # hamiltonian for isite in sites: mus += kpm.local_dos(hk / scale, i=isite, n=npol) if info: print "Done", k mus /= nk # normalize by the number of kpoints if ewindow is None: xs = np.linspace(-0.9, 0.9, npol) # x points else: xs = np.linspace(-ewindow / scale, ewindow / scale, npol) # x points ys = kpm.generate_profile(mus, xs) # generate the profile write_dos(xs * scale, ys) # write in file
def write_surface_kpm(h, ne=400, klist=None, scale=4., npol=200, w=20, ntries=20): """Write the surface DOS using the KPM""" if klist is None: klist = np.linspace(-.5, .5, 50) import kpm fo = open("KDOS.OUT", "w") # open file for k in klist: print("Doing kpoint", k) if h.dimensionality == 2: (intra, inter) = h.kchain(k) # k hamiltonian (es, ds, dsb) = kpm.edge_dos(intra, inter, scale=scale, w=w, npol=npol, ne=ne, bulk=True) # if the Hamiltonian is 1d from the beginning elif h.dimensionality == 1: intra, inter = h.intra, h.inter # 1d hamiltonian dd = h.intra.shape[0] # dimension inde = np.zeros(dd) # array with zeros indb = np.zeros(dd) # array with zeros for i in range(dd // 10): # one tenth inde[i] = 1. # use this one indb[4 * dd // 10 + i] = 1. # use this one def gedge(): return (np.random.random(len(inde)) - 0.5) * inde def gbulk(): return (np.random.random(len(indb)) - 0.5) * (indb) # hamiltonian h0 = intra + inter * np.exp(1j * np.pi * 2. * k) + ( inter * np.exp(1j * np.pi * 2. * k)).H xs = np.linspace(-0.9, 0.9, 4 * npol) # x points es = xs * scale # calculate the bulk mus = kpm.random_trace(h0 / scale, ntries=ntries, n=npol, fun=gbulk) dsb = kpm.generate_profile(mus, xs) # generate the profile # calculate the edge mus = kpm.random_trace(h0 / scale, ntries=ntries, n=npol, fun=gedge) ds = kpm.generate_profile(mus, xs) # generate the profile else: raise for (e, d1, d2) in zip(es, ds, dsb): fo.write( str(k) + " " + str(e) + " " + str(d1) + " " + str(d2) + "\n") fo.close()
import numpy as np import pylab as py import time from numpy.random import random import geometry g = geometry.chain() nrep = 40 g = g.supercell(nrep) h = g.get_hamiltonian() m = h.intra m = m/6. points = 200 # number of polynomials t1 = time.clock() musp = kpm.full_trace(m,use_fortran=False) # full trace t2 = time.clock() musf = kpm.full_trace(m,use_fortran=True) # full trace t3 = time.clock() print "FORTRAN ",t3-t2 print "Python ",t2-t1 x = np.linspace(-.9,.9,points*10) yp = kpm.generate_profile(musp,x) # python yf = kpm.generate_profile(musf,x) # fortran py.scatter(x,yp,label="Python",c="blue") py.plot(x,yf,label="FORTRAN",c="green") py.legend() py.show()
import kpm # kernel polynomial method import numpy as np import pylab as py m = np.matrix([[0., 1.], [1., 0.]]) # default matrix m = m / 2 mus = kpm.full_trace(m) # full trace points = 200 # number of polynomials x = np.linspace(-.9, .9, points * 10) y = kpm.generate_profile(mus, x) py.plot(x, y) py.show()
############################################### ## this a test with a 1d tight binding model ## ############################################### n = 1000 # dimension of the matrix print("Dimension of the matrix",n) ii = np.arange(0,n-2) # indexes from 0 to n-2 cols = np.concatenate([ii,ii+1]) # index for rows rows = np.concatenate([ii+1,ii]) # index for cols data = np.zeros(cols.shape[0]) + 1. # tight binding parameter m = csc_matrix((data,(rows,cols)),shape=(n,n)) # create the sparse matrix site = n//2 # the entry where you want the dos, n/2 is an atom in the middle scale = 4.0 # this number has to be such that max(|eigenvalues|)/scale < 1 npol = 300 # number of polynomials, energy resolution goes as 1/npol ne = 300 # number of energies to calculate (between -scale and scale) # returns energies and dos # this function computes the different moments using the KPM mus = kpm.get_moments_ldos(m,i=site,n=npol,scale=scale) # once you have the moments, you can reconstruct the DOS # using the Chebyshev relations x = np.linspace(-0.9,0.9,400) y = kpm.generate_profile(mus.real,x,kernel="jackson").real # plot the result plt.plot(x*scale,y/scale) # plot this dos plt.show()
import kpm # kernel polynomial method import numpy as np import pylab as py import time from numpy.random import random m = np.matrix([[0., 1.], [1., 0.]]) # default matrix ndim = 30 m = np.matrix(random((ndim, ndim))) - 1. m += m.H m = m / (2 * ndim) points = 200 # number of polynomials t1 = time.clock() musp = kpm.full_trace(m, use_fortran=False) # full trace t2 = time.clock() musf = kpm.full_trace(m, use_fortran=True) # full trace t3 = time.clock() print "FORTRAN ", t3 - t2 print "Python ", t2 - t1 x = np.linspace(-.9, .9, points * 10) yp = kpm.generate_profile(musp, x) # python yf = kpm.generate_profile(musf, x) # fortran py.plot(x, yp, label="Python") py.plot(x, yp, label="FORTRAN") py.legend() py.show()
import geometry g = geometry.honeycomb_lattice() nrep = 2 g = g.supercell(nrep) h = g.get_hamiltonian() m = h.intra m = m / 6. points = 10000 # number of polynomials t1 = time.clock() musp = kpm.full_trace(m, use_fortran=False) # full trace t2 = time.clock() musf = kpm.full_trace(m, use_fortran=True) # full trace t3 = time.clock() print "FORTRAN ", t3 - t2 print "Python ", t2 - t1 x = np.linspace(-.9, .9, points * 10) t1 = time.clock() yp = kpm.generate_profile(musp, x, use_fortran=False) # python t2 = time.clock() yf = kpm.generate_profile(musf, x, use_fortran=True) # fortran t3 = time.clock() print "FORTRAN ", t3 - t2 print "Python ", t2 - t1 py.scatter(x, yp, label="Python", c="blue") py.plot(x, yf, label="FORTRAN", c="green") py.legend() py.show()
import kpm # kernel polynomial method import numpy as np import pylab as py m = np.matrix([[0.,1.],[1.,0.]]) # default matrix m = m/2 mus = kpm.full_trace(m) # full trace points = 200 # number of polynomials x = np.linspace(-.9,.9,points*10) y = kpm.generate_profile(mus,x) py.plot(x,y) py.show()
import geometry g = geometry.honeycomb_lattice() nrep = 2 g = g.supercell(nrep) h = g.get_hamiltonian() m = h.intra m = m/6. points = 10000 # number of polynomials t1 = time.clock() musp = kpm.full_trace(m,use_fortran=False) # full trace t2 = time.clock() musf = kpm.full_trace(m,use_fortran=True) # full trace t3 = time.clock() print "FORTRAN ",t3-t2 print "Python ",t2-t1 x = np.linspace(-.9,.9,points*10) t1 = time.clock() yp = kpm.generate_profile(musp,x,use_fortran=False) # python t2 = time.clock() yf = kpm.generate_profile(musf,x,use_fortran=True) # fortran t3 = time.clock() print "FORTRAN ",t3-t2 print "Python ",t2-t1 py.scatter(x,yp,label="Python",c="blue") py.plot(x,yf,label="FORTRAN",c="green") py.legend() py.show()