{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Example 4: Light polarimetry\n", "\n", "Light polarimetry consists on measuring the polarization information of a light wave, i.e., its Jones or Stokes vector.\n", "\n", "There are different ways of implementing a light polarimeter. In this example we will describe one of the common ones: a polarimeter composed of a rotating perfect quarter-wave plate (a linear retarder with 90º retardance), a rotating perfect polarizer and a photodetector:\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from scipy.optimize import least_squares\n", "import matplotlib.pyplot as plt\n", "\n", "from py_pol import degrees\n", "from py_pol.jones_vector import Jones_vector\n", "from py_pol.jones_matrix import Jones_matrix, create_Jones_matrices\n", "from py_pol.stokes import Stokes, create_Stokes\n", "from py_pol.mueller import Mueller, create_Mueller" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Jones formalism\n", "\n", "During the previous example, it was explained that a Jones vector can be described using a set of four parameters. There are several possibilities. We will use intensity, alpha, delay and global phase during this example:\n", "\n", "$E_i=\\left[\\begin{array}{c}\n", "\\sqrt{I}\\cos(\\alpha)e^{i\\varphi}\\\\\n", "\\sqrt{I}\\sin(\\alpha)e^{i\\left(\\varphi+\\delta\\right)}\n", "\\end{array}\\right]$.\n", "\n", "Jones formalism uses the electric field as its main variable. However, the detector we have chosen is an intensity detector. In principle, it is not possible to measure the global phase using an intensity detector without using interferometric techniques, so first we will concentrate in measuring the other three:\n", "\n", "$E_i=\\left[\\begin{array}{c}\n", "\\sqrt{I}\\cos(\\alpha)\\\\\n", "\\sqrt{I}\\sin(\\alpha)e^{i\\delta}\n", "\\end{array}\\right]$.\n", "\n", "We can calculate analytically the parameters of the Jones vector if we choose certain angles for the retarder and the polarizer. For example, if we choose $\\theta_R = 0º$, $0º$, $135º$ and $45º$, and $\\theta_D = 0º$, $90º$, $0º$ and $45º$:\n", "\n", "1. $E_{f1}=\\left[\\begin{array}{cc}\n", "1 & 0\\\\\n", "0 & 0\n", "\\end{array}\\right]\\left[\\begin{array}{cc}\n", "1 & 0\\\\\n", "0 & -i\n", "\\end{array}\\right]E_{i}\\qquad\\Rightarrow\\qquad I_{f1}=I\\cos(\\alpha)^2$.\n", "1. $E_{f2}=\\left[\\begin{array}{cc}\n", "0 & 0\\\\\n", "0 & 1\n", "\\end{array}\\right]\\left[\\begin{array}{cc}\n", "1 & 0\\\\\n", "0 & -i\n", "\\end{array}\\right]E_{i}\\qquad\\Rightarrow\\qquad I_{f2}=I\\sin(\\alpha)^2$.\n", "1. $E_{f3}=\\left[\\begin{array}{cc}\n", "1 & 0\\\\\n", "0 & 0\n", "\\end{array}\\right]\\frac{1}{\\sqrt{2}}\\left[\\begin{array}{cc}\n", "1 & -i\\\\\n", "-i & 1\n", "\\end{array}\\right]E_{i}\\qquad\\Rightarrow\\qquad I_{f3}=\\frac{I}{2}\\left(1+\\sin(2\\alpha)\\sin(\\delta)\\right)$.\n", "1. $E_{f4}=\\frac{1}{2}\\left[\\begin{array}{cc}\n", "1 & 1\\\\\n", "1 & 1\n", "\\end{array}\\right]\\frac{1}{\\sqrt{2}}\\left[\\begin{array}{cc}\n", "1 & i\\\\\n", "i & 1\n", "\\end{array}\\right]E_{i}\\qquad\\Rightarrow\\qquad I_{f4}=\\frac{I}{2}\\left(1+\\sin(2\\alpha)\\cos(\\delta)\\right)$\n", "\n", "From those three equations the Jones vector parameters can be calculated:\n", "\n", "1. $I = I_{f1} + I_{f2}$.\n", "1. $\\alpha=\\arctan\\left(\\sqrt{\\frac{I_{f2}}{I_{f1}}}\\right)$.\n", "1. $\\delta=\\arctan\\left(\\frac{2I_{f3}-I}{2I_{f4}-I}\\right)$.\n", "\n", "Take into notice that wee need 4 measurements to correctly determine 3 parameters. This is due to the fact that we are restricted to intensity measurements and the equations relating the parameters and the intensity are nonlinear.\n", "\n", "Let's simulate the experiment. In order to do that, first we will define a function that simulates the intiensity measurements." ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [], "source": [ "def light_polarimeter_measurement(E, angleR, angleD):\n", " \"\"\"This function simulates the light polarimeter measurements.\n", " \n", " Parameters:\n", " E: Incident light wave Jones vector.\n", " angleR: Rotation angle of the quarter-wave plate.\n", " angleD: Rotating angle of the diattenuator (polarizer).\n", " \n", " Returns:\n", " I: Measured intensity.\"\"\"\n", " # Rotate the optical elements\n", " Jr_rotated = Jr.rotate(angle=angleR, keep=True)\n", " Jd_rotated = Jd.rotate(angle=angleD, keep=True)\n", " # Multiply all objects\n", " E_final = Jd_rotated * Jr_rotated * E\n", " # Measure the intensity\n", " I = E_final.parameters.intensity()\n", " # Return\n", " return I" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can simulate our polarimetry experiment now. We will use random values for the light wave to be sure that it works." ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Light wave = \n", "[-0.573-1.286j] \n", "[-0.603+1.354j] \n", "\n", "1.9809213510000316 2.1979257961189473 0.5384698311821164 0.6935508621522547\n", "Comparison\n", " - Intensity:\n", " o Original: 4.178847147118979\n", " o Measured: 4.178847147118979\n", " - Alpha (deg):\n", " o Original: 46.488333180979495\n", " o Measured: 46.48833318097949\n", " - Delay (deg):\n", " o Original: 228.0124947579496\n", " o Measured: 228.0124947579496\n" ] } ], "source": [ "# Start by defining the light wave\n", "I_wave = np.random.rand() * 4 + 1\n", "alpha_wave = np.random.rand() * 90*degrees\n", "delay_wave = np.random.rand() * 360*degrees\n", "E_wave = Jones_vector('Light wave')\n", "E_wave.general_charac_angles(intensity=I_wave, alpha=alpha_wave, delay=delay_wave)\n", "print(E_wave)\n", "\n", "# Now, define the optical elements\n", "Jr, Jd = create_Jones_matrices(('Quarter-wave plate', 'Perfect polarizer'))\n", "Jr.quarter_waveplate(azimuth=0)\n", "Jd.diattenuator_perfect(azimuth=0)\n", "\n", "# Now, define the rotation angles for the optical elements\n", "angles_R = np.array([0*degrees, 0*degrees, 135*degrees, 45*degrees])\n", "angles_D = np.array([0*degrees, 90*degrees, 0*degrees, 45*degrees])\n", "\n", "# Make the measurements\n", "If1, If2, If3, If4 = light_polarimeter_measurement(E_wave, angles_R, angles_D)\n", "print(If1, If2, If3, If4)\n", "\n", "# Calculate the parameters\n", "I_calc = If1 + If2\n", "alpha_calc = np.arctan(np.sqrt(If2/If1))\n", "delay_calc = np.arctan2(2*If3 - I_calc, 2*If4 - I_calc) % (2*np.pi)\n", "\n", "# Compare the result\n", "print('Comparison')\n", "print(' - Intensity:')\n", "print(' o Original: ', I_wave)\n", "print(' o Measured: ', I_calc)\n", "print(' - Alpha (deg):')\n", "print(' o Original: ', alpha_wave/degrees)\n", "print(' o Measured: ', alpha_calc/degrees)\n", "print(' - Delay (deg):')\n", "print(' o Original: ', delay_wave/degrees)\n", "print(' o Measured: ', delay_calc/degrees)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is a different way of calculating the parameters of the Jones vector. We could use a fitting algorithm in order to find those values. However, finding three parameters using just four measurements is very inaccurate, as the optimization algorithm probably will find a sub-optimal solution. For that reason, more measurements should be used.\n", "\n", "Now, we need the function that calculates the difference between the measured values and ones which come from a model using the three parameters that we are going to use to define the Jones vector of the light wave. This function is what the fitting algorithm will minimize." ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [], "source": [ "def intensity_difference(parameters): \n", " \"\"\"This function calculates the difference between the measurements and the model.\n", " \n", " Parameters:\n", " parameters: List containing the intensity, the alpha and the delay.\n", " \n", " Returns:\n", " dI: Intensity difference.\"\"\"\n", " # Measure the intensity\n", " I_meas = light_polarimeter_measurement(E_wave, angles_R, angles_D)\n", " # Calculate the intensity from the model\n", " E_model = Jones_vector('Test wave')\n", " E_model.general_charac_angles(intensity=parameters[0], alpha=parameters[1], delay=parameters[2])\n", " I_model = light_polarimeter_measurement(E_model, angles_R, angles_D)\n", " # Calculate the difference and return it\n", " dI = I_meas - I_model\n", " return dI" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using this function, we can proceed to simulate this new experiment. We will define a function that does it so it is easy to repeat it varying the number of measurements." ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [], "source": [ "def polarimetry_fit(fun, N, tol=None, verbose=True):\n", " \"\"\"Function that calculates the parameters of the Jones vector using N measurements and a fitting algorithm.\n", " \n", " Parameters:\n", " N (int): Number of measurements.\n", " tol (float): Tolerance of the fitting algorithm.\n", " verbose (bool): If True, the function prints the comparison between real and fit variables.\n", " \n", " Returns.\n", " x (list): List containing the fit parameters.\"\"\"\n", " # Prepare the fitting\n", " sup_limit = np.array([5, 90*degrees, 360*degrees])\n", " inf_limit = np.zeros(3)\n", " x0 = np.random.rand(3) * sup_limit\n", " # Make the fitting\n", " result = least_squares(fun=fun, x0=x0, bounds=(inf_limit, sup_limit), ftol=tol, xtol=tol, gtol=tol)\n", "\n", " # Compare the result\n", " if verbose:\n", " print('Comparison')\n", " print(' - Intensity:')\n", " print(' o Original: ', I_wave)\n", " print(' o Measured: ', result.x[0])\n", " print(' - Alpha (deg):')\n", " print(' o Original: ', alpha_wave/degrees)\n", " print(' o Measured: ', result.x[1]/degrees)\n", " print(' - Delay (deg):')\n", " print(' o Original: ', delay_wave/degrees)\n", " print(' o Measured: ', result.x[2]/degrees)\n", " \n", " # Return\n", " return result.x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Do the experiment. We can define the delay in its full 360º now." ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Comparison\n", " - Intensity:\n", " o Original: 3.2323659246916203\n", " o Measured: 3.2305908610014584\n", " - Alpha (deg):\n", " o Original: 5.524599657469298\n", " o Measured: 5.540036175372947\n", " - Delay (deg):\n", " o Original: 0.3269349286564305\n", " o Measured: 359.9999999999935\n" ] } ], "source": [ "# Start by defining the light wave\n", "I_wave = np.random.rand() * 5\n", "alpha_wave = np.random.rand() * 90*degrees\n", "delay_wave = np.random.rand() * 360*degrees\n", "E_wave = Jones_vector('Light wave')\n", "E_wave.general_charac_angles(intensity=I_wave, alpha=alpha_wave, delay=delay_wave)\n", "\n", "# Make the experiment\n", "N = 20\n", "tol = 1e-12\n", "polarimetry_fit(fun=intensity_difference, N=N, tol=tol);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The used parameters usually work, however, the algorithm sometimes finds a sub-optimal solution where $\\delta + \\delta_{fit} = N\\;\\pi$.\n", "\n", "## Mueller-Stokes formalism\n", "\n", "Using a Stokes vector to describe the light wave means that we have four independent parameters to characterize the light wave. As none of them is the global phase (which is not considered in Stokes formalism), at least 4 measurements are needed. Mueller formalism main variable is light intensity, which is what the detector measures. This allows calculating much easier the Stokes vector of the light wave.\n", "\n", "The k-th measurement of the light polarimeter experiment is:\n", "\n", "$S_{f}^{k}=\\left[\\begin{array}{cccc}\n", "A_{00}^{k} & A_{01}^{k} & A_{02}^{k} & A_{03}^{k}\\\\\n", "\\bullet & \\bullet & \\bullet & \\bullet\\\\\n", "\\bullet & \\bullet & \\bullet & \\bullet\\\\\n", "\\bullet & \\bullet & \\bullet & \\bullet\n", "\\end{array}\\right]S_{i}=\\left[\\begin{array}{c}\n", "I^{k}\\\\\n", "\\bullet\\\\\n", "\\bullet\\\\\n", "\\bullet\n", "\\end{array}\\right]$.\n", "\n", "Being $A^{k}=M_D(\\theta_D^{k})*M_R(\\theta_R^{k})$ the Mueller matrix of the analyzer. Due to the fact that the detector only measures the intensity, only some parts of the Mueller matrices and Stokes vectors are important (the rest of the parameters are replaced by $\\bullet$). Then, if we consider the four required measurements:\n", "\n", "$\\left[\\begin{array}{cccc}\n", "A_{00}^{0} & A_{01}^{0} & A_{02}^{0} & A_{03}^{0}\\\\\n", "A_{00}^{1} & A_{01}^{1} & A_{02}^{1} & A_{03}^{1}\\\\\n", "A_{00}^{2} & A_{01}^{2} & A_{02}^{2} & A_{03}^{2}\\\\\n", "A_{00}^{3} & A_{01}^{3} & A_{02}^{3} & A_{03}^{3}\n", "\\end{array}\\right]S_{i}=\\left[\\begin{array}{c}\n", "I^{0}\\\\\n", "I^{1}\\\\\n", "I^{2}\\\\\n", "I^{3}\n", "\\end{array}\\right]$.\n", "\n", "$A'S_i=I'$.\n", "\n", "If $A'$ is invertible ($\\det(A')\\neq0$) then $S_i$ can be easily calculated as $S_i=A'^{-1}I'$. This condition is satisfied if the pair of angles used for the diattenuator and the retarder are not repeated.\n", "\n", "Let us reproduce this numerically. Let us define a new experiment function similar to the one used in Jones formalism, but which include the calculation of the Ak matrix. Also, we will include an error amplitude which we will use in the future." ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [], "source": [ "def light_polarimeter_measurement_Mueller(S, angleR, angleD, Ierror=0):\n", " \"\"\"This function simulates the light polarimeter measurements.\n", " \n", " Parameters:\n", " S: Incident light wave Stokes vector.\n", " angleR: Rotation angle of the quarter-wave plate.\n", " angleD: Rotating angle of the diattenuator (polarizer).\n", " \n", " Returns:\n", " Ik: Measured intensities vector.\n", " Ak: Matrix with the first rows of the analizer matrices.\"\"\"\n", " N = angleR.size\n", " # Rotate the optical elements\n", " Mr_rotated = Mr.rotate(angle=angleR, keep=True)\n", " Md_rotated = Md.rotate(angle=angleD, keep=True)\n", " A = Md_rotated * Mr_rotated\n", " # Multiply all objects\n", " S_final = A * S\n", " # Measure the intensity\n", " Ik = S_final.parameters.intensity() + np.random.randn(N) * Ierror\n", " # Calculate the Ak matrix\n", " Ak = A.parameters.matrix() # Extract the 4x4xN matrix of the py_pol object\n", " Ak = Ak[0,:,:] # Extract all the first rows\n", " Ak = np.transpose(Ak) # Transpose so each row of the final matrix corresponds to a first row of the analizer matrices\n", " # Return\n", " return Ik, Ak" ] }, { "cell_type": "code", "execution_count": 88, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original = \n", "[+3.469] \n", "[+0.168] \n", "[+0.134] \n", "[+2.683] \n", " Calculated = \n", "[+3.469] \n", "[+0.168] \n", "[+0.134] \n", "[+2.683] \n", "\n" ] } ], "source": [ "# Start by defining the light wave\n", "I_wave = np.random.rand(1) * 5\n", "alpha_wave = np.random.rand(1) * 90*degrees\n", "delay_wave = np.random.rand(1) * 360*degrees\n", "degree_pol = np.random.rand(1)\n", "S_wave = Stokes('Original')\n", "S_wave.general_charac_angles(intensity=I_wave, alpha=alpha_wave, delay=delay_wave, degree_pol=degree_pol)\n", "\n", "# Now, define the optical elements\n", "Mr, Md = create_Mueller(('Quarter-wave plate', 'Perfect polarizer'))\n", "Mr.quarter_waveplate(azimuth=0)\n", "Md.diattenuator_perfect(azimuth=0)\n", "\n", "# Now, define the rotation angles for the optical elements\n", "angles_R = np.random.rand(4) * 180*degrees\n", "angles_D = np.random.rand(4) * 180*degrees\n", "\n", "# Make the measurements\n", "Ik, Ak = light_polarimeter_measurement_Mueller(S_wave, angles_R, angles_D)\n", "\n", "# Calculate the original Stokes vector\n", "Ak_inv = np.linalg.inv(Ak)\n", "Ik = np.reshape(Ik, (4,1))\n", "S_calc = Stokes('Calculated')\n", "S_calc.from_matrix(M=Ak_inv@Ik)\n", "\n", "# Compare the result\n", "print(S_wave, S_calc)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Experiments are subject to errors. This means that the calculated Stokes vector will be wrong. However, the error in the calculated Stokes vector can be reduced by oversampling, i.e., taking more than the minimum 4 measurements. In this case, $A'$ will be a Nx4 matrix and $I'$ a Nx1 vector. Then, $S_i$ can be calculated using the pseudo-inverse of $A'$: \n", "\n", "$A^+=(A^T*A)^{-1}*A^T$.\n", "\n", "Let us define a function that performs one polarimetry experiment." ] }, { "cell_type": "code", "execution_count": 89, "metadata": {}, "outputs": [], "source": [ "def light_polariemter_experiment(N, Ierror):\n", " \"\"\"This funcion simulates a polarimetry experiment with errors in the detection.\n", " \n", " Parameters:\n", " N (int): Number of measurements.\n", " Ierror (float): Intensity error amplitude.\n", " \n", " Returns:\n", " dif (numpy.ndarray): Difference between the calculated and the original array.\"\"\"\n", " # Start by defining the light wave\n", " alpha_wave = np.random.rand(1) * 90*degrees\n", " delay_wave = np.random.rand(1) * 360*degrees\n", " degree_pol = np.random.rand(1)\n", " S_wave = Stokes('Original')\n", " S_wave.general_charac_angles(intensity=I_wave, alpha=alpha_wave, delay=delay_wave, degree_pol=degree_pol)\n", "\n", " # Now, define the rotation angles for the optical elements\n", " angles_R = np.random.rand(N) * 180*degrees\n", " angles_D = np.random.rand(N) * 180*degrees\n", "\n", " # Make the measurements\n", " Ik, Ak = light_polarimeter_measurement_Mueller(S_wave, angles_R, angles_D, Ierror=Ierror)\n", "\n", " # Calculate the Stokes vector\n", " Ak_T = np.transpose(Ak)\n", " Ak_inv = np.linalg.inv(Ak_T @ Ak)\n", " Ak_inv = Ak_inv @ Ak_T\n", " Ik = np.reshape(Ik, (N,1))\n", " S_calc = Ak_inv @ Ik\n", " \n", " # Calculate the difference\n", " dif = np.squeeze(S_wave.M - S_calc)\n", "\n", " # Return\n", " return dif" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, lets do the experiment many times, changing the number of measurements and the error amplitude. " ] }, { "cell_type": "code", "execution_count": 90, "metadata": {}, "outputs": [], "source": [ "# Define some variables\n", "Nstat = 100 # Number of experiments done under the same condition.\n", "factors = np.array([0, 0.005, 0.01, 0.02]) # Array of error factors\n", "Ns = np.arange(10, 100, 10) # Array of the number of measurements\n", "tol = 1e-12\n", "I_wave = 1 # We will maintain this parameter constant so we can compare the errors easily\n", "\n", "# Create the result variables\n", "error = np.zeros((4, Ns.size, factors.size))\n", "legend = []\n", "\n", "# Make the loops changing the variables\n", "for indI, factor in enumerate(factors): # Loop in the error amplitude\n", " for indN, N in enumerate(Ns): # Loop in the number of measurements\n", " # Create the temporal variables\n", " aux = np.zeros((4, Nstat))\n", " # Repeat the same conditions several times\n", " for indS in range(Nstat):\n", " # Do the experiment\n", " dif = light_polariemter_experiment(N=N, Ierror=I_wave*factor);\n", " # Calculate the errors\n", " aux[:,indS] = dif\n", " # Calculate the mean square error\n", " error[:, indN, indI] = np.linalg.norm(aux, axis=1) / Nstat\n", " # Create the legend for the plots\n", " legend += ['Ierror = {} %'.format(factor*100)]" ] }, { "cell_type": "code", "execution_count": 91, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'S3')" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot the results\n", "plt.figure(figsize=(12,12))\n", "plt.subplot(2,2,1)\n", "plt.plot(Ns, error[0,:,:])\n", "plt.legend(legend)\n", "plt.xlabel('Number of measurements')\n", "plt.ylabel('S0')\n", "\n", "plt.subplot(2,2,2)\n", "plt.plot(Ns, error[1,:,:])\n", "plt.legend(legend)\n", "plt.xlabel('Number of measurements')\n", "plt.ylabel('S1')\n", "\n", "plt.subplot(2,2,3)\n", "plt.plot(Ns, error[2,:,:])\n", "plt.legend(legend)\n", "plt.xlabel('Number of measurements')\n", "plt.ylabel('S2')\n", "\n", "plt.subplot(2,2,4)\n", "plt.plot(Ns, error[3,:,:])\n", "plt.legend(legend)\n", "plt.xlabel('Number of measurements')\n", "plt.ylabel('S3')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These plots show that the error in the determination of the Stokes vectors is proportional to the initial error amplitude, and can be decreased increasing the number of measurements." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.12" } }, "nbformat": 4, "nbformat_minor": 4 }