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

0.1.80

Browse Source
This commit is contained in:
guanjihuan 2024-01-26 00:09:17 +08:00
parent 23a5c80a2b
commit 9de98e961b
4 changed files with 75 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
PyPI/setup.cfg
View File

@ -1,7 +1,7 @@
[metadata]
# replace with your username:
name = guan
version = 0.1.79
version = 0.1.80
author = guanjihuan
author_email = guanjihuan@163.com
description = An open source python package

2
PyPI/src/guan.egg-info/PKG-INFO
View File

@ -1,6 +1,6 @@
Metadata-Version: 2.1
Name: guan
Version: 0.1.79
Version: 0.1.80
Summary: An open source python package
Home-page: https://py.guanjihuan.com
Author: guanjihuan

36
PyPI/src/guan/band_structures_and_wave_functions.py
View File

@ -116,9 +116,35 @@ def find_vector_with_the_same_gauge_with_binary_search(vector_target, vector_ref
print('Phase=', phase)
return vector_target
# 通过使得波函数的一个非零分量为实数，得到固定规范的波函数
# 通过乘一个相反的相位角，实现波函数的一个非零分量为实数，从而得到固定规范的波函数
@guan.statistics_decorator
def find_vector_with_fixed_gauge_by_making_one_component_real(vector, precision=0.005, index=None):
def find_vector_with_fixed_gauge_by_making_one_component_real(vector, index=None):
import numpy as np
import cmath
vector = np.array(vector)
if index == None:
index = np.argmax(np.abs(vector))
angle = cmath.phase(vector[index])
vector = vector*cmath.exp(-1j*angle)
return vector
# 通过乘一个相反的相位角，实现波函数的一个非零分量为实数，从而得到固定规范的波函数（在一组波函数中选取最大的那个分量）
@guan.statistics_decorator
def find_vector_array_with_fixed_gauge_by_making_one_component_real(vector_array):
import numpy as np
import guan
vector_sum = 0
Num_k = np.array(vector_array).shape[0]
for i0 in range(Num_k):
vector_sum += np.abs(vector_array[i0])
index = np.argmax(np.abs(vector_sum))
for i0 in range(Num_k):
vector_array[i0] = guan.find_vector_with_fixed_gauge_by_making_one_component_real(vector_array[i0], index=index)
return vector_array
# 循环查找规范使得波函数的一个非零分量为实数，得到固定规范的波函数
@guan.statistics_decorator
def loop_find_vector_with_fixed_gauge_by_making_one_component_real(vector, precision=0.005, index=None):
import numpy as np
import cmath
vector = np.array(vector)
@ -135,9 +161,9 @@ def find_vector_with_fixed_gauge_by_making_one_component_real(vector, precision=
vector = -vector
return vector
# 通过使得波函数的一个非零分量为实数，得到固定规范的波函数（在一组波函数中选取最大的那个分量）
# 循环查找规范使得波函数的一个非零分量为实数，得到固定规范的波函数（在一组波函数中选取最大的那个分量）
@guan.statistics_decorator
def find_vector_array_with_fixed_gauge_by_making_one_component_real(vector_array, precision=0.005):
def loop_find_vector_array_with_fixed_gauge_by_making_one_component_real(vector_array, precision=0.005):
import numpy as np
import guan
vector_sum = 0
@ -146,7 +172,7 @@ def find_vector_array_with_fixed_gauge_by_making_one_component_real(vector_array
vector_sum += np.abs(vector_array[i0])
index = np.argmax(np.abs(vector_sum))
for i0 in range(Num_k):
vector_array[i0] = guan.find_vector_with_fixed_gauge_by_making_one_component_real(vector_array[i0], precision=precision, index=index)
vector_array[i0] = guan.loop_find_vector_with_fixed_gauge_by_making_one_component_real(vector_array[i0], precision=precision, index=index)
return vector_array
# 旋转两个简并的波函数（说明：参数比较多，算法效率不高）

49
PyPI/src/guan/density_of_states.py
View File

@ -55,7 +55,7 @@ def local_density_of_states_for_cubic_lattice(fermi_energy, hamiltonian, N1, N2,
local_dos[i3, i2, i1] = local_dos[i3, i2, i1]-np.imag(green[i1*N2*N3*internal_degree+i2*N3*internal_degree+i3*internal_degree+i, i1*N2*N3*internal_degree+i2*N3*internal_degree+i3*internal_degree+i])/math.pi
return local_dos
# 利用Dyson方程，计算方格子的局域态密度（其中，h00的维度为：dim_h00 = N2*internal_degree）
# 使用Dyson方程，计算方格子的局域态密度（其中，h00的维度为：dim_h00 = N2*internal_degree）
@guan.statistics_decorator
def local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy, h00, h01, N2, N1, internal_degree=1, broadening=0.01):
import numpy as np
@ -68,14 +68,14 @@ def local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy
green_in_n_minus = green_11_1
green_ni_n_minus = green_11_1
green_ii_n_minus = green_11_1
for i2_0 in range(i1):
for _ in range(i1):
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
if i1!=0:
green_in_n_minus = green_nn_n
green_ni_n_minus = green_nn_n
green_ii_n_minus = green_nn_n
for size_0 in range(N1-1-i1):
for _ in range(N1-1-i1):
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
green_ii_n = guan.green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus)
@ -89,7 +89,42 @@ def local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy
local_dos[i2, i1] = local_dos[i2, i1] - np.imag(green_ii_n_minus[i2*internal_degree+i, i2*internal_degree+i])/math.pi
return local_dos
# 利用Dyson方程，计算立方格子的局域态密度（其中，h00的维度为：dim_h00 = N2*N3*internal_degree）
# 使用Dyson方程，计算方格子的局域态密度，方法二（其中，h00的维度为：dim_h00 = N2*internal_degree）
@guan.statistics_decorator
def local_density_of_states_for_square_lattice_using_dyson_equation_with_second_method(fermi_energy, h00, h01, N2, N1, internal_degree=1, broadening=0.01):
import numpy as np
import math
import guan
h01 = np.array(h01)
if np.array(h00).shape==():
dim = 1
else:
dim = np.array(h00).shape[0]
local_dos = np.zeros((N2, N1))
green_11_1 = guan.green_function(fermi_energy, h00, broadening)
for i1 in range(N1):
green_nn_n_right_minus = green_11_1
green_nn_n_left_minus = green_11_1
if i1!=0:
for _ in range(i1-1):
green_nn_n_right = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_right_minus, broadening)
green_nn_n_right_minus = green_nn_n_right
if i1!=N1-1:
for _ in range(N1-i1-2):
G_nn_n_left = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_left_minus, broadening)
green_nn_n_left_minus = G_nn_n_left
if i1==0:
green_ii_n = np.linalg.inv((fermi_energy+broadening*1j)*np.identity(dim)-h00-np.dot(np.dot(h01, green_nn_n_left_minus), h01.transpose().conj()))
elif i1!=0 and i1!=N1-1:
green_ii_n = np.linalg.inv((fermi_energy+broadening*1j)*np.identity(dim)-h00-np.dot(np.dot(h01.transpose().conj(), green_nn_n_right_minus), h01)-np.dot(np.dot(h01, green_nn_n_left_minus), h01.transpose().conj()))
elif i1==N1-1:
green_ii_n = np.linalg.inv((fermi_energy+broadening*1j)*np.identity(dim)-h00-np.dot(np.dot(h01.transpose().conj(), green_nn_n_right_minus), h01))
for i2 in range(N2):
for i in range(internal_degree):
local_dos[i2, i1] = local_dos[i2, i1] - np.imag(green_ii_n[i2*internal_degree+i, i2*internal_degree+i])/math.pi
return local_dos
# 使用Dyson方程，计算立方格子的局域态密度（其中，h00的维度为：dim_h00 = N2*N3*internal_degree）
@guan.statistics_decorator
def local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy, h00, h01, N3, N2, N1, internal_degree=1, broadening=0.01):
import numpy as np
@ -102,14 +137,14 @@ def local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy,
green_in_n_minus = green_11_1
green_ni_n_minus = green_11_1
green_ii_n_minus = green_11_1
for i1_0 in range(i1):
for _ in range(i1):
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
if i1!=0:
green_in_n_minus = green_nn_n
green_ni_n_minus = green_nn_n
green_ii_n_minus = green_nn_n
for size_0 in range(N1-1-i1):
for _ in range(N1-1-i1):
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
green_ii_n = guan.green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus)
@ -124,7 +159,7 @@ def local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy,
local_dos[i3, i2, i1] = local_dos[i3, i2, i1] -np.imag(green_ii_n_minus[i2*N3*internal_degree+i3*internal_degree+i, i2*N3*internal_degree+i3*internal_degree+i])/math.pi
return local_dos
# 利用Dyson方程，计算方格子条带（考虑了电极自能）的局域态密度（其中，h00的维度为：dim_h00 = N2*internal_degree）
# 使用Dyson方程，计算方格子条带（考虑了电极自能）的局域态密度（其中，h00的维度为：dim_h00 = N2*internal_degree）
@guan.statistics_decorator
def local_density_of_states_for_square_lattice_with_self_energy_using_dyson_equation(fermi_energy, h00, h01, N2, N1, right_self_energy, left_self_energy, internal_degree=1, broadening=0.01):
import numpy as np