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

version 0.0.37 changed to guan.function()

Browse Source
This commit is contained in:
guanjihuan 2021-12-28 21:08:03 +08:00
parent cb0a7d1ac4
commit 3d98ec8cdd
6 changed files with 60 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
PyPI/setup.cfg
View File

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

14
PyPI/src/guan/Hamiltonian_of_models_in_the_reciprocal_space.py
View File

@ -5,14 +5,14 @@
import numpy as np
import cmath
from math import *
from .Fourier_transform import *
import guan
def hamiltonian_of_simple_chain(k):
hamiltonian = one_dimensional_fourier_transform(k, unit_cell=0, hopping=1)
hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=0, hopping=1)
return hamiltonian
def hamiltonian_of_square_lattice(k1, k2):
hamiltonian = two_dimensional_fourier_transform_for_square_lattice(k1, k2, unit_cell=0, hopping_1=1, hopping_2=1)
hamiltonian = guan.two_dimensional_fourier_transform_for_square_lattice(k1, k2, unit_cell=0, hopping_1=1, hopping_2=1)
return hamiltonian
def hamiltonian_of_square_lattice_in_quasi_one_dimension(k, N=10):
@ -23,11 +23,11 @@ def hamiltonian_of_square_lattice_in_quasi_one_dimension(k, N=10):
h00[i+1, i] = 1
for i in range(N):
h01[i, i] = 1
hamiltonian = one_dimensional_fourier_transform(k, unit_cell=h00, hopping=h01)
hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=h00, hopping=h01)
return hamiltonian
def hamiltonian_of_cubic_lattice(k1, k2, k3):
hamiltonian = three_dimensional_fourier_transform_for_cubic_lattice(k1, k2, k3, unit_cell=0, hopping_1=1, hopping_2=1, hopping_3=1)
hamiltonian = guan.three_dimensional_fourier_transform_for_cubic_lattice(k1, k2, k3, unit_cell=0, hopping_1=1, hopping_2=1, hopping_3=1)
return hamiltonian
def hamiltonian_of_ssh_model(k, v=0.6, w=1):
@ -66,7 +66,7 @@ def hamiltonian_of_graphene_with_zigzag_in_quasi_one_dimension(k, N=10, M=0, t=1
for i in range(N):
h01[i*4+1, i*4+0] = t
h01[i*4+2, i*4+3] = t
hamiltonian = one_dimensional_fourier_transform(k, unit_cell=h00, hopping=h01)
hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell=h00, hopping=h01)
return hamiltonian
def hamiltonian_of_haldane_model(k1, k2, M=2/3, t1=1, t2=1/3, phi=pi/4, a=1/sqrt(3)):
@ -121,4 +121,4 @@ def hamiltonian_of_haldane_model_in_quasi_one_dimension(k, N=10, M=2/3, t1=1, t2
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)
return hamiltonian
return hamiltonian

26
PyPI/src/guan/calculate_conductance.py
View File

@ -4,20 +4,20 @@
import numpy as np
import copy
from .calculate_Green_functions import *
import guan
def calculate_conductance(fermi_energy, h00, h01, length=100):
right_self_energy, left_self_energy = self_energy_of_lead(fermi_energy, h00, h01)
right_self_energy, left_self_energy = guan.self_energy_of_lead(fermi_energy, h00, h01)
for ix in range(length):
if ix == 0:
green_nn_n = green_function(fermi_energy, h00, broadening=0, self_energy=left_self_energy)
green_nn_n = guan.green_function(fermi_energy, h00, broadening=0, self_energy=left_self_energy)
green_0n_n = copy.deepcopy(green_nn_n)
elif ix != length-1:
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n, broadening=0)
green_0n_n = green_function_in_n(green_0n_n, h01, green_nn_n)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n, broadening=0)
green_0n_n = guan.green_function_in_n(green_0n_n, h01, green_nn_n)
else:
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n, broadening=0, self_energy=right_self_energy)
green_0n_n = green_function_in_n(green_0n_n, h01, green_nn_n)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n, broadening=0, self_energy=right_self_energy)
green_0n_n = guan.green_function_in_n(green_0n_n, h01, green_nn_n)
right_self_energy = (right_self_energy - right_self_energy.transpose().conj())*1j
left_self_energy = (left_self_energy - left_self_energy.transpose().conj())*1j
conductance = np.trace(np.dot(np.dot(np.dot(left_self_energy, green_0n_n), right_self_energy), green_0n_n.transpose().conj()))
@ -33,7 +33,7 @@ def calculate_conductance_with_fermi_energy_array(fermi_energy_array, h00, h01,
return conductance_array
def calculate_conductance_with_disorder(fermi_energy, h00, h01, disorder_intensity=2.0, disorder_concentration=1.0, length=100):
right_self_energy, left_self_energy = self_energy_of_lead(fermi_energy, h00, h01)
right_self_energy, left_self_energy = guan.self_energy_of_lead(fermi_energy, h00, h01)
dim = np.array(h00).shape[0]
for ix in range(length):
disorder = np.zeros((dim, dim))
@ -41,14 +41,14 @@ def calculate_conductance_with_disorder(fermi_energy, h00, h01, disorder_intensi
if np.random.uniform(0, 1)<=disorder_concentration:
disorder[dim0, dim0] = np.random.uniform(-disorder_intensity, disorder_intensity)
if ix == 0:
green_nn_n = green_function(fermi_energy, h00+disorder, broadening=0, self_energy=left_self_energy)
green_nn_n = guan.green_function(fermi_energy, h00+disorder, broadening=0, self_energy=left_self_energy)
green_0n_n = copy.deepcopy(green_nn_n)
elif ix != length-1:
green_nn_n = green_function_nn_n(fermi_energy, h00+disorder, h01, green_nn_n, broadening=0)
green_0n_n = green_function_in_n(green_0n_n, h01, green_nn_n)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00+disorder, h01, green_nn_n, broadening=0)
green_0n_n = guan.green_function_in_n(green_0n_n, h01, green_nn_n)
else:
green_nn_n = green_function_nn_n(fermi_energy, h00+disorder, h01, green_nn_n, broadening=0, self_energy=right_self_energy)
green_0n_n = green_function_in_n(green_0n_n, h01, green_nn_n)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00+disorder, h01, green_nn_n, broadening=0, self_energy=right_self_energy)
green_0n_n = guan.green_function_in_n(green_0n_n, h01, green_nn_n)
right_self_energy = (right_self_energy - right_self_energy.transpose().conj())*1j
left_self_energy = (left_self_energy - left_self_energy.transpose().conj())*1j
conductance = np.trace(np.dot(np.dot(np.dot(left_self_energy, green_0n_n), right_self_energy), green_0n_n.transpose().conj()))

48
PyPI/src/guan/calculate_density_of_states.py
View File

@ -4,10 +4,10 @@
import numpy as np
from math import *
from .calculate_Green_functions import *
import guan
def total_density_of_states(fermi_energy, hamiltonian, broadening=0.01):
green = green_function(fermi_energy, hamiltonian, broadening)
green = guan.green_function(fermi_energy, hamiltonian, broadening)
total_dos = -np.trace(np.imag(green))/pi
return total_dos
@ -22,7 +22,7 @@ def total_density_of_states_with_fermi_energy_array(fermi_energy_array, hamilton
def local_density_of_states_for_square_lattice(fermi_energy, hamiltonian, N1, N2, internal_degree=1, broadening=0.01):
# dim_hamiltonian = N1*N2*internal_degree
green = green_function(fermi_energy, hamiltonian, broadening)
green = guan.green_function(fermi_energy, hamiltonian, broadening)
local_dos = np.zeros((N2, N1))
for i1 in range(N1):
for i2 in range(N2):
@ -32,7 +32,7 @@ def local_density_of_states_for_square_lattice(fermi_energy, hamiltonian, N1, N2
def local_density_of_states_for_cubic_lattice(fermi_energy, hamiltonian, N1, N2, N3, internal_degree=1, broadening=0.01):
# dim_hamiltonian = N1*N2*N3*internal_degree
green = green_function(fermi_energy, hamiltonian, broadening)
green = guan.green_function(fermi_energy, hamiltonian, broadening)
local_dos = np.zeros((N3, N2, N1))
for i1 in range(N1):
for i2 in range(N2):
@ -44,27 +44,27 @@ def local_density_of_states_for_cubic_lattice(fermi_energy, hamiltonian, N1, N2,
def local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy, h00, h01, N2, N1, internal_degree=1, broadening=0.01):
# dim_h00 = N2*internal_degree
local_dos = np.zeros((N2, N1))
green_11_1 = green_function(fermi_energy, h00, broadening)
green_11_1 = guan.green_function(fermi_energy, h00, broadening)
for i1 in range(N1):
green_nn_n_minus = green_11_1
green_in_n_minus = green_11_1
green_ni_n_minus = green_11_1
green_ii_n_minus = green_11_1
for i2_0 in range(i1):
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
if i1!=0:
green_in_n_minus = green_nn_n
green_ni_n_minus = green_nn_n
green_ii_n_minus = green_nn_n
for size_0 in range(N1-1-i1):
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
green_ii_n = green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus)
green_ii_n = guan.green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus)
green_ii_n_minus = green_ii_n
green_in_n = green_function_in_n(green_in_n_minus, h01, green_nn_n)
green_in_n = guan.green_function_in_n(green_in_n_minus, h01, green_nn_n)
green_in_n_minus = green_in_n
green_ni_n = green_function_ni_n(green_nn_n, h01, green_ni_n_minus)
green_ni_n = guan.green_function_ni_n(green_nn_n, h01, green_ni_n_minus)
green_ni_n_minus = green_ni_n
for i2 in range(N2):
for i in range(internal_degree):
@ -74,27 +74,27 @@ def local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy
def local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy, h00, h01, N3, N2, N1, internal_degree=1, broadening=0.01):
# dim_h00 = N2*N3*internal_degree
local_dos = np.zeros((N3, N2, N1))
green_11_1 = green_function(fermi_energy, h00, broadening)
green_11_1 = guan.green_function(fermi_energy, h00, broadening)
for i1 in range(N1):
green_nn_n_minus = green_11_1
green_in_n_minus = green_11_1
green_ni_n_minus = green_11_1
green_ii_n_minus = green_11_1
for i1_0 in range(i1):
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
if i1!=0:
green_in_n_minus = green_nn_n
green_ni_n_minus = green_nn_n
green_ii_n_minus = green_nn_n
for size_0 in range(N1-1-i1):
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
green_ii_n = green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus)
green_ii_n = guan.green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus)
green_ii_n_minus = green_ii_n
green_in_n = green_function_in_n(green_in_n_minus, h01, green_nn_n)
green_in_n = guan.green_function_in_n(green_in_n_minus, h01, green_nn_n)
green_in_n_minus = green_in_n
green_ni_n = green_function_ni_n(green_nn_n, h01, green_ni_n_minus)
green_ni_n = guan.green_function_ni_n(green_nn_n, h01, green_ni_n_minus)
green_ni_n_minus = green_ni_n
for i2 in range(N2):
for i3 in range(N3):
@ -105,7 +105,7 @@ def local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy,
def local_density_of_states_for_square_lattice_with_self_energy_using_dyson_equation(fermi_energy, h00, h01, N2, N1, right_self_energy, left_self_energy, internal_degree=1, broadening=0.01):
# dim_h00 = N2*internal_degree
local_dos = np.zeros((N2, N1))
green_11_1 = green_function(fermi_energy, h00+left_self_energy, broadening)
green_11_1 = guan.green_function(fermi_energy, h00+left_self_energy, broadening)
for i1 in range(N1):
green_nn_n_minus = green_11_1
green_in_n_minus = green_11_1
@ -113,9 +113,9 @@ def local_density_of_states_for_square_lattice_with_self_energy_using_dyson_equa
green_ii_n_minus = green_11_1
for i2_0 in range(i1):
if i2_0 == N1-1-1:
green_nn_n = green_function_nn_n(fermi_energy, h00+right_self_energy, h01, green_nn_n_minus, broadening)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00+right_self_energy, h01, green_nn_n_minus, broadening)
else:
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
if i1!=0:
green_in_n_minus = green_nn_n
@ -123,15 +123,15 @@ def local_density_of_states_for_square_lattice_with_self_energy_using_dyson_equa
green_ii_n_minus = green_nn_n
for size_0 in range(N1-1-i1):
if size_0 == N1-1-i1-1:
green_nn_n = green_function_nn_n(fermi_energy, h00+right_self_energy, h01, green_nn_n_minus, broadening)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00+right_self_energy, h01, green_nn_n_minus, broadening)
else:
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening)
green_nn_n_minus = green_nn_n
green_ii_n = green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus)
green_ii_n = guan.green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus)
green_ii_n_minus = green_ii_n
green_in_n = green_function_in_n(green_in_n_minus, h01, green_nn_n)
green_in_n = guan.green_function_in_n(green_in_n_minus, h01, green_nn_n)
green_in_n_minus = green_in_n
green_ni_n = green_function_ni_n(green_nn_n, h01, green_ni_n_minus)
green_ni_n = guan.green_function_ni_n(green_nn_n, h01, green_ni_n_minus)
green_ni_n_minus = green_ni_n
for i2 in range(N2):
for i in range(internal_degree):

18
PyPI/src/guan/calculate_scattering_matrix.py
View File

@ -4,7 +4,7 @@
import numpy as np
import copy
from .calculate_Green_functions import *
import guan
def if_active_channel(k_of_channel):
if np.abs(np.imag(k_of_channel))<1e-6:
@ -18,7 +18,7 @@ def get_k_and_velocity_of_channel(fermi_energy, h00, h01):
dim = 1
else:
dim = np.array(h00).shape[0]
transfer = transfer_matrix(fermi_energy, h00, h01)
transfer = guan.transfer_matrix(fermi_energy, h00, h01)
eigenvalue, eigenvector = np.linalg.eig(transfer)
k_of_channel = np.log(eigenvalue)/1j
ind = np.argsort(np.real(k_of_channel))
@ -104,17 +104,17 @@ def calculate_scattering_matrix(fermi_energy, h00, h01, length=100):
left_self_energy = np.dot(h01.transpose().conj(), np.linalg.inv(f_left))
for i0 in range(length):
if i0 == 0:
green_nn_n = green_function(fermi_energy, h00, broadening=0, self_energy=left_self_energy)
green_nn_n = guan.green_function(fermi_energy, h00, broadening=0, self_energy=left_self_energy)
green_00_n = copy.deepcopy(green_nn_n)
green_0n_n = copy.deepcopy(green_nn_n)
green_n0_n = copy.deepcopy(green_nn_n)
elif i0 != length-1:
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n, broadening=0)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n, broadening=0)
else:
green_nn_n = green_function_nn_n(fermi_energy, h00, h01, green_nn_n, broadening=0, self_energy=right_self_energy)
green_00_n = green_function_ii_n(green_00_n, green_0n_n, h01, green_nn_n, green_n0_n)
green_0n_n = green_function_in_n(green_0n_n, h01, green_nn_n)
green_n0_n = green_function_ni_n(green_nn_n, h01, green_n0_n)
green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n, broadening=0, self_energy=right_self_energy)
green_00_n = guan.green_function_ii_n(green_00_n, green_0n_n, h01, green_nn_n, green_n0_n)
green_0n_n = guan.green_function_in_n(green_0n_n, h01, green_nn_n)
green_n0_n = guan.green_function_ni_n(green_nn_n, h01, green_n0_n)
temp = np.dot(h01.transpose().conj(), np.linalg.inv(f_right)-np.linalg.inv(f_left))
transmission_matrix = np.dot(np.dot(np.linalg.inv(u_right), np.dot(green_n0_n, temp)), u_right)
reflection_matrix = np.dot(np.dot(np.linalg.inv(u_left), np.dot(green_00_n, temp)-np.identity(dim)), u_right)
@ -179,4 +179,4 @@ def print_or_write_scattering_matrix(fermi_energy, h00, h01, length=100, on_prin
f.write('\n')
f.write('\n')
f.write('Total transmission of channels:\n'+str(np.sum(np.square(np.abs(transmission_matrix[0:ind_right_active, 0:ind_right_active])), axis=0))+'\n')
f.write('Total conductance = '+str(np.sum(np.square(np.abs(transmission_matrix[0:ind_right_active, 0:ind_right_active]))))+'\n')
f.write('Total conductance = '+str(np.sum(np.square(np.abs(transmission_matrix[0:ind_right_active, 0:ind_right_active]))))+'\n')

12
PyPI/src/guan/calculate_topological_invariant.py
View File

@ -5,7 +5,7 @@
import numpy as np
import cmath
from math import *
from .calculate_band_structures_and_wave_functions import *
import guan
def calculate_chern_number_for_square_lattice(hamiltonian_function, precision=100):
if np.array(hamiltonian_function(0, 0)).shape==():
@ -17,13 +17,13 @@ def calculate_chern_number_for_square_lattice(hamiltonian_function, precision=10
for kx in np.arange(-pi, pi, delta):
for ky in np.arange(-pi, pi, delta):
H = hamiltonian_function(kx, ky)
vector = calculate_eigenvector(H)
vector = guan.calculate_eigenvector(H)
H_delta_kx = hamiltonian_function(kx+delta, ky)
vector_delta_kx = calculate_eigenvector(H_delta_kx)
vector_delta_kx = guan.calculate_eigenvector(H_delta_kx)
H_delta_ky = hamiltonian_function(kx, ky+delta)
vector_delta_ky = calculate_eigenvector(H_delta_ky)
vector_delta_ky = guan.calculate_eigenvector(H_delta_ky)
H_delta_kx_ky = hamiltonian_function(kx+delta, ky+delta)
vector_delta_kx_ky = calculate_eigenvector(H_delta_kx_ky)
vector_delta_kx_ky = guan.calculate_eigenvector(H_delta_kx_ky)
for i in range(dim):
vector_i = vector[:, i]
vector_delta_kx_i = vector_delta_kx[:, i]
@ -45,7 +45,7 @@ def calculate_wilson_loop(hamiltonian_function, k_min=-pi, k_max=pi, precision=1
for i in range(dim):
eigenvector_array = []
for k in k_array:
eigenvector = calculate_eigenvector(hamiltonian_function(k))
eigenvector = guan.calculate_eigenvector(hamiltonian_function(k))
if k != k_max:
eigenvector_array.append(eigenvector[:, i])
else: