PyFiberModes 0.2.1__py3-none-any.whl

PyFiberModes/fiber/fiber.py

@@ -0,0 +1,317 @@
+# 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.
+#
+from . import geometry
+from . import solver
+from .solver.solver import FiberSolver
+from math import sqrt, isnan, isinf
+from PyFiberModes import Wavelength, Mode, ModeFamily
+from PyFiberModes import constants
+from PyFiberModes.functions import derivative
+from PyFiberModes.field import Field
+from itertools import count
+import logging
+from scipy.optimize import fixed_point
+from functools import lru_cache
+
+
+class Fiber(object):
+
+    """The Fiber object usually is build using
+    :py:class:`~PyFiberModes.fiber.factory.FiberFactory`.
+
+    """
+
+    logger = logging.getLogger(__name__)
+
+    def __init__(self, r, f, fp, m, mp, names, Cutoff=None, Neff=None):
+
+        self._r = r
+        self._names = names
+
+        self.layers = []
+        for i, (f_, fp_, m_, mp_) in enumerate(zip(f, fp, m, mp)):
+            ri = self._r[i - 1] if i else 0
+            ro = self._r[i] if i < len(r) else float("inf")
+            layer = geometry.__dict__[f_](ri, ro, *fp_,
+                                          m=m_, mp=mp_, cm=m[-1], cmp=mp[-1])
+            self.layers.append(layer)
+
+        self.co_cache = {Mode("HE", 1, 1): 0,
+                         Mode("LP", 0, 1): 0}
+        self.ne_cache = {}
+
+        self.setSolvers(Cutoff, Neff)
+
+    def __len__(self):
+        return len(self.layers)
+
+    def __str__(self):
+        s = "Fiber {\n"
+        for i, layer in enumerate(self.layers):
+            geom = str(layer)
+            radius = self.outerRadius(i)
+            radius = '' if isinf(radius) else ' {:.3f} µm'.format(radius*1e6)
+            name = self.name(i)
+            name = ' "{}"'.format(name) if name else ''
+            s += "    {}{}{}\n".format(geom, radius, name)
+        s += "}"
+        return s
+
+    def fixedMatFiber(self, wl):
+        f = []
+        fp = []
+        m = []
+        mp = []
+        for layer in self.layers:
+            f.append(layer.__class__.__name__)
+            fp.append(layer._fp)
+            m.append("Fixed")
+            mp.append([layer._m.n(wl, *layer._mp)])
+        return Fiber(self._r, f, fp, m, mp, self._names,
+                     self._cutoff.__class__, self._neff.__class__)
+
+    def name(self, layer):
+        return self._names[layer]
+
+    def _layer(self, r):
+        r = abs(r)
+        for i, r_ in enumerate(self._r):
+            if r < r_:
+                return self.layers[i]
+        return self.layers[-1]
+
+    def innerRadius(self, layer):
+        if layer < 0:
+            layer = len(self._r) + layer + 1
+        return self._r[layer-1] if layer else 0
+
+    def outerRadius(self, layer):
+        return self._r[layer] if layer < len(self._r) else float("inf")
+
+    def thickness(self, layer):
+        return self.outerRadius(layer) - self.innerRadius(layer)
+
+    def index(self, r, wl):
+        return self._layer(r).index(r, wl)
+
+    def minIndex(self, layer, wl):
+        return self.layers[layer].minIndex(wl)
+
+    def maxIndex(self, layer, wl):
+        return self.layers[layer].maxIndex(wl)
+
+    def _findCutoffSolver(self):
+        cutoff = FiberSolver
+        if all(isinstance(layer, geometry.StepIndex)
+               for layer in self.layers):
+            nlayers = len(self)
+            if nlayers == 2:  # SSIF
+                cutoff = solver.ssif.Cutoff
+            elif nlayers == 3:
+                cutoff = solver.tlsif.Cutoff
+        return cutoff
+
+    def _findNeffSolver(self):
+        neff = solver.mlsif.Neff
+        if all(isinstance(layer, geometry.StepIndex)
+               for layer in self.layers):
+            nlayers = len(self)
+            if nlayers == 2:  # SSIF
+                neff = solver.ssif.Neff
+        return neff
+
+    def setSolvers(self, Cutoff=None, Neff=None):
+        assert Cutoff is None or issubclass(Cutoff, FiberSolver)
+        assert Neff is None or issubclass(Neff, FiberSolver)
+        if Cutoff is None:
+            Cutoff = self._findCutoffSolver()
+        self._cutoff = Cutoff(self)
+        if Neff is None:
+            Neff = self._findNeffSolver()
+        self._neff = Neff(self)
+
+    def set_ne_cache(self, wl, mode, neff):
+        try:
+            self.ne_cache[wl][mode] = neff
+        except KeyError:
+            self.ne_cache[wl] = {mode: neff}
+
+    def NA(self, wl):
+        n1 = max(layer.maxIndex(wl) for layer in self.layers)
+        n2 = self.minIndex(-1, wl)
+        return sqrt(n1*n1 - n2*n2)
+
+    def V0(self, wl):
+        return Wavelength(wl).k0 * self.innerRadius(-1) * self.NA(wl)
+
+    def toWl(self, V0, maxiter=500, tol=1e-15):
+        """Convert V0 number to wavelength.
+
+        An iterative method is used, since the index can be wavelength
+        dependant.
+
+        """
+        if V0 == 0:
+            return float("inf")
+        if isinf(V0):
+            return 0
+
+        def f(x):
+            return constants.tpi / V0 * b * self.NA(x)
+
+        b = self.innerRadius(-1)
+
+        wl = f(1.55e-6)
+        if abs(wl - f(wl)) > tol:
+            for w in (1.55e-6, 5e-6, 10e-6):
+                try:
+                    wl = fixed_point(f, w, xtol=tol, maxiter=maxiter)
+                except RuntimeError:
+                    # FIXME: What should we do if it does not converge?
+                    self.logger.info(
+                        "toWl: did not converged from {}µm "
+                        "for V0 = {} (wl={})".format(w * 1e6, V0, wl))
+                if wl > 0:
+                    break
+
+        if wl == 0:
+            self.logger.error("toWl: did not converged for "
+                              "V0 = {} (wl={})".format(V0, wl))
+
+        return Wavelength(wl)
+
+    def cutoff(self, mode):
+        try:
+            return self.co_cache[mode]
+        except KeyError:
+            co = self._cutoff(mode)
+            self.co_cache[mode] = co
+            return co
+
+    def cutoffWl(self, mode):
+        return self.toWl(self.cutoff(mode))
+
+    def neff(self, mode, wl, delta=1e-6, lowbound=None):
+        try:
+            return self.ne_cache[wl][mode]
+        except KeyError:
+            neff = self._neff(Wavelength(wl), mode, delta, lowbound)
+            self.set_ne_cache(wl, mode, neff)
+            return neff
+
+    def beta(self, omega, mode, p=0, delta=1e-6, lowbound=None):
+        wl = Wavelength(omega=omega)
+        if p == 0:
+            neff = self.neff(mode, wl, delta, lowbound)
+            return neff * wl.k0
+
+        m = 5
+        j = (m - 1) // 2
+        h = 1e12  # This value is critical for accurate computation
+        lb = lowbound
+        for i in range(m-1, -1, -1):
+            # Precompute neff using previous wavelength
+            o = omega + (i-j) * h
+            wl = Wavelength(omega=o)
+            lb = self.neff(mode, wl, delta, lb) + delta * 1.1
+
+        return derivative(
+            self.beta, omega, p, m, j, h, mode, 0, delta, lowbound)
+
+    def b(self, mode, wl, delta=1e-6, lowbound=None):
+        """Normalized propagation constant"""
+        neff = self.neff(mode, wl, delta, lowbound)
+        nmax = max(layer.maxIndex(wl) for layer in self.layers)
+        ncl = self.minIndex(-1, wl)
+        ncl2 = ncl*ncl
+        return (neff*neff - ncl2) / (nmax*nmax - ncl2)
+
+    def vp(self, mode, wl, delta=1e-6, lowbound=None):
+        return constants.c / self.neff(mode, wl, delta, lowbound)
+
+    def ng(self, mode, wl, delta=1e-6, lowbound=None):
+        return self.beta(Wavelength(wl).omega,
+                         mode, 1, delta, lowbound) * constants.c
+
+    def vg(self, mode, wl, delta=1e-6, lowbound=None):
+        return 1 / self.beta(
+            Wavelength(wl).omega, mode, 1, delta, lowbound)
+
+    def D(self, mode, wl, delta=1e-6, lowbound=None):
+        return -(self.beta(
+                    Wavelength(wl).omega, mode, 2, delta, lowbound) *
+                 constants.tpi * constants.c * 1e6 / (wl * wl))
+
+    def S(self, mode, wl, delta=1e-6, lowbound=None):
+        return (self.beta(
+                    Wavelength(wl).omega, mode, 3, delta, lowbound) *
+                (constants.tpi * constants.c / (wl * wl))**2 * 1e-3)
+
+    def findVmodes(self, wl, numax=None, mmax=None, delta=1e-6):
+        families = (ModeFamily.HE, ModeFamily.EH, ModeFamily.TE, ModeFamily.TM)
+        return self.findModes(families, wl, numax, mmax, delta)
+
+    def findLPmodes(self, wl, ellmax=None, mmax=None, delta=1e-6):
+        families = (ModeFamily.LP,)
+        return self.findModes(families, wl, ellmax, mmax, delta)
+
+    def findModes(self, families, wl, numax=None, mmax=None, delta=1e-6):
+        """Find all modes of given families, within given constraints
+
+
+
+        """
+        modes = set()
+        v0 = self.V0(wl)
+        for fam in families:
+            for nu in count(0):
+                try:
+                    _mmax = mmax[nu]
+                except IndexError:
+                    _mmax = mmax[-1]
+                except TypeError:
+                    _mmax = mmax
+
+                if (fam is ModeFamily.TE or fam is ModeFamily.TM) and nu > 0:
+                    break
+                if (fam is ModeFamily.HE or fam is ModeFamily.EH) and nu == 0:
+                    continue
+                if numax is not None and nu > numax:
+                    break
+                for m in count(1):
+                    if _mmax is not None and m > _mmax:
+                        break
+                    mode = Mode(fam, nu, m)
+                    try:
+                        co = self.cutoff(mode)
+                        if co > v0:
+                            break
+                    except (NotImplementedError, ValueError):
+                        neff = self.neff(mode, wl, delta)
+                        if isnan(neff):
+                            break
+                    modes.add(mode)
+                if m == 1:
+                    break
+        return modes
+
+    def field(self, mode, wl, r, np=101):
+        """Return electro-magnetic field.
+
+        """
+        return Field(self, mode, wl, r, np)
+
+    @lru_cache(maxsize=None)
+    def _rfield(self, mode, wl, r):
+        neff = self.neff(mode, wl)
+        fct = {ModeFamily.LP: self._neff._lpfield,
+               ModeFamily.TE: self._neff._tefield,
+               ModeFamily.TM: self._neff._tmfield,
+               ModeFamily.EH: self._neff._ehfield,
+               ModeFamily.HE: self._neff._hefield}
+        return fct[mode.family](wl, mode.nu, neff, r)

PyFiberModes/fiber/geometry/__init__.py

@@ -0,0 +1,10 @@
+"""A geometry describes a function applied to the refractive index,
+as function of the radial position.
+
+"""
+
+from .stepindex import StepIndex
+from .supergaussian import SuperGaussian
+
+
+__all__ = ['StepIndex', 'SuperGaussian']

PyFiberModes/fiber/geometry/geometry.py

@@ -0,0 +1,33 @@
+# 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 PyFiberModes.fiber import material
+
+
+class Geometry(object):
+
+    def __init__(self, ri, ro, *fp, m, mp, **kwargs):
+        self._m = material.__dict__[m]()  # instantiate material object
+        self._mp = mp
+        cm = kwargs.get("cm", None)
+        if cm:
+            self._cm = material.__dict__[cm]()
+            self._cmp = kwargs.get("cmp")
+        self._fp = fp
+        self.ri = ri
+        self.ro = ro
+
+    def __str__(self):
+        return self.__class__.__name__ + ' ' + self._m.str(*self._mp)

PyFiberModes/fiber/geometry/stepindex.py

@@ -0,0 +1,181 @@
+from PyFiberModes.fiber.geometry.geometry import Geometry
+from PyFiberModes import constants
+from math import sqrt
+import numpy
+from scipy.special import jn, yn, iv, kn
+from scipy.special import j0, y0, i0, k0
+from scipy.special import j1, y1, i1, k1
+from scipy.special import jvp, yvp, ivp, kvp
+
+
+class StepIndex(Geometry):
+
+    DEFAULT_PARAMS = []
+
+    def index(self, r, wl):
+        if self.ri <= abs(r) <= self.ro:
+            return self._m.n(wl, *self._mp)
+        else:
+            return None
+
+    def minIndex(self, wl):
+        return self._m.n(wl, *self._mp)
+
+    def maxIndex(self, wl):
+        return self._m.n(wl, *self._mp)
+
+    def u(self, r, neff, wl):
+        return wl.k0 * r * sqrt(abs(self.index(r, wl)**2 - neff**2))
+
+    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 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 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 tetmConstants(self, ri, ro, neff, wl, EH, c, idx):
+        a = numpy.empty((2, 2))
+        n = self.maxIndex(wl)
+        u = self.u(ro, neff, wl)
+        urp = self.u(ri, neff, wl)
+
+        if neff < n:
+            B1 = j0(u)
+            B2 = y0(u)
+            F1 = j0(urp) / B1
+            F2 = y0(urp) / B2
+            F3 = -j1(urp) / B1
+            F4 = -y1(urp) / B2
+            c1 = wl.k0 * ro / u
+        else:
+            B1 = i0(u)
+            B2 = k0(u)
+            F1 = i0(urp) / B1
+            F2 = k0(urp) / B2
+            F3 = i1(urp) / B1
+            F4 = -k1(urp) / B2
+            c1 = -wl.k0 * ro / u
+        c3 = c * c1
+
+        a[0, 0] = F1
+        a[0, 1] = F2
+        a[1, 0] = F3 * c3
+        a[1, 1] = F4 * c3
+
+        return numpy.linalg.solve(a, EH.take(idx))