From 7bfa69a61fa0f2200f20c3fdfffaf3d969aca07b Mon Sep 17 00:00:00 2001 From: guanjihuan <34735497+guanjihuan@users.noreply.github.com> Date: Thu, 24 Jun 2021 09:20:23 +0800 Subject: [PATCH] update to guan project --- API_reference.md | 130 +-- PyPI/README.md | 2 +- PyPI/{src/gjh => build/lib/guan}/__init__.py | 2 +- PyPI/dist/guan-0.0.1-py3-none-any.whl | Bin 0 -> 9044 bytes PyPI/dist/guan-0.0.1.tar.gz | Bin 0 -> 9564 bytes PyPI/setup.cfg | 4 +- PyPI/src/guan.egg-info/PKG-INFO | 19 + PyPI/src/guan.egg-info/SOURCES.txt | 9 + PyPI/src/guan.egg-info/dependency_links.txt | 1 + PyPI/src/guan.egg-info/top_level.txt | 1 + PyPI/src/guan/__init__.py | 985 ++++++++++++++++++ README.md | 7 +- Tutorial/0_test.py | 4 +- Tutorial/10_Wilson_loop.py | 4 +- Tutorial/11_read_and_write.py | 10 +- Tutorial/12_download.py | 8 +- Tutorial/1_Pauli_matrix.py | 10 +- Tutorial/2_Hamiltonian_of_finite_size.py | 8 +- ...3_Fourier_transform_and_band_structures.py | 20 +- Tutorial/4_bands_of_zigzag_graphene.py | 12 +- Tutorial/5_total_density_of_states.py | 8 +- Tutorial/6_local_density_of_states.py | 20 +- Tutorial/7_conductance.py | 8 +- Tutorial/8_scattering_matrix.py | 6 +- Tutorial/9_Chern_number.py | 4 +- source_code.py | 2 +- 26 files changed, 1150 insertions(+), 134 deletions(-) rename PyPI/{src/gjh => build/lib/guan}/__init__.py (99%) create mode 100644 PyPI/dist/guan-0.0.1-py3-none-any.whl create mode 100644 PyPI/dist/guan-0.0.1.tar.gz create mode 100644 PyPI/src/guan.egg-info/PKG-INFO create mode 100644 PyPI/src/guan.egg-info/SOURCES.txt create mode 100644 PyPI/src/guan.egg-info/dependency_links.txt create mode 100644 PyPI/src/guan.egg-info/top_level.txt create mode 100644 PyPI/src/guan/__init__.py diff --git a/API_reference.md b/API_reference.md index afba9fc..117d3a1 100644 --- a/API_reference.md +++ b/API_reference.md @@ -1,113 +1,113 @@ -import gjh +import guan # test -gjh.test() +guan.test() # basic functions -sigma_0 = gjh.sigma_0() -sigma_x = gjh.sigma_x() -sigma_y = gjh.sigma_y() -sigma_z = gjh.sigma_z() +sigma_0 = guan.sigma_0() +sigma_x = guan.sigma_x() +sigma_y = guan.sigma_y() +sigma_z = guan.sigma_z() -sigma_00 = gjh.sigma_00() -sigma_0x = gjh.sigma_0x() -sigma_0y = gjh.sigma_0y() -sigma_0z = gjh.sigma_0z() +sigma_00 = guan.sigma_00() +sigma_0x = guan.sigma_0x() +sigma_0y = guan.sigma_0y() +sigma_0z = guan.sigma_0z() -sigma_x0 = gjh.sigma_x0() -sigma_xx = gjh.sigma_xx() -sigma_xy = gjh.sigma_xy() -sigma_xz = gjh.sigma_xz() +sigma_x0 = guan.sigma_x0() +sigma_xx = guan.sigma_xx() +sigma_xy = guan.sigma_xy() +sigma_xz = guan.sigma_xz() -sigma_y0 = gjh.sigma_y0() -sigma_yx = gjh.sigma_yx() -sigma_yy = gjh.sigma_yy() -sigma_yz = gjh.sigma_yz() +sigma_y0 = guan.sigma_y0() +sigma_yx = guan.sigma_yx() +sigma_yy = guan.sigma_yy() +sigma_yz = guan.sigma_yz() -sigma_z0 = gjh.sigma_z0() -sigma_zx = gjh.sigma_zx() -sigma_zy = gjh.sigma_zy() -sigma_zz = gjh.sigma_zz() +sigma_z0 = guan.sigma_z0() +sigma_zx = guan.sigma_zx() +sigma_zy = guan.sigma_zy() +sigma_zz = guan.sigma_zz() # Hermitian Hamiltonian of tight binding model -hamiltonian = gjh.finite_size_along_one_direction(N, on_site=0, hopping=1, period=0) -hamiltonian = gjh.finite_size_along_two_directions_for_square_lattice(N1, N2, on_site=0, hopping_1=1, hopping_2=1, period_1=0, period_2=0) -hamiltonian = gjh.finite_size_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) -hamiltonian = gjh.one_dimensional_fourier_transform(k, unit_cell, hopping) -hamiltonian = gjh.two_dimensional_fourier_transform_for_square_lattice(k1, k2, unit_cell, hopping_1, hopping_2) -hamiltonian = gjh.three_dimensional_fourier_transform_for_cubic_lattice(k1, k2, k3, unit_cell, hopping_1, hopping_2, hopping_3) +hamiltonian = guan.finite_size_along_one_direction(N, on_site=0, hopping=1, period=0) +hamiltonian = guan.finite_size_along_two_directions_for_square_lattice(N1, N2, on_site=0, hopping_1=1, hopping_2=1, period_1=0, period_2=0) +hamiltonian = guan.finite_size_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) +hamiltonian = guan.one_dimensional_fourier_transform(k, unit_cell, hopping) +hamiltonian = guan.two_dimensional_fourier_transform_for_square_lattice(k1, k2, unit_cell, hopping_1, hopping_2) +hamiltonian = guan.three_dimensional_fourier_transform_for_cubic_lattice(k1, k2, k3, unit_cell, hopping_1, hopping_2, hopping_3) # Hamiltonian of graphene lattice -hopping = gjh.hopping_along_zigzag_direction_for_graphene(N) -hamiltonian = gjh.finite_size_along_two_directions_for_graphene(N1, N2, period_1=0, period_2=0) +hopping = guan.hopping_along_zigzag_direction_for_graphene(N) +hamiltonian = guan.finite_size_along_two_directions_for_graphene(N1, N2, period_1=0, period_2=0) # calculate band structures -eigenvalue = gjh.calculate_eigenvalue(hamiltonian) -eigenvalue_array = gjh.calculate_eigenvalue_with_one_parameter(x, hamiltonian_function): -eigenvalue_array = gjh.calculate_eigenvalue_with_two_parameters(x, y, hamiltonian_function) +eigenvalue = guan.calculate_eigenvalue(hamiltonian) +eigenvalue_array = guan.calculate_eigenvalue_with_one_parameter(x, hamiltonian_function): +eigenvalue_array = guan.calculate_eigenvalue_with_two_parameters(x, y, hamiltonian_function) # calculate wave functions -eigenvector = gjh.calculate_eigenvector(hamiltonian) +eigenvector = guan.calculate_eigenvector(hamiltonian) # calculate Green functions -green = gjh.green_function(fermi_energy, hamiltonian, broadening, self_energy=0) -green_nn_n = gjh.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening, self_energy=0) -green_in_n = gjh.green_function_in_n(green_in_n_minus, h01, green_nn_n) -green_ni_n = gjh.green_function_ni_n(green_nn_n, h01, green_ni_n_minus) -green_ii_n = gjh.green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus) +green = guan.green_function(fermi_energy, hamiltonian, broadening, self_energy=0) +green_nn_n = guan.green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening, self_energy=0) +green_in_n = guan.green_function_in_n(green_in_n_minus, h01, green_nn_n) +green_ni_n = guan.green_function_ni_n(green_nn_n, h01, 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) # calculate density of states -total_dos = gjh.total_density_of_states(fermi_energy, hamiltonian, broadening=0.01) -total_dos_array = gjh.total_density_of_states_with_fermi_energy_array(fermi_energy_array, hamiltonian, broadening=0.01) -local_dos = gjh.local_density_of_states_for_square_lattice(fermi_energy, hamiltonian, N1, N2, internal_degree=1, broadening=0.01) -local_dos = gjh.local_density_of_states_for_cubic_lattice(fermi_energy, hamiltonian, N1, N2, N3, internal_degree=1, broadening=0.01) -local_dos = gjh.local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy, h00, h01, N2, N1, internal_degree=1, broadening=0.01) -local_dos = gjh.local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy, h00, h01, N3, N2, N1, internal_degree=1, broadening=0.01) +total_dos = guan.total_density_of_states(fermi_energy, hamiltonian, broadening=0.01) +total_dos_array = guan.total_density_of_states_with_fermi_energy_array(fermi_energy_array, hamiltonian, broadening=0.01) +local_dos = guan.local_density_of_states_for_square_lattice(fermi_energy, hamiltonian, N1, N2, internal_degree=1, broadening=0.01) +local_dos = guan.local_density_of_states_for_cubic_lattice(fermi_energy, hamiltonian, N1, N2, N3, internal_degree=1, broadening=0.01) +local_dos = guan.local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy, h00, h01, N2, N1, internal_degree=1, broadening=0.01) +local_dos = guan.local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy, h00, h01, N3, N2, N1, internal_degree=1, broadening=0.01) # calculate conductance -transfer = gjh.transfer_matrix(fermi_energy, h00, h01) -right_lead_surface, left_lead_surface = gjh.surface_green_function_of_lead(fermi_energy, h00, h01 -right_self_energy, left_self_energy = gjh.self_energy_of_lead(fermi_energy, h00, h01) -conductance = gjh.calculate_conductance(fermi_energy, h00, h01, length=100) -conductance_array = gjh.calculate_conductance_with_fermi_energy_array(fermi_energy_array, h00, h01, length=100) +transfer = guan.transfer_matrix(fermi_energy, h00, h01) +right_lead_surface, left_lead_surface = guan.surface_green_function_of_lead(fermi_energy, h00, h01 +right_self_energy, left_self_energy = guan.self_energy_of_lead(fermi_energy, h00, h01) +conductance = guan.calculate_conductance(fermi_energy, h00, h01, length=100) +conductance_array = guan.calculate_conductance_with_fermi_energy_array(fermi_energy_array, h00, h01, length=100) # scattering matrix -if_active = gjh.if_active_channel(k_of_channel) -k_of_channel, velocity_of_channel, eigenvalue, eigenvector = gjh.get_k_and_velocity_of_channel(fermi_energy, h00, h01) -k_right, k_left, velocity_right, velocity_left, f_right, f_left, u_right, u_left, ind_right_active = gjh.get_classified_k_velocity_u_and_f(fermi_energy, h00, h01) -transmission_matrix, reflection_matrix, k_right, k_left, velocity_right, velocity_left, ind_right_active = gjh.calculate_scattering_matrix(fermi_energy, h00, h01, length=100) -gjh.print_or_write_scattering_matrix(fermi_energy, h00, h01, length=100, on_print=1, on_write=0) +if_active = guan.if_active_channel(k_of_channel) +k_of_channel, velocity_of_channel, eigenvalue, eigenvector = guan.get_k_and_velocity_of_channel(fermi_energy, h00, h01) +k_right, k_left, velocity_right, velocity_left, f_right, f_left, u_right, u_left, ind_right_active = guan.get_classified_k_velocity_u_and_f(fermi_energy, h00, h01) +transmission_matrix, reflection_matrix, k_right, k_left, velocity_right, velocity_left, ind_right_active = guan.calculate_scattering_matrix(fermi_energy, h00, h01, length=100) +guan.print_or_write_scattering_matrix(fermi_energy, h00, h01, length=100, on_print=1, on_write=0) # calculate Chern number -chern_number = gjh.calculate_chern_number_for_square_lattice(hamiltonian_function, precision=100) +chern_number = guan.calculate_chern_number_for_square_lattice(hamiltonian_function, precision=100) # calculate Wilson loop -wilson_loop_array = gjh.calculate_wilson_loop(hamiltonian_function, k_min=-pi, k_max=pi, precision=100) +wilson_loop_array = guan.calculate_wilson_loop(hamiltonian_function, k_min=-pi, k_max=pi, precision=100) # read and write -x, y = gjh.read_one_dimensional_data(filename='a') -x, y, matrix = gjh.read_two_dimensional_data(filename='a') -gjh.write_one_dimensional_data(x, y, filename='a') -gjh.write_two_dimensional_data(x, y, matrix, filename='a') +x, y = guan.read_one_dimensional_data(filename='a') +x, y, matrix = guan.read_two_dimensional_data(filename='a') +guan.write_one_dimensional_data(x, y, filename='a') +guan.write_two_dimensional_data(x, y, matrix, filename='a') # plot figures -gjh.plot(x, y, xlabel='x', ylabel='y', title='', filename='a', show=1, save=0, type='', y_min=None, y_max=None) -gjh.plot_3d_surface(x, y, matrix, xlabel='x', ylabel='y', zlabel='z', title='', filename='a', show=1, save=0, z_min=None, z_max=None) -gjh.plot_contour(x, y, matrix, xlabel='x', ylabel='y', title='', filename='a', show=1, save=0) +guan.plot(x, y, xlabel='x', ylabel='y', title='', filename='a', show=1, save=0, type='', y_min=None, y_max=None) +guan.plot_3d_surface(x, y, matrix, xlabel='x', ylabel='y', zlabel='z', title='', filename='a', show=1, save=0, z_min=None, z_max=None) +guan.plot_contour(x, y, matrix, xlabel='x', ylabel='y', title='', filename='a', show=1, save=0) # download -gjh.download_with_scihub(address=None, num=1) \ No newline at end of file +guan.download_with_scihub(address=None, num=1) \ No newline at end of file diff --git a/PyPI/README.md b/PyPI/README.md index 31813c3..9f1f029 100644 --- a/PyPI/README.md +++ b/PyPI/README.md @@ -1 +1 @@ -GJH is an open-source python package developed and maintained by https://www.guanjihuan.com. The primary location of this package is on website https://py.guanjihuan.com. \ No newline at end of file +GUAN is an open-source python package developed and maintained by https://www.guanjihuan.com. The primary location of this package is on website https://py.guanjihuan.com. \ No newline at end of file diff --git a/PyPI/src/gjh/__init__.py b/PyPI/build/lib/guan/__init__.py similarity index 99% rename from PyPI/src/gjh/__init__.py rename to PyPI/build/lib/guan/__init__.py index 357d97d..1db4c8b 100644 --- a/PyPI/src/gjh/__init__.py +++ b/PyPI/build/lib/guan/__init__.py @@ -9,7 +9,7 @@ import copy # test def test(): - print('\nSuccess in the installation of GJH package!\n') + print('\nSuccess in the installation of GUAN package!\n') diff --git a/PyPI/dist/guan-0.0.1-py3-none-any.whl b/PyPI/dist/guan-0.0.1-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..48e86a6c5e8628ea6cf900a9faad7ba3d7fe0015 GIT binary patch literal 9044 zcmZ{q1yCK$wzfC!1a}GUF2UV5y0KuvT{o`5A-D#DYmngX?!Iw%cZVPeH|N}Q|MQ>k z-fyORrlxDwQ>$jZy?Uxvs{&zQaR2}SA|MKJ38b;pn(%`N05B{C05JZHTDloKuo)U! zJ6O9K8nQZhoeQrz@5;DeR^Esjovl#P2a*J2){ycmj@EcAFtlmtbyB~p4+@ftw?Trn z0+3+3zEVA_8T;rD|I;9X^A%W`d6)>78sJAT-W z!?4%0%fGqUjnndK1aHk4pW~xRHCBlH{_=LIUK|~TRhe=fso&OD7ANX_m17?}Gei2C z_`6w;c_-gV^(5JY<99KA0d<5z@^|G%=ifKC+KZFCx%r z-U$tLwWvL7uK$wh5x#5x;3n+qN@MDU19K|(@fYjVjOR7R;m7P{=O%h_v#i$)*sFk= z<_6z(84cvnPI<1i_*)$DL zW1iB>gAPlhyZLpJMIn{mKrq9OkPe;PEfl0NXdH+RCZN%2MF&$OrP9aAGrLs@(*du~ zIkUG*TvF|u2!>FH^6WDU?D%i_8&F5nc&;OP&=>%xOwiS|@BvyRBhAfGjn{TsQP97c zr{N#btRypWYTQ*$gdZK3nuFMfm%{m`kQX~TyE}x!UxUqCnVE$4C|B*0Jg4Y&&0B(f z<>bARD@`AD3uU_nWkrly?y8pHdhD#)txN0(jd4hL!lGWsjD{T$MVCG*c3Xsy`sqbj zA`a2eHZ565pP>&$F?V!fO`KuAh#35^9oO%jJa@9K=Xd+DV=PD{_`rbMTB4vvXWQI_s~vYCNs9mY z-7p68Uc7InILK##rFTwoxgfDjz#@Pcj(i+M(tYTOVETU)BsoE?IYzETFIt@Eis zBjWY%s)!DAx~FSg`i~=?PwoU(b0v4|R3O$ytwGARZ*@{btY_!OuT~dlJI0Ic(Up6S zJN4Zz)$~0{)dsOULe$OG8@w06hi6x7Ec*TOpsDKS-zS1Qu0;;@2J@+Ov~G_;csKEf z#G&iYr|^&X?<6-Ij6MQLF_%6gLCjatk-lj;lV82w7@H(2(of2(V9xT>rmf$g!bs=$ zT-7p}lu6)r(;*i{IE_Ki_REOcW#y_!-poL0L;C8q<$G&;US?7!^1C@ari);E616MK0zg3EmLY^@yGWO|AB-(B3BIrU{8})Bac2-=j z{FPTQ3V$9{u^O?VLALyVWmxdb!lbk3mIC_sdmg)DSCVYLnU&c#5-a(wc2}W(21i5m z^uvIpV|mg$ZsAWjlbzhoi3SI#g6{TEAyL(sxnK8L^UZ4dBnKw#lUcL!$30L`H%ay_4&1yBSn@x=j0&2>tkTEvf(Z{VHn6{w-2@xzWANpK_;9RU zgpb-VJZz`!dW<#=o;>%7=!6$Gnaza2Pa%Z`<-YemlfPSPa-<0`O)FV?k!*<*cqMrn zmt47@d^7sZ)~21tA`Jr0X}$lM<3W+Ae%7p6qWvK&Ot`C+(0xRk%QJFi@QmWiyoF)F zy0(4M)Z_R|4EcLT%>0?Pf<>D4q^$fKk|f73WFu$=lwoQNVc;q;_l$%F2IJ`;2Xi(U zj}O^{^qt9(fC(vOu()Ec^`|8(G4S9!Lxkd1w_@5j4@bf8?#~^%)Iu_jrcbbS44fF9 zO47Xyl+OK?B>F#jx^7C)D)qRYV@!>{y7Ia_;R~$;-FO!vYXrT>=$v8AcH@iA&9|AW zLQyH;NFdh~!;aZNZhGQFiH-Gg+ww|anY(~Q2eox_ryC6`D{(7Z(91TQpgsEU4_NGR zuqk^s5z*6Ts5(Z*k#AKB6X6rC}?4tG8ek z8s~Uo0IJ$octw_ zI#ri?XuxI=m5P>$o#+b4j39)DP_-^)%h#1a*Gsi9ET?mz+_==CHt>eRk!2iC87;fdtg`rW z#il4a@K#s(GVBTI;rkMS+?tuCQrq-`D^eY)O2s^c+O9Y|c5h^XLAK6GyLPigCEl*+ zONK!YJ%Jx2F_~~~gn!qr2lS)f>_geSSk8L%^o+7@sr8 zJvn}P)#>){M_vy%2g9!%!jkCLWzKfMU zp517Ml;I5wfdiBJr*B|*QLPQ!Xn(b%?o5jsz&@tK>7@Sx`&5!JSPC0BkDkWNA2qUP zCNu6%JbbLv(oVg$qQ2bmA22tICT#RLzNx7_L@@}tg`LTFf_kRz;K4QnV57f(!foT{ zxpOE_fa(CTmjL+NC&NA(4o9o6(w@0#_~}9V3f~FCsRROzIy3RBCPhoYY_;D`T-%8l zhYnpSJOv_x@ISnKQ*kpWO8_s32lyg_mict=Dm(?T>^-M(32PhA1Y=I2y%?k`2; zX;fR=U(6E2>H*KOPDiw?ec|j1soSdrQ#8xabac&av7Sxp-5zS)QTdkD%eu^)hBs-U zrE_$R^tM%KEXS0A*&=KKBG?_Xf*I2B*N2qU{CcZAi}Be^39~{yv_Q#B4*hEeqq(Cb z=ZQlSmMQn`j9x~XVcE6F!=)p*Ot=EUK417DOWr-j>uOvU+;;I;fP0_Lc9&tIaWw@* z4e2*=*y>iy0%K$DSit8=YaCa(bk@CcI@`XFYDxF#gbu@nvh40PeChgEVpf3owT!lU z2Qf*n1VvZwDelTeJoY`Y7PTJsK|URh(M0^Xr6 z5j`mno!;Q$vM~Ba^k|NsLl!us%DGx?Nf~N6EUQoQI_rX-p?q$V%t7_aN(mCgv+RAG zd7PTYsHx)t5FI*@S^P$LmR^3{G_4QH0A<@q7~})Zw}~mu%OH#j?Bd5%w6!lqnsx%b z)9EqIbLDvjM!aK;U+`ev5~hQsqIjN@1f-@FK1e@EL?3?@rG<6pMw>p9QgWpd(xhAe z7&jA(#^@uARGZ>v?j%>YDt1=;NEDFG#BgAx)Ih=iNzneA9k;|Yrw507({#``Yx^we z{N{FBzZwJJbXcHQ{9kp~>{2qwCCc zI^~FT8ATMkiC*Q$#9(WRbH9sNk*@kB*X_b%)k{{4gd>HeIiBH)1Grq;b?0*wRqPwZd7_-Iji?knU}x0-rH8{1 z>mkiOg_@MyC9^EANaw52;9&_uT&sRU?s6{l2F74ed5X|D($KCdS`AqqcDC@o*gYeJ z(b$o-mZU&lX#(RjSHGMv^!sS*wjDXBAT0n%UOYT1noY6reaSv| zG?YT(i1MO-+o!Tq*Z%!r7pRVpWNVss$7pn#443cXQ)AxZhzOb2E-jV=q>IpkwtQx)_H#;BFf!eQ!s~}kDI|gZF?^U7Se`F)v-gLj2EGmW z`5{;AV|_y;Ss!B(@pCbSuEd}^X-jlBO0J`cJuk%^RJ$_uTRt@Kr=}8NojU4#rl}Bx za3P>KGN(9MOo|oTmux@P@fP!%2FVv)=)gQDD8e0jTtx=N;tuX0d)%G~yJV9@JJ`r< zbfOn*(^4#kw8lKY8J!5nBGF{7UQ?o*Pb6k4#%`a{^}u{=E>+9nusel$Q}xk#tX4rj zWD)AifTP|-Ft$zf8{C_hQSU34nRY1>%*rJ9AijZ;Rg<~m9YKfA(J`AeKLt!tLI1#f z>YsN3Gh{Hv+))$%NFa*^@h|f#uZwfDKGM)yUGWk0S|)0r?9!VC^^o4t!7;Dqj~lRX zZMhEwQ}?@j1yO{X3C$$EBh5FBuOhT~n(~O9ASVN&9fj7>yo!^Aa?aKXX43l#H=9x3 za-cwM!!-SFQr`rr6Y_&ONj{-VMe7T&Fce(OQsi11IZ%HL2^0=JuuzAwGLQd7@*_(? z=T)sD0z8~BB3gyPcbgiR&ps>Hk&dXmAZ2eZt`s2<#y+{%3@)tsT~Ea4Upw|JhF(fV z*C0$BaS}gv8)0|1Azf5laEMFLHE+0Z)qI!vRmrlP^I-0<;78t|EBC``8$qXY$LiY5 z&}1^qxYLJ152dOU&JOvxz6Qy5F|o4db(3o?z2ftR#-VXXmW_pzImgqOB+lLrI()sm z+M@IgY@H^7OPJ0(F|zgd{TPl!_Lz7GzkxC!e0*|7J*%I$6|*-73kcsb%2u%_Mg(_( zid~xBU1%fUw);B$l7Y|?gU*V<5%jt;72+#lRjp}-)C4-X9Cy)`qdzFhk^;i~Q8*v8 zlF!^sl4T3ffRnvOU(RY5!#~HY-g9ay#kEdU+L|BfF2~xObzF*F)wM&3J+SdjNva&$ z{7fXBYPv9z6BgB$Mb#x0w3_EU60sxKI{I-7k(KbbEI{pbpGMgcOv{X&gm>Nuc$c7( z+RgBm^N26D8A{v^TZ1+tZGJ*0bIBhR>fNwE<7J9^w=Y8DptJVNz*E&^aO`Qt4j zkusR>t*#~ z;`#mo^!&~@!t7V~!~O>&+K_&t{a2Zh1jvi{s=jKgU`5^n$=J0SP~Ny%$SXkDg_29M zd)|svcGW(U)!@Dd#SOp8oNE-G+$UZ^fU+z*y5wt_Kh3Su?vMcJr(EpQ2mrf$G}!`m zZfMEMQHUzwOo}MvNZvECof>FgXm-E~Taovy(_pS4bAe0)CbHjIeor*#sIG4uIn0RJ z<-@;KCe6<_Ip+D!GEa-0#c&~qosvI!h&!ySFL@vFCf&qd9I`cha5zEiHuJ(@BR zk1C1UK^b+FLaICbOS`oe{nt)S#E{W@t|SOOd$Pz%tS^k+6=hJzXGWQPWFj^tpOXfS z5IPzqgox&!hh`XUEC&jS8vECiquGouP(O3!>eA%O^?sRcY!15)+#r&tWKv%DBOEP`Rj|%EM^8{_5_+M$ zi0AytR3y+w#^!SJweXnh*_ErmG**e@&d0;v>efP0P&8FBc{JfNF{*iGeFK|Js^~%` z4uhbM_}nNOdP3_989b^UWs&3fw=N>8N~lY})=$NiRuoH_O6!rxD?h2@BO~#!i}pE8 zIvHE#$J+WX;CxK3Zo7{JXrZ_IxIS2r zlBOP6&@MI^@-LO!G}sv%^0VRkj5Vy4T7R}is}sS~fG3KBXs?+1LfsmZv}_c2uU>PC zY?xZ2SZ#t(n<8A?JVv&yp@P{FvkhTPdk^(d`oLpxX?cVvd#lII9?z<7;s#3*0bT`i z?x}}4Q!Q+ll=xkuKI|%JKPqEz-~#VGa`yZ{BfIX#W#ml9#3<+L`0I6lF19q0yNNj1DP!>OHf^@Wbh+jjp@|`MoWe>yc zu;&?#_)3Hfo~JlIk|3dJhU#TS!Vi(=$Ky+(R67D)CHzMbR!Vl}h_Avodi)K*;&JXh z&-TYbms?$+)O3b=Fq1$WT|mr{LcM41=65FjUasAgTglaG0euyq*j+rxIUTb+z{*&lWbI*kxkdO z!w5@TN94mwOSflsL^w%n`}?w3QyKsG3@bs;C$;q?RVKhppKa)+O~x9cT>Kh`A4*7c z5`M9bWQDHkifxv0Br?_)@*K|O74_o1Gz}->r#z|K9K89Uy*qO9C@zfKOY0IpJCMg> zK%zSf*U`s}R6D48zLdy~&TI{d z<6o?i`$Mg^>~8VAF4DdIdUX@V{gix#+AiVF^)Jzc*%&>*j3uL#r`VYY=~*l0QGVV z7-q?U+wfQ@*O|6)vRUe=6d}f|&AXV;0qFH}hjpu#ewUpf+_qx}uCm1oxd?B)_MOh( zj^KKxX`9s7Z|995oMF@b!>YDsdX!QQCYwQ{WF4`_z@;nQSo8CV3kuuj?R$f1q>3{h zWWleVb`6!L9ozg}u5DCIyKm_DZ;xGX1*|M`FxPMr3-pD!v6yj;_ZaZ->Icq5j$98IQQe&eIDWInYl%|aO6uFy)qe?eB@uIrud=dq z_irD=hAQgz9x#*lcE9DYBkBgO6kw&OSOlAO$rm1?r<7eCl6MXXL-i0;Z1tVoiYKta z?+6|lQNaqTB(q)U`@+49EFrA*_^WjyNXD6haO-0t^Q}3`*LZQ*DbQJUl4t|EKHr7` zrUo?ZlK3!k7%iH{(AL zn|nzIa$-f}#Q_(c!roHvh!1Ay4dRAO)ff`}jB!}07K3+3!S!jsk}vzWGjM^qC@Bn% zdgvRbFQ3-VLACxlahR3g$>wv9PnUvvRPSS-ZHhSUXra zvMI_-N-L{N8-RduE9@AZvZMY4;FYiW=ervB7C}1YVSLWLpjcXte)}(KXE@iFg4j#z z4m5>UgSQj;#><4M2Q$XX19KwtZ!}Dqv z42dE`RsN9M;n6TJhZs{flyn@7PVHHpb$x{a*(-0SvWQDkFm=V3ZA9?)^$U)YJ~R#J z`N_VNE{9d^w;qGm;^}vBHnKs3D01FEggFySCK*2ut6W)w@SM)D?6u~x(1gUD()?)J zT~usg?=4}RsNw){6yOfS!K+XKZ~jt}-21HvM0@1%I?>nlc>Xq!U(m;QM{h%`y6a@0 zbik&LZ~}Slam#8`ZC$yK`L6m~kTh1g?C~Nl?Pl#_qbIbFvHy$t=7>^uKV$ZWi6nrmnHZf3uLq#rPOmN^V%3UgvNFhOEj{kuF1j<7-ylwZE z&^d$h?|~l09pjvdq-yK|L^4Y-MrC15l_6_!>N(j>@_U=!MsL=$Yo~M6C>!-GoTaJI zM{pCw9XP-nx9!YPNr!dSV{sN!myR=qng@w%-iNJ6Cen2$(_7O4X%@dFxJP2}*Su#x z{6Mtw!IuvuR<(oSiI|F+Z!Er?`YQRx?fIDPKefA|Hg5bG3INFbqhHd$)2@=VhPaft zhPWSS)nSz#)o)Sz3Wl**CqRV2YMOasAvZ#ud*q>fDY{~zRWX0}=~8x4sS#a|oLN;! zC>$qFTkeNy;ob*SHNlMDVl!q=bN0|$HLc9s)Dar0j6nk2R-7WdOj(p^9tznjQq9RA z?WZV4wKc)u8JA=U={-{cq9@j4xE!|u%S1t{A~cs?h^1WDcWR>Vr=o$Y*YkT{>*n}Z zhHKl-DD?cN`c0jtz9p>*v#9@EORh!}f(eUyMBpyVBq7l{^gFsIBa zR>~-6law64s8B+|NZWH$g11qJPWRl)R_w>S$9WT=;XykS8W zNTO#ic?>$iK7=4 zx&UZ^$CCKMGws3TJlk(d3L!t?{xfiEZDoP_e**T8{->t?&tm%jN;=wd($b13Q*ufZ z(`Y~z#>w%iIuQFD*Os%&1dv66d4#PNB&RUK%o@RlP^t!Dhj8)Ea?R`^k4~{o-!m_u z(X%K_j40NE=ouK5_L1ckn?Up>+zS(9Q^0wp@v^-gXuyB^Gzsmvi}1%6xIdlp?|gD~ zbTYIvcQ?0Vb@g-wvMG)4{uLA7V{OUsN0V)TI`Q9OK+=*bASwItv2+Pl0AR~+%K1oj z*aUB=!W64F+GdxkiK;~^zc^=k>4|)6>XUH;Iy5Lj1o6lM+JLN<+53I$*15+~Eh_<=NT&}PorgIum4$;zt}6e>>I{#}W;oH$v!wp)DuY8%9S zjgoskVmkL7$IlvqO34W&N#*$m-dGitHK^=OmSPbtO;fUpg%(@(7AK!Ix1r}!T=TtS z7M!KLo|wTt4N;0t*8xnZ1OxP!R-{ogIfYj87yd~c`^Wb|_QNe#wm`)=-(5dV8kRY&UjeuGo!jwXtm{jcq55?Z&oOSG3md_wSiK-+#7G?s;eK zndd!wo`dTmk3mB6*<3P(fyfCOx>=f8**aJnI$3(V100+^EZD3)%$)3OZT=-2z}e9d z;A~;(M&ay4;bm#=X6tTApA{ zH6Jy3Lkn9scSCna7Y|EMH+yTY?}q=G&C0>X!N$qvZsrPg9dPZs#ouNMj<0#gI8)kg zvQXq=e4$=2njvjJbT_>I&9-&E!)U@DlTMMvE93f=DP35Iy=kuLwxzz|G?)T8nL=hG zJ>>>#Tb==npPzqs0D5B8)Bf$&`t|DbO4M>db8;~p?X8K-`PImpZhf^-_cfmd@C0{q z`OyPEGU!|$ETQm5ngtpQ2QK#lXJ_AfKSWx~dTv{GZ?As!R!tW4#a48!Xz42`ZX0h9 zRARopy}i5^^nFX){@CWTXkUb+Wvu=+g>3ohz3o+eK%>!KwF+u-}o`8C%4vRIy*a2!}h=*GQnL zU{QMg8~@&Kjw(4jQHmE}=wELG>k_mor@DGVyuqA(kq1+#6U~B-cY z`@4nk@&S5SI?qsqVV%W%&45r;kWWZJ$dA?z!BGeTuLahpa`^a1PyPYdpvR4g`%hYA ze=$}2{P}Mnl7W%&A4`g^uJ11(>_X#wY?7p5LD4R8n}UQ{OtHbau!02Dcy`EwuF0FX z|At&8x$4{mw15zQzp&`LtE-F3Y+r6co-qkD3^|k&qyutK5-ITNzufOI*q|mC9~ee{ zbg(oyfgIo3=XnQD=MvA5JiOE#luHhII8XK$6nSxhOA{l9c0v>@Ab|%A_F$-D#EbF$ zjtZMY>?dh7u7E-)kGh6|o475AZ@`cf4u)W|C#b&hrwlKFj|JWx2BhcMOZxiBO-Oit z55C;PFCHDfoLgs7FXD9Naxu&|2H^xt_@=-a6e5GcuHSJaXvpI+RG`-3J*}G24BDCK zUlG}A?I0DKkSbtMHOORJ^zAu=4%EK177tkg-URAH{sRBjfFL}R))$vj+iN-f5`T~- z3^G~_E?)Ib3g+1)_H|8SZa6rh$HnrL+`V>a5wT{3mP3);FC;V1;Or5iY6;I?H|hN( zb1)1&Cu(nnjJ^D}vf8mu^1h=6wIcxGLTTF?kj79hhP&wU&LSCiUb?&1kbU#uK6z&N zpF=jqK6)|jvDe11I$n<7OBDn2<0r~cqt)8gzksr;-l(_okX$g7b$tn_!(ddPK7Zp$ zL6%*l?}G0gPj&C!zd))JoWLMq?Q!${u7p7{9%1Si-A_q^?o9udD>;CEi9v8+e)Hmv z?M^qonh5hfs^L!0M5qFiOVki-i$Lu)vFn?+y7Rh;c!6#>JZRJHV>A3P^^lX{hIn?c zl+};!&_%w9`Axe1L{3)(I(txoeE8m^Ph1#Ty`Su^iSd~B*RMW}&o`JGT+r+0`&1Z# zLtX4Nx5L9yKl@nQQr!(Zn!GPq+)=)Tw54t5F@gQ!9uOZOX-(h2{fiLXR|pg2 zP3kSk`UcMaEZtdkTIUIJ;p7WxZ?36Mg9OF7dT{ehn=JthFxM{a*>-IyL|j|@WD9$q zE5$tgw|IN|pFKC7iF;o6(={HiUy0mNO#kc!qJ|@iG%ChyFVQWp?S9+*_VVwO$Gn#y zTd;Ne$4x-@PnbX!$Xu+aJqJ<$!z+1<2q~o9Yg6GEVloO*^@c(E(^00%;C)MR`N;G8 zb-+0vxS*#Ixr@ooBT+WS#q-19d$kq8DMR6CXl|0N0f2P_FrtCCaH7=~$BV>8o-O8u z1<|?yTu@oT%Ttg&+s$JQ=RddhBb}EV)P*r54Ev=|5`2_7WS_BHx=LNz>+qI@A+j8W zFGofaQ!G>G3q@au$g0|}M-W9O(T(^CSKtiWNA&8iBNmG7sf!IsND2v(*+=p;?Wfl# z@ZeoEn%(0g;kId4w$G!->s(M(UT@yTOZ_BR z=N&=^4C-In*x0SPf+Sc&?oWYCPeB52yEm17X&(@?tDrQmIc`=*gq;_PT+NhyArN=ceK!33pNM=%|&> z*$bT+%;Yu{EgQ`)B!_`DfYKlzSRM z|5kW6Ufz;^cfJE(O3RXwPQhATT`GclJ+Y2m7{l6HRp8@6pzA!5wBUkhaJj(n0 z$B^SvZ{e49^I~3ebN-B?*X*n>P`9huVf7KdIUj$-{`zK(DNYz^59Yfj~#^mDQR^}~LM zl+q!~krqi+WLpbsC|kd9H_&9#6i=tGzM`8O5ast@hpcqAk|LTu4PXc?^IVy!A~zn_ zer0dd>8U3BvKKIl(DRdzLzXh}-S&R7^VripPSWl#-wp5bk_hUzAl80P}0)hA~ zsjE$==9#ZZC#)eTxLj)b6A%G7!g(GG_|jx#&Ty7&xJ|UAZ!#hm>}Sb(A)G_k zyIKud5ylf6HJhb55l-tdXZn-na%H++V-Jks(bV98!$_GUDxkN%+!knVml1_CfS6+S z$=!>0(`{qQi~GXGHX9!X&}qAz*y|Otnbhf&m3i!@h+6xTW~*{Oc-Ok`xJvwx#OE=z z=i|d&8@e6$oeX+%)C*jCSW8HMdUi1-zPq9ySLceiy%3$PqT%B5ZR_giX`w66kO#_F zDyp**iR$oW9Q!5Dvk$yvFT^XCv>*j`phbX{}RlU z4S#PMqCfvJ7FcyZg{-fX*On^S$)!7BK^Lz_H@?D17gL*0rCkL^=41;~6cEr~G}`G( zEhjxO^#!1Dftz+2&$)-m^ZXHsjJ*1OaK~|^@?7{UCT!hCtMGx+p1au(-SuMP=ZjOE zC^L?sn6>urs#6mG^t^>mi@}bd{CVM{l)fr@9At6Qbf|d@i?EJ=k@WYEgF4(&6u=}# z8T`71Ba|iCQowzJ%H959K5aC;$?|407rqj!B51>6mr|^8DsRIs_Mf&n+uPHpEN*xT zW~r?~nE=z;=0UjI0K1q#NX!kd9!pznso`P0ZC!F=^J};+Th|(-PF2T+ZlMz8Yi8;PQ#ksm%5f=Rnc%hficKe5dUC1#FRrYE+ zfQGwctJXJ!EOW^qab<3OvxxVYo9L;m%BHKjKvy$tkKKb>UOl!>8EX~g-mRW`=i}Qg z6y=;>*XAg2TW#<-iPuLv!>IvctAXfaUu(-6iTpH4;}E&*y2r`B3sY) z`|I~JzR3>vak^ucGz)j!Xi7w++bi_T6;6(;SXFfqi2ah1!D0(m#hrO8n%!lE!&fg$ zFt4&|_6h-?YI#PP95Y#W9EjUB~tAO+Z1@X~jGfvHm3DNWYdb9}pucEudFps-T zJConJ37yVEbVn2j09 zV@nLgR8kb)ePN9iNYog+EkIP&zLZp9tKT`!)UW(|PO&cmQAnZBv`i0~F~Fk{j*ynV zBI3mlH1Z%0L5p`2dF4q`O7lpcd%)Md(c7?%ZxqA}|3qf7OyS@@F7LKR!Bfj>H#?TjRiWPC)msR_hq&enBe?-#Xr z?q=vC#ZF7LQ|YuY9O-&Nm`XBDyffHUv(Y*x16Zq+8O#W-w3Xa&7ZsV<8f;DkO8VmZ zDAXY>XnZ9|d{fab!(jPevC$|oN0c{-VeW8-lFwZh;)HQ=R7B&C9I=_As8#u5YXk&+ ztqkx!%mU+O8>y;4xl%c(6iTlzu>Q`y3pgcti)u-yue1kjFM}Ls$ZQ9%UFq5?T5xzI zGNNgwHta+R<74CMaU^@;1P8cCT0M&sU>{a4x8jpBeV66ec~VuGkg{aLVWJGCzNO{3 zPU>0?mWoJ(+w(q1`lTBAnNQP%j-D|J#hQv~Qj4R74Nf(8KX>KNeCXt zzAD3~duj&g!y~?DbY)h9}ij%c|x`(JsICkhP~4o}5s04eAf?*sB`M zz{(0dZ7nMwroU@SZssrp!@Vd>5NH_ES%2@q{rS2bf&BDkm;dB{r=Pog9 z=6_|3Y^&5Oy0KebY15di3@6AZ(uDm)o?xaZ7g-)e zj&;PRSl#){Wp0>y{rDSL{jFo2MiHw+551OG)-M580zdycKEnIY#R0Ni%-#tfJqNo< zhXVJf;EMS$M{>F(cPQ5GU}vs9(wAJpH!KaV z#_C<~IIG-@j zb&4XLcPqI?p>)|D8+v%k?Sav?4UY4r4i~G%a8z8L96Sf8i)UGsctlE4y9P9gCk(eMy9Bo)?OD{hgoc2hV`$_! z8k14Cqf^qtc`RhoU+1KVn3x9nLFI$1i5iIPc8l}r+0c_>&-{cr7gOxQ$&ZXf{9+n9 zTnnzgRLJBV*wZPwzmYbkRF%pvTOBO9x75l{a(FBid#Bcb`sH<5wryB-g$*IlKe#qF zG@)(x&_k@AWj!@K8bi=hN+;w;Z{W)kUeXNT;lcO)3xT@`wNBFRzq_2~v%2ji6nRltarKN4%lK(ncY6~EzN1T(Q`c}G4fFGWvy z{Q8w(t^&v}2OTyPD|T|v#BCkhk!9up+gpCXB!VAB*g`u;zCPn9@=LMR8|j3nhl&V7 zqs`A5pp^|0E&4@M*o+=@H9g;iw2b}lF~=jq*wUidzIQ&j9Kw(+u1A4a;Ml|Y(g@Nm zV?0Gugg(~QNZ_ehg#N2`dnI2mt($+;sLJ`tFRl&2T*9za6t=}hNWnaY1dC02a-VBr z$w?U^$MeLD8ar}69~-)Vc7y?{m)3>e-4fc-`)ZkEG=VkFxFGTrULE(;)7SoHs(D!O z5&hrNvGwZX?B)a9bhK0!l*5MP&sc)iNjUTbf5xX-5B1#4gGNo0c8{biQm_qA>K8X7 z=mcX7+k!L(%1m7+=q4sm7g-|GfJAy&hE_gsNw5?sT&}?u4$44z(y=qGcART?;^stf zFp||5+SRKcxeN#(t$Z9Qqn|>S;%TQT;+Hh_G$@QZ#4Se0tq2AtWrov>xs$L>!d?#) zY5Pc*Q!6r?y=eH-ss`Wmq<>~C;YQlA@H47{zr5my`ccuNn6V9~U$yHO4T$;8r zcfA!s-^ee2bp4XLx*G-R68nPSruq9$BMT{|C{lX&;!1Fn_mdZHN9G8DmsU5txO|(&=q_gFt+A@vd^ZeOPVnJ-X%O%w1Yj=MVoBw4xW?3+{}k$OvkUYx2NCQR!=H7%#dwp~oK$ZE0jg7?sCC68@5 zDJC6>K9UD{4+AKKuCu4=DcpHy9U5}--q#&*3F6zhG=Ie<%>1#xPdwC-G{cYCIc%GF zG+Y@w=5Sd-M%dtuZ)5Smho445?Wuf^r64TL9RMdz(0mmSm=~XMRI`d8l>s;KZ?iZQ z8n5BYY;J(0hw{AfRnbjq@8&?cik?L!hR)W^&{={ThH#=Ws*wq_jmWV5h8Dc2l!`DX z74r&ufs#Eje0ip+F;X_`GSe-Cz51T*`k}Fl%6{L42U7H+OBgP>hhe+B(-1{tfDZ!z z9{D*89!b%|(x};|H)3^zpUHR@VB8_+}6 zC&T2@I2H(zBBIGl2!oViv(fb+Pd-6h6Mi8lKS&(fkXuc_d0E#C<`(xX@_s6X`tQhJ zVuId9I?mVhV+nHzCBK`vcvHvlc~TsU(=%Fb$#k|p1~Pt@-pnSFXmVEQ3v(Y;p=s2@ zrDQw8kH^#yMT7G%2TW3Ay3LNIZV|OKt%&K`t%rawEcsCKoemlQuIx|$Fzk-dYio0`6 zhDWN)w6KWjVMB(Ar%^SmwM&;*M`savjI>oukgJNmR;y_%YJbndL~;~%Sia|;D0w<$ zU_~fuYg}i9aunIEwG@V3uK20w*(c@&vjSk|W)|SQneeU$xfGD;-Vg;c6(mToEkJoN1_;h&1t} z!9OmKK9bgMC_L<5F~n$G3NYsokbg2sN7_GXU&a}>pk_S^f3;AN)+m?FbXayHV``4P zJ|2^geI_qKe;_~Z5iK4*`0YtEr%{S>)+CtB(=Ra5bYs&Bhw99VVK3R;GWpxep7SST zL6_h!a|a7K0H!lz;IXe@Co-9kBB|+Ex4w%G(2j8aD`C`So#4b_k;%(L3i}&6X#MN?%;=lX z#;UI9ac}1{+1knZleGVX$}9GgYSl@>7v6GDu_6Qr?AI7J=v12iQ(jLcMv$RI1 zmU3ypd|W6{vJzCoyA1!SFSSt3E3a6-Nmtm&vws#l=b8V8#Hm2oY|Fb@L>)S#dW@Rx zA3X(F$2O$A4Y&C$)`(fTWlG>Vw(v2;vh4@Radp{|#vspV+VVsCGQe_AHlWKY#y^$F z_x{uqU1Zqm=|~;4{9|7FMmva4X>N=j;z)m~MZT_#?tH>O@8_>Bk4JF2a zP5(K|y+SPOFSSCuH zHhY|39>!lLQ@XlU`j=I31I7L?*ct`0p2?NdR0XT>mL9<`OD{wia2E-VV)wY)A@P_@r=(_ zMg^70ca%l?JppfhBIk^?ZP-1(5ZG3{iclAwYsgA2%>d3aBW-iXT` z4Mh7anxYc#$B}f59(TrQ86xCfpF(oCK8u(`M}3-a#(Qr@!%2qv+)&IL#6-{_6iX?_ z$!5Bfeoq6+5}wE7U<;s*mcGY$ubR0$XB*hfWphCU({xFvaM88;G{jq@0~TM#_C!H! zc{%{MlVy(wh%#xFI=0-0HPjTNS#^i>IXx3;fq|mKc)qlVu-B(3L z5PP^Br+s=+S34Z9sBW}Z4W~1!7?k$SxzF!1tNA=!+~sGE=?*065%xY=P%B#5!{7Xn zx;1eoUF$>D@N(`xaa7lp6FEn2q9Y~D}X-v6y}8BP`tZQXNB;pu4tp^*ls)z zFBUL6tG~<(=DBR!ED3U!R;0wr8ZYhko_51e=)9ro7^X$;l@;0M9JdvAt@z{)x0~ca zns6pa2D^5zJLXZ@J@=jT`}1LpFHZa-Mbo#}Sl?FWvS*B?PF4?m$hY;~x9$Z6ZVgVPb}TqabQ#BcWj7N5I}MNK8{2*O`MB8E$;kBJ?K!? z(O1We;F~oxaF-LcVU7i=dnbW6+yWt(`&$DvtuoY$=2o!jf=~-N%hGC8kv38gqBF}A z!r1jwc{yfO10B%2!CslZ*XA}pqLOb%rSeitGvI=_q{_!kH7^|3#rEPuXtr?&#^OV6A>e|i zRY~(gm#{<~6erqnq!Kz`B-j#$D0e#n-psx@gI%wl8z8SsIr1-CA29D^#LZ=IkmFq& z@ix{$|79}0#cb8-db->v501hOIz$QUzVXD0xQc!`aPV8-h-zDgtSx<9og74)L=r z65|Yo+~1y|(?kFo|0ljSZ|z7ZYjV*@9JFYxc*1t+R*OGLWm?-dPSPAHS^?2qTLu%Z0(8YSuF2u3KU- znwlavkV%`k5kyJBsosWA?s$)+$<{*{O2W>Jp1zO08UO8C7|jqUs6BwSQ)gBD9Fk!6zm$tja2RJLOOPdG0bKC$s`&U1r9Z)I0i2!L zRsV-YD?q%oaSz1G{-bNmEw6o7-hGej@~$pb++_6#sKu!6ok+gW>ysbd13V?|(YR`Tyh5@*Np_(*{V7vmG)5VP%W2n}ayMorAg(0lI6Y zpSL+ig@Sbc3QE*}28grz8y#nW>pzxu-!AQ~C3qW=VNd<5w->f!~aWf%6W%WnV} zvcYZyeG?ciFqr_I0;N0o_0QX(I{<|)HS%ek|4pJ>`xhy}V1IwY9TlK}M`g_$|H$Z{ z$8(x9rTALP(GL>c-*xqQ!;6I94ve`8Iu*gImo326HBmL^JtB+~wVbHI>UJLiuVA(g z#ioB4dfc%s+IS`*5}8jm9y8$;U#{cx->Hl+(Y^;+Oz(}$*^M*-g6Ul-bC*qj;b;?xb-Pmzbc2tn-}7Dyy)MZl09ZxC7_Tf2U=lVw8Rf10X(0K)t;dl}MJe08G@hVUqqU8F(k--C`J%n*|oh&F30 w-Wy~)6?}W`>B$U%=)c!5_cCc$DQH(~q*ZH`{eM5j{&8(Wb!%fNacHRj1E{^#>;M1& literal 0 HcmV?d00001 diff --git a/PyPI/setup.cfg b/PyPI/setup.cfg index e48316d..ab6a513 100644 --- a/PyPI/setup.cfg +++ b/PyPI/setup.cfg @@ -1,7 +1,7 @@ [metadata] # replace with your username: -name = gjh -version = 0.0.12 +name = guan +version = 0.0.1 author = guanjihuan author_email = guanjihuan@163.com description = An open source python package diff --git a/PyPI/src/guan.egg-info/PKG-INFO b/PyPI/src/guan.egg-info/PKG-INFO new file mode 100644 index 0000000..815a414 --- /dev/null +++ b/PyPI/src/guan.egg-info/PKG-INFO @@ -0,0 +1,19 @@ +Metadata-Version: 2.1 +Name: guan +Version: 0.0.1 +Summary: An open source python package +Home-page: https://py.guanjihuan.com +Author: guanjihuan +Author-email: guanjihuan@163.com +License: UNKNOWN +Project-URL: Bug Tracker, https://py.guanjihuan.com +Platform: UNKNOWN +Classifier: Programming Language :: Python :: 3 +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +License-File: LICENSE + +GUAN is an open-source python package developed and maintained by https://www.guanjihuan.com. The primary location of this package is on website https://py.guanjihuan.com. + diff --git a/PyPI/src/guan.egg-info/SOURCES.txt b/PyPI/src/guan.egg-info/SOURCES.txt new file mode 100644 index 0000000..d26d474 --- /dev/null +++ b/PyPI/src/guan.egg-info/SOURCES.txt @@ -0,0 +1,9 @@ +LICENSE +README.md +pyproject.toml +setup.cfg +src/guan/__init__.py +src/guan.egg-info/PKG-INFO +src/guan.egg-info/SOURCES.txt +src/guan.egg-info/dependency_links.txt +src/guan.egg-info/top_level.txt \ No newline at end of file diff --git a/PyPI/src/guan.egg-info/dependency_links.txt b/PyPI/src/guan.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/PyPI/src/guan.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/PyPI/src/guan.egg-info/top_level.txt b/PyPI/src/guan.egg-info/top_level.txt new file mode 100644 index 0000000..ff25243 --- /dev/null +++ b/PyPI/src/guan.egg-info/top_level.txt @@ -0,0 +1 @@ +guan diff --git a/PyPI/src/guan/__init__.py b/PyPI/src/guan/__init__.py new file mode 100644 index 0000000..1db4c8b --- /dev/null +++ b/PyPI/src/guan/__init__.py @@ -0,0 +1,985 @@ +import numpy as np +import cmath +from math import * +import copy + + + + +# test + +def test(): + print('\nSuccess in the installation of GUAN package!\n') + + + + +# basic functions + +## Pauli matrices + +def sigma_0(): + return np.eye(2) + +def sigma_x(): + return np.array([[0, 1],[1, 0]]) + +def sigma_y(): + return np.array([[0, -1j],[1j, 0]]) + +def sigma_z(): + return np.array([[1, 0],[0, -1]]) + + +## Kronecker product of Pauli matrices + +def sigma_00(): + return np.kron(sigma_0(), sigma_0()) + +def sigma_0x(): + return np.kron(sigma_0(), sigma_x()) + +def sigma_0y(): + return np.kron(sigma_0(), sigma_y()) + +def sigma_0z(): + return np.kron(sigma_0(), sigma_z()) + + +def sigma_x0(): + return np.kron(sigma_x(), sigma_0()) + +def sigma_xx(): + return np.kron(sigma_x(), sigma_x()) + +def sigma_xy(): + return np.kron(sigma_x(), sigma_y()) + +def sigma_xz(): + return np.kron(sigma_x(), sigma_z()) + + +def sigma_y0(): + return np.kron(sigma_y(), sigma_0()) + +def sigma_yx(): + return np.kron(sigma_y(), sigma_x()) + +def sigma_yy(): + return np.kron(sigma_y(), sigma_y()) + +def sigma_yz(): + return np.kron(sigma_y(), sigma_z()) + + +def sigma_z0(): + return np.kron(sigma_z(), sigma_0()) + +def sigma_zx(): + return np.kron(sigma_z(), sigma_x()) + +def sigma_zy(): + return np.kron(sigma_z(), sigma_y()) + +def sigma_zz(): + return np.kron(sigma_z(), sigma_z()) + + + + +# Hermitian Hamiltonian of tight binding model + +def finite_size_along_one_direction(N, on_site=0, hopping=1, period=0): + 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() + return hamiltonian + + +def finite_size_along_two_directions_for_square_lattice(N1, N2, on_site=0, hopping_1=1, hopping_2=1, period_1=0, period_2=0): + 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() + return hamiltonian + + +def finite_size_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): + 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() + return hamiltonian + + +def one_dimensional_fourier_transform(k, unit_cell, hopping): + unit_cell = np.array(unit_cell) + hopping = np.array(hopping) + hamiltonian = unit_cell+hopping*cmath.exp(1j*k)+hopping.transpose().conj()*cmath.exp(-1j*k) + return hamiltonian + + +def two_dimensional_fourier_transform_for_square_lattice(k1, k2, unit_cell, hopping_1, hopping_2): + unit_cell = np.array(unit_cell) + hopping_1 = np.array(hopping_1) + hopping_2 = np.array(hopping_2) + hamiltonian = unit_cell+hopping_1*cmath.exp(1j*k1)+hopping_1.transpose().conj()*cmath.exp(-1j*k1)+hopping_2*cmath.exp(1j*k2)+hopping_2.transpose().conj()*cmath.exp(-1j*k2) + return hamiltonian + + +def three_dimensional_fourier_transform_for_cubic_lattice(k1, k2, k3, unit_cell, hopping_1, hopping_2, hopping_3): + unit_cell = np.array(unit_cell) + hopping_1 = np.array(hopping_1) + hopping_2 = np.array(hopping_2) + hopping_3 = np.array(hopping_3) + hamiltonian = unit_cell+hopping_1*cmath.exp(1j*k1)+hopping_1.transpose().conj()*cmath.exp(-1j*k1)+hopping_2*cmath.exp(1j*k2)+hopping_2.transpose().conj()*cmath.exp(-1j*k2)+hopping_3*cmath.exp(1j*k3)+hopping_3.transpose().conj()*cmath.exp(-1j*k3) + return hamiltonian + + + + +# Hamiltonian of graphene lattice + +def hopping_along_zigzag_direction_for_graphene(N): + hopping = np.zeros((4*N, 4*N), dtype=complex) + for i0 in range(N): + hopping[4*i0+1, 4*i0+0] = 1 + hopping[4*i0+2, 4*i0+3] = 1 + return hopping + + +def finite_size_along_two_directions_for_graphene(N1, N2, period_1=0, period_2=0): + on_site = finite_size_along_one_direction(4) + hopping_1 = hopping_along_zigzag_direction_for_graphene(1) + hopping_2 = np.zeros((4, 4), dtype=complex) + hopping_2[3, 0] = 1 + hamiltonian = finite_size_along_two_directions_for_square_lattice(N1, N2, on_site, hopping_1, hopping_2, period_1, period_2) + return hamiltonian + + + + +# calculate band structures + +def calculate_eigenvalue(hamiltonian): + if np.array(hamiltonian).shape==(): + eigenvalue = np.real(hamiltonian) + else: + eigenvalue, eigenvector = np.linalg.eig(hamiltonian) + eigenvalue = np.sort(np.real(eigenvalue)) + return eigenvalue + + +def calculate_eigenvalue_with_one_parameter(x, hamiltonian_function): + dim_x = np.array(x).shape[0] + i0 = 0 + if np.array(hamiltonian_function(0)).shape==(): + eigenvalue_array = np.zeros((dim_x, 1)) + for x0 in x: + hamiltonian = hamiltonian_function(x0) + eigenvalue_array[i0, 0] = np.real(hamiltonian) + i0 += 1 + else: + dim = np.array(hamiltonian_function(0)).shape[0] + eigenvalue_array = np.zeros((dim_x, dim)) + for x0 in x: + hamiltonian = hamiltonian_function(x0) + eigenvalue, eigenvector = np.linalg.eig(hamiltonian) + eigenvalue_array[i0, :] = np.sort(np.real(eigenvalue[:])) + i0 += 1 + return eigenvalue_array + + +def calculate_eigenvalue_with_two_parameters(x, y, hamiltonian_function): + dim_x = np.array(x).shape[0] + dim_y = np.array(y).shape[0] + if np.array(hamiltonian_function(0,0)).shape==(): + eigenvalue_array = np.zeros((dim_y, dim_x, 1)) + i0 = 0 + for y0 in y: + j0 = 0 + for x0 in x: + hamiltonian = hamiltonian_function(x0, y0) + eigenvalue_array[i0, j0, 0] = np.real(hamiltonian) + j0 += 1 + i0 += 1 + else: + dim = np.array(hamiltonian_function(0, 0)).shape[0] + eigenvalue_array = np.zeros((dim_y, dim_x, dim)) + i0 = 0 + for y0 in y: + j0 = 0 + for x0 in x: + hamiltonian = hamiltonian_function(x0, y0) + eigenvalue, eigenvector = np.linalg.eig(hamiltonian) + eigenvalue_array[i0, j0, :] = np.sort(np.real(eigenvalue[:])) + j0 += 1 + i0 += 1 + return eigenvalue_array + + + + +# calculate wave functions + +def calculate_eigenvector(hamiltonian): + eigenvalue, eigenvector = np.linalg.eig(hamiltonian) + eigenvector = eigenvector[:, np.argsort(np.real(eigenvalue))] + return eigenvector + + + + +# calculate Green functions + +def green_function(fermi_energy, hamiltonian, broadening, self_energy=0): + if np.array(hamiltonian).shape==(): + dim = 1 + else: + dim = np.array(hamiltonian).shape[0] + green = np.linalg.inv((fermi_energy+broadening*1j)*np.eye(dim)-hamiltonian-self_energy) + return green + + +def green_function_nn_n(fermi_energy, h00, h01, green_nn_n_minus, broadening, self_energy=0): + h01 = np.array(h01) + if np.array(h00).shape==(): + dim = 1 + else: + dim = np.array(h00).shape[0] + green_nn_n = np.linalg.inv((fermi_energy+broadening*1j)*np.identity(dim)-h00-np.dot(np.dot(h01.transpose().conj(), green_nn_n_minus), h01)-self_energy) + return green_nn_n + + +def green_function_in_n(green_in_n_minus, h01, green_nn_n): + green_in_n = np.dot(np.dot(green_in_n_minus, h01), green_nn_n) + return green_in_n + + +def green_function_ni_n(green_nn_n, h01, green_ni_n_minus): + h01 = np.array(h01) + green_ni_n = np.dot(np.dot(green_nn_n, h01.transpose().conj()), green_ni_n_minus) + return green_ni_n + + +def green_function_ii_n(green_ii_n_minus, green_in_n_minus, h01, green_nn_n, green_ni_n_minus): + green_ii_n = green_ii_n_minus+np.dot(np.dot(np.dot(np.dot(green_in_n_minus, h01), green_nn_n), h01.transpose().conj()),green_ni_n_minus) + return green_ii_n + + + + +# calculate density of states + +def total_density_of_states(fermi_energy, hamiltonian, broadening=0.01): + green = green_function(fermi_energy, hamiltonian, broadening) + total_dos = -np.trace(np.imag(green))/pi + return total_dos + + +def total_density_of_states_with_fermi_energy_array(fermi_energy_array, hamiltonian, broadening=0.01): + dim = np.array(fermi_energy_array).shape[0] + total_dos_array = np.zeros(dim) + i0 = 0 + for fermi_energy in fermi_energy_array: + total_dos_array[i0] = total_density_of_states(fermi_energy, hamiltonian, broadening) + i0 += 1 + return total_dos_array + + +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) + local_dos = np.zeros((N2, N1)) + for i1 in range(N1): + for i2 in range(N2): + for i in range(internal_degree): + local_dos[i2, i1] = local_dos[i2, i1]-np.imag(green[i1*N2*internal_degree+i2*internal_degree+i, i1*N2*internal_degree+i2*internal_degree+i])/pi + return local_dos + + +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) + local_dos = np.zeros((N3, N2, N1)) + for i1 in range(N1): + for i2 in range(N2): + for i3 in range(N3): + for i in range(internal_degree): + local_dos[i3, i2, i1] = local_dos[i3, i2, i1]-np.imag(green[i1*N2*N3*internal_degree+i2*N3*internal_degree+i3*internal_degree+i, i1*N2*N3*internal_degree+i2*N3*internal_degree+i3*internal_degree+i])/pi + return local_dos + + +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) + 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_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_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_minus = green_ii_n + green_in_n = 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_minus = green_ni_n + for i2 in range(N2): + for i in range(internal_degree): + local_dos[i2, i1] = local_dos[i2, i1] - np.imag(green_ii_n_minus[i2*internal_degree+i, i2*internal_degree+i])/pi + return local_dos + + +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) + 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_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_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_minus = green_ii_n + green_in_n = 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_minus = green_ni_n + for i2 in range(N2): + for i3 in range(N3): + for i in range(internal_degree): + local_dos[i3, i2, i1] = local_dos[i3, i2, i1] -np.imag(green_ii_n_minus[i2*N3*internal_degree+i3*internal_degree+i, i2*N3*internal_degree+i3*internal_degree+i])/pi + return local_dos + + + + +# calculate conductance + +def transfer_matrix(fermi_energy, h00, h01): + h01 = np.array(h01) + if np.array(h00).shape==(): + dim = 1 + else: + dim = np.array(h00).shape[0] + transfer = np.zeros((2*dim, 2*dim), dtype=complex) + transfer[0:dim, 0:dim] = np.dot(np.linalg.inv(h01), fermi_energy*np.identity(dim)-h00) + transfer[0:dim, dim:2*dim] = np.dot(-1*np.linalg.inv(h01), h01.transpose().conj()) + transfer[dim:2*dim, 0:dim] = np.identity(dim) + transfer[dim:2*dim, dim:2*dim] = 0 + return transfer + + +def surface_green_function_of_lead(fermi_energy, h00, h01): + h01 = np.array(h01) + if np.array(h00).shape==(): + dim = 1 + else: + dim = np.array(h00).shape[0] + fermi_energy = fermi_energy+1e-9*1j + transfer = transfer_matrix(fermi_energy, h00, h01) + eigenvalue, eigenvector = np.linalg.eig(transfer) + ind = np.argsort(np.abs(eigenvalue)) + temp = np.zeros((2*dim, 2*dim), dtype=complex) + i0 = 0 + for ind0 in ind: + temp[:, i0] = eigenvector[:, ind0] + i0 += 1 + s1 = temp[dim:2*dim, 0:dim] + s2 = temp[0:dim, 0:dim] + s3 = temp[dim:2*dim, dim:2*dim] + s4 = temp[0:dim, dim:2*dim] + right_lead_surface = np.linalg.inv(fermi_energy*np.identity(dim)-h00-np.dot(np.dot(h01, s2), np.linalg.inv(s1))) + left_lead_surface = np.linalg.inv(fermi_energy*np.identity(dim)-h00-np.dot(np.dot(h01.transpose().conj(), s3), np.linalg.inv(s4))) + return right_lead_surface, left_lead_surface + + +def self_energy_of_lead(fermi_energy, h00, h01): + h01 = np.array(h01) + right_lead_surface, left_lead_surface = surface_green_function_of_lead(fermi_energy, h00, h01) + right_self_energy = np.dot(np.dot(h01, right_lead_surface), h01.transpose().conj()) + left_self_energy = np.dot(np.dot(h01.transpose().conj(), left_lead_surface), h01) + return right_self_energy, left_self_energy + + +def calculate_conductance(fermi_energy, h00, h01, length=100): + right_self_energy, left_self_energy = 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_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) + 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) + right_self_energy = (right_self_energy - right_self_energy.transpose().conj())*(0+1j) + left_self_energy = (left_self_energy - left_self_energy.transpose().conj())*(0+1j) + conductance = np.trace(np.dot(np.dot(np.dot(left_self_energy, green_0n_n), right_self_energy), green_0n_n.transpose().conj())) + return conductance + + +def calculate_conductance_with_fermi_energy_array(fermi_energy_array, h00, h01, length=100): + dim = np.array(fermi_energy_array).shape[0] + conductance_array = np.zeros(dim) + i0 = 0 + for fermi_energy_0 in fermi_energy_array: + conductance_array[i0] = np.real(calculate_conductance(fermi_energy_0, h00, h01, length)) + i0 += 1 + return conductance_array + + + + +# calculate scattering matrix + +def if_active_channel(k_of_channel): + if np.abs(np.imag(k_of_channel))<1e-6: + if_active = 1 + else: + if_active = 0 + return if_active + + +def get_k_and_velocity_of_channel(fermi_energy, h00, h01): + if np.array(h00).shape==(): + dim = 1 + else: + dim = np.array(h00).shape[0] + transfer = 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)) + k_of_channel = np.sort(k_of_channel) + temp = np.zeros((2*dim, 2*dim), dtype=complex) + temp2 = np.zeros((2*dim), dtype=complex) + i0 = 0 + for ind0 in ind: + temp[:, i0] = eigenvector[:, ind0] + temp2[i0] = eigenvalue[ind0] + i0 += 1 + eigenvalue = copy.deepcopy(temp2) + temp = temp[0:dim, :] + factor = np.zeros(2*dim, dtype=complex) + for dim0 in range(dim): + factor = factor+np.square(np.abs(temp[dim0, :])) + for dim0 in range(2*dim): + temp[:, dim0] = temp[:, dim0]/np.sqrt(factor[dim0]) + velocity_of_channel = np.zeros((2*dim), dtype=complex) + for dim0 in range(2*dim): + velocity_of_channel[dim0] = eigenvalue[dim0]*np.dot(np.dot(temp[0:dim, :].transpose().conj(), h01),temp[0:dim, :])[dim0, dim0] + velocity_of_channel = -2*np.imag(velocity_of_channel) + eigenvector = copy.deepcopy(temp) + return k_of_channel, velocity_of_channel, eigenvalue, eigenvector + + +def get_classified_k_velocity_u_and_f(fermi_energy, h00, h01): + if np.array(h00).shape==(): + dim = 1 + else: + dim = np.array(h00).shape[0] + k_of_channel, velocity_of_channel, eigenvalue, eigenvector = get_k_and_velocity_of_channel(fermi_energy, h00, h01) + ind_right_active = 0; ind_right_evanescent = 0; ind_left_active = 0; ind_left_evanescent = 0 + k_right = np.zeros(dim, dtype=complex); k_left = np.zeros(dim, dtype=complex) + velocity_right = np.zeros(dim, dtype=complex); velocity_left = np.zeros(dim, dtype=complex) + lambda_right = np.zeros(dim, dtype=complex); lambda_left = np.zeros(dim, dtype=complex) + u_right = np.zeros((dim, dim), dtype=complex); u_left = np.zeros((dim, dim), dtype=complex) + for dim0 in range(2*dim): + if_active = if_active_channel(k_of_channel[dim0]) + if if_active_channel(k_of_channel[dim0]) == 1: + direction = np.sign(velocity_of_channel[dim0]) + else: + direction = np.sign(np.imag(k_of_channel[dim0])) + if direction == 1: + if if_active == 1: # right-moving active channel + k_right[ind_right_active] = k_of_channel[dim0] + velocity_right[ind_right_active] = velocity_of_channel[dim0] + lambda_right[ind_right_active] = eigenvalue[dim0] + u_right[:, ind_right_active] = eigenvector[:, dim0] + ind_right_active += 1 + else: # right-moving evanescent channel + k_right[dim-1-ind_right_evanescent] = k_of_channel[dim0] + velocity_right[dim-1-ind_right_evanescent] = velocity_of_channel[dim0] + lambda_right[dim-1-ind_right_evanescent] = eigenvalue[dim0] + u_right[:, dim-1-ind_right_evanescent] = eigenvector[:, dim0] + ind_right_evanescent += 1 + else: + if if_active == 1: # left-moving active channel + k_left[ind_left_active] = k_of_channel[dim0] + velocity_left[ind_left_active] = velocity_of_channel[dim0] + lambda_left[ind_left_active] = eigenvalue[dim0] + u_left[:, ind_left_active] = eigenvector[:, dim0] + ind_left_active += 1 + else: # left-moving evanescent channel + k_left[dim-1-ind_left_evanescent] = k_of_channel[dim0] + velocity_left[dim-1-ind_left_evanescent] = velocity_of_channel[dim0] + lambda_left[dim-1-ind_left_evanescent] = eigenvalue[dim0] + u_left[:, dim-1-ind_left_evanescent] = eigenvector[:, dim0] + ind_left_evanescent += 1 + lambda_matrix_right = np.diag(lambda_right) + lambda_matrix_left = np.diag(lambda_left) + f_right = np.dot(np.dot(u_right, lambda_matrix_right), np.linalg.inv(u_right)) + f_left = np.dot(np.dot(u_left, lambda_matrix_left), np.linalg.inv(u_left)) + return k_right, k_left, velocity_right, velocity_left, f_right, f_left, u_right, u_left, ind_right_active + + +def calculate_scattering_matrix(fermi_energy, h00, h01, length=100): + h01 = np.array(h01) + if np.array(h00).shape==(): + dim = 1 + else: + dim = np.array(h00).shape[0] + k_right, k_left, velocity_right, velocity_left, f_right, f_left, u_right, u_left, ind_right_active = get_classified_k_velocity_u_and_f(fermi_energy, h00, h01) + right_self_energy = np.dot(h01, f_right) + 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_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) + 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) + 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) + for dim0 in range(dim): + for dim1 in range(dim): + if_active = if_active_channel(k_right[dim0])*if_active_channel(k_right[dim1]) + if if_active == 1: + transmission_matrix[dim0, dim1] = np.sqrt(np.abs(velocity_right[dim0]/velocity_right[dim1])) * transmission_matrix[dim0, dim1] + reflection_matrix[dim0, dim1] = np.sqrt(np.abs(velocity_left[dim0]/velocity_right[dim1]))*reflection_matrix[dim0, dim1] + else: + transmission_matrix[dim0, dim1] = 0 + reflection_matrix[dim0, dim1] = 0 + sum_of_tran_refl_array = np.sum(np.square(np.abs(transmission_matrix[0:ind_right_active, 0:ind_right_active])), axis=0)+np.sum(np.square(np.abs(reflection_matrix[0:ind_right_active, 0:ind_right_active])), axis=0) + for sum_of_tran_refl in sum_of_tran_refl_array: + if sum_of_tran_refl > 1.001: + print('Error Alert: scattering matrix is not normalized!') + return transmission_matrix, reflection_matrix, k_right, k_left, velocity_right, velocity_left, ind_right_active + + +def print_or_write_scattering_matrix(fermi_energy, h00, h01, length=100, on_print=1, on_write=0): + if np.array(h00).shape==(): + dim = 1 + else: + dim = np.array(h00).shape[0] + transmission_matrix, reflection_matrix, k_right, k_left, velocity_right, velocity_left, ind_right_active = calculate_scattering_matrix(fermi_energy, h00, h01, length) + if on_print == 1: + print('\nActive channel (left or right) = ', ind_right_active) + print('Evanescent channel (left or right) = ', dim-ind_right_active, '\n') + print('K of right-moving active channels:\n', np.real(k_right[0:ind_right_active])) + print('K of left-moving active channels:\n', np.real(k_left[0:ind_right_active]), '\n') + print('Velocity of right-moving active channels:\n', np.real(velocity_right[0:ind_right_active])) + print('Velocity of left-moving active channels:\n', np.real(velocity_left[0:ind_right_active]), '\n') + print('Transmission matrix:\n', np.square(np.abs(transmission_matrix[0:ind_right_active, 0:ind_right_active]))) + print('Reflection matrix:\n', np.square(np.abs(reflection_matrix[0:ind_right_active, 0:ind_right_active])), '\n') + print('Total transmission of channels:\n', np.sum(np.square(np.abs(transmission_matrix[0:ind_right_active, 0:ind_right_active])), axis=0)) + print('Total reflection of channels:\n',np.sum(np.square(np.abs(reflection_matrix[0:ind_right_active, 0:ind_right_active])), axis=0)) + print('Sum of transmission and reflection of channels:\n', np.sum(np.square(np.abs(transmission_matrix[0:ind_right_active, 0:ind_right_active])), axis=0) + np.sum(np.square(np.abs(reflection_matrix[0:ind_right_active, 0:ind_right_active])), axis=0)) + print('Total conductance = ', np.sum(np.square(np.abs(transmission_matrix[0:ind_right_active, 0:ind_right_active]))), '\n') + if on_write == 1: + with open('a.txt', 'w') as f: + f.write('Active channel (left or right) = ' + str(ind_right_active) + '\n') + f.write('Evanescent channel (left or right) = ' + str(dim - ind_right_active) + '\n\n') + f.write('Channel K Velocity\n') + for ind0 in range(ind_right_active): + f.write(' '+str(ind0 + 1) + ' | '+str(np.real(k_right[ind0]))+' ' + str(np.real(velocity_right[ind0]))+'\n') + f.write('\n') + for ind0 in range(ind_right_active): + f.write(' -' + str(ind0 + 1) + ' | ' + str(np.real(k_left[ind0])) + ' ' + str(np.real(velocity_left[ind0])) + '\n') + f.write('\nScattering matrix:\n ') + for ind0 in range(ind_right_active): + f.write(str(ind0+1)+' ') + f.write('\n') + for ind1 in range(ind_right_active): + f.write(' '+str(ind1+1)+' ') + for ind2 in range(ind_right_active): + f.write('%f' % np.square(np.abs(transmission_matrix[ind1, ind2]))+' ') + f.write('\n') + f.write('\n') + for ind1 in range(ind_right_active): + f.write(' -'+str(ind1+1)+' ') + for ind2 in range(ind_right_active): + f.write('%f' % np.square(np.abs(reflection_matrix[ind1, ind2]))+' ') + 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') + + + + +# calculate Chern number + +def calculate_chern_number_for_square_lattice(hamiltonian_function, precision=100): + if np.array(hamiltonian_function(0, 0)).shape==(): + dim = 1 + else: + dim = np.array(hamiltonian_function(0, 0)).shape[0] + delta = 2*pi/precision + chern_number = np.zeros(dim, dtype=complex) + 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) + H_delta_kx = hamiltonian_function(kx+delta, ky) + vector_delta_kx = calculate_eigenvector(H_delta_kx) + H_delta_ky = hamiltonian_function(kx, ky+delta) + vector_delta_ky = 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) + for i in range(dim): + vector_i = vector[:, i] + vector_delta_kx_i = vector_delta_kx[:, i] + vector_delta_ky_i = vector_delta_ky[:, i] + vector_delta_kx_ky_i = vector_delta_kx_ky[:, i] + Ux = np.dot(np.conj(vector_i), vector_delta_kx_i)/abs(np.dot(np.conj(vector_i), vector_delta_kx_i)) + Uy = np.dot(np.conj(vector_i), vector_delta_ky_i)/abs(np.dot(np.conj(vector_i), vector_delta_ky_i)) + Ux_y = np.dot(np.conj(vector_delta_ky_i), vector_delta_kx_ky_i)/abs(np.dot(np.conj(vector_delta_ky_i), vector_delta_kx_ky_i)) + Uy_x = np.dot(np.conj(vector_delta_kx_i), vector_delta_kx_ky_i)/abs(np.dot(np.conj(vector_delta_kx_i), vector_delta_kx_ky_i)) + F = cmath.log(Ux*Uy_x*(1/Ux_y)*(1/Uy)) + chern_number[i] = chern_number[i] + F + chern_number = chern_number/(2*pi*1j) + return chern_number + + + + +# calculate Wilson loop + +def calculate_wilson_loop(hamiltonian_function, k_min=-pi, k_max=pi, precision=100): + k_array = np.linspace(k_min, k_max, precision) + dim = np.array(hamiltonian_function(0)).shape[0] + wilson_loop_array = np.ones(dim, dtype=complex) + for i in range(dim): + eigenvector_array = [] + for k in k_array: + eigenvector = calculate_eigenvector(hamiltonian_function(k)) + if k != k_max: + eigenvector_array.append(eigenvector[:, i]) + else: + eigenvector_array.append(eigenvector_array[0]) + for i0 in range(precision-1): + F = np.dot(eigenvector_array[i0+1].transpose().conj(), eigenvector_array[i0]) + wilson_loop_array[i] = np.dot(F, wilson_loop_array[i]) + return wilson_loop_array + + + + +# read and write + +def read_one_dimensional_data(filename='a'): + f = open(filename+'.txt', 'r') + text = f.read() + f.close() + row_list = np.array(text.split('\n')) + dim_column = np.array(row_list[0].split()).shape[0] + x = np.array([]) + y = np.array([]) + for row in row_list: + column = np.array(row.split()) + if column.shape[0] != 0: + x = np.append(x, [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).shape[0] == 0: + y = [y_row] + else: + y = np.append(y, [y_row], axis=0) + return x, y + + +def read_two_dimensional_data(filename='a'): + f = open(filename+'.txt', 'r') + text = f.read() + f.close() + row_list = np.array(text.split('\n')) + dim_column = np.array(row_list[0].split()).shape[0] + x = np.array([]) + y = 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 = np.zeros(x_str.shape[0]) + for i00 in range(x_str.shape[0]): + x[i00] = float(x_str[i00]) + elif column.shape[0] != 0: + y = np.append(y, [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) + return x, y, matrix + + +def write_one_dimensional_data(x, y, filename='a'): + with open(filename+'.txt', 'w') as f: + i0 = 0 + for x0 in x: + f.write(str(x0)+' ') + if len(y.shape) == 1: + f.write(str(y[i0])+'\n') + elif len(y.shape) == 2: + for j0 in range(y.shape[1]): + f.write(str(y[i0, j0])+' ') + f.write('\n') + i0 += 1 + + +def write_two_dimensional_data(x, y, matrix, filename='a'): + with open(filename+'.txt', 'w') as f: + f.write('0 ') + for x0 in x: + f.write(str(x0)+' ') + f.write('\n') + i0 = 0 + for y0 in y: + f.write(str(y0)) + j0 = 0 + for x0 in x: + f.write(' '+str(matrix[i0, j0])+' ') + j0 += 1 + f.write('\n') + i0 += 1 + + + + +# plot figures + +def plot(x, y, xlabel='x', ylabel='y', title='', filename='a', show=1, save=0, type='', y_min=None, y_max=None): + import matplotlib.pyplot as plt + fig, ax = plt.subplots() + plt.subplots_adjust(bottom=0.20, left=0.18) + ax.plot(x, y, type) + ax.grid() + ax.set_title(title, fontsize=20, fontfamily='Times New Roman') + ax.set_xlabel(xlabel, fontsize=20, fontfamily='Times New Roman') + ax.set_ylabel(ylabel, fontsize=20, fontfamily='Times New Roman') + if y_min!=None or y_max!=None: + if y_min==None: + y_min=min(y) + if y_max==None: + y_max=max(y) + ax.set_ylim(y_min, y_max) + ax.tick_params(labelsize=20) + labels = ax.get_xticklabels() + ax.get_yticklabels() + [label.set_fontname('Times New Roman') for label in labels] + if save == 1: + plt.savefig(filename+'.jpg', dpi=300) + if show == 1: + plt.show() + plt.close('all') + + +def plot_3d_surface(x, y, matrix, xlabel='x', ylabel='y', zlabel='z', title='', filename='a', show=1, save=0, z_min=None, z_max=None): + 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, y = np.meshgrid(x, y) + if len(matrix.shape) == 2: + surf = ax.plot_surface(x, y, matrix, cmap=cm.coolwarm, linewidth=0, antialiased=False) + elif len(matrix.shape) == 3: + for i0 in range(matrix.shape[2]): + surf = ax.plot_surface(x, y, matrix[:,:,i0], cmap=cm.coolwarm, linewidth=0, antialiased=False) + ax.set_title(title, fontsize=20, fontfamily='Times New Roman') + ax.set_xlabel(xlabel, fontsize=20, fontfamily='Times New Roman') + ax.set_ylabel(ylabel, fontsize=20, fontfamily='Times New Roman') + ax.set_zlabel(zlabel, fontsize=20, 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=15) + labels = ax.get_xticklabels() + ax.get_yticklabels() + ax.get_zticklabels() + [label.set_fontname('Times New Roman') for label in labels] + cax = plt.axes([0.80, 0.15, 0.05, 0.75]) + cbar = fig.colorbar(surf, cax=cax) + cbar.ax.tick_params(labelsize=15) + for l in cbar.ax.yaxis.get_ticklabels(): + l.set_family('Times New Roman') + if save == 1: + plt.savefig(filename+'.jpg', dpi=300) + if show == 1: + plt.show() + plt.close('all') + + +def plot_contour(x, y, matrix, xlabel='x', ylabel='y', title='', filename='a', show=1, save=0): + import matplotlib.pyplot as plt + fig, ax = plt.subplots() + plt.subplots_adjust(bottom=0.2, right=0.75, left = 0.16) + x, y = np.meshgrid(x, y) + contour = ax.contourf(x,y,matrix,cmap='jet') + ax.set_title(title, fontsize=20, fontfamily='Times New Roman') + ax.set_xlabel(xlabel, fontsize=20, fontfamily='Times New Roman') + ax.set_ylabel(ylabel, fontsize=20, fontfamily='Times New Roman') + ax.tick_params(labelsize=15) + labels = ax.get_xticklabels() + ax.get_yticklabels() + [label.set_fontname('Times New Roman') for label in labels] + cax = plt.axes([0.78, 0.17, 0.08, 0.71]) + cbar = fig.colorbar(contour, cax=cax) + cbar.ax.tick_params(labelsize=15) + for l in cbar.ax.yaxis.get_ticklabels(): + l.set_family('Times New Roman') + if save == 1: + plt.savefig(filename+'.jpg', dpi=300) + if show == 1: + plt.show() + plt.close('all') + + + + +# download + +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.iframe['src'] + 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') \ No newline at end of file diff --git a/README.md b/README.md index b3e3e05..4d616c2 100755 --- a/README.md +++ b/README.md @@ -1,5 +1,6 @@ -### GJH project: an open source python package. The official website is https://py.guanjihuan.com +### GUAN project: an open source python package. The official website is https://py.guanjihuan.com -### Installation: pip install --upgrade gjh +### Installation: pip install --upgrade guan + +### Usage: import guan -### Usage: import gjh \ No newline at end of file diff --git a/Tutorial/0_test.py b/Tutorial/0_test.py index 1d702a5..3989fe9 100644 --- a/Tutorial/0_test.py +++ b/Tutorial/0_test.py @@ -1,3 +1,3 @@ -import gjh +import guan -gjh.test() \ No newline at end of file +guan.test() \ No newline at end of file diff --git a/Tutorial/10_Wilson_loop.py b/Tutorial/10_Wilson_loop.py index 34dd76b..5ec63ba 100644 --- a/Tutorial/10_Wilson_loop.py +++ b/Tutorial/10_Wilson_loop.py @@ -1,4 +1,4 @@ -import gjh +import guan import numpy as np import cmath from math import * @@ -14,7 +14,7 @@ def hamiltonian_function(k): # SSH model hamiltonian[1,0] = gamma+lambda0*cmath.exp(1j*k) return hamiltonian -wilson_loop_array = gjh.calculate_wilson_loop(hamiltonian_function) +wilson_loop_array = guan.calculate_wilson_loop(hamiltonian_function) print('wilson loop =', wilson_loop_array) p = np.log(wilson_loop_array)/2/pi/1j print('p =', p, '\n') \ No newline at end of file diff --git a/Tutorial/11_read_and_write.py b/Tutorial/11_read_and_write.py index 3d17d93..136376f 100644 --- a/Tutorial/11_read_and_write.py +++ b/Tutorial/11_read_and_write.py @@ -1,20 +1,20 @@ -import gjh +import guan import numpy as np x = np.array([1, 2, 3]) y = np.array([5, 6, 7]) -gjh.write_one_dimensional_data(x, y, filename='one_dimensional_data') +guan.write_one_dimensional_data(x, y, filename='one_dimensional_data') matrix = np.zeros((3, 3)) matrix[0, 1] = 11 -gjh.write_two_dimensional_data(x, y, matrix, filename='two_dimensional_data') +guan.write_two_dimensional_data(x, y, matrix, filename='two_dimensional_data') -x_read, y_read = gjh.read_one_dimensional_data('one_dimensional_data') +x_read, y_read = guan.read_one_dimensional_data('one_dimensional_data') print(x_read, '\n') print(y_read, '\n\n') -x_read, y_read, matrix_read = gjh.read_two_dimensional_data('two_dimensional_data') +x_read, y_read, matrix_read = guan.read_two_dimensional_data('two_dimensional_data') print(x_read, '\n') print(y_read, '\n') print(matrix_read) \ No newline at end of file diff --git a/Tutorial/12_download.py b/Tutorial/12_download.py index f6a62f0..e07cc9b 100644 --- a/Tutorial/12_download.py +++ b/Tutorial/12_download.py @@ -1,5 +1,5 @@ -import gjh +import guan -gjh.download_with_scihub() -# gjh.download_with_scihub('address') -# gjh.download_with_scihub(num=3) \ No newline at end of file +guan.download_with_scihub() +# guan.download_with_scihub('address') +# guan.download_with_scihub(num=3) \ No newline at end of file diff --git a/Tutorial/1_Pauli_matrix.py b/Tutorial/1_Pauli_matrix.py index 4403c0e..b8ab886 100644 --- a/Tutorial/1_Pauli_matrix.py +++ b/Tutorial/1_Pauli_matrix.py @@ -1,6 +1,6 @@ -import gjh +import guan -print('sigma_0:\n', gjh.sigma_0(), '\n') -print('sigma_x:\n', gjh.sigma_x(), '\n') -print('sigma_y:\n', gjh.sigma_y(), '\n') -print('sigma_z:\n', gjh.sigma_z(), '\n') \ No newline at end of file +print('sigma_0:\n', guan.sigma_0(), '\n') +print('sigma_x:\n', guan.sigma_x(), '\n') +print('sigma_y:\n', guan.sigma_y(), '\n') +print('sigma_z:\n', guan.sigma_z(), '\n') \ No newline at end of file diff --git a/Tutorial/2_Hamiltonian_of_finite_size.py b/Tutorial/2_Hamiltonian_of_finite_size.py index aac1e0d..a218f75 100644 --- a/Tutorial/2_Hamiltonian_of_finite_size.py +++ b/Tutorial/2_Hamiltonian_of_finite_size.py @@ -1,5 +1,5 @@ -import gjh +import guan -print(gjh.finite_size_along_one_direction(3), '\n') -print(gjh.finite_size_along_two_directions_for_square_lattice(2, 2), '\n') -print(gjh.finite_size_along_three_directions_for_cubic_lattice(2, 2, 2), '\n') \ No newline at end of file +print(guan.finite_size_along_one_direction(3), '\n') +print(guan.finite_size_along_two_directions_for_square_lattice(2, 2), '\n') +print(guan.finite_size_along_three_directions_for_cubic_lattice(2, 2, 2), '\n') \ No newline at end of file diff --git a/Tutorial/3_Fourier_transform_and_band_structures.py b/Tutorial/3_Fourier_transform_and_band_structures.py index 3669a26..de460a4 100644 --- a/Tutorial/3_Fourier_transform_and_band_structures.py +++ b/Tutorial/3_Fourier_transform_and_band_structures.py @@ -1,4 +1,4 @@ -import gjh +import guan import numpy as np from math import * import functools @@ -6,14 +6,14 @@ import functools x = np.linspace(-pi, pi, 100) y = np.linspace(-pi, pi, 100) -hamiltonian_function = functools.partial(gjh.one_dimensional_fourier_transform, unit_cell=0, hopping=1) -eigenvalue_array = gjh.calculate_eigenvalue_with_one_parameter(x, hamiltonian_function) -gjh.plot(x, eigenvalue_array, xlabel='k', ylabel='E', type='-o') +hamiltonian_function = functools.partial(guan.one_dimensional_fourier_transform, unit_cell=0, hopping=1) +eigenvalue_array = guan.calculate_eigenvalue_with_one_parameter(x, hamiltonian_function) +guan.plot(x, eigenvalue_array, xlabel='k', ylabel='E', type='-o') -hamiltonian_function = functools.partial(gjh.two_dimensional_fourier_transform_for_square_lattice, unit_cell=0, hopping_1=1, hopping_2=1) -eigenvalue_array = gjh.calculate_eigenvalue_with_two_parameters(x, y, hamiltonian_function) -gjh.plot_3d_surface(x, y, eigenvalue_array, xlabel='kx', ylabel='ky', zlabel='E') +hamiltonian_function = functools.partial(guan.two_dimensional_fourier_transform_for_square_lattice, unit_cell=0, hopping_1=1, hopping_2=1) +eigenvalue_array = guan.calculate_eigenvalue_with_two_parameters(x, y, hamiltonian_function) +guan.plot_3d_surface(x, y, eigenvalue_array, xlabel='kx', ylabel='ky', zlabel='E') -hamiltonian_function = functools.partial(gjh.three_dimensional_fourier_transform_for_cubic_lattice, k3=0, unit_cell=0, hopping_1=1, hopping_2=1, hopping_3=1) -eigenvalue_array = gjh.calculate_eigenvalue_with_two_parameters(x, y, hamiltonian_function) -gjh.plot_3d_surface(x, y, eigenvalue_array, xlabel='kx', ylabel='ky', zlabel='E') \ No newline at end of file +hamiltonian_function = functools.partial(guan.three_dimensional_fourier_transform_for_cubic_lattice, k3=0, unit_cell=0, hopping_1=1, hopping_2=1, hopping_3=1) +eigenvalue_array = guan.calculate_eigenvalue_with_two_parameters(x, y, hamiltonian_function) +guan.plot_3d_surface(x, y, eigenvalue_array, xlabel='kx', ylabel='ky', zlabel='E') \ No newline at end of file diff --git a/Tutorial/4_bands_of_zigzag_graphene.py b/Tutorial/4_bands_of_zigzag_graphene.py index 1a02233..cc360c2 100644 --- a/Tutorial/4_bands_of_zigzag_graphene.py +++ b/Tutorial/4_bands_of_zigzag_graphene.py @@ -1,12 +1,12 @@ -import gjh +import guan import numpy as np from math import * import functools x = np.linspace(-pi, pi, 100) Ny = 10 -unit_cell = gjh.finite_size_along_two_directions_for_graphene(1, Ny) -hopping = gjh.hopping_along_zigzag_direction_for_graphene(Ny) -hamiltonian_function = functools.partial(gjh.one_dimensional_fourier_transform, unit_cell=unit_cell, hopping=hopping) -eigenvalue_array = gjh.calculate_eigenvalue_with_one_parameter(x, hamiltonian_function) -gjh.plot(x, eigenvalue_array, xlabel='k', ylabel='E') \ No newline at end of file +unit_cell = guan.finite_size_along_two_directions_for_graphene(1, Ny) +hopping = guan.hopping_along_zigzag_direction_for_graphene(Ny) +hamiltonian_function = functools.partial(guan.one_dimensional_fourier_transform, unit_cell=unit_cell, hopping=hopping) +eigenvalue_array = guan.calculate_eigenvalue_with_one_parameter(x, hamiltonian_function) +guan.plot(x, eigenvalue_array, xlabel='k', ylabel='E') \ No newline at end of file diff --git a/Tutorial/5_total_density_of_states.py b/Tutorial/5_total_density_of_states.py index e2052b2..000980b 100644 --- a/Tutorial/5_total_density_of_states.py +++ b/Tutorial/5_total_density_of_states.py @@ -1,7 +1,7 @@ -import gjh +import guan import numpy as np -hamiltonian = gjh.finite_size_along_two_directions_for_square_lattice(2,2) +hamiltonian = guan.finite_size_along_two_directions_for_square_lattice(2,2) fermi_energy_array = np.linspace(-4, 4, 400) -total_dos_array = gjh.total_density_of_states_with_fermi_energy_array(fermi_energy_array, hamiltonian, broadening=0.1) -gjh.plot(fermi_energy_array, total_dos_array, xlabel='E', ylabel='Total DOS', type='-o') \ No newline at end of file +total_dos_array = guan.total_density_of_states_with_fermi_energy_array(fermi_energy_array, hamiltonian, broadening=0.1) +guan.plot(fermi_energy_array, total_dos_array, xlabel='E', ylabel='Total DOS', type='-o') \ No newline at end of file diff --git a/Tutorial/6_local_density_of_states.py b/Tutorial/6_local_density_of_states.py index 1b284c8..34f617b 100644 --- a/Tutorial/6_local_density_of_states.py +++ b/Tutorial/6_local_density_of_states.py @@ -1,28 +1,28 @@ -import gjh +import guan import numpy as np fermi_energy = 0 N1 = 3 N2 = 4 -hamiltonian = gjh.finite_size_along_two_directions_for_square_lattice(N1,N2) -LDOS = gjh.local_density_of_states_for_square_lattice(fermi_energy, hamiltonian, N1=N1, N2=N2) +hamiltonian = guan.finite_size_along_two_directions_for_square_lattice(N1,N2) +LDOS = guan.local_density_of_states_for_square_lattice(fermi_energy, hamiltonian, N1=N1, N2=N2) print('square lattice:\n', LDOS, '\n') -h00 = gjh.finite_size_along_one_direction(N2) +h00 = guan.finite_size_along_one_direction(N2) h01 = np.identity(N2) -LDOS = gjh.local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy, h00=h00, h01=h01, N2=N2, N1=N1) +LDOS = guan.local_density_of_states_for_square_lattice_using_dyson_equation(fermi_energy, h00=h00, h01=h01, N2=N2, N1=N1) print(LDOS, '\n\n') -gjh.plot_contour(range(N1), range(N2), LDOS) +guan.plot_contour(range(N1), range(N2), LDOS) N1 = 3 N2 = 4 N3 = 5 -hamiltonian = gjh.finite_size_along_three_directions_for_cubic_lattice(N1, N2, N3) -LDOS = gjh.local_density_of_states_for_cubic_lattice(fermi_energy, hamiltonian, N1=N1, N2=N2, N3=N3) +hamiltonian = guan.finite_size_along_three_directions_for_cubic_lattice(N1, N2, N3) +LDOS = guan.local_density_of_states_for_cubic_lattice(fermi_energy, hamiltonian, N1=N1, N2=N2, N3=N3) print('cubic lattice:\n', LDOS, '\n') -h00 = gjh.finite_size_along_two_directions_for_square_lattice(N2, N3) +h00 = guan.finite_size_along_two_directions_for_square_lattice(N2, N3) h01 = np.identity(N2*N3) -LDOS = gjh.local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy, h00, h01, N3=N3, N2=N2, N1=N1) +LDOS = guan.local_density_of_states_for_cubic_lattice_using_dyson_equation(fermi_energy, h00, h01, N3=N3, N2=N2, N1=N1) print(LDOS) \ No newline at end of file diff --git a/Tutorial/7_conductance.py b/Tutorial/7_conductance.py index 10d5a94..c536973 100644 --- a/Tutorial/7_conductance.py +++ b/Tutorial/7_conductance.py @@ -1,8 +1,8 @@ -import gjh +import guan import numpy as np fermi_energy_array = np.linspace(-5, 5, 400) -h00 = gjh.finite_size_along_one_direction(4) +h00 = guan.finite_size_along_one_direction(4) h01 = np.identity(4) -conductance_array = gjh.calculate_conductance_with_fermi_energy_array(fermi_energy_array, h00, h01) -gjh.plot(fermi_energy_array, conductance_array, xlabel='E', ylabel='Conductance', type='-o') \ No newline at end of file +conductance_array = guan.calculate_conductance_with_fermi_energy_array(fermi_energy_array, h00, h01) +guan.plot(fermi_energy_array, conductance_array, xlabel='E', ylabel='Conductance', type='-o') \ No newline at end of file diff --git a/Tutorial/8_scattering_matrix.py b/Tutorial/8_scattering_matrix.py index c6a5f8e..e6f7f50 100644 --- a/Tutorial/8_scattering_matrix.py +++ b/Tutorial/8_scattering_matrix.py @@ -1,7 +1,7 @@ -import gjh +import guan import numpy as np fermi_energy = 0 -h00 = gjh.finite_size_along_one_direction(4) +h00 = guan.finite_size_along_one_direction(4) h01 = np.identity(4) -gjh.print_or_write_scattering_matrix(fermi_energy, h00, h01) \ No newline at end of file +guan.print_or_write_scattering_matrix(fermi_energy, h00, h01) \ No newline at end of file diff --git a/Tutorial/9_Chern_number.py b/Tutorial/9_Chern_number.py index ef2d23a..ff307dc 100644 --- a/Tutorial/9_Chern_number.py +++ b/Tutorial/9_Chern_number.py @@ -1,4 +1,4 @@ -import gjh +import guan import numpy as np from math import * @@ -14,5 +14,5 @@ def hamiltonian_function(kx, ky): # one QAH model with chern number 2 hamiltonian[1, 1] = -(m+2*t3*sin(kx)+2*t3*sin(ky)+2*t2*cos(kx+ky)) return hamiltonian -chern_number = gjh.calculate_chern_number_for_square_lattice(hamiltonian_function, precision=100) +chern_number = guan.calculate_chern_number_for_square_lattice(hamiltonian_function, precision=100) print(chern_number) \ No newline at end of file diff --git a/source_code.py b/source_code.py index 357d97d..1db4c8b 100644 --- a/source_code.py +++ b/source_code.py @@ -9,7 +9,7 @@ import copy # test def test(): - print('\nSuccess in the installation of GJH package!\n') + print('\nSuccess in the installation of GUAN package!\n')