0.1.44

PyPI/setup.cfg

@@ -1,7 +1,7 @@
 [metadata]
 # replace with your username:
 name = guan
-version = 0.1.43
+version = 0.1.44
 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.43
+Version: 0.1.44
 Summary: An open source python package
 Home-page: https://py.guanjihuan.com
 Author: guanjihuan

PyPI/src/guan.egg-info/SOURCES.txt

@@ -4,18 +4,14 @@ pyproject.toml
 setup.cfg
 src/guan/Fourier_transform.py
 src/guan/Green_functions.py
-src/guan/Hamiltonian_of_finite_size_systems.py
+src/guan/Hamiltonian_of_examples.py
-src/guan/Hamiltonian_of_models_in_reciprocal_space.py
 src/guan/__init__.py
 src/guan/band_structures_and_wave_functions.py
 src/guan/basic_functions.py
 src/guan/data_processing.py
 src/guan/density_of_states.py
-src/guan/file_processing.py
 src/guan/others.py
-src/guan/plot_figures.py
 src/guan/quantum_transport.py
-src/guan/read_and_write.py
 src/guan/topological_invariant.py
 src/guan.egg-info/PKG-INFO
 src/guan.egg-info/SOURCES.txt

PyPI/src/guan/Hamiltonian_of_examples.py

@@ -0,0 +1,574 @@
+# Module: Hamiltonian_of_examples
+
+# 构建一维的有限尺寸体系哈密顿量（可设置是否为周期边界条件）
+def hamiltonian_of_finite_size_system_along_one_direction(N, on_site=0, hopping=1, period=0):
+    import numpy as np
+    on_site = np.array(on_site)
+    hopping = np.array(hopping)
+    if on_site.shape==():
+        dim = 1
+    else:
+        dim = on_site.shape[0]
+    hamiltonian = np.zeros((N*dim, N*dim), dtype=complex)
+    for i0 in range(N):
+        hamiltonian[i0*dim+0:i0*dim+dim, i0*dim+0:i0*dim+dim] = on_site
+    for i0 in range(N-1):
+        hamiltonian[i0*dim+0:i0*dim+dim, (i0+1)*dim+0:(i0+1)*dim+dim] = hopping
+        hamiltonian[(i0+1)*dim+0:(i0+1)*dim+dim, i0*dim+0:i0*dim+dim] = hopping.transpose().conj()
+    if period == 1:
+        hamiltonian[(N-1)*dim+0:(N-1)*dim+dim, 0:dim] = hopping
+        hamiltonian[0:dim, (N-1)*dim+0:(N-1)*dim+dim] = hopping.transpose().conj()
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 构建二维的方格子有限尺寸体系哈密顿量（可设置是否为周期边界条件）
+def hamiltonian_of_finite_size_system_along_two_directions_for_square_lattice(N1, N2, on_site=0, hopping_1=1, hopping_2=1, period_1=0, period_2=0):
+    import numpy as np
+    on_site = np.array(on_site)
+    hopping_1 = np.array(hopping_1)
+    hopping_2 = np.array(hopping_2)
+    if on_site.shape==():
+        dim = 1
+    else:
+        dim = on_site.shape[0]
+    hamiltonian = np.zeros((N1*N2*dim, N1*N2*dim), dtype=complex)    
+    for i1 in range(N1):
+        for i2 in range(N2):
+            hamiltonian[i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim, i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim] = on_site
+    for i1 in range(N1-1):
+        for i2 in range(N2):
+            hamiltonian[i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim, (i1+1)*N2*dim+i2*dim+0:(i1+1)*N2*dim+i2*dim+dim] = hopping_1
+            hamiltonian[(i1+1)*N2*dim+i2*dim+0:(i1+1)*N2*dim+i2*dim+dim, i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim] = hopping_1.transpose().conj()
+    for i1 in range(N1):
+        for i2 in range(N2-1):
+            hamiltonian[i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim, i1*N2*dim+(i2+1)*dim+0:i1*N2*dim+(i2+1)*dim+dim] = hopping_2
+            hamiltonian[i1*N2*dim+(i2+1)*dim+0:i1*N2*dim+(i2+1)*dim+dim, i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim] = hopping_2.transpose().conj()
+    if period_1 == 1:
+        for i2 in range(N2):
+            hamiltonian[(N1-1)*N2*dim+i2*dim+0:(N1-1)*N2*dim+i2*dim+dim, i2*dim+0:i2*dim+dim] = hopping_1
+            hamiltonian[i2*dim+0:i2*dim+dim, (N1-1)*N2*dim+i2*dim+0:(N1-1)*N2*dim+i2*dim+dim] = hopping_1.transpose().conj()
+    if period_2 == 1:
+        for i1 in range(N1):
+            hamiltonian[i1*N2*dim+(N2-1)*dim+0:i1*N2*dim+(N2-1)*dim+dim, i1*N2*dim+0:i1*N2*dim+dim] = hopping_2
+            hamiltonian[i1*N2*dim+0:i1*N2*dim+dim, i1*N2*dim+(N2-1)*dim+0:i1*N2*dim+(N2-1)*dim+dim] = hopping_2.transpose().conj()
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 构建三维的立方格子有限尺寸体系哈密顿量（可设置是否为周期边界条件）
+def hamiltonian_of_finite_size_system_along_three_directions_for_cubic_lattice(N1, N2, N3, on_site=0, hopping_1=1, hopping_2=1, hopping_3=1, period_1=0, period_2=0, period_3=0):
+    import numpy as np
+    on_site = np.array(on_site)
+    hopping_1 = np.array(hopping_1)
+    hopping_2 = np.array(hopping_2)
+    hopping_3 = np.array(hopping_3)
+    if on_site.shape==():
+        dim = 1
+    else:
+        dim = on_site.shape[0]
+    hamiltonian = np.zeros((N1*N2*N3*dim, N1*N2*N3*dim), dtype=complex) 
+    for i1 in range(N1):
+        for i2 in range(N2):
+            for i3 in range(N3):
+                hamiltonian[i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim, i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim] = on_site
+    for i1 in range(N1-1):
+        for i2 in range(N2):
+            for i3 in range(N3):
+                hamiltonian[i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim, (i1+1)*N2*N3*dim+i2*N3*dim+i3*dim+0:(i1+1)*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_1
+                hamiltonian[(i1+1)*N2*N3*dim+i2*N3*dim+i3*dim+0:(i1+1)*N2*N3*dim+i2*N3*dim+i3*dim+dim, i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_1.transpose().conj()
+    for i1 in range(N1):
+        for i2 in range(N2-1):
+            for i3 in range(N3):
+                hamiltonian[i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim, i1*N2*N3*dim+(i2+1)*N3*dim+i3*dim+0:i1*N2*N3*dim+(i2+1)*N3*dim+i3*dim+dim] = hopping_2
+                hamiltonian[i1*N2*N3*dim+(i2+1)*N3*dim+i3*dim+0:i1*N2*N3*dim+(i2+1)*N3*dim+i3*dim+dim, i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_2.transpose().conj()
+    for i1 in range(N1):
+        for i2 in range(N2):
+            for i3 in range(N3-1):
+                hamiltonian[i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim, i1*N2*N3*dim+i2*N3*dim+(i3+1)*dim+0:i1*N2*N3*dim+i2*N3*dim+(i3+1)*dim+dim] = hopping_3
+                hamiltonian[i1*N2*N3*dim+i2*N3*dim+(i3+1)*dim+0:i1*N2*N3*dim+i2*N3*dim+(i3+1)*dim+dim, i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_3.transpose().conj()
+    if period_1 == 1:
+        for i2 in range(N2):
+            for i3 in range(N3):
+                hamiltonian[(N1-1)*N2*N3*dim+i2*N3*dim+i3*dim+0:(N1-1)*N2*N3*dim+i2*N3*dim+i3*dim+dim, i2*N3*dim+i3*dim+0:i2*N3*dim+i3*dim+dim] = hopping_1
+                hamiltonian[i2*N3*dim+i3*dim+0:i2*N3*dim+i3*dim+dim, (N1-1)*N2*N3*dim+i2*N3*dim+i3*dim+0:(N1-1)*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_1.transpose().conj()
+    if period_2 == 1:
+        for i1 in range(N1):
+            for i3 in range(N3):
+                hamiltonian[i1*N2*N3*dim+(N2-1)*N3*dim+i3*dim+0:i1*N2*N3*dim+(N2-1)*N3*dim+i3*dim+dim, i1*N2*N3*dim+i3*dim+0:i1*N2*N3*dim+i3*dim+dim] = hopping_2
+                hamiltonian[i1*N2*N3*dim+i3*dim+0:i1*N2*N3*dim+i3*dim+dim, i1*N2*N3*dim+(N2-1)*N3*dim+i3*dim+0:i1*N2*N3*dim+(N2-1)*N3*dim+i3*dim+dim] = hopping_2.transpose().conj()
+    if period_3 == 1:
+        for i1 in range(N1):
+            for i2 in range(N2):
+                hamiltonian[i1*N2*N3*dim+i2*N3*dim+(N3-1)*dim+0:i1*N2*N3*dim+i2*N3*dim+(N3-1)*dim+dim, i1*N2*N3*dim+i2*N3*dim+0:i1*N2*N3*dim+i2*N3*dim+dim] = hopping_3
+                hamiltonian[i1*N2*N3*dim+i2*N3*dim+0:i1*N2*N3*dim+i2*N3*dim+dim, i1*N2*N3*dim+i2*N3*dim+(N3-1)*dim+0:i1*N2*N3*dim+i2*N3*dim+(N3-1)*dim+dim] = hopping_3.transpose().conj()
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 构建有限尺寸的SSH模型哈密顿量
+def hamiltonian_of_finite_size_ssh_model(N, v=0.6, w=1, onsite_1=0, onsite_2=0, period=1):
+    import numpy as np
+    hamiltonian = np.zeros((2*N, 2*N))
+    for i in range(N):
+        hamiltonian[i*2+0, i*2+0] = onsite_1
+        hamiltonian[i*2+1, i*2+1] = onsite_2
+        hamiltonian[i*2+0, i*2+1] = v
+        hamiltonian[i*2+1, i*2+0] = v
+    for i in range(N-1):
+        hamiltonian[i*2+1, (i+1)*2+0] = w
+        hamiltonian[(i+1)*2+0, i*2+1] = w
+    if period==1:
+        hamiltonian[0, 2*N-1] = w
+        hamiltonian[2*N-1, 0] = w
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 获取Zigzag边的石墨烯条带的元胞间跃迁
+def get_hopping_term_of_graphene_ribbon_along_zigzag_direction(N, eta=0):
+    import numpy as np
+    hopping = np.zeros((4*N, 4*N), dtype=complex)
+    for i0 in range(N):
+        hopping[4*i0+0, 4*i0+0] = eta
+        hopping[4*i0+1, 4*i0+1] = eta
+        hopping[4*i0+2, 4*i0+2] = eta
+        hopping[4*i0+3, 4*i0+3] = eta
+        hopping[4*i0+1, 4*i0+0] = 1
+        hopping[4*i0+2, 4*i0+3] = 1
+    import guan
+    guan.statistics_of_guan_package()
+    return hopping
+
+# 构建有限尺寸的石墨烯哈密顿量（可设置是否为周期边界条件）
+def hamiltonian_of_finite_size_system_along_two_directions_for_graphene(N1, N2, period_1=0, period_2=0):
+    import numpy as np
+    import guan
+    on_site = guan.hamiltonian_of_finite_size_system_along_one_direction(4)
+    hopping_1 = guan.get_hopping_term_of_graphene_ribbon_along_zigzag_direction(1)
+    hopping_2 = np.zeros((4, 4), dtype=complex)
+    hopping_2[3, 0] = 1
+    hamiltonian = guan.hamiltonian_of_finite_size_system_along_two_directions_for_square_lattice(N1, N2, on_site, hopping_1, hopping_2, period_1, period_2)
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 获取石墨烯有效模型沿着x方向的在位能和跃迁项（其中，动量qy为参数）
+def get_onsite_and_hopping_terms_of_2d_effective_graphene_along_one_direction(qy, t=1, staggered_potential=0, eta=0, valley_index=0):
+    import numpy as np
+    constant = -np.sqrt(3)/2
+    h00 = np.zeros((2, 2), dtype=complex)
+    h00[0, 0] = staggered_potential
+    h00[1, 1] = -staggered_potential
+    h00[0, 1] = -1j*constant*t*np.sin(qy)
+    h00[1, 0] = 1j*constant*t*np.sin(qy)
+    h01 = np.zeros((2, 2), dtype=complex)
+    h01[0, 0] = eta
+    h01[1, 1] = eta
+    if valley_index == 0:
+        h01[0, 1] = constant*t*(-1j/2)
+        h01[1, 0] = constant*t*(-1j/2)
+    else:
+        h01[0, 1] = constant*t*(1j/2)
+        h01[1, 0] = constant*t*(1j/2)
+    import guan
+    guan.statistics_of_guan_package()
+    return h00, h01
+
+# 获取BHZ模型的在位能和跃迁项
+def get_onsite_and_hopping_terms_of_bhz_model(A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01, a=1):
+    import numpy as np
+    E_s = C+M-4*(D+B)/(a**2)
+    E_p = C-M-4*(D-B)/(a**2)
+    V_ss = (D+B)/(a**2)
+    V_pp = (D-B)/(a**2)
+    V_sp = -1j*A/(2*a)
+    H0 = np.zeros((4, 4), dtype=complex)
+    H1 = np.zeros((4, 4), dtype=complex)
+    H2 = np.zeros((4, 4), dtype=complex)
+    H0[0, 0] = E_s
+    H0[1, 1] = E_p
+    H0[2, 2] = E_s
+    H0[3, 3] = E_p
+    H1[0, 0] = V_ss
+    H1[1, 1] = V_pp
+    H1[2, 2] = V_ss
+    H1[3, 3] = V_pp
+    H1[0, 1] = V_sp
+    H1[1, 0] = -np.conj(V_sp)
+    H1[2, 3] = np.conj(V_sp)
+    H1[3, 2] = -V_sp
+    H2[0, 0] = V_ss
+    H2[1, 1] = V_pp
+    H2[2, 2] = V_ss
+    H2[3, 3] = V_pp
+    H2[0, 1] = 1j*V_sp
+    H2[1, 0] = 1j*np.conj(V_sp)
+    H2[2, 3] = -1j*np.conj(V_sp)
+    H2[3, 2] = -1j*V_sp
+    import guan
+    guan.statistics_of_guan_package()
+    return H0, H1, H2
+
+# 获取半个BHZ模型的在位能和跃迁项（自旋向上）
+def get_onsite_and_hopping_terms_of_half_bhz_model_for_spin_up(A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01, a=1):
+    import numpy as np
+    E_s = C+M-4*(D+B)/(a**2)
+    E_p = C-M-4*(D-B)/(a**2)
+    V_ss = (D+B)/(a**2)
+    V_pp = (D-B)/(a**2)
+    V_sp = -1j*A/(2*a)
+    H0 = np.zeros((2, 2), dtype=complex)
+    H1 = np.zeros((2, 2), dtype=complex)
+    H2 = np.zeros((2, 2), dtype=complex)
+    H0[0, 0] = E_s
+    H0[1, 1] = E_p
+    H1[0, 0] = V_ss
+    H1[1, 1] = V_pp
+    H1[0, 1] = V_sp
+    H1[1, 0] = -np.conj(V_sp)
+    H2[0, 0] = V_ss
+    H2[1, 1] = V_pp
+    H2[0, 1] = 1j*V_sp
+    H2[1, 0] = 1j*np.conj(V_sp)
+    import guan
+    guan.statistics_of_guan_package()
+    return H0, H1, H2
+
+# 获取半个BHZ模型的在位能和跃迁项（自旋向下）
+def get_onsite_and_hopping_terms_of_half_bhz_model_for_spin_down(A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01, a=1):
+    import numpy as np
+    E_s = C+M-4*(D+B)/(a**2)
+    E_p = C-M-4*(D-B)/(a**2)
+    V_ss = (D+B)/(a**2)
+    V_pp = (D-B)/(a**2)
+    V_sp = -1j*A/(2*a)
+    H0 = np.zeros((2, 2), dtype=complex)
+    H1 = np.zeros((2, 2), dtype=complex)
+    H2 = np.zeros((2, 2), dtype=complex)
+    H0[0, 0] = E_s
+    H0[1, 1] = E_p
+    H1[0, 0] = V_ss
+    H1[1, 1] = V_pp
+    H1[0, 1] = np.conj(V_sp)
+    H1[1, 0] = -V_sp
+    H2[0, 0] = V_ss
+    H2[1, 1] = V_pp
+    H2[0, 1] = -1j*np.conj(V_sp)
+    H2[1, 0] = -1j*V_sp
+    import guan
+    guan.statistics_of_guan_package()
+    return H0, H1, H2
+
+# 一维链的哈密顿量（倒空间）
+def hamiltonian_of_simple_chain(k):
+    import guan
+    hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=0, hopping=1)
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 二维方格子的哈密顿量（倒空间）
+def hamiltonian_of_square_lattice(k1, k2):
+    import guan
+    hamiltonian = guan.two_dimensional_fourier_transform_for_square_lattice(k1, k2, unit_cell=0, hopping_1=1, hopping_2=1)
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 准一维方格子条带的哈密顿量（倒空间）
+def hamiltonian_of_square_lattice_in_quasi_one_dimension(k, N=10, period=0):
+    import numpy as np
+    import guan
+    h00 = np.zeros((N, N), dtype=complex)  # hopping in a unit cell
+    h01 = np.zeros((N, N), dtype=complex)  # hopping between unit cells
+    for i in range(N-1):   
+        h00[i, i+1] = 1
+        h00[i+1, i] = 1
+    if period == 1:
+        h00[N-1, 0] = 1
+        h00[0, N-1] = 1
+    for i in range(N):   
+        h01[i, i] = 1
+    hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=h00, hopping=h01)
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 三维立方格子的哈密顿量（倒空间）
+def hamiltonian_of_cubic_lattice(k1, k2, k3):
+    import guan
+    hamiltonian = guan.three_dimensional_fourier_transform_for_cubic_lattice(k1, k2, k3, unit_cell=0, hopping_1=1, hopping_2=1, hopping_3=1)
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# SSH模型的哈密顿量（倒空间）
+def hamiltonian_of_ssh_model(k, v=0.6, w=1):
+    import numpy as np
+    import cmath
+    hamiltonian = np.zeros((2, 2), dtype=complex)
+    hamiltonian[0,1] = v+w*cmath.exp(-1j*k)
+    hamiltonian[1,0] = v+w*cmath.exp(1j*k)
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 石墨烯的哈密顿量（倒空间）
+def hamiltonian_of_graphene(k1, k2, staggered_potential=0, t=1, a='default'):
+    import numpy as np
+    import cmath
+    import math
+    if a == 'default':
+        a = 1/math.sqrt(3)
+    h0 = np.zeros((2, 2), dtype=complex)  # mass term
+    h1 = np.zeros((2, 2), dtype=complex)  # nearest hopping
+    h0[0, 0] = staggered_potential     
+    h0[1, 1] = -staggered_potential
+    h1[1, 0] = t*(cmath.exp(1j*k2*a)+cmath.exp(1j*math.sqrt(3)/2*k1*a-1j/2*k2*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a-1j/2*k2*a))   
+    h1[0, 1] = h1[1, 0].conj()
+    hamiltonian = h0 + h1
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 石墨烯有效模型的哈密顿量（倒空间）
+def effective_hamiltonian_of_graphene(qx, qy, t=1, staggered_potential=0, valley_index=0):
+    import numpy as np
+    hamiltonian = np.zeros((2, 2), dtype=complex)
+    hamiltonian[0, 0] = staggered_potential
+    hamiltonian[1, 1] = -staggered_potential
+    constant = -np.sqrt(3)/2
+    if valley_index == 0:
+        hamiltonian[0, 1] = constant*t*(qx-1j*qy)
+        hamiltonian[1, 0] = constant*t*(qx+1j*qy)
+    else:
+        hamiltonian[0, 1] = constant*t*(-qx-1j*qy)
+        hamiltonian[1, 0] = constant*t*(-qx+1j*qy)
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 石墨烯有效模型离散化后的哈密顿量（倒空间）
+def effective_hamiltonian_of_graphene_after_discretization(qx, qy, t=1, staggered_potential=0, valley_index=0):
+    import numpy as np
+    hamiltonian = np.zeros((2, 2), dtype=complex)
+    hamiltonian[0, 0] = staggered_potential
+    hamiltonian[1, 1] = -staggered_potential
+    constant = -np.sqrt(3)/2
+    if valley_index == 0:
+        hamiltonian[0, 1] = constant*t*(np.sin(qx)-1j*np.sin(qy))
+        hamiltonian[1, 0] = constant*t*(np.sin(qx)+1j*np.sin(qy))
+    else:
+        hamiltonian[0, 1] = constant*t*(-np.sin(qx)-1j*np.sin(qy))
+        hamiltonian[1, 0] = constant*t*(-np.sin(qx)+1j*np.sin(qy))
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 准一维Zigzag边石墨烯条带的哈密顿量（倒空间）
+def hamiltonian_of_graphene_with_zigzag_in_quasi_one_dimension(k, N=10, M=0, t=1, period=0):
+    import numpy as np
+    import guan
+    h00 = np.zeros((4*N, 4*N), dtype=complex)  # hopping in a unit cell
+    h01 = np.zeros((4*N, 4*N), dtype=complex)  # hopping between unit cells
+    for i in range(N):
+        h00[i*4+0, i*4+0] = M
+        h00[i*4+1, i*4+1] = -M
+        h00[i*4+2, i*4+2] = M
+        h00[i*4+3, i*4+3] = -M
+        h00[i*4+0, i*4+1] = t
+        h00[i*4+1, i*4+0] = t
+        h00[i*4+1, i*4+2] = t
+        h00[i*4+2, i*4+1] = t
+        h00[i*4+2, i*4+3] = t
+        h00[i*4+3, i*4+2] = t
+    for i in range(N-1):
+        h00[i*4+3, (i+1)*4+0] = t
+        h00[(i+1)*4+0, i*4+3] = t
+    if period == 1:
+        h00[(N-1)*4+3, 0] = t
+        h00[0, (N-1)*4+3] = t
+    for i in range(N):
+        h01[i*4+1, i*4+0] = t
+        h01[i*4+2, i*4+3] = t
+    hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=h00, hopping=h01)
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# Haldane模型的哈密顿量（倒空间）
+def hamiltonian_of_haldane_model(k1, k2, M=2/3, t1=1, t2=1/3, phi='default', a='default'):
+    import numpy as np
+    import cmath
+    import math
+    if phi == 'default':
+        phi=math.pi/4
+    if a == 'default':
+        a=1/math.sqrt(3)
+    h0 = np.zeros((2, 2), dtype=complex)  # mass term
+    h1 = np.zeros((2, 2), dtype=complex)  # nearest hopping
+    h2 = np.zeros((2, 2), dtype=complex)  # next nearest hopping
+    h0[0, 0] = M
+    h0[1, 1] = -M
+    h1[1, 0] = t1*(cmath.exp(1j*k2*a)+cmath.exp(1j*math.sqrt(3)/2*k1*a-1j/2*k2*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a-1j/2*k2*a))
+    h1[0, 1] = h1[1, 0].conj()
+    h2[0, 0] = t2*cmath.exp(-1j*phi)*(cmath.exp(1j*math.sqrt(3)*k1*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a+1j*3/2*k2*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a-1j*3/2*k2*a))
+    h2[1, 1] = t2*cmath.exp(1j*phi)*(cmath.exp(1j*math.sqrt(3)*k1*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a+1j*3/2*k2*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a-1j*3/2*k2*a))
+    hamiltonian = h0 + h1 + h2 + h2.transpose().conj()
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 准一维Haldane模型条带的哈密顿量（倒空间）
+def hamiltonian_of_haldane_model_in_quasi_one_dimension(k, N=10, M=2/3, t1=1, t2=1/3, phi='default', period=0):
+    import numpy as np
+    import cmath
+    import math
+    if phi == 'default':
+        phi=math.pi/4
+    h00 = np.zeros((4*N, 4*N), dtype=complex)  # hopping in a unit cell
+    h01 = np.zeros((4*N, 4*N), dtype=complex)  # hopping between unit cells
+    for i in range(N):
+        h00[i*4+0, i*4+0] = M
+        h00[i*4+1, i*4+1] = -M
+        h00[i*4+2, i*4+2] = M
+        h00[i*4+3, i*4+3] = -M
+        h00[i*4+0, i*4+1] = t1
+        h00[i*4+1, i*4+0] = t1
+        h00[i*4+1, i*4+2] = t1
+        h00[i*4+2, i*4+1] = t1
+        h00[i*4+2, i*4+3] = t1
+        h00[i*4+3, i*4+2] = t1
+        h00[i*4+0, i*4+2] = t2*cmath.exp(-1j*phi)
+        h00[i*4+2, i*4+0] = h00[i*4+0, i*4+2].conj()
+        h00[i*4+1, i*4+3] = t2*cmath.exp(-1j*phi)
+        h00[i*4+3, i*4+1] = h00[i*4+1, i*4+3].conj()
+    for i in range(N-1):
+        h00[i*4+3, (i+1)*4+0] = t1
+        h00[(i+1)*4+0, i*4+3] = t1
+        h00[i*4+2, (i+1)*4+0] = t2*cmath.exp(1j*phi)
+        h00[(i+1)*4+0, i*4+2] = h00[i*4+2, (i+1)*4+0].conj()
+        h00[i*4+3, (i+1)*4+1] = t2*cmath.exp(1j*phi)
+        h00[(i+1)*4+1, i*4+3] = h00[i*4+3, (i+1)*4+1].conj()
+    if period == 1:
+        h00[(N-1)*4+3, 0] = t1
+        h00[0, (N-1)*4+3] = t1
+        h00[(N-1)*4+2, 0] = t2*cmath.exp(1j*phi)
+        h00[0, (N-1)*4+2] = h00[(N-1)*4+2, 0].conj()
+        h00[(N-1)*4+3, 1] = t2*cmath.exp(1j*phi)
+        h00[1, (N-1)*4+3] = h00[(N-1)*4+3, 1].conj()
+    for i in range(N):
+        h01[i*4+1, i*4+0] = t1
+        h01[i*4+2, i*4+3] = t1
+        h01[i*4+0, i*4+0] = t2*cmath.exp(1j*phi)
+        h01[i*4+1, i*4+1] = t2*cmath.exp(-1j*phi)
+        h01[i*4+2, i*4+2] = t2*cmath.exp(1j*phi)
+        h01[i*4+3, i*4+3] = t2*cmath.exp(-1j*phi)
+        h01[i*4+1, i*4+3] = t2*cmath.exp(1j*phi)
+        h01[i*4+2, i*4+0] = t2*cmath.exp(-1j*phi)
+        if i != 0:
+            h01[i*4+1, (i-1)*4+3] = t2*cmath.exp(1j*phi)
+    for i in range(N-1):
+        h01[i*4+2, (i+1)*4+0] = t2*cmath.exp(-1j*phi)
+    hamiltonian = h00 + h01*cmath.exp(1j*k) + h01.transpose().conj()*cmath.exp(-1j*k)
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 一个量子反常霍尔效应的哈密顿量（倒空间）
+def hamiltonian_of_one_QAH_model(k1, k2, t1=1, t2=1, t3=0.5, m=-1):
+    import numpy as np
+    import math
+    hamiltonian = np.zeros((2, 2), dtype=complex)
+    hamiltonian[0, 1] = 2*t1*math.cos(k1)-1j*2*t1*math.cos(k2)
+    hamiltonian[1, 0] = 2*t1*math.cos(k1)+1j*2*t1*math.cos(k2)
+    hamiltonian[0, 0] = m+2*t3*math.sin(k1)+2*t3*math.sin(k2)+2*t2*math.cos(k1+k2)
+    hamiltonian[1, 1] = -(m+2*t3*math.sin(k1)+2*t3*math.sin(k2)+2*t2*math.cos(k1+k2))
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# BHZ模型的哈密顿量（倒空间）
+def hamiltonian_of_bhz_model(kx, ky, A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01):
+    import numpy as np
+    import math
+    hamiltonian = np.zeros((4, 4), dtype=complex)
+    varepsilon = C-2*D*(2-math.cos(kx)-math.cos(ky))
+    d3 = -2*B*(2-(M/2/B)-math.cos(kx)-math.cos(ky))
+    d1_d2 = A*(math.sin(kx)+1j*math.sin(ky))
+    hamiltonian[0, 0] = varepsilon+d3
+    hamiltonian[1, 1] = varepsilon-d3
+    hamiltonian[0, 1] = np.conj(d1_d2)
+    hamiltonian[1, 0] = d1_d2
+    hamiltonian[2, 2] = varepsilon+d3
+    hamiltonian[3, 3] = varepsilon-d3
+    hamiltonian[2, 3] = -d1_d2 
+    hamiltonian[3, 2] = -np.conj(d1_d2)
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 半BHZ模型的哈密顿量（自旋向上）（倒空间）
+def hamiltonian_of_half_bhz_model_for_spin_up(kx, ky, A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01):
+    import numpy as np
+    import math
+    hamiltonian = np.zeros((2, 2), dtype=complex)
+    varepsilon = C-2*D*(2-math.cos(kx)-math.cos(ky))
+    d3 = -2*B*(2-(M/2/B)-math.cos(kx)-math.cos(ky))
+    d1_d2 = A*(math.sin(kx)+1j*math.sin(ky))
+    hamiltonian[0, 0] = varepsilon+d3
+    hamiltonian[1, 1] = varepsilon-d3
+    hamiltonian[0, 1] = np.conj(d1_d2)
+    hamiltonian[1, 0] = d1_d2
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# 半BHZ模型的哈密顿量（自旋向下）（倒空间）
+def hamiltonian_of_half_bhz_model_for_spin_down(kx, ky, A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01):
+    import numpy as np
+    import math
+    hamiltonian = np.zeros((2, 2), dtype=complex)
+    varepsilon = C-2*D*(2-math.cos(kx)-math.cos(ky))
+    d3 = -2*B*(2-(M/2/B)-math.cos(kx)-math.cos(ky))
+    d1_d2 = A*(math.sin(kx)+1j*math.sin(ky))
+    hamiltonian[0, 0] = varepsilon+d3
+    hamiltonian[1, 1] = varepsilon-d3
+    hamiltonian[0, 1] = -d1_d2 
+    hamiltonian[1, 0] = -np.conj(d1_d2)
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# BBH模型的哈密顿量（倒空间）
+def hamiltonian_of_bbh_model(kx, ky, gamma_x=0.5, gamma_y=0.5, lambda_x=1, lambda_y=1):
+    import numpy as np
+    import cmath
+    # label of atoms in a unit cell
+    # (2) —— (0)
+    #  |      |
+    # (1) —— (3)   
+    hamiltonian = np.zeros((4, 4), dtype=complex)
+    hamiltonian[0, 2] = gamma_x+lambda_x*cmath.exp(1j*kx)
+    hamiltonian[1, 3] = gamma_x+lambda_x*cmath.exp(-1j*kx)
+    hamiltonian[0, 3] = gamma_y+lambda_y*cmath.exp(1j*ky)
+    hamiltonian[1, 2] = -gamma_y-lambda_y*cmath.exp(-1j*ky)
+    hamiltonian[2, 0] = np.conj(hamiltonian[0, 2])
+    hamiltonian[3, 1] = np.conj(hamiltonian[1, 3])
+    hamiltonian[3, 0] = np.conj(hamiltonian[0, 3])
+    hamiltonian[2, 1] = np.conj(hamiltonian[1, 2])
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian
+
+# Kagome模型的哈密顿量（倒空间）
+def hamiltonian_of_kagome_lattice(kx, ky, t=1):
+    import numpy as np
+    import math
+    k1_dot_a1 = kx
+    k2_dot_a2 = kx/2+ky*math.sqrt(3)/2
+    k3_dot_a3 = -kx/2+ky*math.sqrt(3)/2
+    hamiltonian = np.zeros((3, 3), dtype=complex)
+    hamiltonian[0, 1] = 2*math.cos(k1_dot_a1)
+    hamiltonian[0, 2] = 2*math.cos(k2_dot_a2)
+    hamiltonian[1, 2] = 2*math.cos(k3_dot_a3)
+    hamiltonian = hamiltonian + hamiltonian.transpose().conj()
+    hamiltonian = -t*hamiltonian
+    import guan
+    guan.statistics_of_guan_package()
+    return hamiltonian

PyPI/src/guan/Hamiltonian_of_finite_size_systems.py

@@ -1,260 +0,0 @@
-# Module: Hamiltonian_of_finite_size_systems
-
-# 构建一维的有限尺寸体系哈密顿量（可设置是否为周期边界条件）
-def hamiltonian_of_finite_size_system_along_one_direction(N, on_site=0, hopping=1, period=0):
-    import numpy as np
-    on_site = np.array(on_site)
-    hopping = np.array(hopping)
-    if on_site.shape==():
-        dim = 1
-    else:
-        dim = on_site.shape[0]
-    hamiltonian = np.zeros((N*dim, N*dim), dtype=complex)
-    for i0 in range(N):
-        hamiltonian[i0*dim+0:i0*dim+dim, i0*dim+0:i0*dim+dim] = on_site
-    for i0 in range(N-1):
-        hamiltonian[i0*dim+0:i0*dim+dim, (i0+1)*dim+0:(i0+1)*dim+dim] = hopping
-        hamiltonian[(i0+1)*dim+0:(i0+1)*dim+dim, i0*dim+0:i0*dim+dim] = hopping.transpose().conj()
-    if period == 1:
-        hamiltonian[(N-1)*dim+0:(N-1)*dim+dim, 0:dim] = hopping
-        hamiltonian[0:dim, (N-1)*dim+0:(N-1)*dim+dim] = hopping.transpose().conj()
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 构建二维的方格子有限尺寸体系哈密顿量（可设置是否为周期边界条件）
-def hamiltonian_of_finite_size_system_along_two_directions_for_square_lattice(N1, N2, on_site=0, hopping_1=1, hopping_2=1, period_1=0, period_2=0):
-    import numpy as np
-    on_site = np.array(on_site)
-    hopping_1 = np.array(hopping_1)
-    hopping_2 = np.array(hopping_2)
-    if on_site.shape==():
-        dim = 1
-    else:
-        dim = on_site.shape[0]
-    hamiltonian = np.zeros((N1*N2*dim, N1*N2*dim), dtype=complex)    
-    for i1 in range(N1):
-        for i2 in range(N2):
-            hamiltonian[i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim, i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim] = on_site
-    for i1 in range(N1-1):
-        for i2 in range(N2):
-            hamiltonian[i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim, (i1+1)*N2*dim+i2*dim+0:(i1+1)*N2*dim+i2*dim+dim] = hopping_1
-            hamiltonian[(i1+1)*N2*dim+i2*dim+0:(i1+1)*N2*dim+i2*dim+dim, i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim] = hopping_1.transpose().conj()
-    for i1 in range(N1):
-        for i2 in range(N2-1):
-            hamiltonian[i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim, i1*N2*dim+(i2+1)*dim+0:i1*N2*dim+(i2+1)*dim+dim] = hopping_2
-            hamiltonian[i1*N2*dim+(i2+1)*dim+0:i1*N2*dim+(i2+1)*dim+dim, i1*N2*dim+i2*dim+0:i1*N2*dim+i2*dim+dim] = hopping_2.transpose().conj()
-    if period_1 == 1:
-        for i2 in range(N2):
-            hamiltonian[(N1-1)*N2*dim+i2*dim+0:(N1-1)*N2*dim+i2*dim+dim, i2*dim+0:i2*dim+dim] = hopping_1
-            hamiltonian[i2*dim+0:i2*dim+dim, (N1-1)*N2*dim+i2*dim+0:(N1-1)*N2*dim+i2*dim+dim] = hopping_1.transpose().conj()
-    if period_2 == 1:
-        for i1 in range(N1):
-            hamiltonian[i1*N2*dim+(N2-1)*dim+0:i1*N2*dim+(N2-1)*dim+dim, i1*N2*dim+0:i1*N2*dim+dim] = hopping_2
-            hamiltonian[i1*N2*dim+0:i1*N2*dim+dim, i1*N2*dim+(N2-1)*dim+0:i1*N2*dim+(N2-1)*dim+dim] = hopping_2.transpose().conj()
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 构建三维的立方格子有限尺寸体系哈密顿量（可设置是否为周期边界条件）
-def hamiltonian_of_finite_size_system_along_three_directions_for_cubic_lattice(N1, N2, N3, on_site=0, hopping_1=1, hopping_2=1, hopping_3=1, period_1=0, period_2=0, period_3=0):
-    import numpy as np
-    on_site = np.array(on_site)
-    hopping_1 = np.array(hopping_1)
-    hopping_2 = np.array(hopping_2)
-    hopping_3 = np.array(hopping_3)
-    if on_site.shape==():
-        dim = 1
-    else:
-        dim = on_site.shape[0]
-    hamiltonian = np.zeros((N1*N2*N3*dim, N1*N2*N3*dim), dtype=complex) 
-    for i1 in range(N1):
-        for i2 in range(N2):
-            for i3 in range(N3):
-                hamiltonian[i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim, i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim] = on_site
-    for i1 in range(N1-1):
-        for i2 in range(N2):
-            for i3 in range(N3):
-                hamiltonian[i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim, (i1+1)*N2*N3*dim+i2*N3*dim+i3*dim+0:(i1+1)*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_1
-                hamiltonian[(i1+1)*N2*N3*dim+i2*N3*dim+i3*dim+0:(i1+1)*N2*N3*dim+i2*N3*dim+i3*dim+dim, i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_1.transpose().conj()
-    for i1 in range(N1):
-        for i2 in range(N2-1):
-            for i3 in range(N3):
-                hamiltonian[i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim, i1*N2*N3*dim+(i2+1)*N3*dim+i3*dim+0:i1*N2*N3*dim+(i2+1)*N3*dim+i3*dim+dim] = hopping_2
-                hamiltonian[i1*N2*N3*dim+(i2+1)*N3*dim+i3*dim+0:i1*N2*N3*dim+(i2+1)*N3*dim+i3*dim+dim, i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_2.transpose().conj()
-    for i1 in range(N1):
-        for i2 in range(N2):
-            for i3 in range(N3-1):
-                hamiltonian[i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim, i1*N2*N3*dim+i2*N3*dim+(i3+1)*dim+0:i1*N2*N3*dim+i2*N3*dim+(i3+1)*dim+dim] = hopping_3
-                hamiltonian[i1*N2*N3*dim+i2*N3*dim+(i3+1)*dim+0:i1*N2*N3*dim+i2*N3*dim+(i3+1)*dim+dim, i1*N2*N3*dim+i2*N3*dim+i3*dim+0:i1*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_3.transpose().conj()
-    if period_1 == 1:
-        for i2 in range(N2):
-            for i3 in range(N3):
-                hamiltonian[(N1-1)*N2*N3*dim+i2*N3*dim+i3*dim+0:(N1-1)*N2*N3*dim+i2*N3*dim+i3*dim+dim, i2*N3*dim+i3*dim+0:i2*N3*dim+i3*dim+dim] = hopping_1
-                hamiltonian[i2*N3*dim+i3*dim+0:i2*N3*dim+i3*dim+dim, (N1-1)*N2*N3*dim+i2*N3*dim+i3*dim+0:(N1-1)*N2*N3*dim+i2*N3*dim+i3*dim+dim] = hopping_1.transpose().conj()
-    if period_2 == 1:
-        for i1 in range(N1):
-            for i3 in range(N3):
-                hamiltonian[i1*N2*N3*dim+(N2-1)*N3*dim+i3*dim+0:i1*N2*N3*dim+(N2-1)*N3*dim+i3*dim+dim, i1*N2*N3*dim+i3*dim+0:i1*N2*N3*dim+i3*dim+dim] = hopping_2
-                hamiltonian[i1*N2*N3*dim+i3*dim+0:i1*N2*N3*dim+i3*dim+dim, i1*N2*N3*dim+(N2-1)*N3*dim+i3*dim+0:i1*N2*N3*dim+(N2-1)*N3*dim+i3*dim+dim] = hopping_2.transpose().conj()
-    if period_3 == 1:
-        for i1 in range(N1):
-            for i2 in range(N2):
-                hamiltonian[i1*N2*N3*dim+i2*N3*dim+(N3-1)*dim+0:i1*N2*N3*dim+i2*N3*dim+(N3-1)*dim+dim, i1*N2*N3*dim+i2*N3*dim+0:i1*N2*N3*dim+i2*N3*dim+dim] = hopping_3
-                hamiltonian[i1*N2*N3*dim+i2*N3*dim+0:i1*N2*N3*dim+i2*N3*dim+dim, i1*N2*N3*dim+i2*N3*dim+(N3-1)*dim+0:i1*N2*N3*dim+i2*N3*dim+(N3-1)*dim+dim] = hopping_3.transpose().conj()
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 构建有限尺寸的SSH模型哈密顿量
-def hamiltonian_of_finite_size_ssh_model(N, v=0.6, w=1, onsite_1=0, onsite_2=0, period=1):
-    import numpy as np
-    hamiltonian = np.zeros((2*N, 2*N))
-    for i in range(N):
-        hamiltonian[i*2+0, i*2+0] = onsite_1
-        hamiltonian[i*2+1, i*2+1] = onsite_2
-        hamiltonian[i*2+0, i*2+1] = v
-        hamiltonian[i*2+1, i*2+0] = v
-    for i in range(N-1):
-        hamiltonian[i*2+1, (i+1)*2+0] = w
-        hamiltonian[(i+1)*2+0, i*2+1] = w
-    if period==1:
-        hamiltonian[0, 2*N-1] = w
-        hamiltonian[2*N-1, 0] = w
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 获取Zigzag边的石墨烯条带的元胞间跃迁
-def get_hopping_term_of_graphene_ribbon_along_zigzag_direction(N, eta=0):
-    import numpy as np
-    hopping = np.zeros((4*N, 4*N), dtype=complex)
-    for i0 in range(N):
-        hopping[4*i0+0, 4*i0+0] = eta
-        hopping[4*i0+1, 4*i0+1] = eta
-        hopping[4*i0+2, 4*i0+2] = eta
-        hopping[4*i0+3, 4*i0+3] = eta
-        hopping[4*i0+1, 4*i0+0] = 1
-        hopping[4*i0+2, 4*i0+3] = 1
-    import guan
-    guan.statistics_of_guan_package()
-    return hopping
-
-# 构建有限尺寸的石墨烯哈密顿量（可设置是否为周期边界条件）
-def hamiltonian_of_finite_size_system_along_two_directions_for_graphene(N1, N2, period_1=0, period_2=0):
-    import numpy as np
-    import guan
-    on_site = guan.hamiltonian_of_finite_size_system_along_one_direction(4)
-    hopping_1 = guan.get_hopping_term_of_graphene_ribbon_along_zigzag_direction(1)
-    hopping_2 = np.zeros((4, 4), dtype=complex)
-    hopping_2[3, 0] = 1
-    hamiltonian = guan.hamiltonian_of_finite_size_system_along_two_directions_for_square_lattice(N1, N2, on_site, hopping_1, hopping_2, period_1, period_2)
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 获取石墨烯有效模型沿着x方向的在位能和跃迁项（其中，动量qy为参数）
-def get_onsite_and_hopping_terms_of_2d_effective_graphene_along_one_direction(qy, t=1, staggered_potential=0, eta=0, valley_index=0):
-    import numpy as np
-    constant = -np.sqrt(3)/2
-    h00 = np.zeros((2, 2), dtype=complex)
-    h00[0, 0] = staggered_potential
-    h00[1, 1] = -staggered_potential
-    h00[0, 1] = -1j*constant*t*np.sin(qy)
-    h00[1, 0] = 1j*constant*t*np.sin(qy)
-    h01 = np.zeros((2, 2), dtype=complex)
-    h01[0, 0] = eta
-    h01[1, 1] = eta
-    if valley_index == 0:
-        h01[0, 1] = constant*t*(-1j/2)
-        h01[1, 0] = constant*t*(-1j/2)
-    else:
-        h01[0, 1] = constant*t*(1j/2)
-        h01[1, 0] = constant*t*(1j/2)
-    import guan
-    guan.statistics_of_guan_package()
-    return h00, h01
-
-# 获取BHZ模型的在位能和跃迁项
-def get_onsite_and_hopping_terms_of_bhz_model(A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01, a=1):
-    import numpy as np
-    E_s = C+M-4*(D+B)/(a**2)
-    E_p = C-M-4*(D-B)/(a**2)
-    V_ss = (D+B)/(a**2)
-    V_pp = (D-B)/(a**2)
-    V_sp = -1j*A/(2*a)
-    H0 = np.zeros((4, 4), dtype=complex)
-    H1 = np.zeros((4, 4), dtype=complex)
-    H2 = np.zeros((4, 4), dtype=complex)
-    H0[0, 0] = E_s
-    H0[1, 1] = E_p
-    H0[2, 2] = E_s
-    H0[3, 3] = E_p
-    H1[0, 0] = V_ss
-    H1[1, 1] = V_pp
-    H1[2, 2] = V_ss
-    H1[3, 3] = V_pp
-    H1[0, 1] = V_sp
-    H1[1, 0] = -np.conj(V_sp)
-    H1[2, 3] = np.conj(V_sp)
-    H1[3, 2] = -V_sp
-    H2[0, 0] = V_ss
-    H2[1, 1] = V_pp
-    H2[2, 2] = V_ss
-    H2[3, 3] = V_pp
-    H2[0, 1] = 1j*V_sp
-    H2[1, 0] = 1j*np.conj(V_sp)
-    H2[2, 3] = -1j*np.conj(V_sp)
-    H2[3, 2] = -1j*V_sp
-    import guan
-    guan.statistics_of_guan_package()
-    return H0, H1, H2
-
-# 获取半个BHZ模型的在位能和跃迁项（自旋向上）
-def get_onsite_and_hopping_terms_of_half_bhz_model_for_spin_up(A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01, a=1):
-    import numpy as np
-    E_s = C+M-4*(D+B)/(a**2)
-    E_p = C-M-4*(D-B)/(a**2)
-    V_ss = (D+B)/(a**2)
-    V_pp = (D-B)/(a**2)
-    V_sp = -1j*A/(2*a)
-    H0 = np.zeros((2, 2), dtype=complex)
-    H1 = np.zeros((2, 2), dtype=complex)
-    H2 = np.zeros((2, 2), dtype=complex)
-    H0[0, 0] = E_s
-    H0[1, 1] = E_p
-    H1[0, 0] = V_ss
-    H1[1, 1] = V_pp
-    H1[0, 1] = V_sp
-    H1[1, 0] = -np.conj(V_sp)
-    H2[0, 0] = V_ss
-    H2[1, 1] = V_pp
-    H2[0, 1] = 1j*V_sp
-    H2[1, 0] = 1j*np.conj(V_sp)
-    import guan
-    guan.statistics_of_guan_package()
-    return H0, H1, H2
-
-# 获取半个BHZ模型的在位能和跃迁项（自旋向下）
-def get_onsite_and_hopping_terms_of_half_bhz_model_for_spin_down(A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01, a=1):
-    import numpy as np
-    E_s = C+M-4*(D+B)/(a**2)
-    E_p = C-M-4*(D-B)/(a**2)
-    V_ss = (D+B)/(a**2)
-    V_pp = (D-B)/(a**2)
-    V_sp = -1j*A/(2*a)
-    H0 = np.zeros((2, 2), dtype=complex)
-    H1 = np.zeros((2, 2), dtype=complex)
-    H2 = np.zeros((2, 2), dtype=complex)
-    H0[0, 0] = E_s
-    H0[1, 1] = E_p
-    H1[0, 0] = V_ss
-    H1[1, 1] = V_pp
-    H1[0, 1] = np.conj(V_sp)
-    H1[1, 0] = -V_sp
-    H2[0, 0] = V_ss
-    H2[1, 1] = V_pp
-    H2[0, 1] = -1j*np.conj(V_sp)
-    H2[1, 0] = -1j*V_sp
-    import guan
-    guan.statistics_of_guan_package()
-    return H0, H1, H2

PyPI/src/guan/Hamiltonian_of_models_in_reciprocal_space.py

@@ -1,315 +0,0 @@
-# Module: Hamiltonian_of_models_in_reciprocal_space
-
-# 一维链的哈密顿量
-def hamiltonian_of_simple_chain(k):
-    import guan
-    hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=0, hopping=1)
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 二维方格子的哈密顿量
-def hamiltonian_of_square_lattice(k1, k2):
-    import guan
-    hamiltonian = guan.two_dimensional_fourier_transform_for_square_lattice(k1, k2, unit_cell=0, hopping_1=1, hopping_2=1)
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 准一维方格子条带的哈密顿量
-def hamiltonian_of_square_lattice_in_quasi_one_dimension(k, N=10, period=0):
-    import numpy as np
-    import guan
-    h00 = np.zeros((N, N), dtype=complex)  # hopping in a unit cell
-    h01 = np.zeros((N, N), dtype=complex)  # hopping between unit cells
-    for i in range(N-1):   
-        h00[i, i+1] = 1
-        h00[i+1, i] = 1
-    if period == 1:
-        h00[N-1, 0] = 1
-        h00[0, N-1] = 1
-    for i in range(N):   
-        h01[i, i] = 1
-    hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=h00, hopping=h01)
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 三维立方格子的哈密顿量
-def hamiltonian_of_cubic_lattice(k1, k2, k3):
-    import guan
-    hamiltonian = guan.three_dimensional_fourier_transform_for_cubic_lattice(k1, k2, k3, unit_cell=0, hopping_1=1, hopping_2=1, hopping_3=1)
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# SSH模型的哈密顿量
-def hamiltonian_of_ssh_model(k, v=0.6, w=1):
-    import numpy as np
-    import cmath
-    hamiltonian = np.zeros((2, 2), dtype=complex)
-    hamiltonian[0,1] = v+w*cmath.exp(-1j*k)
-    hamiltonian[1,0] = v+w*cmath.exp(1j*k)
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 石墨烯的哈密顿量
-def hamiltonian_of_graphene(k1, k2, staggered_potential=0, t=1, a='default'):
-    import numpy as np
-    import cmath
-    import math
-    if a == 'default':
-        a = 1/math.sqrt(3)
-    h0 = np.zeros((2, 2), dtype=complex)  # mass term
-    h1 = np.zeros((2, 2), dtype=complex)  # nearest hopping
-    h0[0, 0] = staggered_potential     
-    h0[1, 1] = -staggered_potential
-    h1[1, 0] = t*(cmath.exp(1j*k2*a)+cmath.exp(1j*math.sqrt(3)/2*k1*a-1j/2*k2*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a-1j/2*k2*a))   
-    h1[0, 1] = h1[1, 0].conj()
-    hamiltonian = h0 + h1
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 石墨烯有效模型的哈密顿量
-def effective_hamiltonian_of_graphene(qx, qy, t=1, staggered_potential=0, valley_index=0):
-    import numpy as np
-    hamiltonian = np.zeros((2, 2), dtype=complex)
-    hamiltonian[0, 0] = staggered_potential
-    hamiltonian[1, 1] = -staggered_potential
-    constant = -np.sqrt(3)/2
-    if valley_index == 0:
-        hamiltonian[0, 1] = constant*t*(qx-1j*qy)
-        hamiltonian[1, 0] = constant*t*(qx+1j*qy)
-    else:
-        hamiltonian[0, 1] = constant*t*(-qx-1j*qy)
-        hamiltonian[1, 0] = constant*t*(-qx+1j*qy)
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 石墨烯有效模型离散化后的哈密顿量
-def effective_hamiltonian_of_graphene_after_discretization(qx, qy, t=1, staggered_potential=0, valley_index=0):
-    import numpy as np
-    hamiltonian = np.zeros((2, 2), dtype=complex)
-    hamiltonian[0, 0] = staggered_potential
-    hamiltonian[1, 1] = -staggered_potential
-    constant = -np.sqrt(3)/2
-    if valley_index == 0:
-        hamiltonian[0, 1] = constant*t*(np.sin(qx)-1j*np.sin(qy))
-        hamiltonian[1, 0] = constant*t*(np.sin(qx)+1j*np.sin(qy))
-    else:
-        hamiltonian[0, 1] = constant*t*(-np.sin(qx)-1j*np.sin(qy))
-        hamiltonian[1, 0] = constant*t*(-np.sin(qx)+1j*np.sin(qy))
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 准一维Zigzag边石墨烯条带的哈密顿量
-def hamiltonian_of_graphene_with_zigzag_in_quasi_one_dimension(k, N=10, M=0, t=1, period=0):
-    import numpy as np
-    import guan
-    h00 = np.zeros((4*N, 4*N), dtype=complex)  # hopping in a unit cell
-    h01 = np.zeros((4*N, 4*N), dtype=complex)  # hopping between unit cells
-    for i in range(N):
-        h00[i*4+0, i*4+0] = M
-        h00[i*4+1, i*4+1] = -M
-        h00[i*4+2, i*4+2] = M
-        h00[i*4+3, i*4+3] = -M
-        h00[i*4+0, i*4+1] = t
-        h00[i*4+1, i*4+0] = t
-        h00[i*4+1, i*4+2] = t
-        h00[i*4+2, i*4+1] = t
-        h00[i*4+2, i*4+3] = t
-        h00[i*4+3, i*4+2] = t
-    for i in range(N-1):
-        h00[i*4+3, (i+1)*4+0] = t
-        h00[(i+1)*4+0, i*4+3] = t
-    if period == 1:
-        h00[(N-1)*4+3, 0] = t
-        h00[0, (N-1)*4+3] = t
-    for i in range(N):
-        h01[i*4+1, i*4+0] = t
-        h01[i*4+2, i*4+3] = t
-    hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=h00, hopping=h01)
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# Haldane模型的哈密顿量
-def hamiltonian_of_haldane_model(k1, k2, M=2/3, t1=1, t2=1/3, phi='default', a='default'):
-    import numpy as np
-    import cmath
-    import math
-    if phi == 'default':
-        phi=math.pi/4
-    if a == 'default':
-        a=1/math.sqrt(3)
-    h0 = np.zeros((2, 2), dtype=complex)  # mass term
-    h1 = np.zeros((2, 2), dtype=complex)  # nearest hopping
-    h2 = np.zeros((2, 2), dtype=complex)  # next nearest hopping
-    h0[0, 0] = M
-    h0[1, 1] = -M
-    h1[1, 0] = t1*(cmath.exp(1j*k2*a)+cmath.exp(1j*math.sqrt(3)/2*k1*a-1j/2*k2*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a-1j/2*k2*a))
-    h1[0, 1] = h1[1, 0].conj()
-    h2[0, 0] = t2*cmath.exp(-1j*phi)*(cmath.exp(1j*math.sqrt(3)*k1*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a+1j*3/2*k2*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a-1j*3/2*k2*a))
-    h2[1, 1] = t2*cmath.exp(1j*phi)*(cmath.exp(1j*math.sqrt(3)*k1*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a+1j*3/2*k2*a)+cmath.exp(-1j*math.sqrt(3)/2*k1*a-1j*3/2*k2*a))
-    hamiltonian = h0 + h1 + h2 + h2.transpose().conj()
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 准一维Haldane模型条带的哈密顿量
-def hamiltonian_of_haldane_model_in_quasi_one_dimension(k, N=10, M=2/3, t1=1, t2=1/3, phi='default', period=0):
-    import numpy as np
-    import cmath
-    import math
-    if phi == 'default':
-        phi=math.pi/4
-    h00 = np.zeros((4*N, 4*N), dtype=complex)  # hopping in a unit cell
-    h01 = np.zeros((4*N, 4*N), dtype=complex)  # hopping between unit cells
-    for i in range(N):
-        h00[i*4+0, i*4+0] = M
-        h00[i*4+1, i*4+1] = -M
-        h00[i*4+2, i*4+2] = M
-        h00[i*4+3, i*4+3] = -M
-        h00[i*4+0, i*4+1] = t1
-        h00[i*4+1, i*4+0] = t1
-        h00[i*4+1, i*4+2] = t1
-        h00[i*4+2, i*4+1] = t1
-        h00[i*4+2, i*4+3] = t1
-        h00[i*4+3, i*4+2] = t1
-        h00[i*4+0, i*4+2] = t2*cmath.exp(-1j*phi)
-        h00[i*4+2, i*4+0] = h00[i*4+0, i*4+2].conj()
-        h00[i*4+1, i*4+3] = t2*cmath.exp(-1j*phi)
-        h00[i*4+3, i*4+1] = h00[i*4+1, i*4+3].conj()
-    for i in range(N-1):
-        h00[i*4+3, (i+1)*4+0] = t1
-        h00[(i+1)*4+0, i*4+3] = t1
-        h00[i*4+2, (i+1)*4+0] = t2*cmath.exp(1j*phi)
-        h00[(i+1)*4+0, i*4+2] = h00[i*4+2, (i+1)*4+0].conj()
-        h00[i*4+3, (i+1)*4+1] = t2*cmath.exp(1j*phi)
-        h00[(i+1)*4+1, i*4+3] = h00[i*4+3, (i+1)*4+1].conj()
-    if period == 1:
-        h00[(N-1)*4+3, 0] = t1
-        h00[0, (N-1)*4+3] = t1
-        h00[(N-1)*4+2, 0] = t2*cmath.exp(1j*phi)
-        h00[0, (N-1)*4+2] = h00[(N-1)*4+2, 0].conj()
-        h00[(N-1)*4+3, 1] = t2*cmath.exp(1j*phi)
-        h00[1, (N-1)*4+3] = h00[(N-1)*4+3, 1].conj()
-    for i in range(N):
-        h01[i*4+1, i*4+0] = t1
-        h01[i*4+2, i*4+3] = t1
-        h01[i*4+0, i*4+0] = t2*cmath.exp(1j*phi)
-        h01[i*4+1, i*4+1] = t2*cmath.exp(-1j*phi)
-        h01[i*4+2, i*4+2] = t2*cmath.exp(1j*phi)
-        h01[i*4+3, i*4+3] = t2*cmath.exp(-1j*phi)
-        h01[i*4+1, i*4+3] = t2*cmath.exp(1j*phi)
-        h01[i*4+2, i*4+0] = t2*cmath.exp(-1j*phi)
-        if i != 0:
-            h01[i*4+1, (i-1)*4+3] = t2*cmath.exp(1j*phi)
-    for i in range(N-1):
-        h01[i*4+2, (i+1)*4+0] = t2*cmath.exp(-1j*phi)
-    hamiltonian = h00 + h01*cmath.exp(1j*k) + h01.transpose().conj()*cmath.exp(-1j*k)
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 一个量子反常霍尔效应的哈密顿量
-def hamiltonian_of_one_QAH_model(k1, k2, t1=1, t2=1, t3=0.5, m=-1):
-    import numpy as np
-    import math
-    hamiltonian = np.zeros((2, 2), dtype=complex)
-    hamiltonian[0, 1] = 2*t1*math.cos(k1)-1j*2*t1*math.cos(k2)
-    hamiltonian[1, 0] = 2*t1*math.cos(k1)+1j*2*t1*math.cos(k2)
-    hamiltonian[0, 0] = m+2*t3*math.sin(k1)+2*t3*math.sin(k2)+2*t2*math.cos(k1+k2)
-    hamiltonian[1, 1] = -(m+2*t3*math.sin(k1)+2*t3*math.sin(k2)+2*t2*math.cos(k1+k2))
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# BHZ模型的哈密顿量
-def hamiltonian_of_bhz_model(kx, ky, A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01):
-    import numpy as np
-    import math
-    hamiltonian = np.zeros((4, 4), dtype=complex)
-    varepsilon = C-2*D*(2-math.cos(kx)-math.cos(ky))
-    d3 = -2*B*(2-(M/2/B)-math.cos(kx)-math.cos(ky))
-    d1_d2 = A*(math.sin(kx)+1j*math.sin(ky))
-    hamiltonian[0, 0] = varepsilon+d3
-    hamiltonian[1, 1] = varepsilon-d3
-    hamiltonian[0, 1] = np.conj(d1_d2)
-    hamiltonian[1, 0] = d1_d2
-    hamiltonian[2, 2] = varepsilon+d3
-    hamiltonian[3, 3] = varepsilon-d3
-    hamiltonian[2, 3] = -d1_d2 
-    hamiltonian[3, 2] = -np.conj(d1_d2)
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 半BHZ模型的哈密顿量（自旋向上）
-def hamiltonian_of_half_bhz_model_for_spin_up(kx, ky, A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01):
-    import numpy as np
-    import math
-    hamiltonian = np.zeros((2, 2), dtype=complex)
-    varepsilon = C-2*D*(2-math.cos(kx)-math.cos(ky))
-    d3 = -2*B*(2-(M/2/B)-math.cos(kx)-math.cos(ky))
-    d1_d2 = A*(math.sin(kx)+1j*math.sin(ky))
-    hamiltonian[0, 0] = varepsilon+d3
-    hamiltonian[1, 1] = varepsilon-d3
-    hamiltonian[0, 1] = np.conj(d1_d2)
-    hamiltonian[1, 0] = d1_d2
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# 半BHZ模型的哈密顿量（自旋向下）
-def hamiltonian_of_half_bhz_model_for_spin_down(kx, ky, A=0.3645/5, B=-0.686/25, C=0, D=-0.512/25, M=-0.01):
-    import numpy as np
-    import math
-    hamiltonian = np.zeros((2, 2), dtype=complex)
-    varepsilon = C-2*D*(2-math.cos(kx)-math.cos(ky))
-    d3 = -2*B*(2-(M/2/B)-math.cos(kx)-math.cos(ky))
-    d1_d2 = A*(math.sin(kx)+1j*math.sin(ky))
-    hamiltonian[0, 0] = varepsilon+d3
-    hamiltonian[1, 1] = varepsilon-d3
-    hamiltonian[0, 1] = -d1_d2 
-    hamiltonian[1, 0] = -np.conj(d1_d2)
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# BBH模型的哈密顿量
-def hamiltonian_of_bbh_model(kx, ky, gamma_x=0.5, gamma_y=0.5, lambda_x=1, lambda_y=1):
-    import numpy as np
-    import cmath
-    # label of atoms in a unit cell
-    # (2) —— (0)
-    #  |      |
-    # (1) —— (3)   
-    hamiltonian = np.zeros((4, 4), dtype=complex)
-    hamiltonian[0, 2] = gamma_x+lambda_x*cmath.exp(1j*kx)
-    hamiltonian[1, 3] = gamma_x+lambda_x*cmath.exp(-1j*kx)
-    hamiltonian[0, 3] = gamma_y+lambda_y*cmath.exp(1j*ky)
-    hamiltonian[1, 2] = -gamma_y-lambda_y*cmath.exp(-1j*ky)
-    hamiltonian[2, 0] = np.conj(hamiltonian[0, 2])
-    hamiltonian[3, 1] = np.conj(hamiltonian[1, 3])
-    hamiltonian[3, 0] = np.conj(hamiltonian[0, 3])
-    hamiltonian[2, 1] = np.conj(hamiltonian[1, 2])
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian
-
-# Kagome模型的哈密顿量
-def hamiltonian_of_kagome_lattice(kx, ky, t=1):
-    import numpy as np
-    import math
-    k1_dot_a1 = kx
-    k2_dot_a2 = kx/2+ky*math.sqrt(3)/2
-    k3_dot_a3 = -kx/2+ky*math.sqrt(3)/2
-    hamiltonian = np.zeros((3, 3), dtype=complex)
-    hamiltonian[0, 1] = 2*math.cos(k1_dot_a1)
-    hamiltonian[0, 2] = 2*math.cos(k2_dot_a2)
-    hamiltonian[1, 2] = 2*math.cos(k3_dot_a3)
-    hamiltonian = hamiltonian + hamiltonian.transpose().conj()
-    hamiltonian = -t*hamiltonian
-    import guan
-    guan.statistics_of_guan_package()
-    return hamiltonian

PyPI/src/guan/__init__.py

@@ -2,15 +2,11 @@
 
 from .basic_functions import *
 from .Fourier_transform import *
-from .Hamiltonian_of_finite_size_systems import *
+from .Hamiltonian_of_examples import *
-from .Hamiltonian_of_models_in_reciprocal_space import *
 from .band_structures_and_wave_functions import *
 from .Green_functions import *
 from .density_of_states import *
 from .quantum_transport import *
 from .topological_invariant import *
-from .plot_figures import *
-from .read_and_write import *
-from .file_processing import *
 from .data_processing import *
 from .others import *

PyPI/src/guan/band_structures_and_wave_functions.py

@@ -154,7 +154,7 @@ def find_vector_array_with_fixed_gauge_by_making_one_component_real(vector_array
     guan.statistics_of_guan_package()
     return vector_array
 
-# 旋转两个简并的波函数（说明：参数比较多，效率不高）
+# 旋转两个简并的波函数（说明：参数比较多，算法效率不高）
 def rotation_of_degenerate_vectors(vector1, vector2, index1=None, index2=None, precision=0.01, criterion=0.01, show_theta=0):
     import numpy as np
     import math
@@ -185,7 +185,7 @@ def rotation_of_degenerate_vectors(vector1, vector2, index1=None, index2=None, p
     guan.statistics_of_guan_package()
     return vector1, vector2
 
-# 旋转两个简并的波函数向量组（说明：参数比较多，效率不高）
+# 旋转两个简并的波函数向量组（说明：参数比较多，算法效率不高）
 def rotation_of_degenerate_vectors_array(vector1_array, vector2_array, precision=0.01, criterion=0.01, show_theta=0):
     import numpy as np
     import guan
@@ -202,3 +202,34 @@ def rotation_of_degenerate_vectors_array(vector1_array, vector2_array, precision
         vector1_array[i0], vector2_array[i0] = guan.rotation_of_degenerate_vectors(vector1=vector1_array[i0], vector2=vector2_array[i0], index1=index1, index2=index2, precision=precision, criterion=criterion, show_theta=show_theta)
     guan.statistics_of_guan_package()
     return vector1_array, vector2_array
+
+# 在一组数据中找到数值相近的数
+def find_close_values_in_one_array(array, precision=1e-2):
+    new_array = []
+    i0 = 0
+    for a1 in array:
+        j0 = 0
+        for a2 in array:
+            if j0>i0 and abs(a1-a2)<precision: 
+                new_array.append([a1, a2])
+            j0 +=1
+        i0 += 1
+    import guan
+    guan.statistics_of_guan_package()
+    return new_array
+
+# 寻找能带的简并点
+def find_degenerate_points(k_array, eigenvalue_array, precision=1e-2):
+    import guan
+    degenerate_k_array = []
+    degenerate_eigenvalue_array = []
+    i0 = 0
+    for k in k_array:
+        degenerate_points = guan.find_close_values_in_one_array(eigenvalue_array[i0], precision=precision)
+        if len(degenerate_points) != 0:
+            degenerate_k_array.append(k)
+            degenerate_eigenvalue_array.append(degenerate_points)
+        i0 += 1
+    import guan
+    guan.statistics_of_guan_package()
+    return degenerate_k_array, degenerate_eigenvalue_array

PyPI/src/guan/file_processing.py

@@ -1,727 +0,0 @@
-# Module: file_processing
-
-# 自动先后运行程序（串行）
-def run_programs_sequentially(program_files=['./a.py', './b.py'], execute='python ', show_time=0):
-    import os
-    import time
-    if show_time == 1:
-        start = time.time()
-    i0 = 0
-    for program_file in program_files:
-        i0 += 1
-        if show_time == 1:
-            start_0 = time.time()
-        os.system(execute+program_file)
-        if show_time == 1:
-            end_0 = time.time()
-            print('Running time of program_'+str(i0)+' = '+str((end_0-start_0)/60)+' min')
-    if show_time == 1:
-        end = time.time()
-        print('Total running time = '+str((end-start)/60)+' min')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 如果不存在文件夹，则新建文件夹
-def make_directory(directory='./test'):
-    import os
-    if not os.path.exists(directory):
-        os.makedirs(directory)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 复制一份文件
-def copy_file(file1='./a.txt', file2='./b.txt'):
-    import shutil
-    shutil.copy(file1, file2)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 拼接两个PDF文件
-def combine_two_pdf_files(input_file_1='a.pdf', input_file_2='b.pdf', output_file='combined_file.pdf'):
-    import PyPDF2
-    output_pdf = PyPDF2.PdfWriter()
-    with open(input_file_1, 'rb') as file1:
-        pdf1 = PyPDF2.PdfReader(file1)
-        for page in range(len(pdf1.pages)):
-            output_pdf.add_page(pdf1.pages[page])
-    with open(input_file_2, 'rb') as file2:
-        pdf2 = PyPDF2.PdfReader(file2)
-        for page in range(len(pdf2.pages)):
-            output_pdf.add_page(pdf2.pages[page])
-    with open(output_file, 'wb') as combined_file:
-        output_pdf.write(combined_file)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 查找文件名相同的文件
-def find_repeated_file_with_same_filename(directory='./', ignored_directory_with_words=[], ignored_file_with_words=[], num=1000):
-    import os
-    from collections import Counter
-    file_list = []
-    for root, dirs, files in os.walk(directory):
-        for i0 in range(len(files)):
-            file_list.append(files[i0])
-            for word in ignored_directory_with_words:
-                if word in root:
-                    file_list.remove(files[i0])       
-            for word in ignored_file_with_words:
-                if word in files[i0]:
-                    try:
-                        file_list.remove(files[i0])   
-                    except:
-                        pass 
-    count_file = Counter(file_list).most_common(num)
-    repeated_file = []
-    for item in count_file:
-        if item[1]>1:
-            repeated_file.append(item)
-    import guan
-    guan.statistics_of_guan_package()
-    return repeated_file
-
-# 统计各个子文件夹中的文件数量
-def count_file_in_sub_directory(directory='./', sort=0, reverse=1, print_show=1, smaller_than_num=None):
-    import os
-    import numpy as np
-    dirs_list = []
-    for root, dirs, files in os.walk(directory):
-        if dirs != []:
-            for i0 in range(len(dirs)):
-                dirs_list.append(root+'/'+dirs[i0])
-    count_file_array = []
-    for sub_dir in dirs_list:
-        file_list = []
-        for root, dirs, files in os.walk(sub_dir):
-            for i0 in range(len(files)):
-                file_list.append(files[i0])
-        count_file = len(file_list)
-        count_file_array.append(count_file)
-        if sort == 0:
-            if print_show == 1:
-                if smaller_than_num == None:
-                    print(sub_dir)
-                    print(count_file)
-                    print()
-                else:
-                    if count_file<smaller_than_num:
-                        print(sub_dir)
-                        print(count_file)
-                        print()
-    if sort == 0:
-        sub_directory = dirs_list
-        num_in_sub_directory = count_file_array
-    if sort == 1:
-        sub_directory = []
-        num_in_sub_directory = []
-        if reverse == 1:
-            index_array = np.argsort(count_file_array)[::-1]
-        else:
-            index_array = np.argsort(count_file_array)
-        for i0 in index_array:
-            sub_directory.append(dirs_list[i0])
-            num_in_sub_directory.append(count_file_array[i0])
-            if print_show == 1:
-                if smaller_than_num == None:
-                    print(dirs_list[i0])
-                    print(count_file_array[i0])
-                    print()
-                else:
-                    if count_file_array[i0]<smaller_than_num:
-                        print(dirs_list[i0])
-                        print(count_file_array[i0])
-                        print()
-    
-    import guan
-    guan.statistics_of_guan_package()
-    return sub_directory, num_in_sub_directory
-
-# 改变当前的目录位置
-def change_directory_by_replacement(current_key_word='code', new_key_word='data'):
-    import os
-    code_path = os.getcwd()
-    data_path = code_path.replace('\\', '/') 
-    data_path = data_path.replace(current_key_word, new_key_word) 
-    if os.path.exists(data_path) == False:
-        os.makedirs(data_path)
-    os.chdir(data_path)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 在多个子文件夹中产生必要的文件，例如 readme.md
-def creat_necessary_file(directory, filename='readme', file_format='.md', content='', overwrite=None, ignored_directory_with_words=[]):
-    import os
-    directory_with_file = []
-    ignored_directory = []
-    for root, dirs, files in os.walk(directory):
-        for i0 in range(len(files)):
-            if root not in directory_with_file:
-                directory_with_file.append(root)
-            if files[i0] == filename+file_format:
-                if root not in ignored_directory:
-                    ignored_directory.append(root)
-    if overwrite == None:
-        for root in ignored_directory:
-            directory_with_file.remove(root)
-    ignored_directory_more =[]
-    for root in directory_with_file: 
-        for word in ignored_directory_with_words:
-            if word in root:
-                if root not in ignored_directory_more:
-                    ignored_directory_more.append(root)
-    for root in ignored_directory_more:
-        directory_with_file.remove(root) 
-    for root in directory_with_file:
-        os.chdir(root)
-        f = open(filename+file_format, 'w', encoding="utf-8")
-        f.write(content)
-        f.close()
-    import guan
-    guan.statistics_of_guan_package()
-
-# 删除特定文件名的文件（慎用）
-def delete_file_with_specific_name(directory, filename='readme', file_format='.md'):
-    import os
-    for root, dirs, files in os.walk(directory):
-        for i0 in range(len(files)):
-            if files[i0] == filename+file_format:
-                os.remove(root+'/'+files[i0])
-    import guan
-    guan.statistics_of_guan_package()
-
-# 所有文件移到根目录（慎用）
-def move_all_files_to_root_directory(directory):
-    import os
-    import shutil
-    for root, dirs, files in os.walk(directory):
-        for i0 in range(len(files)):
-            shutil.move(root+'/'+files[i0], directory+'/'+files[i0])
-    for i0 in range(100):
-        for root, dirs, files in os.walk(directory):
-            try:
-                os.rmdir(root) 
-            except:
-                pass
-    import guan
-    guan.statistics_of_guan_package()
-
-# 将文件目录结构写入Markdown文件
-def write_file_list_in_markdown(directory='./', filename='a', reverse_positive_or_negative=1, starting_from_h1=None, banned_file_format=[], hide_file_format=None, divided_line=None, show_second_number=None, show_third_number=None): 
-    import os
-    f = open(filename+'.md', 'w', encoding="utf-8")
-    filenames1 = os.listdir(directory)
-    u0 = 0
-    for filename1 in filenames1[::reverse_positive_or_negative]:
-        filename1_with_path = os.path.join(directory,filename1) 
-        if os.path.isfile(filename1_with_path):
-            if os.path.splitext(filename1)[1] not in banned_file_format:
-                if hide_file_format == None:
-                    f.write('+ '+str(filename1)+'\n\n')
-                else:
-                    f.write('+ '+str(os.path.splitext(filename1)[0])+'\n\n')
-        else:
-            u0 += 1
-            if divided_line != None and u0 != 1:
-                f.write('--------\n\n')
-            if starting_from_h1 == None:
-                f.write('#')
-            f.write('# '+str(filename1)+'\n\n')
-
-            filenames2 = os.listdir(filename1_with_path) 
-            i0 = 0     
-            for filename2 in filenames2[::reverse_positive_or_negative]:
-                filename2_with_path = os.path.join(directory, filename1, filename2) 
-                if os.path.isfile(filename2_with_path):
-                    if os.path.splitext(filename2)[1] not in banned_file_format:
-                        if hide_file_format == None:
-                            f.write('+ '+str(filename2)+'\n\n')
-                        else:
-                            f.write('+ '+str(os.path.splitext(filename2)[0])+'\n\n')
-                else: 
-                    i0 += 1
-                    if starting_from_h1 == None:
-                        f.write('#')
-                    if show_second_number != None:
-                        f.write('## '+str(i0)+'. '+str(filename2)+'\n\n')
-                    else:
-                        f.write('## '+str(filename2)+'\n\n')
-                    
-                    j0 = 0
-                    filenames3 = os.listdir(filename2_with_path)
-                    for filename3 in filenames3[::reverse_positive_or_negative]:
-                        filename3_with_path = os.path.join(directory, filename1, filename2, filename3) 
-                        if os.path.isfile(filename3_with_path): 
-                            if os.path.splitext(filename3)[1] not in banned_file_format:
-                                if hide_file_format == None:
-                                    f.write('+ '+str(filename3)+'\n\n')
-                                else:
-                                    f.write('+ '+str(os.path.splitext(filename3)[0])+'\n\n')
-                        else:
-                            j0 += 1
-                            if starting_from_h1 == None:
-                                f.write('#')
-                            if show_third_number != None:
-                                f.write('### ('+str(j0)+') '+str(filename3)+'\n\n')
-                            else:
-                                f.write('### '+str(filename3)+'\n\n')
-
-                            filenames4 = os.listdir(filename3_with_path)
-                            for filename4 in filenames4[::reverse_positive_or_negative]:
-                                filename4_with_path = os.path.join(directory, filename1, filename2, filename3, filename4) 
-                                if os.path.isfile(filename4_with_path):
-                                    if os.path.splitext(filename4)[1] not in banned_file_format:
-                                        if hide_file_format == None:
-                                            f.write('+ '+str(filename4)+'\n\n')
-                                        else:
-                                            f.write('+ '+str(os.path.splitext(filename4)[0])+'\n\n')
-                                else: 
-                                    if starting_from_h1 == None:
-                                        f.write('#')
-                                    f.write('#### '+str(filename4)+'\n\n')
-
-                                    filenames5 = os.listdir(filename4_with_path)
-                                    for filename5 in filenames5[::reverse_positive_or_negative]:
-                                        filename5_with_path = os.path.join(directory, filename1, filename2, filename3, filename4, filename5) 
-                                        if os.path.isfile(filename5_with_path): 
-                                            if os.path.splitext(filename5)[1] not in banned_file_format:
-                                                if hide_file_format == None:
-                                                    f.write('+ '+str(filename5)+'\n\n')
-                                                else:
-                                                    f.write('+ '+str(os.path.splitext(filename5)[0])+'\n\n')
-                                        else:
-                                            if starting_from_h1 == None:
-                                                f.write('#')
-                                            f.write('##### '+str(filename5)+'\n\n')
-
-                                            filenames6 = os.listdir(filename5_with_path)
-                                            for filename6 in filenames6[::reverse_positive_or_negative]:
-                                                filename6_with_path = os.path.join(directory, filename1, filename2, filename3, filename4, filename5, filename6) 
-                                                if os.path.isfile(filename6_with_path): 
-                                                    if os.path.splitext(filename6)[1] not in banned_file_format:
-                                                        if hide_file_format == None:
-                                                            f.write('+ '+str(filename6)+'\n\n')
-                                                        else:
-                                                            f.write('+ '+str(os.path.splitext(filename6)[0])+'\n\n')
-                                                else:
-                                                    if starting_from_h1 == None:
-                                                        f.write('#')
-                                                    f.write('###### '+str(filename6)+'\n\n')
-    f.close()
-    import guan
-    guan.statistics_of_guan_package()
-
-# 从网页的标签中获取内容
-def get_html_from_tags(link, tags=['title', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'li', 'a']):
-    from bs4 import BeautifulSoup
-    import urllib.request
-    import ssl
-    ssl._create_default_https_context = ssl._create_unverified_context
-    html = urllib.request.urlopen(link).read().decode('utf-8')
-    soup = BeautifulSoup(html, features="lxml")
-    all_tags = soup.find_all(tags)
-    content = ''
-    for tag in all_tags:
-        text = tag.get_text().replace('\n', '')
-        if content == '':
-            content = text
-        else:
-            content = content + '\n\n' + text
-    import guan
-    guan.statistics_of_guan_package()
-    return content
-
-# 生成二维码
-def creat_qrcode(data="https://www.guanjihuan.com", filename='a', file_format='.png'):
-    import qrcode
-    img = qrcode.make(data)
-    img.save(filename+file_format)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 将PDF文件转成文本
-def pdf_to_text(pdf_path):
-    from pdfminer.pdfparser import PDFParser, PDFDocument
-    from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
-    from pdfminer.converter import PDFPageAggregator
-    from pdfminer.layout import LAParams, LTTextBox
-    from pdfminer.pdfinterp import PDFTextExtractionNotAllowed
-    import logging 
-    logging.Logger.propagate = False 
-    logging.getLogger().setLevel(logging.ERROR) 
-    praser = PDFParser(open(pdf_path, 'rb'))
-    doc = PDFDocument()
-    praser.set_document(doc)
-    doc.set_parser(praser)
-    doc.initialize()
-    if not doc.is_extractable:
-        raise PDFTextExtractionNotAllowed
-    else:
-        rsrcmgr = PDFResourceManager()
-        laparams = LAParams()
-        device = PDFPageAggregator(rsrcmgr, laparams=laparams)
-        interpreter = PDFPageInterpreter(rsrcmgr, device)
-        content = ''
-        for page in doc.get_pages():
-            interpreter.process_page(page)                        
-            layout = device.get_result()                     
-            for x in layout:
-                if isinstance(x, LTTextBox):
-                    content  = content + x.get_text().strip()
-    import guan
-    guan.statistics_of_guan_package()
-    return content
-
-# 获取PDF文件页数
-def get_pdf_page_number(pdf_path):
-    import PyPDF2
-    pdf_file = open(pdf_path, 'rb')
-    pdf_reader = PyPDF2.PdfReader(pdf_file)
-    num_pages = len(pdf_reader.pages)
-    import guan
-    guan.statistics_of_guan_package()
-    return num_pages
-
-# 获取PDF文件指定页面的内容
-def pdf_to_txt_for_a_specific_page(pdf_path, page_num=1):
-    import PyPDF2
-    pdf_file = open(pdf_path, 'rb')
-    pdf_reader = PyPDF2.PdfReader(pdf_file)
-    num_pages = len(pdf_reader.pages)
-    for page_num0 in range(num_pages):
-        if page_num0 == page_num-1:
-            page = pdf_reader.pages[page_num0]
-            page_text = page.extract_text()
-    pdf_file.close()
-    import guan
-    guan.statistics_of_guan_package()
-    return page_text
-
-# 获取PDF文献中的链接。例如: link_starting_form='https://doi.org'
-def get_links_from_pdf(pdf_path, link_starting_form=''):
-    import PyPDF2
-    import re
-    pdfReader = PyPDF2.PdfFileReader(pdf_path)
-    pages = pdfReader.getNumPages()
-    i0 = 0
-    links = []
-    for page in range(pages):
-        pageSliced = pdfReader.getPage(page)
-        pageObject = pageSliced.getObject()
-        if '/Annots' in pageObject.keys():
-            ann = pageObject['/Annots']
-            old = ''
-            for a in ann:
-                u = a.getObject()
-                if '/A' in u.keys():
-                    if re.search(re.compile('^'+link_starting_form), u['/A']['/URI']):
-                        if u['/A']['/URI'] != old:
-                            links.append(u['/A']['/URI']) 
-                            i0 += 1
-                            old = u['/A']['/URI']        
-    import guan
-    guan.statistics_of_guan_package()
-    return links
-
-# 通过Sci-Hub网站下载文献
-def download_with_scihub(address=None, num=1):
-    from bs4 import BeautifulSoup
-    import re
-    import requests
-    import os
-    if num==1 and address!=None:
-        address_array = [address]
-    else:
-        address_array = []
-        for i in range(num):
-            address = input('\nInput：')
-            address_array.append(address)
-    for address in address_array:
-        r = requests.post('https://sci-hub.st/', data={'request': address})
-        print('\nResponse：', r)
-        print('Address：', r.url)
-        soup = BeautifulSoup(r.text, features='lxml')
-        pdf_URL = soup.embed['src']
-        # pdf_URL = soup.iframe['src'] # This is a code line of history version which fails to get pdf URL.
-        if re.search(re.compile('^https:'), pdf_URL):
-            pass
-        else:
-            pdf_URL = 'https:'+pdf_URL
-        print('PDF address：', pdf_URL)
-        name = re.search(re.compile('fdp.*?/'),pdf_URL[::-1]).group()[::-1][1::]
-        print('PDF name：', name)
-        print('Directory：', os.getcwd())
-        print('\nDownloading...')
-        r = requests.get(pdf_URL, stream=True)
-        with open(name, 'wb') as f:
-            for chunk in r.iter_content(chunk_size=32):
-                f.write(chunk)
-        print('Completed!\n')
-    if num != 1:
-        print('All completed!\n')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 将文本转成音频
-def str_to_audio(str='hello world', filename='str', rate=125, voice=1, read=1, save=0, compress=0, bitrate='16k', print_text=0):
-    import pyttsx3
-    import guan
-    if print_text==1:
-        print(str)
-    engine = pyttsx3.init()
-    voices = engine.getProperty('voices')  
-    engine.setProperty('voice', voices[voice].id)
-    engine.setProperty("rate", rate)
-    if save==1:
-        engine.save_to_file(str, filename+'.wav')
-        engine.runAndWait()
-        print('Wav file saved!')
-        if compress==1:
-            import os
-            os.rename(filename+'.wav', 'temp.wav')
-            guan.compress_wav_to_mp3('temp.wav', output_filename=filename+'.mp3', bitrate=bitrate)
-            os.remove('temp.wav')
-    if read==1:
-        engine.say(str)
-        engine.runAndWait()
-    guan.statistics_of_guan_package()
-
-# 将txt文件转成音频
-def txt_to_audio(txt_path, rate=125, voice=1, read=1, save=0, compress=0, bitrate='16k', print_text=0):
-    import pyttsx3
-    import guan
-    f = open(txt_path, 'r', encoding ='utf-8')
-    text = f.read()
-    if print_text==1:
-        print(text)
-    engine = pyttsx3.init()
-    voices = engine.getProperty('voices')  
-    engine.setProperty('voice', voices[voice].id)
-    engine.setProperty("rate", rate)
-    if save==1:
-        import re
-        filename = re.split('[/,\\\]', txt_path)[-1][:-4]
-        engine.save_to_file(text, filename+'.wav')
-        engine.runAndWait()
-        print('Wav file saved!')
-        if compress==1:
-            import os
-            os.rename(filename+'.wav', 'temp.wav')
-            guan.compress_wav_to_mp3('temp.wav', output_filename=filename+'.mp3', bitrate=bitrate)
-            os.remove('temp.wav')
-    if read==1:
-        engine.say(text)
-        engine.runAndWait()
-    guan.statistics_of_guan_package()
-
-# 将PDF文件转成音频
-def pdf_to_audio(pdf_path, rate=125, voice=1, read=1, save=0, compress=0, bitrate='16k', print_text=0):
-    import pyttsx3
-    import guan
-    text = guan.pdf_to_text(pdf_path)
-    text = text.replace('\n', ' ')
-    if print_text==1:
-        print(text)
-    engine = pyttsx3.init()
-    voices = engine.getProperty('voices')  
-    engine.setProperty('voice', voices[voice].id)
-    engine.setProperty("rate", rate)
-    if save==1:
-        import re
-        filename = re.split('[/,\\\]', pdf_path)[-1][:-4]
-        engine.save_to_file(text, filename+'.wav')
-        engine.runAndWait()
-        print('Wav file saved!')
-        if compress==1:
-            import os
-            os.rename(filename+'.wav', 'temp.wav')
-            guan.compress_wav_to_mp3('temp.wav', output_filename=filename+'.mp3', bitrate=bitrate)
-            os.remove('temp.wav')
-    if read==1:
-        engine.say(text)
-        engine.runAndWait()
-    guan.statistics_of_guan_package()
-
-# 将wav音频文件压缩成MP3音频文件
-def compress_wav_to_mp3(wav_path, output_filename='a.mp3', bitrate='16k'):
-    # Note: Beside the installation of pydub, you may also need download FFmpeg on http://www.ffmpeg.org/download.html and add the bin path to the environment variable.
-    from pydub import AudioSegment
-    sound = AudioSegment.from_mp3(wav_path)
-    sound.export(output_filename,format="mp3",bitrate=bitrate)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 播放学术单词
-def play_academic_words(reverse=0, random_on=0, bre_or_ame='ame', show_translation=1, show_link=1, translation_time=2, rest_time=1):
-    from bs4 import BeautifulSoup
-    import re
-    import urllib.request
-    import requests
-    import os
-    import pygame
-    import time
-    import ssl
-    import random
-    ssl._create_default_https_context = ssl._create_unverified_context
-    html = urllib.request.urlopen("https://www.guanjihuan.com/archives/4418").read().decode('utf-8')
-    if bre_or_ame == 'ame':
-        directory = 'words_mp3_ameProns/'
-    elif bre_or_ame == 'bre':
-        directory = 'words_mp3_breProns/'
-    exist_directory = os.path.exists(directory)
-    html_file = urllib.request.urlopen("https://file.guanjihuan.com/words/"+directory).read().decode('utf-8')
-    if exist_directory == 0:
-        os.makedirs(directory)
-    soup = BeautifulSoup(html, features='lxml')
-    contents = re.findall('<h2.*?</a></p>', html, re.S)
-    if random_on==1:
-        random.shuffle(contents)
-    if reverse==1:
-        contents.reverse()
-    for content in contents:
-        soup2 = BeautifulSoup(content, features='lxml')
-        all_h2 = soup2.find_all('h2')
-        for h2 in all_h2:
-            if re.search('\d*. ', h2.get_text()):
-                word = re.findall('[a-zA-Z].*', h2.get_text(), re.S)[0]
-                exist = os.path.exists(directory+word+'.mp3')
-                if not exist:
-                    try:
-                        if re.search(word, html_file):
-                            r = requests.get("https://file.guanjihuan.com/words/"+directory+word+".mp3", stream=True)
-                            with open(directory+word+'.mp3', 'wb') as f:
-                                for chunk in r.iter_content(chunk_size=32):
-                                    f.write(chunk)
-                    except:
-                        pass
-                print(h2.get_text())
-                try:
-                    pygame.mixer.init()
-                    track = pygame.mixer.music.load(directory+word+'.mp3')
-                    pygame.mixer.music.play()
-                    if show_link==1:
-                        print('https://www.ldoceonline.com/dictionary/'+word)
-                except:
-                    pass
-                translation = re.findall('<p>.*?</p>', content, re.S)[0][3:-4]
-                if show_translation==1:
-                    time.sleep(translation_time)
-                    print(translation)
-                time.sleep(rest_time)
-                pygame.mixer.music.stop()
-                print()
-    import guan
-    guan.statistics_of_guan_package()
-
-# 播放挑选过后的学术单词
-def play_selected_academic_words(reverse=0, random_on=0, bre_or_ame='ame', show_link=1, rest_time=3):
-    from bs4 import BeautifulSoup
-    import re
-    import urllib.request
-    import requests
-    import os
-    import pygame
-    import time
-    import ssl
-    import random
-    ssl._create_default_https_context = ssl._create_unverified_context
-    html = urllib.request.urlopen("https://www.guanjihuan.com/archives/24732").read().decode('utf-8')
-    if bre_or_ame == 'ame':
-        directory = 'words_mp3_ameProns/'
-    elif bre_or_ame == 'bre':
-        directory = 'words_mp3_breProns/'
-    exist_directory = os.path.exists(directory)
-    html_file = urllib.request.urlopen("https://file.guanjihuan.com/words/"+directory).read().decode('utf-8')
-    if exist_directory == 0:
-        os.makedirs(directory)
-    soup = BeautifulSoup(html, features='lxml')
-    contents = re.findall('<li>\d.*?</li>', html, re.S)
-    if random_on==1:
-        random.shuffle(contents)
-    if reverse==1:
-        contents.reverse()
-    for content in contents:
-        soup2 = BeautifulSoup(content, features='lxml')
-        all_li = soup2.find_all('li')
-        for li in all_li:
-            if re.search('\d*. ', li.get_text()):
-                word = re.findall('\s[a-zA-Z].*?\s', li.get_text(), re.S)[0][1:-1]
-                exist = os.path.exists(directory+word+'.mp3')
-                if not exist:
-                    try:
-                        if re.search(word, html_file):
-                            r = requests.get("https://file.guanjihuan.com/words/"+directory+word+".mp3", stream=True)
-                            with open(directory+word+'.mp3', 'wb') as f:
-                                for chunk in r.iter_content(chunk_size=32):
-                                    f.write(chunk)
-                    except:
-                        pass
-                print(li.get_text())
-                try:
-                    pygame.mixer.init()
-                    track = pygame.mixer.music.load(directory+word+'.mp3')
-                    pygame.mixer.music.play()
-                    if show_link==1:
-                        print('https://www.ldoceonline.com/dictionary/'+word)
-                except:
-                    pass
-                time.sleep(rest_time)
-                pygame.mixer.music.stop()
-                print()
-    import guan
-    guan.statistics_of_guan_package()
-
-# 播放元素周期表上的单词
-def play_element_words(random_on=0, show_translation=1, show_link=1, translation_time=2, rest_time=1):
-    from bs4 import BeautifulSoup
-    import re
-    import urllib.request
-    import requests
-    import os
-    import pygame
-    import time
-    import ssl
-    import random
-    ssl._create_default_https_context = ssl._create_unverified_context
-    html = urllib.request.urlopen("https://www.guanjihuan.com/archives/10897").read().decode('utf-8')
-    directory = 'prons/'
-    exist_directory = os.path.exists(directory)
-    html_file = urllib.request.urlopen("https://file.guanjihuan.com/words/periodic_table_of_elements/"+directory).read().decode('utf-8')
-    if exist_directory == 0:
-        os.makedirs(directory)
-    soup = BeautifulSoup(html, features='lxml')
-    contents = re.findall('<h2.*?</a></p>', html, re.S)
-    if random_on==1:
-        random.shuffle(contents)
-    for content in contents:
-        soup2 = BeautifulSoup(content, features='lxml')
-        all_h2 = soup2.find_all('h2')
-        for h2 in all_h2:
-            if re.search('\d*. ', h2.get_text()):
-                word = re.findall('[a-zA-Z].* \(', h2.get_text(), re.S)[0][:-2]
-                exist = os.path.exists(directory+word+'.mp3')
-                if not exist:
-                    try:
-                        if re.search(word, html_file):
-                            r = requests.get("https://file.guanjihuan.com/words/periodic_table_of_elements/prons/"+word+".mp3", stream=True)
-                            with open(directory+word+'.mp3', 'wb') as f:
-                                for chunk in r.iter_content(chunk_size=32):
-                                    f.write(chunk)
-                    except:
-                        pass
-                print(h2.get_text())
-                try:
-                    pygame.mixer.init()
-                    track = pygame.mixer.music.load(directory+word+'.mp3')
-                    pygame.mixer.music.play()
-                    if show_link==1:
-                        print('https://www.merriam-webster.com/dictionary/'+word)
-                except:
-                    pass
-                translation = re.findall('<p>.*?</p>', content, re.S)[0][3:-4]
-                if show_translation==1:
-                    time.sleep(translation_time)
-                    print(translation)
-                time.sleep(rest_time)
-                pygame.mixer.music.stop()
-                print()
-    import guan
-    guan.statistics_of_guan_package()

PyPI/src/guan/plot_figures.py

@@ -1,413 +0,0 @@
-# Module: plot_figures
-
-# 导入plt, fig, ax
-def import_plt_and_start_fig_ax(adjust_bottom=0.2, adjust_left=0.2, labelsize=20):
-    import matplotlib.pyplot as plt
-    fig, ax = plt.subplots()
-    plt.subplots_adjust(bottom=adjust_bottom, left=adjust_left)
-    ax.grid()
-    ax.tick_params(labelsize=labelsize) 
-    labels = ax.get_xticklabels() + ax.get_yticklabels()
-    [label.set_fontname('Times New Roman') for label in labels]
-    import guan
-    guan.statistics_of_guan_package()
-    return plt, fig, ax
-
-# 基于plt, fig, ax开始画图
-def plot_without_starting_fig(plt, fig, ax, x_array, y_array, xlabel='x', ylabel='y', title='', fontsize=20, style='', y_min=None, y_max=None, linewidth=None, markersize=None, color=None): 
-    if color==None:
-        ax.plot(x_array, y_array, style, linewidth=linewidth, markersize=markersize)
-    else:
-        ax.plot(x_array, y_array, style, linewidth=linewidth, markersize=markersize, color=color)
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    if y_min!=None or y_max!=None:
-        if y_min==None:
-            y_min=min(y_array)
-        if y_max==None:
-            y_max=max(y_array)
-        ax.set_ylim(y_min, y_max)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 画图
-def plot(x_array, y_array, xlabel='x', ylabel='y', title='', fontsize=20, labelsize=20, show=1, save=0, filename='a', file_format='.jpg', dpi=300, style='', y_min=None, y_max=None, linewidth=None, markersize=None, adjust_bottom=0.2, adjust_left=0.2): 
-    import guan
-    plt, fig, ax = guan.import_plt_and_start_fig_ax(adjust_bottom=adjust_bottom, adjust_left=adjust_left, labelsize=labelsize)
-    ax.plot(x_array, y_array, style, linewidth=linewidth, markersize=markersize)
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    if y_min!=None or y_max!=None:
-        if y_min==None:
-            y_min=min(y_array)
-        if y_max==None:
-            y_max=max(y_array)
-        ax.set_ylim(y_min, y_max)
-    if save == 1:
-        plt.savefig(filename+file_format, dpi=dpi) 
-    if show == 1:
-        plt.show()
-    plt.close('all')
-    guan.statistics_of_guan_package()
-
-# 一组横坐标数据，两组纵坐标数据画图
-def plot_two_array(x_array, y1_array, y2_array, xlabel='x', ylabel='y', title='', fontsize=20, labelsize=20, show=1, save=0, filename='a', file_format='.jpg', dpi=300, style_1='', style_2='', y_min=None, y_max=None, linewidth_1=None, linewidth_2=None, markersize_1=None, markersize_2=None, adjust_bottom=0.2, adjust_left=0.2): 
-    import guan
-    plt, fig, ax = guan.import_plt_and_start_fig_ax(adjust_bottom=adjust_bottom, adjust_left=adjust_left, labelsize=labelsize) 
-    ax.plot(x_array, y1_array, style_1, linewidth=linewidth_1, markersize=markersize_1)
-    ax.plot(x_array, y2_array, style_2, linewidth=linewidth_2, markersize=markersize_2)
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    if y_min!=None or y_max!=None:
-        if y_min==None:
-            y1_min=min(y1_array)
-            y2_min=min(y2_array)
-            y_min=min([y1_min, y2_min])
-        if y_max==None:
-            y1_max=max(y1_array)
-            y2_max=max(y2_array)
-            y_max=max([y1_max, y2_max])
-        ax.set_ylim(y_min, y_max)
-    if save == 1:
-        plt.savefig(filename+file_format, dpi=dpi) 
-    if show == 1:
-        plt.show()
-    plt.close('all')
-    guan.statistics_of_guan_package()
-
-# 两组横坐标数据，两组纵坐标数据画图
-def plot_two_array_with_two_horizontal_array(x1_array, x2_array, y1_array, y2_array, xlabel='x', ylabel='y', title='', fontsize=20, labelsize=20, show=1, save=0, filename='a', file_format='.jpg', dpi=300, style_1='', style_2='', y_min=None, y_max=None, linewidth_1=None, linewidth_2=None, markersize_1=None, markersize_2=None, adjust_bottom=0.2, adjust_left=0.2): 
-    import guan
-    plt, fig, ax = guan.import_plt_and_start_fig_ax(adjust_bottom=adjust_bottom, adjust_left=adjust_left, labelsize=labelsize) 
-    ax.plot(x1_array, y1_array, style_1, linewidth=linewidth_1, markersize=markersize_1)
-    ax.plot(x2_array, y2_array, style_2, linewidth=linewidth_2, markersize=markersize_2)
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    if y_min!=None or y_max!=None:
-        if y_min==None:
-            y1_min=min(y1_array)
-            y2_min=min(y2_array)
-            y_min=min([y1_min, y2_min])
-        if y_max==None:
-            y1_max=max(y1_array)
-            y2_max=max(y2_array)
-            y_max=max([y1_max, y2_max])
-        ax.set_ylim(y_min, y_max)
-    if save == 1:
-        plt.savefig(filename+file_format, dpi=dpi) 
-    if show == 1:
-        plt.show()
-    plt.close('all')
-    guan.statistics_of_guan_package()
-
-# 一组横坐标数据，三组纵坐标数据画图
-def plot_three_array(x_array, y1_array, y2_array, y3_array, xlabel='x', ylabel='y', title='', fontsize=20, labelsize=20, show=1, save=0, filename='a', file_format='.jpg', dpi=300, style_1='', style_2='', style_3='', y_min=None, y_max=None, linewidth_1=None, linewidth_2=None, linewidth_3=None,markersize_1=None, markersize_2=None, markersize_3=None, adjust_bottom=0.2, adjust_left=0.2): 
-    import guan
-    plt, fig, ax = guan.import_plt_and_start_fig_ax(adjust_bottom=adjust_bottom, adjust_left=adjust_left, labelsize=labelsize) 
-    ax.plot(x_array, y1_array, style_1, linewidth=linewidth_1, markersize=markersize_1)
-    ax.plot(x_array, y2_array, style_2, linewidth=linewidth_2, markersize=markersize_2)
-    ax.plot(x_array, y3_array, style_3, linewidth=linewidth_3, markersize=markersize_3)
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    if y_min!=None or y_max!=None:
-        if y_min==None:
-            y1_min=min(y1_array)
-            y2_min=min(y2_array)
-            y3_min=min(y3_array)
-            y_min=min([y1_min, y2_min, y3_min])
-        if y_max==None:
-            y1_max=max(y1_array)
-            y2_max=max(y2_array)
-            y3_max=max(y3_array)
-            y_max=max([y1_max, y2_max, y3_max])
-        ax.set_ylim(y_min, y_max)
-    if save == 1:
-        plt.savefig(filename+file_format, dpi=dpi) 
-    if show == 1:
-        plt.show()
-    plt.close('all')
-    guan.statistics_of_guan_package()
-
-# 三组横坐标数据，三组纵坐标数据画图
-def plot_three_array_with_three_horizontal_array(x1_array, x2_array, x3_array, y1_array, y2_array, y3_array, xlabel='x', ylabel='y', title='', fontsize=20, labelsize=20, show=1, save=0, filename='a', file_format='.jpg', dpi=300, style_1='', style_2='', style_3='', y_min=None, y_max=None, linewidth_1=None, linewidth_2=None, linewidth_3=None,markersize_1=None, markersize_2=None, markersize_3=None, adjust_bottom=0.2, adjust_left=0.2): 
-    import guan
-    plt, fig, ax = guan.import_plt_and_start_fig_ax(adjust_bottom=adjust_bottom, adjust_left=adjust_left, labelsize=labelsize) 
-    ax.plot(x1_array, y1_array, style_1, linewidth=linewidth_1, markersize=markersize_1)
-    ax.plot(x2_array, y2_array, style_2, linewidth=linewidth_2, markersize=markersize_2)
-    ax.plot(x3_array, y3_array, style_3, linewidth=linewidth_3, markersize=markersize_3)
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    if y_min!=None or y_max!=None:
-        if y_min==None:
-            y1_min=min(y1_array)
-            y2_min=min(y2_array)
-            y3_min=min(y3_array)
-            y_min=min([y1_min, y2_min, y3_min])
-        if y_max==None:
-            y1_max=max(y1_array)
-            y2_max=max(y2_array)
-            y3_max=max(y3_array)
-            y_max=max([y1_max, y2_max, y3_max])
-        ax.set_ylim(y_min, y_max)
-    if save == 1:
-        plt.savefig(filename+file_format, dpi=dpi) 
-    if show == 1:
-        plt.show()
-    plt.close('all')
-    guan.statistics_of_guan_package()
-
-# 画三维图
-def plot_3d_surface(x_array, y_array, matrix, xlabel='x', ylabel='y', zlabel='z', title='', fontsize=20, labelsize=15, show=1, save=0, filename='a', file_format='.jpg', dpi=300, z_min=None, z_max=None, rcount=100, ccount=100): 
-    import numpy as np
-    import matplotlib.pyplot as plt
-    from matplotlib import cm
-    from matplotlib.ticker import LinearLocator
-    matrix = np.array(matrix)
-    fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
-    plt.subplots_adjust(bottom=0.1, right=0.65) 
-    x_array, y_array = np.meshgrid(x_array, y_array)
-    if len(matrix.shape) == 2:
-        surf = ax.plot_surface(x_array, y_array, matrix, rcount=rcount, ccount=ccount, cmap=cm.coolwarm, linewidth=0, antialiased=False) 
-    elif len(matrix.shape) == 3:
-        for i0 in range(matrix.shape[2]):
-            surf = ax.plot_surface(x_array, y_array, matrix[:,:,i0], rcount=rcount, ccount=ccount, cmap=cm.coolwarm, linewidth=0, antialiased=False) 
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_zlabel(zlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.zaxis.set_major_locator(LinearLocator(5)) 
-    ax.zaxis.set_major_formatter('{x:.2f}')  
-    if z_min!=None or z_max!=None:
-        if z_min==None:
-            z_min=matrix.min()
-        if z_max==None:
-            z_max=matrix.max()
-        ax.set_zlim(z_min, z_max)
-    ax.tick_params(labelsize=labelsize) 
-    labels = ax.get_xticklabels() + ax.get_yticklabels() + ax.get_zticklabels()
-    [label.set_fontname('Times New Roman') for label in labels] 
-    cax = plt.axes([0.8, 0.1, 0.05, 0.8]) 
-    cbar = fig.colorbar(surf, cax=cax)  
-    cbar.ax.tick_params(labelsize=labelsize)
-    for l in cbar.ax.yaxis.get_ticklabels():
-        l.set_family('Times New Roman')
-    if save == 1:
-        plt.savefig(filename+file_format, dpi=dpi) 
-    if show == 1:
-        plt.show()
-    plt.close('all')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 画Contour图
-def plot_contour(x_array, y_array, matrix, xlabel='x', ylabel='y', title='', fontsize=20, labelsize=15, cmap='jet', levels=None, show=1, save=0, filename='a', file_format='.jpg', dpi=300):
-    import numpy as np
-    import matplotlib.pyplot as plt
-    fig, ax = plt.subplots()
-    plt.subplots_adjust(bottom=0.2, right=0.75, left=0.2) 
-    x_array, y_array = np.meshgrid(x_array, y_array)
-    contour = ax.contourf(x_array,y_array,matrix,cmap=cmap, levels=levels) 
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.tick_params(labelsize=labelsize) 
-    labels = ax.get_xticklabels() + ax.get_yticklabels()
-    [label.set_fontname('Times New Roman') for label in labels]
-    cax = plt.axes([0.8, 0.2, 0.05, 0.68])
-    cbar = fig.colorbar(contour, cax=cax) 
-    cbar.ax.tick_params(labelsize=labelsize) 
-    for l in cbar.ax.yaxis.get_ticklabels():
-        l.set_family('Times New Roman')
-    if save == 1:
-        plt.savefig(filename+file_format, dpi=dpi) 
-    if show == 1:
-        plt.show()
-    plt.close('all')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 画棋盘图/伪彩色图
-def plot_pcolor(x_array, y_array, matrix, xlabel='x', ylabel='y', title='', fontsize=20, labelsize=15, cmap='jet', levels=None, show=1, save=0, filename='a', file_format='.jpg', dpi=300):  
-    import numpy as np
-    import matplotlib.pyplot as plt
-    fig, ax = plt.subplots()
-    plt.subplots_adjust(bottom=0.2, right=0.75, left=0.2) 
-    x_array, y_array = np.meshgrid(x_array, y_array)
-    contour = ax.pcolor(x_array,y_array,matrix, cmap=cmap)
-    ax.set_title(title, fontsize=fontsize, fontfamily='Times New Roman')
-    ax.set_xlabel(xlabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.set_ylabel(ylabel, fontsize=fontsize, fontfamily='Times New Roman') 
-    ax.tick_params(labelsize=labelsize) 
-    labels = ax.get_xticklabels() + ax.get_yticklabels()
-    [label.set_fontname('Times New Roman') for label in labels]
-    cax = plt.axes([0.8, 0.2, 0.05, 0.68])
-    cbar = fig.colorbar(contour, cax=cax) 
-    cbar.ax.tick_params(labelsize=labelsize) 
-    for l in cbar.ax.yaxis.get_ticklabels():
-        l.set_family('Times New Roman')
-    if save == 1:
-        plt.savefig(filename+file_format, dpi=dpi) 
-    if show == 1:
-        plt.show()
-    plt.close('all')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 通过坐标画点和线
-def draw_dots_and_lines(coordinate_array, draw_dots=1, draw_lines=1, max_distance=1.1, line_style='-k', linewidth=1, dot_style='ro', markersize=3, show=1, save=0, filename='a', file_format='.eps', dpi=300):
-    import numpy as np
-    import matplotlib.pyplot as plt
-    coordinate_array = np.array(coordinate_array)
-    print(coordinate_array.shape)
-    x_range = max(coordinate_array[:, 0])-min(coordinate_array[:, 0])
-    y_range = max(coordinate_array[:, 1])-min(coordinate_array[:, 1])
-    fig, ax = plt.subplots(figsize=(6*x_range/y_range,6))
-    plt.subplots_adjust(left=0, bottom=0, right=1, top=1)
-    plt.axis('off')
-    if draw_lines==1:
-        for i1 in range(coordinate_array.shape[0]):
-            for i2 in range(coordinate_array.shape[0]):
-                if np.sqrt((coordinate_array[i1, 0] - coordinate_array[i2, 0])**2+(coordinate_array[i1, 1] - coordinate_array[i2, 1])**2) < max_distance:
-                    ax.plot([coordinate_array[i1, 0], coordinate_array[i2, 0]], [coordinate_array[i1, 1], coordinate_array[i2, 1]], line_style, linewidth=linewidth)
-    if draw_dots==1:
-        for i in range(coordinate_array.shape[0]):
-            ax.plot(coordinate_array[i, 0], coordinate_array[i, 1], dot_style, markersize=markersize)
-    if show==1:
-        plt.show()
-    if save==1:
-        if file_format=='.eps':
-            plt.savefig(filename+file_format)
-        else:
-            plt.savefig(filename+file_format, dpi=dpi)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 合并两个图片
-def combine_two_images(image_path_array, figsize=(16,8), show=0, save=1, filename='a', file_format='.jpg', dpi=300):
-    import numpy as np
-    num = np.array(image_path_array).shape[0]
-    if num != 2:
-        print('Error: The number of images should be two!')
-    else:
-        import matplotlib.pyplot as plt
-        import matplotlib.image as mpimg
-        fig = plt.figure(figsize=figsize)
-        plt.subplots_adjust(left=0, right=1, bottom=0, top=1, wspace=0, hspace=0) 
-        ax1 = fig.add_subplot(121)
-        ax2 = fig.add_subplot(122)
-        image_1 = mpimg.imread(image_path_array[0])
-        image_2 = mpimg.imread(image_path_array[1])
-        ax1.imshow(image_1)
-        ax2.imshow(image_2)
-        ax1.axis('off')
-        ax2.axis('off')
-        if show == 1:
-            plt.show()
-        if save == 1:
-            plt.savefig(filename+file_format, dpi=dpi)
-        plt.close('all')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 合并三个图片
-def combine_three_images(image_path_array, figsize=(16,5), show=0, save=1, filename='a', file_format='.jpg', dpi=300):
-    import numpy as np
-    num = np.array(image_path_array).shape[0]
-    if num != 3:
-        print('Error: The number of images should be three!')
-    else:
-        import matplotlib.pyplot as plt
-        import matplotlib.image as mpimg
-        fig = plt.figure(figsize=figsize)
-        plt.subplots_adjust(left=0, right=1, bottom=0, top=1, wspace=0, hspace=0) 
-        ax1 = fig.add_subplot(131)
-        ax2 = fig.add_subplot(132)
-        ax3 = fig.add_subplot(133)
-        image_1 = mpimg.imread(image_path_array[0])
-        image_2 = mpimg.imread(image_path_array[1])
-        image_3 = mpimg.imread(image_path_array[2])
-        ax1.imshow(image_1)
-        ax2.imshow(image_2)
-        ax3.imshow(image_3)
-        ax1.axis('off')
-        ax2.axis('off')
-        ax3.axis('off')
-        if show == 1:
-            plt.show()
-        if save == 1:
-            plt.savefig(filename+file_format, dpi=dpi)
-        plt.close('all')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 合并四个图片
-def combine_four_images(image_path_array, figsize=(16,16), show=0, save=1, filename='a', file_format='.jpg', dpi=300):
-    import numpy as np
-    num = np.array(image_path_array).shape[0]
-    if num != 4:
-        print('Error: The number of images should be four!')
-    else:
-        import matplotlib.pyplot as plt
-        import matplotlib.image as mpimg
-        fig = plt.figure(figsize=figsize)
-        plt.subplots_adjust(left=0, right=1, bottom=0, top=1, wspace=0, hspace=0) 
-        ax1 = fig.add_subplot(221)
-        ax2 = fig.add_subplot(222)
-        ax3 = fig.add_subplot(223)
-        ax4 = fig.add_subplot(224)
-        image_1 = mpimg.imread(image_path_array[0])
-        image_2 = mpimg.imread(image_path_array[1])
-        image_3 = mpimg.imread(image_path_array[2])
-        image_4 = mpimg.imread(image_path_array[3])
-        ax1.imshow(image_1)
-        ax2.imshow(image_2)
-        ax3.imshow(image_3)
-        ax4.imshow(image_4)
-        ax1.axis('off')
-        ax2.axis('off')
-        ax3.axis('off')
-        ax4.axis('off')
-        if show == 1:
-            plt.show()
-        if save == 1:
-            plt.savefig(filename+file_format, dpi=dpi)
-        plt.close('all')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 对于某个目录中的txt文件，批量读取和画图
-def batch_reading_and_plotting(directory, xlabel='x', ylabel='y'):
-    import re
-    import os
-    import guan
-    for root, dirs, files in os.walk(directory):
-        for file in files:
-            if re.search('^txt.', file[::-1]):
-                filename = file[:-4]
-                x_array, y_array = guan.read_one_dimensional_data(filename=filename)
-                guan.plot(x_array, y_array, xlabel=xlabel, ylabel=ylabel, title=filename, show=0, save=1, filename=filename)
-    guan.statistics_of_guan_package()
-
-# 制作GIF动画
-def make_gif(image_path_array, filename='a', duration=0.1):
-    import imageio
-    images = []
-    for image_path in image_path_array:
-        im = imageio.imread(image_path)
-        images.append(im)
-    imageio.mimsave(filename+'.gif', images, 'GIF', duration=duration)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 选取颜色
-def color_matplotlib():
-    color_array = ['tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple', 'tab:brown', 'tab:pink', 'tab:gray', 'tab:olive', 'tab:cyan']
-    import guan
-    guan.statistics_of_guan_package()
-    return color_array

PyPI/src/guan/quantum_transport.py

@@ -479,7 +479,7 @@ def calculate_scattering_matrix_and_get_information(fermi_energy, h00, h01, leng
 
     return number_of_active_channels, number_of_evanescent_channels, k_of_right_moving_active_channels, k_of_left_moving_active_channels, velocity_of_right_moving_active_channels, velocity_of_left_moving_active_channels, transmission_matrix_for_active_channels, reflection_matrix_for_active_channels, total_transmission_of_channels, total_conductance, total_reflection_of_channels, sum_of_transmission_and_reflection_of_channels
 
-# 从散射矩阵中，打印出散射矩阵的信息
+# 从散射矩阵中打印出散射矩阵的信息
 def print_or_write_scattering_matrix_with_information_of_scattering_matrix(number_of_active_channels, number_of_evanescent_channels, k_of_right_moving_active_channels, k_of_left_moving_active_channels, velocity_of_right_moving_active_channels, velocity_of_left_moving_active_channels, transmission_matrix_for_active_channels, reflection_matrix_for_active_channels, total_transmission_of_channels, total_conductance, total_reflection_of_channels, sum_of_transmission_and_reflection_of_channels, print_show=1, write_file=0, filename='a', file_format='.txt'):
     if print_show == 1:
         print('\nActive channel (left or right) = ', number_of_active_channels)

PyPI/src/guan/read_and_write.py

@@ -1,263 +0,0 @@
-# Module: read_and_write
-
-# 将数据存到文件
-def dump_data(data, filename, file_format='.txt'):
-    import pickle
-    with open(filename+file_format, 'wb') as f:
-        pickle.dump(data, f)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 从文件中恢复数据到变量
-def load_data(filename, file_format='.txt'):
-    import pickle
-    with open(filename+file_format, 'rb') as f:
-        data = pickle.load(f)
-    import guan
-    guan.statistics_of_guan_package()
-    return data
-
-# 读取文件中的一维数据（每一行一组x和y）
-def read_one_dimensional_data(filename='a', file_format='.txt'): 
-    import numpy as np
-    f = open(filename+file_format, 'r')
-    text = f.read()
-    f.close()
-    row_list = np.array(text.split('\n')) 
-    dim_column = np.array(row_list[0].split()).shape[0] 
-    x_array = np.array([])
-    y_array = np.array([])
-    for row in row_list:
-        column = np.array(row.split()) 
-        if column.shape[0] != 0:  
-            x_array = np.append(x_array, [float(column[0])], axis=0)  
-            y_row = np.zeros(dim_column-1)
-            for dim0 in range(dim_column-1):
-                y_row[dim0] = float(column[dim0+1])
-            if np.array(y_array).shape[0] == 0:
-                y_array = [y_row]
-            else:
-                y_array = np.append(y_array, [y_row], axis=0)
-    import guan
-    guan.statistics_of_guan_package()
-    return x_array, y_array
-
-# 读取文件中的一维数据（每一行一组x和y）（支持复数形式）
-def read_one_dimensional_complex_data(filename='a', file_format='.txt'): 
-    import numpy as np
-    f = open(filename+file_format, 'r')
-    text = f.read()
-    f.close()
-    row_list = np.array(text.split('\n')) 
-    dim_column = np.array(row_list[0].split()).shape[0] 
-    x_array = np.array([])
-    y_array = np.array([])
-    for row in row_list:
-        column = np.array(row.split()) 
-        if column.shape[0] != 0:  
-            x_array = np.append(x_array, [complex(column[0])], axis=0)  
-            y_row = np.zeros(dim_column-1, dtype=complex)
-            for dim0 in range(dim_column-1):
-                y_row[dim0] = complex(column[dim0+1])
-            if np.array(y_array).shape[0] == 0:
-                y_array = [y_row]
-            else:
-                y_array = np.append(y_array, [y_row], axis=0)
-    import guan
-    guan.statistics_of_guan_package()
-    return x_array, y_array
-
-# 读取文件中的二维数据（第一行和列分别为横纵坐标）
-def read_two_dimensional_data(filename='a', file_format='.txt'): 
-    import numpy as np
-    f = open(filename+file_format, 'r')
-    text = f.read()
-    f.close()
-    row_list = np.array(text.split('\n')) 
-    dim_column = np.array(row_list[0].split()).shape[0] 
-    x_array = np.array([])
-    y_array = np.array([])
-    matrix = np.array([])
-    for i0 in range(row_list.shape[0]):
-        column = np.array(row_list[i0].split()) 
-        if i0 == 0:
-            x_str = column[1::] 
-            x_array = np.zeros(x_str.shape[0])
-            for i00 in range(x_str.shape[0]):
-                x_array[i00] = float(x_str[i00]) 
-        elif column.shape[0] != 0: 
-            y_array = np.append(y_array, [float(column[0])], axis=0)  
-            matrix_row = np.zeros(dim_column-1)
-            for dim0 in range(dim_column-1):
-                matrix_row[dim0] = float(column[dim0+1])
-            if np.array(matrix).shape[0] == 0:
-                matrix = [matrix_row]
-            else:
-                matrix = np.append(matrix, [matrix_row], axis=0)
-    import guan
-    guan.statistics_of_guan_package()
-    return x_array, y_array, matrix
-
-# 读取文件中的二维数据（第一行和列分别为横纵坐标）（支持复数形式）
-def read_two_dimensional_complex_data(filename='a', file_format='.txt'): 
-    import numpy as np
-    f = open(filename+file_format, 'r')
-    text = f.read()
-    f.close()
-    row_list = np.array(text.split('\n')) 
-    dim_column = np.array(row_list[0].split()).shape[0] 
-    x_array = np.array([])
-    y_array = np.array([])
-    matrix = np.array([])
-    for i0 in range(row_list.shape[0]):
-        column = np.array(row_list[i0].split()) 
-        if i0 == 0:
-            x_str = column[1::] 
-            x_array = np.zeros(x_str.shape[0], dtype=complex)
-            for i00 in range(x_str.shape[0]):
-                x_array[i00] = complex(x_str[i00]) 
-        elif column.shape[0] != 0: 
-            y_array = np.append(y_array, [complex(column[0])], axis=0)  
-            matrix_row = np.zeros(dim_column-1, dtype=complex)
-            for dim0 in range(dim_column-1):
-                matrix_row[dim0] = complex(column[dim0+1])
-            if np.array(matrix).shape[0] == 0:
-                matrix = [matrix_row]
-            else:
-                matrix = np.append(matrix, [matrix_row], axis=0)
-    import guan
-    guan.statistics_of_guan_package()
-    return x_array, y_array, matrix
-
-# 读取文件中的二维数据（不包括x和y）
-def read_two_dimensional_data_without_xy_array(filename='a', file_format='.txt'):
-    import numpy as np
-    matrix = np.loadtxt(filename+file_format)
-    import guan
-    guan.statistics_of_guan_package()
-    return matrix
-
-# 打开文件用于新增内容
-def open_file(filename='a', file_format='.txt'):
-    f = open(filename+file_format, 'a', encoding='UTF-8')
-    import guan
-    guan.statistics_of_guan_package()
-    return f
-
-# 在文件中写入一维数据（每一行一组x和y）
-def write_one_dimensional_data(x_array, y_array, filename='a', file_format='.txt'):
-    import guan
-    with open(filename+file_format, 'w', encoding='UTF-8') as f:
-        guan.write_one_dimensional_data_without_opening_file(x_array, y_array, f)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 在文件中写入一维数据（每一行一组x和y）（需要输入文件）
-def write_one_dimensional_data_without_opening_file(x_array, y_array, f):
-    import numpy as np
-    x_array = np.array(x_array)
-    y_array = np.array(y_array)
-    i0 = 0
-    for x0 in x_array:
-        f.write(str(x0)+'   ')
-        if len(y_array.shape) == 1:
-            f.write(str(y_array[i0])+'\n')
-        elif len(y_array.shape) == 2:
-            for j0 in range(y_array.shape[1]):
-                f.write(str(y_array[i0, j0])+'   ')
-            f.write('\n')
-        i0 += 1
-    import guan
-    guan.statistics_of_guan_package()
-
-# 在文件中写入二维数据（第一行和列分别为横纵坐标）
-def write_two_dimensional_data(x_array, y_array, matrix, filename='a', file_format='.txt'):
-    import guan
-    with open(filename+file_format, 'w', encoding='UTF-8') as f:
-        guan.write_two_dimensional_data_without_opening_file(x_array, y_array, matrix, f)
-    guan.statistics_of_guan_package()
-
-# 在文件中写入二维数据（第一行和列分别为横纵坐标）（需要输入文件）
-def write_two_dimensional_data_without_opening_file(x_array, y_array, matrix, f):
-    import numpy as np
-    x_array = np.array(x_array)
-    y_array = np.array(y_array)
-    matrix = np.array(matrix)
-    f.write('0   ')
-    for x0 in x_array:
-        f.write(str(x0)+'   ')
-    f.write('\n')
-    i0 = 0
-    for y0 in y_array:
-        f.write(str(y0))
-        j0 = 0
-        for x0 in x_array:
-            f.write('   '+str(matrix[i0, j0])+'   ')
-            j0 += 1
-        f.write('\n')
-        i0 += 1
-    import guan
-    guan.statistics_of_guan_package()
-
-# 在文件中写入二维数据（不包括x和y）
-def write_two_dimensional_data_without_xy_array(matrix, filename='a', file_format='.txt'):
-    import guan
-    with open(filename+file_format, 'w', encoding='UTF-8') as f:
-        guan.write_two_dimensional_data_without_xy_array_and_without_opening_file(matrix, f)
-    guan.statistics_of_guan_package()
-
-# 在文件中写入二维数据（不包括x和y）（需要输入文件）
-def write_two_dimensional_data_without_xy_array_and_without_opening_file(matrix, f):
-    for row in matrix:
-        for element in row:
-            f.write(str(element)+'   ')
-        f.write('\n')
-    import guan
-    guan.statistics_of_guan_package()
-
-# 以显示编号的样式，打印数组
-def print_array_with_index(array, show_index=1, index_type=0):
-    if show_index==0:
-        for i0 in array:
-            print(i0)
-    else:
-        if index_type==0:
-            index = 0
-            for i0 in array:
-                print(index, i0)
-                index += 1
-        else:
-            index = 0
-            for i0 in array:
-                index += 1
-                print(index, i0)
-    import guan
-    guan.statistics_of_guan_package()
-
-# 读取文件夹中某个文件类型的所有文本文件
-def read_text_files_in_directory(directory='./', file_format='.md'):
-    import os
-    file_list = []
-    for root, dirs, files in os.walk(directory):
-        for i0 in range(len(files)):
-            if file_format in files[i0]:
-                file_list.append(root+'/'+files[i0])
-    content_array = []
-    for file in file_list:
-        with open(file, 'r') as f:
-            content_array.append(f.read())
-    import guan
-    guan.statistics_of_guan_package()
-    return file_list, content_array
-
-# 在多个文本文件中查找关键词
-def find_words_in_multiple_files(words, directory='./', file_format='.md'):
-    import guan
-    file_list, content_array = guan.read_text_files_in_directory(directory=directory, file_format=file_format)
-    num_files = len(file_list)
-    file_list_with_words = []
-    for i0 in range(num_files):
-        if words in content_array[i0]:
-            file_list_with_words.append(file_list[i0])
-    guan.statistics_of_guan_package()
-    return file_list_with_words

README.md

@@ -1,6 +1,6 @@
 ## Guan package
 
-Guan is an open-source python package developed and maintained by https://www.guanjihuan.com/about (Ji-Huan Guan, 关济寰). With this package, you can calculate band structures, density of states, quantum transport and topological invariant of tight-binding models by invoking the functions you need. Other frequently used functions are also integrated in this package, such as figure plotting, file-reading/writing, file processing, data processing.
+Guan is an open-source python package developed and maintained by https://www.guanjihuan.com/about (Ji-Huan Guan, 关济寰). With this package, you can calculate band structures, density of states, quantum transport and topological invariant of tight-binding models by invoking the functions you need. Other frequently used functions are also integrated, such as figure-plotting and file-reading/writing.
 
 The primary location of this package is on https://py.guanjihuan.com.
 
@@ -16,17 +16,14 @@ import guan
 
 + basic functions
 + Fourier transform
-+ Hamiltonian of finite size systems
++ Hamiltonian of examples
-+ Hamiltonian of models in reciprocal space
 + band structures and wave functions
 + Green functions
 + density of states
 + quantum transport
 + topological invariant
-+ plot figures
-+ read and write
-+ file processing
 + data processing
++ others
 
 ## About this package