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 _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 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 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 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 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 __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 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 _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))