PyFiberModes 0.2.1__py3-none-any.whl

PyFiberModes/fiber/material/sio2geo2cm.py

@@ -0,0 +1,43 @@
+# 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 .claussiusmossotti import ClaussiusMossotti
+import numpy
+
+
+class SiO2GeO2(ClaussiusMossotti):
+
+    '''
+    classdocs
+    '''
+
+    name = "Silica doped with Germania (Claussius-Mossotti version)"
+    nparams = 1
+    WLRANGE = (0.6e-6, 1.8e-6)
+    XRANGE = 0.2
+
+    A = numpy.array([0.2045154578, 0.06451676258, 0.1311583151])
+    B = numpy.array([-0.1011783769, 0.1778934999, -0.1064179581])
+    Z = numpy.array([0.06130807320e-6, 0.1108859848e-6, 8.964441861e-6])
+
+    @classmethod
+    def info(cls):
+        return "Silica doped with Germania."
+
+# Article (Sunak1989)
+# Sunak, H. & Bastien, S.
+# Refractive index and material dispersion interpolation of doped silica
+# in the 0.6-1.8 mu m wavelength region
+# Photonics Technology Letters, IEEE, 1989, 1, 142-145

PyFiberModes/fiber/solver/__init__.py

@@ -0,0 +1,12 @@
+"""A solver gives the function used to find cutoff and/or effective index
+of a given :py:class:`~fibermodes.mode.Mode`
+in a given :py:class:`fibermodes.fiber.fiber.Fiber`.
+
+"""
+
+from . import ssif
+from . import tlsif
+from . import mlsif
+
+
+__all__ = ['ssif', 'tlsif', 'mlsif']

PyFiberModes/fiber/solver/cuda.py

@@ -0,0 +1,124 @@
+# 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/>.
+
+"""Solver using CUDA (Nvidia GPU)"""
+
+from fibermodes.fiber.solver import mlsif
+from fibermodes import Mode, Wavelength, ModeFamily
+import numpy
+import os
+from itertools import cycle
+
+import pycuda.driver as cuda
+import pycuda.autoinit
+from pycuda.compiler import SourceModule
+assert pycuda.autoinit
+
+
+class Neff(mlsif.Neff):
+
+    def __init__(self, fiber):
+        super().__init__(fiber)
+
+        self.NSOLVERS = 1000  # Number of points for the solver
+        self._init_gpu()
+
+    def _init_gpu(self):
+        c_src = ""
+        c_path = os.path.dirname(os.path.realpath(__file__)) + "/cudasrc/"
+        for cfile in ("constf.c", "hypergf.c", "ivf.c",
+                      "knf.c", "besseldiff.c", "chareq.c"):
+            with open(c_path+cfile) as f:
+                c_src += f.read()
+        cudamod = SourceModule(c_src)
+        self.chareq = cudamod.get_function("chareq")
+        self.chareq.prepare("PfPPIPP")
+
+        sof = numpy.dtype(numpy.float32).itemsize
+        self.gpu_neff = cuda.mem_alloc(self.NSOLVERS * sof)
+        r = numpy.array(self.fiber._r, dtype=numpy.float32)
+        self.gpu_r = cuda.mem_alloc(r.nbytes)
+        cuda.memcpy_htod(self.gpu_r, r)
+        self.gpu_n = cuda.mem_alloc(len(self.fiber) * sof)
+        soi = numpy.dtype(numpy.int32).itemsize
+        self.gpu_nu = cuda.mem_alloc(soi)
+        self.x = numpy.empty((1, self.NSOLVERS), dtype=numpy.float32)
+        self.gpu_x = cuda.mem_alloc(self.x.nbytes)
+
+    def __call__(self, wl, mode, delta, lowbound):
+
+        if mode.nu == 0 or mode.family is ModeFamily.LP:
+            return super().__call__(wl, mode, delta, lowbound)
+
+        wl = Wavelength(wl)
+        nmin = self.fiber.minIndex(-1, wl)
+        nmax = max(layer.maxIndex(wl) for layer in self.fiber.layers)
+        neff = numpy.linspace(nmin, nmax, self.NSOLVERS).astype(numpy.float32)
+        cuda.memcpy_htod(self.gpu_neff, neff)
+
+        n = numpy.fromiter((layer.minIndex(wl) for layer in self.fiber.layers),
+                           dtype=numpy.float32,
+                           count=len(self.fiber))
+        cuda.memcpy_htod(self.gpu_n, n)
+
+        nu = numpy.array([mode.nu], dtype=numpy.int32)
+        cuda.memcpy_htod(self.gpu_nu, nu)
+
+        self.chareq.prepared_call(
+            (neff.size, nu.size), (5, 4, 2),
+            self.gpu_neff, numpy.float32(wl.k0), self.gpu_r,
+            self.gpu_n, numpy.uint32(n.size), self.gpu_nu,
+            self.gpu_x,
+            shared_size=5*4*2*4)
+
+        cuda.memcpy_dtoh(self.x, self.gpu_x)
+
+        sols = []
+
+        for i in range(self.NSOLVERS-1, 0, -1):
+            if (abs(self.x[0, i]) > 1e5) or (abs(self.x[0, i-1]) > 1e5):
+                continue
+            if ((self.x[0, i-1] < 0 and self.x[0, i] > 0) or
+                    (self.x[0, i-1] > 0 and self.x[0, i] < 0)):
+                sols.append((neff[i-1], neff[i]))
+                # sols.append(self._findBetween(
+                #     self._heceq, neff[i-1], neff[i], args=(wl, mode.nu)))
+
+        famc = cycle((ModeFamily.HE, ModeFamily.EH))
+        m = 1
+        for n in sols:
+            fam = next(famc)
+            self.fiber.set_ne_cache(wl, Mode(fam, mode.nu, m), n)
+            if fam == ModeFamily.EH:
+                m += 1
+
+        try:
+            return self.fiber.ne_cache[wl][mode]
+        except KeyError:
+            return float("nan")
+
+if __name__ == '__main__':
+    from fibermodes import FiberFactory
+
+    f = FiberFactory()
+    f.setSolvers(neff=Neff)
+    f.addLayer(radius=4e-6, index=1.4489)
+    f.addLayer(radius=10e-6, index=1.4474)
+    f.addLayer(index=1.4444)
+    fiber = f[0]
+    wl = 1550e-9
+    modes = fiber.findVmodes(wl)
+    for mode in modes:
+        print(mode, fiber.neff(mode, wl, delta=1e-5))

PyFiberModes/fiber/solver/cudasrc/besseldiff.c

@@ -0,0 +1,28 @@
+
+__device__ float jnp(int n, float z) {
+    if (0 == n)
+        return -jnf(1, z);
+    else
+        return (jnf(n-1, z) - jnf(n+1, z)) / 2.;
+}
+
+__device__ float ynp(int n, float z) {
+    if (0 == n)
+        return -ynf(1, z);
+    else
+        return (ynf(n-1, z) - ynf(n+1, z)) / 2.;
+}
+
+__device__ float ivp(int n, float z) {
+    if (0 == n)
+        return ivf(1, z);
+    else
+        return (ivf(n-1, z) + ivf(n+1, z)) / 2.;
+}
+
+__device__ float knp(int n, float z) {
+    if (0 == n)
+        return -knf(1, z);
+    else
+        return -(knf(n-1, z) + knf(n+1, z)) / 2.;
+}

PyFiberModes/fiber/solver/cudasrc/chareq.c

@@ -0,0 +1,314 @@
+
+#include <math_constants.h>
+
+#define ETA0 376.73031346177066f
+
+#define THREADIDX ((blockDim.x * blockDim.y * threadIdx.z) + (blockDim.x * threadIdx.y) + threadIdx.x)
+#define BLOCKIDX ((gridDim.x * blockIdx.y) + blockIdx.x)
+#define IDX THREADIDX
+// ((BLOCKIDX * blockDim.x * blockDim.y * blockDim.z) + THREADIDX)
+#define IJ(i, j) ((blockDim.x * blockDim.y * threadIdx.z) + (blockDim.x * i) + j)
+#define IZ(i) (blockDim.y * threadIdx.z + i)
+
+#define F(fct, nu, u, r, rho) (fct(nu, u * r / rho) / fct(nu, u))
+#define FP(fct, fctp, nu, u, r, rho) (fctp(nu, u * r / rho) / fct(nu, u))
+
+#define J(nu, u, r, rho) F(jnf, nu, u, r, rho)
+#define Y(nu, u, r, rho) F(ynf, nu, u, r, rho)
+#define I(nu, u, r, rho) F(ivf, nu, u, r, rho)
+#define K(nu, u, r, rho) F(knf, nu, u, r, rho)
+
+#define JP(nu, u, r, rho) FP(jnf, jnp, nu, u, r, rho)
+#define YP(nu, u, r, rho) FP(ynf, ynp, nu, u, r, rho)
+#define IP(nu, u, r, rho) FP(ivf, ivp, nu, u, r, rho)
+#define KP(nu, u, r, rho) FP(knf, knp, nu, u, r, rho)
+
+
+__device__ void solve(float *x) {
+    extern __shared__ float ab[];
+
+    int i, j;
+    int pidx, rpidx, ridx;
+    float temp, temp2;
+
+    for (i=0; i<blockDim.y; ++i) {
+        /* find max pivot */
+        if (threadIdx.y == i) {
+            temp = 0.;
+            for (j=i; j<blockDim.y; ++j) {
+                if ( (temp2 = fabs(ab[IJ(j,i)])) > temp) {
+                    temp = temp2;
+                    pidx = j;
+                }
+            }
+        }
+
+        /* swap rows */
+        __syncthreads();
+        if (threadIdx.y == i && pidx != i) {
+            ridx = IJ(pidx,threadIdx.x);
+            temp = ab[IDX];
+            ab[IDX] = ab[ridx];
+            ab[ridx] = temp;
+        }
+
+        ridx = IJ(i,threadIdx.x);
+        pidx = IJ(i,i);
+        rpidx = IJ(threadIdx.y,i);
+
+        /* row operations */
+        __syncthreads();
+        if (threadIdx.y != i) {
+            if (threadIdx.x > i) {
+                ab[IDX] -= ab[ridx] * ab[rpidx] / ab[pidx];
+            }
+            else if (threadIdx.x == i) {
+                ab[IDX] = 0.;
+            }
+        }
+
+        /* normalize row */
+        __syncthreads();
+        if (threadIdx.y == i) {
+            if (threadIdx.x > i) {
+                ab[IDX] /= ab[pidx];
+            }
+            else if (threadIdx.x == i) {
+                ab[IDX] = 1.;
+            }
+        }
+    }
+
+    /* copy from ab to x */
+    __syncthreads();
+    for (i=0; i<8; ++i) {
+        x[i] = ab[(i / 4) * (blockDim.x * blockDim.y) + blockDim.y + (i % 4)];
+    }
+}
+
+
+__device__ float _chareq(float neff, float k0,
+                         float *r, float *n, unsigned int N,
+                         unsigned int nu) {
+    extern __shared__ float ab[];
+    unsigned int i;
+    float *w, *u;
+    float x[8];
+
+    w = (float *) malloc(N*sizeof(float));
+    u = (float *) malloc(N*sizeof(float));
+
+    for (i=0; i<N; ++i) {
+        w[i] = sqrtf(fabsf(n[i]*n[i] - neff*neff));
+        if (0. == w[i]) {
+            free(w);
+            free(u);
+            return CUDART_INF_F;
+        }
+        u[i] = k0 * r[(i+1 == N)?(i-1):i] * w[i];
+        if (neff > n[i]) {
+            w[i] = -w[i];
+        }
+    }
+
+    /* First layer */
+    if (4 == threadIdx.x) {
+        switch (threadIdx.y) {
+            case 0:
+            case 1:
+                ab[IDX] = (threadIdx.y == threadIdx.z)?1.:0.;
+                break;
+            case 2:
+                if (threadIdx.z == 0) {
+                    ab[IDX] = neff * nu / (u[0] * w[0]);
+                }
+                else {
+                    if (neff < n[0]) {
+                        ab[IDX] = -JP(nu, u[0], 1, 1) * ETA0 / w[0];
+                    }
+                    else {
+                        ab[IDX] = -IP(nu, u[0], 1, 1) * ETA0 / w[0];
+                    }
+                }
+                break;
+            case 3:
+                if (threadIdx.z == 0) {
+                    if (neff < n[0]) {
+                        ab[IDX] = JP(nu, u[0], 1, 1) * n[0] * n[0] / (ETA0 * w[0]);
+                    }
+                    else {
+                        ab[IDX] = IP(nu, u[0], 1, 1) * n[0] * n[0] / (ETA0 * w[0]);
+                    }
+                }
+                else {
+                    ab[IDX] = -neff * nu / (u[0] * w[0]);
+                }
+                break;
+        }
+    }
+
+    /* For each intermediate layer */
+    for (i=1; i<N-1; ++i) {
+        /* Fill matrix */
+        switch (threadIdx.x) {
+            case 0:
+                switch (threadIdx.y) {
+                    case 0:
+                        ab[IDX] = (neff < n[i]) ? J(nu, u[i], r[i-1], r[i]): 
+                                                  I(nu, u[i], r[i-1], r[i]);
+                        break;
+                    case 1:
+                        ab[IDX] = (neff < n[i]) ? Y(nu, u[i], r[i-1], r[i]): 
+                                                  K(nu, u[i], r[i-1], r[i]);
+                        break;
+                    case 2:
+                    case 3:
+                        ab[IDX] = 0.;
+                        break;
+                }
+                break;
+            case 1:
+                switch (threadIdx.y) {
+                    case 0:
+                    case 1:
+                        ab[IDX] = 0.;
+                        break;
+                    case 2:
+                        ab[IDX] = (neff < n[i]) ? J(nu, u[i], r[i-1], r[i]): 
+                                                  I(nu, u[i], r[i-1], r[i]);
+                        break;
+                    case 3:
+                        ab[IDX] = (neff < n[i]) ? Y(nu, u[i], r[i-1], r[i]): 
+                                                  K(nu, u[i], r[i-1], r[i]);
+                        break;
+                }
+                break;
+            case 2:
+                switch (threadIdx.y) {
+                    case 0:
+                        ab[IDX] = ((neff < n[i]) ? J(nu, u[i], r[i-1], r[i]): 
+                                                   I(nu, u[i], r[i-1], r[i])) *
+                                    neff * nu * r[i] / (u[i] * r[i-1] * w[i]);
+                        break;
+                    case 1:
+                        ab[IDX] = ((neff < n[i]) ? Y(nu, u[i], r[i-1], r[i]): 
+                                                   K(nu, u[i], r[i-1], r[i])) *
+                                    neff * nu * r[i] / (u[i] * r[i-1] * w[i]);
+                        break;
+                    case 2:
+                        ab[IDX] = -((neff < n[i]) ? JP(nu, u[i], r[i-1], r[i]): 
+                                                    IP(nu, u[i], r[i-1], r[i])) *
+                                    ETA0 / w[i];
+                        break;
+                    case 3:
+                        ab[IDX] = -((neff < n[i]) ? YP(nu, u[i], r[i-1], r[i]): 
+                                                    KP(nu, u[i], r[i-1], r[i])) *
+                                    ETA0 / w[i];
+                        break;
+                }
+                break;
+            case 3:
+                switch (threadIdx.y) {
+                    case 0:
+                        ab[IDX] = ((neff < n[i]) ? JP(nu, u[i], r[i-1], r[i]): 
+                                                   IP(nu, u[i], r[i-1], r[i])) *
+                                    n[i] * n[i] / (ETA0 * w[i]);
+                        break;
+                    case 1:
+                        ab[IDX] = ((neff < n[i]) ? YP(nu, u[i], r[i-1], r[i]): 
+                                                   KP(nu, u[i], r[i-1], r[i])) *
+                                    n[i] * n[i] / (ETA0 * w[i]);
+                        break;
+                    case 2:
+                        ab[IDX] = -((neff < n[i]) ? J(nu, u[i], r[i-1], r[i]): 
+                                                    I(nu, u[i], r[i-1], r[i])) *
+                                    neff * nu * r[i] / (u[i] * r[i-1] * w[i]);
+                        break;
+                    case 3:
+                        ab[IDX] = -((neff < n[i]) ? Y(nu, u[i], r[i-1], r[i]): 
+                                                    K(nu, u[i], r[i-1], r[i])) *
+                                    neff * nu * r[i] / (u[i] * r[i-1] * w[i]);
+                        break;
+                }
+                break;
+        }
+
+        /* Solve system */
+        __syncthreads();
+        solve(x);
+
+        /* Get E and H values */
+        if (4 == threadIdx.x) {
+            switch (threadIdx.y) {
+                case 0:
+                    ab[IDX] = x[IZ(0)] + x[IZ(1)];
+                    break;
+                case 1:
+                    ab[IDX] = x[IZ(2)] + x[IZ(3)];
+                    break;
+                case 2:
+                    if (neff < n[i])
+                        ab[IDX] = ((neff * nu / (u[i] * w[i])) * (x[IZ(0)] + x[IZ(1)])) - 
+                                  ((ETA0 / w[i]) * (x[IZ(2)] * JP(nu, u[i], 1, 1) + 
+                                                    x[IZ(3)] * YP(nu, u[i], 1, 1)));
+                    else
+                        ab[IDX] = ((neff * nu / (u[i] * w[i])) * (x[IZ(0)] + x[IZ(1)])) - 
+                                  ((ETA0 / w[i]) * (x[IZ(2)] * IP(nu, u[i], 1, 1) + 
+                                                    x[IZ(3)] * KP(nu, u[i], 1, 1)));
+                    break;
+                case 3:
+                    if (neff < n[i])
+                        ab[IDX] = ((n[i] * n[i] / (ETA0 * w[i])) * 
+                                        (x[IZ(0)] * JP(nu, u[i], 1, 1) + 
+                                         x[IZ(1)] * YP(nu, u[i], 1, 1))) - 
+                                  ((neff * nu / (u[i] * w[i])) * (x[IZ(2)] + x[IZ(3)]));
+                    else
+                        ab[IDX] = ((n[i] * n[i] / (ETA0 * w[i])) * 
+                                        (x[IZ(0)] * IP(nu, u[i], 1, 1) + 
+                                         x[IZ(1)] * KP(nu, u[i], 1, 1))) - 
+                                  ((neff * nu / (u[i] * w[i])) * (x[IZ(2)] + x[IZ(3)]));
+                    break;                
+            }
+        }
+
+    }
+
+    __syncthreads();
+
+    /* Find values for last layer */
+    if (neff < n[i]) {
+        /* Leaky mode */
+    }
+    else {
+        /* Guided mode */
+        if (4 == threadIdx.x) {
+            if (2 == threadIdx.y) {
+                ab[IDX] -= (neff * nu / (u[N-1] * w[N-1])) * ab[IJ(0,4)] -
+                            ((ETA0 / w[N-1]) * ab[IJ(1,4)] * KP(nu, u[N-1], 1, 1));
+            }
+            else if (3 == threadIdx.y) {
+                ab[IDX] -= (n[N-1] * n[N-1] / (ETA0 * w[N-1])) * ab[IJ(0,4)] * KP(nu, u[N-1], 1, 1) -
+                            (neff * nu / (u[N-1] * w[N-1])) * ab[IJ(1,4)];
+            }
+        }
+    }
+
+    free(w);
+    free(u);
+
+    __syncthreads();
+
+    return ab[((blockDim.x * 2) + 4)] * ab[((blockDim.x * blockDim.y) + (blockDim.x * 3) + 4)] -
+           ab[((blockDim.x * blockDim.y) + (blockDim.x * 2) + 4)] * ab[((blockDim.x * 3) + 4)];
+}
+
+__global__ void chareq(float *neff, float k0,
+                       float *r, float *n, unsigned int N, unsigned int *nu,
+                       float *x) {
+    float xx;
+
+    xx = _chareq(neff[blockIdx.x], k0, r, n, N, nu[blockIdx.y]);
+    if (0 == threadIdx.x == threadIdx.y == threadIdx.z) {
+        x[BLOCKIDX] = xx;
+    }
+}

PyFiberModes/fiber/solver/cudasrc/constf.c

@@ -0,0 +1,20 @@
+
+#ifdef DEC
+/* MAXNUMF = 2^127 * (1 - 2^-24) */
+__device__ float MAXNUMF = 1.7014117331926442990585209174225846272e38;
+__device__ float MAXLOGF = 88.02969187150841;
+__device__ float MINLOGF = -88.7228391116729996; /* log(2^-128) */
+#else
+/* MAXNUMF = 2^128 * (1 - 2^-24) */
+__device__ float MAXNUMF = 3.4028234663852885981170418348451692544e38;
+__device__ float MAXLOGF = 88.72283905206835;
+__device__ float MINLOGF = -103.278929903431851103; /* log(2^-149) */
+#endif
+
+__device__ float LOG2EF = 1.44269504088896341;
+__device__ float LOGE2F = 0.693147180559945309;
+__device__ float SQRTHF = 0.707106781186547524;
+__device__ float PIF = 3.141592653589793238;
+__device__ float PIO2F = 1.5707963267948966192;
+__device__ float PIO4F = 0.7853981633974483096;
+__device__ float MACHEPF = 5.9604644775390625E-8;