def logK1e_2ndderiv(x):
"""Slow and probably inaccurate for large x. For testing only."""
f = special.k1e(x)
k1 = special.kvp(1,x,1)
k2 = special.kvp(1,x,2)
e = np.exp(x)
f1 = f + e*k1
f2 = f1 + e*(k1+k2)
return (f2*f - f1**2) / f**2
def h_field(self, x, y, w, l, alpha, h, coef):
"""Return the magnetic field vectors for the specified mode and
point
Args:
x: A float indicating the x coordinate [um]
y: A float indicating the y coordinate [um]
w: A complex indicating the angular frequency
l: "h" (horizontal polarization) or "v" (vertical polarization)
alpha: A tuple (pol, n, m) where pol is 'M' for TM-like mode or
'E' for TE-like mode, n is the order of the mode, and m is
the number of modes in the order and the polarization.
h: A complex indicating the phase constant.
coef: The coefficients of TE- and TM- components
Returns:
h_vec: An array of complexes [hx, hy, hz].
"""
pol, n, m = alpha
a, b = coef
r = np.hypot(x, y)
p = np.arctan2(y, x)
u = self.samples.u(h**2, w, self.fill(w))
v = self.samples.v(h**2, w, self.clad(w))
ur = u * r / self.r
vr = v * r / self.r
if l == 'h':
fr = np.cos(n * p)
fp = -np.sin(n * p)
else:
fr = np.sin(n * p)
fp = np.cos(n * p)
y_te = self.y_te(w, h)
if r <= self.r:
y_tm = self.y_tm_inner(w, h)
er_te = (jv(n - 1, ur) + jv(n + 1, ur)) / 2 * fr
er_tm = jvp(n, ur) * fr
ep_te = jvp(n, ur) * fp
ep_tm = (jv(n - 1, ur) + jv(n + 1, ur)) / 2 * fp
hr = -y_te * a * ep_te - y_tm * b * ep_tm
hp = y_te * a * er_te + y_tm * b * er_tm
hz = -u / (1j * h * self.r) * y_te * a * jv(n, ur) * fp
else:
y_tm = self.y_tm_outer(w, h)
val = -u * jv(n, u) / (v * kv(n, v))
er_te = -(kv(n - 1, vr) - kv(n + 1, vr)) / 2 * fr * val
er_tm = kvp(n, vr) * fr * val
ep_te = kvp(n, vr) * fp * val
ep_tm = -(kv(n - 1, vr) - kv(n + 1, vr)) / 2 * fp * val
hr = -y_te * a * ep_te - y_tm * b * ep_tm
hp = y_te * a * er_te + y_tm * b * er_tm
hz = v / (1j * h * self.r) * y_te * a * kv(n, vr) * fp * val
hx = hr * np.cos(p) - hp * np.sin(p)
hy = hr * np.sin(p) + hp * np.cos(p)
return np.array([hx, hy, hz])
def e_field(self, x, y, w, l, alpha, h, coef):
"""Return the electric field vector for the specified mode and
point
Args:
x: A float indicating the x coordinate [um]
y: A float indicating the y coordinate [um]
w: A complex indicating the angular frequency
l: "h" (horizontal polarization) or "v" (vertical polarization)
alpha: A tuple (pol, n, m) where pol is 'M' for TM-like mode or
'E' for TE-like mode, n is the order of the mode, and m is
the number of modes in the order and the polarization.
h: A complex indicating the phase constant.
coef: The coefficients of TE- and TM- components
Returns:
e_vec: An array of complexes [ex, ey, ez].
"""
pol, n, m = alpha
a, b = coef
r = np.hypot(x, y)
p = np.arctan2(y, x)
u = self.samples.u(h**2, w, self.fill(w))
v = self.samples.v(h**2, w, self.clad(w))
ur = u * r / self.r
vr = v * r / self.r
if l == 'h':
fr = np.cos(n * p)
fp = -np.sin(n * p)
else:
fr = np.sin(n * p)
fp = np.cos(n * p)
if r <= self.r:
er_te = (jv(n - 1, ur) + jv(n + 1, ur)) / 2 * fr
er_tm = jvp(n, ur) * fr
er = a * er_te + b * er_tm
ep_te = jvp(n, ur) * fp
ep_tm = (jv(n - 1, ur) + jv(n + 1, ur)) / 2 * fp
ep = a * ep_te + b * ep_tm
ez = u / (1j * h * self.r) * b * jv(n, ur) * fr
else:
val = -u * jv(n, u) / (v * kv(n, v))
er_te = -(kv(n - 1, vr) - kv(n + 1, vr)) / 2 * fr * val
er_tm = kvp(n, vr) * fr * val
er = a * er_te + b * er_tm
ep_te = kvp(n, vr) * fp * val
ep_tm = -(kv(n - 1, vr) - kv(n + 1, vr)) / 2 * fp * val
ep = a * ep_te + b * ep_tm
ez = -v / (1j * h * self.r) * b * kv(n, vr) * fr * val
ex = er * np.cos(p) - ep * np.sin(p)
ey = er * np.sin(p) + ep * np.cos(p)
return np.array([ex, ey, ez])
def test_cylindrical_bessel_k_prime():
order = np.random.randint(0, 5)
value = np.random.rand(1).item()
assert (roundScaler(NumCpp.bessel_kn_prime_Scaler(order, value), NUM_DECIMALS_ROUND) ==
roundScaler(sp.kvp(order, value).item(), NUM_DECIMALS_ROUND))
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
order = np.random.randint(0, 5)
data = np.random.rand(shape.rows, shape.cols)
cArray.setArray(data)
assert np.array_equal(roundArray(NumCpp.bessel_kn_prime_Array(order, cArray), NUM_DECIMALS_ROUND),
roundArray(sp.kvp(order, data), NUM_DECIMALS_ROUND))
def vpart_diag(n, vc, knvc, knpvc, v, knv, knpv):
if abs(vc - v) < 1e-10:
v0 = (v + vc) / 2
knv0 = kv(n, v0)
knpv0 = kvp(n, v0)
return (knv0 * knpv0 / v0 + (knpv0**2 -
(1 + n**2 / v0**2) * knv0**2) / 2)
if abs(vc + v) < 1e-10:
v0 = (v - vc) / 2
knv0 = kv(n, v0)
knpv0 = kvp(n, v0)
return (-1)**(n - 1) * (knv0 * knpv0 / v0 +
(knpv0**2 -
(1 + n**2 / v0**2) * knv0**2) / 2)
return (vc * knvc * knpv - v * knv * knpvc) / (vc**2 - v**2)
def _hefield(self, wl, nu, neff, r):
self._heceq(neff, wl, nu)
for i, rho in enumerate(self.fiber._r):
if r < rho:
break
else:
i += 1
layer = self.fiber.layers[i]
n = layer.maxIndex(wl)
u = layer.u(rho, neff, wl)
urp = u * r / rho
c1 = rho / u
c2 = wl.k0 * c1
c3 = nu * c1 / r if r else 0 # To avoid div by 0
c6 = constants.Y0 * n * n
if neff < n:
B1 = jn(nu, u)
B2 = yn(nu, u)
F1 = jn(nu, urp) / B1
F2 = yn(nu, urp) / B2 if i > 0 else 0
F3 = jvp(nu, urp) / B1
F4 = yvp(nu, urp) / B2 if i > 0 else 0
else:
c2 = -c2
B1 = iv(nu, u)
B2 = kn(nu, u)
F1 = iv(nu, urp) / B1
F2 = kn(nu, urp) / B2 if i > 0 else 0
F3 = ivp(nu, urp) / B1
F4 = kvp(nu, urp) / B2 if i > 0 else 0
A, B, Ap, Bp = layer.C[:, 0] + layer.C[:, 1] * self.alpha
Ez = A * F1 + B * F2
Ezp = A * F3 + B * F4
Hz = Ap * F1 + Bp * F2
Hzp = Ap * F3 + Bp * F4
if r == 0 and nu == 1:
# Asymptotic expansion of Ez (or Hz):
# J1(ur/p)/r (r->0) = u/(2p)
if neff < n:
f = 1 / (2 * jn(nu, u))
else:
f = 1 / (2 * iv(nu, u))
c3ez = A * f
c3hz = Ap * f
else:
c3ez = c3 * Ez
c3hz = c3 * Hz
Er = c2 * (neff * Ezp - constants.eta0 * c3hz)
Ep = c2 * (neff * c3ez - constants.eta0 * Hzp)
Hr = c2 * (neff * Hzp - c6 * c3ez)
Hp = c2 * (-neff * c3hz + c6 * Ezp)
return numpy.array((Er, Ep, Ez)), numpy.array((Hr, Hp, Hz))
def eig_eq(self, h2: complex, w: complex, pol: str, n: int, e1: complex,
e2: complex):
"""Return the value of the characteristic equation
Args:
h2: The square of the phase constant.
w: The angular frequency
pol: The polarization
n: The order of the modes
e1: The permittivity of the core
e2: The permittivity of the clad.
Returns:
val: A complex indicating the left-hand value of the characteristic
equation.
"""
h2comp = h2.real + 1j * h2.imag
u = self.u(h2comp, w, e1)
v = self.v(h2comp, w, e2)
jus = jv(n, u)
jpus = jvp(n, u)
kvs = kv(n, v)
kpvs = kvp(n, v)
te = jpus / u + kpvs * jus / (v * kvs)
tm = e1 * jpus / u + e2 * kpvs * jus / (v * kvs)
if n == 0:
if pol == 'M':
val = tm
else:
val = te
else:
val = (tm * te - h2comp * (n / w)**2 *
((1 / u**2 + 1 / v**2) * jus)**2)
return val
def k_2(self, dumk1):
temp = -1 / (3 * np.sqrt(self.Pi))
temp -= dumk1 * special.ivp(1, np.sqrt(self.Pi) * self.r0, 1)
return temp / special.kvp(1, np.sqrt(self.Pi) * self.r0, 1)
def lpConstants(self, r, neff, wl, nu, A):
u = self.u(r, neff, wl)
if neff < self.maxIndex(wl):
W = constants.pi / 2
return (W * (u * yvp(nu, u) * A[0] - yn(nu, u) * A[1]),
W * (jn(nu, u) * A[1] - u * jvp(nu, u) * A[0]))
else:
return ((u * kvp(nu, u) * A[0] - kn(nu, u) * A[1]),
(iv(nu, u) * A[1] - u * ivp(nu, u) * A[0]))
def lpConstants(self, r, neff, wl, nu, A):
u = self.u(r, neff, wl)
if neff < self.maxIndex(wl):
W = constants.pi / 2
return (W * (u * yvp(nu, u) * A[0] - yn(nu, u) * A[1]),
W * (jn(nu, u) * A[1] - u * jvp(nu, u) * A[0]))
else:
return ((u * kvp(nu, u) * A[0] - kn(nu, u) * A[1]),
(iv(nu, u) * A[1] - u * ivp(nu, u) * A[0]))
def EH_fields(self, ri, ro, nu, neff, wl, EH, tm=True):
"""
modify EH in-place (for speed)
"""
n = self.maxIndex(wl)
u = self.u(ro, neff, wl)
if ri == 0:
if nu == 0:
if tm:
self.C = numpy.array([1., 0., 0., 0.])
else:
self.C = numpy.array([0., 0., 1., 0.])
else:
self.C = numpy.zeros((4, 2))
self.C[0, 0] = 1 # Ez = 1
self.C[2, 1] = 1 # Hz = alpha
elif nu == 0:
self.C = numpy.zeros(4)
if tm:
c = constants.Y0 * n * n
idx = (0, 3)
self.C[:2] = self.tetmConstants(ri, ro, neff, wl, EH, c, idx)
else:
c = -constants.eta0
idx = (1, 2)
self.C[2:] = self.tetmConstants(ri, ro, neff, wl, EH, c, idx)
else:
self.C = self.vConstants(ri, ro, neff, wl, nu, EH)
# Compute EH fields
if neff < n:
c1 = wl.k0 * ro / u
F3 = jvp(nu, u) / jn(nu, u)
F4 = yvp(nu, u) / yn(nu, u)
else:
c1 = -wl.k0 * ro / u
F3 = ivp(nu, u) / iv(nu, u)
F4 = kvp(nu, u) / kn(nu, u)
c2 = neff * nu / u * c1
c3 = constants.eta0 * c1
c4 = constants.Y0 * n * n * c1
EH[0] = self.C[0] + self.C[1]
EH[1] = self.C[2] + self.C[3]
EH[2] = (c2 * (self.C[0] + self.C[1]) - c3 *
(F3 * self.C[2] + F4 * self.C[3]))
EH[3] = (c4 * (F3 * self.C[0] + F4 * self.C[1]) - c2 *
(self.C[2] + self.C[3]))
return EH
def EH_fields(self, ri, ro, nu, neff, wl, EH, tm=True):
"""
modify EH in-place (for speed)
"""
n = self.maxIndex(wl)
u = self.u(ro, neff, wl)
if ri == 0:
if nu == 0:
if tm:
self.C = numpy.array([1., 0., 0., 0.])
else:
self.C = numpy.array([0., 0., 1., 0.])
else:
self.C = numpy.zeros((4, 2))
self.C[0, 0] = 1 # Ez = 1
self.C[2, 1] = 1 # Hz = alpha
elif nu == 0:
self.C = numpy.zeros(4)
if tm:
c = constants.Y0 * n * n
idx = (0, 3)
self.C[:2] = self.tetmConstants(ri, ro, neff, wl, EH, c, idx)
else:
c = -constants.eta0
idx = (1, 2)
self.C[2:] = self.tetmConstants(ri, ro, neff, wl, EH, c, idx)
else:
self.C = self.vConstants(ri, ro, neff, wl, nu, EH)
# Compute EH fields
if neff < n:
c1 = wl.k0 * ro / u
F3 = jvp(nu, u) / jn(nu, u)
F4 = yvp(nu, u) / yn(nu, u)
else:
c1 = -wl.k0 * ro / u
F3 = ivp(nu, u) / iv(nu, u)
F4 = kvp(nu, u) / kn(nu, u)
c2 = neff * nu / u * c1
c3 = constants.eta0 * c1
c4 = constants.Y0 * n * n * c1
EH[0] = self.C[0] + self.C[1]
EH[1] = self.C[2] + self.C[3]
EH[2] = (c2 * (self.C[0] + self.C[1]) -
c3 * (F3 * self.C[2] + F4 * self.C[3]))
EH[3] = (c4 * (F3 * self.C[0] + F4 * self.C[1]) -
c2 * (self.C[2] + self.C[3]))
return EH
def _ehceq(self, neff, wl, nu):
u, w = self._uw(wl, neff)
v2 = u * u + w * w
nco = self.fiber.maxIndex(0, wl)
ncl = self.fiber.minIndex(1, wl)
delta = (1 - ncl**2 / nco**2) / 2
jnu = jn(nu, u)
knu = kn(nu, w)
kp = kvp(nu, w)
return (jvp(nu, u) * w * knu + kp * u * jnu * (1 - delta) -
jnu * sqrt((u * kp * delta)**2 + ((nu * neff * v2 * knu) /
(nco * u * w))**2))
def w_minus_prime(self, r):
if self.r0 == 1:
return r * 0
sPi = np.sqrt(self.Pi)
return (sPi * special.ivp(1, sPi * r, 1) * self.nu_1(r) / r +
special.i1(sPi * r) * self.nu_1_prime(r) / r +
sPi * special.kvp(1, sPi * r, 1) * self.nu_2(r) / r +
special.k1(sPi * r) * self.nu_2_prime(r) / r -
self.w_minus(r) / r)
def eigenvalue_equation(cls, fiber, W):
U = sqrt(fiber.V**2 - W**2)
j0 = jv(0, U)
j1 = jv(1, U)
k1 = kv(1, W)
k1p = kvp(1, W, 1)
return (
j0/(U*j1) + (fiber.n**2 + fiber.nc**2)/(2*fiber.n**2) * k1p/(W*k1) - 1/U**2 +
sqrt(
((fiber.n**2 - fiber.nc**2)/(2*fiber.n**2) * k1p/(W*k1))**2
+ (cls._rboverrk(fiber, U, fiber.V)**2/fiber.n**2) * (1/W**2 + 1/U**2)**2
)
)
def _lpceq(self, neff, wl, nu):
N = len(self.fiber)
C = numpy.zeros((N-1, 2))
C[0, 0] = 1
for i in range(1, N-1):
r = self.fiber.innerRadius(i)
A = self.fiber.layers[i-1].Psi(r, neff, wl, nu, C[i-1, :])
C[i, :] = self.fiber.layers[i].lpConstants(r, neff, wl, nu, A)
r = self.fiber.innerRadius(-1)
A = self.fiber.layers[N-2].Psi(r, neff, wl, nu, C[-1, :])
u = self.fiber.layers[N-1].u(r, neff, wl)
return u * kvp(nu, u) * A[0] - kn(nu, u) * A[1]
def Psi(self, r, neff, wl, nu, C):
u = self.u(r, neff, wl)
if neff < self.maxIndex(wl):
psi = (C[0] * jn(nu, u) + C[1] * yn(nu, u) if C[1] else
C[0] * jn(nu, u))
psip = u * (C[0] * jvp(nu, u) + C[1] * yvp(nu, u) if C[1] else
C[0] * jvp(nu, u))
else:
psi = (C[0] * iv(nu, u) + C[1] * kn(nu, u) if C[1] else
C[0] * iv(nu, u))
psip = u * (C[0] * ivp(nu, u) + C[1] * kvp(nu, u) if C[1] else
C[0] * ivp(nu, u))
# if numpy.isnan(psi):
# print(neff, self.maxIndex(wl), C, r)
return psi, psip
def Psi(self, r, neff, wl, nu, C):
u = self.u(r, neff, wl)
if neff < self.maxIndex(wl):
psi = (C[0] * jn(nu, u) + C[1] * yn(nu, u) if C[1] else C[0] *
jn(nu, u))
psip = u * (C[0] * jvp(nu, u) +
C[1] * yvp(nu, u) if C[1] else C[0] * jvp(nu, u))
else:
psi = (C[0] * iv(nu, u) + C[1] * kn(nu, u) if C[1] else C[0] *
iv(nu, u))
psip = u * (C[0] * ivp(nu, u) +
C[1] * kvp(nu, u) if C[1] else C[0] * ivp(nu, u))
# if numpy.isnan(psi):
# print(neff, self.maxIndex(wl), C, r)
return psi, psip
def _ehceq(self, neff, wl, nu):
u, w = self._uw(wl, neff)
v2 = u*u + w*w
nco = self.fiber.maxIndex(0, wl)
ncl = self.fiber.minIndex(1, wl)
delta = (1 - ncl**2 / nco**2) / 2
jnu = jn(nu, u)
knu = kn(nu, w)
kp = kvp(nu, w)
return (jvp(nu, u) * w * knu +
kp * u * jnu * (1 - delta) -
jnu * sqrt((u * kp * delta)**2 +
((nu * neff * v2 * knu) /
(nco * u * w))**2))
def he11_dispertion_eq(beta, k0, R_fiber, epsilon_in, epsilon_out):
h = np.sqrt(epsilon_in * k0**2 - beta**2 + 0j)
q = np.sqrt(beta**2 - epsilon_out * k0**2 + 0j)
ha = h * R_fiber
qa = q * R_fiber
nnn_plus = 0.5 * (1 + epsilon_out / epsilon_in)
nnn_minus = 0.5 * (1 - epsilon_out / epsilon_in)
J0ha = sp.jn(0, ha)
J1ha = sp.jv(1, ha)
K1qa = sp.kv(1, qa)
DK1qa = sp.kvp(1, qa)
Kp_qaK1 = DK1qa / (qa * K1qa)
f_beta = J0ha / (ha * J1ha) + nnn_plus*Kp_qaK1 - 1.0/ha**2 + \
np.sqrt(0j + (nnn_minus*Kp_qaK1)**2 + (beta/k0)**2 / epsilon_in * (1/qa**2 + 1/ha**2)**2 )
return (np.real(f_beta))
def _hefield(self, wl, nu, neff, r):
rho = self.fiber.outerRadius(0)
k = wl.k0
nco2 = self.fiber.maxIndex(0, wl)**2
ncl2 = self.fiber.minIndex(1, wl)**2
u = rho * k * sqrt(nco2 - neff**2)
w = rho * k * sqrt(neff**2 - ncl2)
v = rho * k * sqrt(nco2 - ncl2)
jnu = jn(nu, u)
knw = kn(nu, w)
Delta = (1 - ncl2/nco2)/2
b1 = jvp(nu, u) / (u * jnu)
b2 = kvp(nu, w) / (w * knw)
F1 = (u * w / v)**2 * (b1 + (1 - 2 * Delta)*b2) / nu
F2 = (v / (u * w))**2 * nu / (b1 + b2)
a1 = (F2 - 1) / 2
a2 = (F2 + 1) / 2
a3 = (F1 - 1) / 2
a4 = (F1 + 1) / 2
a5 = (F1 - 1 + 2 * Delta) / 2
a6 = (F1 + 1 - 2 * Delta) / 2
if r < rho:
jmur = jn(nu-1, u * r / rho)
jpur = jn(nu+1, u * r / rho)
jnur = jn(nu, u * r / rho)
er = -(a1 * jmur + a2 * jpur) / jnu
ephi = -(a1 * jmur - a2 * jpur) / jnu
ez = u / (k * neff * rho) * jnur / jnu
hr = Y0 * nco2 / neff * (a3 * jmur - a4 * jpur) / jnu
hphi = -Y0 * nco2 / neff * (a3 * jmur + a4 * jpur) / jnu
hz = Y0 * u * F2 / (k * rho) * jnur / jnu
else:
kmur = kn(nu-1, w * r / rho)
kpur = kn(nu+1, w * r / rho)
knur = kn(nu, w * r / rho)
er = -u / w * (a1 * kmur - a2 * kpur) / knw
ephi = -u / w * (a1 * kmur + a2 * kpur) / knw
ez = u / (k * neff * rho) * knur / knw
hr = Y0 * nco2 / neff * u / w * (a5 * kmur + a6 * kpur) / knw
hphi = -Y0 * nco2 / neff * u / w * (a5 * kmur - a6 * kpur) / knw
hz = Y0 * u * F2 / (k * rho) * knur / knw
return numpy.array((er, ephi, ez)), numpy.array((hr, hphi, hz))
def _hefield(self, wl, nu, neff, r):
rho = self.fiber.outerRadius(0)
k = wl.k0
nco2 = self.fiber.maxIndex(0, wl)**2
ncl2 = self.fiber.minIndex(1, wl)**2
u = rho * k * sqrt(nco2 - neff**2)
w = rho * k * sqrt(neff**2 - ncl2)
v = rho * k * sqrt(nco2 - ncl2)
jnu = jn(nu, u)
knw = kn(nu, w)
Delta = (1 - ncl2 / nco2) / 2
b1 = jvp(nu, u) / (u * jnu)
b2 = kvp(nu, w) / (w * knw)
F1 = (u * w / v)**2 * (b1 + (1 - 2 * Delta) * b2) / nu
F2 = (v / (u * w))**2 * nu / (b1 + b2)
a1 = (F2 - 1) / 2
a2 = (F2 + 1) / 2
a3 = (F1 - 1) / 2
a4 = (F1 + 1) / 2
a5 = (F1 - 1 + 2 * Delta) / 2
a6 = (F1 + 1 - 2 * Delta) / 2
if r < rho:
jmur = jn(nu - 1, u * r / rho)
jpur = jn(nu + 1, u * r / rho)
jnur = jn(nu, u * r / rho)
er = -(a1 * jmur + a2 * jpur) / jnu
ephi = -(a1 * jmur - a2 * jpur) / jnu
ez = u / (k * neff * rho) * jnur / jnu
hr = Y0 * nco2 / neff * (a3 * jmur - a4 * jpur) / jnu
hphi = -Y0 * nco2 / neff * (a3 * jmur + a4 * jpur) / jnu
hz = Y0 * u * F2 / (k * rho) * jnur / jnu
else:
kmur = kn(nu - 1, w * r / rho)
kpur = kn(nu + 1, w * r / rho)
knur = kn(nu, w * r / rho)
er = -u / w * (a1 * kmur - a2 * kpur) / knw
ephi = -u / w * (a1 * kmur + a2 * kpur) / knw
ez = u / (k * neff * rho) * knur / knw
hr = Y0 * nco2 / neff * u / w * (a5 * kmur + a6 * kpur) / knw
hphi = -Y0 * nco2 / neff * u / w * (a5 * kmur - a6 * kpur) / knw
hz = Y0 * u * F2 / (k * rho) * knur / knw
return numpy.array((er, ephi, ez)), numpy.array((hr, hphi, hz))
def coef(self, h, w, alpha):
"""Return the coefficients of TE- and TM- components which compose
the hybrid mode.
Args:
h: A complex indicating the phase constant.
w: A complex indicating the angular frequency
alpha: A tuple (pol, n, m) where pol is 'M' for TM-like mode or
'E' for TE-like mode, n is the order of the mode, and m is
the number of modes in the order and the polarization.
Returns:
a: A complex indicating the coefficient of TE-component
b: A complex indicating the coefficient of TM-component
"""
e1 = self.fill(w)
e2 = self.clad(w)
pol, n, m = alpha
w = w.real + 1j * w.imag
h = h.real + 1j * h.imag
if e2.real < -1e6:
if pol == 'E':
norm = self.norm(w, h, alpha, 1.0 + 0.0j, 0.0j)
ai, bi = 1.0 / norm, 0.0
else:
norm = self.norm(w, h, alpha, 0.0j, 1.0 + 0.0j)
ai, bi = 0.0, 1.0 / norm
else:
u = self.samples.u(h**2, w, e1)
v = self.samples.v(h**2, w, e2)
knv = kv(n, v)
knpv = kvp(n, v)
jnu = jv(n, u)
jnpu = jvp(n, u)
ci = -n * (u**2 + v**2) * jnu * knv / (u * v)
if pol == 'E':
ci *= (h / w)**2
ci /= (e1 * jnpu * v * knv + e2 * knpv * u * jnu)
norm = self.norm(w, h, alpha, 1.0 + 0.0j, ci)
ai = 1.0 / norm
bi = ci / norm
else:
ci /= (jnpu * v * knv + knpv * u * jnu)
norm = self.norm(w, h, alpha, ci, 1.0 + 0.0j)
bi = 1.0 / norm
ai = ci / norm
return ai, bi
def func_jac(self, h2, *args):
"""Return the value and Jacobian of the characteristic equation
Args:
h2: A complex indicating the square of the phase constant.
Returns:
val: 2 complexes indicating the left-hand value and Jacobian
of the characteristic equation.
"""
w, pol, n, e1, e2 = args
h2comp = h2.real + 1j * h2.imag
u = self.u(h2comp, w, e1)
v = self.v(h2comp, w, e2)
jus = jv(n, u)
jpus = jvp(n, u)
kvs = kv(n, v)
kpvs = kvp(n, v)
du_dh2 = -self.r / (2 * u)
dv_dh2 = self.r / (2 * v)
te = jpus / u + kpvs * jus / (v * kvs)
dte_du = (-(u * (1 - n**2 / u**2) * jus + 2 * jpus) / u**2 +
jpus * kpvs / (v * kvs))
dte_dv = jus * (n**2 * kvs**2 / v + v *
(kvs**2 - kpvs**2) - 2 * kvs * kpvs) / (v**2 * kvs**2)
tm = e1 * jpus / u + e2 * kpvs * jus / (v * kvs)
dtm_du = e1 * dte_du
dtm_dv = e2 * dte_dv
if n == 0:
if pol == 'M':
f = tm
val = dtm_du * du_dh2 + dtm_dv * dv_dh2
else:
f = te
val = dte_du * du_dh2 + dte_dv * dv_dh2
else:
f = (tm * te - h2comp * (n / w)**2 *
((1 / u**2 + 1 / v**2) * jus)**2)
dre_dh2 = -(n / w)**2 * jus * (jus * (
(1 / u**2 + 1 / v**2)**2 - self.r * h2comp *
(1 / u**4 - 1 / v**4)) + jpus * 2 * h2comp *
(1 / u**2 + 1 / v**2)**2)
val = ((dte_du * du_dh2 + dte_dv * dv_dh2) * tm +
(dtm_du * du_dh2 + dtm_dv * dv_dh2) * te + dre_dh2)
return f, val
def jac(self, h2, args):
"""Return Jacobian of the characteristic equation
Args:
h2: A complex indicating the square of the phase constant.
args: A tuple (w, n, e1, e2), where w indicates the angular
frequency, n indicates the order of the modes, e1 indicates
the permittivity of the core, and e2 indicates the permittivity
of the clad.
Returns:
val: A complex indicating the Jacobian of the characteristic
equation.
"""
w, pol, n, e1, e2 = args
h2comp = h2.real + 1j * h2.imag
u = self.u(h2comp, w, e1)
v = self.v(h2comp, w, e2)
jus = jv(n, u)
jpus = jvp(n, u)
kvs = kv(n, v)
kpvs = kvp(n, v)
du_dh2 = -self.r / (2 * u)
dv_dh2 = self.r / (2 * v)
te = jpus / u + kpvs * jus / (v * kvs)
dte_du = (-(u * (1 - n**2 / u**2) * jus + 2 * jpus) / u**2 +
jpus * kpvs / (v * kvs))
dte_dv = jus * (n**2 * kvs**2 / v + v *
(kvs**2 - kpvs**2) - 2 * kvs * kpvs) / (v**2 * kvs**2)
tm = e1 * jpus / u + e2 * kpvs * jus / (v * kvs)
dtm_du = e1 * dte_du
dtm_dv = e2 * dte_dv
if n == 0:
if pol == 'M':
val = dtm_du * du_dh2 + dtm_dv * dv_dh2
else:
val = dte_du * du_dh2 + dte_dv * dv_dh2
else:
dre_dh2 = -(n / w)**2 * jus * (jus * (
(1 / u**2 + 1 / v**2)**2 - self.r * h2comp *
(1 / u**4 - 1 / v**4)) + jpus * 2 * h2comp *
(1 / u**2 + 1 / v**2)**2)
val = ((dte_du * du_dh2 + dte_dv * dv_dh2) * tm +
(dtm_du * du_dh2 + dtm_dv * dv_dh2) * te + dre_dh2)
return val
def Y(self, w, h, alpha, a, b):
"""Return the effective admittance of the waveguide mode
Args:
w: A complex indicating the angular frequency
h: A complex indicating the phase constant.
alpha: A tuple (pol, n, m) where pol is 'M' for TM-like mode or
'E' for TE-like mode, n is the order of the mode, and m is
the number of modes in the order and the polarization.
a: A complex indicating the coefficient of TE-component
b: A complex indicating the coefficient of TM-component
Returns:
y: A complex indicating the effective admittance
"""
pol, n, m = alpha
e1 = self.fill(w)
e2 = self.clad(w)
en = 1 if n == 0 else 2
if e2.real < -1e6:
if pol == 'E':
val = h / w
else:
val = e1 * w / h
else:
u = self.samples.u(h**2, w, e1)
jnu = jv(n, u)
jnpu = jvp(n, u)
v = self.samples.v(h**2, w, e2)
knv = kv(n, v)
knpv = kvp(n, v)
val_u = 2 * np.pi * self.r**2 / en
val_v = val_u * ((u * jnu) / (v * knv))**2
upart_diag = self.upart_diag(n, u, jnu, jnpu, u, jnu, jnpu)
vpart_diag = self.vpart_diag(n, v, knv, knpv, v, knv, knpv)
upart_off = self.upart_off(n, u, jnu, u, jnu)
vpart_off = self.vpart_off(n, v, knv, v, knv)
val = (val_u * (h / w * a *
(a * upart_diag + b * upart_off) + e1 * w / h * b *
(b * upart_diag + a * upart_off)) - val_v *
(h / w * a *
(a * vpart_diag + b * vpart_off) + e2 * w / h * b *
(b * vpart_diag + a * vpart_off)))
return val
def norm(self, w, h, alpha, a, b):
pol, n, m = alpha
en = 1 if n == 0 else 2
if self.clad(w).real < -1e6:
radius = self.r
if pol == 'E':
u = jnp_zeros(n, m)[-1]
jnu = jv(n, u)
jnpu = 0.0
else:
u = jn_zeros(n, m)[-1]
jnu = 0.0
jnpu = jvp(n, u)
return np.sqrt(a**2 * np.pi * radius**2 / en *
(1 - n**2 / u**2) * jnu**2 +
b**2 * np.pi * radius**2 / en * jnpu**2)
# ac = a.conjugate()
# bc = b.conjugate()
u = self.samples.u(h**2, w, self.fill(w))
jnu = jv(n, u)
jnpu = jvp(n, u)
v = self.samples.v(h**2, w, self.clad(w))
knv = kv(n, v)
knpv = kvp(n, v)
# uc = u.conjugate()
# jnuc = jnu.conjugate()
# jnpuc = jnpu.conjugate()
# vc = v.conjugate()
# knvc = knv.conjugate()
# knpvc = knpv.conjugate()
val_u = 2 * np.pi * self.r**2 / en
val_v = val_u * ((u * jnu) / (v * knv))**2
# val_v = val_u * (uc * u * jnuc * jnu) / (vc * v * knvc * knv)
upart_diag = self.upart_diag(n, u, jnu, jnpu, u, jnu, jnpu)
vpart_diag = self.vpart_diag(n, v, knv, knpv, v, knv, knpv)
upart_off = self.upart_off(n, u, jnu, u, jnu)
vpart_off = self.vpart_off(n, v, knv, v, knv)
return np.sqrt(val_u * (a * (a * upart_diag + b * upart_off) + b *
(b * upart_diag + a * upart_off)) - val_v *
(a * (a * vpart_diag + b * vpart_off) + b *
(b * vpart_diag + a * vpart_off)))
def det_M_real_modes(Kz, Ω, modo, alfa): #xz es en fracción de k0
Kz_real = Kz[0]
Kz_imag = Kz[1]
if Kz_imag == 0:
Kz = Kz_real
else:
Kz = Kz_real + 1j * Kz_imag
V1_star = alfa * (-Ω**2 + Kz**2 + 1)**(1 / 2)
V2_star = alfa * (-Ω**2 + Kz**2)**(1 / 2)
X = V1_star * special.ivp(modo, V1_star) / special.iv(modo, V1_star)
Y = V2_star * special.kvp(modo, V2_star) / special.kv(modo, V2_star)
rta1 = (Ω**2 - 1) * (Ω**2 - Kz**2)**2 * X**2 + Ω**2 * (Ω**2 - Kz**2 -
1)**2 * Y**2
rta2 = (2 * Ω**2 - 1) * (Ω**2 - Kz**2) * (Ω**2 - Kz**2 -
1) * X * Y + modo**2 * Kz**2
return rta1 - rta2
def vConstants(self, ri, ro, neff, wl, nu, EH):
a = numpy.zeros((4, 4))
n = self.maxIndex(wl)
u = self.u(ro, neff, wl)
urp = self.u(ri, neff, wl)
if neff < n:
B1 = jn(nu, u)
B2 = yn(nu, u)
F1 = jn(nu, urp) / B1
F2 = yn(nu, urp) / B2
F3 = jvp(nu, urp) / B1
F4 = yvp(nu, urp) / B2
c1 = wl.k0 * ro / u
else:
B1 = iv(nu, u)
B2 = kn(nu, u)
F1 = iv(nu, urp) / B1 if u else 1
F2 = kn(nu, urp) / B2
F3 = ivp(nu, urp) / B1 if u else 1
F4 = kvp(nu, urp) / B2
c1 = -wl.k0 * ro / u
c2 = neff * nu / urp * c1
c3 = constants.eta0 * c1
c4 = constants.Y0 * n * n * c1
a[0, 0] = F1
a[0, 1] = F2
a[1, 2] = F1
a[1, 3] = F2
a[2, 0] = F1 * c2
a[2, 1] = F2 * c2
a[2, 2] = -F3 * c3
a[2, 3] = -F4 * c3
a[3, 0] = F3 * c4
a[3, 1] = F4 * c4
a[3, 2] = -F1 * c2
a[3, 3] = -F2 * c2
return numpy.linalg.solve(a, EH)
def vConstants(self, ri, ro, neff, wl, nu, EH):
a = numpy.zeros((4, 4))
n = self.maxIndex(wl)
u = self.u(ro, neff, wl)
urp = self.u(ri, neff, wl)
if neff < n:
B1 = jn(nu, u)
B2 = yn(nu, u)
F1 = jn(nu, urp) / B1
F2 = yn(nu, urp) / B2
F3 = jvp(nu, urp) / B1
F4 = yvp(nu, urp) / B2
c1 = wl.k0 * ro / u
else:
B1 = iv(nu, u)
B2 = kn(nu, u)
F1 = iv(nu, urp) / B1 if u else 1
F2 = kn(nu, urp) / B2
F3 = ivp(nu, urp) / B1 if u else 1
F4 = kvp(nu, urp) / B2
c1 = -wl.k0 * ro / u
c2 = neff * nu / urp * c1
c3 = constants.eta0 * c1
c4 = constants.Y0 * n * n * c1
a[0, 0] = F1
a[0, 1] = F2
a[1, 2] = F1
a[1, 3] = F2
a[2, 0] = F1 * c2
a[2, 1] = F2 * c2
a[2, 2] = -F3 * c3
a[2, 3] = -F4 * c3
a[3, 0] = F3 * c4
a[3, 1] = F4 * c4
a[3, 2] = -F1 * c2
a[3, 3] = -F2 * c2
return numpy.linalg.solve(a, EH)
def _tmfield(self, wl, nu, neff, r):
N = len(self.fiber)
C = numpy.array((1, 0))
EH = numpy.zeros(4)
ri = 0
for i in range(N-1):
ro = self.fiber.outerRadius(i)
layer = self.fiber.layers[i]
n = layer.maxIndex(wl)
u = layer.u(ro, neff, wl)
if i > 0:
C = layer.tetmConstants(ri, ro, neff, wl, EH,
constants.Y0 * n * n, (0, 3))
if r < ro:
break
if neff < n:
c1 = wl.k0 * ro / u
F3 = jvp(nu, u) / jn(nu, u)
F4 = yvp(nu, u) / yn(nu, u)
else:
c1 = -wl.k0 * ro / u
F3 = ivp(nu, u) / iv(nu, u)
F4 = kvp(nu, u) / kn(nu, u)
c4 = constants.Y0 * n * n * c1
EH[0] = C[0] + C[1]
EH[3] = c4 * (F3 * C[0] + F4 * C[1])
ri = ro
else:
layer = self.fiber.layers[-1]
u = layer.u(ro, neff, wl)
# C =
return numpy.array((0, ephi, 0)), numpy.array((hr, 0, hz))
def _heceq(self, neff, wl, nu):
N = len(self.fiber)
EH = numpy.empty((4, 2))
ri = 0
for i in range(N-1):
ro = self.fiber.outerRadius(i)
try:
self.fiber.layers[i].EH_fields(ri, ro, nu, neff, wl, EH)
except ZeroDivisionError:
return float("inf")
ri = ro
# Last layer
C = numpy.zeros((4, 2))
C[1, :] = EH[0, :]
C[3, :] = EH[1, :]
self.fiber.layers[N-1].C = C
u = self.fiber.layers[N-1].u(ri, neff, wl)
n = self.fiber.maxIndex(-1, wl)
F4 = kvp(nu, u) / kn(nu, u)
c1 = -wl.k0 * ri / u
c2 = neff * nu / u * c1
c3 = constants.eta0 * c1
c4 = constants.Y0 * n * n * c1
E = EH[2, :] - (c2 * EH[0, :] - c3 * F4 * EH[1, :])
H = EH[3, :] - (c4 * F4 * EH[0, :] - c2 * EH[1, :])
if E[1] != 0:
self.alpha = -E[0] / E[1]
else:
self.alpha = -H[0] / H[1]
return E[0]*H[1] - E[1]*H[0]
def coeq(v0, nu, fiber):
r1, r2 = fiber.rho
n1, n2, n3 = fiber.n
na = sqrt(max(fiber.n)**2 - n3**2)
K0 = v0 / (na * r2)
beta = K0 * n3
if n1 > n3:
u1 = K0**2 * (n1**2 - n3**2)
s1 = 1
else:
u1 = K0**2 * (n3**2 - n1**2)
s1 = -1
if n2 > n3:
u2 = K0**2 * (n2**2 - n3**2)
s2 = 1
else:
u2 = K0**2 * (n3**2 - n2**2)
s2 = -1
s = -s1 * s2
u1r1 = u1 * r1
u2r1 = u2 * r1
u2r2 = u2 * r2
X = (u2r1**2 + s * u1r1**2) * nu * beta
if s1 == 1:
Y = jvp(nu, u1r1) / jn(nu, u1r1)
else:
Y = ivp(nu, u1r1) / iv(nu, u1r1)
ju2r1 = jn(nu, u2r1) if s2 == 1 else iv(nu, u2r1)
nu2r1 = yn(nu, u2r1) if s2 == 1 else kn(nu, u2r1)
jpu2r1 = jvp(nu, u2r1) if s2 == 1 else ivp(nu, u2r1)
npu2r1 = yvp(nu, u2r1) if s2 == 1 else kvp(nu, u2r1)
ju2r2 = jn(nu, u2r2) if s2 == 1 else iv(nu, u2r2)
nu2r2 = yn(nu, u2r2) if s2 == 1 else kn(nu, u2r2)
j1u2r2 = jn(nu + 1, u2r2)
n1u2r2 = yn(nu + 1, u2r2)
M = numpy.empty((4, 4))
M[0, 0] = X * ju2r1
M[0, 1] = X * nu2r1
M[0, 2] = -K0 * (jpu2r1 * u1r1 + s * Y * ju2r1 * u2r1) * u1r1 * u2r1
M[0, 3] = -K0 * (npu2r1 * u1r1 + s * Y * nu2r1 * u2r1) * u1r1 * u2r1
M[1, 0] = -K0 * (n2**2 * jpu2r1 * u1r1 +
s * n1**2 * Y * ju2r1 * u2r1) * u1r1 * u2r1
M[1, 1] = -K0 * (n2**2 * npu2r1 * u1r1 +
s * n1**2 * Y * nu2r1 * u2r1) * u1r1 * u2r1
M[1, 2] = X * ju2r1
M[1, 3] = X * nu2r1
D201 = nu * n3 / u2r2 * (j1u2r2 * nu2r2 - ju2r2 * yn(nu + 1, u2r2))
D202 = -(
(n2**2 + n3**2) * nu * n1u2r2 * nu2r2 / u2r2 + n3**2 * nu * nu2r2**2 /
(nu - 1))
D203 = -(n2**2 * nu * ju2r2 * n1u2r2 / u2r2 +
n3**2 * nu * nu2r2 * j1u2r2 / u2r2 + n3**2 * nu *
(j1u2r2 * nu2r2 + n1u2r2 * ju2r2) / (2 * (nu - 1)))
D212 = -(n2**2 * nu * nu2r2 * j1u2r2 / u2r2 +
n3**2 * nu * ju2r2 * n1u2r2 / u2r2 + n3**2 * nu *
(n1u2r2 * ju2r2 + j1u2r2 * nu2r2) / (2 * (nu - 1)))
D213 = -(
(n2**2 + n3**2) * nu * j1u2r2 * ju2r2 / u2r2 + n3**2 * nu * ju2r2**2 /
(nu - 1))
D223 = nu * n2**2 * n3 / u2r2 * (j1u2r2 * nu2r2 - ju2r2 * n1u2r2)
D30 = M[1, 1] * D201 - M[1, 2] * D202 + M[1, 3] * D203
D31 = M[1, 0] * D201 - M[1, 2] * D212 + M[1, 3] * D213
D32 = M[1, 0] * D202 - M[1, 1] * D212 + M[1, 3] * D223
D33 = M[1, 0] * D203 - M[1, 1] * D213 + M[1, 2] * D223
return M[0, 0] * D30 - M[0, 1] * D31 + M[0, 2] * D32 - M[0, 3] * D33
def coeq(v0, nu, fiber):
r1, r2 = fiber.rho
n1, n2, n3 = fiber.n
na = sqrt(max(fiber.n)**2 - n3**2)
K0 = v0 / (na * r2)
beta = K0 * n3
if n1 > n3:
u1 = K0**2 * (n1**2 - n3**2)
s1 = 1
else:
u1 = K0**2 * (n3**2 - n1**2)
s1 = -1
if n2 > n3:
u2 = K0**2 * (n2**2 - n3**2)
s2 = 1
else:
u2 = K0**2 * (n3**2 - n2**2)
s2 = -1
s = -s1 * s2
u1r1 = u1 * r1
u2r1 = u2 * r1
u2r2 = u2 * r2
X = (u2r1**2 + s * u1r1**2) * nu * beta
if s1 == 1:
Y = jvp(nu, u1r1) / jn(nu, u1r1)
else:
Y = ivp(nu, u1r1) / iv(nu, u1r1)
ju2r1 = jn(nu, u2r1) if s2 == 1 else iv(nu, u2r1)
nu2r1 = yn(nu, u2r1) if s2 == 1 else kn(nu, u2r1)
jpu2r1 = jvp(nu, u2r1) if s2 == 1 else ivp(nu, u2r1)
npu2r1 = yvp(nu, u2r1) if s2 == 1 else kvp(nu, u2r1)
ju2r2 = jn(nu, u2r2) if s2 == 1 else iv(nu, u2r2)
nu2r2 = yn(nu, u2r2) if s2 == 1 else kn(nu, u2r2)
j1u2r2 = jn(nu+1, u2r2)
n1u2r2 = yn(nu+1, u2r2)
M = numpy.empty((4, 4))
M[0, 0] = X * ju2r1
M[0, 1] = X * nu2r1
M[0, 2] = -K0 * (jpu2r1 * u1r1 + s * Y * ju2r1 * u2r1) * u1r1 * u2r1
M[0, 3] = -K0 * (npu2r1 * u1r1 + s * Y * nu2r1 * u2r1) * u1r1 * u2r1
M[1, 0] = -K0 * (n2**2 * jpu2r1 * u1r1 +
s * n1**2 * Y * ju2r1 * u2r1) * u1r1 * u2r1
M[1, 1] = -K0 * (n2**2 * npu2r1 * u1r1 +
s * n1**2 * Y * nu2r1 * u2r1) * u1r1 * u2r1
M[1, 2] = X * ju2r1
M[1, 3] = X * nu2r1
D201 = nu * n3 / u2r2 * (j1u2r2 * nu2r2 - ju2r2 * yn(nu+1, u2r2))
D202 = -((n2**2 + n3**2) * nu * n1u2r2 * nu2r2 / u2r2 +
n3**2 * nu * nu2r2**2 / (nu - 1))
D203 = -(n2**2 * nu * ju2r2 * n1u2r2 / u2r2 +
n3**2 * nu * nu2r2 * j1u2r2 / u2r2 +
n3**2 * nu * (j1u2r2 * nu2r2 +
n1u2r2 * ju2r2) / (2 * (nu - 1)))
D212 = -(n2**2 * nu * nu2r2 * j1u2r2 / u2r2 +
n3**2 * nu * ju2r2 * n1u2r2 / u2r2 +
n3**2 * nu * (n1u2r2 * ju2r2 +
j1u2r2 * nu2r2) / (2 * (nu - 1)))
D213 = -((n2**2 + n3**2) * nu * j1u2r2 * ju2r2 / u2r2 +
n3**2 * nu * ju2r2**2 / (nu - 1))
D223 = nu * n2**2 * n3 / u2r2 * (j1u2r2 * nu2r2 - ju2r2 * n1u2r2)
D30 = M[1, 1] * D201 - M[1, 2] * D202 + M[1, 3] * D203
D31 = M[1, 0] * D201 - M[1, 2] * D212 + M[1, 3] * D213
D32 = M[1, 0] * D202 - M[1, 1] * D212 + M[1, 3] * D223
D33 = M[1, 0] * D203 - M[1, 1] * D213 + M[1, 2] * D223
return M[0, 0] * D30 - M[0, 1] * D31 + M[0, 2] * D32 - M[0, 3] * D33
def Yab(self, w, h1, s1, l1, n1, m1, a1, b1, h2, s2, l2, n2, m2, a2, b2):
"""Return the admittance matrix element of the waveguide modes using
orthogonality.
Args:
w: A complex indicating the angular frequency
h1: A complex indicating the phase constant.
s1: 0 for TE-like mode or 1 for TM-like mode
l1: 0 for h mode or 1 for v mode
n1: the order of the mode
m1: the number of modes in the order and the polarization
a1: A complex indicating the coefficient of TE-component
b1: A complex indicating the coefficient of TM-component
h2: A complex indicating the phase constant.
s2: 0 for TE-like mode or 1 for TM-like mode
l2: 0 for h mode or 1 for v mode
n2: the order of the mode
m2: the number of modes in the order and the polarization
a2: A complex indicating the coefficient of TE-component
b2: A complex indicating the coefficient of TM-component
Returns:
y: A complex indicating the effective admittance
"""
if n1 != n2 or l1 != l2:
return 0.0
n = n1
e1 = self.fill(w)
e2 = self.clad(w)
en = 1 if n == 0 else 2
if e2.real < -1e6:
if s1 != s2 or m1 != m2:
return 0.0
if s1 == 0:
val = h2 / w
else:
val = e1 * w / h2
else:
ac = a1
bc = b1
a, b = a2, b2
uc = self.samples.u(h1**2, w, e1)
vc = self.samples.v(h1**2, w, e2)
u = self.samples.u(h2**2, w, e1)
v = self.samples.v(h2**2, w, e2)
jnuc = jv(n, uc)
jnpuc = jvp(n, uc)
knvc = kv(n, vc)
knpvc = kvp(n, vc)
jnu = jv(n, u)
jnpu = jvp(n, u)
knv = kv(n, v)
knpv = kvp(n, v)
val_u = 2 * np.pi * self.r**2 / en
val_v = val_u * (uc * u * jnuc * jnu) / (vc * v * knvc * knv)
upart_diag = self.upart_diag(n, uc, jnuc, jnpuc, u, jnu, jnpu)
vpart_diag = self.vpart_diag(n, vc, knvc, knpvc, v, knv, knpv)
upart_off = self.upart_off(n, uc, jnuc, u, jnu)
vpart_off = self.vpart_off(n, vc, knvc, v, knv)
val = (val_u *
(h2 / w * a *
(ac * upart_diag + bc * upart_off) + e1 * w / h2 * b *
(bc * upart_diag + ac * upart_off)) - val_v *
(h2 / w * a *
(ac * vpart_diag + bc * vpart_off) + e2 * w / h2 * b *
(bc * vpart_diag + ac * vpart_off)))
return val
def derK(n,m):
return special.kvp(modo,xt(n)*rbarra(m))
v = m * math.pi / Phi0
Beta_List = []
TM_List = np.array([])
TE_List = np.array([])
for i in range(1, len(Beta) + 1):
Beta_value = Beta[i - 1]
Beta_t = cmath.sqrt((w**2 / c**2) * n1**2 - Beta_value**2)
q_t = cmath.sqrt(Beta_value**2 - w**2 / c**2 * n2**2)
if q_t != 0 and Beta_t != 0:
Beta_List.append(Beta_value)
x = Beta_t * alpha
y = q_t * alpha
TM = np.array([[1, -1, -1], [1 / Beta_t**2, 1 / q_t**2, 1 / q_t**2],
[
n1**2 * sp.jvp(v, x) / (Beta_t * sp.jv(v, x)),
n2**2 * sp.kvp(v, y) / (q_t * sp.kv(v, y)),
n2**2 * sp.ivp(v, y) / (q_t * sp.iv(v, y))
]])
TM_determinant = np.linalg.det(TM)
TM_List = np.append(TM_List, TM_determinant)
TE = np.array([[1, -1, -1], [1 / Beta_t**2, 1 / q_t**2, 1 / q_t**2],
[
sp.jvp(v, x) / (Beta_t * sp.jv(v, x)),
sp.kvp(v, x) / (q_t * sp.kv(v, y)),
sp.ivp(v, x) / (q_t * sp.iv(v, y))
]])
TE_determinant = np.linalg.det(TE)
TE_List = np.append(TE_List, TE_determinant)
print(TE_List)
def s(self):
U = self.U
W = self.W
return (1/U**2 + 1/W**2)/(jvp(1, U, 1)/(U*jv(1,U)) + kvp(1, W, 1)/(W*kv(1, W)))
def derK(n):
return special.kvp(modo, xt(n) * ρ_barra)
