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 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()
