0.1.80

PyPI/setup.cfg

@@ -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

PyPI/src/guan.egg-info/PKG-INFO

@@ -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

PyPI/src/guan/band_structures_and_wave_functions.py

@@ -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
 
 # 旋转两个简并的波函数（说明：参数比较多，算法效率不高）

PyPI/src/guan/density_of_states.py

@@ -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