{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "# GDSII import\n", "\n", "\"diagram\"\n", "\n", "Run this notebook in your browser using [Binder](https://mybinder.org/v2/gh/flexcompute-readthedocs/tidy3d-docs/readthedocs?labpath=docs%2Fsource%2Fnotebooks%2FGDS_import.ipynb).\n", "\n", "In Tidy3D, complex structures can be defined or imported from GDSII files via the third-party [gdspy](https://gdspy.readthedocs.io/en/stable/index.html) package. In this tutorial, we will first illustrate how to use the package to define a structure, then we will save this to file, and then we will read that file and import the structures in a simulation.\n", "\n", "Note that this tutorial requires gdspy, so grab it with `pip install gdspy` before running the tutorial or uncomment the cell line below." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:00.874214Z", "iopub.status.busy": "2022-07-21T20:35:00.873757Z", "iopub.status.idle": "2022-07-21T20:35:01.863810Z", "shell.execute_reply": "2022-07-21T20:35:01.863282Z" }, "tags": [] }, "outputs": [], "source": [ "# standard python imports\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import gdspy\n", "import os\n", "\n", "# tidy3d import\n", "import tidy3d as td\n", "from tidy3d import web" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Creating a beam splitter with gdspy\n", "\n", "First, we will construct an integrated beam splitter as in the title image in this notebook using `gdspy`. If you are only interested in importing an already existing GDSII file, just jump ahead to the next section.\n", "\n", "We first define some structural parameters. We consider the sidewall of the device to be slanted, deviating from the vertical sidewall by `sidewall_angle`. `sidewall_angle>0` corresponds to a typical fabrication scenario where the base of the device is larger than the top. On the base, the two arms of the device start at a distance `wg_spacing_in` apart, then come together at a coupling distance `wg_spacing_coup` for a certain length `coup_length`, and then split again into separate ports. In the coupling region, the field overlap results in energy exchange between the two waveguides. Here, we will only see how to define, export, and import such a device using `gdspy`. When importing the device, we can optionally dilate or erode its cross section via `dilation`. In a later example we will simulate the device and study the frequency dependence of the transmission into each of the ports." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:01.865974Z", "iopub.status.busy": "2022-07-21T20:35:01.865842Z", "iopub.status.idle": "2022-07-21T20:35:01.868292Z", "shell.execute_reply": "2022-07-21T20:35:01.867887Z" }, "tags": [] }, "outputs": [], "source": [ "### Length scale in micron.\n", "\n", "# Waveguide width\n", "wg_width = 0.45\n", "# Waveguide separation in the beginning/end\n", "wg_spacing_in = 8\n", "# Length of the coupling region\n", "coup_length = 10\n", "# Angle of the sidewall deviating from the vertical ones, positive values for the base larger than the top\n", "sidewall_angle = np.pi/6\n", "# Length of the bend region\n", "bend_length = 16\n", "# Waveguide separation in the coupling region\n", "wg_spacing_coup = 0.10\n", "# Total device length along propagation direction\n", "device_length = 100" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Generating Geometry\n", "To create the device, we will define each waveguide as a GDSII path object with the given waveguide width. To do that, we just need to define a series of points along the base of each waveguide that follows the curvature we desire. First, we define a convenience function to create the points along one of the waveguides, using a hyperbolic tangent curvature between the input and coupling regions. The second waveguide is just a reflected version of the first one." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:01.869716Z", "iopub.status.busy": "2022-07-21T20:35:01.869610Z", "iopub.status.idle": "2022-07-21T20:35:01.926655Z", "shell.execute_reply": "2022-07-21T20:35:01.926300Z" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "
<Figure size 576x216 with 1 Axes>\n",
       "
\n" ], "text/plain": [ "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 576x216 with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def bend_pts(bend_length, width, npts=10):\n", " \"\"\" Set of points describing a tanh bend from (0, 0) to (length, width)\"\"\"\n", " x = np.linspace(0, bend_length, npts)\n", " y = width*(1 + np.tanh(6*(x/bend_length - 0.5)))/2\n", " return np.stack((x, y), axis=1)\n", "\n", "def arm_pts(length, width, coup_length, bend_length, npts_bend=30):\n", " \"\"\" Set of points defining one arm of an integrated coupler \"\"\"\n", " ### Make the right half of the coupler arm first\n", " # Make bend and offset by coup_length/2\n", " bend = bend_pts(bend_length, width, npts_bend)\n", " bend[:, 0] += coup_length / 2\n", " # Add starting point as (0, 0)\n", " right_half = np.concatenate(([[0, 0]], bend))\n", " # Add an extra point to make sure waveguide is straight past the bend\n", " right_half = np.concatenate((right_half, [[right_half[-1, 0] + 0.1, width]]))\n", " # Add end point as (length/2, width)\n", " right_half = np.concatenate((right_half, [[length/2, width]]))\n", "\n", " ### Make the left half by reflecting and omitting the (0, 0) point\n", " left_half = np.copy(right_half)[1:, :]\n", " left_half[:, 0] = -left_half[::-1, 0]\n", " left_half[:, 1] = left_half[::-1, 1]\n", " \n", " return np.concatenate((left_half, right_half), axis=0)\n", "\n", "# Plot the upper arm for the current configuration\n", "arm_center_coords = arm_pts(\n", " device_length,\n", " wg_spacing_in/2,\n", " coup_length,\n", " bend_length)\n", "\n", "fig, ax = plt.subplots(1, figsize=(8, 3))\n", "ax.plot(arm_center_coords[:, 0], arm_center_coords[:, 1], lw=4)\n", "ax.set_xlim([-30, 30])\n", "ax.set_ylim([-1, 5])\n", "ax.set_xlabel(\"x (um)\")\n", "ax.set_ylabel(\"y (um)\")\n", "ax.set_title(\"Upper beam splitter arm\")\n", "ax.axes.set_aspect('equal')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can take the `arm_pts` function defined above and use it to define a FlexPath to create a curved waveguide.\n", "\n", "We put this in a convenience function defined below." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:01.928479Z", "iopub.status.busy": "2022-07-21T20:35:01.928325Z", "iopub.status.idle": "2022-07-21T20:35:01.931477Z", "shell.execute_reply": "2022-07-21T20:35:01.931068Z" }, "tags": [] }, "outputs": [], "source": [ "def make_coupler(\n", " length, \n", " wg_spacing_in,\n", " wg_width,\n", " wg_spacing_coup,\n", " coup_length,\n", " bend_length,\n", " npts_bend=30):\n", " \"\"\" Make an integrated coupler using the gdspy FlexPath object. \"\"\"\n", "\n", " # Compute one arm of the coupler\n", " arm_width = (wg_spacing_in - wg_width - wg_spacing_coup)/2\n", " arm = arm_pts(length, arm_width, coup_length, bend_length, npts_bend)\n", "\n", " # Reflect and offset bottom arm\n", " coup_bot = np.copy(arm)\n", " coup_bot[:, 1] = -coup_bot[::-1, 1] - wg_width/2 - wg_spacing_coup/2\n", "\n", " # Offset top arm\n", " coup_top = np.copy(arm)\n", " coup_top[:, 1] += wg_width/2 + wg_spacing_coup/2\n", " \n", " # Create waveguides as GDS paths\n", " path_bot = gdspy.FlexPath(coup_bot, wg_width, layer=1, datatype=0)\n", " path_top = gdspy.FlexPath(coup_top, wg_width, layer=1, datatype=1)\n", " \n", " return [path_bot, path_top]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Writing to GDS cells\n", "\n", "Next, we construct the splitter and write it to a GDS cell. We add a rectangle for the substrate to layer 0, and in layer 1 we add two paths, one for the upper and one for the lower splitter arms, and set the path width to be the waveguide width defined above." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:01.932892Z", "iopub.status.busy": "2022-07-21T20:35:01.932758Z", "iopub.status.idle": "2022-07-21T20:35:01.936745Z", "shell.execute_reply": "2022-07-21T20:35:01.936487Z" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "
<gdspy.library.Cell object at 0x7f06b1a24280>\n",
       "
\n" ], "text/plain": [ "\u001b[1m<\u001b[0m\u001b[1;95mgdspy.library.Cell\u001b[0m\u001b[39m object at \u001b[0m\u001b[1;36m0x7f06b1a24280\u001b[0m\u001b[1m>\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# make gds library\n", "gdspy.current_library = gdspy.GdsLibrary()\n", "lib = gdspy.GdsLibrary()\n", "\n", "# Create a gds cell to add our structures to\n", "coup_cell = lib.new_cell('Coupler')\n", "\n", "# make substrate and add to cell\n", "substrate = gdspy.Rectangle(\n", " (-device_length/2, -wg_spacing_in/2-10),\n", " (device_length/2, wg_spacing_in/2+10),\n", " layer=0)\n", "\n", "coup_cell.add(substrate)\n", "\n", "# make coupler and add to the gdspy cell\n", "top, bot = make_coupler(\n", " device_length,\n", " wg_spacing_in,\n", " wg_width,\n", " wg_spacing_coup,\n", " coup_length,\n", " bend_length)\n", "\n", "coup_cell.add(top)\n", "coup_cell.add(bot)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Writing to GDS file\n", "To write the gds cell to file is straightforward.\n", "\n", "First we will clear the file if it exists and write to it using gdspy." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:01.938023Z", "iopub.status.busy": "2022-07-21T20:35:01.937899Z", "iopub.status.idle": "2022-07-21T20:35:01.942861Z", "shell.execute_reply": "2022-07-21T20:35:01.942589Z" }, "tags": [] }, "outputs": [], "source": [ "gds_path = 'data/coupler.gds'\n", "\n", "if os.path.exists(gds_path):\n", " os.remove(gds_path)\n", "\n", "lib.write_gds(gds_path)" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Loading a GDS file into Tidy3d\n", "\n", "We first load the file we just created into a gdspy library and grab the \"Coupler\" cell containing our structures." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:01.944290Z", "iopub.status.busy": "2022-07-21T20:35:01.944057Z", "iopub.status.idle": "2022-07-21T20:35:01.945953Z", "shell.execute_reply": "2022-07-21T20:35:01.945723Z" }, "tags": [] }, "outputs": [], "source": [ "lib_loaded = gdspy.GdsLibrary(infile=gds_path)\n", "coup_cell_loaded = lib_loaded.cells['Coupler']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Set up Geometries\n", "\n", "Then we can construct tidy3d \"PolySlab\" geometries from the GDS cell we just loaded, along with other information about the out of plane direction, such as the axis, sidewall angle, and bounds of the \"slab\". When loading GDS cell as the base cross section of the device, we can optionally dilate or erode the cell by setting `dilation`. A negative `dilation` corresponds to erosion.\n", "\n", "Note, we have to keep track of the `gds_layer` and `gds_dtype` used to defined the GDS cell earlier, so we can load the right components.." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:01.947417Z", "iopub.status.busy": "2022-07-21T20:35:01.947266Z", "iopub.status.idle": "2022-07-21T20:35:01.990213Z", "shell.execute_reply": "2022-07-21T20:35:01.989744Z" }, "tags": [] }, "outputs": [], "source": [ "# Define waveguide height\n", "wg_height = 0.22\n", "dilation = 0.02\n", "\n", "[substrate_geo] = td.PolySlab.from_gds(coup_cell_loaded, gds_layer=0, gds_dtype=0, axis=2, slab_bounds=(-430, 0))\n", "top_arm_geo, bot_arm_geo = td.PolySlab.from_gds(coup_cell_loaded, gds_layer=1, axis=2, slab_bounds=(0, wg_height), sidewall_angle=sidewall_angle, dilation=dilation)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that we can also individually select the dtype by supplying `gds_dtype` to `PolySlab.from_gds`." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:01.992102Z", "iopub.status.busy": "2022-07-21T20:35:01.991955Z", "iopub.status.idle": "2022-07-21T20:35:02.034076Z", "shell.execute_reply": "2022-07-21T20:35:02.033621Z" } }, "outputs": [], "source": [ "top_arm_geo = td.PolySlab.from_gds(coup_cell_loaded, gds_layer=1, gds_dtype=0, axis=2, slab_bounds=(0, wg_height), sidewall_angle=sidewall_angle, dilation=dilation)[0]\n", "bot_arm_geo = td.PolySlab.from_gds(coup_cell_loaded, gds_layer=1, gds_dtype=1, axis=2, slab_bounds=(0, wg_height), sidewall_angle=sidewall_angle, dilation=dilation)[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's plot the base and the top of the coupler waveguide arms to make sure it looks ok. The base of the device should be larger than the top due to a positive `sidewall_angle`." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:02.035801Z", "iopub.status.busy": "2022-07-21T20:35:02.035655Z", "iopub.status.idle": "2022-07-21T20:35:02.126773Z", "shell.execute_reply": "2022-07-21T20:35:02.126480Z" } }, "outputs": [ { "data": { "text/html": [ "
<Figure size 1080x432 with 2 Axes>\n",
       "
\n" ], "text/plain": [ "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 108\u001b[0m\u001b[1;36m0x432\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m2\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "f, ax = plt.subplots(2,1,figsize=(15, 6))\n", "top_arm_geo.plot(z=0., ax=ax[0])\n", "bot_arm_geo.plot(z=0., ax=ax[0])\n", "ax[0].set_ylim(-5, 5)\n", "\n", "top_arm_geo.plot(z=wg_height, ax=ax[1])\n", "bot_arm_geo.plot(z=wg_height, ax=ax[1])\n", "ax[1].set_ylim(-5, 5)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Note on Vertices Convention" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is worth noting that the vertices supplied to define a `PolySlab` signify the vertces at the `base` of the polygon, before any dilation or slanted side wall effects.\n", "\n", "If, instead, one prefers to input the vertices at some height `h` above the base, including sidewall effects, a dilation factor can be applied independently to take this into account, for example.\n", "\n", "```\n", "# amount of dilation needed to apply to vertices at h to convert to vertices at base\n", "dilation_h = h * np.tan(sidewall_angle)\n", "\n", "# Construct polyslab with vertices at h and this extra dilation\n", "ps = Polyslab(vertices_at_h, sidewall_angle=sidewall_angle, dilation=dilation_h)\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Set up Structures\n", "\n", "To make use of these new geometries, we need to load them into a tidy3d.Simulation as td.Structures with material properties.\n", "\n", "We'll define the substrate and waveguide mediums and then link them up with the Polyslabs." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:02.128603Z", "iopub.status.busy": "2022-07-21T20:35:02.128463Z", "iopub.status.idle": "2022-07-21T20:35:02.131498Z", "shell.execute_reply": "2022-07-21T20:35:02.131118Z" }, "tags": [] }, "outputs": [], "source": [ "# Permittivity of waveguide and substrate\n", "wg_n = 3.48\n", "sub_n = 1.45\n", "medium_wg = td.Medium(permittivity=wg_n**2)\n", "medium_sub = td.Medium(permittivity=sub_n**2)\n", "\n", "# Substrate\n", "substrate = td.Structure(\n", " geometry=substrate_geo,#td.Box(center=(0, 0, -td.inf/2), size=(td.inf, td.inf, td.inf)),\n", " medium=medium_sub\n", ")\n", "\n", "# Waveguides (import all datatypes if gds_dtype not specified)\n", "top_arm = td.Structure(\n", " geometry=top_arm_geo,\n", " medium=medium_wg\n", ")\n", "\n", "bot_arm = td.Structure(\n", " geometry=bot_arm_geo,\n", " medium=medium_wg\n", ")\n", "\n", "structures = [substrate, top_arm, bot_arm]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Set up Simulation\n", "\n", "Now let's set up the rest of the Simulation." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:02.133032Z", "iopub.status.busy": "2022-07-21T20:35:02.132853Z", "iopub.status.idle": "2022-07-21T20:35:02.137576Z", "shell.execute_reply": "2022-07-21T20:35:02.137333Z" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "
[16:35:02] WARNING  No sources in simulation.                               simulation.py:406\n",
       "
\n" ], "text/plain": [ "\u001b[2;36m[16:35:02]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m No sources in simulation. \u001b]8;id=193748;file:///home/shashwat/flexcompute/repositories/tidy3d-docs/tidy3d/tidy3d/components/simulation.py\u001b\\\u001b[2msimulation.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=615439;file:///home/shashwat/flexcompute/repositories/tidy3d-docs/tidy3d/tidy3d/components/simulation.py#406\u001b\\\u001b[2m406\u001b[0m\u001b]8;;\u001b\\\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Simulation size along propagation direction\n", "sim_length = 2 + 2*bend_length + coup_length\n", "\n", "# Spacing between waveguides and PML\n", "pml_spacing = 1\n", "sim_size = (\n", " np.ceil(sim_length),\n", " np.ceil(wg_spacing_in + wg_width + 2*pml_spacing),\n", " np.ceil(wg_height + 2*pml_spacing)\n", ")\n", "\n", "# grid size in each direction\n", "dl = 0.020\n", "\n", "### Initialize and visualize simulation ###\n", "sim = td.Simulation(\n", " size=sim_size,\n", " grid_spec = td.GridSpec.uniform(dl=dl),\n", " structures=structures,\n", " run_time=2e-12,\n", " boundary_spec=td.BoundarySpec.all_sides(boundary=td.PML())\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot Simulation Geometry\n", "\n", "Let's take a look at the simulation all together with the PolySlabs added. Here the angle of the sidewall deviating from the vertical direction is 30 degree." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2022-07-21T20:35:02.139105Z", "iopub.status.busy": "2022-07-21T20:35:02.138976Z", "iopub.status.idle": "2022-07-21T20:35:02.307670Z", "shell.execute_reply": "2022-07-21T20:35:02.307206Z" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "
<Figure size 1224x360 with 2 Axes>\n",
       "
\n" ], "text/plain": [ "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 1224x360 with \u001b[0m\u001b[1;36m2\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(17, 5))\n", "\n", "sim.plot(z=wg_height/2, lw=1, edgecolor='k', ax=ax1)\n", "sim.plot(x=0.1, lw=1, edgecolor='k', ax=ax2)\n", "\n", "ax2.set_xlim([-3, 3])\n", "ax2.set_ylim([-1, 1])\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.8.10" } }, "nbformat": 4, "nbformat_minor": 4 }