guanjihuan/guanjihuan.com
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

category

Browse Source
This commit is contained in:
guanjihuan
2023-07-26 00:46:01 +08:00
parent c7cbcd09af
commit 822fa7e626
212 changed files with 5687 additions and 5687 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
academic_codes/density_of_states/2019.11.02_numerically_verify_the_relation_between_eigenstates_and_DOS/numerically_verify_the_relation_between_eigenstates_and_DOS.py Normal file
View File

@@ -0,0 +1,43 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/962
"""
import numpy as np
def hamiltonian(width=2, length=4): # 有一定宽度和长度的方格子
h00 = np.zeros((width*length, width*length))
for i0 in range(length):
for j0 in range(width-1):
h00[i0*width+j0, i0*width+j0+1] = 1
h00[i0*width+j0+1, i0*width+j0] = 1
for i0 in range(length-1):
for j0 in range(width):
h00[i0*width+j0, (i0+1)*width+j0] = 1
h00[(i0+1)*width+j0, i0*width+j0] = 1
return h00
def main():
h0 = hamiltonian()
dim = h0.shape[0]
n = 4 # 选取第n个能级
eigenvalue, eigenvector = np.linalg.eig(h0) # 本征值、本征矢
# print(h0)
# print('哈密顿量的维度：', dim) # 哈密顿量的维度
# print('本征矢的维度：', eigenvector.shape) # 本征矢的维度
# print('能级（未排序）：', eigenvalue) # 输出本征值。因为体系是受限的，所以是离散的能级
# print('选取第', n, '个能级，为', eigenvalue[n-1]) # 从1开始算，查看第n个能级是什么（这里本征值未排序）
# print('第', n, '个能级对应的波函数：', eigenvector[:, n-1]) # 查看第n个能级对应的波函数
print('\n波函数模的平方：\n', np.square(np.abs(eigenvector[:, n-1]))) # 查看第n个能级对应的波函数模的平方
green = np.linalg.inv((eigenvalue[n-1]+1e-15j)*np.eye(dim)-h0) # 第n个能级对应的格林函数
total = np.trace(np.imag(green)) # 求该能级格林函数的迹，对应的是总态密度（忽略符号和系数）
print('归一化后的态密度分布：')
for i in range(dim):
print(np.imag(green)[i, i]/total) # 第n个能级单位化后的态密度分布
print('观察以上两个分布的数值情况，可以发现两者完全相同。')
if __name__ == '__main__':
main()

160
academic_codes/density_of_states/2019.12.30_calculation_of_spectral_function_and_QPI/calculation of spectral function and QPI.f90 Normal file
View File

@@ -0,0 +1,160 @@
! This code is supported by the website: https://www.guanjihuan.com
! The newest version of this code is on the web page: https://www.guanjihuan.com/archives/3785
module global
implicit none
double precision sqrt3,Pi
parameter(sqrt3=1.7320508075688773d0,Pi=3.14159265358979324d0)
end module global
program QPI !QPI主程序
use blas95
use lapack95,only:GETRF,GETRI
use global
implicit none
integer i,j,info,index_0(4)
double precision omega,kx,ky,Eigenvalues(4),eta,V0,kx1,kx2,ky1,ky2,qx,qy,time_begin,time_end
parameter(eta=0.005)
complex*16 H0(4,4),green_0(4,4),green_1(4,4),green_0_k1(4,4),green_0_k2(4,4),A_spectral,V(4,4),gamma_0(4,4),Temp_0(4,4),T(4,4),g_1,rho_1
character(len=*):: Flname
parameter(Flname='') !可以写上输出文件路径，也可以不写，输出存在当前文件的路径
omega=0.070d0
open(unit=10,file=Flname//'Spectral function_w=0.07.txt')
open(unit=20,file=Flname//'QPI_intra_nonmag_w=0.07.txt')
call CPU_TIME(time_begin)
!计算谱函数A(kx,ky)
write(10,"(f20.10,x)",advance='no') 0
do ky=-Pi,Pi,0.01d0 !谱函数图案的精度
write(10,"(f20.10,x)",advance='no') ky
enddo
write(10,"(a)",advance='yes') ' '
do kx=-Pi,Pi,0.01d0 !谱函数图案的精度
write(10,"(f20.10,x)",advance='no') kx
do ky=-Pi,Pi,0.01d0 !谱函数图案的精度
call Greenfunction_clean(kx,ky,eta,omega,green_0)
A_spectral=-(green_0(1,1)+green_0(3,3))/Pi
write(10,"(f20.10)",advance='no') imag(A_spectral)
enddo
write(10,"(a)",advance='yes') ' '
enddo
!计算QPI(qx,qy)
V0=0.4d0
V=0.d0
V(1,1)=V0
V(2,2)=-V0
V(3,3)=V0
V(4,4)=-V0
gamma_0=0.d0
do kx=-Pi,Pi,0.01
do ky=-Pi,Pi,0.01
call Greenfunction_clean(kx,ky,eta,omega,green_0)
do i=1,4
do j=1,4
gamma_0(i,j)=gamma_0(i,j)+green_0(i,j)*0.01*0.01
enddo
enddo
enddo
enddo
gamma_0=gamma_0/(2*Pi)/(2*Pi)
call gemm(V,gamma_0,Temp_0)
do i=1,4
Temp_0(i,i)=1-Temp_0(i,i)
enddo
call GETRF( Temp_0,index_0,info ); call GETRI( Temp_0,index_0,info) !求逆
call gemm(Temp_0,V,T) !矩阵乘积
write(20,"(f20.10,x)",advance='no') 0
do qy=-Pi,Pi,0.01 !QPI图案的精度
write(20,"(f20.10,x)",advance='no') qy
enddo
write(20,"(a)",advance='yes') ' '
do qx=-Pi,Pi,0.01 !QPI图案的精度
write(*,"(a)",advance='no') 'qx='
write(*,*) qx !屏幕输出可以实时查看计算进度
write(20,"(f20.10)",advance='no') qx
do qy=-Pi,Pi,0.01 !QPI图案的精度
rho_1=0.d0
do kx1=-Pi,Pi,0.06 !积分的精度
kx2=kx1+qx
do ky1=-Pi,Pi,0.06 !积分的精度
ky2=ky1+qy
call Greenfunction_clean(kx1,ky1,eta,omega,green_0_k1)
call Greenfunction_clean(kx2,ky2,eta,omega,green_0_k2)
call gemm(green_0_k1,T,Temp_0)
call gemm(Temp_0, green_0_k2, green_1)
g_1=green_1(1,1)-dconjg(green_1(1,1))+green_1(3,3)-dconjg(green_1(3,3))
rho_1=rho_1+g_1*0.06*0.06
enddo
enddo
rho_1=rho_1/(2*Pi)/(2*Pi)/(2*Pi)*(0.d0,1.d0)
write(20,"(f20.10,x,f20.10)",advance='no') real(rho_1)
enddo
write(20,"(a)",advance='yes') ' '
enddo
call CPU_TIME(time_end)
write(*,"(a)",advance='no') 'The running time of this task='
write (*,*) time_end-time_begin !屏幕输出总的计算时间，单位为秒（按照当前步长的精度，在个人计算机上运算大概需要4个小时）
end program
subroutine Greenfunction_clean(kx,ky,eta,omega,green_0) !干净体系的格林函数
use blas95
use lapack95,only:GETRF,GETRI
use global
integer info,index_0(4)
double precision, intent(in):: kx,ky,eta,omega
complex*16 H0(4,4)
complex*16,intent(out):: green_0(4,4)
call Hamiltonian(kx,ky,H0)
green_0=H0
do i=1,4
green_0(i,i)=omega+(0.d0,1.d0)*eta-green_0(i,i)
enddo
call GETRF( green_0,index_0,info ); call GETRI( green_0,index_0,info );
end subroutine Greenfunction_clean
subroutine Hamiltonian(kx,ky,Matrix) !哈密顿量
use global
implicit none
integer i,j
double precision t1,t2,t3,t4,mu,epsilon_x,epsilon_y,epsilon_xy,delta_1,delta_2,delta_0
double precision, intent(in):: kx,ky
complex*16,intent(out):: Matrix(4,4)
t1=-1;t2=1.3;t3=-0.85;t4=-0.85;delta_0=0.1;mu=1.54
Matrix=(0.d0,0.d0)
epsilon_x=-2*t1*dcos(kx)-2*t2*dcos(ky)-4*t3*dcos(kx)*dcos(ky)
epsilon_y=-2*t1*dcos(ky)-2*t2*dcos(kx)-4*t3*dcos(kx)*dcos(ky)
epsilon_xy=-4*t4*dsin(kx)*dsin(ky)
delta_1=delta_0*dcos(kx)*dcos(ky)
delta_2=delta_1
Matrix(1,1)=epsilon_x-mu
Matrix(2,2)=-epsilon_x+mu
Matrix(3,3)=epsilon_y-mu
Matrix(4,4)=-epsilon_y+mu
Matrix(1,2)=delta_1
Matrix(2,1)=delta_1
Matrix(1,3)=epsilon_xy
Matrix(3,1)=epsilon_xy
Matrix(1,4)=0.d0
Matrix(4,1)=0.d0
Matrix(2,3)=0.d0
Matrix(3,2)=0.d0
Matrix(2,4)=-epsilon_xy
Matrix(4,2)=-epsilon_xy
Matrix(3,4)=delta_2
Matrix(4,3)=delta_2
end subroutine Hamiltonian

158
academic_codes/density_of_states/2019.12.30_calculation_of_spectral_function_and_QPI/calculation of spectral function and QPI.py Normal file
View File

@@ -0,0 +1,158 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/3785
"""
import numpy as np
from math import *
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
import time
def green_function(fermi_energy, k1, k2, hamiltonian): # 计算格林函数
matrix0 = hamiltonian(k1, k2)
dim = matrix0.shape[0]
green = np.linalg.inv(fermi_energy * np.identity(dim) - matrix0)
return green
def spectral_function(fermi_energy, k1, k2, hamiltonian): # 计算谱函数
dim1 = k1.shape[0]
dim2 = k2.shape[0]
spectrum = np.zeros((dim1, dim2))
i0 = 0
for k10 in k1:
j0 = 0
for k20 in k2:
green = green_function(fermi_energy, k10, k20, hamiltonian)
spectrum[i0, j0] = (np.imag(green[0,0])+np.imag(green[2,2]))/(-pi)
j0 += 1
i0 += 1
# print(spectrum)
print()
print('Spectral function显示的网格点 =', k1.shape[0], '*', k1.shape[0], '; 步长 =', k1[1] - k1[0])
print()
return spectrum
def qpi(fermi_energy, q1, q2, hamiltonian, potential_i): # 计算QPI
dim = hamiltonian(0, 0).shape[0]
ki1 = np.arange(-pi, pi, 0.01) # 计算gamma_0时，k的积分密度
ki2 = np.arange(-pi, pi, 0.01)
print('gamma_0的积分网格点 =', ki1.shape[0], '*', ki1.shape[0], '; 步长 =', ki1[1] - ki1[0])
gamma_0 = integral_of_green(fermi_energy, ki1, ki2, hamiltonian)/np.square(2*pi)
t_matrix = np.dot(np.linalg.inv(np.identity(dim)-np.dot(potential_i, gamma_0)), potential_i)
ki1 = np.arange(-pi, pi, 0.06) # 计算induced_local_density时，k的积分密度
ki2 = np.arange(-pi, pi, 0.06)
print('局域态密度变化的积分网格点 =', ki1.shape[0], '*', ki1.shape[0], '; 步长 =', ki1[1] - ki1[0])
print('QPI显示的网格点 =', q1.shape[0], '*', q1.shape[0], '; 步长 =', q1[1] - q1[0])
step_length = ki1[1] - ki1[0]
induced_local_density = np.zeros((q1.shape[0], q2.shape[0]))*(1+0j)
print()
i0 = 0
for q10 in q1:
print('i0=', i0)
j0 = 0
for q20 in q2:
for ki10 in ki1:
for ki20 in ki2:
green_01 = green_function(fermi_energy, ki10, ki20, hamiltonian)
green_02 = green_function(fermi_energy, ki10+q10, ki20+q20, hamiltonian)
induced_green = np.dot(np.dot(green_01, t_matrix), green_02)
temp = induced_green[0, 0]-induced_green[0, 0].conj()+induced_green[2, 2]-induced_green[2, 2].conj()
induced_local_density[i0, j0] = induced_local_density[i0, j0]+temp*np.square(step_length)
j0 += 1
i0 += 1
write_matrix_k1_k2(q1, q2, np.real(induced_local_density*1j/np.square(2*pi)/(2*pi)), 'QPI') # 数据写入文件（临时写入，会被多次替代）
induced_local_density = np.real(induced_local_density*1j/np.square(2*pi)/(2*pi))
return induced_local_density
def integral_of_green(fermi_energy, ki1, ki2, hamiltonian): # 在计算QPI时需要对格林函数积分
dim = hamiltonian(0, 0).shape[0]
integral_value = np.zeros((dim, dim))*(1+0j)
step_length = ki1[1]-ki1[0]
for ki10 in ki1:
for ki20 in ki2:
green = green_function(fermi_energy, ki10, ki20, hamiltonian)
integral_value = integral_value+green*np.square(step_length)
return integral_value
def write_matrix_k1_k2(x1, x2, value, filename='matrix_k1_k2'): # 把矩阵数据写入文件（格式化输出）
with open(filename+'.txt', 'w') as f:
np.set_printoptions(suppress=True) # 取消输出科学记数法
f.write('0 ')
for x10 in x1:
f.write(str(x10)+' ')
f.write('\n')
i0 = 0
for x20 in x2:
f.write(str(x20))
for j0 in range(x1.shape[0]):
f.write(' '+str(value[i0, j0])+' ')
f.write('\n')
i0 += 1
def plot_contour(x1, x2, value, filename='contour'): # 直接画出contour图像（保存图像）
plt.contourf(x1, x2, value) #, cmap=plt.cm.hot)
plt.savefig(filename+'.eps')
# plt.show()
def hamiltonian(kx, ky): # 体系的哈密顿量
t1 = -1; t2 = 1.3; t3 = -0.85; t4 = -0.85; delta_0 = 0.1; mu = 1.54
epsilon_x = -2*t1*cos(kx)-2*t2*cos(ky)-4*t3*cos(kx)*cos(ky)
epsilon_y = -2*t1*cos(ky)-2*t2*cos(kx)-4*t3*cos(kx)*cos(ky)
epsilon_xy = -4*t4*sin(kx)*sin(ky)
delta_1 = delta_0*cos(kx)*cos(ky)
delta_2 = delta_0*cos(kx)*cos(ky)
h = np.zeros((4, 4))
h[0, 0] = epsilon_x-mu
h[1, 1] = -epsilon_x+mu
h[2, 2] = epsilon_y-mu
h[3, 3] = -epsilon_y+mu
h[0, 1] = delta_1
h[1, 0] = delta_1
h[0, 2] = epsilon_xy
h[2, 0] = epsilon_xy
h[0, 3] = 0
h[3, 0] = 0
h[1, 2] = 0
h[2, 1] = 0
h[1, 3] = -epsilon_xy
h[3, 1] = -epsilon_xy
h[2, 3] = delta_2
h[3, 2] = delta_2
return h
def main(): # 主程序
start_clock = time.perf_counter()
fermi_energy = 0.07 # 费米能
energy_broadening_width = 0.005 # 展宽
k1 = np.arange(-pi, pi, 0.01) # 谱函数的图像精度
k2 = np.arange(-pi, pi, 0.01)
spectrum = spectral_function(fermi_energy+energy_broadening_width*1j, k1, k2, hamiltonian) # 调用谱函数子程序
write_matrix_k1_k2(k1, k2, spectrum, 'Spectral_function') # 把谱函数的数据写入文件
# plot_contour(k1, k2, spectrum, 'Spectral_function') # 直接显示谱函数的图像（保存图像）
q1 = np.arange(-pi, pi, 0.01) # QPI数的图像精度
q2 = np.arange(-pi, pi, 0.01)
potential_i = (0.4+0j)*np.identity(hamiltonian(0, 0).shape[0]) # 杂质势
potential_i[1, 1] = - potential_i[1, 1] # for nonmagnetic
potential_i[3, 3] = - potential_i[3, 3]
induced_local_density = qpi(fermi_energy+energy_broadening_width*1j, q1, q2, hamiltonian, potential_i) # 调用QPI子程序
write_matrix_k1_k2(q1, q2, induced_local_density, 'QPI') # 把QPI数据写入文件（这里用的方法是计算结束后一次性把数据写入）
# plot_contour(q1, q2, induced_local_density, 'QPI') # 直接显示QPI图像（保存图像）
end_clock = time.perf_counter()
print('CPU执行时间=', end_clock - start_clock)
if __name__ == '__main__':
main()

56
academic_codes/density_of_states/2020.06.16_total_DOS_as_a_function_of_Fermi_energy_in_square_lattice_and_graphene/total_DOS_as_a_function_of_Fermi_energy_in_graphene.py Normal file
View File

@@ -0,0 +1,56 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/4622
"""
import numpy as np
import matplotlib.pyplot as plt
from math import *
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
def hamiltonian(width=8, length=8): # 石墨烯格子的哈密顿量。这里width要求为4的倍数
h = np.zeros((width*length, width*length))
# y方向的跃迁
for x in range(length):
for y in range(width-1):
h[x*width+y, x*width+y+1] = 1
h[x*width+y+1, x*width+y] = 1
# x方向的跃迁
for x in range(length-1):
for y in range(width):
if np.mod(y, 4)==0:
h[x*width+y+1, (x+1)*width+y] = 1
h[(x+1)*width+y, x*width+y+1] = 1
h[x*width+y+2, (x+1)*width+y+3] = 1
h[(x+1)*width+y+3, x*width+y+2] = 1
return h
def main():
plot_precision = 0.01 # 画图的精度
Fermi_energy_array = np.arange(-5, 5, plot_precision) # 计算中取的费米能Fermi_energy组成的数组
dim_energy = Fermi_energy_array.shape[0] # 需要计算的费米能的个数
total_DOS_array = np.zeros((dim_energy)) # 计算结果（总态密度total_DOS）放入该数组中
h = hamiltonian() # 体系的哈密顿量
dim = h.shape[0] # 哈密顿量的维度
i0 = 0
for Fermi_energy in Fermi_energy_array:
print(Fermi_energy) # 查看计算的进展情况
green = np.linalg.inv((Fermi_energy+0.1j)*np.eye(dim)-h) # 体系的格林函数
total_DOS = -np.trace(np.imag(green))/pi # 通过格林函数求得总态密度
total_DOS_array[i0] = total_DOS # 记录每个Fermi_energy对应的总态密度
i0 += 1
sum_up = np.sum(total_DOS_array)*plot_precision # 用于图像归一化
plt.plot(Fermi_energy_array, total_DOS_array/sum_up, '-') # 画DOS(E)图像
plt.xlabel('费米能')
plt.ylabel('总态密度')
plt.show()
if __name__ == '__main__':
main()

52
academic_codes/density_of_states/2020.06.16_total_DOS_as_a_function_of_Fermi_energy_in_square_lattice_and_graphene/total_DOS_as_a_function_of_Fermi_energy_in_square_lattice.py Normal file
View File

@@ -0,0 +1,52 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/4622
"""
import numpy as np
import matplotlib.pyplot as plt
from math import *
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
def hamiltonian(width=10, length=10): # 方格子哈密顿量
h = np.zeros((width*length, width*length))
# y方向的跃迁
for x in range(length):
for y in range(width-1):
h[x*width+y, x*width+y+1] = 1
h[x*width+y+1, x*width+y] = 1
# x方向的跃迁
for x in range(length-1):
for y in range(width):
h[x*width+y, (x+1)*width+y] = 1
h[(x+1)*width+y, x*width+y] = 1
return h
def main():
plot_precision = 0.01 # 画图的精度
Fermi_energy_array = np.arange(-5, 5, plot_precision) # 计算中取的费米能Fermi_energy组成的数组
dim_energy = Fermi_energy_array.shape[0] # 需要计算的费米能的个数
total_DOS_array = np.zeros((dim_energy)) # 计算结果（总态密度total_DOS）放入该数组中
h = hamiltonian() # 体系的哈密顿量
dim = h.shape[0] # 哈密顿量的维度
i0 = 0
for Fermi_energy in Fermi_energy_array:
print(Fermi_energy) # 查看计算的进展情况
green = np.linalg.inv((Fermi_energy+0.1j)*np.eye(dim)-h) # 体系的格林函数
total_DOS = -np.trace(np.imag(green))/pi # 通过格林函数求得总态密度
total_DOS_array[i0] = total_DOS # 记录每个Fermi_energy对应的总态密度
i0 += 1
sum_up = np.sum(total_DOS_array)*plot_precision # 用于图像归一化
plt.plot(Fermi_energy_array, total_DOS_array/sum_up, '-') # 画DOS(E)图像
plt.xlabel('费米能')
plt.ylabel('总态密度')
plt.show()
if __name__ == '__main__':
main()

84
academic_codes/density_of_states/2020.06.25_numerically_verify_Green_functions_in_Dyson_equations/numerically_verify_Green_functions_in_Dyson_equations.py Normal file
View File

@@ -0,0 +1,84 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/4396
"""
import numpy as np
import matplotlib.pyplot as plt
import copy
import time
def matrix_00(width): # 一个切片（slide)内的哈密顿量
h00 = np.zeros((width, width))
for width0 in range(width-1):
h00[width0, width0+1] = 1
h00[width0+1, width0] = 1
return h00
def matrix_01(width): # 切片之间的跃迁项（hopping）
h01 = np.identity(width)
return h01
def matrix_whole(width, length): # 方格子整体的哈密顿量，宽度为width，长度为length
hamiltonian = np.zeros((width*length, width*length))
for x in range(length):
for y in range(width-1):
hamiltonian[x*width+y, x*width+y+1] = 1
hamiltonian[x*width+y+1, x*width+y] = 1
for x in range(length-1):
for y in range(width):
hamiltonian[x*width+y, (x+1)*width+y] = 1
hamiltonian[(x+1)*width+y, x*width+y] = 1
return hamiltonian
def main():
width =4 # 方格子的宽度
length = 200 # 方格子的长度
h00 = matrix_00(width) # 一个切片（slide)内的哈密顿量
h01 = matrix_01(width) # 切片之间的跃迁项（hopping）
hamiltonian = matrix_whole(width, length) # 方格子整体的哈密顿量，宽度为width，长度为length
fermi_energy = 0.1 # 费米能取为0.1为例。按理来说计算格林函数时，这里需要加上一个无穷小的虚数，但Python中好像不加也不会有什么问题。
start_1= time.perf_counter()
green = General_way(fermi_energy, hamiltonian) # 利用通常直接求逆的方法得到整体的格林函数green
end_1 = time.perf_counter()
start_2= time.perf_counter()
green_0n_n = Dyson_way(fermi_energy, h00, h01, length) # 利用Dyson方程得到的格林函数green_0n
end_2 = time.perf_counter()
# print(green)
print('\n整体格林函数中的一个分块矩阵green_0n：\n', green[0:width, (length-1)*width+0:(length-1)*width+width]) # a:b代表 a <= x < b，左闭右开
print('Dyson方程得到的格林函数green_0n：\n', green_0n_n)
print('观察以上两个矩阵，可以直接看出两个矩阵完全相同。\n')
print('General_way执行时间=', end_1-start_1)
print('Dyson_way执行时间=', end_2-start_2)
def General_way(fermi_energy, hamiltonian):
dim_hamiltonian = hamiltonian.shape[0]
green = np.linalg.inv((fermi_energy)*np.eye(dim_hamiltonian)-hamiltonian)
return green
def Dyson_way(fermi_energy, h00, h01, length):
dim = h00.shape[0]
for ix in range(length):
if ix == 0:
green_nn_n = np.linalg.inv(fermi_energy*np.identity(dim)-h00) # 如果有左电极，还需要减去左电极的自能left_self_energy
green_0n_n = copy.deepcopy(green_nn_n) # 如果直接用等于，两个变量会指向相同的id，改变一个值，另外一个值可能会发生改变，容易出错，所以要用上这个COPY
elif ix != length-1:
green_nn_n = np.linalg.inv(fermi_energy*np.identity(dim)-h00-np.dot(np.dot(h01.transpose().conj(), green_nn_n), h01))
green_0n_n = np.dot(np.dot(green_0n_n, h01), green_nn_n)
else: # 这里和（elif ix != length-1）中的内容完全一样，但如果有右电极，这里是还需要减去右电极的自能right_self_energy
green_nn_n = np.linalg.inv(fermi_energy*np.identity(dim)-h00-np.dot(np.dot(h01.transpose().conj(), green_nn_n), h01))
green_0n_n = np.dot(np.dot(green_0n_n, h01), green_nn_n)
return green_0n_n
if __name__ == '__main__':
main()

102
academic_codes/density_of_states/2020.12.31_DOS_calculation_using_Dyson_equations/cubic_lattice/DOS_calculation_using_Dyson_equations_in_cubic_lattice.py Normal file
View File

@@ -0,0 +1,102 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/7650
"""
import numpy as np
import matplotlib.pyplot as plt
from math import *
def matrix_00(width, length):
h00 = np.zeros((width*length, width*length))
for x in range(length):
for y in range(width-1):
h00[x*width+y, x*width+y+1] = 1
h00[x*width+y+1, x*width+y] = 1
for x in range(length-1):
for y in range(width):
h00[x*width+y, (x+1)*width+y] = 1
h00[(x+1)*width+y, x*width+y] = 1
return h00
def matrix_01(width, length):
h01 = np.identity(width*length)
return h01
def main():
height = 2 # z
width = 3 # y
length = 4 # x
eta = 1e-2
E = 0
h00 = matrix_00(width, length)
h01 = matrix_01(width, length)
G_ii_n_array = G_ii_n_with_Dyson_equation(width, length, height, E, eta, h00, h01)
for i0 in range(height):
print('z=', i0+1, ':')
for j0 in range(width):
print(' y=', j0+1, ':')
for k0 in range(length):
print(' x=', k0+1, ' ', -np.imag(G_ii_n_array[i0, k0*width+j0, k0*width+j0])/pi) # 态密度
def G_ii_n_with_Dyson_equation(width, length, height, E, eta, h00, h01):
dim = length*width
G_ii_n_array = np.zeros((height, dim, dim), dtype=complex)
G_11_1 = np.linalg.inv((E+eta*1j)*np.identity(dim)-h00)
for i in range(height): # i为格林函数的右下指标
# 初始化开始
G_nn_n_minus = G_11_1
G_in_n_minus = G_11_1
G_ni_n_minus = G_11_1
G_ii_n_minus = G_11_1
for i0 in range(i):
G_nn_n = Green_nn_n(E, eta, h00, h01, G_nn_n_minus)
G_nn_n_minus = G_nn_n
if i!=0:
G_in_n_minus = G_nn_n
G_ni_n_minus = G_nn_n
G_ii_n_minus = G_nn_n
# 初始化结束
for j0 in range(height-1-i): # j0为格林函数的右上指标，表示当前体系大小，即G^{(j0)}
G_nn_n = Green_nn_n(E, eta, h00, h01, G_nn_n_minus)
G_nn_n_minus = G_nn_n
G_ii_n = Green_ii_n(G_ii_n_minus, G_in_n_minus, h01, G_nn_n, G_ni_n_minus) # 需要求的对角分块矩阵
G_ii_n_minus = G_ii_n
G_in_n = Green_in_n(G_in_n_minus, h01, G_nn_n)
G_in_n_minus = G_in_n
G_ni_n = Green_ni_n(G_nn_n, h01, G_ni_n_minus)
G_ni_n_minus = G_ni_n
G_ii_n_array[i, :, :] = G_ii_n_minus
return G_ii_n_array
def Green_nn_n(E, eta, H00, V, G_nn_n_minus): # n>=2
dim = H00.shape[0]
G_nn_n = np.linalg.inv((E+eta*1j)*np.identity(dim)-H00-np.dot(np.dot(V.transpose().conj(), G_nn_n_minus), V))
return G_nn_n
def Green_in_n(G_in_n_minus, V, G_nn_n): # n>=2
G_in_n = np.dot(np.dot(G_in_n_minus, V), G_nn_n)
return G_in_n
def Green_ni_n(G_nn_n, V, G_ni_n_minus): # n>=2
G_ni_n = np.dot(np.dot(G_nn_n, V.transpose().conj()), G_ni_n_minus)
return G_ni_n
def Green_ii_n(G_ii_n_minus, G_in_n_minus, V, G_nn_n, G_ni_n_minus): # n>=i
G_ii_n = G_ii_n_minus+np.dot(np.dot(np.dot(np.dot(G_in_n_minus, V), G_nn_n), V.transpose().conj()),G_ni_n_minus)
return G_ii_n
if __name__ == '__main__':
main()

99
academic_codes/density_of_states/2020.12.31_DOS_calculation_using_Dyson_equations/cubic_lattice/DOS_calculation_using_Dyson_equations_in_cubic_lattice_version_II.py Normal file
View File

@@ -0,0 +1,99 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/7650
"""
import numpy as np
import matplotlib.pyplot as plt
from math import *
def matrix_00(width, length):
h00 = np.zeros((width*length, width*length))
for x in range(length):
for y in range(width-1):
h00[x*width+y, x*width+y+1] = 1
h00[x*width+y+1, x*width+y] = 1
for x in range(length-1):
for y in range(width):
h00[x*width+y, (x+1)*width+y] = 1
h00[(x+1)*width+y, x*width+y] = 1
return h00
def matrix_01(width, length):
h01 = np.identity(width*length)
return h01
def main():
height = 2 # z
width = 3 # y
length = 4 # x
eta = 1e-2
E = 0
h00 = matrix_00(width, length)
h01 = matrix_01(width, length)
G_ii_n_with_Dyson_equation_version_II(width, length, height, E, eta, h00, h01)
def G_ii_n_with_Dyson_equation_version_II(width, length, height, E, eta, h00, h01):
dim = length*width
G_11_1 = np.linalg.inv((E+eta*1j)*np.identity(dim)-h00)
for i in range(height): # i为格林函数的右下指标
# 初始化开始
G_nn_n_minus = G_11_1
G_in_n_minus = G_11_1
G_ni_n_minus = G_11_1
G_ii_n_minus = G_11_1
for i0 in range(i):
G_nn_n = Green_nn_n(E, eta, h00, h01, G_nn_n_minus)
G_nn_n_minus = G_nn_n
if i!=0:
G_in_n_minus = G_nn_n
G_ni_n_minus = G_nn_n
G_ii_n_minus = G_nn_n
# 初始化结束
for j0 in range(height-1-i): # j0为格林函数的右上指标，表示当前体系大小，即G^{(j0)}
G_nn_n = Green_nn_n(E, eta, h00, h01, G_nn_n_minus)
G_nn_n_minus = G_nn_n
G_ii_n = Green_ii_n(G_ii_n_minus, G_in_n_minus, h01, G_nn_n, G_ni_n_minus) # 需要求的对角分块矩阵
G_ii_n_minus = G_ii_n
G_in_n = Green_in_n(G_in_n_minus, h01, G_nn_n)
G_in_n_minus = G_in_n
G_ni_n = Green_ni_n(G_nn_n, h01, G_ni_n_minus)
G_ni_n_minus = G_ni_n
# 输出
print('z=', i+1, ':')
for j0 in range(width):
print(' y=', j0+1, ':')
for k0 in range(length):
print(' x=', k0+1, ' ', -np.imag(G_ii_n_minus[k0*width+j0, k0*width+j0])/pi) # 态密度
def Green_nn_n(E, eta, H00, V, G_nn_n_minus): # n>=2
dim = H00.shape[0]
G_nn_n = np.linalg.inv((E+eta*1j)*np.identity(dim)-H00-np.dot(np.dot(V.transpose().conj(), G_nn_n_minus), V))
return G_nn_n
def Green_in_n(G_in_n_minus, V, G_nn_n): # n>=2
G_in_n = np.dot(np.dot(G_in_n_minus, V), G_nn_n)
return G_in_n
def Green_ni_n(G_nn_n, V, G_ni_n_minus): # n>=2
G_ni_n = np.dot(np.dot(G_nn_n, V.transpose().conj()), G_ni_n_minus)
return G_ni_n
def Green_ii_n(G_ii_n_minus, G_in_n_minus, V, G_nn_n, G_ni_n_minus): # n>=i
G_ii_n = G_ii_n_minus+np.dot(np.dot(np.dot(np.dot(G_in_n_minus, V), G_nn_n), V.transpose().conj()),G_ni_n_minus)
return G_ii_n
if __name__ == '__main__':
main()

49
academic_codes/density_of_states/2020.12.31_DOS_calculation_using_Dyson_equations/cubic_lattice/get_DOS_by_direct_inverseion_of_Hamiltonian_of_cubic_lattice.py Normal file
View File

@@ -0,0 +1,49 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/7650
"""
import numpy as np
import matplotlib.pyplot as plt
from math import *
def hamiltonian(width, length, height):
h = np.zeros((width*length*height, width*length*height))
for i0 in range(length):
for j0 in range(width):
for k0 in range(height-1):
h[k0*width*length+i0*width+j0, (k0+1)*width*length+i0*width+j0] = 1
h[(k0+1)*width*length+i0*width+j0, k0*width*length+i0*width+j0] = 1
for i0 in range(length):
for j0 in range(width-1):
for k0 in range(height):
h[k0*width*length+i0*width+j0, k0*width*length+i0*width+j0+1] = 1
h[k0*width*length+i0*width+j0+1, k0*width*length+i0*width+j0] = 1
for i0 in range(length-1):
for j0 in range(width):
for k0 in range(height):
h[k0*width*length+i0*width+j0, k0*width*length+(i0+1)*width+j0] = 1
h[k0*width*length+(i0+1)*width+j0, k0*width*length+i0*width+j0] = 1
return h
def main():
height = 2 # z
width = 3 # y
length = 4 # x
h = hamiltonian(width, length, height)
E = 0
green = np.linalg.inv((E+1e-2j)*np.eye(width*length*height)-h)
for k0 in range(height):
print('z=', k0+1, ':')
for j0 in range(width):
print(' y=', j0+1, ':')
for i0 in range(length):
print(' x=', i0+1, ' ', -np.imag(green[k0*width*length+i0*width+j0, k0*width*length+i0*width+j0])/pi) # 态密度
if __name__ == "__main__":
main()

95
academic_codes/density_of_states/2020.12.31_DOS_calculation_using_Dyson_equations/square_lattice/DOS_calculation_using_Dyson_equations_in_square_lattice.py Normal file
View File

@@ -0,0 +1,95 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/7650
"""
import numpy as np
import matplotlib.pyplot as plt
from math import *
def matrix_00(width):
h00 = np.zeros((width, width))
for width0 in range(width-1):
h00[width0, width0+1] = 1
h00[width0+1, width0] = 1
return h00
def matrix_01(width):
h01 = np.identity(width)
return h01
def main():
width = 2
length = 3
eta = 1e-2
E = 0
h00 = matrix_00(width)
h01 = matrix_01(width)
G_ii_n_array = G_ii_n_with_Dyson_equation(width, length, E, eta, h00, h01)
for i0 in range(length):
# print('G_{'+str(i0+1)+','+str(i0+1)+'}^{('+str(length)+')}:')
# print(G_ii_n_array[i0, :, :],'\n')
print('x=', i0+1, ':')
for j0 in range(width):
print(' y=', j0+1, ' ', -np.imag(G_ii_n_array[i0, j0, j0])/pi) # 态密度
def G_ii_n_with_Dyson_equation(width, length, E, eta, h00, h01):
G_ii_n_array = np.zeros((length, width, width), complex)
G_11_1 = np.linalg.inv((E+eta*1j)*np.identity(width)-h00)
for i in range(length): # i为格林函数的右下指标
# 初始化开始
G_nn_n_minus = G_11_1
G_in_n_minus = G_11_1
G_ni_n_minus = G_11_1
G_ii_n_minus = G_11_1
for i0 in range(i):
G_nn_n = Green_nn_n(E, eta, h00, h01, G_nn_n_minus)
G_nn_n_minus = G_nn_n
if i!=0:
G_in_n_minus = G_nn_n
G_ni_n_minus = G_nn_n
G_ii_n_minus = G_nn_n
# 初始化结束
for j0 in range(length-1-i): # j0为格林函数的右上指标，表示当前体系大小，即G^{(j0)}
G_nn_n = Green_nn_n(E, eta, h00, h01, G_nn_n_minus)
G_nn_n_minus = G_nn_n
G_ii_n = Green_ii_n(G_ii_n_minus, G_in_n_minus, h01, G_nn_n, G_ni_n_minus) # 需要求的对角分块矩阵
G_ii_n_minus = G_ii_n
G_in_n = Green_in_n(G_in_n_minus, h01, G_nn_n)
G_in_n_minus = G_in_n
G_ni_n = Green_ni_n(G_nn_n, h01, G_ni_n_minus)
G_ni_n_minus = G_ni_n
G_ii_n_array[i, :, :] = G_ii_n_minus
return G_ii_n_array
def Green_nn_n(E, eta, H00, V, G_nn_n_minus): # n>=2
dim = H00.shape[0]
G_nn_n = np.linalg.inv((E+eta*1j)*np.identity(dim)-H00-np.dot(np.dot(V.transpose().conj(), G_nn_n_minus), V))
return G_nn_n
def Green_in_n(G_in_n_minus, V, G_nn_n): # n>=2
G_in_n = np.dot(np.dot(G_in_n_minus, V), G_nn_n)
return G_in_n
def Green_ni_n(G_nn_n, V, G_ni_n_minus): # n>=2
G_ni_n = np.dot(np.dot(G_nn_n, V.transpose().conj()), G_ni_n_minus)
return G_ni_n
def Green_ii_n(G_ii_n_minus, G_in_n_minus, V, G_nn_n, G_ni_n_minus): # n>=i
G_ii_n = G_ii_n_minus+np.dot(np.dot(np.dot(np.dot(G_in_n_minus, V), G_nn_n), V.transpose().conj()),G_ni_n_minus)
return G_ii_n
if __name__ == '__main__':
main()

41
academic_codes/density_of_states/2020.12.31_DOS_calculation_using_Dyson_equations/square_lattice/get_DOS_by_direct_inverseion_of_Hamiltonian_of_square_lattice.py Normal file
View File

@@ -0,0 +1,41 @@
"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/7650
"""
import numpy as np
import matplotlib.pyplot as plt
from math import *
def hamiltonian(width, length):
h = np.zeros((width*length, width*length))
for i0 in range(length):
for j0 in range(width-1):
h[i0*width+j0, i0*width+j0+1] = 1
h[i0*width+j0+1, i0*width+j0] = 1
for i0 in range(length-1):
for j0 in range(width):
h[i0*width+j0, (i0+1)*width+j0] = 1
h[(i0+1)*width+j0, i0*width+j0] = 1
return h
def main():
width = 2
length = 3
h = hamiltonian(width, length)
E = 0
green = np.linalg.inv((E+1e-2j)*np.eye(width*length)-h)
for i0 in range(length):
# print('G_{'+str(i0+1)+','+str(i0+1)+'}^{('+str(length)+')}:')
# print(green[i0*width+0: i0*width+width, i0*width+0: i0*width+width], '\n')
print('x=', i0+1, ':')
for j0 in range(width):
print(' y=', j0+1, ' ', -np.imag(green[i0*width+j0, i0*width+j0])/pi)
if __name__ == "__main__":
main()