def ldos2d(h, e=0.0, delta=0.001, nrep=3, nk=None, mode="green", random=True, num_wf=20): """ Calculate DOS for a 2d system""" if mode == "green": import green if h.dimensionality != 2: raise # only for 1d if nk is not None: print("LDOS using normal integration with nkpoints", nk) gb, gs = green.bloch_selfenergy(h, energy=e, delta=delta, mode="full", nk=nk) d = [-(gb[i, i]).imag for i in range(len(gb))] # get imaginary part else: print("LDOS using renormalization adaptative Green function") gb, gs = green.bloch_selfenergy(h, energy=e, delta=delta, mode="adaptive") d = [-(gb[i, i]).imag for i in range(len(gb))] # get imaginary part elif mode == "arpack": # arpack diagonalization import klist if nk is None: nk = 10 hkgen = h.get_hk_gen() # get generator ds = [] # empty list for k in klist.kmesh(h.dimensionality, nk=nk): # loop over kpoints print("Doing", k) if random: print("Random k-point") k = np.random.random(3) # random k-point hk = csc_matrix(hkgen(k)) # get Hamiltonian ds += [ ldos_arpack(hk, num_wf=num_wf, robust=False, tol=0, e=e, delta=delta) ] d = ds[0] * 0.0 # inititlize for di in ds: d += di # add d /= len(ds) # normalize d = spatial_dos(h, d) # convert to spatial resolved DOS g = h.geometry # store geometry x, y = g.x, g.y # get the coordinates go = h.geometry.copy() # copy geometry go = go.supercell(nrep) # create supercell write_ldos(go.x, go.y, d.tolist() * (nrep**2), z=go.z) # write in file
def dos2d_ewindow(h,energies=np.linspace(-1.,1.,30),delta=None,info=False, use_green=True,nk=300,mode="adaptive"): """Calculate the density of states in certain eenrgy window""" ys = [] # density of states if delta is None: # pick a good delta value delta = 0.1*(max(energies) - min(energies))/len(energies) if use_green: from green import bloch_selfenergy for energy in energies: (g,selfe) = bloch_selfenergy(h,nk=nk,energy=energy, delta=delta, mode=mode) ys.append(-g.trace()[0,0].imag) if info: print("Done",energy) write_dos(energies,ys) # write in file return else: # do not use green function from dosf90 import calculate_dos # import fortran library import scipy.linalg as lg kxs = np.linspace(0.,1.,nk) kys = np.linspace(0.,1.,nk) hkgen= h.get_hk_gen() # get hamiltonian generator ys = energies*0. weight = 1./(nk*nk) for ix in kxs: for iy in kys: k = np.array([ix,iy,0.]) # create kpoint hk = hkgen(k) # get hk hamiltonian evals = lg.eigvalsh(hk) # get eigenvalues ys += weight*calculate_dos(evals,energies,delta) # add this contribution if info: print("Done",ix) write_dos(energies,ys) # write in file return
def ldos2d(h,e=0.0,delta=0.001,nrep=3,nk=None): """ Calculate DOS for a 1d system""" import green if h.dimensionality!=2: raise # only for 1d if nk is not None: print("LDOS using normal integration with nkpoints",nk) gb,gs = green.bloch_selfenergy(h,energy=e,delta=delta,mode="full",nk=nk) else: print("LDOS using renormalization adaptative Green function") gb,gs = green.bloch_selfenergy(h,energy=e,delta=delta,mode="adaptive") d = [ -(gb[i,i]).imag for i in range(len(gb))] # get imaginary part d = spatial_dos(h,d) # convert to spatial resolved DOS g = h.geometry # store geometry x,y = g.x,g.y # get the coordinates go = h.geometry.copy() # copy geometry go = go.supercell(nrep) # create supercell write_ldos(go.x,go.y,d.tolist()*(nrep**2)) # write in file
def renor_dos(e): g, selfe = green.bloch_selfenergy(h1, energy=e, delta=delta, nk=200, mode="adaptative") emat = np.matrix(np.identity(len(g))) * (e + delta * 1j) # E +i\delta return g, selfe
def ldos2d(h,e=0.0,delta=0.001,nrep=3): """ Calculate DOS for a 1d system""" import green if h.dimensionality!=2: raise # only for 1d gb,gs = green.bloch_selfenergy(h,energy=e,delta=delta,mode="adaptive") d = [ -(gb[i,i]).imag for i in range(len(gb))] # get imaginary part d = spatial_dos(h,d) # convert to spatial resolved DOS g = h.geometry # store geometry x,y = g.x,g.y # get the coordinates go = h.geometry.copy() # copy geometry go = go.supercell(nrep) # create supercell write_ldos(go.x,go.y,d.tolist()*(nrep**2)) # write in file
def ldos2d(h, e=0.0, delta=0.001, nrep=3): """ Calculate DOS for a 1d system""" import green if h.dimensionality != 2: raise # only for 1d gb, gs = green.bloch_selfenergy(h, energy=e, delta=delta, mode="adaptive") d = [-(gb[i, i]).imag for i in range(len(gb))] # get imaginary part d = spatial_dos(h, d) # convert to spatial resolved DOS g = h.geometry # store geometry x, y = g.x, g.y # get the coordinates go = h.geometry.copy() # copy geometry go = go.supercell(nrep) # create supercell write_ldos(go.x, go.y, d.tolist() * (nrep**2)) # write in file
def dos_impurity(h,vc=None,energy=0.,mode="adaptive",delta=0.001,nk=200): """ Calculates the green function using the embedding technique""" if vc==None: vc = h.intra # assume perfect if mode=="adaptive": mode = "adaptative" # stupid lexic mistake g,selfe = green.bloch_selfenergy(h,energy=energy,delta=delta,nk=nk, mode=mode) emat = np.matrix(np.identity(len(g)))*(energy + delta*1j) # E +i\delta gv = (emat - vc -selfe).I # Green function of a vacancy, with selfener ds = (-g.trace()[0,0].imag) # save DOS of the pristine dsv = (-gv.trace()[0,0].imag) # save DOS of the defected class emb_dos: pass edos = emb_dos() # create object edos.dos_perfect = ds # pristine dos edos.dos_defected = dsv # defected dos return edos # return object
def dos_impurity(h, vc=None, energy=0., mode="adaptive", delta=0.001, nk=200): """ Calculates the green function using the embedding technique""" if vc == None: vc = h.intra # assume perfect if mode == "adaptive": mode = "adaptative" # stupid lexic mistake g, selfe = green.bloch_selfenergy(h, energy=energy, delta=delta, nk=nk, mode=mode) emat = np.matrix(np.identity(len(g))) * (energy + delta * 1j) # E +i\delta gv = (emat - vc - selfe).I # Green function of a vacancy, with selfener ds = (-g.trace()[0, 0].imag) # save DOS of the pristine dsv = (-gv.trace()[0, 0].imag) # save DOS of the defected class emb_dos: pass edos = emb_dos() # create object edos.dos_perfect = ds # pristine dos edos.dos_defected = dsv # defected dos return edos # return object
import time for e in es: delta = 0.001 told = time.clock() # g,selfe = green.bloch_selfenergy(h,energy=e,delta=delta,nk=500, # mode="renormalization") # print time.clock() - told told = time.clock() # g2,selfe2 = green.bloch_selfenergy(h,energy=e,delta=delta,nk=200, # mode="full") # print time.clock() - told told = time.clock() g3, selfe3 = green.bloch_selfenergy(h, energy=e, delta=delta, nk=500, mode="adaptive") g = g3 selfe = selfe3 # print time.clock() - told told = time.clock() # print np.max(np.abs(g-g2)),np.max(np.abs(selfe-selfe2)) # print np.max(np.abs(g2-g3)),np.max(np.abs(selfe2-selfe3)) print np.max(np.abs(g - g3)), np.max(np.abs(selfe - selfe3)) print emat = np.matrix(np.identity(len(g))) * (e + delta * 1j) gv = (emat - vintra - selfe).I # Green function of a vacancy # gv2 = (emat - vintra -selfe2).I # Green function of a vacancy gv3 = (emat - vintra - selfe3).I # Green function of a vacancy
h.remove_spin() #h.add_rashba(.2) #h.add_zeeman([0.,0.,.2]) es = np.linspace(-1.,1.,80) #es = np.linspace(-.3,.3,80) dos = [] dosv = [] vintra = h.intra.copy() vintra[len(vintra)/2,len(vintra)/2] = 10000. import time for e in es: delta = 0.001 print e g,selfe = green.bloch_selfenergy(h,energy=e,delta=delta,error=0.001, mode="adaptative") emat = np.matrix(np.identity(len(g)))*(e + delta*1j) gv = (emat - vintra -selfe).I # Green function of a vacancy dos.append(-g.trace()[0,0].imag) # dosv.append(-gv.trace()[0,0].imag) dosv.append(-gv.trace()[0,0].imag) # dos.append(-green.bloch_selfenergy(h,energy=e,delta=0.1).imag) py.plot(es,dos,marker="o") py.plot(es,dosv,marker="o") #print h.get_hk_gen()(.1) h.write("hamiltonian.in")
def get_green(energy): return green.bloch_selfenergy(h,energy=energy,delta=delta,nk=nk, mode=mode)
dosv = [] # array with defected DOS ### end create arrays of energies and dos #### #### and cell with the defect #### vintra = h.intra.copy() # hoppings intracell for the defected one vintra[len(vintra) / 2, len(vintra) / 2] = 10000. # model vacancy as huge onsite #### end cell with the defect #### ### perform Green function calculation over the energies ##### for e in es: # loop over energies delta = 0.02 g, selfe = green.bloch_selfenergy(h, energy=e, delta=delta, nk=200, mode="renormalization") emat = np.matrix(np.identity(len(g))) * (e + delta * 1j) # E +i\delta gv = (emat - vintra - selfe).I # Green function of a vacancy, with selfener dos.append(-g.trace()[0, 0].imag) # save DOS of the pristine dosv.append(-gv.trace()[0, 0].imag) # save DOS of the defected ### end Green function calculation over the energies ##### #### finally plot #### py.plot(es, dos, marker="o", color="red", label="pristine") py.plot(es, dosv, marker="o", color="blue", label="defected") py.legend()
#### Parameters #### delta = 0.02 # analitic continuation e = 0.7 # energy ## Calculate by both methods import green import time t0 = time.clock() ### OLD METHOD ### g1,selfe1 = green.bloch_selfenergy(h1,energy=e,delta=delta,nk=200, mode="adaptative") t1 = time.clock() ### NEW METHOD ### g2,selfe2 = green.supercell_selfenergy(h2,e=e,delta=delta,nk=200,nsuper=ncell) t2 = time.clock() ## Output results print "Time for OLD = ",t1-t0 print "Time for NEW = ",t2-t1
vintra = h.intra.copy() vintra[len(vintra)/2,len(vintra)/2] = 10000. import time for e in es: delta = 0.001 told = time.clock() # g,selfe = green.bloch_selfenergy(h,energy=e,delta=delta,nk=500, # mode="renormalization") # print time.clock() - told told = time.clock() # g2,selfe2 = green.bloch_selfenergy(h,energy=e,delta=delta,nk=200, # mode="full") # print time.clock() - told told = time.clock() g3,selfe3 = green.bloch_selfenergy(h,energy=e,delta=delta,nk=500, mode="adaptive") g = g3 selfe = selfe3 # print time.clock() - told told = time.clock() # print np.max(np.abs(g-g2)),np.max(np.abs(selfe-selfe2)) # print np.max(np.abs(g2-g3)),np.max(np.abs(selfe2-selfe3)) print np.max(np.abs(g-g3)),np.max(np.abs(selfe-selfe3)) print emat = np.matrix(np.identity(len(g)))*(e + delta*1j) gv = (emat - vintra -selfe).I # Green function of a vacancy # gv2 = (emat - vintra -selfe2).I # Green function of a vacancy gv3 = (emat - vintra -selfe3).I # Green function of a vacancy # print np.max(np.abs(gv-gv2))
# return np.exp(-x) return 1/(x*x+100) return np.sin(x) ecs = [e1,e2,e3,e4] ecs = [e1,e2,e3] #ecs = [e4] des = [de1,de2,de3,de4] des = [de1,de2,de3] #des = [de4] gt = h.intra*0.0 gt2 = h.intra*0.0 #gt = 0.0 i = np.identity(len(h.intra)) for (e,de) in zip(ecs,des): for ie in e: # g = ((ie+0.001j)*i - h.intra).I g,s = green.bloch_selfenergy(h,energy = ie,mode="renormalization") # gt += f(ie)*de gt += g*de print "Integral of DOS from",dx,"to 0" print -gt.trace()[0,0].imag/np.pi #print gt
def f(x): # return np.exp(-x) return 1 / (x * x + 100) return np.sin(x) ecs = [e1, e2, e3, e4] ecs = [e1, e2, e3] #ecs = [e4] des = [de1, de2, de3, de4] des = [de1, de2, de3] #des = [de4] gt = h.intra * 0.0 gt2 = h.intra * 0.0 #gt = 0.0 i = np.identity(len(h.intra)) for (e, de) in zip(ecs, des): for ie in e: # g = ((ie+0.001j)*i - h.intra).I g, s = green.bloch_selfenergy(h, energy=ie, mode="renormalization") # gt += f(ie)*de gt += g * de print "Integral of DOS from", dx, "to 0" print -gt.trace()[0, 0].imag / np.pi #print gt
g = g.supercell(ncell) # create a supercell h1 = g.get_hamiltonian() # create hamiltonian #### Parameters #### delta = 0.02 # analitic continuation e = 0.7 # energy ## Calculate by both methods import green import time t0 = time.clock() ### OLD METHOD ### g1, selfe1 = green.bloch_selfenergy(h1, energy=e, delta=delta, nk=200, mode="adaptative") t1 = time.clock() ### NEW METHOD ### g2, selfe2 = green.supercell_selfenergy(h2, e=e, delta=delta, nk=200, nsuper=ncell) t2 = time.clock() ## Output results
def renor_dos(e): g,selfe = green.bloch_selfenergy(h1,energy=e,delta=delta,nk=200, mode="adaptative") emat = np.matrix(np.identity(len(g)))*(e + delta*1j) # E +i\delta return g,selfe
es = np.linspace(-3.,3.,100) # array with energies dos = [] # arry with pristine DOS dosv = [] # array with defected DOS ### end create arrays of energies and dos #### #### and cell with the defect #### vintra = h.intra.copy() # hoppings intracell for the defected one vintra[len(vintra)/2,len(vintra)/2] = 10000. # model vacancy as huge onsite #### end cell with the defect #### ### perform Green function calculation over the energies ##### for e in es: # loop over energies delta = 0.02 g,selfe = green.bloch_selfenergy(h,energy=e,delta=delta,nk=200, mode="renormalization") emat = np.matrix(np.identity(len(g)))*(e + delta*1j) # E +i\delta gv = (emat - vintra -selfe).I # Green function of a vacancy, with selfener dos.append(-g.trace()[0,0].imag) # save DOS of the pristine dosv.append(-gv.trace()[0,0].imag) # save DOS of the defected ### end Green function calculation over the energies ##### #### finally plot #### py.plot(es,dos,marker="o",color="red",label="pristine") py.plot(es,dosv,marker="o",color="blue",label="defected") py.legend() py.show()