\n",
" \n",
" | Gerd Duscher | \n",
" Khalid Hattar | \n",
"
\n",
" \n",
" | Microscopy Facilities | \n",
" Tennessee Ion Beam Materials Laboratory | \n",
"
\n",
" \n",
" \n",
" | Materials Science & Engineering | \n",
" Nuclear Engineering | \n",
"
\n",
" \n",
" | Institute of Advanced Materials & Manufacturing | \n",
" | \n",
"
\n",
" \n",
" | The University of Tennessee, Knoxville | \n",
"
\n",
"
\n",
"\n",
"Background and methods to analysis and quantification of data acquired with transmission electron microscopes.\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Load relevant python packages\n",
"### Check Installed Packages"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"done\n"
]
}
],
"source": [
"import sys\n",
"import importlib.metadata\n",
"def test_package(package_name):\n",
" \"\"\"Test if package exists and returns version or -1\"\"\"\n",
" try:\n",
" version = importlib.metadata.version(package_name)\n",
" except importlib.metadata.PackageNotFoundError:\n",
" version = '-1'\n",
" return version\n",
"\n",
"if test_package('pyTEMlib') < '0.2024.1.0':\n",
" print('installing pyTEMlib')\n",
" !{sys.executable} -m pip install --upgrade pyTEMlib -q\n",
"if 'google.colab' in sys.modules:\n",
" !{sys.executable} -m pip install numpy==1.24.4\n",
"print('done')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Load the plotting and figure packages\n",
"Import the python packages that we will use:\n",
"\n",
"Beside the basic numerical (numpy) and plotting (pylab of matplotlib) libraries,\n",
"* three dimensional plotting\n",
"and some libraries from the book\n",
"* kinematic scattering library."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"pyTEM version: 0.2023.8.0\n"
]
}
],
"source": [
"%matplotlib widget\n",
"import matplotlib.pylab as plt\n",
"import numpy as np\n",
"import sys\n",
"if 'google.colab' in sys.modules:\n",
" from google.colab import output\n",
" output.enable_custom_widget_manager()\n",
" \n",
"# 3D plotting package \n",
"from mpl_toolkits.mplot3d import Axes3D # 3D plotting\n",
"\n",
"import ase\n",
"\n",
"# Import libraries from the pyTEMlib\n",
"import pyTEMlib\n",
"import pyTEMlib.kinematic_scattering as ks # kinematic scattering Library\n",
" # with atomic form factors from Kirkland's book\n",
"# it is a good idea to show the version numbers at this point for archiving reasons.\n",
"print('pyTEM version: ',pyTEMlib.__version__)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"## Define Crystal\n",
"\n",
"A crystal is well defined by its unit cell and the atom positions within, the so called base.\n",
"The base consists of which element sits where within the unit cell\n",
"\n",
"\n",
"The unit cell fills the volume completely when translated in all three directions. Placing the unit cell in a global carthesian coordination system, we need the length of the sides and their angles for a complete description. This is depicted in the graph below.\n",
"\n",
"\n",
"Figure taken from the wikipedia page on lattice constants.\n",
"\n",
"Mathematically it is more advantageous to describe the unit cell as matrix, the\n",
"### Structure Matrix\n",
"\n",
"This matrix consists of rows of vectors that span the unit cell:\n",
"$\\begin{bmatrix}\n",
" a_1 & a_2 & a_3 \\\\\n",
" b_1 & b_2 & b_3 \\\\\n",
" c_1 & c_2 & c_3 \\\\\n",
"\\end{bmatrix} =\\left[\\vec{a},\\vec{b},\\vec{c}\\right]$.\n",
"\n",
"This structure matrix is also used to describe the super cells in materials simulations for example density functional theory.\n",
"\n",
"The representation of unit cells as structure matrices allows also for easy conversions as we will see in the following.\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"structure matrix \n",
" [[ 2.46 0. 0. ]\n",
" [-1.23 2.13 0. ]\n",
" [ 0. 0. 6.71]]\n",
"elements: ['C', 'C', 'C', 'C']\n",
"base \n",
" [[0. 0. 0. ]\n",
" [0. 0. 0.5 ]\n",
" [0.333 0.667 0. ]\n",
" [0.667 0.333 0.5 ]]\n"
]
}
],
"source": [
"# Create graphite unit cell (or structure matrix)\n",
"a = b = 2.46 # Angstrom\n",
"c = 6.71 # Angstrom\n",
"gamma = 120\n",
"alpha = beta = 90\n",
"\n",
"## Create the structure matrix for a hexagonal system explicitly:\n",
"structure_matrix = np.array([[a,0.,0.], ## also called the structure matrix\n",
" [np.cos(np.radians(gamma))*a,np.sin(np.radians(gamma))*a,0. ],\n",
" [0.,0.,c]\n",
" ])\n",
"print('structure matrix \\n', np.round(structure_matrix,3))\n",
"\n",
"elements = ['C']*4\n",
"base = [[0, 0, 0], [0, 0, 1/2], [1/3, 2/3, 0], [2/3, 1/3, 1/2]]\n",
"print('elements:', elements)\n",
"print('base \\n',np.round(base,3))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Store Information in ASE (atomic simulation environment) format"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Atoms(symbols='C4', pbc=False, cell=[[2.46, 0.0, 0.0], [-1.2299999999999995, 2.130422493309719, 0.0], [0.0, 0.0, 6.71]])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"atoms = ase.Atoms(elements, cell=structure_matrix, scaled_positions=base)\n",
"atoms"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can retrieve the information stored"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"structure matrix [nm]\n",
" [[ 2.46 0. 0. ]\n",
" [-1.23 2.13 0. ]\n",
" [ 0. 0. 6.71]]\n",
"elements \n",
" C4\n",
"base \n",
" [[0. 0. 0. ]\n",
" [0. 0. 0.5 ]\n",
" [0.333 0.667 0. ]\n",
" [0.667 0.333 0.5 ]]\n"
]
}
],
"source": [
"print('structure matrix [nm]\\n',np.round(atoms.cell.array,3))\n",
"print('elements \\n',atoms.get_chemical_formula())\n",
"print('base \\n',np.round(atoms.get_scaled_positions(), 3))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A convenient function is provided by the kinematic_scttering library (loaded with name ks)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Cell([[2.46772414, 0.0, 0.0], [-1.2338620699999996, 2.1371117947721068, 0.0], [0.0, 0.0, 6.711]]),\n",
" array([[0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n",
" [0.00000000e+00, 0.00000000e+00, 3.35550000e+00],\n",
" [1.23386207e+00, 7.12370598e-01, 0.00000000e+00],\n",
" [3.04714108e-16, 1.42474120e+00, 3.35550000e+00]]))"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"atoms = ks.structure_by_name('Graphite')\n",
"atoms.cell, atoms.positions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Volume of Unit Cell\n",
"We will need the volume of the unit cell for unit conversions later.\n",
"\n",
"Volume of the parallelepiped (https://en.wikipedia.org/wiki/Triple_product) : \n",
"$\\vec{a} \\cdot \\vec{b} \\times \\vec{c} = \\det \\begin{bmatrix}\n",
" a_1 & a_2 & a_3 \\\\\n",
" b_1 & b_2 & b_3 \\\\\n",
" c_1 & c_2 & c_3 \\\\\n",
"\\end{bmatrix} ={\\rm det}\\left(\\vec{a},\\vec{b},\\vec{c}\\right)$\n",
"\n",
"We see that the structure matrix comes in handy for that calculation."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"volume of unit cell: 35.1660 Ang^3\n"
]
}
],
"source": [
"volume = v = np.linalg.det(structure_matrix)\n",
"print(f\"volume of unit cell: {volume:.4f} Ang^3\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The same procedure is provided by ase"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"volume of unit cell: 35.3925 Ang^3\n"
]
}
],
"source": [
"print(f\"volume of unit cell: {atoms.cell.volume:.4f} Ang^3\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Vector Algebra in Unit Cell \n",
"We will use the linear algebra package of numpy (np.linalg) for our vector calculations.\n",
"\n",
"The length of a vector is called its norm.\n",
"\n",
"And the angle between two vectors is calculated by the dot product: $\\vec{a} \\cdot \\vec{b} = \\left\\| \\vec{a} \\right\\| \\left\\| \\vec{b} \\right\\| \\cos (\\theta) $\n",
"\n",
"> Note that python starts couting at 0 and so the second vector has index 1"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"length of second unit cell vector is 2.460 Ang\n",
"angle between a and b is 120.0 degree\n"
]
}
],
"source": [
"length_b = np.linalg.norm(structure_matrix[1])\n",
"print(f'length of second unit cell vector is {length_b:.3f} Ang' ) \n",
"\n",
"gamma = np.arccos(np.dot(structure_matrix[0]/length_b, structure_matrix[1]/length_b))\n",
"print(f'angle between a and b is {np.degrees(gamma):.1f} degree')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Plot the unit cell\n",
"\n",
"We use the visualization library of ase to plot structures."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"
\n",
"