PyFiberModes 0.2.1__py3-none-any.whl

PyFiberModes/fiber/solver/mlsif.py

@@ -0,0 +1,289 @@
+from .solver import FiberSolver
+from PyFiberModes import Wavelength, Mode, ModeFamily
+from PyFiberModes import constants
+from math import isnan
+import numpy
+from scipy.special import kn, kvp, k0, k1, jn, jvp, yn, yvp, iv, ivp
+
+
+class Neff(FiberSolver):
+
+    def __call__(self, wl, mode, delta, lowbound):
+        wl = Wavelength(wl)
+        if lowbound is None or isnan(lowbound):
+            pm = None
+            if mode.family is ModeFamily.HE:
+                if mode.m > 1:
+                    pm = Mode(ModeFamily.EH, mode.nu, mode.m - 1)
+            elif mode.family is ModeFamily.EH:
+                pm = Mode(ModeFamily.HE, mode.nu, mode.m)
+            elif mode.m > 1:
+                pm = Mode(mode.family, mode.nu, mode.m - 1)
+
+            if pm:
+                lowbound = self.fiber.neff(pm, wl, delta)
+                if isnan(lowbound):
+                    return lowbound
+            else:
+                lowbound = max(layer.maxIndex(wl)
+                               for layer in self.fiber.layers)
+
+            if mode.family is ModeFamily.LP and mode.nu > 0:
+                pm = Mode(mode.family, mode.nu - 1, mode.m)
+                lb = self.fiber.neff(pm, wl, delta)
+                if isnan(lb):
+                    return lb
+                lowbound = min(lowbound, lb)
+        # try:
+        #     # Use cutoff information if available
+        #     co = self.fiber.cutoff(mode)
+        #     if self.fiber.V0(wl) < co:
+        #         return float("nan")
+
+        #     nco = max(layer.maxIndex(wl) for layer in self.fiber.layers)
+        #     r = self.fiber.innerRadius(-1)
+
+        #     lowbound = min(lowbound, sqrt(nco**2 - (co / (r * wl.k0))**2))
+        # except (NotImplementedError):
+        #     pass
+        # if mode == Mode(ModeFamily.HE, 3, 1):
+        #     print('3', lowbound)
+
+        highbound = self.fiber.minIndex(-1, wl)
+
+        fct = {ModeFamily.LP: self._lpceq,
+               ModeFamily.TE: self._teceq,
+               ModeFamily.TM: self._tmceq,
+               ModeFamily.HE: self._heceq,
+               ModeFamily.EH: self._heceq
+               }
+
+        if lowbound <= highbound:
+            print("impossible bound")
+            return float("nan")
+
+        if (lowbound - highbound) < 10 * delta:
+            delta = (lowbound - highbound) / 10
+
+        return self._findFirstRoot(fct[mode.family], args=(wl, mode.nu),
+                                   lowbound=lowbound-1e-15,
+                                   highbound=highbound+1e-15,
+                                   delta=-delta)
+
+    def _lpfield(self, wl, nu, neff, r):
+        N = len(self.fiber)
+        C = numpy.array((1, 0))
+
+        for i in range(1, N):
+            rho = self.fiber.innerRadius(i)
+            if r < rho:
+                layer = self.fiber.layers[i-1]
+                break
+            A = self.fiber.layers[i-1].Psi(rho, neff, wl, nu, C)
+            C = self.fiber.layers[i].lpConstants(rho, neff, wl, nu, A)
+        else:
+            layer = self.fiber.layers[-1]
+            u = layer.u(rho, neff, wl)
+            C = (0, A[0] / kn(nu, u))
+
+        ex, _ = layer.Psi(r, neff, wl, nu, C)
+        hy = neff * constants.Y0 * ex
+
+        return numpy.array((ex, 0, 0)), numpy.array((0, hy, 0))
+
+    def _tefield(self, wl, nu, neff, r):
+        pass
+
+    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 _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))
+
+    _ehfield = _hefield
+
+    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 _teceq(self, neff, wl, nu):
+        N = len(self.fiber)
+        EH = numpy.empty(4)
+        ri = 0
+
+        for i in range(N-1):
+            ro = self.fiber.outerRadius(i)
+            self.fiber.layers[i].EH_fields(ri, ro, nu, neff, wl, EH, False)
+            ri = ro
+
+        # Last layer
+        _, Hz, Ep, _ = EH
+        u = self.fiber.layers[-1].u(ri, neff, wl)
+
+        F4 = k1(u) / k0(u)
+        return Ep + wl.k0 * ri / u * constants.eta0 * Hz * F4
+
+    def _tmceq(self, neff, wl, nu):
+        N = len(self.fiber)
+        EH = numpy.empty(4)
+        ri = 0
+
+        for i in range(N-1):
+            ro = self.fiber.outerRadius(i)
+            self.fiber.layers[i].EH_fields(ri, ro, nu, neff, wl, EH, True)
+            ri = ro
+
+        # Last layer
+        Ez, _, _, Hp = EH
+        u = self.fiber.layers[-1].u(ri, neff, wl)
+        n = self.fiber.maxIndex(-1, wl)
+
+        F4 = k1(u) / k0(u)
+        return Hp - wl.k0 * ri / u * constants.Y0 * n * n * Ez * F4
+
+    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]
+
+    _ehceq = _heceq

PyFiberModes/fiber/solver/solver.py

@@ -0,0 +1,119 @@
+# This file is part of FiberModes.
+#
+# FiberModes is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# FiberModes is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with FiberModes.  If not, see <http://www.gnu.org/licenses/>.
+
+from itertools import count
+from scipy.optimize import brentq
+import logging
+
+
+class FiberSolver(object):
+
+    """Generic abstract class for callable objects used as fiber solvers."""
+
+    logger = logging.getLogger(__name__)
+    _MCD = 0.1
+
+    def __init__(self, fiber):
+        self.fiber = fiber
+        self.log = []
+        self._logging = False
+
+    def __call__(self, *args, **kwargs):
+        raise NotImplementedError()
+
+    def start_log(self):
+        self.log = []
+        self._logging = True
+
+    def stop_log(self):
+        self._logging = False
+
+    def __record(self, fct):
+        def wrapper(z, *args):
+            r = fct(z, *args)
+            if self._logging:
+                self.log.append((z, r))
+            return r
+        return wrapper
+
+    def _findFirstRoot(self, fct, args=(), lowbound=0, highbound=None,
+                       ipoints=[], delta=0.25, maxiter=None):
+        fct = self.__record(fct)  # For debug purpose.
+        while True:
+            if ipoints:
+                maxiter = len(ipoints)
+            elif highbound:
+                maxiter = int((highbound - lowbound) / delta)
+            assert maxiter is not None
+
+            a = lowbound
+            fa = fct(a, *args)
+            if fa == 0:
+                return a
+
+            for i in range(1, maxiter+1):
+                b = ipoints.pop(0) if ipoints else a + delta
+                if highbound:
+                    if ((b > highbound > lowbound) or
+                            (b < highbound < lowbound)):
+                        self.logger.info("_findFirstRoot: no root found within"
+                                         " allowed range")
+                        return float("nan")
+                fb = fct(b, *args)
+                if fb == 0:
+                    return b
+
+                if (fa > 0 and fb < 0) or (fa < 0 and fb > 0):
+                    z = brentq(fct, a, b, args=args, xtol=1e-20)
+                    fz = fct(z, *args)
+                    if abs(fa) > abs(fz) < abs(fb):  # Skip discontinuities
+                        self.logger.debug("skipped ({}, {}, {})".format(
+                            fa, fz, fb))
+                        return z
+
+                a, fa = b, fb
+            if highbound and maxiter < 100:
+                delta /= 10
+            else:
+                break
+        self.logger.info("maxiter reached ({}, {}, {})".format(
+                            maxiter, lowbound, highbound))
+        return float("nan")
+
+    def _findBetween(self, fct, lowbound, highbound, args=(), maxj=15):
+        fct = self.__record(fct)  # For debug purpose.
+        v = [lowbound, highbound]
+        s = [fct(lowbound, *args), fct(highbound, *args)]
+
+        for j in count():  # probably not needed...
+            if j == maxj:
+                self.logger.warning("_findBetween: max iter reached")
+                return float("nan")
+            for i in range(len(s)-1):
+                a, b = v[i], v[i+1]
+                fa, fb = s[i], s[i+1]
+
+                if (fa > 0 and fb < 0) or (fa < 0 and fb > 0):
+                    z = brentq(fct, a, b, args=args)
+                    fz = fct(z, *args)
+                    if abs(fa) > abs(fz) < abs(fb):  # Skip discontinuities
+                        return z
+
+            ls = len(s)
+            for i in range(ls-1):
+                a, b = v[2*i], v[2*i+1]
+                c = (a + b) / 2
+                v.insert(2*i+1, c)
+                s.insert(2*i+1, fct(c, *args))

PyFiberModes/fiber/solver/ssif.py

@@ -0,0 +1,275 @@
+# This file is part of FiberModes.
+#
+# FiberModes is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# FiberModes is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with FiberModes.  If not, see <http://www.gnu.org/licenses/>.
+
+from .solver import FiberSolver
+from PyFiberModes import Mode, ModeFamily
+from math import sqrt, isnan, isinf
+import numpy
+from scipy.special import jn, jn_zeros, kn, j0, j1, k0, k1, jvp, kvp
+from PyFiberModes.constants import Y0
+import logging
+
+
+class Cutoff(FiberSolver):
+
+    """Cutoff for standard step-index fiber."""
+
+    logger = logging.getLogger(__name__)
+
+    def __call__(self, mode):
+        nu = mode.nu
+        m = mode.m
+
+        if mode.family is ModeFamily.LP:
+            if nu == 0:
+                nu, m = 1, -1
+
+            else:
+                nu -= 1
+        elif mode.family is ModeFamily.HE:
+            if nu == 1:
+                m -= 1
+            else:
+                return self._findHEcutoff(mode)
+
+        return jn_zeros(nu, m)[m - 1]
+
+    def _cutoffHE(self, V0, nu):
+        wl = self.fiber.toWl(V0)
+        n02 = self.fiber.maxIndex(0, wl)**2 / self.fiber.minIndex(1, wl)**2
+        return (1 + n02) * jn(nu - 2, V0) - (1 - n02) * jn(nu, V0)
+
+    def _findHEcutoff(self, mode):
+        if mode.m > 1:
+            pm = Mode(mode.family, mode.nu, mode.m - 1)
+            lowbound = self.fiber.cutoff(pm)
+            if isnan(lowbound) or isinf(lowbound):
+                raise AssertionError("_findHEcutoff: no previous cutoff for"
+                                     "{} mode".format(str(mode)))
+            delta = 1 / lowbound if lowbound else self._MCD
+            lowbound += delta
+        else:
+            lowbound = delta = self._MCD
+        ipoints = numpy.concatenate((jn_zeros(mode.nu, mode.m),
+                                     jn_zeros(mode.nu - 2, mode.m)))
+        ipoints.sort()
+        ipoints = list(ipoints[ipoints > lowbound])
+        co = self._findFirstRoot(self._cutoffHE,
+                                 args=(mode.nu,),
+                                 lowbound=lowbound,
+                                 ipoints=ipoints,
+                                 delta=delta)
+        if isnan(co):
+            self.logger.error("_findHEcutoff: no cutoff found for "
+                              "{} mode".format(str(mode)))
+            return 0
+        return co
+
+
+class Neff(FiberSolver):
+
+    """neff for standard step-index fiber"""
+
+    def __call__(self, wl, mode, delta, lowbound):
+        epsilon = 1e-12
+
+        co = self.fiber.cutoff(mode)
+        if self.fiber.V0(wl) < co:
+            return float("nan")
+
+        nco = self.fiber.maxIndex(0, wl)
+        r = self.fiber.outerRadius(0)
+        highbound = sqrt(nco**2 - (co / (r * wl.k0))**2) - epsilon
+
+        if mode.family is ModeFamily.LP:
+            nm = Mode(ModeFamily.LP, mode.nu+1, mode.m)
+        elif mode.family is ModeFamily.HE:
+            nm = Mode(ModeFamily.LP, mode.nu, mode.m)
+        elif mode.family is ModeFamily.EH:
+            nm = Mode(ModeFamily.LP, mode.nu+2, mode.m)
+        else:
+            nm = Mode(ModeFamily.LP, 1, mode.m+1)
+        co = self.fiber.cutoff(nm)
+        try:
+            lowbound = max(sqrt(nco**2 - (co / (r * wl.k0))**2) + epsilon,
+                           self.fiber.minIndex(-1, wl) + epsilon)
+        except ValueError:
+            lowbound = nco
+
+        fct = {ModeFamily.LP: self._lpceq,
+               ModeFamily.TE: self._teceq,
+               ModeFamily.TM: self._tmceq,
+               ModeFamily.HE: self._heceq,
+               ModeFamily.EH: self._ehceq
+               }
+
+        return self._findBetween(fct[mode.family], lowbound, highbound,
+                                 args=(wl, mode.nu))
+
+    def _lpfield(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)
+
+        if r < rho:
+            ex = j0(u * r / rho) / j0(u)
+        else:
+            ex = k0(w * r / rho) / k0(w)
+        hy = neff * Y0 * ex  # Snyder & Love uses nco, but Bures uses neff
+
+        return numpy.array((ex, 0, 0)), numpy.array((0, hy, 0))
+
+    def _tefield(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)
+
+        if r < rho:
+            hz = -Y0 * u / (k * rho) * j0(u * r / rho) / j1(u)
+            ephi = -j1(u * r / rho) / j1(u)
+        else:
+            hz = Y0 * w / (k * rho) * k0(w * r / rho) / k1(w)
+            ephi = -k1(w * r / rho) / k1(w)
+        hr = -neff * Y0 * ephi
+
+        return numpy.array((0, ephi, 0)), numpy.array((hr, 0, hz))
+
+    def _tmfield(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)
+
+        if r < rho:
+            ez = -u / (k * neff * rho) * j0(u * r / rho) / j1(u)
+            er = j1(u * r / rho) / j1(u)
+            hphi = Y0 * nco2 / neff * er
+        else:
+            ez = nco2 / ncl2 * w / (k * neff * rho) * k0(w * r / rho) / k1(w)
+            er = nco2 / ncl2 * k1(w * r / rho) / k1(w)
+            hphi = Y0 * nco2 / ncl2 * k1(w * r / rho) / k1(w)
+
+        return numpy.array((er, 0, ez)), numpy.array((0, hphi, 0))
+
+    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))
+
+    _ehfield = _hefield
+
+    def _uw(self, wl, neff):
+        r = self.fiber.outerRadius(0)
+        rk0 = r * wl.k0
+        return (rk0 * sqrt(self.fiber.maxIndex(0, wl)**2 - neff**2),
+                rk0 * sqrt(neff**2 - self.fiber.minIndex(1, wl)**2))
+
+    def _lpceq(self, neff, wl, nu):
+        u, w = self._uw(wl, neff)
+        return (u * jn(nu - 1, u) * kn(nu, w) +
+                w * jn(nu, u) * kn(nu - 1, w))
+
+    def _teceq(self, neff, wl, nu):
+        u, w = self._uw(wl, neff)
+        return u * j0(u) * k1(w) + w * j1(u) * k0(w)
+
+    def _tmceq(self, neff, wl, nu):
+        u, w = self._uw(wl, neff)
+        nco = self.fiber.maxIndex(0, wl)
+        ncl = self.fiber.minIndex(1, wl)
+        return (u * j0(u) * k1(w) * ncl**2 +
+                w * j1(u) * k0(w) * nco**2)
+
+    def _heceq(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 _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))