def __fct1(self, nu, u1r1, u2r1, u2r2, s1, s2, s3, n1sq, n2sq, n3sq):
if s2 < 0: # a
b11 = iv(nu, u2r1)
b12 = kn(nu, u2r1)
b21 = iv(nu, u2r2)
b22 = kn(nu, u2r2)
b31 = iv(nu+1, u2r1)
b32 = kn(nu+1, u2r1)
f1 = b31*b22 + b32*b21
f2 = b11*b22 - b12*b21
else:
b11 = jn(nu, u2r1)
b12 = yn(nu, u2r1)
b21 = jn(nu, u2r2)
b22 = yn(nu, u2r2)
if s1 == 0:
f1 = 0
else:
b31 = jn(nu+1, u2r1)
b32 = yn(nu+1, u2r1)
f1 = b31*b22 - b32*b21
f2 = b12*b21 - b11*b22
if s1 == 0:
delta = 1
else:
delta = self.__delta(nu, u1r1, u2r1, s1, s2, s3, n1sq, n2sq, n3sq)
return f1 + f2 * delta
def fullDet(b, nu):
a = rho * b
i = ivp(nu, u1 * a) / (u1 * a * iv(nu, u1 * a))
if nu == 1:
k2 = -2
k = 0
else:
k2 = 2 * nu / (u2 * b)**2 - 1 / (nu - 1)
k = -1
X = (1 / (u1 * a)**2 + 1 / (u2 * a)**2)
P1 = jn(nu, u2 * a) * yn(nu, u2 * b) - yn(nu, u2 * a) * jn(nu, u2 * b)
P2 = (jvp(nu, u2 * a) * yn(nu, u2 * b) -
yvp(nu, u2 * a) * jn(nu, u2 * b)) / (u2 * a)
P3 = (jn(nu, u2 * a) * yvp(nu, u2 * b) -
yn(nu, u2 * a) * jvp(nu, u2 * b)) / (u2 * b)
P4 = (jvp(nu, u2 * a) * yvp(nu, u2 * b) -
yvp(nu, u2 * a) * jvp(nu, u2 * b)) / (u2 * a * u2 * b)
A = (n12 * i**2 - n32 * nu**2 * X**2)
if nu == 1:
B = 0
else:
B = 2 * n22 * n32 * nu * X * (P1 * P4 - P2 * P3)
return (n32 * k2 * A * P1**2 + (n12 + n22) * n32 * i * k2 * P1 * P2 -
(n22 + n32) * k * A * P1 * P3 -
(n12 * n32 + n22 * n22) * i * k * P1 * P4 +
n22 * n32 * k2 * P2**2 - n22 * (n12 + n32) * i * k * P2 * P3 -
n22 * (n22 + n32) * k * P2 * P4 - B)
def corner_exact(k,m):
"""
created Monday 11 July 2016
Function which vanishes at eigenenergies of circular corner.
"""
psi=jv(m,r1*k)-jv(m,r2*k)*yn(m,r1*k)/yn(m,r2*k)
return psi
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 bc_solve(x, k, a, b):
F = (sp.jn(k - 1, x * a) - sp.jn(k + 1, x * a)) * \
(sp.yn(k - 1, x * b) - sp.yn(k + 1, x * b)) / 4.0 \
- \
(sp.jn(k - 1, x * b) - sp.jn(k + 1, x * b)) * \
(sp.yn(k - 1, x * a) - sp.yn(k + 1, x * a)) / 4.0
return F
def __fct2(self, nu, u1r1, u2r1, u2r2, s1, s2, s3, n1sq, n2sq, n3sq):
with numpy.errstate(invalid='ignore'):
delta = self.__delta(nu, u1r1, u2r1, s1, s2, s3, n1sq, n2sq, n3sq)
n0sq = (n3sq - n2sq) / (n2sq + n3sq)
if s2 < 0: # a
b11 = iv(nu, u2r1)
b12 = kn(nu, u2r1)
b21 = iv(nu, u2r2)
b22 = kn(nu, u2r2)
b31 = iv(nu+1, u2r1)
b32 = kn(nu+1, u2r1)
b41 = iv(nu-2, u2r2)
b42 = kn(nu-2, u2r2)
g1 = b11 * delta + b31
g2 = b12 * delta - b32
f1 = b41*g2 - b42*g1
f2 = b21*g2 - b22*g1
else:
b11 = jn(nu, u2r1)
b12 = yn(nu, u2r1)
b21 = jn(nu, u2r2)
b22 = yn(nu, u2r2)
b31 = jn(nu+1, u2r1)
b32 = yn(nu+1, u2r1)
b41 = jn(nu-2, u2r2)
b42 = yn(nu-2, u2r2)
g1 = b11 * delta - b31
g2 = b12 * delta - b32
f1 = b41*g2 - b42*g1
f2 = b22*g1 - b21*g2
return f1 + n0sq*f2
def fullDet(b, nu):
a = rho * b
i = ivp(nu, u1*a) / (u1*a * iv(nu, u1*a))
if nu == 1:
k2 = -2
k = 0
else:
k2 = 2 * nu / (u2 * b)**2 - 1 / (nu - 1)
k = -1
X = (1 / (u1*a)**2 + 1 / (u2*a)**2)
P1 = jn(nu, u2*a) * yn(nu, u2*b) - yn(nu, u2*a) * jn(nu, u2*b)
P2 = (jvp(nu, u2*a) * yn(nu, u2*b) - yvp(nu, u2*a) * jn(nu, u2*b)) / (u2 * a)
P3 = (jn(nu, u2*a) * yvp(nu, u2*b) - yn(nu, u2*a) * jvp(nu, u2*b)) / (u2 * b)
P4 = (jvp(nu, u2*a) * yvp(nu, u2*b) - yvp(nu, u2*a) * jvp(nu, u2*b)) / (u2 * a * u2 * b)
A = (n12 * i**2 - n32 * nu**2 * X**2)
if nu == 1:
B = 0
else:
B = 2 * n22 * n32 * nu * X * (P1 * P4 - P2 * P3)
return (n32 * k2 * A * P1**2 +
(n12 + n22) * n32 * i * k2 * P1 * P2 -
(n22 + n32) * k * A * P1 * P3 -
(n12*n32 + n22*n22) * i * k * P1 * P4 +
n22 * n32 * k2 * P2**2 -
n22 * (n12 + n32) * i * k * P2 * P3 -
n22 * (n22 + n32) * k * P2 * P4 -
B)
def aTM(m, k):
kaIn = rtEpsIn * k * a
kaOut = rtEpsOut * k * a
kbOut = rtEpsOut * k * b
res = jn(m, kaIn)
res /= jn(m, kaOut) - jn(m, kbOut) * yn(m, kaOut) / yn(m, kbOut)
return res
def aTM(m, k): kaIn = rtEpsIn * k * a kaOut = rtEpsOut * k * a kbOut = rtEpsOut * k * b res = jn(m, kaIn) res /= jn(m, kaOut) - jn(m, kbOut) * yn(m, kaOut) / yn(m, kbOut) return res
def _Psi_p(type, n, x):
"""Eq:II.83-86 """
if type == 0:
return x * jn(n, x, derivative=True) + jn(n, x, derivative=False)
if type == 1: return jn(n, x, derivative=True)
if type == 2: return yn(n, x, derivative=True)
if type == 3:
return jn(n, x, derivative=True) + 1j * yn(n, x, derivative=True)
if type == 4:
return jn(n, x, derivative=True) - 1j * yn(n, x, derivative=True)
def kFuncTM(k, m): kaIn = rtEpsIn * k * a kaOut = rtEpsOut * k * a kbOut = rtEpsOut * k * b one = rtEpsIn * djn(m, kaIn, 1) one *= jn(m, kaOut) * yn(m, kbOut) - jn(m, kbOut) * yn(m, kaOut) two = rtEpsOut * jn(m, kaIn) two *= djn(m, kaOut, 1) * yn(m, kbOut) - jn(m, kbOut) * dyn(m, kaOut, 1) return one - two
def Gm(E, m, r1, r2):
ra = r1
rb = r2
if (r2 < r1):
ra, rb = rb, ra
j1a = special.jn(m, E * ra)
j2a = special.jn(m + 1, E * ra)
j1b = special.jn(m, E * rb)
j2b = special.jn(m + 1, E * rb)
y1b = special.yn(m, E * rb)
y2b = special.yn(m + 1, E * rb)
return E * E * (j1a * j1a + j2a * j2a) * (j1b * y1b + j2b * y2b)
def Gm(E, m, r1, r2):
ra = r1
rb = r2
if (r2 < r1):
ra, rb = rb, ra
j1a = special.jn(m, E * ra)
j2a = special.jn(m + 1, E * ra)
j1b = special.jn(m, E * rb)
j2b = special.jn(m + 1, E * rb)
y1b = special.yn(m, E * rb)
y2b = special.yn(m + 1, E * rb)
return E * E * (j1a * j1a + j2a * j2a) * (j1b * y1b + j2b * y2b)
def G(k):
s = 0.0
for m in mvals:
j1a = special.jn(m, k * ra)
j1b = special.jn(m, k * rb)
j2a = special.jn(m + 1, k * ra)
j2b = special.jn(m + 1, k * rb)
y1b = special.yn(m, k * rb)
y2b = special.yn(m + 1, k * rb)
s += (j1a**2 + j2a**2) * (j1b * y1b + j2b * y2b)
s *= k**2
return s
def kFuncTM(k, m):
kaIn = rtEpsIn * k * a
kaOut = rtEpsOut * k * a
kbOut = rtEpsOut * k * b
one = rtEpsIn * djn(m, kaIn, 1)
one *= jn(m, kaOut) * yn(m, kbOut) - jn(m, kbOut) * yn(m, kaOut)
two = rtEpsOut * jn(m, kaIn)
two *= djn(m, kaOut, 1) * yn(m, kbOut) - jn(m, kbOut) * dyn(m, kaOut, 1)
return one - two
def coeffs(alpha, a, Tb):
An = scipy.zeros(alpha.shape)
Bn = scipy.zeros(alpha.shape)
for i in xrange(len(alpha)):
Bn[i] = -Tb * genB(scipy.log, alpha[i], a) / scipy.log(a)
if jn(0, alpha[i]) == 0:
An[i] = -yn(0, alpha[i] * a) / jn(0, alpha[i] * a) * Bn[i]
else:
An[i] = -yn(0, alpha[i]) / jn(0, alpha[i]) * Bn[i]
return An, Bn
def G(k):
s = 0.0
for m in mvals:
j1a = special.jn(m, k * ra)
j1b = special.jn(m, k * rb)
j2a = special.jn(m + 1, k * ra)
j2b = special.jn(m + 1, k * rb)
y1b = special.yn(m, k * rb)
y2b = special.yn(m + 1, k * rb)
s += (j1a**2 + j2a**2) * (j1b * y1b + j2b * y2b)
s *= k**2
return s
def analytic_sol(R, a, theta, Ampli, k, N_terms):
result = 0
for n in range(N_terms):
tosum = 0
cn = -Ampli * (2 * n +
1) * (-1j)**(n) * (jn(n, k * a, derivative=True) /
(jn(n, k * a, derivative=True) -
1j * yn(n, k * a, derivative=True)))
tosum = cn * (jn(n, k * R, derivative=False) -
1j * yn(n, k * R, derivative=False)) * eval_legendre(
n, np.cos(theta))
result = result + tosum
return result
def alpha(self, N, M, a, b):
alphax = np.zeros(shape=(N, M))
betax = np.zeros(shape=(N, M))
for n in xrange(N):
k = 2 * (n + 1)
x0 = 0.1
for m in xrange(M):
alphanm = newton(CylindricalSandwich.bc_solve, x0, args=(k, a, b))
x0 = alphanm + 4
alphax[n, m] = alphanm
betax[n, m] = -(sp.jn(k + 1, alphanm * a) - sp.jn(k - 1, alphanm * a)) /\
(sp.yn(k + 1, alphanm * a) - sp.yn(k - 1, alphanm * a))
return alphax, betax
def test_cylindrical_bessel_y():
order = np.random.randint(0, 5)
value = np.random.rand(1).item()
assert (roundScaler(NumCpp.bessel_yn_Scaler(order, value), NUM_DECIMALS_ROUND) ==
roundScaler(sp.yn(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_yn_Array(order, cArray), NUM_DECIMALS_ROUND),
roundArray(sp.yn(order, data), NUM_DECIMALS_ROUND))
def ex(num, a, b, Tb):
#r = scipy.array([.55,.7,.9])
r = scipy.linspace(a, 1, 1e3)
s = ['-', ':', '-.']
#t = scipy.linspace(0,1,1e3)
t = scipy.array([.1, 1., 10.])
toff = scipy.linspace(-1., 0., 1e3)
r1, t1 = scipy.meshgrid(r, t)
output = scipy.zeros((len(t), len(r), num))
alpha = zeros(num, a)
An, Bn = coeffs(alpha, a, Tb)
print((jn(0, alpha[0] * r1)).shape, r1.shape, output.shape)
for i in xrange(num):
output[:, :, i] = (
(An[i] * jn(0, alpha[i] * r1) + Bn[i] * yn(0, alpha[i] * r1)) *
scipy.exp(-b * pow(alpha[i], 2) * t1))
temp = scipy.sum(output, axis=2) + Tb * scipy.log(r1) / scipy.log(a)
temp2 = Tb * scipy.log(r1) / scipy.log(a)
for i in xrange(len(t)):
#plt.plot(scipy.concatenate((toff,t)),scipy.concatenate((scipy.zeros(toff.shape),temp.T[i])),colors[c[i]],linewidth=2.)
#plt.plot(t,temp.T[i],colors[c[i]],linewidth=2.)/temp2[:,i]
#plt.plot(t,temp.T[i]/(Tb*scipy.log(r1)/scipy.log(a))[:,i],colors[c[i]],linewidth=2.)
plt.plot(r, temp[i], 'k', linewidth=2., linestyle=s[i])
def gendata(X):
l = '%5s%23s%23s%23s%23s%23s%23s\n' % ('x', 'J0', 'J1', 'J2', 'Y0', 'Y1',
'Y2')
for i, x in enumerate(X):
l += '%5.2f%23.15e%23.15e%23.15e%23.15e%23.15e%23.15e\n' % (x, sp.j0(
x), sp.j1(x), sp.jv(2, x), sp.y0(x), sp.y1(x), sp.yn(2, x))
return l
def efieldTE(m, k, pts, phase="re"):
pts = numpy.asarray(pts, dtype='d')
r, phi, z = toCyl(pts)
if phase == "re":
rTrig = -numpy.sin(m * phi)
phiTrig = numpy.cos(m * phi)
else:
rTrig = numpy.cos(m * phi)
phiTrig = numpy.sin(m * phi)
res = numpy.zeros(r.shape + (3, ), dtype='d')
indsIn = numpy.logical_and(r > 0.0, r < a)
xIn = rtEpsIn * k * r[indsIn]
er = m * jn(m, xIn) * rTrig[indsIn] / (epsIn * r[indsIn])
print numpy.sum(numpy.abs(er))
ephi = -k * djn(m, xIn, 1) * phiTrig[indsIn] / rtEpsIn
print numpy.sum(numpy.abs(ephi))
phiIn = phi[indsIn]
res[indsIn, 0] = er * numpy.cos(phiIn) - ephi * numpy.sin(phiIn)
res[indsIn, 1] = er * numpy.sin(phiIn) + ephi * numpy.cos(phiIn)
indsOut = numpy.logical_and(r >= a, r < b)
xOut = rtEpsOut * k * r[indsOut]
er = m * (aTE(m, k) * jn(m, xOut) +
bTE(m, k) * yn(m, xOut)) * rTrig[indsOut] / (epsOut * r[indsOut])
print numpy.sum(numpy.abs(er))
ephi = -k * (aTE(m, k) * djn(m, xOut, 1) +
bTE(m, k) * dyn(m, xOut, 1)) * phiTrig[indsOut] / rtEpsOut
print numpy.sum(numpy.abs(ephi))
phiOut = phi[indsOut]
res[indsOut, 0] = er * numpy.cos(phiOut) - ephi * numpy.sin(phiOut)
res[indsOut, 1] = er * numpy.sin(phiOut) + ephi * numpy.cos(phiOut)
return res
def plotrcfte():
V = numpy.linspace(1, 7)
rho = 0.5
f = j0(V) * yn(2, V * rho) - y0(V) * jn(2, rho * V)
pyplot.plot(V, f)
pyplot.show()
def cutoffTE(b):
# EXP: 2.4220557071361126
a = rho * b
return (i0(u1 * a) *
(j0(u2 * b) * yn(2, u2 * a) - y0(u2 * b) * jn(2, u2 * a)) -
iv(2, u1 * a) *
(j0(u2 * a) * y0(u2 * b) - y0(u2 * a) * j0(u2 * b)))
def plotrcfte():
V = numpy.linspace(1, 7)
rho = 0.5
f = j0(V) * yn(2, V*rho) - y0(V) * jn(2, rho*V)
pyplot.plot(V, f)
pyplot.show()
def efieldTE(m, k, pts, phase = "re"):
pts = numpy.asarray(pts, dtype = 'd')
r, phi, z = toCyl(pts)
if phase == "re":
rTrig = -numpy.sin(m * phi)
phiTrig = numpy.cos(m * phi)
else:
rTrig = numpy.cos(m * phi)
phiTrig = numpy.sin(m * phi)
res = numpy.zeros(r.shape + (3, ), dtype = 'd')
indsIn = numpy.logical_and(r > 0.0, r < a)
xIn = rtEpsIn * k * r[indsIn]
er = m * jn(m, xIn) * rTrig[indsIn] / (epsIn * r[indsIn])
print numpy.sum(numpy.abs(er))
ephi = -k * djn(m, xIn, 1) * phiTrig[indsIn] / rtEpsIn
print numpy.sum(numpy.abs(ephi))
phiIn = phi[indsIn]
res[indsIn, 0] = er * numpy.cos(phiIn) - ephi * numpy.sin(phiIn)
res[indsIn, 1] = er * numpy.sin(phiIn) + ephi * numpy.cos(phiIn)
indsOut = numpy.logical_and(r >= a, r < b)
xOut = rtEpsOut * k * r[indsOut]
er = m * (aTE(m, k) * jn(m, xOut) + bTE(m, k) * yn(m, xOut)) * rTrig[indsOut] / (epsOut * r[indsOut])
print numpy.sum(numpy.abs(er))
ephi = -k * (aTE(m, k) * djn(m, xOut, 1) + bTE(m, k) * dyn(m, xOut, 1)) * phiTrig[indsOut] / rtEpsOut
print numpy.sum(numpy.abs(ephi))
phiOut = phi[indsOut]
res[indsOut, 0] = er * numpy.cos(phiOut) - ephi * numpy.sin(phiOut)
res[indsOut, 1] = er * numpy.sin(phiOut) + ephi * numpy.cos(phiOut)
return res
def _Psi(type, n, x):
"""Eq:II.83-86 """
if type == 0: return x * jn(n, x)
if type == 1: return jn(n, x)
if type == 2: return yn(n, x)
if type == 3: return _Psi(1, n, x) + 1j * _Psi(2, n, x)
if type == 4: return _Psi(1, n, x) - 1j * _Psi(2, n, x)
def cutoffTM(b):
# EXP: 2.604335468618898
a = rho * b
return (n22 / n12 *
(j0(u2 * b) * yn(2, u2 * a) - y0(u2 * b) * jn(2, u2 * a)) +
(n22 / n12 - 1 + iv(2, u1 * a) / i0(u1 * a)) *
(j0(u2 * b) * y0(u2 * a) - y0(u2 * b) * j0(u2 * a)))
def aTE(m, k):
kaIn = rtEpsIn * k * a
kaOut = rtEpsOut * k * a
kbOut = rtEpsOut * k * b
res = jn(m, kaIn)
res /= jn(m, kaOut) - djn(m, kbOut, 1) * yn(m, kaOut) / dyn(m, kbOut, 1)
return res
def aTE(m, k): kaIn = rtEpsIn * k * a kaOut = rtEpsOut * k * a kbOut = rtEpsOut * k * b res = jn(m, kaIn) res /= jn(m, kaOut) - djn(m, kbOut, 1) * yn(m, kaOut) / dyn(m, kbOut, 1) return res
def phase_shift(E,l):
k = sqrt(mass*E/hbarc**2)
# r1 and r2 >> R, way outside the potential
r1 = xlist[4444]
r2 = xlist[4454]
U = u_l(E,l)
U1 = U[4444]
U2 = U[4454]
al = (U1*r2)/(U2*r1)
x1 = jn(l, k*r1) - al*jn(l, k*r2)
x2 = yn(l, k*r1) - al*yn(l, k*r2)
# return the tangent of delta_0
if np.arctan2(x1, x2) < 0:
return np.arctan2(x1, x2) + pi
else:
return np.arctan2(x1, x2)
def _lpcoeq(self, v0, nu):
u1r1, u2r1, u2r2, s1, s2, n1sq, n2sq, n3sq = self.__params(v0)
if s1 == 0: # e
return (jn(nu+1, u2r1) * yn(nu-1, u2r2) -
yn(nu+1, u2r1) * jn(nu-1, u2r2))
(f11a, f11b) = ((jn(nu-1, u1r1), jn(nu, u1r1)) if s1 > 0 else
(iv(nu-1, u1r1), iv(nu, u1r1)))
if s2 > 0:
f22a, f22b = jn(nu-1, u2r2), yn(nu-1, u2r2)
f2a = jn(nu, u2r1) * f22b - yn(nu, u2r1) * f22a
f2b = jn(nu-1, u2r1) * f22b - yn(nu-1, u2r1) * f22a
else: # a
f22a, f22b = iv(nu-1, u2r2), kn(nu-1, u2r2)
f2a = iv(nu, u2r1) * f22b + kn(nu, u2r1) * f22a
f2b = iv(nu-1, u2r1) * f22b - kn(nu-1, u2r1) * f22a
return f11a * f2a * u1r1 - f11b * f2b * u2r1
def cutoffHE2(b):
nu = 2
a = rho * b
i = ivp(2, u1*a) / (u1*a * iv(2, u1*a))
X = (1 / (u1*a)**2 + 1 / (u2*a)**2)
P1 = jn(nu, u2*a) * yn(nu, u2*b) - yn(nu, u2*a) * jn(nu, u2*b)
P2 = (jvp(nu, u2*a) * yn(nu, u2*b) - yvp(nu, u2*a) * jn(nu, u2*b)) / (u2 * a)
P3 = (jn(nu, u2*a) * yvp(nu, u2*b) - yn(nu, u2*a) * jvp(nu, u2*b)) / (u2 * b)
P4 = (jvp(nu, u2*a) * yvp(nu, u2*b) - yvp(nu, u2*a) * jvp(nu, u2*b)) / (u2 * a * u2 * b)
A = 2 * nu / (u2 * b)**2 - 1 / (nu - 1)
return (n22 / n32 * (i*P1 + P2) * (n12*i*P3 + n22 * P4) +
(A * i * P1 + A * P2 + i*P3 + P4) * (n12*i*P1 + n22*P2) -
n32 * nu**2 * X**2 * P1 * (A * P1 + P3) -
n22 * nu * X * (nu * X * P1 * P3 + 2 * P1 * P4 - 2 * P2 * P3))
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 __fct3(self, nu, u2r1, u2r2, dn, n2sq, n3sq):
n0sq = (n3sq - n2sq) / (n2sq + n3sq)
b11 = jn(nu, u2r1)
b12 = yn(nu, u2r1)
b21 = jn(nu, u2r2)
b22 = yn(nu, u2r2)
if dn > 0:
b31 = jn(nu+dn, u2r1)
b32 = yn(nu+dn, u2r1)
f1 = b31*b22 - b32*b21
f2 = b11*b22 - b12*b21
else:
b31 = jn(nu+dn, u2r2)
b32 = yn(nu+dn, u2r2)
f1 = b31*b12 - b32*b11
f2 = b12*b21 - b11*b22
return f1 - n0sq * f2
def test_bessely_int(self):
def mpbessely(v, x):
r = float(mpmath.bessely(v, x))
if abs(r) == 0 and x == 0:
# invalid result from mpmath, point x=0 is a divergence
return np.nan
return r
assert_mpmath_equal(lambda v, z: sc.yn(int(v), z),
_exception_to_nan(mpbessely),
[IntArg(-1000, 1000), Arg(-1e8, 1e8)])
def _run(self, rtheta_list, t):
# unpack rtheta_list
r = rtheta_list[0]
theta = rtheta_list[1]
#
alphax = np.zeros((self.Nsum, self.Msum))
# dT = r * R[n,m]
def dTinRun(x, k, m, alphanm, betanm):
Tnm = sp.jn(k, x * alphanm) + betanm * sp.yn(k, x * alphanm)
return x * Tnm
# specific nonhomogeneous contribution \bar T(x,y)
tempnonhom = self.T0 + 2 * self.T1 * theta / np.pi
# general homogeneous contribution \tilde T(x, y, t)
temperature = 0
if self.NonHomogeneousOnly == False:
alphax, betax = CylindricalSandwich.alpha(self, self.Nsum, self.Msum, self.a, self.b)
for n in xrange(self.Nsum): # fragile: n <= 20
k = 2 * (n + 1)
for m in xrange(self.Msum):
alphanm = alphax[n, m] # eigen values based on Bessel Functions
betanm = betax[n, m] # J vs Y weighting
Rnm = CylindricalSandwich.R(self, r, k, m, alphanm, betanm)
#
Rnmb = sp.jn(k, alphanm * self.b) + betanm * sp.yn(k, alphanm * self.b)
Rnma = sp.jn(k, alphanm * self.a) + betanm * sp.yn(k, alphanm * self.a)
Anm = (1./2.) * (self.b**2 - m**2/alphanm**2) * Rnmb - \
(1./2.) * (self.a**2 - m**2/alphanm**2) * Rnma
# Anm = CylindricalSandwich.Anm_analytic(self, self.a, self.b, k, m, alphanm, betanm)
Tnm = (4 * self.T1 / np.pi) * ((-1)**(k/2) / float(k)) * (1 / Anm) * \
quad(dTinRun, self.a, self.b, args=(k, m, alphanm, betanm))[0]
tmp = Tnm * Rnm * np.sin(k * theta) * np.exp(-self.kappa * alphanm * t) # combine Tnm and tmp
temperature += tmp # this line is throwing a waring during the unit test
# add homogeneous and nonhomogeneous
temperature = temperature + tempnonhom
return ExactSolution([r, theta, temperature],
names=['position_r', 'angle_theta',
'temperature'], jumps=[])
def test_bessely_int(self):
def mpbessely(v, x):
r = float(mpmath.bessely(v, x))
if abs(r) == 0 and x == 0:
# invalid result from mpmath, point x=0 is a divergence
return np.nan
return r
assert_mpmath_equal(
lambda v, z: sc.yn(int(v), z), _exception_to_nan(mpbessely),
[IntArg(-1000, 1000), Arg(-1e8, 1e8)])
def Descrete_Hankel_Transfrom(x, ff, phase=0, Nroots=50, h=0.01):
# result(x) = int_0^inf ff(l) J_nv(l*x) ldl
# 1/h: node density; Nroots: # of points to use to approximate the integral
nv = abs(phase)
zeros_PI = jn_zeros(nv,Nroots) / pi
phi_dot = deriv_DEtransform(h * zeros_PI)
y_k = DEtransform(h*zeros_PI) * pi / h
w_nv_k = yn(nv, zeros_PI * pi) / jn(nv + 1, zeros_PI * pi)
J_nv = jn(nv, y_k)
res = pi / x**2 * w_nv_k * y_k * ff(y_k / x) * J_nv * phi_dot
return res.sum() * np.sign(phase + 0.1)**phase # +0.1 to give 1 for phase=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 cutoffHE2(b):
nu = 2
a = rho * b
i = ivp(2, u1 * a) / (u1 * a * iv(2, u1 * a))
X = (1 / (u1 * a)**2 + 1 / (u2 * a)**2)
P1 = jn(nu, u2 * a) * yn(nu, u2 * b) - yn(nu, u2 * a) * jn(nu, u2 * b)
P2 = (jvp(nu, u2 * a) * yn(nu, u2 * b) -
yvp(nu, u2 * a) * jn(nu, u2 * b)) / (u2 * a)
P3 = (jn(nu, u2 * a) * yvp(nu, u2 * b) -
yn(nu, u2 * a) * jvp(nu, u2 * b)) / (u2 * b)
P4 = (jvp(nu, u2 * a) * yvp(nu, u2 * b) -
yvp(nu, u2 * a) * jvp(nu, u2 * b)) / (u2 * a * u2 * b)
A = 2 * nu / (u2 * b)**2 - 1 / (nu - 1)
return (n22 / n32 * (i * P1 + P2) * (n12 * i * P3 + n22 * P4) +
(A * i * P1 + A * P2 + i * P3 + P4) * (n12 * i * P1 + n22 * P2) -
n32 * nu**2 * X**2 * P1 * (A * P1 + P3) - n22 * nu * X *
(nu * X * P1 * P3 + 2 * P1 * P4 - 2 * P2 * P3))
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 _tecoeq(self, v0, nu):
u1r1, u2r1, u2r2, s1, s2, n1sq, n2sq, n3sq = self.__params(v0)
(f11a, f11b) = ((j0(u1r1), jn(2, u1r1)) if s1 > 0 else
(i0(u1r1), -iv(2, u1r1)))
if s2 > 0:
f22a, f22b = j0(u2r2), y0(u2r2)
f2a = jn(2, u2r1) * f22b - yn(2, u2r1) * f22a
f2b = j0(u2r1) * f22b - y0(u2r1) * f22a
else: # a
f22a, f22b = i0(u2r2), k0(u2r2)
f2a = kn(2, u2r1) * f22a - iv(2, u2r1) * f22b
f2b = i0(u2r1) * f22b - k0(u2r1) * f22a
return f11a * f2a - f11b * f2b
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 JnYn(maxn, resolution):
delta = numpy.pi / resolution
z_table = numpy.mgrid[min(minz_j(maxn), minz_y(maxn)) : max(maxz_j(maxn), maxz_y(maxn)) : delta]
J_table = []
Jdot_table = []
Y_table = []
Ydot_table = []
for n in range(maxn + 1):
J_table.append(special.jn(n, z_table))
Jdot_table.append(special.jvp(n, z_table))
Y_table.append(special.yn(n, z_table))
Ydot_table.append(special.yvp(n, z_table))
return z_table, J_table, Jdot_table, Y_table, Ydot_table
def efieldTM(m, k, pts, phase = "re"):
pts = numpy.asarray(pts, dtype = 'd')
r, phi, z = toCyl(pts)
if phase == "re":
trig = numpy.cos(m * phi)
else:
trig = numpy.sin(m * phi)
res = numpy.zeros(r.shape + (3, ), dtype = 'd')
indsIn = r < a
res[indsIn, 2] = jn(m, rtEpsIn * k * r[indsIn]) * trig[indsIn]
indsOut = numpy.logical_and(r >= a, r < b)
xOut = rtEpsOut * k * r[indsOut]
res[indsOut, 2] = aTM(m, k) * jn(m, xOut) + bTM(m, k) * yn(m, xOut)
res[indsOut, 2] *= trig[indsOut]
return res
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 sphericalBesselCondition(x):
if abs(special.yn(1,x))>1:
return True
else:
return False
else:
return False
def sphericalBesselCondition(x):
if abs(special.yn(1,x))>1:
return True
else:
return False
# <codecell>
[conditions(-0.00001),conditions(1.999),conditions(2),conditions(4)]
# <codecell>
[[special.yn(1,0.001),special.yn(1,1)],[sphericalBesselCondition(0.001),sphericalBesselCondition(1)]]
# <headingcell level=4>
# Problem 4
# <codecell>
x = sp.linspace(1,52,52)
xmask = x
num = 0
while sp.corrcoef(x,xmask)[0,1] >.1:
xmask = shuffle(xmask)
num+=1
[num,xmask,sp.corrcoef(x,xmask)[0,1]]
def dyn(n, x, d):
if d == 0:
return yn(n, x)
else:
return 0.5 * (dyn(n - 1, x, d - 1) - dyn(n + 1, x, d - 1))
