def precise_spin_chern(h,delta=0.00001,tol=0.1):
""" Calculates the chern number of a 2d system """
from scipy import integrate
err = {"epsabs" : 0.01, "epsrel": 0.01,"limit" : 20}
sz = operators.get_sz(h) # get sz operator
def f(x,y): # function to integrate
return operator_berry(h,np.array([x,y]),delta=delta,operator=sz)
c = integrate.dblquad(f,0.,1.,lambda x : 0., lambda x: 1.,epsabs=tol,
epsrel=tol)
return c[0]/(2.*np.pi)
def write_spin_berry(h, kpath, delta=0.00001):
"""Calculate and write in file the Berry curvature"""
sz = operators.get_sz(h) # get sz operator
be = [operator_berry(h, k=k, operator=sz, delta=delta) for k in kpath]
fo = open("BERRY_CURVATURE_SZ.OUT", "w") # open file
for (k, b) in zip(kpath, be):
fo.write(str(k[0]) + " ")
fo.write(str(k[1]) + " ")
fo.write(str(b) + "\n")
fo.close() # close file
def write_spin_berry(h,kpath,delta=0.00001,operator=None):
"""Calculate and write in file the Berry curvature"""
if operator is None: sz = operators.get_sz(h) # get sz operator
else: sz = operator # assign operator
be = [operator_berry(h,k=k,operator=sz,delta=delta) for k in kpath]
fo = open("BERRY_CURVATURE_SZ.OUT","w") # open file
for (k,b) in zip(kpath,be):
fo.write(str(k[0])+" ")
fo.write(str(k[1])+" ")
fo.write(str(b)+"\n")
fo.close() # close file
def berry_bands(h,klist=None,mode=None,operator=None):
"""Calculate band structure resolved with Berry curvature"""
ks = [] # list of kpoints
if mode is not None: # get the mode
if mode=="sz": operator = operators.get_sz(h)
else: raise
fo = open("BANDS.OUT","w")
for ik in range(len(klist)): # loop over kpoints
(es,bs) = topology.operator_berry_bands(h,k=klist[ik],operator=operator)
for (e,b) in zip(es,bs):
fo.write(str(ik)+" "+str(e)+" "+str(b)+"\n")
fo.close()
def berry_bands(h, klist=None, mode=None, operator=None):
"""Calculate band structure resolved with Berry curvature"""
ks = [] # list of kpoints
if mode is not None: # get the mode
if mode == "sz": operator = operators.get_sz(h)
else: raise
fo = open("BANDS.OUT", "w")
for ik in range(len(klist)): # loop over kpoints
(es, bs) = topology.operator_berry_bands(h,
k=klist[ik],
operator=operator)
for (e, b) in zip(es, bs):
fo.write(str(ik) + " " + str(e) + " " + str(b) + "\n")
fo.close()
def precise_spin_chern(h, delta=0.00001, tol=0.1):
""" Calculates the chern number of a 2d system """
from scipy import integrate
err = {"epsabs": 0.01, "epsrel": 0.01, "limit": 20}
sz = operators.get_sz(h) # get sz operator
def f(x, y): # function to integrate
return operator_berry(h, np.array([x, y]), delta=delta, operator=sz)
c = integrate.dblquad(f,
0.,
1.,
lambda x: 0.,
lambda x: 1.,
epsabs=tol,
epsrel=tol)
return c[0] / (2. * np.pi)
def spin_chern(h,nk=40,delta=0.00001,k0=[0.,0.],expandk=1.0):
"""Calculate the spin Chern number"""
kxs = np.linspace(-.5,.5,nk,endpoint=False)*expandk + k0[0]
kys = np.linspace(-.5,.5,nk,endpoint=False)*expandk + k0[1]
kk = [] # list of kpoints
for i in kxs:
for j in kys:
kk.append(np.array([i,j])) # store vector
sz = operators.get_sz(h) # get sz operator
bs = [operator_berry(h,k=ki,operator=sz,delta=delta) for ki in kk] # get all berries
fo = open("BERRY_CURVATURE_SZ.OUT","w") # open file
for (k,b) in zip(kk,bs):
fo.write(str(k[0])+" ")
fo.write(str(k[1])+" ")
fo.write(str(b)+"\n")
fo.close() # close file
bs = np.array(bs)/(2.*np.pi) # normalize by 2 pi
return sum(bs)/len(kk)
def spin_chern(h, nk=40, delta=0.00001, k0=[0., 0.], expandk=1.0):
"""Calculate the spin Chern number"""
kxs = np.linspace(-.5, .5, nk, endpoint=False) * expandk + k0[0]
kys = np.linspace(-.5, .5, nk, endpoint=False) * expandk + k0[1]
kk = [] # list of kpoints
for i in kxs:
for j in kys:
kk.append(np.array([i, j])) # store vector
sz = operators.get_sz(h) # get sz operator
bs = [operator_berry(h, k=ki, operator=sz, delta=delta)
for ki in kk] # get all berries
fo = open("BERRY_CURVATURE_SZ.OUT", "w") # open file
for (k, b) in zip(kk, bs):
fo.write(str(k[0]) + " ")
fo.write(str(k[1]) + " ")
fo.write(str(b) + "\n")
fo.close() # close file
bs = np.array(bs) / (2. * np.pi) # normalize by 2 pi
return sum(bs) / len(kk)
def get_operator(self, name, projector=False):
"""Return a certain operator"""
if name == "sx": return operators.get_sx(self)
elif name == "sy": return operators.get_sy(self)
elif name == "sz": return operators.get_sz(self)
elif name == "sublattice":
return operators.get_sublattice(self, mode="both")
elif name == "sublatticeA":
return operators.get_sublattice(self, mode="A")
elif name == "sublatticeB":
return operators.get_sublattice(self, mode="B")
elif name == "interface":
return operators.get_interface(self)
elif name == "spair":
return operators.get_pairing(self, ptype="s")
elif name == "deltax":
return operators.get_pairing(self, ptype="deltax")
elif name == "deltay":
return operators.get_pairing(self, ptype="deltay")
elif name == "deltaz":
return operators.get_pairing(self, ptype="deltaz")
elif name == "electron":
return operators.get_electron(self)
elif name == "hole":
return operators.get_hole(self)
elif name == "zposition":
return operators.get_zposition(self)
elif name == "yposition":
return operators.get_yposition(self)
elif name == "xposition":
return operators.get_xposition(self)
elif name == "velocity":
return operators.get_velocity(self)
# total magnetizations
elif name == "mx":
return self.get_operator("sx") * self.get_operator("electron")
elif name == "my":
return self.get_operator("sy") * self.get_operator("electron")
elif name == "mz":
return self.get_operator("sz") * self.get_operator("electron")
elif name == "valley":
return operators.get_valley(self, projector=projector)
elif name == "inplane_valley":
return operators.get_inplane_valley(self)
elif name == "valley_upper":
print("This operator only makes sense for TBG")
ht = self.copy()
ht.geometry.sublattice = self.geometry.sublattice * (
np.sign(self.geometry.z) + 1.0) / 2.0
return operators.get_valley(ht)
elif name == "inplane_valley_upper":
print("This operator only makes sense for TBG")
ht = self.copy()
ht.geometry.sublattice = self.geometry.sublattice * (
np.sign(self.geometry.z) + 1.0) / 2.0
return operators.get_inplane_valley(ht)
elif name == "valley_lower":
print("This operator only makes sense for TBG")
ht = self.copy()
ht.geometry.sublattice = self.geometry.sublattice * (
-np.sign(self.geometry.z) + 1.0) / 2.0
return operators.get_valley(ht)
else:
raise
g = geometry.diamond_lattice_minimal(
) # get the three dimensional diamond lattice
g = films.geometry_film(g, nz=20) # create a film
h = g.get_hamiltonian(is_multicell=True) # create hamiltonian
def get_hamiltonian():
"""Hamiltonian for parameter p"""
h = g.get_hamiltonian(is_multicell=True,
is_sparse=False) # create hamiltonian
def step(z, width=0.00001):
"""This will yield 0 for z<0 and 1 for z>0"""
out = (-np.tanh(z / width) + 1.0) / 2. # this is the interpolator
return out
h.add_antiferromagnetism(lambda r: 0.7 * step(r[2]), axis=[0., 0., 1.])
h.shift_fermi(lambda r: 1. * (-step(r[2], width=0.0001) + 1.0))
h.add_swave(lambda r: 0.4 * (-step(r[2]) + 1.0))
h.add_kane_mele(0.05)
return h
h = get_hamiltonian()
h.get_bands(operator=operators.get_sz(h))
import kdos
#kdos.kdos_bands(h,delta=0.01)
# zigzag ribbon
import sys
sys.path.append("../../../pygra") # add pygra library
import geometry
import scftypes
import operators
g = geometry.honeycomb_zigzag_ribbon(4) # create geometry of a zigzag ribbon
h = g.get_hamiltonian() # create hamiltonian of the system
mf = scftypes.guess(h, "ferro", fun=lambda r: [0., 0., 1.])
scf = scftypes.selfconsistency(h,
nkp=30,
filling=0.5,
mf=mf,
mode="Hubbard collinear")
h = scf.hamiltonian # get the Hamiltonian
#op = operators.get_sz(h)
#print(op.shape)
#h.add_zeeman([0.,0.,4])
h.get_bands(operator=operators.get_sz(h)) # calculate band structure
#print(scf.magnetization)
h.write()