def __call__(self, energy, flag=None):
if self.data_path is not None and flag is not None:
nid = int(flag[2:])
nid += self.nid_plus
flag = str(flag[:2]) + str(nid)
fd = file(self.data_path[self.direction] + '/' +
self.direction + '/' + flag, 'r')
data = cPickle.load(fd)
return data
else:
if self.energy is None or abs(energy - self.energy) > self.tol:
self.energy = energy
z = energy - self.bias
tau_ij = z * self.hsd_ij.S[self.pk].recover() - \
self.hsd_ij.H[self.s][self.pk].recover()
tau_ji = z * dagger(self.hsd_ij.S[self.pk].recover()) - \
dagger(self.hsd_ij.H[self.s][self.pk].recover())
ginv = self.get_sgfinv(energy)
a_ij = dot(ginv, tau_ij)
mat = dot(tau_ji, a_ij)
#if self.rotation_mat is not None:
# mat = np.dot(self.rotation_mat, mat)
# mat = np.dot(mat, self.rotation_mat.T)
self.sigma = Banded_Sparse_Matrix(complex, mat,
self.hsd_ii.S[self.pk].band_index)
return self.sigma
def __call__(self, energy, flag=None):
if self.data_path is not None and flag is not None:
nid = int(flag[2:])
nid += self.nid_plus
flag = str(flag[:2]) + str(nid)
fd = file(
self.data_path[self.direction] + '/' + self.direction + '/' +
flag, 'r')
data = cPickle.load(fd)
return data
else:
if self.energy is None or abs(energy - self.energy) > self.tol:
self.energy = energy
z = energy - self.bias
tau_ij = z * self.hsd_ij.S[self.pk].recover() - \
self.hsd_ij.H[self.s][self.pk].recover()
tau_ji = z * dagger(self.hsd_ij.S[self.pk].recover()) - \
dagger(self.hsd_ij.H[self.s][self.pk].recover())
ginv = self.get_sgfinv(energy)
a_ij = dot(ginv, tau_ij)
mat = dot(tau_ji, a_ij)
#if self.rotation_mat is not None:
# mat = np.dot(self.rotation_mat, mat)
# mat = np.dot(mat, self.rotation_mat.T)
self.sigma = Banded_Sparse_Matrix(
complex, mat, self.hsd_ii.S[self.pk].band_index)
return self.sigma
def calculate_dos(self, tp, s, k, energy, nid_flag=None):
self.reset_selfenergy(tp, s, k)
self.reset_green_function(tp, s, k)
sigma = self.calculate_sigma(tp, s, k, energy, nid_flag)
gr = self.calculate_green_function_of_k_point(tp, s, k, energy, sigma)
dos = -np.imag(np.diag(dot(gr, tp.hsd.S[k].recover()))) / np.pi
return dos
def calculate_dos(self, tp, s, k, energy, nid_flag=None):
self.reset_selfenergy(tp, s, k)
self.reset_green_function(tp, s, k)
sigma = self.calculate_sigma(tp, s, k, energy, nid_flag)
gr = self.calculate_green_function_of_k_point(tp, s, k, energy, sigma)
dos = - np.imag(np.diag(dot(gr, tp.hsd.S[k].recover()))) / np.pi
return dos
def test_inv_eq(self, tol=1e-9):
tp_mat = copy.deepcopy(self)
tp_mat.inv_eq()
mol_h = dot(tp_mat.mol_h.recover(), self.mol_h.recover())
for i in range(self.lead_num):
mol_h += dot(tp_mat.upc_h[i][0], self.dwnc_h[i][0])
diff = np.max(abs(mol_h - np.eye(mol_h.shape[0])))
if diff > tol:
print 'warning, mol_diff', diff
for i in range(self.lead_num):
for j in range(self.lead_nlayer[i] - 2):
diag_h = dot(tp_mat.diag_h[i][j].recover(),
self.diag_h[i][j].recover())
diag_h += dot(tp_mat.dwn_h[i][j], self.upc_h[i][j])
diag_h += dot(tp_mat.upc_h[i][j + 1], self.dwnc_h[i][j + 1])
diff = np.max(abs(diag_h - np.eye(diag_h.shape[0])))
if diff > tol:
print 'warning, diag_diff', i, j, diff
j = self.lead_nlayer[i] - 2
diag_h = dot(tp_mat.diag_h[i][j].recover(),
self.diag_h[i][j].recover())
diag_h += dot(tp_mat.dwnc_h[i][j], self.upc_h[i][j])
diff = np.max(abs(diag_h - np.eye(diag_h.shape[0])))
if diff > tol:
print 'warning, diag_diff', i, j, diff
def calculate_transmission(self, tp, s, k, energy, nid_flag=None):
self.reset_selfenergy(tp, s, k)
self.reset_green_function(tp, s, k)
sigma = self.calculate_sigma(tp, s, k, energy, nid_flag)
gamma = self.get_gamma(tp, sigma)
trans_coff = []
for i, lead_pair in enumerate(self.lead_pairs):
l1, l2 = lead_pair
if i == 0:
gr_sub, inv_mat = tp.hsd.abstract_sub_green_matrix(
energy, sigma, l1, l2)
else:
gr_sub = tp.hsd.abstract_sub_green_matrix(
energy, sigma, l1, l2, inv_mat)
transmission = dot(dot(gamma[l1], gr_sub),
dot(gamma[l2], gr_sub.T.conj()))
trans_coff.append(np.real(np.trace(transmission)))
trans_coff = np.array(trans_coff)
return trans_coff
def calculate_transmission(self, tp, s, k, energy, nid_flag=None):
self.reset_selfenergy(tp, s, k)
self.reset_green_function(tp, s, k)
sigma = self.calculate_sigma(tp, s, k, energy, nid_flag)
gamma = self.get_gamma(tp, sigma)
trans_coff = []
for i, lead_pair in enumerate(self.lead_pairs):
l1, l2 = lead_pair
if i == 0:
gr_sub, inv_mat = tp.hsd.abstract_sub_green_matrix(
energy, sigma, l1, l2)
else:
gr_sub = tp.hsd.abstract_sub_green_matrix(energy,
sigma, l1, l2, inv_mat)
transmission = dot(dot(gamma[l1], gr_sub),
dot(gamma[l2], gr_sub.T.conj()))
trans_coff.append(np.real(np.trace(transmission)))
trans_coff = np.array(trans_coff)
return trans_coff
def inv_eq(self):
q_mat = []
for i in range(self.lead_num):
q_mat.append([])
nll = self.lead_nlayer[i]
for j in range(nll - 1):
q_mat[i].append([])
end = nll - 2
q_mat[i][end] = self.diag_h[i][end].inv()
for j in range(end - 1, -1, -1):
self.diag_h[i][j].reset_minus(self.dotdot(
self.upc_h[i][j + 1],
q_mat[i][j + 1],
self.dwnc_h[i][j + 1]), full=True)
q_mat[i][j] = self.diag_h[i][j].inv()
h_mm = self.mol_h
for i in range(self.lead_num):
h_mm.reset_minus(self.dotdot(self.upc_h[i][0], q_mat[i][0],
self.dwnc_h[i][0]), full=True)
inv_h_mm = h_mm.inv()
h_mm.reset(inv_h_mm)
for i in range(self.lead_num):
tmp_dc = self.dwnc_h[i][0].copy()
self.dwnc_h[i][0] = -self.dotdot(q_mat[i][0], tmp_dc, inv_h_mm)
self.upc_h[i][0] = -self.dotdot(inv_h_mm, self.upc_h[i][0],
q_mat[i][0])
dim = len(self.ll_index[i][1])
self.diag_h[i][0].reset(dot(q_mat[i][0], np.eye(dim) -
dot(tmp_dc, self.upc_h[i][0])))
for j in range(1, self.lead_nlayer[i] - 1):
tmp_dc = self.dwnc_h[i][j].copy()
self.dwnc_h[i][j] = -self.dotdot(q_mat[i][j], tmp_dc,
self.diag_h[i][j - 1].recover())
self.upc_h[i][j] = -self.dotdot(self.diag_h[i][j - 1].recover(),
self.upc_h[i][j],
q_mat[i][j])
dim = len(self.ll_index[i][j + 1])
self.diag_h[i][j].reset(dot(q_mat[i][j], np.eye(dim) -
dot(tmp_dc, self.upc_h[i][j])))
def get_sgfinv(self, energy):
"""The inverse of the retarded surface Green function"""
z = energy - self.bias
v_00 = Banded_Sparse_Matrix(complex,
None,
self.hsd_ii.S[self.pk].band_index)
v_00.reset_from_others(self.hsd_ii.S[self.pk],
self.hsd_ii.H[self.s][self.pk],
z, -1.0)
v_11 = copy.deepcopy(v_00)
v_10 = z * self.hsd_ij.S[self.pk].recover()- \
self.hsd_ij.H[self.s][self.pk].recover()
v_01 = z * dagger(self.hsd_ij.S[self.pk].recover()) - \
dagger(self.hsd_ij.H[self.s][self.pk].recover())
delta = self.conv + 1
while delta > self.conv:
inv_v_11 = v_11.inv()
a = dot(inv_v_11, v_01)
b = dot(inv_v_11, v_10)
v_01_dot_b = dot(v_01, b)
v_00.reset_minus(v_01_dot_b, full=True)
v_11.reset_minus(dot(v_10, a), full=True)
v_11.reset_minus(v_01_dot_b, full=True)
v_01 = -dot(v_01, a)
v_10 = -dot(v_10, b)
delta = np.abs(v_01).max()
return v_00.inv()
def get_sgfinv(self, energy):
"""The inverse of the retarded surface Green function"""
z = energy - self.bias
v_00 = Banded_Sparse_Matrix(complex, None,
self.hsd_ii.S[self.pk].band_index)
v_00.reset_from_others(self.hsd_ii.S[self.pk],
self.hsd_ii.H[self.s][self.pk], z, -1.0)
v_11 = copy.deepcopy(v_00)
v_10 = z * self.hsd_ij.S[self.pk].recover()- \
self.hsd_ij.H[self.s][self.pk].recover()
v_01 = z * dagger(self.hsd_ij.S[self.pk].recover()) - \
dagger(self.hsd_ij.H[self.s][self.pk].recover())
delta = self.conv + 1
while delta > self.conv:
inv_v_11 = v_11.inv()
a = dot(inv_v_11, v_01)
b = dot(inv_v_11, v_10)
v_01_dot_b = dot(v_01, b)
v_00.reset_minus(v_01_dot_b, full=True)
v_11.reset_minus(dot(v_10, a), full=True)
v_11.reset_minus(v_01_dot_b, full=True)
v_01 = -dot(v_01, a)
v_10 = -dot(v_10, b)
delta = np.abs(v_01).max()
return v_00.inv()
def dotdot(self, mat1, mat2, mat3):
return dot(mat1, dot(mat2, mat3))
