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)