def honeycomb2squareMoS2(h,check=True):
"""Transforms a honeycomb lattice into a square lattice"""
ho = deepcopy(h) # output geometry
g = h.geometry # geometry
go = deepcopy(g) # output geometry
go.a1 = g.a1 + g.a2
go.a2 = g.a1 - g.a2
# now put the first vector along the x axis
go.r = np.concatenate([g.r,g.r + g.a1])
go.r2xyz()
go = sculpt.rotate_a2b(go,go.a1,np.array([1.,0.,0.]))
# perform a check to see if the supercell is well built
a1a2 = go.a1.dot(go.a2)
# if a1a2>0.001:
if np.abs(go.a1)[1]>0.001 or np.abs(go.a2[0])>0.001:
ang = go.a1.dot(go.a2)
print("The projection of lattice vectors is",ang)
if check: raise
go.r2xyz() # update r atribbute
zero = csc(h.tx*0.)
# define sparse
intra = csc(h.intra)
tx = csc(h.tx)
ty = csc(h.ty)
txy = csc(h.txy)
txmy = csc(h.txmy)
# define new hoppings
ho.intra = bmat([[intra,tx],[tx.H,intra]]).todense()
ho.tx = bmat([[txy,zero],[ty,txy]]).todense()
ho.ty = bmat([[txmy,zero],[ty.H,txmy]]).todense()
ho.txy = bmat([[zero,zero],[tx,zero]]).todense()
ho.txmy = bmat([[zero,zero],[zero,zero]]).todense()
ho.geometry = go
return ho
def honeycomb2squareMoS2(h,check=True):
"""Transforms a honeycomb lattice into a square lattice"""
ho = deepcopy(h) # output geometry
g = h.geometry # geometry
go = deepcopy(g) # output geometry
go.a1 = g.a1 + g.a2
go.a2 = g.a1 - g.a2
# now put the first vector along the x axis
go.r = np.concatenate([g.r,g.r + g.a1])
go.r2xyz()
go = sculpt.rotate_a2b(go,go.a1,np.array([1.,0.,0.]))
# perform a check to see if the supercell is well built
a1a2 = go.a1.dot(go.a2)
# if a1a2>0.001:
if np.abs(go.a1)[1]>0.001 or np.abs(go.a2[0])>0.001:
ang = go.a1.dot(go.a2)
print("The projection of lattice vectors is",ang)
if check: raise
go.r2xyz() # update r atribbute
zero = csc(h.tx*0.)
# define sparse
intra = csc(h.intra)
tx = csc(h.tx)
ty = csc(h.ty)
txy = csc(h.txy)
txmy = csc(h.txmy)
# define new hoppings
ho.intra = bmat([[intra,tx],[tx.H,intra]]).todense()
ho.tx = bmat([[txy,zero],[ty,txy]]).todense()
ho.ty = bmat([[txmy,zero],[ty.H,txmy]]).todense()
ho.txy = bmat([[zero,zero],[tx,zero]]).todense()
ho.txmy = bmat([[zero,zero],[zero,zero]]).todense()
ho.geometry = go
return ho
def supercell1d(g, nsuper):
"""Creates a supercell of the system"""
# get the old geometry
y = g.y
x = g.x
z = g.z
celldis = g.a1[0]
if np.abs(g.a1.dot(g.a1) - g.a1[0]**2) > 0.001:
print("Something weird in supercell 1d")
return supercell1d(sculpt.rotate_a2b(g, g.a1, np.sqrt([1., 0., 0.])))
# position of the supercell
yout = []
xout = []
for i in range(nsuper):
yout += y.tolist()
xout += (x + i * celldis).tolist()
# now modify the geometry
go = deepcopy(g)
go.x = np.array(xout)
go.y = np.array(yout)
# and shift to zero
go.z = np.array(z.tolist() * nsuper)
go.center() # center the unit cell
go.celldis = celldis * nsuper
go.a1 = g.a1 * nsuper # supercell
go.xyz2r() # update r
if g.has_sublattice: # if has sublattice, keep the indexes
go.sublattice = np.concatenate([g.sublattice for i in range(nsuper)
]) # store the keeped atoms
# print(nsuper)
if g.atoms_have_names: # supercell sublattice
go.atoms_names = g.atoms_names * nsuper
return go
def bulk2ribbon(h,n=10):
"""Converts a hexagonal bulk hamiltonian into a ribbon hamiltonian"""
go = h.geometry.copy() # copy geometry
ho = h.copy() # copy hamiltonian
ho.dimensionality = 1 # reduce dimensionality
ho.geometry.dimensionality = 1 # reduce dimensionality
intra = [[None for i in range(n)] for j in range(n)]
inter = [[None for i in range(n)] for j in range(n)]
for i in range(n): # to the the sam index
intra[i][i] = csc(h.intra)
inter[i][i] = csc(h.tx)
for i in range(n-1): # one more or less
intra[i][i+1] = csc(h.ty)
intra[i+1][i] = csc(h.ty.H)
inter[i+1][i] = csc(h.txmy)
inter[i][i+1] = csc(h.txy)
ho.intra = bmat(intra).todense()
ho.inter = bmat(inter).todense()
# calculate the angle
import sculpt
go = sculpt.rotate_a2b(go,go.a1,np.array([1.,0.,0.]))
ho.geometry.celldis = go.a1[0] # first eigenvector
r = []
for i in range(n):
for ri in go.r:
r.append(ri+i*go.a2)
ho.geometry.r = np.array(r)
ho.geometry.r2xyz() # get r positions
return ho
def build_island(h, n=5, angle=30, nedges=6):
""" Build an island starting from a 2d geometry"""
gin = geometry.triangular_lattice() # create lattice
angle = sculpt.get_angle(h.geometry.a1, h.geometry.a2) / np.pi * 180
if np.abs(angle - 60) < 1.: gin.a2 = -gin.a2 # change the unit cell
g = sculpt.build_island(gin, n=n, angle=angle, nedges=nedges,
clear=False) # get the island
angle2 = sculpt.get_angle(gin.a1, gin.a2) / np.pi * 180
if np.abs(angle - angle2) > 1.: raise # error in the angles
gh = sculpt.rotate_a2b(h.geometry, h.geometry.a1,
gin.a1) # use the same axis
# now define a function to select the correct hopping
(w1, w2, w3) = sculpt.reciprocal(gin.a1, gin.a2) # get reciprocal vectors
def get_rij(r):
"""Provide a vector r, return this vector expressed in the basis cell"""
i = r.dot(w1) # first projection
j = r.dot(w2) # second projection
return i, j # return indexes
# turn into multicell
if not h.is_multicell: h = multicell.turn_multicell(h)
h.turn_sparse() # convert into sparse
intra = [[None for ri in g.r] for rj in g.r]
# loop over the skeleton
for i in range(len(g.r)): # loop over i
ri = g.r[i]
for j in range(len(g.r)): # loop over j
rj = g.r[j]
vi, vj = get_rij(ri - rj) # get the vector
if np.abs(vi) > 2 or np.abs(vj) > 2: continue
m = multicell.get_tij(h, rij=np.array([vi, vj,
0])) # return the matrix
intra[i][j] = m # store in the matrix
# fic the new hamiltonian
ho = h.copy() # copy hamiltonian object
from scipy.sparse import bmat
ho.dimensionality = 0 # zero dimensional
ho.intra = bmat(intra) # store hamiltonian
# fix the new geometry
go = h.geometry.copy() # copy the original geometry
go.dimensionality = 0 # zero dimensional
rs = [] # empty list
for rd in g.r:
for r in h.geometry.r:
vi, vj = get_rij(rd) # get the vector
ri = r + vi * h.geometry.a1 + vj * h.geometry.a2
rs.append(ri) # append the vector
rs = np.array(rs) # convert to array
go.r = rs # store
if go.atoms_have_names: # if the atoms have names, expand
go.atoms_names = go.atoms_names * len(g.r) # enlarge the list
go.r2xyz() # fill the xyz values
ho.geometry = go # store in the hamiltonian
go.write()
return ho
def build_island(h,n=5,angle=30,nedges=6):
""" Build an island starting from a 2d geometry"""
gin = geometry.triangular_lattice() # create lattice
angle = sculpt.get_angle(h.geometry.a1,h.geometry.a2)/np.pi*180
if np.abs(angle-60)<1.: gin.a2 = -gin.a2 # change the unit cell
g = sculpt.build_island(gin,n=n,angle=angle,nedges=nedges,clear=False) # get the island
angle2 = sculpt.get_angle(gin.a1,gin.a2)/np.pi*180
if np.abs(angle-angle2)>1.: raise # error in the angles
gh = sculpt.rotate_a2b(h.geometry,h.geometry.a1,gin.a1) # use the same axis
# now define a function to select the correct hopping
(w1,w2,w3) = sculpt.reciprocal(gin.a1,gin.a2) # get reciprocal vectors
def get_rij(r):
"""Provide a vector r, return this vector expressed in the basis cell"""
i = r.dot(w1) # first projection
j = r.dot(w2) # second projection
return i,j # return indexes
# turn into multicell
if not h.is_multicell: h = multicell.turn_multicell(h)
h.turn_sparse() # convert into sparse
intra = [[None for ri in g.r] for rj in g.r ]
# loop over the skeleton
for i in range(len(g.r)): # loop over i
ri = g.r[i]
for j in range(len(g.r)): # loop over j
rj = g.r[j]
vi,vj = get_rij(ri-rj) # get the vector
if np.abs(vi)>2 or np.abs(vj)>2: continue
m = multicell.get_tij(h,rij=np.array([vi,vj,0])) # return the matrix
intra[i][j] = m # store in the matrix
# fic the new hamiltonian
ho = h.copy() # copy hamiltonian object
from scipy.sparse import bmat
ho.dimensionality = 0 # zero dimensional
ho.intra = bmat(intra) # store hamiltonian
# fix the new geometry
go = h.geometry.copy() # copy the original geometry
go.dimensionality = 0 # zero dimensional
rs = [] # empty list
for rd in g.r:
for r in h.geometry.r:
vi,vj = get_rij(rd) # get the vector
ri = r +vi*h.geometry.a1 + vj*h.geometry.a2
rs.append(ri) # append the vector
rs = np.array(rs) # convert to array
go.r = rs # store
if go.atoms_have_names: # if the atoms have names, expand
go.atoms_names = go.atoms_names*len(g.r) # enlarge the list
go.r2xyz() # fill the xyz values
ho.geometry = go # store in the hamiltonian
go.write()
return ho
def hamiltonian_ribbon(hin, n=10):
"""Return the Hamiltonian of a film"""
h = hin.copy() # copy Hamiltonian
import multicell
h = multicell.supercell_hamiltonian(h, nsuper=[1, n, 1])
hopout = [] # list
for i in range(len(h.hopping)): # loop over hoppings
if abs(h.hopping[i].dir[2]) < 0.1:
if abs(h.hopping[i].dir[1]) < 0.1:
hopout.append(h.hopping[i])
h.hopping = hopout
h.dimensionality = 1
h.geometry.dimensionality = 1
import sculpt
h.geometry = sculpt.rotate_a2b(h.geometry, h.geometry.a1,
np.array([1., 0., 0.]))
return h
def bulk2ribbon(hin, n=10, sparse=True, nxt=6, ncut=6):
""" Create a ribbon hamiltonian object"""
if not hin.is_multicell: h = turn_multicell(hin)
else: h = hin # nothing othrwise
hr = h.copy() # copy hamiltonian
if sparse: hr.is_sparse = True # sparse output
hr.dimensionality = 1 # reduce dimensionality
# stuff about geometry
hr.geometry = h.geometry.supercell((1, n)) # create supercell
hr.geometry.dimensionality = 1
hr.geometry.a1 = h.geometry.a1 # add the unit cell vector
import sculpt # rotate the geometry
hr.geometry = sculpt.rotate_a2b(hr.geometry, hr.geometry.a1,
np.array([1., 0., 0.]))
hr.geometry.celldis = hr.geometry.a1[0]
def superhopping(dr=[0, 0, 0]):
""" Return a matrix with the hopping of the supercell"""
intra = [[None for i in range(n)] for j in range(n)] # intracell term
for ii in range(n): # loop over ii
for jj in range(n): # loop over jj
d = np.array([dr[0], ii - jj + dr[1], dr[2]])
if d.dot(d) > ncut * ncut: continue # skip iteration
m = get_tij(h, rij=d) # get the matrix
if m is not None: intra[ii][jj] = csc_matrix(m) # store
else:
if ii == jj: intra[ii][jj] = csc_matrix(h.intra * 0.)
intra = bmat(intra) # convert to matrix
if not sparse: intra = intra.todense() # dense matrix
return intra
# get the intra matrix
hr.intra = superhopping()
# now do the same for the interterm
hoppings = [] # list of hopings
for i in range(-nxt, nxt + 1): # loop over hoppings
if i == 0: continue # skip the 0
d = np.array([i, 0., 0.])
hopp = Hopping() # create object
hopp.m = superhopping(dr=d) # get hopping of the supercell
hopp.dir = d
hoppings.append(hopp)
hr.hopping = hoppings # store the list
hr.dimensionality = 1
return hr
def orthogonalize_geometry(g):
go = deepcopy(g) # output geometry
go.a1 = g.a1 + g.a2
go.a2 = g.a1 - g.a2
# now put the first vector along the x axis
go.r = np.concatenate([g.r,g.r + g.a1])
go.r2xyz()
go = sculpt.rotate_a2b(go,go.a1,np.array([1.,0.,0.]))
# perform a check to see if the supercell is well built
a1a2 = go.a1.dot(go.a2)
# if a1a2>0.001:
if np.abs(go.a1)[1]>0.001 or np.abs(go.a2[0])>0.001:
ang = go.a1.dot(go.a2)
print("The projection of lattice vectors is",ang)
if check: raise
go.has_sublattice = False
go.r2xyz() # update r atribbute
return go
def bulk2ribbon(hin,n=10,sparse=True,nxt=6,ncut=6):
""" Create a ribbon hamiltonian object"""
if not hin.is_multicell: h = turn_multicell(hin)
else: h = hin # nothing othrwise
hr = h.copy() # copy hamiltonian
if sparse: hr.is_sparse = True # sparse output
hr.dimensionality = 1 # reduce dimensionality
# stuff about geometry
hr.geometry = h.geometry.supercell((1,n)) # create supercell
hr.geometry.dimensionality = 1
hr.geometry.a1 = h.geometry.a1 # add the unit cell vector
import sculpt # rotate the geometry
hr.geometry = sculpt.rotate_a2b(hr.geometry,hr.geometry.a1,np.array([1.,0.,0.]))
hr.geometry.celldis = hr.geometry.a1[0]
def superhopping(dr=[0,0,0]):
""" Return a matrix with the hopping of the supercell"""
intra = [[None for i in range(n)] for j in range(n)] # intracell term
for ii in range(n): # loop over ii
for jj in range(n): # loop over jj
d = np.array([dr[0],ii-jj+dr[1],dr[2]])
if d.dot(d)>ncut*ncut: continue # skip iteration
m = get_tij(h,rij=d) # get the matrix
if m is not None: intra[ii][jj] = csc_matrix(m) # store
else:
if ii==jj: intra[ii][jj] = csc_matrix(h.intra*0.)
intra = bmat(intra) # convert to matrix
# print intra
if not sparse: intra = intra.todense() # dense matrix
return intra
# get the intra matrix
hr.intra = superhopping()
# now do the same for the interterm
hoppings = [] # list of hopings
for i in range(-nxt,nxt+1): # loop over hoppings
if i==0: continue # skip the 0
d = np.array([i,0.,0.])
hopp = Hopping() # create object
hopp.m = superhopping(dr=d) # get hopping of the supercell
hopp.dir = d
hoppings.append(hopp)
hr.hopping = hoppings # store the list
return hr
def hamiltonian_bulk2ribbon(h, n=10, sparse=False, check=True):
"""Converts a hexagonal bulk hamiltonian into a ribbon hamiltonian"""
from scipy.sparse import csc_matrix as csc
from scipy.sparse import bmat
go = h.geometry.copy() # copy geometry
ho = h.copy() # copy hamiltonian
if np.abs(go.a1.dot(go.a2)) > 0.01:
if check: raise # if axis non orthogonal
ho.dimensionality = 1 # reduce dimensionality
ho.geometry.dimensionality = 1 # reduce dimensionality
intra = [[None for i in range(n)] for j in range(n)]
inter = [[None for i in range(n)] for j in range(n)]
for i in range(n): # to the the sam index
intra[i][i] = csc(h.intra)
inter[i][i] = csc(h.tx)
for i in range(n - 1): # one more or less
intra[i][i + 1] = csc(h.ty)
intra[i + 1][i] = csc(h.ty.H)
inter[i + 1][i] = csc(h.txmy)
inter[i][i + 1] = csc(h.txy)
if sparse:
ho.intra = bmat(intra)
ho.inter = bmat(inter)
ho.is_sparse = True # hamiltonian is sparse
else:
ho.intra = bmat(intra).todense()
ho.inter = bmat(inter).todense()
# calculate the angle
import sculpt
go = sculpt.rotate_a2b(go, go.a1, np.array([1., 0., 0.]))
ho.geometry.celldis = go.a1[0] # first eigenvector
r = []
for i in range(n):
for ri in go.r:
r.append(ri + i * go.a2)
ho.geometry.r = np.array(r)
ho.geometry.r2xyz() # get r positions
ho.geometry.center()
ho.dimensionality = 1
# for geometries with names
if ho.geometry.atoms_have_names:
ho.geometry.atoms_names = ho.geometry.atoms_names * n
return ho
def bulk2ribbon(g, boundary=[1, 0], n=10, clean=True):
"""Return the geometry of a ribbon"""
go = g.copy() # copy
m = [[boundary[0], boundary[1], 0], [0, 1, 0], [0, 0, 1]] # supercell
if boundary[0] != 1 or boundary[1] != 0:
go = supercell.non_orthogonal_supercell(go, m, mode="brute")
go = go.supercell((1, n)) # create a supercell
go = sculpt.rotate_a2b(go, go.a1, np.array([1., 0., 0.]))
go.dimensionality = 1 # zero dimensional
go.a2 = np.array([0., 1., 0.])
if clean:
go = go.clean(iterative=True)
if len(go.r) == 0:
print("Ribbon is not wide enough")
raise
go.real2fractional()
go.fractional2real()
go.celldis = go.a1[0]
go.center()
return go
def hamiltonian_bulk2ribbon(h, n=10, sparse=False, check=True):
"""Converts a hexagonal bulk hamiltonian into a ribbon hamiltonian"""
from scipy.sparse import csc_matrix as csc
from scipy.sparse import bmat
go = h.geometry.copy() # copy geometry
ho = h.copy() # copy hamiltonian
# if np.abs(go.a1.dot(go.a2))>0.01:
# if check: raise # if axis non orthogonal
ho.dimensionality = 1 # reduce dimensionality
ho.geometry.dimensionality = 1 # reduce dimensionality
intra = [[None for i in range(n)] for j in range(n)]
inter = [[None for i in range(n)] for j in range(n)]
for i in range(n): # to the the sam index
intra[i][i] = csc(h.intra)
inter[i][i] = csc(h.tx)
for i in range(n - 1): # one more or less
intra[i][i + 1] = csc(h.ty)
intra[i + 1][i] = csc(h.ty.H)
inter[i + 1][i] = csc(h.txmy)
inter[i][i + 1] = csc(h.txy)
if sparse:
ho.intra = bmat(intra)
ho.inter = bmat(inter)
ho.is_sparse = True # hamiltonian is sparse
else:
ho.intra = bmat(intra).todense()
ho.inter = bmat(inter).todense()
# calculate the angle
import sculpt
ho.geometry = sculpt.rotate_a2b(ho.geometry, ho.geometry.a1,
np.array([1., 0., 0.]))
ho.geometry = h.geometry.supercell((1, n)) # create supercell
ho.geometry.dimensionality = 1
ho.geometry.a1 = h.geometry.a1 # add the unit cell vector
ho.dimensionality = 1
# for geometries with names
if ho.geometry.atoms_have_names:
ho.geometry.atoms_names = ho.geometry.atoms_names * n
return ho
def hamiltonian_bulk2ribbon(h,n=10,sparse=False,check=True):
"""Converts a hexagonal bulk hamiltonian into a ribbon hamiltonian"""
from scipy.sparse import csc_matrix as csc
from scipy.sparse import bmat
go = h.geometry.copy() # copy geometry
ho = h.copy() # copy hamiltonian
if np.abs(go.a1.dot(go.a2))>0.01:
if check: raise # if axis non orthogonal
ho.dimensionality = 1 # reduce dimensionality
ho.geometry.dimensionality = 1 # reduce dimensionality
intra = [[None for i in range(n)] for j in range(n)]
inter = [[None for i in range(n)] for j in range(n)]
for i in range(n): # to the the sam index
intra[i][i] = csc(h.intra)
inter[i][i] = csc(h.tx)
for i in range(n-1): # one more or less
intra[i][i+1] = csc(h.ty)
intra[i+1][i] = csc(h.ty.H)
inter[i+1][i] = csc(h.txmy)
inter[i][i+1] = csc(h.txy)
if sparse:
ho.intra = bmat(intra)
ho.inter = bmat(inter)
ho.is_sparse = True # hamiltonian is sparse
else:
ho.intra = bmat(intra).todense()
ho.inter = bmat(inter).todense()
# calculate the angle
import sculpt
go = sculpt.rotate_a2b(go,go.a1,np.array([1.,0.,0.]))
ho.geometry.celldis = go.a1[0] # first eigenvector
r = []
for i in range(n):
for ri in go.r:
r.append(ri+i*go.a2)
ho.geometry.r = np.array(r)
ho.geometry.r2xyz() # get r positions
ho.geometry.center()
return ho
def hamiltonian_bulk2ribbon(h,n=10,sparse=False,check=True):
"""Converts a hexagonal bulk hamiltonian into a ribbon hamiltonian"""
from scipy.sparse import csc_matrix as csc
from scipy.sparse import bmat
go = h.geometry.copy() # copy geometry
ho = h.copy() # copy hamiltonian
# if np.abs(go.a1.dot(go.a2))>0.01:
# if check: raise # if axis non orthogonal
ho.dimensionality = 1 # reduce dimensionality
ho.geometry.dimensionality = 1 # reduce dimensionality
intra = [[None for i in range(n)] for j in range(n)]
inter = [[None for i in range(n)] for j in range(n)]
for i in range(n): # to the the sam index
intra[i][i] = csc(h.intra)
inter[i][i] = csc(h.tx)
for i in range(n-1): # one more or less
intra[i][i+1] = csc(h.ty)
intra[i+1][i] = csc(h.ty.H)
inter[i+1][i] = csc(h.txmy)
inter[i][i+1] = csc(h.txy)
if sparse:
ho.intra = bmat(intra)
ho.inter = bmat(inter)
ho.is_sparse = True # hamiltonian is sparse
else:
ho.intra = bmat(intra).todense()
ho.inter = bmat(inter).todense()
# calculate the angle
import sculpt
ho.geometry = sculpt.rotate_a2b(ho.geometry,ho.geometry.a1,np.array([1.,0.,0.]))
ho.geometry = h.geometry.supercell((1,n)) # create supercell
ho.geometry.dimensionality = 1
ho.geometry.a1 = h.geometry.a1 # add the unit cell vector
ho.dimensionality = 1
# for geometries with names
if ho.geometry.atoms_have_names:
ho.geometry.atoms_names = ho.geometry.atoms_names*n
return ho
def triangular_ribbon(n):
g = triangular_lattice() # create geometry
go = g.copy() # copy geometry
r0 = [] # empty list
for ir in g.r:
r0.append(ir) # supercell
r0.append(ir + g.a1) # supercell
rs = []
dr = g.a1 + g.a2 # displacement vector
for i in range(n): # loop over replicas
for ir in r0: # loop over unit cell
rs.append(dr * i + ir) # append atom
go.r = np.array(rs) # save coordinates
go.r2xyz() # update
go.a1 = g.a1 - g.a2 #
go.center()
go.dimensionality = 1
# now rotate the geometry
import sculpt
go = sculpt.rotate_a2b(go, go.a1, np.array([1.0, 0.0, 0.0]))
# setup the cell dis parameter (deprecated)
go.celldis = go.a1[0]
return go
def triangular_ribbon(n):
g = triangular_lattice() # create geometry
go = g.copy() # copy geometry
r0 = [] # empty list
for ir in g.r:
r0.append(ir) # supercell
r0.append(ir+g.a1) # supercell
rs = []
dr = g.a1+g.a2 # displacement vector
for i in range(n): # loop over replicas
for ir in r0: # loop over unit cell
rs.append(dr*i + ir) # append atom
go.r = np.array(rs) # save coordinates
go.r2xyz() # update
go.a1 = g.a1 - g.a2 #
go.center()
go.dimensionality = 1
# now rotate the geometry
import sculpt
go = sculpt.rotate_a2b(go,go.a1,np.array([1.0,0.0,0.0]))
# setup the cell dis parameter (deprecated)
go.celldis = go.a1[0]
return go
def build_ribbon(hin,g=None,n=20):
""" Build a supercell using a certain geometry as skeleton"""
if g is None: # if skeleton not provided
h.geometry.get_lattice_name()
if h.geometry.lattice_name=="square": # square lattice
g = geometry.square_ribbon(n)
else: raise # not implemented
# now build the hamiltonian
h = hin.copy() # generate hamiltonian
# if the hamiltonian is not multicell, turn it so
if not h.is_multicell: h = multicell.turn_multicell(h)
gin = h.geometry # geometry of the hamiltonian input
# use the same axis
gh = sculpt.rotate_a2b(h.geometry,h.geometry.a1,np.array([0.,1.,0.]))
# if np.abs(h.geometry.a1.dot(h.geometry.a2)) > 0.01: raise # orthogonal
# gh = h.geometry
def normalize(v): # normalize a vector
return v/np.sqrt(v.dot(v))
# get reciprocal vectors
(w1,w2,w3) = sculpt.reciprocal(normalize(gh.a1),normalize(gh.a2))
# exit()
def get_rij(r):
"""Provide a vector r, return this vector expressed in the basis cell"""
i = r.dot(w1) # first projection
j = r.dot(w2) # second projection
i,j = round(i),round(j)
print i,j
return [i,j,0] # return indexes
ho = h.copy() # generate hamiltonian
intra = [[None for i in range(len(g.r))] for j in range(len(g.r))]
hoppings = [] # empty list for the hoppings
for i in range(len(g.r)): # loop over positions
intra[i][i] = h.intra # intracell hopping
for i in range(len(g.r)): # hopping up to third cells
for j in range(len(g.r)): # hopping up to third cells
rij = g.r[i] - g.r[j] # distance between replicas
intra[i][j] = multicell.get_tij(h,rij=get_rij(rij))
ho.intra = csc_matrix(bmat(intra)) # add the intracell matrix
for nn in [-3,-2,-1,1,2,3]: # hopping up to third cells
inter = [[None for i in range(len(g.r))] for j in range(len(g.r))]
print "Next"
for i in range(len(g.r)): # hopping up to third cells
for j in range(len(g.r)): # hopping up to third cells
rij = g.r[i] - g.r[j] # distance between replicas
rij += nn*h.geometry.a1 # add the displacement
if i==j: # for diagonal, at least zeros
mm = multicell.get_tij(h,rij=get_rij(rij))
if mm is None: inter[i][j] = h.intra*0.0 # store zero
else: inter[i][j] = mm # store matrix
else: inter[i][j] = multicell.get_tij(h,rij=get_rij(rij))
hopping = multicell.Hopping() # create object
hopping.m = csc_matrix(bmat(inter)) # store matrix
hopping.dir = np.array([nn,0.,0.]) # store vector
hoppings.append(hopping) # store hopping
gout = g.copy() # copy geometry for the hamiltonian
rs = []
for jr in g.r: # loop over skeleton geometry
for ir in h.geometry.r: # loop over basis
rs.append(ir + jr[0]*h.geometry.a1 + jr[1]*h.geometry.a2)
gout.r = np.array(rs) # store
gout.r2xyz() # update
gout.celldis = h.geometry.a1[0] # this has to be well done
ho.geometry = gout # assign geometry
ho.hopping = hoppings # store the full hoppings list
ho.dimensionality = 1 # one dimensional
ho.is_multicell = True # multicell Hamiltonian
ho.is_sparse = True # sparse Hamiltonian
return ho # return ribbon hamiltonian
