{ "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", " 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\"))\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", " 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": "9509fdd0b81b47a7bdcdd99704c382a7", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "