blazing_angle_DMD_interactive.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#HIDDEN\n",
    "# Written by Sebastien Popoff\n",
    "# 29/10/2016\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "from matplotlib import rc\n",
    "# rc('figure', figsize=(14,8))\n",
    "from ipywidgets import interact, interact_manual, FloatSlider\n",
    "#rc('text', usetex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#HIDDEN\n",
    "def mu_function(theta, d, _lambda):      \n",
    "    ## A simple criterion matching the diffraction angle and the reflection angle\n",
    "    _beta = lambda x: (2*theta-x)\n",
    "    return lambda x: 1.*d/_lambda *(np.sin(x)+np.sin(_beta(x)))\n",
    "    # when mu is an integer, we are at a blazing angle with a maximum of energy at the order along the optical axis\n",
    "    # whem mu is n+1/2, the enregy is spread over many diffraction orders not aligned with the optical axis\n",
    "\n",
    "def get_mu(theta_1D, d, _lambda):\n",
    "\n",
    "    mu = mu_function(theta_1D, d, _lambda)\n",
    "    # test different incident angles\n",
    "    alpha_vec = np.linspace(-75,75,400)*np.pi/180\n",
    "    alpha_1D_vec = np.arctan(np.tan(alpha_vec)/np.sqrt(2))\n",
    "    criterion = np.abs(np.mod([mu(a) for a in alpha_1D_vec],1)-0.5)\n",
    "    \n",
    "    return alpha_vec, criterion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#HIDDEN\n",
    "def get_diffraction_pattern(_lambda, d, alpha, theta):\n",
    "\n",
    "    ## A full numerical simulation of the Fourier plane for an all-on configuration\n",
    "    beta = 2*theta-alpha\n",
    "    N_mirrors = 15 # number of mirrors in each direction\n",
    "    gap = 2 # gap between pixels in micron\n",
    "    res = 10 # pixels per mirror (for numerical calculation)\n",
    "    Nx = N_mirrors*res\n",
    "\n",
    "    ## Pixelate image function\n",
    "    f = np.ones([N_mirrors,N_mirrors]) # all-on configuration\n",
    "    ## Phase slope due to incident and reflection angle\n",
    "    X,Y = np.meshgrid(np.arange(N_mirrors),np.arange(N_mirrors))\n",
    "    phi = np.exp((X-Y)*complex(0,1)*2*np.pi/_lambda*d*(np.sin(alpha)+np.sin(beta)))\n",
    "    ## cell unit\n",
    "    Cell = np.zeros([res,res])\n",
    "    gpix = int(np.round(gap/(2.*d)*res))\n",
    "    Cell[gpix:res-gpix,gpix:res-gpix] = 1.\n",
    "    ## Mirror image\n",
    "    MI = np.zeros([Nx,Nx],dtype='complex')\n",
    "    for i in range(N_mirrors):\n",
    "        for j in range(N_mirrors):\n",
    "            MI[i*res:(i+1)*res,j*res:(j+1)*res]= f[i,j]*phi[i,j]*Cell\n",
    "            \n",
    "    ## In the Fourier plane\n",
    "    coeff = 5\n",
    "    FP = np.fft.fftshift(np.fft.fft2(MI,s=[coeff*Nx,coeff*Nx]))\n",
    "    ROIsize = 300\n",
    "    ROI = 1\n",
    "    \n",
    "    return FP[coeff*Nx//2-ROIsize//2:coeff*Nx//2+ROIsize//2,coeff*Nx//2-ROIsize//2:coeff*Nx//2+ROIsize//2]\n",
    "    \n",
    "def make_figure(_lambda, d, alpha, theta):\n",
    "    \n",
    "    theta = theta/180*np.pi\n",
    "    alpha = alpha/180*np.pi\n",
    "    alpha_1D = np.arctan(np.tan(alpha)/np.sqrt(2))\n",
    "    theta_1D = np.arctan(np.tan(theta)/np.sqrt(2))\n",
    "    \n",
    "    far_field = get_diffraction_pattern(_lambda, d, alpha_1D, theta_1D)\n",
    "    alpha_vec, mu_vec = get_mu(theta_1D, d, _lambda)\n",
    "    mu = mu_function(theta_1D, d, _lambda)\n",
    "    \n",
    "    f, (a0, a1) = plt.subplots(1, 2, gridspec_kw={'width_ratios': [2, 1]}, figsize = (18,6))\n",
    "    a0.plot(alpha_vec*180/np.pi,mu_vec,linewidth = 2)\n",
    "    mu_alpha = np.abs(np.mod(mu(alpha_1D),1)-0.5)\n",
    "    label = fr' $\\alpha = {alpha*180/np.pi:.1f}°$, $\\mu = {mu_alpha:.2f}$' \n",
    "    a0.plot([alpha*180/np.pi,alpha*180/np.pi],[0.,0.5],label = label,linewidth = 2)\n",
    "    a0.set_xticks(np.arange(-75,75+15,15))\n",
    "    a0.set_xticklabels(np.arange(-75,75+15,15),fontsize = 20)\n",
    "    a0.set_yticks(np.arange(0,0.55,0.1))\n",
    "    a0.set_yticklabels([f'{x:.1f}' for x in np.arange(0,0.55,0.1)], fontsize = 20)\n",
    "    a0.set_title(r'Blazing cirterion', fontsize = 25)\n",
    "    a0.legend(fontsize = 25, loc='lower right')\n",
    "    a0.set_ylabel(r'Blazing criterion $\\mu$', fontsize = 24)\n",
    "    a0.set_xlabel(r'Incident angle $\\alpha$', fontsize = 24)\n",
    "    \n",
    "    a1.imshow(\n",
    "        np.abs(far_field),\n",
    "        interpolation = 'None',\n",
    "        clim = [0,(np.max(np.abs(far_field)))/1.5],\n",
    "        cmap='gray'\n",
    "    )\n",
    "    a1.scatter(\n",
    "        far_field.shape[1]//2, \n",
    "        far_field.shape[0]//2, \n",
    "        s=400,\n",
    "        alpha = 0.5,\n",
    "        c='yellow',\n",
    "        marker='x'\n",
    "    )        \n",
    "    a1.axis('off')    \n",
    "    a1.set_title('Diffraction pattern', fontsize = 25)\n",
    "    \n",
    "    f.tight_layout()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4aa6f6aac7144f7389fe72724c1927da",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.632, continuous_update=False, description='$\\\\lambda$ ($\\\\mu m$)', m…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#HIDDEN\n",
    "theta_slider = FloatSlider(\n",
    "    min = -20, \n",
    "    max = 20, \n",
    "    step = 1, \n",
    "    value = 12, \n",
    "    continuous_update=False, \n",
    "    description = r'$\\theta$ (degrees)'\n",
    ")\n",
    "pitch_slider = FloatSlider(\n",
    "    min = 5, \n",
    "    max = 15, \n",
    "    step = 0.1, \n",
    "    value = 7.6, \n",
    "    continuous_update=False,\n",
    "    description = r'pitch ($\\mu m$)'\n",
    ")\n",
    "lambda_slider = FloatSlider(\n",
    "    min = 0.3, \n",
    "    max = 2., \n",
    "    step = 0.001, \n",
    "    value = 0.632, \n",
    "    continuous_update=False,\n",
    "    description = r'$\\lambda$ ($\\mu m$)'\n",
    ")\n",
    "alpha_slider = FloatSlider(\n",
    "    min = -75, \n",
    "    max = 75, \n",
    "    step = 1, \n",
    "    value = 24, \n",
    "    continuous_update=False, \n",
    "    description = r'$\\alpha$ (degrees)'\n",
    ")\n",
    "interact(make_figure, \n",
    "         theta = theta_slider,\n",
    "         d = pitch_slider,\n",
    "         alpha = alpha_slider,\n",
    "         _lambda = lambda_slider);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.8 64-bit",
   "language": "python",
   "name": "python36864bit2d3c9c76f14a418581f71968b859fcd5"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}