{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Using the Fresnel module\n",
"====================="
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this section, we will describe how to use the `Fresnel` module of `pySCATMECH`. This module defines the classes `OpticalFunction`, `Film`, and `FilmStack`. The last can be used to calculate the reflectance and transmittance of a stack of thin films on a substrate.\n",
"\n",
"We start by importing the package and importing `matplotlib`, which we use for some graphing:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from pySCATMECH.fresnel import *\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import matplotlib.ticker as ticker"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"OpticalFunction class\n",
"-------------------------------\n",
"The optical properties of a material can be stored with the class `OpticalFunction`. Here we create some materials by defining their optical functions. An optical function can be obtained from a file containing a table of wavelengths ($\\lambda$), optical constant ($n$), and extinction coefficient ($k$). Or it can be defined as a complex number $n+\\mathrm{i}k$. Since optical functions are a function of wavelength, one can create them as a function. If you create them as a function, they need to be tabulated at discrete wavelengths in order for SCATMECH to use them as interpolation tables. Note that doing that will create temporary files."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"wavelengths = np.arange(0.2,2.5,0.01)\n",
"\n",
"# The following looks for a file named \"silicon\"\n",
"# Assume that \"silicon\" exists on your computer...\n",
"silicon = OpticalFunction(\"silicon\") \n",
"\n",
"# A fixed real index:\n",
"glass = OpticalFunction(1.5) \n",
"\n",
"# A metal, i.e., a complex index of refraction:\n",
"aMetal = OpticalFunction(1.4+2.1j)\n",
"\n",
"# A material with a Cauchy dispersion, given as a lambda function\n",
"# When providing a function, one must provide an iterable list of wavelengths because \n",
"# the function is tabulated.\n",
"SiO2 = OpticalFunction(lambda L: 1.4580 + 0.00354/L**2, wavelengths)\n",
"\n",
"# A couple materials with Sellmeier functions...\n",
"MgF = OpticalFunction(lambda L: math.sqrt(1+0.48755108*L**2/(L**2-0.04338408**2)\n",
" +0.39875031*L**2/(L**2-0.09461442**2)\n",
" +2.3120353*L**2/(L**2-23.793604**2)),\n",
" wavelengths)\n",
"\n",
"ZnO = OpticalFunction(lambda L: math.sqrt(1+1.347091*L**2/(L**2-0.062543**2)\n",
" +2.117788*L**2/(L**2-0.166739**2)\n",
" +9.452943*L**2/(L**2-24.320570**2)),\n",
" wavelengths)\n",
"\n",
"# It is useful to have one for vacuum:\n",
"vacuum = OpticalFunction(1)\n",
"\n",
"wavelengths = np.arange(0.25,1.5,0.001)\n",
"\n",
"# Plot the curves...\n",
"plt.figure()\n",
"plt.plot(wavelengths, [silicon(w).real for w in wavelengths], label=\"Si n\")\n",
"plt.plot(wavelengths, [silicon(w).imag for w in wavelengths], label=\"Si k\")\n",
"plt.plot(wavelengths, [glass(w) for w in wavelengths], label=\"glass\")\n",
"plt.plot(wavelengths, [SiO2(w) for w in wavelengths], label=\"SiO2\")\n",
"plt.plot(wavelengths, [MgF(w) for w in wavelengths], label=\"MgF\")\n",
"plt.plot(wavelengths, [ZnO(w) for w in wavelengths], label=\"ZnO\")\n",
"plt.xlabel(\"Wavelength (µm)\")\n",
"plt.ylabel(\"Optical Constants\")\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Film class\n",
"----------\n",
"\n",
"The class `Film` handles the properties of a film, namely, its optical function and its thickness. There are basically two ways to create a `Film`: with a thickness (length) or with an optical thickness (length relative to wavelength in the material). (SCATMECH assumes lengths are in micrometers, although any user can use another unit, provided that unit is consistently used everywhere.)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# Create a film of ZnO (defined above) of thickness 0.5 micrometers...\n",
"film1 = Film(ZnO, thickness = 0.5)\n",
"\n",
"# Create a quarter-wave thickness of ZnO for wavelength 0.5 micrometers...\n",
"film2 = Film(ZnO, waves = 1/4, wavelength = 0.5)\n",
"\n",
"# create a quarter-wave thickness of ZnO for wavelength 0.5 micrometers for 45 degrees incidence...\n",
"film3 = Film(ZnO, waves = 1/4, wavelength = 0.5, angle = 45*deg)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One of the properties of `Film` is that we can multiply a film by a scalar to obtain a film, say, twice as thick. This feature can be used to create high/low stacks in an intuitive way. FOr example, we can create a notch filter."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"H = Film(ZnO, waves = 1/4, wavelength = 0.5)\n",
"L = Film(MgF, waves = 1/4, wavelength = 0.5)\n",
"\n",
"notch_filter = 5*[H,L] + [2*H] + 5*[L,H]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"FilmStack class\n",
"----------------------\n",
"\n",
"The `FilmStack` class handles a stack of films. Most importantly, it allows us to calculate the reflection or transmission properties for radiation incident on one material to another with a stack of films in between. We will start our demonstration of the `FilmStack` class with an empty one. \n",
"\n",
"The `FilmStack` methods that return reflection or transmission properties take four or five parameters. \n",
"* The angle of incidence in radians\n",
"* The wavelength (as measured in vacuum)\n",
"* The `OpticalFunction` for the medium the radiation is incident from\n",
"* The `OpticalFunction` for the medium the radiation will transmit to\n",
"* Optional: a string '12', '21', '12i', or '21i'. The default is '12', which means that the stack of films is to be evaluated as if the first `Film` is closest to the medium the radiation will transmit to. '21' means the stack of films is to be evaluated as if the first `Film` is closest to the medium the radiation is incident from. The 'i' indicates that the angle is expressed as the incident angle in the incident medium. By default (no 'i'), the angle is expressed as a vacuum angle.\n",
"\n",
"So, let's see what the 60° reflectance of silicon is at 0.532 µm. "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Jones matrix = \n",
" [[(-0.7875336574103252-0.001629630653451164j), 0j], [0j, (0.37351472018980436+0.003391942682930761j)]] \n",
"\n",
"Mueller matrix = \n",
" [[ 0.37986833 0.24034358 0. 0. ]\n",
" [ 0.24034358 0.37986833 0. 0. ]\n",
" [ 0. 0. -0.29416094 0.00206258]\n",
" [ 0. 0. -0.00206258 -0.29416094]] \n",
"\n",
"Rs = 0.6202119172501502 , Rp = 0.13952475147363208\n"
]
}
],
"source": [
"stack = FilmStack()\n",
"\n",
"wavelength = 0.500 \n",
"\n",
"# Return a Jones matrix\n",
"r = stack.reflectionCoefficient(60*deg, wavelength, vacuum, silicon)\n",
"print(\"Jones matrix = \\n\",r,\"\\n\")\n",
"\n",
"# Return a Mueller matrix\n",
"R = stack.R(60*deg, wavelength, vacuum, silicon)\n",
"print(\"Mueller matrix = \\n\",R,\"\\n\")\n",
"\n",
"# Return the s and p reflectance\n",
"Rs = stack.Rs(60*deg, wavelength, vacuum, silicon) \n",
"Rp = stack.Rp(60*deg, wavelength, vacuum, silicon) \n",
"print(\"Rs = \",Rs,\", Rp = \",Rp)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's calculate the reflectance of silicon as a function of angle."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.figure()\n",
"thetas=[t for t in np.arange(0,90)]\n",
"Rs = [stack.Rs(t*deg, wavelength, vacuum, silicon) for t in thetas]\n",
"Rp = [stack.Rp(t*deg, wavelength, vacuum, silicon) for t in thetas]\n",
"plt.plot(thetas, Rs, label=\"$R_\\mathrm{s}$\")\n",
"plt.plot(thetas, Rp, label=\"$R_\\mathrm{p}$\")\n",
"plt.legend()\n",
"plt.title(\"Reflectance of silicon at \" + str(wavelength) + \" µm\")\n",
"plt.xlabel(r\"$\\theta$ (degrees)\")\n",
"plt.ylabel(\"Reflectance\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's calculate that reflectance as a function of wavelength for an angle of incidence of 70°."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.figure()\n",
"wavelengths = [L for L in np.arange(0.1, 1.5, 0.01)]\n",
"Rs = [stack.Rs(70*deg, wavelength, vacuum, silicon) for wavelength in wavelengths]\n",
"Rp = [stack.Rp(70*deg, wavelength, vacuum, silicon) for wavelength in wavelengths]\n",
"plt.plot(wavelengths, Rs, label=\"$R_\\mathrm{s}(\\lambda)$\")\n",
"plt.plot(wavelengths, Rp, label=\"$R_\\mathrm{p}(\\lambda)$\")\n",
"plt.legend()\n",
"plt.title(\"Reflectance of silicon at 70° incidence\")\n",
"plt.xlabel(\"$\\lambda$ (µm)\")\n",
"plt.ylabel(\"Reflectance\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, let's calculate the ellipsometric parameters $\\Psi$ and $\\Delta$ as a function of wavelength."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.figure()\n",
"wavelengths = [L for L in np.arange(0.1, 1.5, 0.01)]\n",
"M = [stack.R(70*deg, wavelength, vacuum, silicon) for wavelength in wavelengths]\n",
"delta = [(m @ Polarization(angle=45*deg)).delta() for m in M]\n",
"psi = [(m @ Polarization(angle=45*deg)).psi() for m in M]\n",
"plt.plot(wavelengths, delta, label=\"$\\Delta(\\lambda)$\")\n",
"plt.plot(wavelengths, psi, label=\"$\\Psi(\\lambda)$\")\n",
"plt.legend()\n",
"plt.title(\"Ellipsometric parameters\")\n",
"plt.xlabel(\"$\\lambda$ (µm)\")\n",
"plt.ylabel('$\\Psi$, $\\Delta$ (rad)')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"That isn't a very interesting film stack. The `grow()` method allows us to grow films on the substrate. The `clean()` method wipes all of the films off. Let's see what the ellipsometric parameters do when we add films of thickness 0 µm, 0.01 µm, 0.02 µm, and 0.03 µm."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"stack = FilmStack()\n",
"film = Film(SiO2, thickness = 0.01)\n",
"stack.grow(film)\n",
"\n",
"plt.figure()\n",
"wavelengths = [L for L in np.arange(0.1, 1.5, 0.01)]\n",
"\n",
"for t in [0., 0.01, 0.02, 0.03]:\n",
" stack.clean()\n",
" stack.grow(Film(SiO2, thickness = t))\n",
" \n",
" M = [stack.R(70*deg, wavelength, vacuum, silicon) for wavelength in wavelengths]\n",
" delta = [(m @ StokesVector(1,0,1,0)).delta() for m in M]\n",
" psi = [(m @ StokesVector(1,0,1,0)).psi() for m in M]\n",
" plt.plot(wavelengths, delta)\n",
" plt.plot(wavelengths, psi)\n",
"\n",
"plt.title(\"Ellipsometric parameters\")\n",
"plt.xlabel(\"$\\lambda$ (µm)\")\n",
"plt.ylabel('$\\Psi$, $\\Delta$ (rad)')\n",
"plt.show()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can also look at transmission. Here is the angle dependence of the transmission of a quarter wave MgF coating on glass."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"stack = FilmStack()\n",
"\n",
"substrate = SiO2\n",
"wavelength = 0.500\n",
"stack.grow(Film(MgF, waves=1/4, wavelength=wavelength))\n",
"\n",
"plt.figure()\n",
"ax = plt.subplot()\n",
"thetas=np.array([t for t in np.arange(0,90)])\n",
"Rs = [stack.Rs(theta*deg, wavelength, vacuum, substrate) for theta in thetas]\n",
"Rp = [stack.Rp(theta*deg, wavelength, vacuum, substrate) for theta in thetas]\n",
"Ts = [stack.Ts(theta*deg, wavelength, vacuum, substrate) for theta in thetas]\n",
"Tp = [stack.Tp(theta*deg, wavelength, vacuum, substrate) for theta in thetas]\n",
"plt.plot(thetas, Rs, label = \"Rs\")\n",
"plt.plot(thetas, Rp, label = \"Rp\")\n",
"plt.plot(thetas, Ts, label = \"Ts\")\n",
"plt.plot(thetas, Tp, label = \"Tp\")\n",
"plt.legend()\n",
"plt.xlim([-5, 95])\n",
"plt.xticks(np.linspace(0, 90, 10))\n",
"plt.xlabel(\"Angle\")\n",
"plt.ylabel(\"Reflectance, Transmittance\")\n",
"plt.title(\"Reflectance and Transmittance of a $\\lambda/4$ MgF film on SiO$_2$\")\n",
"class AddDegrees(ticker.Formatter):\n",
" def __call__(self,x,pos):\n",
" return \"$%g \\degree$\"% x\n",
"ax.xaxis.set_major_formatter(AddDegrees())\n",
"class AddPercent(ticker.Formatter):\n",
" def __call__(self,x,pos):\n",
" return (\"%g\" % (x*100))+\" %\"\n",
"ax.yaxis.set_major_formatter(AddPercent())\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's create with some high-low stacks. Note that we can create `FilmStack` from a list of `Film`. In the following, we create a series of curves containing various numbers of low-high pairs. A twenty-pair stack, for example, can be created by `FilmStack(20*[L,H])`."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"L = Film(MgF, waves=1/4, wavelength=0.500)\n",
"H = Film(ZnO, waves=1/4, wavelength=0.500)\n",
"\n",
"substrate = glass\n",
"\n",
"def pltFilm(stack,label=\"\"):\n",
" stack = FilmStack(stack)\n",
" wavelengths = np.arange(0.2, 1.0, 0.001)\n",
" Rs = [stack.Rs(0*deg, L, vacuum, substrate) for L in wavelengths]\n",
" plt.plot(wavelengths, Rs, label=label)\n",
"\n",
"plt.figure()\n",
"plt.title(\"Buildup of a high reflector\")\n",
"pltFilm(2*[L,H], label=\"2 LH\")\n",
"pltFilm(3*[L,H], label=\"3 LH\")\n",
"pltFilm(4*[L,H], label=\"4 LH\")\n",
"pltFilm(10*[L,H], label=\"10 LH\")\n",
"pltFilm(20*[L,H], label=\"20 LH\")\n",
"plt.legend()\n",
"plt.xlabel(\"Wavelength (µm)\")\n",
"plt.ylabel(\"Reflectance\")\n",
"plt.show()\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here is a notch filter, which consists of a 2H layer between two high reflectors."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.figure()\n",
"plt.title(\"Notch filter\")\n",
"pltFilm(5*[H,L] + [2*H] + 5*[L,H],\"5(H,L)+2H+5(L,H)\")\n",
"plt.legend()\n",
"plt.xlabel(\"Wavelength (µm)\")\n",
"plt.ylabel(\"Reflectance\")\n",
"plt.show()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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.7.7"
}
},
"nbformat": 4,
"nbformat_minor": 2
}