def calc_q_mean(S_list, i, j):
'''
'''
global dims
global Weyl
global r_list, t_list
q_mean_list = []
for w in range(nfreq):
s = S_list[i, j][3 * w:3 * w + 3]
Q = scat.calc_Q(s, dk)[0]
qlist = ut.sort_eig(Q)[0]
r = r_list[i, 3 * w:3 * w + 3, j, 0:dims[w], 0:dims[w]]
t = t_list[i, 3 * w:3 * w + 3, j, 0:dims[w], 0:dims[w]]
Q_eigstates = (ut.sort_eig(Q)[1].T)
# qmax = np.sum(
# np.absolute(np.dot(r[1], state_max))**2 * \
# ( np.angle(np.dot(r[2], state_max)) - np.angle(np.dot(r[0], state_max)) ) / (2*dk) +\
# np.absolute(np.dot(t[1], state_max))**2 * \
# ( np.angle(np.dot(t[2], state_max)) - np.angle(np.dot(t[0], state_max)) ) / (2*dk)
# )
for n, state in enumerate(Q_eigstates):
qman = np.sum(
np.absolute(np.dot(s[1], state))**2 * \
( np.angle(np.dot(s[2], state)) - np.angle(np.dot(s[0], state)) ) / (2*dk)
)
#print np.shape(t[2]), np.shape(t[0]), np.shape(state), np.shape(state[0:dims[w]]),
tran = (np.linalg.norm(np.dot(t[0], state[0:dims[w]]))**2,
np.linalg.norm(np.dot(t[1], state[0:dims[w]]))**2,
np.linalg.norm(np.dot(t[2], state[0:dims[w]]))**2)
refl = (np.linalg.norm(np.dot(r[2], state[0:dims[w]]))**2,
np.linalg.norm(np.dot(r[0], state[0:dims[w]]))**2)
if (abs((qman - qlist[n]) / qlist[n]) > 0.01):
print "TIME", i, j, w, n, qman, qlist[n]
qlist[n] = abs(qman)
if (abs((tran[1] - tran[0]) / tran[0]) > 0.001 or abs(
(tran[2] - tran[1]) / tran[1]) > 0.001):
print "TRANS", i, j, w, n, tran[1], tran[0], qman
qmax = 0.0 * qlist[-1]
#qmax = 100000.0*Weyl[0]
sdiff = np.array([
s[0] * np.exp(imag_i * qmax * dk), s[1],
s[2] * np.exp(-imag_i * qmax * dk)
])
Qdiff = scat.calc_Q(sdiff, dk)[0]
#qlist[-1] = ut.sort_eig(Qdiff)[0][-1] + qmax
#qlist = ut.sort_eig(Qdiff)[0] + qmax
q_mean = np.sum(qlist)
q_mean_list.append(q_mean)
return q_mean_list
def calc_q_mean(S_list, i, j):
'''
'''
global dims
global Weyl
global r_list, t_list
q_mean_list=[]
for w in range(nfreq):
s = S_list[i,j][3*w:3*w+3]
Q = scat.calc_Q(s,dk)[0]
qlist = ut.sort_eig(Q)[0]
r = r_list[i,3*w:3*w+3,j,0:dims[w],0:dims[w]]
t = t_list[i,3*w:3*w+3,j,0:dims[w],0:dims[w]]
Q_eigstates = (ut.sort_eig(Q)[1].T)
# qmax = np.sum(
# np.absolute(np.dot(r[1], state_max))**2 * \
# ( np.angle(np.dot(r[2], state_max)) - np.angle(np.dot(r[0], state_max)) ) / (2*dk) +\
# np.absolute(np.dot(t[1], state_max))**2 * \
# ( np.angle(np.dot(t[2], state_max)) - np.angle(np.dot(t[0], state_max)) ) / (2*dk)
# )
for n, state in enumerate(Q_eigstates):
qman = np.sum(
np.absolute(np.dot(s[1], state))**2 * \
( np.angle(np.dot(s[2], state)) - np.angle(np.dot(s[0], state)) ) / (2*dk)
)
#print np.shape(t[2]), np.shape(t[0]), np.shape(state), np.shape(state[0:dims[w]]),
tran = ( np.linalg.norm(np.dot(t[0], state[0:dims[w]]))**2,
np.linalg.norm(np.dot(t[1], state[0:dims[w]]))**2,
np.linalg.norm(np.dot(t[2], state[0:dims[w]]))**2 )
refl = ( np.linalg.norm(np.dot(r[2], state[0:dims[w]]))**2, np.linalg.norm(np.dot(r[0], state[0:dims[w]]))**2 )
if ( abs((qman-qlist[n])/qlist[n]) > 0.01 ):
print "TIME", i, j, w, n, qman, qlist[n]
qlist[n] = abs(qman)
if ( abs((tran[1]-tran[0])/tran[0]) > 0.001 or
abs((tran[2]-tran[1])/tran[1]) > 0.001):
print "TRANS", i, j, w, n, tran[1], tran[0], qman
qmax = 0.0*qlist[-1]
#qmax = 100000.0*Weyl[0]
sdiff = np.array([s[0] * np.exp(imag_i*qmax*dk), s[1], s[2] * np.exp(-imag_i*qmax*dk)])
Qdiff = scat.calc_Q(sdiff,dk)[0]
#qlist[-1] = ut.sort_eig(Qdiff)[0][-1] + qmax
#qlist = ut.sort_eig(Qdiff)[0] + qmax
q_mean = np.sum(qlist)
q_mean_list.append(q_mean)
return q_mean_list
def calc_q_eigv(S_list, i, j, w):
'''
Calculates traces of Q operators of S matrices stored in S_list.
If imaginary part of the traces are too high, their value is set
to 0 and the number of configurations at this radius and frequency
is decremented by 1.
'''
s = S_list[i,j][3*w:3*w+3]
return ut.sort_eig(scat.calc_Q(s,dk)[0])[0].real
def write_teigvals(t_q, refpos):
'''
Write t-eigenvalues at reference frequency to file.
'''
teigval = ut.sort_eig(t_q[3 * (refpos) + 1])[0]
np.savetxt(
data_direc + "teigvals." + filen + ".dat",
np.array([range(np.shape(teigval)[0]), teigval.real,
teigval.imag]).transpose())
def calc_q_eigv(S_list, i, j, w):
'''
Calculates traces of Q operators of S matrices stored in S_list.
If imaginary part of the traces are too high, their value is set
to 0 and the number of configurations at this radius and frequency
is decremented by 1.
'''
s = S_list[i,j][3*w:3*w+3]
return ut.sort_eig(scat.calc_Q(s,dk)[0])[0].real
def calc_eigensystem(a, modes):
'''
Calculcate eigenvalues, right eigenvectors and left eigenvectors of matrix a.
Eigenvectors are store column-wise and inflated by appending zeros
to size modes x modes.
'''
aeigval, aeigvec = ut.sort_eig(a)
aeigvec = aeigvec.transpose()
aLeigvec = np.linalg.inv(aeigvec).transpose()
aeigvec = scat.inflate_small_mat(aeigvec, modes)
aLeigvec = scat.inflate_small_mat(aLeigvec, modes)
return aeigval, aeigvec, aLeigvec
def calc_eigensystem(a, modes):
'''
Calculcate eigenvalues, right eigenvectors and left eigenvectors of matrix a.
Eigenvectors are store column-wise and inflated by appending zeros
to size modes x modes.
'''
aeigval, aeigvec = ut.sort_eig(a)
aeigvec = aeigvec.transpose()
aLeigvec = np.linalg.inv(aeigvec).transpose()
aeigvec = scat.inflate_small_mat(aeigvec, modes)
aLeigvec = scat.inflate_small_mat(aLeigvec, modes)
return aeigval, aeigvec, aLeigvec
print "Composing block %i of %i" % (block+1,Nseg),
Seg, comp = compose_block(Slist, dims, Nseg)
Seglist.append(Seg) # get new segments by composing old segments to blocks
print comp
Slist = Seglist # define blocks as new segments
Slist = np.array(Slist)
S = Slist[0]
print
print "Transmission eigenvalues at center frequency:"
print np.abs(ut.sort_eig(trans.calc_t(S, dims, 1)[0][Nw/2])[0])
print "Reflection eigenvalues at center frequency: "
print np.abs(ut.sort_eig(trans.calc_r(S, dims, 1)[0][Nw/2])[0])
Q = scat.calc_Q((S[3*(Nw/3/2)+0],S[3*(Nw/3/2)+1],S[3*(Nw/3/2)+2]), dw, inv=False)[0]
Q = scat.calc_Q((S[0],S[1],S[2]), dw, inv=False)[0]
print "Time delay eigenvalues at center frequency:"
print ut.sort_eig(Q)[0]
print "Writing output"
create_output(S, energs, filen)
t.append(S[i][m:, 0:m]) # full t-matrix
t_q.append(S[i][m:m + n, 0:n]) # considered part of t-matrix
q = np.array([
scat.calc_Q([t_q[3 * i + 0], t_q[3 * i + 1], t_q[3 * i + 2]], dk,
inv=True)[0] for i in range(Nk)
])
refpos = int(0.5 * (Nk - 1)) # k[refpos] = kmean for odd Nk
### define operators at reference frequency ###
qref = q[refpos]
tref = t_q[3 * refpos + 1]
tinv = np.linalg.inv(tref)
### calculate and sort eigenvalues and left and right eigenvectors of operators ###
qeigval, qeigvec = ut.sort_eig(qref)
teigval, teigvec = ut.sort_eig(tref)
qeigvec = qeigvec.transpose()
teigvec = teigvec.transpose()
modesvec = np.identity(refmodes, dtype="complex")
teigval = ut.sort_eig(t_q[3 * (refpos) + 1])[0]
np.savetxt(
data_direc + "teigvals." + filen + ".dat",
np.array([range(np.shape(teigval)[0]), teigval.real,
teigval.imag]).transpose())
# left eigenvectors are to be calculated before inflating, needed for measure \mu
qLeigvec = np.linalg.inv(qeigvec).transpose()
tLeigvec = np.linalg.inv(teigvec).transpose()
m = dims[i]/2
n = min(m, refmodes)
t.append( S[i][m:,0:m] ) # full t-matrix
t_q.append( S[i][m:m+n,0:n] ) # considered part of t-matrix
q = np.array([scat.calc_Q([t_q[3*i+0],t_q[3*i+1],t_q[3*i+2]], dk, inv=True)[0] for i in range(Nk)])
refpos = int(0.5*(Nk-1)) # k[refpos] = kmean for odd Nk
### define operators at reference frequency ###
qref = q[refpos]
tref = t_q[3*refpos+1]
tinv = np.linalg.inv(tref)
### calculate and sort eigenvalues and left and right eigenvectors of operators ###
qeigval, qeigvec = ut.sort_eig(qref)
teigval, teigvec = ut.sort_eig(tref)
qeigvec = qeigvec.transpose()
teigvec = teigvec.transpose()
modesvec = np.identity(refmodes, dtype="complex")
teigval = ut.sort_eig(t_q[3*(refpos)+1])[0]
np.savetxt(data_direc+"teigvals."+filen+".dat", np.array([range(np.shape(teigval)[0]), teigval.real, teigval.imag]).transpose())
# left eigenvectors are to be calculated before inflating, needed for measure \mu
qLeigvec = np.linalg.inv(qeigvec).transpose()
tLeigvec = np.linalg.inv(teigvec).transpose()
### inflate eigenvectors to maximum size and number by appending zeros ###
qeigvec = scat.inflate_small_mat(qeigvec, modes)
from Scattering import scattering2D as scat
from Utils import utils as ut
import sys
if (len(sys.argv)!=2):
sys.exit("ABORT: filen needed")
filen = str(sys.argv[1]) # namestring of calculation
S_dis, dims, energs = scat.read_S('./', filen+'.dis')
S_clean, dims, energs = scat.read_S('./', filen+'.clean')
dk = np.sqrt(2.0*energs[-1]) - np.sqrt(2.0*energs[-2])
t_dis = []
t_clean = []
for i in range(3):
nin = dims[i]/2
t_dis.append( S_dis[i][nin:,0:nin] )
t_clean.append( S_clean[i][nin:,0:nin] )
Q = scat.calc_Q(S_clean,dk)[0]
Q11 = Q[0:nin,0:nin]
Q11EigVec = ut.sort_eig(Q11)[1]
TransStates = np.dot( np.linalg.inv(t_dis[1]), np.dot( t_clean[1], Q11EigVec ))
ut.write_states(Q11EigVec.T, nin, nin, energs[-2], filen+'.clean')
ut.write_states(TransStates.T, nin, nin, energs[-2], filen+'.dis')
from Utils import utils as ut from Scattering import scattering2D as scat from Packets import transmission as trans Pi = np.pi I = 0. + 1.J nin = 50 nloop = 10000 #np.random.seed(1786) A = np.random.random(size=(nin,nin)) + I * np.random.random(size=(nin,nin)) A = 0.5 * (A + A.conj().T) A = ut.sort_eig(A)[1] A = np.dot( A.conj().T, np.dot( 100*np.diagflat(np.random.random(size=(nin))), A)) #A = A / np.linalg.norm(A) C = np.random.random(size=(nin,nin)) + I * np.random.random(size=(nin,nin)) C = 0.5 * (C + C.conj().T) C = ut.sort_eig(C)[1] C = np.dot( C.conj().T, np.dot( np.diagflat(np.random.random(size=(nin))), C)) #C = C / np.linalg.norm(C) D = np.random.random(size=(nin,nin)) + I * np.random.random(size=(nin,nin)) D = 0.5 * (D + D.conj().T) D = ut.sort_eig(D)[1] D = np.dot( D.conj().T, np.dot( np.diagflat(np.random.random(size=(nin))), D)) #D = D / np.linalg.norm(D) phi = np.random.random(size=(nin)) + I * np.random.random(size=(nin)) phi = phi / np.linalg.norm(phi)
from Utils import utils as ut
from Scattering import scattering2D as scat
from Packets import transmission as trans
Pi = np.pi
I = 0. + 1.J
nin = 50
nloop = 10000
#np.random.seed(1786)
A = np.random.random(size=(nin, nin)) + I * np.random.random(size=(nin, nin))
A = 0.5 * (A + A.conj().T)
A = ut.sort_eig(A)[1]
A = np.dot(A.conj().T,
np.dot(100 * np.diagflat(np.random.random(size=(nin))), A))
#A = A / np.linalg.norm(A)
C = np.random.random(size=(nin, nin)) + I * np.random.random(size=(nin, nin))
C = 0.5 * (C + C.conj().T)
C = ut.sort_eig(C)[1]
C = np.dot(C.conj().T, np.dot(np.diagflat(np.random.random(size=(nin))), C))
#C = C / np.linalg.norm(C)
D = np.random.random(size=(nin, nin)) + I * np.random.random(size=(nin, nin))
D = 0.5 * (D + D.conj().T)
D = ut.sort_eig(D)[1]
D = np.dot(D.conj().T, np.dot(np.diagflat(np.random.random(size=(nin))), D))
#D = D / np.linalg.norm(D)
phi = np.random.random(size=(nin)) + I * np.random.random(size=(nin))
for k in range(nconf):
rp_mat = np.array(S[i,k,1+3*j][dims[j]:2*dims[j],dims[j]:2*dims[j]])
# if transmission so low that somewhere set to zero:
zero_mask = rp_mat == 0.
rp_mat[zero_mask] = 10**(-16)
rp[i,j,k,0:dims[j],0:dims[j]] = rp_mat
elif (fullout):
rp = np.zeros((nr, 3*nfreq, nconf, nin_max, nin_max), dtype='complex')
for i in range(nr):
for j in range(3*nfreq):
for k in range(nconf):
rp_mat = np.array(S[i,k,j][dims[int(j/3)]:2*dims[int(j/3)],dims[int(j/3)]:2*dims[int(j/3)]])
# if transmission so low that somewhere set to zero:
zero_mask = rp_mat == 0.
rp_mat[zero_mask] = 10**(-16)
rp[i,j,k,0:dims[int(j/3)],0:dims[int(j/3)]] = rp_mat
return rp
def calc_tdt_eigvals(t, (nr,nfreq,nconf,nin_max)):
'''Calculate eigenvalues of t^dagger.t from t-matrices'''
tdt_eigvals = np.zeros((nr, nfreq, nconf, nin_max), dtype='complex')
for i in range(nr):
for j in range(nfreq):
for k in range(nconf):
tdt_eigvals[i,j,k] = ut.sort_eig(np.dot(t[i,j,k].T.conj(), t[i,j,k]))[0]
# sometimes transmission so low that somewhere tdt-eigval gets negative
neg_mask = tdt_eigvals < 10**(-16)
tdt_eigvals[neg_mask] = 10**(-16)
return tdt_eigvals
calculate normalized n-th lead mode In Flo's code y-axis points downwards, y=0 is upper egde of lead; modes are chosen such that most upper point is real and positive. ''' chi_n = np.sin((n+1)*np.pi/lead_width * yrange) return np.sqrt(2./lead_width) * chi_n chi = np.array(map(calc_modes, np.arange(0,nin))) def calc_yoperator(chi): '''calculate operator y-d/2 in chi-representation''' return np.dot(chi.conj() * [list(yrange),]*nin, chi.T)*dy y_op = calc_yoperator(chi) y_eigm = ut.sort_eig(y_op)[1].T #y_peaks = np.dot(y_eigm, chi) y_peaks = np.dot(y_eigm, chi) ut.write_states(y_eigm, nin, 'ypeaks') q = scat.calc_Q(t_q, dk, inv=True)[0] q_y = np.dot(y_eigm.conj(), np.dot(q, y_eigm.T)) t_y = np.dot(y_eigm.conj(), np.dot(t_q[1], y_eigm.T)) pos_range = (0, int(0.33*nin-0.5*ptc), int(0.5*nin-0.5*ptc))#, int(0.67*nin-0.5*ptc), nin-ptc) # pos_range: place states to these positions
t = []
t_q = []
for i in np.arange(3*Nk):
m = dims[i]/2
n = min(m, nin)
t.append( S[i][m:,0:m] ) # full t-matrix
t_q.append( S[i][m:m+n,0:n] ) # considered part of t-matrix
q = []
for i in range(Nk):
q.append(scat.calc_Q([t_q[3*i+0],t_q[3*i+1],t_q[3*i+2]], dk, inv=True)[0])
q = np.array(q)
t_q = t_q[::3]
pos = ((-1,0), (-quartpos-1,quartpos), (-centpos,centpos-1))
pos_string = ('full', 'quart', 'cent')
for i, p, s in zip(range(3), pos, pos_string):
KEigVal, KEigVec = ut.sort_eig( np.dot(np.linalg.inv(t_q[p[1]]), t_q[p[0]]) )[:2]
KEigVec = KEigVec.T
KEigVec_L = np.linalg.inv(KEigVec).T
data = np.array([range(nin), (-1.0J*np.log(KEigVal)).real, (-1.0J*np.log(KEigVal)).imag])
np.savetxt('KEigVals.'+filen+'.'+s+'.txt', data.T, fmt=('%3i', '%12.8f', '%12.8f'))
ut.write_states(KEigVec, nin, nin_Max, energs[centpos], filen, s)
pickle.dump((KEigVec, KEigVec_L), open('KEigVecs.%i.p'%i, 'wb'))
wlist = np.sqrt(2.0 * np.array(energs, dtype="float"))
w0 = 0.5 * (wlist[-2] + wlist[1])
dw = w0 * 10**(-8)
refpos = int(0.5 * len(wlist) / 3)
nyout = int(0.5*(modes_min+modes_max)) * pphwl
yvals = np.linspace(0.0,1.0,nyout+2)
ky = (np.arange(refmodes)+1)*np.pi
kx = np.array([np.sqrt(w**2 - ky**2) for w in wlist[1::3]])
lead_funcs = np.sqrt(2.) * np.sin(np.einsum('m,y->ym', ky, yvals))
chi = np.einsum('wm,ym->wym', 1.0/np.sqrt(kx), lead_funcs)
y_op = np.einsum('ym,y,yn->mn', lead_funcs.conj(), yvals, lead_funcs)
y_eigvec = ut.sort_eig(y_op)[1]
y_funcs = np.dot(lead_funcs, ut.sort_eig(y_op)[1]).T
if (pixel):
chi = np.einsum('ym,wm,mn->wyn', lead_funcs, 1.0/np.sqrt(kx), y_eigvec)
dummy, t_q = trans.calc_t(S, dims, refmodes)
if (pixel):
t_q = np.einsum('ij,wik,kl->wjl', y_eigvec.conj(), t_q, y_eigvec)
dt = (t_q[2::3] - t_q[0::3]) / (2*dk)
t = t_q[1::3]
# add random noise with given strength
print "Adding noise"
noisamp = noiserat * np.abs(t_q)
nin_Max = int(0.5 * (modes_max + modes_min)) # nin_Max = n_open_modes
wlist = np.sqrt(2.0 * np.array(energs, dtype="float"))
w0 = 0.5 * (wlist[-2] + wlist[1])
dw = w0 * 10**(-8)
refpos = int(0.5 * len(wlist) / 3)
nyout = int(0.5 * (modes_min + modes_max)) * pphwl
yvals = np.linspace(0.0, 1.0, nyout + 2)
ky = (np.arange(refmodes) + 1) * np.pi
kx = np.array([np.sqrt(w**2 - ky**2) for w in wlist[1::3]])
lead_funcs = np.sqrt(2.) * np.sin(np.einsum('m,y->ym', ky, yvals))
chi = np.einsum('wm,ym->wym', 1.0 / np.sqrt(kx), lead_funcs)
y_op = np.einsum('ym,y,yn->mn', lead_funcs.conj(), yvals, lead_funcs)
y_eigvec = ut.sort_eig(y_op)[1]
y_funcs = np.dot(lead_funcs, ut.sort_eig(y_op)[1]).T
if (pixel):
chi = np.einsum('ym,wm,mn->wyn', lead_funcs, 1.0 / np.sqrt(kx), y_eigvec)
dummy, t_q = trans.calc_t(S, dims, refmodes)
if (pixel):
t_q = np.einsum('ij,wik,kl->wjl', y_eigvec.conj(), t_q, y_eigvec)
dt = (t_q[2::3] - t_q[0::3]) / (2 * dk)
t = t_q[1::3]
# add random noise with given strength
print "Adding noise"
noisamp = noiserat * np.abs(t_q)
noise_full = np.zeros(np.shape(t_q), dtype="complex")
for i in range(Nav):
q = []
for i in range(Nk):
q.append( scat.calc_Q([t_q[3*i+0],t_q[3*i+1],t_q[3*i+2]], dk, inv=True)[0] )
refpos = int(0.5*(Nk-1)) # k[refpos] = kmean for odd Nk
### define operators at reference frequency ###
qref = q[refpos]
tref = t_q[3*refpos+1]
tinv = np.linalg.inv(tref)
### calculate and sort eigenvalues and left and right eigenvectors of operators ###
qeigval = ut.sort_eig(qref)[0]
teigval = ut.sort_eig(tref)[0]
#teigval = np.linalg.eig(tref)[0]
teigval = ut.sort_eig(t_q[3*(refpos)+0])[0]
np.savetxt(direc+"teigvals."+filen+".dat", np.array([range(np.shape(teigval)[0]), teigval.real, teigval.imag]).transpose())
qeigvec = ut.sort_eig(qref)[1].transpose()
teigvec = ut.sort_eig(tref)[1].transpose()
#teigvec = np.linalg.eig(tref)[1].transpose()
modesvec = np.identity(refmodes, dtype="complex")
# left eigenvectors are to be calculated before inflating
qLeigvec = np.linalg.inv(qeigvec).transpose()
tLeigvec = np.linalg.inv(teigvec).transpose()
def write_teigvals(t_q, refpos):
'''
Write t-eigenvalues at reference frequency to file.
'''
teigval = ut.sort_eig(t_q[3*(refpos)+1])[0]
np.savetxt(data_direc+"teigvals."+filen+".dat", np.array([range(np.shape(teigval)[0]), teigval.real, teigval.imag]).transpose())