diff --git a/docs/notebooks/BroadcastedPolarimetry.ipynb b/docs/notebooks/BroadcastedPolarimetry.ipynb index ecc15e0..0659323 100644 --- a/docs/notebooks/BroadcastedPolarimetry.ipynb +++ b/docs/notebooks/BroadcastedPolarimetry.ipynb @@ -6,13 +6,13 @@ "source": [ "# Fast, Broadcasted Mueller Polarimetry\n", "\n", + "_written by Jaren N. Ashcraft_\n", + "\n", "`katsu` was built in part to understand the spatially-varying polarized response of optics. Manufacturing errors can leave phase and amplitude aberrations in an optical beam, and understanding these sources of error is critical to understanding our system.\n", "\n", "To spatially resolve this data, we need to be able to do full polarimetry on an array of pixels - so a naive implementation of the algorithm will take a very long time to run. Here, we show off the numpy optimizations done to speed up the polarimetric data reduction for Full Mueller Polarimetry.\n", "\n", - "Readers should first be familiar with the Full Mueller Polarimetry demo\n", - "\n", - "_written by Jaren Ashcraft_" + "Readers should first be familiar with the Full Mueller Polarimetry demo" ] }, { diff --git a/docs/notebooks/CalibratingPolarimeters.ipynb b/docs/notebooks/CalibratingPolarimeters.ipynb index 1c8cf76..81ea4e2 100644 --- a/docs/notebooks/CalibratingPolarimeters.ipynb +++ b/docs/notebooks/CalibratingPolarimeters.ipynb @@ -1,8 +1,21 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calibrating Mueller Polarimeters - Simulation\n", + "\n", + "In this tutorial we will review how `katsu` can be used to perform the calibration of DRRPs. Generally this technique is somewhat model-based, because it requires the construction of a polarization data reduction matrix $\\mathbf{W}$ from models of our polarization state generator and analyzer.\n", + "\n", + "But, what if you don't know their exact state? \n", + "\n", + "It's common to use commercial off-the-shelf components for our waveplates and polarizers, but the retardence and diattenuation are not guarenteed for these" + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -12,105 +25,104 @@ " linear_polarizer,\n", " linear_retarder,\n", " linear_diattenuator\n", - ")" + ")\n", + "\n", + "from katsu.polarimetry import broadcasted_full_mueller_polarimetry" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "polarizer_angle_1 = np.random.random()\n", - "polarizer_angle_2 = np.random.random()\n", - "\n", - "retarder_angle_1 = np.random.random()\n", - "retarder_angle_2 = np.random.random()" + "guess_pol_params = [0, # psgpol angle\n", + " np.pi/2, # psa angle\n", + " 0, # psgret angle\n", + " 0, # psaret angle\n", + " np.pi/2, # psgret retardance\n", + " np.pi/2] # psaret retardance\n", + "true_pol_params = [p + np.random.random()/10 for p in guess_pol_params]" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def m_fwd(a):\n", "\n", - " polang1, polang2, retang1, retang2 = a[0], a[1], a[2], a[3]\n", - "\n", - " ## Build the forward model\n", - " # build PSG\n", - " psg = linear_retarder(retang1, np.pi/2) @ linear_polarizer(polang1)\n", + " polang1, polang2, retang1, retang2, ret1, ret2 = a[0], a[1], a[2], a[3], a[4], a[5]\n", "\n", - " # build PSA\n", - " psa = linear_polarizer(polang2) @ linear_retarder(retang2, np.pi/2)\n", - "\n", - " # system\n", - " total = psa @ psg\n", - "\n", - " # modeled irradiance\n", - " I = total[..., 0, 0]\n", - "\n", - " # Now the truth\n", - " true_M = linear_polarizer(np.pi/2) @ linear_retarder(np.pi/4, np.pi/2) @ linear_retarder(np.pi/10, np.pi/2) @ linear_polarizer(0)\n", - " true_I = true_M[..., 0, 0]\n", + " \n", "\n", " return (I - true_I)**2" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " fun: 3.3420258623272954e-15\n", - " hess_inv: <4x4 LbfgsInvHessProduct with dtype=float64>\n", - " jac: array([-4.29546817e-08, 4.24794664e-08, 6.16342601e-08, -5.34759102e-08])\n", - " message: 'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n", - " nfev: 40\n", - " nit: 6\n", - " njev: 8\n", - " status: 0\n", + " message: CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL\n", " success: True\n", - " x: array([-0.1455775 , 0.09747455, -0.13116726, 1.2432434 ])\n" + " status: 0\n", + " fun: 4.7678044542371367e-14\n", + " x: [ 5.408e-01 1.035e-01 5.786e-01 6.867e-01 1.050e-02\n", + " 6.440e-01]\n", + " nit: 4\n", + " jac: [-1.269e-07 1.741e-07 -1.270e-09 -4.341e-08 -4.594e-09\n", + " -1.737e-08]\n", + " nfev: 42\n", + " njev: 6\n", + " hess_inv: <6x6 LbfgsInvHessProduct with dtype=float64>\n" ] } ], "source": [ "from scipy.optimize import minimize\n", - "results = minimize(m_fwd,x0=(polarizer_angle_1,polarizer_angle_2,retarder_angle_1,retarder_angle_2),method='L-BFGS-B')\n", + "results = minimize(m_fwd,x0=guess_pol_params,method='L-BFGS-B')\n", "print(results)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0, 0.3141592653589793, 0.7853981633974483, 1.5707963267948966]\n" + "[0.525556233612956, 0.1242341545076937, 0.5783983696215821, 0.6813338883135133, 0.00985510712712001, 0.6418720464960674]\n" ] }, { "data": { "text/plain": [ - "array([-0.1455775 , 0.09747455, -0.13116726, 1.2432434 ])" + "array([0.5408466 , 0.10346372, 0.57855067, 0.68666164, 0.01050236,\n", + " 0.64404705])" ] }, - "execution_count": 22, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "print([0, np.pi/10, np.pi/4, np.pi/2])\n", + "print(pol_params)\n", "results.x" ] }, @@ -156,7 +168,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/docs/notebooks/FullMuellerExample.ipynb b/docs/notebooks/FullMuellerExample.ipynb index 2aed2d2..c9cb118 100644 --- a/docs/notebooks/FullMuellerExample.ipynb +++ b/docs/notebooks/FullMuellerExample.ipynb @@ -17,7 +17,8 @@ "metadata": {}, "source": [ "# Dual Rotating Retarder Mueller Polarimetry\n", - "So you want to measure a Mueller matrix, that's neat. To do so we use the Dual Rotating Retarder Polarimeter (DRRP). This consists of:\n", + "In order to measure how a system transforms the polarization state of light, we can measure the system's Mueller Matrix. There are a host of different methods by which we can do so. In this tutorial, we review the popular Dual Rotating Retarder Polarimeter (DRRP) for full Mueller matrix polarimetry. This consists of:\n", + "\n", "- a source\n", "- a linear polarizer at a fixed angle\n", "- a quarter-wave plate that can rotate\n", @@ -26,9 +27,9 @@ "- a linear polarizer at a fixed angle\n", "- a detector to measure power\n", "\n", - "The theory of this polarimeter is covered in Chipman, and also Azzam, but is reproduced in brief here. Our first polarizer/waveplate pair forms our *polarization state generator* (PSG). The latter pair forms our *polarization state analyzer* (PSA). The first waveplate must rotate $N_{meas} > 16$ times at some angular step size $\\delta\\theta$. The second waveplate must also rotate $N_{meas}$ times, but at five times the step size $5\\delta\\theta$.\n", + "The theory of this polarimeter is covered in Chipman, and also Azzam, but is reproduced in brief here. Our first polarizer/waveplate pair forms our *polarization state generator* (PSG). The latter pair forms our *polarization state analyzer* (PSA). The first waveplate must rotate $N_{meas} > 16$ times at some angular step size $\\delta\\theta$ to completely determine the Mueller matrix. The second waveplate must also rotate $N_{meas}$ times, but at five times the step size $5\\delta\\theta$.\n", "\n", - "For each $\\delta\\theta$ we record the power on the detector. We next must understand that detectors can only measure power! This means, that it effectively measures the first row of the PSA matrix and the first column of the PSG matrix. The reason for that is revealed in the mueller calculus, which I've left as an exercise to the reader below*\n", + "For each $\\delta\\theta$ we record the power on the detector. We next must understand that detectors can only measure power! This means, that it effectively measures the first row of the PSA matrix and the first column of the PSG matrix. The reason for that is revealed in the Mueller calculus, which I've left as an exercise to the reader below*\n", "\n", "$$\\mathbf{S}_{out} = [\\mathbf{PSA}] \\mathbf{M}_{system} [\\mathbf{PSG}] \\mathbf{S_{0}}$$\n", "\n", @@ -36,11 +37,11 @@ "\n", "$$\\mathbf{W} = [\\mathbf{PSA}_{0,j}] \\otimes [\\mathbf{PSG}_{i,0}]$$\n", "\n", - "Where $i,j$ are the row and column indices, respectively, and $\\otimes$ is the Kronecker product. For each measurement, we record the power on the detector and store it in a vector that is $N_{meas}$ long, called $\\mathbf{P}$, and we computpe the unraveled mueller matrix using the following relation:\n", + "Where $i,j$ are the row and column indices, respectively, and $\\otimes$ is the Kronecker product. For each measurement, we record the power on the detector and store it in a vector that is $N_{meas}$ long, called $\\mathbf{P}$, and we computpe the unraveled Mueller matrix using the following relation:\n", "\n", "$$\\mathbf{M}_{meas} = \\mathbf{W}^{-1}\\mathbf{P}$$\n", "\n", - "For the case where $N_{meas} > 16$, you must use the moore-penrose pseudo inverse to invert $\\mathbf{W}$. Now that the theory is out of the way, let's test it out!\n", + "For the case where $N_{meas} > 16$, you must use the moore-penrose pseudo inverse to invert $\\mathbf{W}$. Now that the theory is out of the way, let's test it out! We begin by constructing a random Mueller matrix composed of a polarizer and retarder:\n", "\n", "*aren't I the worst?" ] @@ -53,10 +54,10 @@ { "data": { "text/plain": [ - "array([[5.00000000e-01, 4.99915695e-01, 9.18137207e-03, 0.00000000e+00],\n", - " [4.01478997e-01, 4.01411304e-01, 7.37225609e-03, 0.00000000e+00],\n", - " [1.98600791e-02, 1.98567305e-02, 3.64685551e-04, 0.00000000e+00],\n", - " [2.97355330e-01, 2.97305193e-01, 5.46025985e-03, 0.00000000e+00]])" + "array([[ 0.5 , 0.09029522, 0.49177919, 0. ],\n", + " [ 0.11102659, 0.02005034, 0.10920113, 0. ],\n", + " [ 0.48566558, 0.08770656, 0.47768045, 0. ],\n", + " [-0.0424505 , -0.00766615, -0.04175255, 0. ]])" ] }, "metadata": {}, @@ -64,7 +65,6 @@ } ], "source": [ - "# Start by generating a random mueller matrix composed of a polarizer and retarder\n", "M_to_measure = linear_retarder(np.random.random(),np.random.random()) @ linear_polarizer(np.random.random())\n", "display(M_to_measure)" ] @@ -75,14 +75,26 @@ "metadata": {}, "source": [ "## Performing a simulated measurement\n", - "This mode of `full_mueller_polarimetry` uses an internal simulator where the Mueller matrix is known, and is largely useful for 1) making sure the algorithm works and 2) testing the theoretical limits of the technique. We can provide it with the matrix above and it carries out the method described earlier. Let's see how it does! We begin with the minimum number of measurements, 16." + "In `katsu.polarimetry` we have This mode of `full_mueller_polarimetry` uses an internal simulator where the Mueller matrix is known, and is largely useful for 1) making sure the algorithm works and 2) testing the theoretical limits of the technique. We can provide it with the matrix above and it carries out the method described earlier. Let's see how it does! We begin with the minimum number of measurements, 16." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "full_mueller_polarimetry() missing 2 required positional arguments: 'power' and 'angular_increment'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# katsu has a simulator built-in, so let's try use that\u001b[39;00m\n\u001b[1;32m 2\u001b[0m thetas \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m0\u001b[39m,np\u001b[38;5;241m.\u001b[39mpi,\u001b[38;5;241m16\u001b[39m) \u001b[38;5;66;03m# 16 measurements between 0 and pi\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m M_out \u001b[38;5;241m=\u001b[39m full_mueller_polarimetry(thetas,Min\u001b[38;5;241m=\u001b[39mM_to_measure)\n", + "\u001b[0;31mTypeError\u001b[0m: full_mueller_polarimetry() missing 2 required positional arguments: 'power' and 'angular_increment'" + ] + } + ], "source": [ "# katsu has a simulator built-in, so let's try use that\n", "thetas = np.linspace(0,np.pi,16) # 16 measurements between 0 and pi\n", @@ -283,12 +295,13 @@ "- 1) Katsu assumes that the mueller matrix is measured w.r.t. the axis of the linear polarizers as horizontal\n", "- 2) Katsu assumes that the linear polarizers are parallel\n", "- 3) Katsu assumes that the fast-axis of the quarter-wave plates begin parallel to the polarizers\n", - "- 4) Katsu operates on scalar powers, meaning that it can only presently process one pixel at a time\n", - "\n", - "These changes are easy to implement, it's just worth noting that they are not present in the codebase yet!\n", - "\n", - "**name preliminary, still thinking of a better one" + "- 4) Katsu operates on scalar powers, meaning that it can only presently process one pixel at a time" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { @@ -307,7 +320,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.11.5" }, "orig_nbformat": 4 }, diff --git a/docs/notebooks/FullStokesExample.ipynb b/docs/notebooks/FullStokesExample.ipynb index a102ff7..8521d74 100644 --- a/docs/notebooks/FullStokesExample.ipynb +++ b/docs/notebooks/FullStokesExample.ipynb @@ -6,8 +6,6 @@ "metadata": {}, "outputs": [], "source": [ - "from katsu.polarimetry import full_stokes_polarimetry\n", - "from katsu.mueller import linear_polarizer,linear_retarder\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] @@ -18,19 +16,21 @@ "metadata": {}, "source": [ "# Single Rotating Retarder Stokes Polarimetry\n", - "Stokes polarimetry is a little more simple than full mueller matrices, but the procedure is very much the same. We will use the Single Rotating Retarder Stokes Polarimeter (SRRP). This consists of\n", + "_Written by Jaren N. Ashcraft_\n", + "In optics we are frequently interested in understanding the polarization state of light. In cases where we are simply curious about the polarization of the source, we desire to measure the Stokes vector of the source. One method of realizing this in the laboratory is with the Single Rotating Retarder Stokes Polarimeter (SRRP). This consists of:\n", + "\n", "- a source with some polarization state\n", "- a quarter-wave plate that can rotate\n", "- a linear polarizer at a fixed angle\n", "- a detector to measure power\n", "\n", - "We will be rotating the quarter wave plate in steps of $\\delta\\theta$ over a range to span the poincare sphere to sample all of the possible responses of power on our detector. To know the Stokes vector, we must take a minimum of 4 measurements. These work out analytically to be the vertices of a tetrahedron inscribed in the poincare sphere, but to make it easier we will generalize the polarimeter to N measurements.\n", + "We will be rotating the quarter wave plate in steps of $\\delta\\theta$ over a range to span the poincare sphere to sample all of the possible responses of power on our detector. To know the Stokes vector, we must take a minimum of 4 measurements to completely determine the vector. These work out analytically to be the vertices of a tetrahedron inscribed in the Poincare sphere, but to make it easier we will generalize the polarimeter to N measurements.\n", "\n", "For each measurement, we step the QWP by some angle $\\delta\\theta$ and record the power on our detector. It turns out that the power we observe should follow a sinusoid of 4 frequencies*.\n", "\n", "$$P \\propto a_{0} + a_{2}sin(2\\theta) + a_{4}cos(4\\theta) + b_{4}cos(4\\theta)$$\n", "\n", - "We simply record the power change, and use optimization to curve fit our results to $P$. The stokes vector can be expressed in terms of these coefficients.\n", + "We simply record the power change, and use optimization to curve fit our results to $P$. The Stokes vector can be expressed in terms of these coefficients.\n", "\n", "$$I = 2(a_{0}-a_{4})$$\n", "$$Q = 4a_{4}$$\n", @@ -39,7 +39,7 @@ "\n", "Here we show a demo of how to use the katsu.full_stokes_polarimetry function to reduce the data.\n", "\n", - "*depending on what you consider a frequency this could be 2-4. Semantics I say! There are 4 terms we care about!" + "*depending on what you consider a frequency this could be 2-4. What I mean to say there are 4 terms we care about." ] }, { @@ -51,12 +51,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0.5588569 0.35077517 0.93880784 0.53997475]\n" + "[0.7292107 0.03863661 0.26421782 0.73299779]\n" ] } ], "source": [ "# First we begin with a simulated dataset and provide the function with a stokes vector\n", + "from katsu.polarimetry import full_stokes_polarimetry\n", + "from katsu.mueller import linear_polarizer, linear_retarder\n", + "\n", "thetas = np.linspace(0,np.pi,10)\n", "S_to_measure = np.random.random(4)\n", "print(S_to_measure)" @@ -72,9 +75,9 @@ "output_type": "stream", "text": [ "Stokes Vector Measured\n", - "[0.5588569 0.35077517 0.93880784 0.53997475]\n", + "[0.7292107 0.03863661 0.26421782 0.73299779]\n", "Percent Difference\n", - "[-1.98659624e-14 1.58252797e-14 1.18258815e-14 0.00000000e+00]\n" + "[ 1.52249963e-14 -1.25715620e-13 8.40384672e-14 1.51463353e-14]\n" ] } ], @@ -101,14 +104,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -139,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -147,9 +148,9 @@ "output_type": "stream", "text": [ "Stokes Vector Measured\n", - "[0.5588569 0.35077517 0.93880784 0.53997475]\n", + "[0.7292107 0.03863661 0.26421782 0.73299779]\n", "Percent Difference\n", - "[-1.98659624e-14 1.58252797e-14 1.18258815e-14 0.00000000e+00]\n" + "[ 1.52249963e-14 -1.25715620e-13 8.40384672e-14 1.51463353e-14]\n" ] } ], @@ -160,14 +161,6 @@ "print('Percent Difference')\n", "print(100*(S_to_measure-S_out)/S_to_measure)" ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fantastic! Stokes polarimetry works!" - ] } ], "metadata": { @@ -186,7 +179,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.11.5" }, "orig_nbformat": 4 }, diff --git a/docs/notebooks/MuellerCalculus.ipynb b/docs/notebooks/MuellerCalculus.ipynb index 72777e6..2d854cc 100644 --- a/docs/notebooks/MuellerCalculus.ipynb +++ b/docs/notebooks/MuellerCalculus.ipynb @@ -15,6 +15,7 @@ "$$\\mathbf{s} = [I, Q, U, V] = [S_{0}, S_{1}, S_{2}, S_{3}].$$\n", "\n", "$\\mathbf{s}$ is a 4-vector that contains the _Stokes parameters_ that describe the polarization of light. Intuitively, the parameters can be described by a set of measurements made using the following six power measurements:\n", + "\n", " - $P_{H}$: A power measurement made with a linear polarizer oriented at $0^{\\circ}$\n", " - $P_{V}$: A power measurement made with a linear polarizer oriented at $90^{\\circ}$\n", " - $P_{+}$: A power measurement made with a linear polarizer oriented at $45^{\\circ}$\n",