{ "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", " ridges = voronoi.ridge_vertices\n", " for ridge in ridges:\n", " verts = voronoi.vertices[ridge]\n", " # print(verts, type(verts), verts.shape, verts.ndim)\n", " ax.add_collection3d(Poly3DCollection([voronoi.vertices[ridge]], edgecolor=\"black\"))\n", " ax.set_xlim(-2, 2)\n", " ax.set_ylim(-2, 2)\n", " ax.set_zlim(-2, 2)\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", " 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", " 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": "d387139d3da141268f8c9c7345f26575", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "