changes into new qx format

.ipynb_checkpoints/rugate_d-checkpoint.ipynb

@@ -5,49 +5,11 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2018-11-04T08:04:23.031Z"
+     "end_time": "2018-11-24T08:08:06.174626Z",
+     "start_time": "2018-11-24T07:52:46.148236Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0 3.5364400617784897\n",
-      "5 2.824247002189513\n",
-      "10 2.3462630380353606\n",
-      "15 1.9657988439545293\n",
-      "20 1.7431834173401826\n",
-      "25 1.5548321006945318\n",
-      "30 1.4273202243105385\n",
-      "35 1.324341384452208\n",
-      "40 0.792594549254551\n",
-      "45 0.792594549254551\n",
-      "50 0.792594549254551\n",
-      "55 0.6011330622003288\n",
-      "60 0.6011330622003288\n",
-      "65 0.5913752343291452\n",
-      "70 0.5913752343291452\n",
-      "75 0.5913752343291452\n",
-      "80 0.5913752343291452\n",
-      "85 0.5913752343291452\n",
-      "90 0.49733505560725083\n",
-      "95 0.49733505560725083\n",
-      "100 0.49733505560725083\n",
-      "105 0.49733505560725083\n",
-      "110 0.49733505560725083\n",
-      "115 0.49733505560725083\n",
-      "120 0.49733505560725083\n",
-      "125 0.49733505560725083\n",
-      "130 0.49733505560725083\n",
-      "135 0.49733505560725083\n",
-      "140 0.49733505560725083\n",
-      "145 0.49733505560725083\n",
-      "150 0.4092137422382544\n",
-      "155 0.4092137422382544\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import warnings\n",
     "warnings.filterwarnings(\"ignore\",category =RuntimeWarning)\n",
@@ -56,17 +18,17 @@
     "import de2 as de\n",
     "import multiprocessing as mp\n",
     "    \n",
-    "def arc_0(qx, lam_min=400, lam_max=800, npoints=50):\n",
-    "    cthick = qx[0]\n",
-    "    q_x = qx[1:]\n",
-    "    Rs0, Rp0 = mkq.tmm_lam_parallel(q_x, cthick, 0, n_par=12, lam_low=lam_min, lam_high=lam_max, lam_pts=npoints, n_subs=1.52)\n",
-    "    return np.mean(Rs0)\n",
+    "# def arc_0(qx, lam_min=400, lam_max=800, npoints=50):\n",
+    "#     cthick = qx[0]\n",
+    "#     q_x = qx[1:]\n",
+    "#     Rs0, Rp0 = mkq.tmm_lam_parallel(q_x, cthick, 0, n_par=12, lam_low=lam_min, lam_high=lam_max, lam_pts=npoints, n_subs=1.52)\n",
+    "#     return np.mean(Rs0)\n",
     "    \n",
-    "def arc_dig_0(qx, lam_min=400, lam_max=800, npoints=50):\n",
-    "    cthick = qx[0]\n",
-    "    q_x = mkq.digitize_qx(qx[1:], dlevels=2)\n",
-    "    Rs0, Rp0 = mkq.tmm_lam_parallel(q_x, cthick, 0, n_par=12, lam_low=lam_min, lam_high=lam_max, lam_pts=npoints, n_subs=1.52)\n",
-    "    return np.mean(Rs0)\n",
+    "# def arc_dig_0(qx, lam_min=400, lam_max=800, npoints=50):\n",
+    "#     cthick = qx[0]\n",
+    "#     q_x = mkq.digitize_qx(qx[1:], dlevels=2)\n",
+    "#     Rs0, Rp0 = mkq.tmm_lam_parallel(q_x, cthick, 0, n_par=12, lam_low=lam_min, lam_high=lam_max, lam_pts=npoints, n_subs=1.52)\n",
+    "#     return np.mean(Rs0)\n",
     "\n",
     "\n",
     "def tmm_wrapper2(arg):\n",
@@ -76,7 +38,7 @@
     "\n",
     "def arc_par(pop, **kwargs):\n",
     "    jobs = []\n",
-    "    pool=mp.Pool(12)\n",
+    "    pool=mp.Pool(60)\n",
     "    for indiv in pop:\n",
     "        indivi = mkq.digitize_qx(indiv[1:], dlevels=2)\n",
     "        jobs.append((indivi, indiv[0], 0))\n",
@@ -86,7 +48,7 @@
     "    return np.mean(answ, axis=1)\n",
     "\n",
     "    \n",
-    "num_layers = 40\n",
+    "num_layers = 35 \n",
     "bnds = [(0, 1)]*num_layers\n",
     "bnds = [(300, 400)] + bnds\n",
     "its_first = 0\n",
@@ -96,7 +58,7 @@
     "pop = np.ones((psnew, 1+ num_layers))\n",
     "for indiv in range(psnew):\n",
     "    pop[indiv,1:] = mkq.make_qx(num_layers)\n",
-    "    pop[indiv,0] = 500 \n",
+    "    pop[indiv,0] = np.random.uniform(    bnds[0][0], bnds[0][1], 1 )\n",
     "    \n",
     "b, c, hstry = de.de_cp(fobj=arc_par, bounds=bnds, pop=pop, history=[], it_start=its_first, popsize=psnew, its=its_second, lam_low=400, lam_high=800, lam_pts=50)\n",
     "\n",
@@ -112,14 +74,297 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2018-11-04T07:55:59.342116Z",
-     "start_time": "2018-11-04T07:55:55.500769Z"
+     "start_time": "2018-11-25T05:56:13.149Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 14.620526569593837\n",
+      "5 14.620526569593837\n",
+      "10 14.620526569593837\n",
+      "15 14.620526569593837\n",
+      "20 9.74940559015386\n",
+      "25 8.272239076481561\n",
+      "30 8.272239076481561\n",
+      "35 7.104313257254263\n",
+      "40 4.295486548704374\n",
+      "45 2.380561145573948\n",
+      "50 2.380561145573948\n",
+      "55 2.380561145573948\n",
+      "60 1.717713024452679\n",
+      "65 1.717713024452679\n",
+      "70 1.717713024452679\n",
+      "75 1.717713024452679\n",
+      "80 1.3160948342395318\n",
+      "85 1.3123680110893694\n",
+      "90 0.9706808480376451\n",
+      "95 0.8869983624926128\n",
+      "100 0.8869983624926128\n",
+      "105 0.8869983624926128\n",
+      "110 0.7612086009656585\n",
+      "115 0.7612086009656585\n",
+      "120 0.7345701574595528\n",
+      "125 0.5480017639146584\n",
+      "130 0.5480017639146584\n",
+      "135 0.5480017639146584\n",
+      "140 0.47102733135844466\n",
+      "145 0.34366533410402916\n",
+      "150 0.34366533410402916\n",
+      "155 0.34366533410402916\n",
+      "160 0.34366533410402916\n",
+      "165 0.34366533410402916\n",
+      "170 0.34366533410402916\n",
+      "175 0.34366533410402916\n",
+      "180 0.34366533410402916\n",
+      "185 0.34366533410402916\n",
+      "190 0.34366533410402916\n",
+      "195 0.34366533410402916\n",
+      "200 0.34366533410402916\n",
+      "205 0.34366533410402916\n"
+     ]
+    }
+   ],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\",category =RuntimeWarning)\n",
+    "import numpy as np\n",
+    "import makeqx as mkq\n",
+    "import de2 as de\n",
+    "import multiprocessing as mp\n",
+    "import qxnew as qn    \n",
+    "# def arc_0(qx, lam_min=400, lam_max=800, npoints=50):\n",
+    "#     cthick = qx[0]\n",
+    "#     q_x = qx[1:]\n",
+    "#     Rs0, Rp0 = mkq.tmm_lam_parallel(q_x, cthick, 0, n_par=12, lam_low=lam_min, lam_high=lam_max, lam_pts=npoints, n_subs=1.52)\n",
+    "#     return np.mean(Rs0)\n",
+    "    \n",
+    "# def arc_dig_0(qx, lam_min=400, lam_max=800, npoints=50):\n",
+    "#     cthick = qx[0]\n",
+    "#     q_x = mkq.digitize_qx(qx[1:], dlevels=2)\n",
+    "#     Rs0, Rp0 = mkq.tmm_lam_parallel(q_x, cthick, 0, n_par=12, lam_low=lam_min, lam_high=lam_max, lam_pts=npoints, n_subs=1.52)\n",
+    "#     return np.mean(Rs0)\n",
+    "\n",
+    "\n",
+    "def tmm_wrapper2(arg):\n",
+    "    args, kwargs = arg\n",
+    "    return qn.tmm_eval_wsweep(*args, **kwargs)\n",
+    "\n",
+    "\n",
+    "def arc_par(pop, **kwargs):\n",
+    "    jobs = []\n",
+    "    pool=mp.Pool(90)\n",
+    "    for indiv in pop:\n",
+    "        indiv = indiv.reshape((int(indiv.size/2), 2))\n",
+    "        indiv[:,1] = mkq.digitize_qx(indiv[:,1], dlevels=2)\n",
+    "        indiv = indiv.flatten()\n",
+    "        jobs.append((indiv, 0.5, 8 , 0))\n",
+    "    arg = [(j, kwargs) for j in jobs]\n",
+    "    answ = np.array(pool.map(tmm_wrapper2, arg))\n",
+    "    pool.close()\n",
+    "    return np.mean(answ, axis=1)\n",
+    "\n",
+    "    \n",
+    "num_layers = 50\n",
+    "d_min = 0.5\n",
+    "d_max = 8\n",
+    "\n",
+    "bnds = [(d_min, d_max), (0,1) ]*num_layers\n",
+    "#bnds = [(300, 400)] + bnds\n",
+    "its_first = 0\n",
+    "psnew = 320\n",
+    "its_second = 500\n",
+    "\n",
+    "pop = np.ones((psnew, 2*num_layers))\n",
+    "for indiv in range(psnew):\n",
+    "    pop[indiv] = qn.make_qxn(num_layers, dlevels=2)\n",
+    "    pop[indiv][::2] = (d_max - d_min)*pop[indiv][::2] + d_min\n",
+    "    pop[indiv,0] = np.random.uniform(    bnds[0][0], bnds[0][1], 1 )\n",
+    "    \n",
+    "b, c, hstry = de.de_cp(fobj=arc_par, bounds=bnds, pop=pop, history=[], it_start=its_first, popsize=psnew, its=its_second, lam_low=400, lam_high=800, lam_pts=50)\n",
+    "\n",
+    "np.sum(b[::2]), b[::2], b[1::2], c\n",
+    "\n",
+    "#m1 = mkq.tmm_eval2(qx=pop[0][1:], cthick=pop[0][0]) \n",
+    "#m2 = mkq.tmm_eval(qx=pop[0][1:], cthick=pop[0][0]) \n",
+    "\n",
+    "#"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-25T05:28:27.167141Z",
+     "start_time": "2018-11-25T05:28:27.159054Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(33.093934964446646,\n",
+       " array([2.44511696, 6.27208212, 1.19221335, 0.5       , 2.13392   ,\n",
+       "        0.5       , 1.17464269, 0.5       , 0.5       , 0.5       ,\n",
+       "        0.5       , 0.5       , 0.5       , 0.5       , 1.01725833,\n",
+       "        1.33161583, 0.5       , 0.5       , 0.5       , 0.5       ,\n",
+       "        1.50581117, 0.5356352 , 1.51977252, 0.5       , 0.5       ,\n",
+       "        2.        , 0.5       , 2.9658668 , 0.5       , 0.5       ]),\n",
+       " array([0., 0., 0., 1., 0., 0., 1., 1., 1., 1., 0., 0., 1., 0., 1., 1., 1.,\n",
+       "        0., 1., 0., 1., 0., 1., 1., 0., 0., 1., 0., 1., 1.]),\n",
+       " 0.47579005978506084)"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-04T12:53:39.666806Z",
+     "start_time": "2018-11-04T12:53:39.659691Z"
     }
    },
    "outputs": [],
    "source": [
-    "np.savetxt(X=b, fname='b.txt')"
+    "import makeqx as mkq\n",
+    "mkq.make_qx(10)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-04T13:56:02.195399Z",
+     "start_time": "2018-11-04T13:56:02.187776Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "bnds[0][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-24T09:33:46.310018Z",
+     "start_time": "2018-11-24T09:33:46.290131Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "import qxnew as qn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-24T09:33:48.151601Z",
+     "start_time": "2018-11-24T09:33:48.128603Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "qx = qn.make_qxn(40,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-24T09:33:50.326789Z",
+     "start_time": "2018-11-24T09:33:50.307053Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "qx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-24T07:07:44.202457Z",
+     "start_time": "2018-11-24T07:07:44.180095Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "qn.make_nxdx(qx, d_min=2, d_max=10, wavelen=550, n_substrate=1.52)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-24T07:07:45.345103Z",
+     "start_time": "2018-11-24T07:07:45.322470Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "qn.tmm_eval_wbk(qx, 2, 10, 0, 550, 1.52)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-11-24T07:07:47.293093Z",
+     "start_time": "2018-11-24T07:07:47.155314Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from jupyterthemes import jtplot\n",
+    "# currently installed theme will be used to\n",
+    "# set plot style if no arguments provided\n",
+    "jtplot.style()\n",
+    "Rs = qn.tmm_eval_wsweep(qx, d_min=2 , d_max=10, inc_ang=0, lam_low=400, lam_high=800, lam_pts=50, n_subs=1.52)  # in nm\n",
+    "lams = np.linspace(400, 800, endpoint=True, num=50)\n",
+    "plt.plot(lams, Rs )\n",
+    "plt.xlabel('Wavelength (nm)')\n",
+    "plt.ylabel('Reflectance (%)')\n",
+    "plt.ylim([0,100])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

de2.py

@@ -48,10 +48,11 @@ def de_cp(
                 if f[j] < fitness[best_idx]:
                     best_idx = j
                     best = trial_denorm[j]
-        if i%5 == 0:
+
+        if (i+1)%20 == 0:
             print(i, fitness[best_idx])
         history.append([i, fitness[best_idx]])
-    return best, fitness[best_idx], history
+    return pop, best_idx, fitness[best_idx], best
 
     
     

qxnew.py

@@ -0,0 +1,260 @@
+import snlay as sn
+import numpy as np
+from scipy import interpolate
+from noise import pnoise1
+import random
+from tmm import coh_tmm
+import multiprocessing as mp
+import makeqx as mkq
+#import pyximport; pyximport.install(pyimport=True)
+#import mtmm as mtmm
+
+
+# make a materials dictionary
+matsdict = {
+    1: "./materials/gold.dat",
+    2: "./materials/silicon.dat",
+    3: "./materials/silica.dat",
+    4: "./materials/tio2.dat",
+    5: "./materials/silver.dat",
+}
+
+
+def get_nk(datafile, wavelengths):
+    """Reads the given file and returns the n+ik complex at
+    the given wavelength after suitable interpolation
+    :datafile: TODO
+    :wavelength: TODO
+    :returns: TODO
+    """
+    rawdisp = np.loadtxt(datafile)
+    f_r = interpolate.interp1d(rawdisp[:, 0], rawdisp[:, 1])
+    f_i = interpolate.interp1d(rawdisp[:, 0], rawdisp[:, 2])
+    return f_r(wavelengths) + 1j * f_i(wavelengths)
+
+
+def nk_2_eps(n):
+    """TODO: Docstring for nk_2_epsnk_2_eps.
+    :returns: complex epsilon given n and kappa 
+    """
+    eps_r = n.real ** 2 - n.imag ** 2
+    eps_i = 2 * n.real * n.imag
+    return eps_r + 1j * eps_i
+
+
+def eps_2_nk(eps):
+    """TODO: Docstring for nk_2_epsnk_2_eps.
+    :returns: complex epsilon given n and kappa 
+    """
+    modeps = np.abs(eps)
+    n_r = np.sqrt(0.5 * (modeps + eps.real))
+    n_i = np.sqrt(0.5 * (modeps - eps.real))
+    return n_r + 1j * n_i
+
+
+def LL_mixing(fH, n_H, n_L):
+    """TODO: Docstring for brugg_mixingbrugg_mixing.
+    Given the volumne fraction of the higher index material, give the effective
+    index of the layer
+    :fH: volumne fraction from 0 to 1 
+    :n_H: ri  of the higher index material 
+    :n_L: ri of the lower index material 
+    :returns: TODO
+    """
+    eH = nk_2_eps(n_H)
+    eL = nk_2_eps(n_L)
+    bigK = fH * (eH - 1) / (eH + 2) + (1 - fH) * (eL - 1) / (eL + 2)
+    e_eff = (1 + 2 * bigK) / (1 - bigK)
+    return eps_2_nk(e_eff)
+
+
+def make_qxn(num_layers, dlevels=0):
+    """TODO: Docstring for make_qxn.
+
+    :num_layers: TODO
+    :returns: TODO
+
+    """
+    uni = np.linspace(0, 2*num_layers, 2*num_layers, endpoint=False)
+    rwalk = np.zeros_like(uni).reshape((num_layers,2))
+    rwalk[:,0] = mkq.make_qx(num_layers)
+    if dlevels != 0:
+        rwalk[:,1] = mkq.digitize_qx(mkq.make_qx(num_layers), dlevels)
+    else:
+        rwalk[:,1] = mkq.make_qx(num_layers)
+    return rwalk.flatten()
+
+
+
+def make_nxdx(qx, d_min, d_max, wavelen=550, n_substrate=1.52):
+    """TODO: Docstring for make_nxdx.
+    :qx: TODO
+    :n_substrate: TODO
+    :layer_thickness: TODO
+    :returns: TODO
+    """
+    num_layers = int(qx.size/2)
+    qx = qx.reshape((num_layers, 2))
+    #d_x = d_min + (d_max - d_min)*qx[:,0] 
+    d_x = qx[:,0]
+    d_x = [np.inf] + d_x.tolist() + [np.inf]
+    sde = LL_mixing(
+            fH=qx[:,1], n_H=2.58, n_L=1.45  # get_nk(datafile=matsdict[3], wavelengths=wavelen),
+    )  # get_nk(datafile=matsdict[4], wavelengths=wavelen
+    #   ))
+    n_x = [1.0] + sde.tolist() + [n_substrate]
+    return d_x, n_x
+
+
+# def tmm_eval2(
+#     qx,
+#     cthick,
+#     lam_low=400,  # in nm
+#     lam_high=1200,
+#     lam_pts=100,
+#     ang_low=0,  # degrees
+#     ang_high=90,
+#     ang_pts=25,
+#     n_subs=1.52,
+# ):
+#     """TODO: Docstring for tmm_eval.
+#     :qx: TODO
+#     :lam_low: TODO
+#     :#in nm 
+#         lam_high: TODO
+#     :lam_pts: TODO
+#     :ang_low: TODO
+#     :#degrees
+#         ang_high: TODO
+#     :ang_pts: TODO
+#     :returns: TODO
+
+#     """
+#     degree = np.pi / 180
+#     lams = np.linspace(lam_low, lam_high, endpoint=True, num=lam_pts)
+#     thetas = np.linspace(ang_high, ang_low, endpoint=True, num=ang_pts)
+#     Rs = np.zeros((thetas.size, lams.size))
+#     Rp = np.zeros((thetas.size, lams.size))
+
+#     for tidx, theta in enumerate(thetas):
+#         for lidx, lam in enumerate(lams):
+#             d_x, n_x = make_nxdx(qx=qx, cthick=cthick, wavelen=lam, n_substrate=n_subs)
+#             Rs[tidx, lidx] = 100 * coh_tmm(
+#                 "s", n_x, d_x, th_0=theta * degree, lam_vac=lam
+#             )
+#             Rp[tidx, lidx] = 100 * coh_tmm(
+#                 "p", n_x, d_x, th_0=theta * degree, lam_vac=lam
+#             )
+#     return Rs, Rp
+
+
+# def tmm_eval(
+#     qx,
+#     cthick,
+#     lam_low=400,  # in nm
+#     lam_high=1200,
+#     lam_pts=100,
+#     ang_low=0,  # degrees
+#     ang_high=90,
+#     ang_pts=25,
+#     n_subs=1.52,
+# ):
+#     """TODO: Docstring for tmm_eval.
+#     :qx: TODO
+#     :lam_low: TODO
+#     :#in nm 
+#         lam_high: TODO
+#     :lam_pts: TODO
+#     :ang_low: TODO
+#     :#degrees
+#         ang_high: TODO
+#     :ang_pts: TODO
+#     :returns: TODO
+
+#     """
+#     degree = np.pi / 180
+#     lams = np.linspace(lam_low, lam_high, endpoint=True, num=lam_pts)
+#     thetas = np.linspace(ang_high, ang_low, endpoint=True, num=ang_pts)
+#     Rs = np.zeros((thetas.size, lams.size))
+#     Rp = np.zeros((thetas.size, lams.size))
+
+#     for tidx, theta in enumerate(thetas):
+#         for lidx, lam in enumerate(lams):
+#             d_x, n_x = make_nxdx(qx=qx, cthick=cthick, wavelen=lam, n_substrate=n_subs)
+#             Rs[tidx, lidx] = 100 * coh_tmm(
+#                 "s", n_x, d_x, th_0=theta * degree, lam_vac=lam
+#             )
+#             Rp[tidx, lidx] = 100 * coh_tmm(
+#                 "p", n_x, d_x, th_0=theta * degree, lam_vac=lam
+#             )
+#     return Rs, Rp
+
+
+def tmm_eval_wbk(qx, d_min , d_max, inc_ang, lam, n_subs=1.52):
+    """TODO: Docstring for tmm_eval.
+    :qx: TODO
+    :returns: TODO
+    """
+    degree = np.pi / 180
+    d_x, n_x = make_nxdx(qx=qx, d_min=d_min, d_max=d_max, wavelen=lam, n_substrate=n_subs)
+    Rs = 100 * coh_tmm("s", n_x, d_x, th_0=inc_ang * degree, lam_vac=lam)
+    #     Rp = 100*coh_tmm('p',n_x,d_x, th_0=inc_ang*degree,lam_vac=lam)
+    return Rs
+
+
+def tmm_eval_wsweep(
+    qx, d_min , d_max, inc_ang, lam_low=400, lam_high=1200, lam_pts=100, n_subs=1.52  # in nm
+):
+    """TODO: Docstring for tmm_eval.
+    :qx: TODO
+    :lam_low: TODO
+     lam_high: TODO
+    :lam_pts: TODO
+    :returns: TODO
+    """
+    degree = np.pi / 180
+    lams = np.linspace(lam_low, lam_high, endpoint=True, num=lam_pts)
+    Rs = np.zeros(lams.size)
+    # Rp = np.zeros(lams.size)
+    for lidx, lam in enumerate(lams):
+        d_x, n_x = make_nxdx(qx=qx, d_min=0, d_max=1, wavelen=lam, n_substrate=n_subs)
+        Rs[lidx] = 100 * coh_tmm("s", n_x, d_x, th_0=inc_ang * degree, lam_vac=lam)
+        # Rp[lidx] = 100*coh_tmm('p',n_x,d_x, th_0=inc_ang*degree,lam_vac=lam)
+    return Rs
+
+
+# def tmm_wrapper2(arg):
+#     args, kwargs = arg
+#     return tmm_eval_wbk(*args, **kwargs)
+
+
+# def tmm_lam_parallel(
+#     q_x, cthick, inc_ang, n_par=12, lam_low=400, lam_high=1200, lam_pts=100, **kwargs
+# ):
+
+#     jobs = []
+#     pool = mp.Pool(n_par)
+#     lams = np.linspace(lam_low, lam_high, endpoint=True, num=lam_pts)
+#     for lam in lams:
+#         jobs.append((q_x, cthick, inc_ang, lam))
+#     arg = [(j, kwargs) for j in jobs]
+#     answ = np.array(pool.map(tmm_wrapper2, arg))
+#     pool.close()
+#     return answ[:, 0], answ[:, 1]
+
+
+# def tmm_wrapper(arg):
+#     args, kwargs = arg
+#     return tmm_eval_wsweep(*args, **kwargs)
+
+
+# def tmm_eval_parallel(q_x, cthick, n_ang=25, n_par=10, **kwargs):
+#     jobs = []
+#     pool = mp.Pool(n_par)
+#     angs = np.linspace(90, 0, endpoint=True, num=n_ang)
+#     for ang in angs:
+#         jobs.append((q_x, cthick, ang))
+#     arg = [(j, kwargs) for j in jobs]
+#     answ = np.array(pool.map(tmm_wrapper, arg))
+#     pool.close()
+#     return answ[:, 0, :], answ[:, 1, :]