def get_MFTchi(self, kx, ky, chi):
J = self.J
chi_k = -0.75 * chi * (cos(kx) + cos(ky)) * J
chi_kQ = -chi_k
chi_normal = general_kron(chi_k, sigma_up) + general_kron(
chi_kQ, sigma_dn)
chi_nambu = kron(sigma3, chi_normal)
return chi_nambu
def get_Hk0(self, kx, ky):
t = self.hopping
Ek1 = t[1] * (cos(kx) + cos(ky)) * 2
Ek2 = t[0] * cos(kx / 2) * cos(
ky / 2) * 4 + t[2] * cos(kx) * cos(ky) * 4
Hk0 = general_kron(Ek1, sigma0) + general_kron(Ek2, sigma1)
# pdb.set_trace()
return Hk0
def get_MFThk0(self, kx, ky, doping):
Ek = self.get_Hk0(kx, ky)
kx_Q = kx + pi
ky_Q = ky + pi
Ek_Q = self.get_Hk0(kx_Q, ky_Q)
hk0 = general_kron(Ek, sigma_up) + general_kron(Ek_Q, sigma_dn)
# pdb.set_trace()
hk0 = hk0 * doping
hk0_nambu = kron(sigma3, hk0)
return hk0_nambu
def continum_model_graphene(self, k, twisted_angle):
fermi_velocity = 1.
t3 = cos(twisted_angle / 2) * sigma0 + 1j * sigma3 * sin(
twisted_angle / 2)
s1 = dot(dot(t3, sigma1), t3.conj())
s2 = dot(dot(t3, sigma2), t3.conj())
Hk = general_kron(k[..., 0], s1) + general_kron(k[..., 1], s2)
# Ek,Uk = linalg.eigh(Hk)
# pdb.set_trace()
return Hk
def get_MFTdelta(self, kx, ky, delta):
J = self.J
sigma_c = (sigma1 + 1j * sigma2) / 2
sigma_a = (sigma1 - 1j * sigma2) / 2
delta_k = -0.75 * delta * (cos(kx) - cos(ky)) * J
delta_kQ = -delta_k
delta_normal = general_kron(delta_k, sigma_up) + general_kron(
delta_kQ, sigma_dn)
delta_nambu = kron(sigma_c, delta_normal) + kron(
sigma_a, delta_normal.conj())
# pdb.set_trace()
return delta_nambu
def get_twisted_tba(self, kmesh, t_tunnel, lambda_tunnel):
hk = self.get_tba(kmesh)
bond = self.single_honeycomb() + array([1, 0])
xk, yk = 0, 0
for b in bond:
xk = xk + cos(kmesh.dot(b))
yk = yk + sin(kmesh.dot(b))
xk = xk * t_tunnel * lambda_tunnel
yk = yk * t_tunnel * lambda_tunnel
Tunneling = general_kron(xk, sigma1) - general_kron(
yk, sigma2) + t_tunnel * array([[1, 0], [0, 0]])
Hk = kron(hk, sigma0) + kron(Tunneling, sigma1)
return Hk
def get_Hk0_intralayer(
self,
kx,
ky,
):
t = self.hopping
Ek1 = t[1] * (cos(kx) + cos(ky)) * 2
Ek2 = t[0] * cos(kx / 2) * cos(
ky / 2) * 4 + t[2] * cos(kx) * cos(ky) * 4
h = diag([1, 1, 1.])
deltaE = diag([0, self.deltaE, 0])
H1 = general_kron(Ek1, h) - deltaE
H2 = general_kron(Ek2, h)
Hk0 = kron(sigma0, H1) + kron(sigma1, H2)
return Hk0
def get_Hk_delta(self, kx, ky, delta):
J = self.J
phase = -sin(kx / 2) * sin(ky / 2)
delta_k = delta * J * phase * (-3. / 2.)
hk0_delta = general_kron(delta_k, sigma1)
hk0_delta = kron(sigma1, hk0_delta)
return hk0_delta
def get_Hk_delta(self, kx, ky, delta123):
J = self.J
phase = -sin(kx / 2) * sin(ky / 2)
delta = diag(delta123)
Hk0_delta = general_kron(phase, -delta * J * 3 / 2.)
Hk0_delta = kron(sigma1, Hk0_delta)
Hk0_delta = kron(sigma1, Hk0_delta)
return Hk0_delta
def get_Hk_chi(self, kx, ky, chi123):
J = self.J
phase = cos(kx / 2) * cos(ky / 2)
chi = diag(chi123)
Hk0_chi = general_kron(phase, -chi * J * 3 / 2.)
Hk0_chi = kron(sigma1, Hk0_chi)
Hk0_chi = kron(sigma3, Hk0_chi)
return Hk0_chi
def get_Hk0_interlayer(self, kx, ky):
t_inter = self.interhopping * sin(kx / 2)**2 * sin(ky / 2)**2
h = zeros([3, 3])
h[0, 1] = 1
h[1, 2] = 1
h = h + h.T
Hk0 = general_kron(t_inter, h)
Hk0 = kron(sigma1, Hk0)
return Hk0
def get_Hk_chi(self, kx, ky, chi):
J = self.J
phase = cos(kx / 2) * cos(ky / 2)
# chi_r = chi.real*J*phase*(-3./2.)
# chi_i = chi.imag*J*phase*(-3./2.)
# hk0_chi = general_kron(chi_r, sigma1) - general_kron(chi_i, sigma2)
# hk0_chi = kron(sigma_up, hk0_chi) - kron(sigma_dn, hk0_chi.transpose(0,1,3,2))
chi_k = chi * J * phase * (-3. / 2.)
hk0_chi = general_kron(chi_k, sigma1)
hk0_chi = kron(sigma3, hk0_chi)
# pdb.set_trace()
return hk0_chi
def get_tba(self, k):
alpha = self.alpha
betha = self.betha
mu, t1 = self.mu, self.t1
angle = 2 * pi / 3
alpha = alpha[:-1]
betha = betha[:-1]
delta1 = (alpha + betha) / 3
delta2 = rotate(angle).dot(delta1)
delta3 = -delta1 - delta2
#print delta1,delta2,delta3
phi1 = k.dot(delta1)
phi2 = k.dot(delta2)
phi3 = k.dot(delta3)
xk = -t1 * (cos(phi1) + cos(phi2) + cos(phi3))
yk = -t1 * (sin(phi1) + sin(phi2) + sin(phi3))
#pdb.set_trace()
hk = general_kron(xk, sigma1)
hk = hk - general_kron(yk, sigma2)
hk += -mu * sigma0
return hk
def get_Hk(self, k):
t = array([140.5, -595.1, 163.6, -51.9, -111.7, 51.]) / 1000.
delta0 = 0.042
kx = k[0]
ky = k[1]
Ek=t[0]+t[1]*(cos(kx)+cos(ky))/2.+t[2]*cos(kx)*cos(ky)+t[3]*(cos(2*kx)+cos(2*ky))/2.\
+t[4]*(cos(2*kx)*cos(ky)+cos(kx)*cos(2*ky))/2.+t[5]*cos(2*kx)*cos(2*ky)
#
delta = delta0 * (cos(kx) - cos(ky)) / 2.
Hk = general_kron(Ek, sigma3) - general_kron(delta, sigma1)
# delta = delta0
# Hk = general_kron(Ek,sigma3) + delta0*sigma1
plt.pcolormesh(kx, ky, Ek[...])
plt.axis('equal')
plt.colorbar()
plt.contour(kx, ky, Ek[...], levels=[-0., -0. + 1e-4])
plt.show()
#k = self.get_kmesh()
# t=array([-155,100,36,10,1.5])/1000.
#t=array([130.5,-590.8,96.2,-130.6,-50.7,93.9])/1000.
return Hk
def get_TBG_model(self, kmesh, t2, tt1, tt2):
hk = self.get_tba(kmesh)
bondnnn = zeros([6, 2])
bondnnn[0] = array([0, sqrt(3)])
r_nnn = rotate(pi / 3)
for i in xrange(1, 6):
bondnnn[i] = r_nnn.dot(bondnnn[i - 1])
bondnn = zeros([3, 2])
bondnn[0] = (self.alpha + self.betha)[:-1] / 3
r_nn = rotate(2 * pi / 3)
for i in xrange(1, 3):
bondnn[i] = r_nn.dot(bondnn[i - 1])
isigma2 = 1j * sigma2
sigmap = (sigma1 + isigma2) / 2.
sigmam = sigmap.T.conj()
warp_nnn = 0.
fsign = array([1, -1, 1, -1, 1, -1.])
for i in xrange(6):
phi = kmesh.dot(bondnnn[i])
warp_nnn = warp_nnn + general_kron(exp(1j * phi),
sigma0) * fsign[i]
warp_nnn = warp_nnn * tt2
# fsign = fsign*1j; hop_nnn = 0.
# for i in xrange(6):
# phi = kmesh.dot(bondnnn[i])
# hop_nnn = hop_nnn + general_kron(exp(1j*phi),sigma0)*fsign[i]
# hop_nnn *= tt1
bondnnn = zeros([6, 2])
bondnnn[0] = array([1., 0])
for i in xrange(1, 6):
bondnnn[i] = r_nnn.dot(bondnnn[i - 1])
hop = 0.
for i in xrange(6):
phi = kmesh.dot(bondnnn[i])
hop = hop + general_kron(exp(1j * phi), sigma0)
hop *= t2
hop_nn = 0.
for i in xrange(3):
bond = bondnn[i] * sqrt(3)
xx = bond[0]**2
yy = bond[1]**2
xy = bond[0] * bond[1]
sigma_orbital = array([[xx - yy, 2 * xy], [2 * xy, yy - xx]])
phi = kmesh.dot(bondnn[i])
hop_xy = general_kron(cos(phi), sigma1) - general_kron(
sin(phi), sigma2)
hop_nn = hop_nn + kron(sigma_orbital, hop_xy)
hop_nn *= tt1
Hk = 0.
Hk = Hk + kron(sigma0, hk)
Hk = Hk + kron(isigma2, warp_nnn)
Hk = Hk + kron(sigma0, hop)
# Hk = Hk + kron(sigma0,hop_nnn)
Hk = Hk + hop_nn
# pdb.set_trace()
return Hk
