{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Inverse design optimization of a compact grating coupler\n", "\n", "**This notebook contains a long optimization. Running the entire notebook will cost about 10 FlexCredits and take a few hours.**\n", "\n", "The ability to couple light in and out of photonic integrated circuits (PICs) is crucial for developing wafer-scale systems and tests. This need makes designing efficient and compact grating couplers an important task in the PIC development cycle. In this notebook, we will demonstrate how to use `tidy3d` to perform the inverse design of a compact 3D grating coupler. We will show how to improve design fabricability by enhancing permittivity binarization and controlling the device's minimum feature size.\n", "\n", "\"Schematic\n", "\n", "In addition, if you are interested in more conventional designs, we modeled an [uniform grating coupler](https://www.flexcompute.com/tidy3d/examples/notebooks/GratingCoupler/) and a [Focusing apodized grating coupler](https://www.flexcompute.com/tidy3d/examples/notebooks/FocusedApodGC/) in previous case studies. For more integrated photonic examples, please visit our [examples page](https://www.flexcompute.com/tidy3d/examples/). If you are new to the finite-difference time-domain (FDTD) method, we highly recommend going through our [FDTD101](https://www.flexcompute.com/fdtd101/) tutorials. FDTD simulations can diverge due to various reasons. If you run into any simulation divergence issues, please follow the steps outlined in our [troubleshooting guide](https://www.flexcompute.com/tidy3d/examples/notebooks/DivergedFDTDSimulation/) to resolve it.\n", "\n", "We start by importing our typical python packages, plus `autograd` and `tidy3d`." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.037888Z", "start_time": "2026-03-16T10:28:14.264493Z" } }, "source": [ "# Standard python imports.\n", "from typing import List\n", "\n", "# Import autograd to be able to use automatic differentiation.\n", "import autograd.numpy as anp\n", "import matplotlib.pylab as plt\n", "import numpy as np\n", "import scipy as sp\n", "\n", "# Import regular tidy3d.\n", "import tidy3d as td\n", "import tidy3d.web as web\n", "from autograd import value_and_grad" ], "outputs": [], "execution_count": 1 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Grating Coupler Inverse Design Configuration\n", "\n", "The grating coupler inverse design begins with a rectangular design region connected to a $Si$ waveguide. Throughout the optimization process, this initial structure evolves to convert a vertically incident Gaussian-like mode from an optical fiber into a guided mode and then funnel it into the $Si$ waveguide.\n", "\n", "We are considering a full-etched grating structure, so a $SiO_{2}$ BOX layer is included. To reduce backreflection, we adjusted the fiber tilt angle to $10^{\\circ}$ [[1](https://doi.org/10.1364/OE.23.022628), [2](https://doi.org/10.3390/mi11070666)].\n", "\n", "In the following block of code, you can find the parameters that can be modified to configure the grating coupler structure, optimization, and simulation setup. Special care should be devoted to the `it_per_step` and `opt_steps` variables below." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.043334Z", "start_time": "2026-03-16T10:28:16.041217Z" } }, "source": [ "# Geometric parameters.\n", "w_thick = 0.22 # Waveguide thickness (um).\n", "w_width = 0.5 # Waveguide width (um).\n", "w_length = 1.0 # Waveguide length (um).\n", "box_thick = 1.6 # SiO2 BOX thickness (um).\n", "spot_size = 2.5 # Spot size of the input Gaussian field regarding a lensed fiber (um).\n", "fiber_tilt = 10.0 # Fiber tilt angle (degrees).\n", "src_offset = 0.05 # Distance between the source focus and device (um).\n", "\n", "# Material.\n", "nSi = 3.48 # Silicon refractive index.\n", "nSiO2 = 1.44 # Silica refractive index.\n", "\n", "# Design region parameters.\n", "gc_width = 4.0 # Grating coupler width (um).\n", "gc_length = 4.0 # Grating coupler length (um).\n", "dr_grid_size = 0.02 # Grid size within the design region (um).\n", "\n", "# Inverse design setup parameters.\n", "#################################################################\n", "# Total number of iterations = opt_steps x it_per_step.\n", "it_per_step = 1 # Number of iterations per optimization step.\n", "opt_steps = 75 # Number of optimization steps.\n", "#################################################################\n", "eta = 0.50 # Threshold value for the projection filter.\n", "fom_name = \"fom_field\" # Name of the monitor used to compute the objective function.\n", "\n", "# Simulation wavelength.\n", "wl = 1.55 # Central simulation wavelength (um).\n", "bw = 0.06 # Simulation bandwidth (um).\n", "n_wl = 61 # Number of wavelength points within the bandwidth.\n", "\n", "# feature size\n", "min_feature_size = 0.080\n", "filter_radius = min_feature_size\n", "\n", "# Buffer layer thickness\n", "border_buffer = 0.16\n", "\n", "# projection\n", "beta_min = 1.0\n", "beta_max = 30.0" ], "outputs": [], "execution_count": 2 }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.088516Z", "start_time": "2026-03-16T10:28:16.086876Z" } }, "source": [ "total_iter = opt_steps * it_per_step\n", "print(f\"Total iterations = {total_iter}\")" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Total iterations = 75\n" ] } ], "execution_count": 3 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Inverse Design Optimization Set Up\n", "\n", "We will calculate the values of some parameters used throughout the inverse design set up." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.135005Z", "start_time": "2026-03-16T10:28:16.132261Z" } }, "source": [ "# Minimum and maximum values for the permittivities.\n", "eps_max = nSi**2\n", "eps_min = 1.0\n", "\n", "# Material definitions.\n", "mat_si = td.Medium(permittivity=eps_max) # Waveguide material.\n", "mat_sio2 = td.Medium(permittivity=nSiO2**2) # Substrate material.\n", "\n", "# Wavelengths and frequencies.\n", "wl_max = wl + bw / 2\n", "wl_min = wl - bw / 2\n", "wl_range = np.linspace(wl_min, wl_max, n_wl)\n", "freq = td.C_0 / wl\n", "freqs = td.C_0 / wl_range\n", "freqw = 0.5 * (freqs[0] - freqs[-1])\n", "run_time = 5e-12\n", "\n", "# Computational domain size.\n", "pml_spacing = 0.6 * wl\n", "size_x = pml_spacing + w_length + gc_length + 2 * border_buffer\n", "size_y = gc_width + 2 * pml_spacing + 2 * border_buffer\n", "size_z = w_thick + box_thick + 2 * pml_spacing\n", "center_z = size_z / 2 - pml_spacing - w_thick / 2\n", "eff_inf = 1000\n", "\n", "# Inverse design variables.\n", "src_pos_z = w_thick / 2 + src_offset\n", "mon_pos_x = -size_x / 2 + 0.25 * wl\n", "mon_w = int(3 * w_width / dr_grid_size) * dr_grid_size\n", "mon_h = int(5 * w_thick / dr_grid_size) * dr_grid_size\n", "nx = int((gc_length + 2 * border_buffer) / dr_grid_size)\n", "ny = int((gc_width + 2 * border_buffer) / dr_grid_size / 2.0)\n", "npar = int(nx * ny)\n", "dr_size_x = nx * dr_grid_size\n", "dr_size_y = 2 * ny * dr_grid_size\n", "dr_center_x = -size_x / 2 + w_length + dr_size_x / 2\n", "n_border = int(border_buffer / dr_grid_size)" ], "outputs": [], "execution_count": 4 }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, we will introduce the simulation components that do not change during optimization, such as the $Si$ waveguide and $SiO_{2}$ BOX layer. Additionally, we will include a Gaussian source to drive the simulations, and a mode monitor to compute the objective function." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.202532Z", "start_time": "2026-03-16T10:28:16.178996Z" } }, "source": [ "# Input/output waveguide.\n", "waveguide = td.Structure(\n", " geometry=td.Box.from_bounds(\n", " rmin=(-eff_inf, -w_width / 2, -w_thick / 2),\n", " rmax=(-size_x / 2 + w_length, w_width / 2, w_thick / 2),\n", " ),\n", " medium=mat_si,\n", ")\n", "\n", "# SiO2 BOX layer.\n", "sio2_substrate = td.Structure(\n", " geometry=td.Box.from_bounds(\n", " rmin=(-eff_inf, -eff_inf, -w_thick / 2 - box_thick),\n", " rmax=(eff_inf, eff_inf, -w_thick / 2),\n", " ),\n", " medium=mat_sio2,\n", ")\n", "\n", "# Si substrate.\n", "si_substrate = td.Structure(\n", " geometry=td.Box.from_bounds(\n", " rmin=(-eff_inf, -eff_inf, -eff_inf),\n", " rmax=(eff_inf, eff_inf, -w_thick / 2 - box_thick),\n", " ),\n", " medium=mat_si,\n", ")\n", "\n", "# Gaussian source focused above the grating coupler.\n", "gauss_source = td.GaussianBeam(\n", " center=(dr_center_x, 0, src_pos_z),\n", " size=(dr_size_x - 2 * border_buffer, dr_size_y - 2 * border_buffer, 0),\n", " source_time=td.GaussianPulse(freq0=freq, fwidth=freqw),\n", " pol_angle=np.pi / 2,\n", " angle_theta=fiber_tilt * np.pi / 180.0,\n", " direction=\"-\",\n", " num_freqs=7,\n", " waist_radius=spot_size / 2,\n", ")\n", "\n", "# Monitor where we will compute the objective function from.\n", "mode_spec = td.ModeSpec(num_modes=1, target_neff=nSi)\n", "fom_monitor = td.ModeMonitor(\n", " center=[mon_pos_x, 0, 0],\n", " size=[0, mon_w, mon_h],\n", " freqs=[freq],\n", " mode_spec=mode_spec,\n", " name=fom_name,\n", ")" ], "outputs": [], "execution_count": 5 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we will define a random vector of initial design parameters or load a previously designed structure.\n", "\n", "> Note: if a previous optimization file is found, the optimizer will pick up where that left off instead." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.317631Z", "start_time": "2026-03-16T10:28:16.239625Z" } }, "source": [ "init_par = np.random.uniform(0, 1, int(npar))\n", "init_par = sp.ndimage.gaussian_filter(init_par, 1)\n", "init_par = init_par.reshape((nx, ny))" ], "outputs": [], "execution_count": 6 }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fabrication Constraints\n", "\n", "We will use the `tidy3d.plugins.autograd` plugin to introduce functions that improve device fabricability. A classical conic density filter, which is popular in topology optimization problems, is used to enforce a minimum feature size specified by the `filter_radius` variable. Next, a hyperbolic tangent projection function is applied to eliminate grayscale and obtain a binarized permittivity pattern. The `beta` parameter controls the sharpness of the transition in the projection function, and for better results, this parameter should be gradually increased throughout the optimization process. Finally, the design parameters are transformed into permittivity values. For a detailed review of these methods, refer to [[3](https://doi.org/10.1007/s00419-015-1106-4)].\n", "\n", "We will also introduce a buffer layer around the design region to enhance fabricability at the interfaces. The permittivity is enforced to lower values within the buffer layer, except at the output waveguide connection where we want a smooth transition." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.326982Z", "start_time": "2026-03-16T10:28:16.324589Z" } }, "source": [ "def get_eps(design_param: np.ndarray, beta: float = 1.00, binarize: bool = False) -> np.ndarray:\n", " \"\"\"Returns the permittivities after applying a conic density filter on design parameters\n", " to enforce fabrication constraints, followed by a binarization projection function\n", " which reduces grayscale.\n", " Parameters:\n", " design_param: np.ndarray\n", " Vector of design parameters.\n", " beta: float = 1.0\n", " Sharpness parameter for the projection filter.\n", " binarize: bool = False\n", " Enforce binarization.\n", " Returns:\n", " eps: np.ndarray\n", " Permittivity vector.\n", " \"\"\"\n", "\n", " # Calculates the permittivities from the transformed design parameters.\n", " eps = get_eps_values(design_param, beta=beta)\n", " if binarize:\n", " eps = anp.where(eps < (eps_min + eps_max) / 2, eps_min, eps_max)\n", " else:\n", " eps = anp.where(eps < eps_min, eps_min, eps)\n", " eps = anp.where(eps > eps_max, eps_max, eps)\n", " return eps" ], "outputs": [], "execution_count": 7 }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.603663Z", "start_time": "2026-03-16T10:28:16.368871Z" } }, "source": [ "from tidy3d.plugins.autograd import make_filter_and_project, rescale\n", "\n", "filter_project = make_filter_and_project(filter_radius, dr_grid_size, padding=\"constant\")\n", "\n", "\n", "def interface_buffer(params):\n", " \"\"\"Introduce a buffer around design to enhance fabricability at the interfaces.\"\"\"\n", " mask = anp.zeros_like(params)\n", " mask[0:n_border, :] = 0\n", " mask[nx - n_border :, :] = 0\n", " mask[:, ny - n_border :] = 0\n", " mask[0:n_border, 0 : int((w_width / 2) / dr_grid_size) + 1] = 1\n", "\n", " return params * (1 - mask) + mask\n", "\n", "\n", "def pre_process(params, beta):\n", " \"\"\"Get the permittivity values (1, eps_wg) array as a function of the parameters (0,1)\"\"\"\n", " params1 = interface_buffer(params)\n", " params2 = filter_project(params1, beta=beta)\n", " params3 = filter_project(params2, beta=beta)\n", " return params3\n", "\n", "\n", "def get_eps_values(params: np.ndarray, beta: float) -> np.ndarray:\n", " \"\"\"Get the relative permittivity array given the parameters.\"\"\"\n", " params = pre_process(params, beta=beta)\n", " eps_values = rescale(params, eps_min, eps_max)\n", " return eps_values" ], "outputs": [], "execution_count": 8 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The permittivity values obtained from the design parameters are then used to build a [CustomMedium](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.CustomMedium.html). As we will consider symmetry about the x-axis in the simulations, only the upper-half part of the design region needs to be populated. A `Structure` built using the `CustomMedium` will be returned by the following function: " ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.614568Z", "start_time": "2026-03-16T10:28:16.612004Z" } }, "source": [ "def update_design(eps, unfold: bool = False) -> List[td.Structure]:\n", " \"\"\"Reflects the structure about the x-axis.\"\"\"\n", " nyii = ny\n", " y_min = 0\n", " dr_s_y = dr_size_y / 2\n", " dr_c_y = dr_s_y / 2\n", " eps_val = anp.array(eps).reshape((nx, ny, 1))\n", " if unfold:\n", " nyii = 2 * ny\n", " y_min = -dr_size_y / 2\n", " dr_s_y = dr_size_y\n", " dr_c_y = 0\n", " eps_val = anp.concatenate((anp.fliplr(anp.copy(eps_val)), eps_val), axis=1)\n", "\n", " # Definition of the coordinates x,y along the design region.\n", " coords_x = [(dr_center_x - dr_size_x / 2) + ix * dr_grid_size for ix in range(nx)]\n", " coords_y = [y_min + iy * dr_grid_size for iy in range(nyii)]\n", " coords = dict(x=coords_x, y=coords_y, z=[0])\n", "\n", " # Creation of a custom medium using the values of the design parameters.\n", " permittivity = td.SpatialDataArray(eps_val, coords=coords)\n", " eps_medium = td.CustomMedium(permittivity=permittivity)\n", " box = td.Box(center=(dr_center_x, dr_c_y, 0), size=(dr_size_x, dr_s_y, w_thick))\n", " design_structure = td.Structure(geometry=box, medium=eps_medium)\n", " return [design_structure]" ], "outputs": [], "execution_count": 9 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we will write a function to return the `td.Simulation` object. Note that we are using a `MeshOverrideStructure` to obtain a uniform mesh over the design region." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:16.662748Z", "start_time": "2026-03-16T10:28:16.660526Z" } }, "source": [ "def make_adjoint_sim(\n", " design_param: np.ndarray,\n", " beta: float = 1.00,\n", " unfold: bool = False,\n", " binarize: bool = False,\n", ") -> td.Simulation:\n", " # Builds the design region from the design parameters.\n", " eps = get_eps(design_param, beta, binarize)\n", " design_structure = update_design(eps, unfold=unfold)\n", "\n", " # Creates a uniform mesh for the design region.\n", " adjoint_dr_mesh = td.MeshOverrideStructure(\n", " geometry=td.Box(center=(dr_center_x, 0, 0), size=(dr_size_x, dr_size_y, w_thick)),\n", " dl=[dr_grid_size, dr_grid_size, dr_grid_size],\n", " enforce=True,\n", " )\n", "\n", " return td.Simulation(\n", " size=[size_x, size_y, size_z],\n", " center=[0, 0, -center_z],\n", " grid_spec=td.GridSpec.auto(\n", " wavelength=wl_max,\n", " min_steps_per_wvl=15,\n", " override_structures=[adjoint_dr_mesh],\n", " ),\n", " symmetry=(0, -1, 0),\n", " structures=[waveguide, sio2_substrate, si_substrate] + design_structure,\n", " sources=[gauss_source],\n", " monitors=[fom_monitor],\n", " run_time=run_time,\n", " subpixel=True,\n", " )" ], "outputs": [], "execution_count": 10 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's visualize the simulation set up and verify if all the elements are in their correct places." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:17.091756Z", "start_time": "2026-03-16T10:28:16.706423Z" } }, "source": [ "init_design = make_adjoint_sim(init_par, beta=beta_min)\n", "\n", "fig, (ax1, ax2) = plt.subplots(1, 2, tight_layout=True, figsize=(10, 10))\n", "init_design.plot_eps(z=0, ax=ax1)\n", "init_design.plot_eps(y=0, ax=ax2)\n", "plt.show()" ], "outputs": [ { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } } ], "execution_count": 11 }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T10:28:17.099998Z", "start_time": "2026-03-16T10:28:17.096532Z" } }, "source": [ "from tidy3d.plugins.autograd import make_erosion_dilation_penalty\n", "\n", "erode_dilate_penalty = make_erosion_dilation_penalty(filter_radius, dr_grid_size)\n", "\n", "\n", "# Figure of Merit (FOM) calculation.\n", "def fom(sim_data: td.SimulationData) -> float:\n", " \"\"\"Return the power at the mode index of interest.\"\"\"\n", " output_amps = sim_data[fom_name].amps\n", " amp = output_amps.sel(direction=\"-\", f=freq, mode_index=0).values\n", " return anp.sum(anp.abs(amp) ** 2)\n", "\n", "\n", "def penalty(params, beta) -> float:\n", " \"\"\"Penalty function based on amount of change in parameters after erosion and dilation.\"\"\"\n", " params_processed = pre_process(params, beta=beta)\n", " return erode_dilate_penalty(params_processed)\n", "\n", "\n", "# Objective function to be passed to the optimization algorithm.\n", "def obj(design_param, beta: float = 1.0, step_num: int = None, verbose: bool = False) -> float:\n", " sim = make_adjoint_sim(design_param, beta)\n", " task_name = \"inv_des\"\n", " if step_num:\n", " task_name += f\"_step_{step_num}\"\n", " sim_data = web.run(sim, task_name=task_name, verbose=verbose)\n", " fom_val = fom(sim_data)\n", " feature_size_penalty = penalty(design_param, beta=beta)\n", " J = fom_val - feature_size_penalty\n", " return J\n", "\n", "\n", "# Function to calculate the objective function value and its\n", "# gradient with respect to the design parameters.\n", "obj_grad = value_and_grad(obj)" ], "outputs": [], "execution_count": 12 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimization\n", "\n", "We need to provide an objective function and its gradients with respect to the design parameters of the optimization algorithm.\n", "\n", "Our figure-of-merit (FOM) is the coupling efficiency of the incident power into the fundamental transverse electric mode of the $Si$ waveguide. The optimization algorithm will call the objective function at each iteration step. Therefore, the objective function will create the adjoint simulation, run it, and return the FOM value." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next we will define the optimizer using Tidy3D's built-in Adam helper. We will save the optimization progress in a `pickle` file. If that file is found, it will pick up the optimization from the last state. Otherwise, we will create a blank history." ] }, { "cell_type": "code", "metadata": { "tags": [], "ExecuteTime": { "end_time": "2026-03-16T10:28:17.146805Z", "start_time": "2026-03-16T10:28:17.143405Z" } }, "source": [ "import pickle\n", "\n", "from tidy3d.plugins.autograd import adam, apply_updates\n", "\n", "# hyperparameters\n", "learning_rate = 0.2\n", "optimizer = adam(learning_rate=learning_rate)\n", "\n", "# where to store history\n", "history_fname = \"misc/grating_coupler_history_autograd.pkl\"\n", "\n", "\n", "def save_history(history_dict: dict) -> None:\n", " \"\"\"Convenience function to save the history to file.\"\"\"\n", " with open(history_fname, \"wb\") as file:\n", " pickle.dump(history_dict, file)\n", "\n", "\n", "def load_history() -> dict:\n", " \"\"\"Convenience method to load the history from file.\"\"\"\n", " with open(history_fname, \"rb\") as file:\n", " history_dict = pickle.load(file)\n", " return history_dict" ], "outputs": [], "execution_count": 13 }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Checking For a Previous Optimization\n", "\n", "If `history_fname` is a valid file, the results of a previous optimization are loaded, then the optimization will continue from the last iteration step. If the optimization was completed, only the final structure will be simulated. The pickle file used in this notebook can be downloaded from our documentation [repo](https://github.com/flexcompute/tidy3d-notebooks/tree/develop/misc)." ] }, { "cell_type": "code", "metadata": { "tags": [], "ExecuteTime": { "end_time": "2026-03-16T10:28:17.192991Z", "start_time": "2026-03-16T10:28:17.190463Z" } }, "source": [ "try:\n", " history_dict = load_history()\n", " opt_state = history_dict[\"opt_states\"][-1]\n", " params = history_dict[\"params\"][-1]\n", " num_iters_completed = len(history_dict[\"params\"])\n", " print(\"Loaded optimization checkpoint from file.\")\n", " print(f\"Found {num_iters_completed} iterations previously completed out of {total_iter} total.\")\n", " if num_iters_completed < total_iter:\n", " print(\"Will resume optimization.\")\n", " else:\n", " print(\"Optimization completed, will return results.\")\n", "\n", "except FileNotFoundError:\n", " params = np.array(init_par)\n", " opt_state = optimizer.init(params)\n", " history_dict = dict(\n", " values=[],\n", " params=[],\n", " gradients=[],\n", " opt_states=[opt_state],\n", " data=[],\n", " beta=[],\n", " )" ], "outputs": [], "execution_count": 14 }, { "cell_type": "code", "metadata": { "tags": [], "ExecuteTime": { "end_time": "2026-03-16T13:03:36.127374Z", "start_time": "2026-03-16T10:28:17.236904Z" } }, "source": [ "iter_done = len(history_dict[\"values\"])\n", "\n", "for i in range(iter_done, total_iter):\n", " print(f\"iteration = ({i + 1} / {total_iter})\")\n", "\n", " # compute gradient and current objective function value\n", " perc_done = i / (total_iter - 1)\n", " beta_i = beta_min * (1 - perc_done) + beta_max * perc_done\n", " value, gradient = obj_grad(params, beta=beta_i)\n", "\n", " # outputs\n", " print(f\"\\tbeta = {beta_i}\")\n", " print(f\"\\tJ = {value:.4e}\")\n", " print(f\"\\tgrad_norm = {np.linalg.norm(gradient):.4e}\")\n", "\n", " # compute and apply updates to the optimizer based on gradient (-1 sign to maximize obj_fn)\n", " updates, opt_state = optimizer.update(-gradient, opt_state, params)\n", " params[:] = apply_updates(params, updates)\n", "\n", " # cap parameters between 0 and 1\n", " np.clip(params, 0.0, 1.0, out=params)\n", "\n", " # save history\n", " history_dict[\"values\"].append(value)\n", " history_dict[\"params\"].append(params)\n", " history_dict[\"beta\"].append(beta_i)\n", " history_dict[\"gradients\"].append(gradient)\n", " history_dict[\"opt_states\"].append(opt_state)\n", " # history_dict[\"data\"].append(sim_data_i) # uncomment to store data, can create large files\n", " save_history(history_dict)" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iteration = (1 / 75)\n", "\tbeta = 1.0\n", "\tJ = -9.9931e-01\n", "\tgrad_norm = 5.0684e-04\n", "iteration = (2 / 75)\n", "\tbeta = 1.3918918918918919\n", "\tJ = -8.5667e-01\n", "\tgrad_norm = 1.8488e-02\n", "iteration = (3 / 75)\n", "\tbeta = 1.7837837837837838\n", "\tJ = -6.5615e-01\n", "\tgrad_norm = 3.1502e-02\n", "iteration = (4 / 75)\n", "\tbeta = 2.1756756756756754\n", "\tJ = -2.5974e-01\n", "\tgrad_norm = 2.6614e-02\n", "iteration = (5 / 75)\n", "\tbeta = 2.5675675675675675\n", "\tJ = -1.6450e-01\n", "\tgrad_norm = 3.3836e-02\n", "iteration = (6 / 75)\n", "\tbeta = 2.9594594594594597\n", "\tJ = 6.7839e-03\n", "\tgrad_norm = 2.7315e-02\n", "iteration = (7 / 75)\n", "\tbeta = 3.3513513513513513\n", "\tJ = 6.3927e-02\n", "\tgrad_norm = 4.7242e-02\n", "iteration = (8 / 75)\n", "\tbeta = 3.7432432432432434\n", "\tJ = 1.8325e-01\n", "\tgrad_norm = 2.1999e-02\n", "iteration = (9 / 75)\n", "\tbeta = 4.135135135135135\n", "\tJ = 2.3186e-01\n", "\tgrad_norm = 3.5135e-02\n", "iteration = (10 / 75)\n", "\tbeta = 4.527027027027027\n", "\tJ = 2.9674e-01\n", "\tgrad_norm = 1.7063e-02\n", "iteration = (11 / 75)\n", "\tbeta = 4.918918918918919\n", "\tJ = 3.0984e-01\n", "\tgrad_norm = 4.6940e-02\n", "iteration = (12 / 75)\n", "\tbeta = 5.3108108108108105\n", "\tJ = 3.6498e-01\n", "\tgrad_norm = 1.6333e-02\n", "iteration = (13 / 75)\n", "\tbeta = 5.702702702702703\n", "\tJ = 3.8537e-01\n", "\tgrad_norm = 2.5993e-02\n", "iteration = (14 / 75)\n", "\tbeta = 6.094594594594595\n", "\tJ = 4.2099e-01\n", "\tgrad_norm = 2.6146e-02\n", "iteration = (15 / 75)\n", "\tbeta = 6.486486486486487\n", "\tJ = 4.4694e-01\n", "\tgrad_norm = 6.8875e-03\n", "iteration = (16 / 75)\n", "\tbeta = 6.878378378378379\n", "\tJ = 4.5602e-01\n", "\tgrad_norm = 1.2014e-02\n", "iteration = (17 / 75)\n", "\tbeta = 7.27027027027027\n", "\tJ = 4.6541e-01\n", "\tgrad_norm = 1.1680e-02\n", "iteration = (18 / 75)\n", "\tbeta = 7.662162162162162\n", "\tJ = 4.7758e-01\n", "\tgrad_norm = 9.5678e-03\n", "iteration = (19 / 75)\n", "\tbeta = 8.054054054054054\n", "\tJ = 4.8892e-01\n", "\tgrad_norm = 8.1238e-03\n", "iteration = (20 / 75)\n", "\tbeta = 8.445945945945946\n", "\tJ = 4.9837e-01\n", "\tgrad_norm = 5.5460e-03\n", "iteration = (21 / 75)\n", "\tbeta = 8.837837837837839\n", "\tJ = 5.0473e-01\n", "\tgrad_norm = 9.0177e-03\n", "iteration = (22 / 75)\n", "\tbeta = 9.229729729729728\n", "\tJ = 5.1153e-01\n", "\tgrad_norm = 8.2659e-03\n", "iteration = (23 / 75)\n", "\tbeta = 9.621621621621621\n", "\tJ = 5.1764e-01\n", "\tgrad_norm = 6.9985e-03\n", "iteration = (24 / 75)\n", "\tbeta = 10.013513513513514\n", "\tJ = 5.2214e-01\n", "\tgrad_norm = 5.6008e-03\n", "iteration = (25 / 75)\n", "\tbeta = 10.405405405405405\n", "\tJ = 5.2743e-01\n", "\tgrad_norm = 5.3771e-03\n", "iteration = (26 / 75)\n", "\tbeta = 10.797297297297296\n", "\tJ = 5.3291e-01\n", "\tgrad_norm = 5.4333e-03\n", "iteration = (27 / 75)\n", "\tbeta = 11.18918918918919\n", "\tJ = 5.3699e-01\n", "\tgrad_norm = 5.5197e-03\n", "iteration = (28 / 75)\n", "\tbeta = 11.58108108108108\n", "\tJ = 5.4124e-01\n", "\tgrad_norm = 5.4138e-03\n", "iteration = (29 / 75)\n", "\tbeta = 11.972972972972974\n", "\tJ = 5.4587e-01\n", "\tgrad_norm = 5.7056e-03\n", "iteration = (30 / 75)\n", "\tbeta = 12.364864864864865\n", "\tJ = 5.5136e-01\n", "\tgrad_norm = 3.5261e-03\n", "iteration = (31 / 75)\n", "\tbeta = 12.756756756756758\n", "\tJ = 5.5597e-01\n", "\tgrad_norm = 4.4858e-03\n", "iteration = (32 / 75)\n", "\tbeta = 13.148648648648647\n", "\tJ = 5.6065e-01\n", "\tgrad_norm = 3.4531e-03\n", "iteration = (33 / 75)\n", "\tbeta = 13.54054054054054\n", "\tJ = 5.6492e-01\n", "\tgrad_norm = 3.9379e-03\n", "iteration = (34 / 75)\n", "\tbeta = 13.932432432432433\n", "\tJ = 5.6913e-01\n", "\tgrad_norm = 4.0546e-03\n", "iteration = (35 / 75)\n", "\tbeta = 14.324324324324325\n", "\tJ = 5.7298e-01\n", "\tgrad_norm = 4.3578e-03\n", "iteration = (36 / 75)\n", "\tbeta = 14.716216216216216\n", "\tJ = 5.7663e-01\n", "\tgrad_norm = 3.1236e-03\n", "iteration = (37 / 75)\n", "\tbeta = 15.108108108108109\n", "\tJ = 5.7930e-01\n", "\tgrad_norm = 3.0947e-03\n", "iteration = (38 / 75)\n", "\tbeta = 15.5\n", "\tJ = 5.8213e-01\n", "\tgrad_norm = 2.7705e-03\n", "iteration = (39 / 75)\n", "\tbeta = 15.891891891891891\n", "\tJ = 5.8504e-01\n", "\tgrad_norm = 3.1421e-03\n", "iteration = (40 / 75)\n", "\tbeta = 16.283783783783782\n", "\tJ = 5.8809e-01\n", "\tgrad_norm = 3.0956e-03\n", "iteration = (41 / 75)\n", "\tbeta = 16.675675675675677\n", "\tJ = 5.9031e-01\n", "\tgrad_norm = 3.6009e-03\n", "iteration = (42 / 75)\n", "\tbeta = 17.06756756756757\n", "\tJ = 5.9271e-01\n", "\tgrad_norm = 3.0371e-03\n", "iteration = (43 / 75)\n", "\tbeta = 17.459459459459456\n", "\tJ = 5.9482e-01\n", "\tgrad_norm = 3.3239e-03\n", "iteration = (44 / 75)\n", "\tbeta = 17.85135135135135\n", "\tJ = 5.9726e-01\n", "\tgrad_norm = 2.7564e-03\n", "iteration = (45 / 75)\n", "\tbeta = 18.243243243243246\n", "\tJ = 5.9943e-01\n", "\tgrad_norm = 3.2329e-03\n", "iteration = (46 / 75)\n", "\tbeta = 18.635135135135133\n", "\tJ = 6.0129e-01\n", "\tgrad_norm = 2.7670e-03\n", "iteration = (47 / 75)\n", "\tbeta = 19.027027027027028\n", "\tJ = 6.0305e-01\n", "\tgrad_norm = 2.2379e-03\n", "iteration = (48 / 75)\n", "\tbeta = 19.41891891891892\n", "\tJ = 6.0490e-01\n", "\tgrad_norm = 2.1170e-03\n", "iteration = (49 / 75)\n", "\tbeta = 19.81081081081081\n", "\tJ = 6.0644e-01\n", "\tgrad_norm = 2.9861e-03\n", "iteration = (50 / 75)\n", "\tbeta = 20.202702702702705\n", "\tJ = 6.0811e-01\n", "\tgrad_norm = 2.3777e-03\n", "iteration = (51 / 75)\n", "\tbeta = 20.594594594594593\n", "\tJ = 6.0948e-01\n", "\tgrad_norm = 3.3268e-03\n", "iteration = (52 / 75)\n", "\tbeta = 20.986486486486484\n", "\tJ = 6.1194e-01\n", "\tgrad_norm = 2.7098e-03\n", "iteration = (53 / 75)\n", "\tbeta = 21.37837837837838\n", "\tJ = 6.1337e-01\n", "\tgrad_norm = 4.0915e-03\n", "iteration = (54 / 75)\n", "\tbeta = 21.77027027027027\n", "\tJ = 6.1474e-01\n", "\tgrad_norm = 4.7075e-03\n", "iteration = (55 / 75)\n", "\tbeta = 22.16216216216216\n", "\tJ = 6.1726e-01\n", "\tgrad_norm = 2.5552e-03\n", "iteration = (56 / 75)\n", "\tbeta = 22.554054054054053\n", "\tJ = 6.1824e-01\n", "\tgrad_norm = 4.2067e-03\n", "iteration = (57 / 75)\n", "\tbeta = 22.945945945945947\n", "\tJ = 6.1883e-01\n", "\tgrad_norm = 5.4854e-03\n", "iteration = (58 / 75)\n", "\tbeta = 23.33783783783784\n", "\tJ = 6.2092e-01\n", "\tgrad_norm = 3.3405e-03\n", "iteration = (59 / 75)\n", "\tbeta = 23.72972972972973\n", "\tJ = 6.2251e-01\n", "\tgrad_norm = 2.9213e-03\n", "iteration = (60 / 75)\n", "\tbeta = 24.12162162162162\n", "\tJ = 6.2380e-01\n", "\tgrad_norm = 4.0458e-03\n", "iteration = (61 / 75)\n", "\tbeta = 24.513513513513516\n", "\tJ = 6.2316e-01\n", "\tgrad_norm = 9.4360e-03\n", "iteration = (62 / 75)\n", "\tbeta = 24.905405405405407\n", "\tJ = 6.1947e-01\n", "\tgrad_norm = 1.7525e-02\n", "iteration = (63 / 75)\n", "\tbeta = 25.297297297297295\n", "\tJ = 6.1698e-01\n", "\tgrad_norm = 1.9879e-02\n", "iteration = (64 / 75)\n", "\tbeta = 25.68918918918919\n", "\tJ = 6.2018e-01\n", "\tgrad_norm = 1.7195e-02\n", "iteration = (65 / 75)\n", "\tbeta = 26.08108108108108\n", "\tJ = 6.2787e-01\n", "\tgrad_norm = 5.8718e-03\n", "iteration = (66 / 75)\n", "\tbeta = 26.472972972972972\n", "\tJ = 6.2505e-01\n", "\tgrad_norm = 1.1381e-02\n", "iteration = (67 / 75)\n", "\tbeta = 26.864864864864867\n", "\tJ = 6.3014e-01\n", "\tgrad_norm = 4.3446e-03\n", "iteration = (68 / 75)\n", "\tbeta = 27.256756756756754\n", "\tJ = 6.2900e-01\n", "\tgrad_norm = 8.8777e-03\n", "iteration = (69 / 75)\n", "\tbeta = 27.64864864864865\n", "\tJ = 6.3187e-01\n", "\tgrad_norm = 4.7070e-03\n", "iteration = (70 / 75)\n", "\tbeta = 28.040540540540544\n", "\tJ = 6.3252e-01\n", "\tgrad_norm = 5.8524e-03\n", "iteration = (71 / 75)\n", "\tbeta = 28.43243243243243\n", "\tJ = 6.3276e-01\n", "\tgrad_norm = 7.2980e-03\n", "iteration = (72 / 75)\n", "\tbeta = 28.824324324324323\n", "\tJ = 6.3197e-01\n", "\tgrad_norm = 1.2137e-02\n", "iteration = (73 / 75)\n", "\tbeta = 29.216216216216218\n", "\tJ = 6.3362e-01\n", "\tgrad_norm = 1.3135e-02\n", "iteration = (74 / 75)\n", "\tbeta = 29.60810810810811\n", "\tJ = 6.3657e-01\n", "\tgrad_norm = 3.2041e-03\n", "iteration = (75 / 75)\n", "\tbeta = 30.0\n", "\tJ = 6.3668e-01\n", "\tgrad_norm = 4.4061e-03\n" ] } ], "execution_count": 15 }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Optimization Results\n", "\n", "After 150 iterations, a coupling efficiency value of 0.71 (-1.48 dB) was achieved at the central wavelength." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T13:03:36.188462Z", "start_time": "2026-03-16T13:03:36.185763Z" } }, "source": [ "obj_vals = np.array(history_dict[\"values\"])\n", "final_par = history_dict[\"params\"][-1]\n", "final_beta = history_dict[\"beta\"][-1]" ], "outputs": [], "execution_count": 16 }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T13:03:36.288096Z", "start_time": "2026-03-16T13:03:36.234096Z" } }, "source": [ "fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n", "ax.plot(obj_vals, \"ro\")\n", "ax.set_xlabel(\"iterations\")\n", "ax.set_ylabel(\"objective function\")\n", "ax.set_ylim(-1, 1)\n", "ax.set_title(f\"Final Objective Function Value: {obj_vals[-1]:.2f}\")\n", "plt.show()" ], "outputs": [ { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } } ], "execution_count": 17 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The final grating coupler structure is well binarized, with mostly black (`eps_max`) and white (`eps_min`) regions." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T13:03:36.411261Z", "start_time": "2026-03-16T13:03:36.296178Z" } }, "source": [ "fig, ax = plt.subplots(1, figsize=(4, 4))\n", "sim_final = make_adjoint_sim(final_par, beta=final_beta, unfold=True)\n", "sim_final.plot_eps(z=0, source_alpha=0, monitor_alpha=0, ax=ax)\n", "plt.show()" ], "outputs": [ { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } } ], "execution_count": 18 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once the inverse design is complete, we can visualize the field distributions and the wavelength dependent coupling efficiency." ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { "end_time": "2026-03-16T13:04:28.569820Z", "start_time": "2026-03-16T13:03:36.417870Z" } }, "source": [ "# Field monitors to visualize the final fields.\n", "field_xy = td.FieldMonitor(\n", " size=(td.inf, td.inf, 0),\n", " freqs=[freq],\n", " name=\"field_xy\",\n", ")\n", "\n", "field_xz = td.FieldMonitor(\n", " size=(td.inf, 0, td.inf),\n", " freqs=[freq],\n", " name=\"field_xz\",\n", ")\n", "\n", "# Monitor to compute the grating coupler efficiency.\n", "gc_efficiency = td.ModeMonitor(\n", " center=[mon_pos_x, 0, 0],\n", " size=[0, mon_w, mon_h],\n", " freqs=freqs,\n", " mode_spec=mode_spec,\n", " name=\"gc_efficiency\",\n", ")\n", "\n", "sim_final = sim_final.copy(update=dict(monitors=(field_xy, field_xz, gc_efficiency)))\n", "sim_data_final = web.run(sim_final, task_name=\"inv_des_final\")" ], "outputs": [ { "data": { "text/plain": [ "\u001b[2;36m14:03:36 CET\u001b[0m\u001b[2;36m \u001b[0mCreated task \u001b[32m'inv_des_final'\u001b[0m with resource_id \n", "\u001b[2;36m \u001b[0m\u001b[32m'fdve-aaa2368e-e9b4-4569-8789-d79d657bd812'\u001b[0m and task_type \u001b[32m'FDTD'\u001b[0m. \n" ], "text/html": [ "
14:03:36 CET Created task 'inv_des_final' with resource_id                      \n",
       "             'fdve-aaa2368e-e9b4-4569-8789-d79d657bd812' and task_type 'FDTD'.  \n",
       "
\n" ] }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } }, { "data": { "text/plain": [ "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mView task using web UI at \n", "\u001b[2;36m \u001b[0m\u001b]8;id=348405;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[32m'https://tidy3d.simulation.cloud/workbench?\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=170949;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[32mtaskId\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=348405;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[32m=\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=743319;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[32mfdve\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=348405;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[32m-aaa2368e-e9b\u001b[0m\u001b]8;;\u001b\\\n", "\u001b[2;36m \u001b[0m\u001b]8;id=348405;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[32m4-4569-8789-d79d657bd812'\u001b[0m\u001b]8;;\u001b\\. \n" ], "text/html": [ "
             View task using web UI at                                          \n",
       "             'https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b\n",
       "             4-4569-8789-d79d657bd812'.                                         \n",
       "
\n" ] }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } }, { "data": { "text/plain": [ "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mTask folder: \u001b]8;id=931619;https://tidy3d.simulation.cloud/folders/folder-df61810d-cad6-4474-8ea9-e4f00d5dfcb0\u001b\\\u001b[32m'default'\u001b[0m\u001b]8;;\u001b\\. \n" ], "text/html": [ "
             Task folder: 'default'.                                            \n",
       "
\n" ] }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } }, { "data": { "text/plain": [ "Output()" ], "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, "model_id": "a6b7907b55b94488a4c4900b5e19b9a2" } }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } }, { "data": { "text/plain": [], "text/html": [ "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m14:03:47 CET\u001b[0m\u001b[2;36m \u001b[0mEstimated FlexCredit cost: \u001b[1;36m0.213\u001b[0m. Minimum cost depends on task     \n",
       "\u001b[2;36m             \u001b[0mexecution details. Use \u001b[32m'web.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed  \n",
       "\u001b[2;36m             \u001b[0mFlexCredit cost after a simulation run.                            \n"
      ],
      "text/html": [
       "
14:03:47 CET Estimated FlexCredit cost: 0.213. Minimum cost depends on task     \n",
       "             execution details. Use 'web.real_cost(task_id)' to get the billed  \n",
       "             FlexCredit cost after a simulation run.                            \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m14:03:49 CET\u001b[0m\u001b[2;36m \u001b[0mstatus = queued                                                    \n"
      ],
      "text/html": [
       "
14:03:49 CET status = queued                                                    \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m            \u001b[0m\u001b[2;36m \u001b[0mTo cancel the simulation, use \u001b[32m'web.abort\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or              \n",
       "\u001b[2;36m             \u001b[0m\u001b[32m'web.delete\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or abort/delete the task in the web UI.      \n",
       "\u001b[2;36m             \u001b[0mTerminating the Python script will not stop the job running on the \n",
       "\u001b[2;36m             \u001b[0mcloud.                                                             \n"
      ],
      "text/html": [
       "
             To cancel the simulation, use 'web.abort(task_id)' or              \n",
       "             'web.delete(task_id)' or abort/delete the task in the web UI.      \n",
       "             Terminating the Python script will not stop the job running on the \n",
       "             cloud.                                                             \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "Output()"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "71f313f67465423bac9a1fdad699a84c"
      }
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [],
      "text/html": [
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m14:04:09 CET\u001b[0m\u001b[2;36m \u001b[0mstarting up solver                                                 \n"
      ],
      "text/html": [
       "
14:04:09 CET starting up solver                                                 \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m            \u001b[0m\u001b[2;36m \u001b[0mrunning solver                                                     \n"
      ],
      "text/html": [
       "
             running solver                                                     \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "Output()"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "f1f9e22cf4f54c49ace54a00d167053e"
      }
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m14:04:22 CET\u001b[0m\u001b[2;36m \u001b[0mearly shutoff detected at \u001b[1;36m11\u001b[0m%, exiting.                            \n"
      ],
      "text/html": [
       "
14:04:22 CET early shutoff detected at 11%, exiting.                            \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [],
      "text/html": [
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m14:04:23 CET\u001b[0m\u001b[2;36m \u001b[0mstatus = success                                                   \n"
      ],
      "text/html": [
       "
14:04:23 CET status = success                                                   \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [],
      "text/html": [
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m            \u001b[0m\u001b[2;36m \u001b[0mView simulation result at                                          \n",
       "\u001b[2;36m             \u001b[0m\u001b]8;id=275345;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[4;34m'https://tidy3d.simulation.cloud/workbench?\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=459676;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[4;34mtaskId\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=275345;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[4;34m=\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=786866;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[4;34mfdve\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=275345;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[4;34m-aaa2368e-e9b\u001b[0m\u001b]8;;\u001b\\\n",
       "\u001b[2;36m             \u001b[0m\u001b]8;id=275345;https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b4-4569-8789-d79d657bd812\u001b\\\u001b[4;34m4-4569-8789-d79d657bd812'\u001b[0m\u001b]8;;\u001b\\\u001b[4;34m.\u001b[0m                                         \n"
      ],
      "text/html": [
       "
             View simulation result at                                          \n",
       "             'https://tidy3d.simulation.cloud/workbench?taskId=fdve-aaa2368e-e9b\n",
       "             4-4569-8789-d79d657bd812'.                                         \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "Output()"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "e6eccdf1eabc4d0ab6e2de6bcd0ba1b4"
      }
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [],
      "text/html": [
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "\u001b[2;36m14:04:28 CET\u001b[0m\u001b[2;36m \u001b[0mLoading results from simulation_data.hdf5                          \n"
      ],
      "text/html": [
       "
14:04:28 CET Loading results from simulation_data.hdf5                          \n",
       "
\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-16T13:04:29.150784Z",
     "start_time": "2026-03-16T13:04:28.589513Z"
    }
   },
   "source": [
    "mode_amps = sim_data_final[\"gc_efficiency\"]\n",
    "coeffs_f = mode_amps.amps.sel(direction=\"-\")\n",
    "power_0 = np.abs(coeffs_f.sel(mode_index=0)) ** 2\n",
    "power_0_db = 10 * np.log10(power_0)\n",
    "\n",
    "sim_plot = sim_final.updated_copy(symmetry=(0, 0, 0), monitors=(field_xy, field_xz, gc_efficiency))\n",
    "sim_data_plot = sim_data_final.updated_copy(simulation=sim_plot)\n",
    "\n",
    "f, ax = plt.subplots(2, 2, figsize=(8, 6), tight_layout=True)\n",
    "sim_plot.plot_eps(z=0, source_alpha=0, monitor_alpha=0, ax=ax[0, 1])\n",
    "ax[1, 0].plot(wl_range, power_0_db, \"-k\")\n",
    "ax[1, 0].set_xlabel(\"Wavelength (um)\")\n",
    "ax[1, 0].set_ylabel(\"Power (db)\")\n",
    "ax[1, 0].set_ylim(-15, 0)\n",
    "ax[1, 0].set_xlim(wl - bw / 2, wl + bw / 2)\n",
    "ax[1, 0].set_title(\"Coupling Efficiency\")\n",
    "sim_data_plot.plot_field(\"field_xy\", \"E\", \"abs^2\", z=0, ax=ax[1, 1])\n",
    "ax[0, 0].plot(obj_vals, \"ro\")\n",
    "ax[0, 0].set_xlabel(\"iterations\")\n",
    "ax[0, 0].set_ylabel(\"objective function\")\n",
    "ax[0, 0].set_ylim(-1, 1)\n",
    "ax[0, 0].set_title(f\"Final Objective Function Value: {obj_vals[-1]:.2f}\")\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "
"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-16T13:04:29.170223Z",
     "start_time": "2026-03-16T13:04:29.158570Z"
    }
   },
   "source": [
    "loss_db = max(power_0_db)\n",
    "print(f\"optimized loss of {loss_db:.2f} dB\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimized loss of -1.78 dB\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export to GDS\n",
    "The `Simulation` object has the [.to_gds_file](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.Simulation.html#tidy3d.Simulation.to_gds_file) convenience function to export the final design to a `GDS` file. In addition to a file name, it is necessary to set a cross-sectional plane (`z = 0` in this case) on which to evaluate the geometry, a `frequency` to evaluate the permittivity, and a `permittivity_threshold` to define the shape boundaries in custom mediums. See the [GDS export](https://www.flexcompute.com/tidy3d/examples/notebooks/GDSExport/) notebook for a detailed example on using `.to_gds_file` and other GDS related functions."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-16T13:04:29.221490Z",
     "start_time": "2026-03-16T13:04:29.203684Z"
    }
   },
   "source": [
    "sim_final.to_gds_file(\n",
    "    fname=\"./misc/inverse_designed_gc.gds\",\n",
    "    z=0,\n",
    "    permittivity_threshold=(eps_max + eps_min) / 2,\n",
    "    frequency=freq,\n",
    ")"
   ],
   "outputs": [],
   "execution_count": 22
  }
 ],
 "metadata": {
  "applications": [
   "Passive photonic integrated circuit components"
  ],
  "description": "This notebook demonstrates the inverse design of a compact 3D grating coupler with permittivity binarization and minimum feature size control.",
  "feature_image": "./img/adjoint_6.png",
  "features": [
   "Adjoint inverse design"
  ],
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "keywords": "inverse design, grating coupler, photonic integrated circuits, design optimization, adjoint, Tidy3D, FDTD",
  "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.11.2"
  },
  "nbdime-conflicts": {
   "local_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "diff": [
          {
           "key": 5,
           "op": "addrange",
           "valuelist": "9"
          },
          {
           "key": 5,
           "length": 1,
           "op": "removerange"
          }
         ],
         "key": 0,
         "op": "patch"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ],
   "remote_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "diff": [
          {
           "key": 5,
           "op": "addrange",
           "valuelist": "12"
          },
          {
           "key": 5,
           "length": 1,
           "op": "removerange"
          }
         ],
         "key": 0,
         "op": "patch"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ]
  },
  "title": "Inverse Design of a Grating Coupler in Tidy3D | Flexcompute",
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "066ae3cd7b2843d6ac0977f73d1373ff": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "1377d3a4074543dc8772ada613a50024": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/output",
       "_model_module_version": "1.0.0",
       "_model_name": "OutputModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/output",
       "_view_module_version": "1.0.0",
       "_view_name": "OutputView",
       "layout": "IPY_MODEL_6bf536a19d7241258dd64a0053933ea1",
       "msg_id": "",
       "outputs": [
        {
         "data": {
          "text/html": "
🏃  Finishing 'inv_des_final'...\n
\n",
          "text/plain": "\u001b[32m🏃 \u001b[0m \u001b[1;32mFinishing 'inv_des_final'...\u001b[0m\n"
         },
         "metadata": {},
         "output_type": "display_data"
        }
       ],
       "tabbable": null,
       "tooltip": null
      }
     },
     "2ee47e11bd644b928d4e1958161923bb": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/output",
       "_model_module_version": "1.0.0",
       "_model_name": "OutputModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/output",
       "_view_module_version": "1.0.0",
       "_view_name": "OutputView",
       "layout": "IPY_MODEL_91395efbed0d4032b01f7d69e8722e11",
       "msg_id": "",
       "outputs": [
        {
         "data": {
          "text/html": "
↑ simulation.hdf5.gz ━━━━━━━━━━━━━━━━━━━━━━━ 100.0% • 77.0/77.0 kB • ? • 0:00:00\n
\n",
          "text/plain": "\u001b[1;31m↑\u001b[0m \u001b[1;34msimulation.hdf5.gz\u001b[0m \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[35m100.0%\u001b[0m • \u001b[32m77.0/77.0 kB\u001b[0m • \u001b[31m?\u001b[0m • \u001b[36m0:00:00\u001b[0m\n"
         },
         "metadata": {},
         "output_type": "display_data"
        }
       ],
       "tabbable": null,
       "tooltip": null
      }
     },
     "509db80a6caf47edb14635ddd1380a94": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "699ec8475ab7423c9745a72caefeecde": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/output",
       "_model_module_version": "1.0.0",
       "_model_name": "OutputModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/output",
       "_view_module_version": "1.0.0",
       "_view_name": "OutputView",
       "layout": "IPY_MODEL_d0b35e0ff7244f9bad5f047689ee6aef",
       "msg_id": "",
       "outputs": [
        {
         "data": {
          "text/html": "
🚶  Starting 'inv_des_final'...\n
\n",
          "text/plain": "\u001b[32m🚶 \u001b[0m \u001b[1;32mStarting 'inv_des_final'...\u001b[0m\n"
         },
         "metadata": {},
         "output_type": "display_data"
        }
       ],
       "tabbable": null,
       "tooltip": null
      }
     },
     "6bf536a19d7241258dd64a0053933ea1": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "7102600812d14200a8e80dc3bbb4b1b1": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/output",
       "_model_module_version": "1.0.0",
       "_model_name": "OutputModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/output",
       "_view_module_version": "1.0.0",
       "_view_name": "OutputView",
       "layout": "IPY_MODEL_509db80a6caf47edb14635ddd1380a94",
       "msg_id": "",
       "outputs": [
        {
         "data": {
          "text/html": "
solver progress (field decay = 2.07e-04) ━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:00\n
\n",
          "text/plain": "solver progress (field decay = 2.07e-04) \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[35m100%\u001b[0m \u001b[36m0:00:00\u001b[0m\n"
         },
         "metadata": {},
         "output_type": "display_data"
        }
       ],
       "tabbable": null,
       "tooltip": null
      }
     },
     "91395efbed0d4032b01f7d69e8722e11": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "c2f0576e0ecd418eb80b2449d5c3a2e8": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/output",
       "_model_module_version": "1.0.0",
       "_model_name": "OutputModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/output",
       "_view_module_version": "1.0.0",
       "_view_name": "OutputView",
       "layout": "IPY_MODEL_066ae3cd7b2843d6ac0977f73d1373ff",
       "msg_id": "",
       "outputs": [
        {
         "data": {
          "text/html": "
↓ monitor_data.hdf5 ━━━━━━━━━━━━━━━━━━ 100.0% • 4.2/4.2 MB • 19.0 MB/s • 0:00:00\n
\n",
          "text/plain": "\u001b[1;32m↓\u001b[0m \u001b[1;34mmonitor_data.hdf5\u001b[0m \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[35m100.0%\u001b[0m • \u001b[32m4.2/4.2 MB\u001b[0m • \u001b[31m19.0 MB/s\u001b[0m • \u001b[36m0:00:00\u001b[0m\n"
         },
         "metadata": {},
         "output_type": "display_data"
        }
       ],
       "tabbable": null,
       "tooltip": null
      }
     },
     "d0b35e0ff7244f9bad5f047689ee6aef": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}