def Junc_eff_Ham_gen(omega, Wj, Lx, cutxT, cutyT, cutxB, cutyB, ax, ay, kx, m_eff, alp_l, alp_t, mu, Vj, Gam, delta, phi, Vsc=0, Gam_SC_factor=0, iter=50, eta=0, plot_junction=False): # Generates the effective Hamiltonian for the Junction, which includes the self-energy from both of the SC regions # * omega is the (real) energy that goes into the Green's function # * W is the width of the junction # * ay_targ is the targeted lattice constant # * kx is the wavevector along the length of the junction # * m_eff is the effective mass # * alp_l is the longitudinal spin-orbit coupling coefficient # * alp_t is the transverse spin-orbit coupling coefficient # * mu is the chemical potential # * Vj is an addition potential in the junction region (V = 0 in SC regions by convention) # * Gam is the Zeeman energy in the junction # * Gam_SC = Gam_SC_factor * Gam, which is the Zeeman energy in the SC regions # * delta is the magnitude of the SC pairing in the SC regions # * phi is the phase difference between the two SC regions # * iter is the number of iteration of the algorithm to perform # * eta is the imaginary component of the energy that is used for broadening if cutxT == 0 and cutxB == 0: Nx = 3 Lx = Nx * ax else: Nx = int(Lx / ax) Wj_int = int( Wj / ay ) # number of lattice sites in the junction region (in the y-direction) Ny = Wj_int + 2 #add one SC site on each side coor = shps.square(Nx, Ny) #square lattice NN = nb.NN_sqr(coor) NNb = nb.Bound_Arr(coor) Gam_SC = Gam_SC_factor * Gam H_J = spop.HBDG(coor=coor, ax=ax, ay=ay, NN=NN, NNb=NNb, Wj=Wj_int, cutxT=cutxT, cutyB=cutyB, cutxB=cutxB, cutyT=cutyT, Vj=Vj, Vsc=Vsc, mu=mu, gamx=Gam, alpha=alp_l, delta=delta, phi=phi, qx=kx, meff_sc=m_eff, meff_normal=m_eff, plot_junction=plot_junction) Gs, Gb, sNRG_bot = bot_SC_sNRG_calc(omega=omega, Wj=Wj, Lx=Lx, cutxT=cutxT, cutxB=cutxB, ax=ax, ay=ay, kx=kx, m_eff=m_eff, alp_l=alp_l, alp_t=alp_t, mu=mu, Gam_SC=Gam_SC, delta=delta, phi=phi, iter=iter, eta=eta) Gs, Gb, sNRG_top = top_SC_sNRG_calc(omega=omega, Wj=Wj, Lx=Lx, cutxT=cutxT, cutxB=cutxB, ax=ax, ay=ay, kx=kx, m_eff=m_eff, alp_l=alp_l, alp_t=alp_t, mu=mu, Gam_SC=Gam_SC, delta=delta, phi=phi, iter=iter, eta=eta) #print(H_J.shape) #print(sNRG_top.shape) #print(sNRG_bot.shape) H_eff = H_J + sNRG_bot + sNRG_top return H_eff
Wj = 10 #Junction region cutx = 0 #width of nodule cuty = 0 #height of nodule Nx, Ny, cutx, cuty, Wj = check.junction_geometry_check(Nx, Ny, cutx, cuty, Wj) print("Nx = {}, Ny = {}, cutx = {}, cuty = {}, Wj = {}".format(Nx, Ny, cutx, cuty, Wj)) Junc_width = Wj*ay*.10 #nm SC_width = ((Ny - Wj)*ay*.10)/2 #nm Nod_widthx = cutx*ax*.1 #nm Nod_widthy = cuty*ay*.1 #nm print("Nodule Width in x-direction = ", Nod_widthx, "(nm)") print("Nodule Width in y-direction = ", Nod_widthy, "(nm)") print("Junction Width = ", Junc_width, "(nm)") print("Supercondicting Lead Width = ", SC_width, "(nm)") ###################################################coor = shps.square(Nx, Ny) #square lattice coor = shps.square(Nx, Ny) #square lattice NN = nb.NN_sqr(coor) NNb = nb.Bound_Arr(coor) lat_size = coor.shape[0] Lx = (max(coor[:, 0]) - min(coor[:, 0]) + 1)*ax #Unit cell size in x-direction Ly = (max(coor[:, 1]) - min(coor[:, 1]) + 1)*ay #Unit cell size in y-direction ################################################### #Defining Hamiltonian parameters alpha = 100 #Spin-Orbit Coupling constant: [meV*A] phi = np.pi #SC phase difference delta = 1 #Superconducting Gap: [meV] Vsc = 0 #Amplitude of potential in SC region: [meV] Vj = 0 #Amplitude of potential in junction region: [meV] V = Vjj(coor, Wj = Wj, Vsc = Vsc, Vj = Vj, cutx = cutx, cuty = cuty)
import majoranaJJ.operators.sparse.qmsops as spop #sparse operators import majoranaJJ.operators.dense.qmdops as dpop #dense operators print(" ") N = range(3, 20) t_sparse = np.zeros(len(N)) t_dense = np.zeros(len(N)) ax = 2 ay = 2 for i in range(0, len(N)): Nx = N[i] #incrementing size of lattice Ny = N[i] #incrementing size of lattice coor = shps.square(Nx, Ny) #creating coordinate array NN = nbrs.NN_Arr(coor) #nearest neighbor array NNb = nbrs.Bound_Arr(coor) #boundary array H_sparse = spop.H0(coor, ax, ay, NN) #creating sparse hamiltonian start = time.time() #Time start for numpy H_dense = dpop.H0(coor, ax, ay, NN) #creating dense hamiltonian eigs, vecs = LA.eigh(H_dense) #diagonalizing end = time.time() #Time end for numpy t_dense[i] = end-start #append time taken to diagonalize start = time.time() #Time start for scipy
import majoranaJJ.operators.sparse.qmsops as spop #sparse operators import majoranaJJ.lattice.nbrs as nb #neighbor arrays import majoranaJJ.lattice.shapes as shps #lattice shapes import majoranaJJ.modules.plots as plots #plotting functions Ny = 25 #number of lattice sites in y direction Nx = 25 #number of lattice sites in x direction N = Ny * Nx print(N) coor = shps.square(Nx, Ny) #square coordinate array NN = nb.NN_Arr(coor) #nearest neighbor array of square lattice NN2 = nb.NN_sqr(coor) NNb = nb.Bound_Arr(coor) Lx = int(max(coor[:, 0]) + 1) idx = 2 * Lx - 1 plots.lattice(idx, coor, NN=NN) plots.lattice(idx, coor, NN=NN2) plots.lattice(idx, coor, NNb=NNb)
import scipy.sparse.linalg as spLA import majoranaJJ.lattice.nbrs as nb #neighbor arrays import majoranaJJ.lattice.shapes as shps #lattice shapes import majoranaJJ.modules.plots as plots #plotting functions #Compared packages import majoranaJJ.operators.sparse.qmsops as spop #sparse operators import majoranaJJ.operators.dense.qmdops as dpop #dense operators Nx = 50 Ny = 50 ax = 2 ay = 2 coor = shps.square(Nx, Ny) NN = nb.NN_Arr(coor) NNb = nb.Bound_Arr(coor) H_sparse = spop.H0(coor, ax, ay, NN) H_dense = dpop.H0(coor, ax, ay, NN) start = time.time() eigs, vecs = LA.eigh(H_dense) end = time.time() t_dense = end - start print( "DENSE time for diagonalization for Hamiltonian of size {} = ".format( H_dense.shape), t_dense, "[s]")
import time import majoranaJJ.lattice.shapes as shps #lattice shapes import majoranaJJ.junk.lattice.neighbors as nb2 import majoranaJJ.lattice.nbrs as nb #neighbor arrays import majoranaJJ.modules.plots as plots #plotting functions print("") N = 50 #Making square lattice, nothing has changed with this method. #Finding neighbor array in the unit cell for the old method to find boundary array. coor = shps.square(N, N) NN = nb.NN_Arr(coor) print("size: ", coor.shape[0]) print("") ################################### #Using old method, scaled by N^2 due to a loop within a loop start = time.time() NNb2 = nb2.Bound_Arr(NN, coor) end = time.time() print("Time to create Bound_Arr with original method = {} [s]".format(end - start)) print(NNb2[0:5, :]) idx = 0 plots.lattice(idx, coor, NNb=NNb2) print(" ") ###################################
from numpy import linalg as LA import majoranaJJ.operators.densOP as dop import majoranaJJ.lattice.neighbors as nb import majoranaJJ.lattice.shapes as shps import majoranaJJ.etc.plots as plot ax = 10 #unit cell size along x-direction in [A] ay = 10 #unit cell size along y-direction in [A] Nx = 50 Ny = 50 coor = shps.square(Nx, Ny) #donut coordinate array NN = nb.NN_Arr(coor) NNb = nb.Bound_Arr(coor) print("lattice size", coor.shape[0]) """ This Hamiltonians is defined in operators/densOP.py. The basis is of spin up and spin down, so for a system without spin coupling the wavefunctions should only be different for every other excited state """ alpha = 0.0 #Spin-Orbit Coupling constant: [eV*A] gammaz = 0 #Zeeman field energy contribution: [T] V0 = 0.0 #Amplitude of potential : [eV] mu = 0 #Chemical Potential: [eV] H_dense = dop.H0(coor, ax, ay, NN, mu=mu, gammaz=gammaz, alpha=alpha) print("H shape: ", H_dense.shape) energy_dense, states_dense = LA.eigh(H_dense) n = 0 plot.state_cmap(coor, energy_dense,