def dR(self, lx, ly, kr, kt, kp, qmin, qmax, band, fdm, local_mchi):
if band == "pi":
if not self.lastlx == lx or not self.lastly == ly:
self.P_pi = createP_pi(lx, ly)
self.lastlx = lx
self.lastly = ly
self.E_b = E_pi_minus(lx, ly)
sqP = lambda qr, qt, qp: mp.re(
self.P_pi(
qr * mp.sin(qt) * mp.cos(qp) - kr * mp.sin(kt) * mp.cos(kp
),
qr * mp.sin(qt) * mp.sin(qp) - kr * mp.sin(kt) * mp.sin(kp
),
qr * mp.cos(qt) - kr * mp.cos(kt)))**2 + mp.im(
self.P_pi(
qr * mp.sin(qt) * mp.cos(qp) - kr * mp.sin(kt) * mp
.cos(kp),
qr * mp.sin(qt) * mp.sin(qp) - kr * mp.sin(
kt) * mp.sin(kp),
qr * mp.cos(qt) - kr * mp.cos(kt)))**2
else:
if not self.lastlx == lx or not self.lastly == ly:
self.P_sigma = createP_sigma(lx, ly, band)
self.lastlx = lx
self.lastly = ly
self.E_b = E_sigma(lx, ly, band)
sqP = lambda qr, qt, qp: mp.re(
self.P_sigma(
qr * mp.sin(qt) * mp.cos(qp) - kr * mp.sin(kt) * mp.cos(kp
),
qr * mp.sin(qt) * mp.sin(qp) - kr * mp.sin(kt) * mp.sin(kp
),
qr * mp.cos(qt) - kr * mp.cos(kt)))**2 + mp.im(
self.P_sigma(
qr * mp.sin(qt) * mp.cos(qp) - kr * mp.sin(kt) * mp
.cos(kp),
qr * mp.sin(qt) * mp.sin(qp) - kr * mp.sin(
kt) * mp.sin(kp),
qr * mp.cos(qt) - kr * mp.cos(kt)))**2
integrand = lambda qr, qt, qp: (qr) * mp.sin(qt) / (
4 * mp.pi) * self.eta(qr, kr, self.E_b, local_mchi) * F_DM(
qr, fdm) * sqP(qr, qt, qp)
result = mint.integrate(integrand, [qmin, qmax], [0, mp.pi],
[0, 2 * mp.pi], self.method)
return result
def createP_sigma(lx, ly, band):
C = table.C_Sigma(ly / (2 / mp.sqrt(3)), lx / (mp.sqrt(3) / 2), band)
#Values tabulated on a rectangular grid, flipped and compensated for.
C = [
C[0], C[1], C[2], C[3] / (3**(1 / 2)), C[4] / (3**(1 / 2)),
C[5] / (3**(1 / 2))
]
#For sqrt(3) normalisation, see paper for reference.
f = lambda kx, ky, kz: C[0] * fi_As(lx, ly, kx, ky, kz) + C[1] * fi_Ax(
lx, ly, kx, ky, kz) + C[2] * fi_Ay(lx, ly, kx, ky, kz) + C[3] * fi_Bs(
lx, ly, kx, ky, kz) + C[4] * fi_Bx(lx, ly, kx, ky, kz) + C[
5] * fi_By(lx, ly, kx, ky, kz)
nrm = 1 / mp.sqrt(
mp.conj(C[0]) * C[0] + mp.conj(C[1]) * C[1] + mp.conj(C[2]) * C[2] +
3 *
(mp.conj(C[3]) * C[3] + mp.conj(C[4]) * C[4] + mp.conj(C[5]) * C[5]) +
2 * mp.re((mp.conj(C[0]) * C[3] * pss + mp.conj(C[0]) * C[4] * psx +
mp.conj(C[0]) * C[5] * psy + mp.conj(C[1]) * C[3] * psx +
mp.conj(C[1]) * C[4] * pxx + mp.conj(C[1]) * C[5] * pxy +
mp.conj(C[2]) * C[3] * psy + mp.conj(C[2]) * C[4] * pxy +
mp.conj(C[2]) * C[5] * pyy) *
(mp.exp(1j * mp.fdot([lx, ly, 0], R_1)) +
mp.exp(1j * mp.fdot([lx, ly, 0], R_2)) +
mp.exp(1j * mp.fdot([lx, ly, 0], R_3)))))
return lambda kx, ky, kz: f(kx, ky, kz) * nrm
def plot_C_pi():
C = []
for m in [0, 1]:
Cm = []
for i in range(0, len(lmx)):
Crow = []
for j in range(0, len(lmy)):
if m == 0:
Crow.append(1)
if m == 1:
Crow.append(
float(
mp.norm(-mp.exp(1j * (mp.atan(
mp.im(eq5.fl(lmx[i][j], lmy[i][j], 0)) /
mp.re(eq5.fl(lmx[i][j], lmx[i][j], 0))))))))
Cm.append(Crow)
C.append(Cm)
for m in range(0, len(C)):
plt.figure()
plt.title("C matrix for band pi, element number " + str(m))
plt.contourf(lmx, lmy, C[m], cmap=plt.get_cmap("coolwarm"))
plt.colorbar()
plt.xlabel(r'$l_x$ $[m^{-1}]$')
plt.ylabel(r'$l_y$ $[m^{-1}]$')
def test_eig_dyn():
v = 0
for i in xrange(5):
n = 1 + int(mp.rand() * 5)
if mp.rand() > 0.5:
# real
A = 2 * mp.randmatrix(n, n) - 1
if mp.rand() > 0.5:
A *= 10
for x in xrange(n):
for y in xrange(n):
A[x, y] = int(A[x, y])
else:
A = (2 * mp.randmatrix(n, n) -
1) + 1j * (2 * mp.randmatrix(n, n) - 1)
if mp.rand() > 0.5:
A *= 10
for x in xrange(n):
for y in xrange(n):
A[x,
y] = int(mp.re(A[x, y])) + 1j * int(mp.im(A[x, y]))
run_hessenberg(A, verbose=v)
run_schur(A, verbose=v)
run_eig(A, verbose=v)
def FreeFermions(eigvec, subsystem, FermiVector): r=range(FermiVector) Cij=mp.matrix([[mp.fsum([eigvec[i,k]*eigvec[j,k] for k in r]) for i in subsystem] for j in subsystem]) C_eigval=mp.eigsy(Cij, eigvals_only=True) EH_eigval=mp.matrix([mp.log(mp.fdiv(mp.fsub(mp.mpf(1.0),x),x)) for x in C_eigval]) S=mp.re(mp.fsum([mp.log(mp.mpf(1.0)+mp.exp(-x))+mp.fdiv(x,mp.exp(x)+mp.mpf(1.0)) for x in EH_eigval])) return(S)
def get_ZTT_mineig_grad(ZTT, gradZTT):
eigw, eigv = mp.eigh(ZTT)
eiggrad = mp.matrix(len(gradZTT), 1)
for i in range(len(eiggrad)):
eiggrad[i] = mp.re(mp_conjdot(eigv[:, 0], gradZTT[i] * eigv[:, 0]))
return eiggrad
def B(matriz):
E = mp.eig(matriz, left=False, right=False)
E = mp.eig_sort(E)
bd = matriz
a = 0
for y in range(5):
a = a + 1
d = np.identity(100)
d[d == 1.0] = np.abs(mp.re(E[y]))
d1 = mp.matrix(d)
bd = bd + d1
o = mp.eig(bd, left=False, right=False)
o = mp.eig_sort(o)
if mp.re(o[0]) > 0.001:
break
B1 = mp.cholesky(bd)
return B1, a
def check_xdipole_spherical_expansion(k, R, xp, yp, zp, dist):
print("original xdipole field function")
print(xdipole_field(k, 0, 0, -R - dist, xp, yp, zp))
print("spherical wave expansion dipole field")
print(xdipole_field_from_spherical_wave(k, 0, 0, -R - dist, xp, yp, zp))
field = lambda x, y, z: xdipole_field(k, 0, 0, -R - dist, x, y, z)
fnormsqr = get_field_normsqr(R, field)
print(fnormsqr)
wig_1llp1_000 = []
wig_1llm1_000 = []
wig_1llp1_1m10 = []
wig_1llm1_1m10 = [] #setup wigner3j lists
xdipole_wigner3j_recurrence(2, wig_1llp1_000, wig_1llm1_000,
wig_1llp1_1m10, wig_1llm1_1m10)
cs = []
cnormsqr = 0.0
l = 0
while (fnormsqr - cnormsqr) / fnormsqr > 1e-4:
l += 1
#cl = get_real_RgNM_l_coeffs_for_xdipole_field(l,k,R+dist, wig_1llp1_000,wig_1llm1_000,wig_1llp1_1m10,wig_1llm1_1m10)
cl = get_normalized_real_RgNM_l_coeffs_for_xdipole_field(
l, k, R, dist, wig_1llp1_000, wig_1llm1_000, wig_1llp1_1m10,
wig_1llm1_1m10)
cs.extend(cl)
# rhoM = mp_rho_M(l,k*R)
# rhoN = mp_rho_N(l,k*R)
# rhol = [rhoM, rhoM, rhoN, rhoN]
#cnormsqr += mp.re( np.sum(np.conjugate(cl)*cl * rhol / (2*k**3)) )#factor of 2 since here m!=0
cnormsqr += mp.re(np.sum(np.conjugate(cl) * cl))
# print(cnormsqr)
expfield1 = np.array([mp.zero, mp.zero, mp.zero])
for i in range(1, l + 1):
RgMe_field = get_rgM(k, xp, yp, zp, i, 1, 0)
RgMo_field = get_rgM(k, xp, yp, zp, i, 1, 1)
RgNe_field = get_rgN(k, xp, yp, zp, i, 1, 0)
RgNo_field = get_rgN(k, xp, yp, zp, i, 1, 1)
# expfield1 += (RgMe_field*cs[4*i-4] + RgMo_field*cs[4*i-3] +
# RgNe_field*cs[4*i-2] + RgNo_field*cs[4*i-1])
rhoM = mp_rho_M(i, k * R)
rhoN = mp_rho_N(i, k * R)
normM = mp.sqrt(rhoM / (2 * k**3))
normN = mp.sqrt(rhoN / (2 * k**3))
expfield1 += (RgMe_field * cs[4 * i - 4] / normM +
RgMo_field * cs[4 * i - 3] / normM +
RgNe_field * cs[4 * i - 2] / normN +
RgNo_field * cs[4 * i - 1] / normN)
print("expansion field via real spherical waves is")
print(expfield1)
print(cs)
def rmnNnormsqr_Taylor(n, k, R, rmnBpol, rmnPpol):
#compute norm of spherical wave represented by A_2mn * (kr)^{n-1}*rmnBvec(kr) + A_3mn * (kr)^{n-1}*rmnPvec(kr)
#no conjugates taken since all the Arnoldi vectors will be purely real
kR = mp.mpf(k * R)
prefactpow, normpol = rmnNpol_dot(2 * n - 2, rmnBpol, rmnPpol, rmnBpol,
rmnPpol)
# print(normpol)
#print(po.polyval(k*R, normpol))
return (kR)**prefactpow * mp.re(po.polyval(kR, normpol)) / k**3
def keval(k, band, parts, index, verbose, mchi_index=0):
Rk = 0
if parts == 1:
start = 0
stop = num**2
else:
start = int((index - 1) * num**2 / parts)
stop = int(index * num**2 / parts)
if band == "pi":
for i in range(start, stop):
if verbose:
print("Evaluating Rfunc: " + str(i + 1) + "/" + str(num**2) +
" for kf " + str(k) + " in band pi",
file=sys.stderr)
Rk += mp.re(Rfuncs_pi[i](k, mchi_index))
elif band == "sigma1":
for i in range(start, stop):
if verbose:
print("Evaluating Rfunc: " + str(i + 1) + "/" + str(num**2) +
" for kf " + str(k) + " in band sigma1",
file=sys.stderr)
Rk += mp.re(Rfuncs_sigma1[i](k, mchi_index))
elif band == "sigma2":
for i in range(start, stop):
if verbose:
print("Evaluating Rfunc: " + str(i + 1) + "/" + str(num**2) +
" for kf " + str(k) + " in band sigma2",
file=sys.stderr)
Rk += mp.re(Rfuncs_sigma2[i](k, mchi_index))
elif band == "sigma3":
for i in range(start, stop):
if verbose:
print("Evaluating Rfunc: " + str(i + 1) + "/" + str(num**2) +
" for kf " + str(k) + " in band sigma3",
file=sys.stderr)
Rk += mp.re(Rfuncs_sigma3[i](k, mchi_index))
else:
print("band error")
return 0
return Rk
def plot_RgMmn_g22_g33_g12_g23(n,
k,
Rmin,
Rmax,
klim=10,
Taylor_tol=1e-4,
Rnum=50):
Rlist = np.linspace(Rmin, Rmax, Rnum)
absg11list = np.zeros_like(Rlist)
g22list = np.zeros_like(Rlist)
g33list = np.zeros_like(Rlist)
g12list = np.zeros_like(Rlist)
g23list = np.zeros_like(Rlist)
rholist = np.zeros_like(Rlist)
for i in range(Rnum):
print(i)
R = Rlist[i]
rholist[i] = mp_rho_M(n, k * R)
Gmat = speedup_Green_Taylor_Arnoldi_RgMmn_oneshot(
n, k, R, 3, klim, Taylor_tol) #vecnum=3 for the elements we need
absg11list[i] = mp.fabs(Gmat[0, 0])
g22list[i] = mp.re(Gmat[1, 1]) #note the indexing off-by-one
g33list[i] = mp.re(Gmat[2, 2])
g12list[i] = mp.re(Gmat[0, 1])
g23list[i] = mp.re(Gmat[1, 2])
normalRlist = Rlist * k / (2 * np.pi) #R/lambda list
plt.figure()
plt.plot(normalRlist, g22list, '-r', label='$G_{22}$')
plt.plot(normalRlist, g12list, '--r', label='$G_{12}$')
plt.plot(normalRlist, g33list, '-b', label='$G_{33}$')
plt.plot(normalRlist, g23list, '--b', label='$G_{23}$')
plt.plot(normalRlist, absg11list, '-k', label='$|G_{11}|$')
plt.plot(normalRlist, rholist, '--k', label='$\\rho_M$')
plt.xlabel('$R/\lambda$', **axisfont)
plt.title(
'Green Function matrix elements \n for Arnoldi family radial number n='
+ str(n), **axisfont)
plt.legend()
plt.show()
def FreeFermions(subsystem, C):
C = mp.matrix([[C[x, y] for x in subsystem] for y in subsystem])
C_eigval = mp.eigh(C, eigvals_only=True)
EH_eigval = mp.matrix(
[mp.log(mp.fdiv(mp.fsub(mp.mpf(1.0), x), x)) for x in C_eigval])
S = mp.re(
mp.fsum([
mp.log(mp.mpf(1.0) + mp.exp(-x)) + mp.fdiv(x,
mp.exp(x) + mp.mpf(1.0))
for x in EH_eigval
]))
return (S)
def test_eighe_randmatrix():
N = 5
for a in xrange(10):
A = (2 * mp.randmatrix(N, N) - 1) + 1j * (2 * mp.randmatrix(N, N) - 1)
for i in xrange(0, N):
A[i, i] = mp.re(A[i, i])
for j in xrange(i + 1, N):
A[j, i] = mp.conj(A[i, j])
run_eighe(A)
def test_eighe_randmatrix():
N = 5
for a in xrange(10):
A = (2 * mp.randmatrix(N, N) - 1) + 1j * (2 * mp.randmatrix(N, N) - 1)
for i in xrange(0, N):
A[i,i] = mp.re(A[i,i])
for j in xrange(i + 1, N):
A[j,i] = mp.conj(A[i,j])
run_eighe(A)
def FreeFermions(subsystem,
C_t): #implements free fermion technique by peschel
C = mp.matrix([[C_t[x, y] for x in subsystem] for y in subsystem])
C_eigval = mp.eigh(C, eigvals_only=True)
EH_eigval = mp.matrix(
[mp.log(mp.fdiv(mp.fsub(mp.mpf(1.0), x), x)) for x in C_eigval])
S = mp.re(
mp.fsum([
mp.log(mp.mpf(1.0) + mp.exp(-x)) + mp.fdiv(x,
mp.exp(x) + mp.mpf(1.0))
for x in EH_eigval
]))
return (S)
def test_svd_c_rand():
for i in xrange(5):
full = mp.rand() > 0.5
m = 1 + int(mp.rand() * 10)
n = 1 + int(mp.rand() * 10)
A = (2 * mp.randmatrix(m, n) - 1) + 1j * (2 * mp.randmatrix(m, n) - 1)
if mp.rand() > 0.5:
A *= 10
for x in xrange(m):
for y in xrange(n):
A[x, y] = int(mp.re(A[x, y])) + 1j * int(mp.im(A[x, y]))
run_svd_c(A, full_matrices=full, verbose=False)
def test_svd_c_rand():
for i in xrange(5):
full = mp.rand() > 0.5
m = 1 + int(mp.rand() * 10)
n = 1 + int(mp.rand() * 10)
A = (2 * mp.randmatrix(m, n) - 1) + 1j * (2 * mp.randmatrix(m, n) - 1)
if mp.rand() > 0.5:
A *= 10
for x in xrange(m):
for y in xrange(n):
A[x,y]=int(mp.re(A[x,y])) + 1j * int(mp.im(A[x,y]))
run_svd_c(A, full_matrices=full, verbose=False)
def test_eighe_irandmatrix():
N = 4
R = 4
for a in xrange(10):
A = irandmatrix(N, R) + 1j * irandmatrix(N, R)
for i in xrange(0, N):
A[i, i] = mp.re(A[i, i])
for j in xrange(i + 1, N):
A[j, i] = mp.conj(A[i, j])
run_eighe(A)
def test_eighe_irandmatrix():
N = 4
R = 4
for a in xrange(10):
A=irandmatrix(N, R) + 1j * irandmatrix(N, R)
for i in xrange(0, N):
A[i,i] = mp.re(A[i,i])
for j in xrange(i + 1, N):
A[j,i] = mp.conj(A[i,j])
run_eighe(A)
def keval_L(k, band, verbose, fdm):
iL = []
for i in range(0, len(lmx)):
iLr = []
for j in range(0, len(lmy)):
if verbose:
print("Evaluating Rfunc: " + str(i * len(lmx) + j + 1) + "/" +
str(num**2) + " for kf " + str(k) + " in band " + band,
file=sys.stderr)
#iLr.append(1);
iLr.append(float(mp.re(lcalc(i, j, band, False, fdm)(k))))
iL.append(iLr)
plt.figure()
plt.imshow(iL)
plt.show()
fL = interp.interp2d(lmx, lmy, iL, kind='linear')
return fL
def createP_pi(lx, ly):
fle = fl(lx, ly, 0)
phi_l = -mp.atan(mp.im(fle) / mp.re(fle))
f = lambda kx, ky, kz: (1 + 1 / (3**(1 / 2)) * mp.exp(1j * phi_l) * fl(
lx + kx / ct.hbar, ly + ky / ct.hbar, kz / ct.hbar)) * w2pz(
kx, ky, kz)
#analytical
#differential vectors, not used in nearest neighbor approximation
R_12 = [R_1[0] - R_2[0], R_1[1] - R_2[1], R_1[2] - R_2[2]]
R_23 = [R_2[0] - R_3[0], R_2[1] - R_3[1], R_2[2] - R_3[2]]
R_31 = [R_3[0] - R_1[0], R_3[1] - R_1[1], R_3[2] - R_1[2]]
nrm = mp.sqrt(1 / (
2 + 2 * s / (3**(1 / 2)) *
(mp.cos(phi_l + mp.fdot([lx, ly, 0], R_1)) +
mp.cos(phi_l + mp.fdot([lx, ly, 0], R_2)) +
mp.cos(phi_l + mp.fdot([lx, ly, 0], R_3))) + 2 * s2 *
(mp.cos(mp.fdot([lx, ly, 0], R_12)) + mp.cos(mp.fdot(
[lx, ly, 0], R_23)) + mp.cos(mp.fdot([lx, ly, 0], R_31)))))
return lambda kx, ky, kz: f(kx, ky, kz) * nrm
def test_eig_dyn():
v = 0
for i in xrange(5):
n = 1 + int(mp.rand() * 5)
if mp.rand() > 0.5:
# real
A = 2 * mp.randmatrix(n, n) - 1
if mp.rand() > 0.5:
A *= 10
for x in xrange(n):
for y in xrange(n):
A[x,y] = int(A[x,y])
else:
A = (2 * mp.randmatrix(n, n) - 1) + 1j * (2 * mp.randmatrix(n, n) - 1)
if mp.rand() > 0.5:
A *= 10
for x in xrange(n):
for y in xrange(n):
A[x,y] = int(mp.re(A[x,y])) + 1j * int(mp.im(A[x,y]))
run_hessenberg(A, verbose = v)
run_schur(A, verbose = v)
run_eig(A, verbose = v)
def _eigenvals_eigenvects_mpmath(M):
norm2 = lambda v: mp.sqrt(sum(i**2 for i in v))
v1 = None
prec = max([x._prec for x in M.atoms(Float)])
eps = 2**-prec
while prec < DEFAULT_MAXPREC:
with workprec(prec):
A = mp.matrix(M.evalf(n=prec_to_dps(prec)))
E, ER = mp.eig(A)
v2 = norm2([i for e in E for i in (mp.re(e), mp.im(e))])
if v1 is not None and mp.fabs(v1 - v2) < eps:
return E, ER
v1 = v2
prec *= 2
# we get here because the next step would have taken us
# past MAXPREC or because we never took a step; in case
# of the latter, we refuse to send back a solution since
# it would not have been verified; we also resist taking
# a small step to arrive exactly at MAXPREC since then
# the two calculations might be artificially close.
raise PrecisionExhausted
def mp_vecnormsqr(vec):
return mp.re((vec.transpose_conj() * vec)[0, 0])
def mp_normsqr(cplx):
return mp.re(mp.conj(cplx) * cplx)
def plots(self, re_lerp, im_lerp):
return [[(re_lerp(mp.re(z)), im_lerp(mp.im(z))) for z in zs]
for t, zs in self.pts]
def mp_re(mpcarr):
rearr = mp.zero * np.zeros_like(mpcarr)
for i in range(len(mpcarr)):
rearr[i] = mp.re(mpcarr[i])
return rearr
def rmnMnormsqr_Taylor(n, k, R, rmnCpol):
kR = mp.mpf(k * R)
prefactpow, normpol = rmnMpol_dot(2 * n, rmnCpol, rmnCpol)
return kR**prefactpow * mp.re(po.polyval(kR, normpol)) / k**3
def mp_to_complex(mpcplx):
mpreal = mp.re(mpcplx)
mpimag = mp.im(mpcplx)
flreal = np.float(mp.nstr(mpreal, mp.dps))
flimag = np.float(mp.nstr(mpimag, mp.dps))
return flreal + 1j * flimag
Kabct = mp.matrix([[KKt[i, j] for j in la + lb + lc]
for i in la + lb + lc])
Dmabct = mp.matrix([[Dmt[i, j] for j in la + lb + lc]
for i in la + lb + lc])
Dpabct = mp.matrix([[Dpt[i, j] for j in la + lb + lc]
for i in la + lb + lc])
Sab.append(SvN(Dmabt, Dpabt, Kabt))
Sbc.append(SvN(Dmbct, Dpbct, Kbct))
Sb.append(SvN(Dmbt, Dpbt, Kbt))
Sabc.append(SvN(Dmabct, Dpabct, Kabct))
print('step ' + str(iter + 1))
temp = (Sab[iter] + Sbc[iter] - Sb[iter] - Sabc[iter]) / mp.log(2)
Sqtopo.append(mp.re(temp))
print("--- Sqtopo ---")
print(temp)
print("======================================================")
# f1.write("%.10f,%.10f\n" % (tsteps[iter],Sqtopo[iter]))
iter += 1
# f1.close()
print('end')
#plt.plot(tsteps,Sqtopo)
#plt.title("$\Delta=0.5$")
#plt.xlabel("t")
#plt.ylabel("$S^q_{topo} $")
#plt.legend(loc="upper right")
A = np.ndarray(f.size)
R = np.ndarray(f.size)
I = np.ndarray(f.size)
Gr = np.ndarray(f.size)
Gi = np.ndarray(f.size)
for n in range(f.size):
Zap[n] = ZapA[n]*( i0(gammac[n]*a) / i1(gammac[n]*a) )
Zbp[n] = ZbpA[n] * ((i0(gammac[n]*b) * k1(gammac[n]*c) + k0(gammac[n]*b)*i1(gammac[n]*c)) / ( i1(gammac[n]*c)*k1(gammac[n]*b) - i1(gammac[n]*b)*k1(gammac[n]*c) ) )
ZL[n] = 1j*omega[n]*Lp
YC[n] = 1j*omega[n]*Cp
Zp[n] = Zap[n] + Zbp[n] + ZL[n]
Yp[n] = YC[n] # + G[n]
Zc[n] = mp.sqrt(Zp[n]/Yp[n])
A[n] = mp.fabs(Zc[n])
R[n] = mp.re(Zc[n])
I[n] = mp.im(Zc[n])
Gr[n] = mp.re(mp.sqrt(Zp[n]*Yp[n]))
Gi[n] = mp.im(mp.sqrt(Zp[n]*Yp[n]))
fig = plt.figure()
plt.plot(f/10**6, A, label='Magnitude', color='red')
plt.xlabel('Frequency [MHz]')
plt.ylabel('Magnitude of Z$_{c}$ [$\Omega$]')
plt.legend()
plt.xlim([-0.3,100])
#plt.show()
fig2 = plt.figure()
plt.plot(f/10**6, R, label='Real Part', color='red')
plt.xlabel('Frequency [MHz]')
plt.ylabel('Real Part of Z$_{c}$ [$\Omega$]')
def E_pi_minus(lx, ly):
fle = float(mp.re(mp.sqrt(mp.conj(fl(lx, ly, 0) * fl(lx, ly, 0)))))
return -1 * t * fle / (1 + s * fle)
