{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "eaed683c-c6f1-45e4-aaee-ae4e57209f5f",
"metadata": {},
"outputs": [],
"source": [
"import scipy as scp\n",
"from scipy.spatial import Voronoi, voronoi_plot_2d\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"from mpl_toolkits.mplot3d import Axes3D\n",
"from mpl_toolkits.mplot3d.art3d import Poly3DCollection\n",
"%matplotlib widget"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "efd84ecd-9fb3-4d2f-9f7a-47cd1ff09eea",
"metadata": {},
"outputs": [],
"source": [
"class Lattice:\n",
" def __init__(self, *vecs):\n",
" # if the vecs were put in an iterable\n",
" if len(vecs) == 1:\n",
" vecs = vecs[0]\n",
" if len(vecs) == 3:\n",
" pass\n",
" elif len(vecs) == 2:\n",
" pass\n",
" else: raise ValueError(\"Vecs must contain either 2 or 3 vectors\")\n",
" self.dim = len(vecs)\n",
" self.vecs = list(vecs)\n",
" for i, v in enumerate(self.vecs):\n",
" if type(v) != np.ndarray:\n",
" self.vecs[i] = np.array(v)\n",
" if self.vecs[i].shape != (self.dim,):\n",
" raise ValueError(f\"Got {self.dim} vectors, therefore all vectors must be {self.dim} dimensional but vector {i+1} has shape {self.vecs[i].shape}\")\n",
" self.vecs = np.array(self.vecs)\n",
" self.vec_lengths = np.array([np.linalg.norm(v) for v in self.vecs])\n",
" self.center = np.zeros(self.dim)\n",
"\n",
" def get_point(self, *ns):\n",
" if len(ns) != len(self.vecs): raise ValueError(f\"Requires one index for each lattice vector {len(self.vecs)}, but got only {ns}\")\n",
" point = self.center.copy()\n",
" for i, n in enumerate(ns):\n",
" point += n * self.vecs[i]\n",
" return point\n",
"\n",
" \n",
" def get_points_around_center(self, n):\n",
" points = []\n",
" import itertools\n",
" ns = [i for i in range(-n, n+1)]\n",
" for n in itertools.product(*[ns for _ in range(self.dim)]):\n",
" # print(n)\n",
" points.append(self.get_point(*n))\n",
" return points"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "515b9133-233b-4a6a-8b2f-a2fca10fea3d",
"metadata": {},
"outputs": [],
"source": [
"def rot_mat_2D(rad):\n",
" return np.array([[np.cos(rad), -np.sin(rad)], [np.sin(rad), np.cos(rad)]])\n",
"\n",
"\n",
"def get_reciprocal_lattice(lattice: Lattice):\n",
" if lattice.dim == 2:\n",
" rot_90_deg = rot_mat_2D(np.pi / 2)\n",
" a1, a2 = lattice.vecs\n",
" b1 = 2 * np.pi * rot_90_deg @ a2 / (np.dot(a1, rot_90_deg @ a2))\n",
" b2 = 2 * np.pi * rot_90_deg @ a1 / (np.dot(a2, rot_90_deg @ a1))\n",
" return Lattice(b1, b2)\n",
" elif lattice.dim == 3:\n",
" a1, a2, a3 = lattice.vecs\n",
" V = np.dot(a1, np.cross(a2, a3))\n",
" b1 = 2 * np.pi/V * np.cross(a2, a3)\n",
" b2 = 2 * np.pi/V * np.cross(a3, a1)\n",
" b3 = 2 * np.pi/V * np.cross(a1, a2)\n",
" return Lattice(b1, b2, b3)\n",
" else: raise NotImplementedError(f\"Dim must be 2 or 3, but is {lattice.dim}\")"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "2855d08e-70d8-4ef7-ba19-2c06316caf15",
"metadata": {},
"outputs": [],
"source": [
"\n",
"def get_elementary_cell(lattice: Lattice):\n",
" points = lattice.get_points_around_center(1)\n",
" return points\n",
"\n",
"def get_orthogonal_2D(vec):\n",
" return np.array((vec[1], -vec[0]))\n",
"\n",
"def get_unit_cell_vertices(lattice: Lattice, voronoi: Voronoi):\n",
" \"\"\"regard only voronoi vertices which are closest to the center <=> their norm is <= 0.5*(norm of the unit vectors added together\n",
" \"\"\"\n",
" lattice_vec_norm = np.sqrt(np.sum(lattice.vec_lengths**2))\n",
" return voronoi.vertices[np.linalg.norm(voronoi.vertices, axis=1) <= 0.5 * lattice_vec_norm]\n",
" \n",
"def plot_unit_cell(lattice, fig_ax=None, vec_label=\"a\", subplot_kw={}):\n",
" # get voronoi of the points around the center\n",
" points = get_elementary_cell(lattice)\n",
" voronoi = Voronoi(points)\n",
"\n",
" if fig_ax:\n",
" fig, ax = fig_ax\n",
" else:\n",
" if lattice.dim == 3:\n",
" fig = plt.figure()\n",
" ax = fig.add_subplot(1,1,1, projection=\"3d\") \n",
" else:\n",
" fig, ax = plt.subplots(**subplot_kw) \n",
"\n",
" # unit cell vertices\n",
" cell_points = get_unit_cell_vertices(lattice, voronoi)\n",
" # sort by polar angle for the fill function\n",
" cell_points = list(cell_points)\n",
" # print(cell_points)\n",
" # print([i for i in map(lambda p: np.arctan2(p[1],p[0]), cell_points)])\n",
" if lattice.dim == 2:\n",
" cell_points.sort(key=lambda p: np.arctan2(p[1],p[0]))\n",
" x_cell, y_cell = zip(*cell_points)\n",
" ax.fill(x_cell, y_cell, color=\"#4444\")\n",
" ax.scatter(x_cell, y_cell, color=\"orange\")\n",
" \n",
" # lattice points\n",
" x_lat, y_lat = zip(*lattice.get_points_around_center(3))\n",
" ax.scatter(x_lat, y_lat, color=\"blue\")\n",
" \n",
" # lattice vectors\n",
" arrowprops = dict(arrowstyle=\"-|>,head_width=0.4,head_length=0.8\", color=\"black\", shrinkA=0,shrinkB=0)\n",
" for i, vec in enumerate(lattice.vecs):\n",
" ax.annotate(f\"\", xy=lattice.vecs[i], xytext=lattice.center, arrowprops=arrowprops)\n",
" if vec_label is not None:\n",
" # add name of vector at a perpendicular offset starting at half length\n",
" ax.annotate(r\"$\\vec{\"+f\"{vec_label}}}_{i+1}$\", xy=0.7*lattice.vecs[i], xytext=0.7*lattice.vecs[i] + 0.06*get_orthogonal_2D(lattice.vecs[i]))\n",
" elif lattice.dim == 3:\n",
" # todo filter so that only\n",
" ridges = voronoi.ridge_vertices\n",
" lattice_vec_norm = np.sqrt(np.sum(lattice.vec_lengths**2))\n",
" for ridge in ridges:\n",
" # ATOMS\n",
" verts = voronoi.vertices[ridge]\n",
" # TODO: doesnt seem to work\n",
" \"\"\"regard only voronoi vertices which are closest to the center <=> their norm is <= 0.5*(norm of the unit vectors added together\n",
" \"\"\"\n",
" verts = verts[np.linalg.norm(verts, axis=1) <= 0.5 * lattice_vec_norm]\n",
" x_lat, y_lat, z_lat = zip(*lattice.get_points_around_center(1))\n",
" ax.scatter(x_lat, y_lat, z_lat, color=\"red\", marker=\".\")\n",
" # print(verts, type(verts), verts.shape, verts.ndim)\n",
" ax.add_collection3d(Poly3DCollection([voronoi.vertices[ridge]], edgecolor=\"black\", alpha=0.5))\n",
" # UNIT VECTORS \n",
" for vec in lattice.vecs:\n",
" ax.plot(*[i for i in zip([0,0,0], vec)])\n",
" ax.set_xlim(-2, 2)\n",
" ax.set_ylim(-2, 2)\n",
" ax.set_zlim(-2, 2)\n",
" \n",
" else: raise NotImplementedError(f\"Dim must be 2 or 3, but is {lattice.dim}\")\n",
"\n",
" # limit to 2*lattice vectors\n",
" def calc_lim(axis):\n",
" lim = 2.05 * np.max(np.abs(lattice.vecs[axis,:]))\n",
" return -lim, lim\n",
" ax.set_xlim(*calc_lim(0))\n",
" ax.set_ylim(*calc_lim(1))\n",
" if lattice.dim == 3: ax.set_zlim(*calc_lim(2))\n",
" fig.tight_layout()\n",
" return fig"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "c2faef81-5f2a-4950-b986-e891ddfa7da8",
"metadata": {},
"outputs": [],
"source": [
"sphere_point = lambda rad: np.array([np.cos(rad), np.sin(rad)])\n",
"\n",
"square_lattice = Lattice([1, 0], [0, 1])\n",
"tilted_lattice = Lattice([1, 0.5], [0, 1])\n",
"honeycomb_lattice = Lattice(sphere_point(0), sphere_point(np.pi * 2/3))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "a6b6ccf4-34c7-419d-8bcc-f3ce2870ba25",
"metadata": {},
"outputs": [],
"source": [
"# fig, axs = plt.subplots(3, figsize=(4, 12))\n",
"# plot_unit_cell(square_lattice, fig_ax=(fig, axs[0]))\n",
"# plot_unit_cell(tilted_lattice, fig_ax=(fig, axs[1]))\n",
"# plot_unit_cell(honeycomb_lattice, fig_ax=(fig,axs[2]));"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "5314dd3a-17a7-402d-b3ee-ddbf69a6c4ed",
"metadata": {},
"outputs": [],
"source": [
"def plot_lattice(lattice: Lattice):\n",
" reci = get_reciprocal_lattice(lattice)\n",
" print(reci.vecs)\n",
" if lattice.dim == 3:\n",
" fig = plt.figure()\n",
" axs = [fig.add_subplot(1,2,i, projection=\"3d\") for i in [1,2]]\n",
" fig.suptitle(\"3D Lattice\")\n",
" \n",
" else:\n",
" fig, axs = plt.subplots(1, 2)\n",
" plot_unit_cell(lattice, fig_ax=(fig, axs[0]))\n",
" plot_unit_cell(reci, fig_ax=(fig, axs[1]), vec_label=\"b\")"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "39a49d00-fc93-4f2a-8645-d5e440e7a092",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 6.28318531e+00 -3.84734139e-16]\n",
" [ 3.84734139e-16 6.28318531e+00]]\n",
"[[ 6.28318531e+00 -3.84734139e-16]\n",
" [-3.14159265e+00 6.28318531e+00]]\n",
"[[6.28318531e+00 3.62759873e+00]\n",
" [4.44252717e-16 7.25519746e+00]]\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "03f1538170914d43ab528487e51297c3",
"version_major": 2,
"version_minor": 0
},
"image/png": "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",
"text/html": [
"\n",
" \n",
"
\n",
" Figure\n",
"
\n",
"
\n",
"
\n",
"
\n",
" Figure\n",
"
\n",
"
\n",
"
\n",
"
\n",
" Figure\n",
"
\n",
"
\n",
"
\n",
"
\n",
" Figure\n",
"
\n",
"
\n",
"
\n",
"
\n",
" Figure\n",
"
\n",
"
\n",
"
\n",
"
\n",
" Figure\n",
"
\n",
"
\n",
"
\n",
"
\n",
" Figure\n",
"
\n",
"
\n",
"