Electromagnetic-wave-animation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Electromagnetic wave animation ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "An electromagnetic wave is a combination of electric and magnetic fields that vibrate together in space and time, in a synchronous way. Suppose that the end points of the  electric field vectors describe, during the field oscillation, the wave $E_z=A\\sin(y/\\lambda-\\omega t), x=0$, while the end points of the magnetic field vectors run the wave $E_x=A\\sin(y/\\lambda-\\omega t), z=0$. \n",
    "\n",
    "To simulate/animate the electromagnetic wave propagation we plot at each t in a grid of the interval of simulation,  the electric field and the magnetic field vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Define a function that returns data to draw  vectors of a vector field with values in the plane yOz or xOy (i.e.  electric or magnetic field vectors, in our case). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def rot_matrix(theta):\n",
    "    return np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])\n",
    "\n",
    "def get_arrows(start, end, arrow_angle,  plane=2, fract=0.1):# this is  function for defining vectors/quivers\n",
    "    #start is the numpy array of x,y, z-coordinates of the starting points of arrows; shape (3, m)\n",
    "    #start[0,:] contains x-coordinates, etc\n",
    "    #end is a numpy array with the same shape as start; contains on rows the x,  y and z-coords \n",
    "    # of ending points of the arrow  \n",
    "    #the arrowhead is an isosceles triangle with the equal sides forming an angle of 2*arrow_angle radians \n",
    "    #plane=0 or 2 depending on the plane where the vectors are drawn (plane=0 i.e. x=0, plane=2, z=0)\n",
    "    \n",
    "    start=np.asarray(start)\n",
    "    end=np.asarray(end)\n",
    "    m=start[0,:].shape[0]\n",
    "    arr_dir=start-end\n",
    "    arr_dir_norm=np.linalg.norm(arr_dir, axis=0)\n",
    "    arr_dir=fract*arr_dir/arr_dir_norm[None,:]#the arrowhead is a fraction fract from the unit vector\n",
    "    if plane==2:# i.e. we plot vectors in z=0\n",
    "        v=np.einsum('ji, im -> jm', rot_matrix(arrow_angle), arr_dir[:plane,:])#Einstein summation to apply                                                                                  # rotation to all vectors at a time\n",
    "        w=np.einsum('ji, im -> jm', rot_matrix(-arrow_angle), arr_dir[:plane, :])\n",
    "        v=np.append(v, [[0]*m], axis=0) \n",
    "        w=np.append(w, [[0]*m], axis=0) \n",
    "    elif plane==0:# plot vectors in x=0\n",
    "        v=np.einsum('ji, im -> jm',  rot_matrix(arrow_angle), arr_dir[1:,:])                         \n",
    "        w=np.einsum('ji, im -> jm', rot_matrix(-arrow_angle), arr_dir[1:, :])\n",
    "        v=np.append([[0]*m], v, axis=0)\n",
    "        w=np.append([[0]*m], w, axis=0)\n",
    "    else: raise ValueError('the key plane must be 0 or 2')    \n",
    "    p=end+v\n",
    "    q=end+w\n",
    "\n",
    "    suppx=np.stack((start[0,:], end[0,:], np.nan*np.ones(m )))#supp is the line segment as support for arrow \n",
    "    suppy=np.stack((start[1,:], end[1,:], np.nan*np.ones(m )))\n",
    "    suppz=np.stack((start[2,:], end[2,:], np.nan*np.ones(m )))\n",
    "    x=suppx.flatten('F')#Fortran type flattening\n",
    "    y=suppy.flatten('F')\n",
    "    z=suppz.flatten('F')\n",
    "    x=map(lambda u: None if np.isnan(u) else u, x)\n",
    "    y=map(lambda u: None if np.isnan(u) else u, y)\n",
    "    z=map(lambda u: None if np.isnan(u) else u, z)\n",
    "    \n",
    "    #headx, heady, headz the x, y, z coordinates of the triangle vertices\n",
    "    headx=np.stack((end[0,:], p[0,:], q[0,:], end[0,:], np.nan*np.ones(m)))\n",
    "    heady=np.stack((end[1,:], p[1,:], q[1,:], end[1,:], np.nan*np.ones(m)))\n",
    "    headz=np.stack((end[2,:], p[2,:], q[2,:], end[2,:], np.nan*np.ones(m)))               \n",
    "    xx=headx.flatten('F')\n",
    "    yy=heady.flatten('F')\n",
    "    zz=headz.flatten('F')               \n",
    "    xx=map(lambda u: None if np.isnan(u) else u, xx)\n",
    "    yy=map(lambda u: None if np.isnan(u) else u, yy)\n",
    "    zz=map(lambda u: None if np.isnan(u) else u, zz)               \n",
    "    \n",
    "    return x, y, z, xx, yy, zz\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import plotly.plotly as py\n",
    "from plotly.grid_objs import Grid, Column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "py.sign_in('empet', 'api-key')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Define data for fixed traces in each frame (tr0, tr1, tr2, described below), representing the two orthogonal planes of the electric and magnetic field, and their common line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "a=2\n",
    "b=5\n",
    " \n",
    "xblue=[-a, a, a , -a, -a]\n",
    "yblue=[-b, -b, b, b, -b]\n",
    "zblue=[0]*5\n",
    "my_columns=[Column(xblue, 'xb'),Column(yblue, 'yb'), Column(zblue, 'zb')]\n",
    "\n",
    "xred=[0]*5+[None, 0, 0, 0]\n",
    "yred=[-b, -b, b, b, -b, None, -b, b]\n",
    "zred=[a, -a, -a, a, a, None, 0, 0]\n",
    "my_columns+=[Column(xred, 'xr'),Column(yred, 'yr'), Column(zred, 'zr')]\n",
    "\n",
    "x_Oy=[0,0]\n",
    "y_Oy=[-b,b]\n",
    "z_Oy=[0,0]\n",
    "my_columns+=[Column(x_Oy, 'xy'), Column(y_Oy, 'yy'), Column(z_Oy, 'zy')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Set the wave parameters and the interval of simulation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "A=1# wave amplitude\n",
    "lambdA=0.5#wavelength\n",
    "omega=1# angular frequency\n",
    "t=np.arange(0., 10., 0.2)# interval of simulation\n",
    "Y=np.arange(-b, b, 0.2)#a grid of an interval on Oy, where the vector fields are evaluated\n",
    "X=np.zeros(Y.shape[0])\n",
    "ZZe=np.zeros(Y.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3L, 50L)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nr_frames=t.shape[0]\n",
    "theta=np.pi/13# the characteristic angle of each arrow\n",
    "start=np.stack((X, Y, np.zeros(X.shape)))# the numpy array of starting points of the the two classes of vectors\n",
    "start.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Define data representing the vectors of the two vector fields:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "u'https://plot.ly/~empet/14296/'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for k in range(nr_frames):\n",
    "    Ze=A*np.sin(Y/lambdA-omega*t[k])\n",
    "    end1=np.stack((X, Y, Ze))\n",
    "    x1,y1,z1, xx1, yy1, zz1=get_arrows(start, end1, theta, plane=0)\n",
    "    my_columns+=[Column(x1, 'x1_{}'.format(k+1)), Column(y1, 'y1_{}'.format(k+1)), Column(z1, 'z1_{}'.format(k+1))]\n",
    "    my_columns+=[Column(xx1, 'xx1_{}'.format(k+1)), Column(yy1, 'yy1_{}'.format(k+1)), Column(zz1, 'zz1_{}'.format(k+1))]\n",
    "    XXe=A*np.sin(Y/lambdA-omega*t[k])\n",
    "    end2=np.stack((XXe, Y, ZZe))\n",
    "    x2,y2,z2, xx2, yy2, zz2=get_arrows(start, end2, theta, plane=2)\n",
    "    my_columns+=[Column(x2, 'x2_{}'.format(k+1)), Column(y2, 'y2_{}'.format(k+1)), Column(z2, 'z2_{}'.format(k+1))]\n",
    "    my_columns+=[Column(xx2, 'xx2_{}'.format(k+1)), Column(yy2, 'yy2_{}'.format(k+1)), Column(zz2, 'zz2_{}'.format(k+1))]\n",
    "    \n",
    "grid = Grid(my_columns)\n",
    "py.grid_ops.upload(grid, 'electromg-wave1', auto_open=False)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "tr0=dict(type='scatter3d',  # a rectangle in xOy  \n",
    "         xsrc=grid.get_column_reference('xb'),\n",
    "         ysrc=grid.get_column_reference('yb'),\n",
    "         zsrc=grid.get_column_reference('zb'), \n",
    "         mode='lines',\n",
    "         line=dict(width=1.5, color='blue')  \n",
    "       )\n",
    "tr1=dict(type='scatter3d',# a rectangle in yOz\n",
    "         xsrc=grid.get_column_reference('xr'),\n",
    "         ysrc=grid.get_column_reference('yr'),\n",
    "         zsrc=grid.get_column_reference('zr'), \n",
    "         mode='lines',\n",
    "         line=dict(width=1.5, color='red')\n",
    "        )\n",
    "tr2=dict(type='scatter3d',#line of direction Oy\n",
    "         xsrc=grid.get_column_reference('xy'),\n",
    "         ysrc=grid.get_column_reference('yy'),\n",
    "         zsrc=grid.get_column_reference('zy'), \n",
    "         mode='lines',\n",
    "         line=dict(width=1.5, color='rgb(140,140,140)')\n",
    "        )\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The following four traces are the base traces updated by the animation frames:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "tr3=dict(type='scatter3d',\n",
    "         xsrc=grid.get_column_reference('x1_1'),\n",
    "         ysrc=grid.get_column_reference('y1_1'),\n",
    "         zsrc=grid.get_column_reference('z1_1'),\n",
    "         mode='lines', \n",
    "         line=dict(color='red', width=1.5),\n",
    "         name=''\n",
    "        )\n",
    "                                   \n",
    "tr4=dict(type='scatter3d',\n",
    "         xsrc=grid.get_column_reference('xx1_1'),\n",
    "         ysrc=grid.get_column_reference('yy1_1'),\n",
    "         zsrc=grid.get_column_reference('zz1_1'),      \n",
    "         mode='lines', \n",
    "         line=dict(color='red', width=2), \n",
    "         name='' \n",
    "        )\n",
    "tr5=dict(type='scatter3d',\n",
    "         xsrc=grid.get_column_reference('x2_1'),\n",
    "         ysrc=grid.get_column_reference('y2_1'),\n",
    "         zsrc=grid.get_column_reference('z2_1'),\n",
    "         mode='lines', \n",
    "         line=dict(color='blue', width=1.5),\n",
    "         name=''\n",
    "        )\n",
    "tr6=dict(type='scatter3d',\n",
    "         xsrc=grid.get_column_reference('xx2_1'),\n",
    "         ysrc=grid.get_column_reference('yy2_1'),\n",
    "         zsrc=grid.get_column_reference('zz2_1'),  \n",
    "         mode='lines', \n",
    "         line=dict(color='blue', width=2), \n",
    "         name=''\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define data to be plotted in each animation frame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "frames=[]\n",
    "for k in range(nr_frames):\n",
    "    frames+=[dict(data=[dict(xsrc=grid.get_column_reference('x1_{}'.format(k+1)),\n",
    "                             ysrc=grid.get_column_reference('y1_{}'.format(k+1)),\n",
    "                             zsrc=grid.get_column_reference('z1_{}'.format(k+1))\n",
    "                           ),\n",
    "                        dict(xsrc=grid.get_column_reference('xx1_{}'.format(k+1)),\n",
    "                             ysrc=grid.get_column_reference('yy1_{}'.format(k+1)),\n",
    "                             zsrc=grid.get_column_reference('zz1_{}'.format(k+1))\n",
    "                            ),\n",
    "                        dict(xsrc=grid.get_column_reference('x2_{}'.format(k+1)),\n",
    "                             ysrc=grid.get_column_reference('y2_{}'.format(k+1)),\n",
    "                             zsrc=grid.get_column_reference('z2_{}'.format(k+1))\n",
    "                           ),\n",
    "                        dict(xsrc=grid.get_column_reference('xx2_{}'.format(k+1)),\n",
    "                             ysrc=grid.get_column_reference('yy2_{}'.format(k+1)),\n",
    "                             zsrc=grid.get_column_reference('zz2_{}'.format(k+1))\n",
    "                            )\n",
    "                       ],\n",
    "                  traces=[3,4,5,6]\n",
    "                 )\n",
    "           ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "data=[tr0, tr1, tr2, tr3, tr4, tr5, tr6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Set the plot layout:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "noaxis=dict( showbackground=False,\n",
    "            showgrid=False,\n",
    "            showline=False,\n",
    "            showticklabels=False,\n",
    "            ticks='',\n",
    "            title='',\n",
    "            zeroline=False)\n",
    "title='Electromagnetic wave propagating in the positive Oy direction<br>'+\\\n",
    "'The  electric field vectors (red) are included in the plane yOz,<br> and  the magnetic field vectors (blue), in xOy'\n",
    "layout = dict(title=title,\n",
    "              font=dict(family='Balto'),\n",
    "              autosize=False,\n",
    "              width=700,\n",
    "              height=700,\n",
    "              showlegend=False,\n",
    "              scene=dict(camera = dict(eye=dict(x=1.22, y=0.55, z=0.3)),\n",
    "                         aspectratio=dict(x=1, y=1, z=0.65),\n",
    "                         xaxis=dict(noaxis),\n",
    "                         yaxis=dict(noaxis), \n",
    "                         zaxis=dict(noaxis),\n",
    "                        ),\n",
    "              updatemenus=[dict(type='buttons', showactive=False,\n",
    "                                y=0.75,\n",
    "                                x=1.05,\n",
    "                                xanchor='left',\n",
    "                                yanchor='top',\n",
    "                                pad=dict(t=0, l=10),\n",
    "                                buttons=[dict(label='Play',\n",
    "                                              method='animate',\n",
    "                                              args=[None, \n",
    "                                                    dict(frame=dict(duration=80, \n",
    "                                                                    redraw=False),\n",
    "                                                         transition=dict(duration=0),\n",
    "                                                         fromcurrent=True,\n",
    "                                                         mode='immediate'\n",
    "                                                        )\n",
    "                                                   ]\n",
    "                                             )\n",
    "                                        ]\n",
    "                               )\n",
    "                          ]     \n",
    "          )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~empet/14297.embed\" height=\"700px\" width=\"700px\"></iframe>"
      ],
      "text/plain": [
       "<plotly.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig=dict(data=data, layout=layout, frames=frames)\n",
    "py.icreate_animations(fig, filename='anim-electromagwave')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "    /*body {\n",
       "        background-color: #F5F5F5;\n",
       "    }*/\n",
       "    div.cell{\n",
       "        width: 900px;\n",
       "        margin-left: 13% !important;\n",
       "        margin-right: auto;\n",
       "    }\n",
       "    #notebook li { /* More space between bullet points */\n",
       "    margin-top:0.8em;\n",
       "    }\n",
       "\n",
       "    h1 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\n",
       "    .text_cell_render h1 {\n",
       "        font-weight: 200;\n",
       "        font-size: 40pt;\n",
       "        line-height: 100%;\n",
       "        color: rgb(8, 66, 133);\n",
       "        margin-bottom: 0em;\n",
       "        margin-top: 0em;\n",
       "        display: block;\n",
       "    }\n",
       "    h2 {\n",
       "        font-family: 'Fenix', serif;\n",
       "        text-indent:1em;\n",
       "        text-align:center;\n",
       "    }\n",
       "    .text_cell_render h2 {\n",
       "        font-weight: 200;\n",
       "        font-size: 28pt;\n",
       "        line-height: 100%;\n",
       "        color: rgb(8, 66, 133);\n",
       "        margin-bottom: 1.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    h3 {\n",
       "        font-family: 'Fenix', serif;\n",
       "        %margin-top:12px;\n",
       "        %margin-bottom: 3px;\n",
       "    }\n",
       "    .text_cell_render h3 {\n",
       "        font-weight: 300;\n",
       "        font-size: 18pt;\n",
       "        line-height: 100%;\n",
       "        color: rgb(8, 66, 133);\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 2em;\n",
       "        display: block;\n",
       "    }\n",
       "    h4 {\n",
       "        font-family: 'Fenix', serif;\n",
       "    }\n",
       "    .text_cell_render h4 {\n",
       "        font-weight: 300;\n",
       "        font-size: 16pt;\n",
       "        color: rgb(8, 66, 133);\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    h5 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-style: normal;\n",
       "        font-size: 16pt;\n",
       "        margin-bottom: 0em;\n",
       "        margin-top: 1.5em;\n",
       "        display: block;\n",
       "        }\n",
       "    div.text_cell_render{\n",
       "        font-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 145%;\n",
       "        font-size: 130%;\n",
       "        width:900px;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "        %text-align:justify;\n",
       "        %text-justify:inter-word;\n",
       "    }\n",
       "    \n",
       "    \n",
       "    code{\n",
       "      font-size: 78%;\n",
       "    }\n",
       "    .rendered_html code{\n",
       "        background-color: transparent;\n",
       "        white-space: inherit;   \n",
       "    }\n",
       "    .prompt{\n",
       "        display: None;\n",
       "     }\n",
       "    .rendered_html code{\n",
       "    background-color: transparent;\n",
       "    }\n",
       "\n",
       "    blockquote{\n",
       "      display:block;\n",
       "      background: #f3f3f3;\n",
       "      font-family: \"Open sans\",verdana,arial,sans-serif;\n",
       "      width:610px;\n",
       "      padding: 15px 15px 15px 15px;\n",
       "      text-align:justify;\n",
       "      text-justify:inter-word;\n",
       "      }\n",
       "      blockquote p {\n",
       "        margin-bottom: 0;\n",
       "        line-height: 125%;\n",
       "        font-size: 100%;\n",
       "      }\n",
       "   /* element.style {\n",
       "    } */\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ [\"$\",\"$\"], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ [\"$$\",\"$$\"], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: \"center\", // Change this to \"center\" to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {\".MathJax_Display\": {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def  css_styling():\n",
    "    styles = open(\"./custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}