Esempio n. 1
0
 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
Esempio n. 2
0
 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
Esempio n. 3
0
 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
Esempio n. 5
0
 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
Esempio n. 7
0
 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
Esempio n. 8
0
 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
Esempio n. 9
0
 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
Esempio n. 10
0
 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
Esempio n. 11
0
 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
Esempio n. 12
0
 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
Esempio n. 14
0
    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