update

academic_codes/2020.11.27_find_the_same_gauge_numerically_by_binary_search/function_form.py

@@ -1,39 +0,0 @@
-"""
-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/7516
-"""
-
-def find_vector_with_the_same_gauge(vector_1, vector_0):
-    # 寻找近似的同一的规范
-    phase_1_pre = 0
-    phase_2_pre = pi
-    n_test = 10001
-    for i0 in range(n_test):
-        test_1 = np.sum(np.abs(vector_1*cmath.exp(1j*phase_1_pre) - vector_0))
-        test_2 = np.sum(np.abs(vector_1*cmath.exp(1j*phase_2_pre) - vector_0))
-        if test_1 < 1e-6:
-            phase = phase_1_pre
-            # print('Done with i0=', i0)
-            break
-        if i0 == n_test-1:
-            phase = phase_1_pre
-            print('Gauge Not Found with i0=', i0)
-        if test_1 < test_2:
-            if i0 == 0:
-                phase_1 = phase_1_pre-(phase_2_pre-phase_1_pre)/2
-                phase_2 = phase_1_pre+(phase_2_pre-phase_1_pre)/2
-            else:
-                phase_1 = phase_1_pre
-                phase_2 = phase_1_pre+(phase_2_pre-phase_1_pre)/2
-        else:
-            if i0 == 0:
-                phase_1 = phase_2_pre-(phase_2_pre-phase_1_pre)/2
-                phase_2 = phase_2_pre+(phase_2_pre-phase_1_pre)/2
-            else:
-                phase_1 = phase_2_pre-(phase_2_pre-phase_1_pre)/2
-                phase_2 = phase_2_pre 
-        phase_1_pre = phase_1
-        phase_2_pre = phase_2
-    vector_1 = vector_1*cmath.exp(1j*phase)
-    # print('二分查找找到的规范=', phase)   
-    return vector_1

academic_codes/2020.11.27_find_the_same_gauge_numerically_with_binary_search/find_the_same_gauge_numerically_with_binary_search.py

@@ -4,7 +4,6 @@ The newest version of this code is on the web page: https://www.guanjihuan.com/a
 """
 
 import numpy as np
-import matplotlib.pyplot as plt
 from math import *   # 引入pi, cos等
 import cmath
 import time

academic_codes/2020.11.27_find_the_same_gauge_numerically_with_binary_search/find_the_same_gauge_numerically_with_guan.py

@@ -0,0 +1,78 @@
+"""
+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/7516
+"""
+
+import numpy as np
+from math import * 
+import cmath
+import time
+import guan
+
+
+def hamiltonian(kx, ky):  # 量子反常霍尔QAH模型（该参数对应的陈数为2）
+    t1 = 1.0
+    t2 = 1.0
+    t3 = 0.5
+    m = -1.0
+    matrix = np.zeros((2, 2))*(1+0j)
+    matrix[0, 1] = 2*t1*cos(kx)-1j*2*t1*cos(ky)
+    matrix[1, 0] = 2*t1*cos(kx)+1j*2*t1*cos(ky)
+    matrix[0, 0] = m+2*t3*sin(kx)+2*t3*sin(ky)+2*t2*cos(kx+ky)
+    matrix[1, 1] = -(m+2*t3*sin(kx)+2*t3*sin(ky)+2*t2*cos(kx+ky))
+    return matrix
+
+
+def main():
+    start_time = time.time()
+    n = 100  # 积分密度
+    delta = 1e-9  # 求导的偏离量
+    chern_number = 0  # 陈数初始化
+    for kx in np.arange(-pi, pi, 2*pi/n):
+        for ky in np.arange(-pi, pi, 2*pi/n):
+            H = hamiltonian(kx, ky)
+            eigenvalue, eigenvector = np.linalg.eig(H)
+            vector = eigenvector[:, np.argsort(np.real(eigenvalue))[0]]  # 价带波函数
+
+            H_delta_kx = hamiltonian(kx+delta, ky) 
+            eigenvalue, eigenvector = np.linalg.eig(H_delta_kx)
+            vector_delta_kx = eigenvector[:, np.argsort(np.real(eigenvalue))[0]]   # 略偏离kx的波函数
+
+            H_delta_ky = hamiltonian(kx, ky+delta)  
+            eigenvalue, eigenvector = np.linalg.eig(H_delta_ky)
+            vector_delta_ky = eigenvector[:, np.argsort(np.real(eigenvalue))[0]]  # 略偏离ky的波函数
+
+            H_delta_kx_ky = hamiltonian(kx+delta, ky+delta)  
+            eigenvalue, eigenvector = np.linalg.eig(H_delta_kx_ky)
+            vector_delta_kx_ky = eigenvector[:, np.argsort(np.real(eigenvalue))[0]]  # 略偏离kx和ky的波函数
+
+            # vector = vector*cmath.exp(-1j*1)
+            # vector_delta_kx = vector_delta_kx*cmath.exp(-1j*1)
+            # vector_delta_ky = vector_delta_ky*cmath.exp(-1j*1)
+            # vector_delta_kx_ky = vector_delta_kx_ky*cmath.exp(-1j*(1+1e-8))
+
+            rand = np.random.uniform(-pi, pi)
+            vector_delta_kx_ky = vector_delta_kx_ky*cmath.exp(-1j*rand)
+
+            vector_delta_kx_ky = guan.find_vector_with_the_same_gauge_with_binary_search(vector_delta_kx_ky, vector)
+            
+            # 价带的波函数的贝里联络(berry connection) # 求导后内积
+            A_x = np.dot(vector.transpose().conj(), (vector_delta_kx-vector)/delta)   # 贝里联络Ax（x分量）
+            A_y = np.dot(vector.transpose().conj(), (vector_delta_ky-vector)/delta)   # 贝里联络Ay（y分量）
+            
+            A_x_delta_ky = np.dot(vector_delta_ky.transpose().conj(), (vector_delta_kx_ky-vector_delta_ky)/delta)  # 略偏离ky的贝里联络Ax
+            A_y_delta_kx = np.dot(vector_delta_kx.transpose().conj(), (vector_delta_kx_ky-vector_delta_kx)/delta)  # 略偏离kx的贝里联络Ay
+
+            # 贝里曲率(berry curvature)
+            F = (A_y_delta_kx-A_y)/delta-(A_x_delta_ky-A_x)/delta
+
+            # 陈数(chern number)
+            chern_number = chern_number + F*(2*pi/n)**2
+    chern_number = chern_number/(2*pi*1j)
+    print('Chern number = ', chern_number)
+    end_time = time.time()
+    print('运行时间(min)=', (end_time-start_time)/60)
+
+
+if __name__ == '__main__':
+    main()

academic_codes/2021.03.01_Wilson_loop_in_SSH_model/Wilson_loop_in_SSH_model.py

@@ -8,13 +8,12 @@ import cmath
 from math import *
 
 
-def hamiltonian(k):
+def hamiltonian(k):  # SSH模型哈密顿量
     gamma = 0.5
     lambda0 = 1
-    delta = 0
     h = np.zeros((2, 2))*(1+0j)
-    h[0,0] = delta
+    h[0,0] = 0
-    h[1,1] = -delta
+    h[1,1] = 0
     h[0,1] = gamma+lambda0*cmath.exp(-1j*k)
     h[1,0] = gamma+lambda0*cmath.exp(1j*k)
     return h
@@ -27,11 +26,16 @@ def main():
     for k in k_array:
         vector  = get_occupied_bands_vectors(k, hamiltonian)   
         vector_array.append(vector)
+        # vector_array.append(vector*cmath.exp(1j*np.random.uniform(0, pi)))
 
     # 波函数固定一个规范
-    index = np.argmax(np.abs(vector_array[0]))
     for i0 in range(Num_k):
-        vector_array[i0] = find_vector_with_fixed_gauge(vector_array[i0], index)
+        vector_array[i0] = find_vector_with_fixed_gauge_by_making_one_component_real(vector_array[i0])
+
+    # 波函数固定一个规范
+    # import guan
+    # for i0 in range(Num_k):
+    #     vector_array[i0] = guan.find_vector_with_fixed_gauge_by_making_one_component_real(vector_array[i0])
 
     # 计算Wilson loop
     W_k = 1
@@ -51,9 +55,10 @@ def get_occupied_bands_vectors(x, matrix):
     return vector
 
 
-def find_vector_with_fixed_gauge(vector, index):
+def find_vector_with_fixed_gauge_by_making_one_component_real(vector, precision=0.005):
+    index = np.argmax(np.abs(vector))
     sign_pre = np.sign(np.imag(vector[index]))
-    for phase in np.arange(0, 2*pi, 0.01):
+    for phase in np.arange(0, 2*pi, precision):
         sign =  np.sign(np.imag(vector[index]*cmath.exp(1j*phase)))
         if np.abs(np.imag(vector[index]*cmath.exp(1j*phase))) < 1e-9 or sign == -sign_pre:
             break