{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "67c6c455",
   "metadata": {
    "id": "67c6c455"
   },
   "source": [
    "# FDTD design of a 1D diffractive optical edge detector\n",
    "\n",
    "**Author:** Donghee Lee, University of Seoul\n",
    "\n",
    "This notebook designs a 1D dielectric phase-step grating that acts like a simple optical spatial differentiator. The FDTD result is interpreted as a physical transfer function for optical neural-network preprocessing:\n",
    "\n",
    "$$H(k_x) \\propto i k_x.$$\n",
    "\n",
    "Here, $A_m$ is the complex transmitted amplitude of diffraction order $m$.\n",
    "\n",
    "For the first transmitted side orders, the desired edge-detection condition is:\n",
    "\n",
    "$$A_{+1} \\approx -A_{-1}, \\qquad A_0 \\approx 0.$$\n",
    "\n",
    "The notebook intentionally keeps the setup simple:\n",
    "\n",
    "- no automatic package installation inside the notebook,\n",
    "- no automatic kernel restart,\n",
    "- one authentication cell,\n",
    "- one simulation builder,\n",
    "- one batch sweep,\n",
    "- one best-field run,\n",
    "- one compact convergence check.\n",
    "\n",
    "<img src=\"img/DiffractiveOpticalEdgeDetector.png\" width=\"500\" alt=\"Schematic\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b652685",
   "metadata": {
    "id": "0b652685"
   },
   "source": [
    "## Setup\n",
    "\n",
    "If this is your first time using Tidy3D, please follow the [Start Here](https://docs.flexcompute.com/projects/tidy3d/en/latest/index.html) guide to install the package and configure your API key.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a36e066f",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a36e066f",
    "outputId": "868648b6-49a0-4634-a8d3-3cf8caf3dac1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tidy3D version: 2.10.2\n",
      "NumPy version : 2.4.4\n",
      "Pandas version: 2.3.3\n",
      "tidy3d.web import OK\n"
     ]
    }
   ],
   "source": [
    "# 1. Imports and preflight checks\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display, Image\n",
    "\n",
    "try:\n",
    "    import tidy3d as td\n",
    "except ModuleNotFoundError as exc:\n",
    "    raise ModuleNotFoundError(\n",
    "        \"Tidy3D is not installed. Install it outside the notebook with:\\n\"\n",
    "        \"python -m pip install tidy3d==2.10.2 numpy pandas matplotlib ipython\\n\"\n",
    "        \"Then restart the kernel and run again.\"\n",
    "    ) from exc\n",
    "\n",
    "try:\n",
    "    import tidy3d.web as web\n",
    "except Exception as exc:\n",
    "    raise ImportError(\n",
    "        \"tidy3d.web failed to import. Use a clean environment and install:\\n\"\n",
    "        \"python -m pip install tidy3d==2.10.2 numpy pandas matplotlib ipython\\n\"\n",
    "        \"Then restart the kernel and run again.\"\n",
    "    ) from exc\n",
    "\n",
    "\n",
    "# Keep public notebook output clean after the geometry has been intentionally bounded.\n",
    "# The finite ridge uses a physical margin in the simulation builder; this only suppresses\n",
    "# repeated non-fatal geometry warnings from cluttering the submitted notebook.\n",
    "try:\n",
    "    td.config.logging_level = \"ERROR\"\n",
    "except Exception:\n",
    "    import logging\n",
    "\n",
    "    logging.getLogger(\"tidy3d\").setLevel(logging.ERROR)\n",
    "\n",
    "print(\"Tidy3D version:\", td.__version__)\n",
    "print(\"NumPy version :\", np.__version__)\n",
    "print(\"Pandas version:\", pd.__version__)\n",
    "print(\"tidy3d.web import OK\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3cb3100",
   "metadata": {
    "id": "b3cb3100"
   },
   "source": [
    "## 1. Physical Parameters\n",
    "\n",
    "The design is a one-period silicon ridge on silica. The simulation is periodic along $x$, invariant along $y$, and open along $z$. A normally incident plane wave illuminates the grating from air. Material dispersion is neglected at the design wavelength of 1.55 \u00b5m; both materials are modelled with [Medium](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.Medium.html) using a constant permittivity.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3050d9c3",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3050d9c3",
    "outputId": "c41afbea-d432-4959-b786-ca6de300f44d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lambda0 = 1.550 um\n",
      "period  = 2.200 um\n",
      "first-order angle in air \u2248 44.8 deg\n"
     ]
    }
   ],
   "source": [
    "# Tidy3D length unit is micrometer.\n",
    "um = 1.0\n",
    "nm = 1e-3\n",
    "\n",
    "# Operating wavelength.\n",
    "lambda0 = 1.55 * um\n",
    "freq0 = td.C_0 / lambda0\n",
    "fwidth = freq0 / 30\n",
    "run_time = 80 / fwidth\n",
    "\n",
    "# Materials.\n",
    "air = td.Medium(permittivity=1.0)\n",
    "sio2 = td.Medium(permittivity=1.444**2)\n",
    "si = td.Medium(permittivity=3.48**2)\n",
    "\n",
    "# Grating period: choose period > wavelength so +/-1 diffraction orders propagate in air.\n",
    "period = 2.20 * um\n",
    "\n",
    "# Vertical layout.\n",
    "space_above = 1.2 * lambda0\n",
    "space_below = 1.2 * lambda0\n",
    "substrate_thickness = 1.0 * um\n",
    "\n",
    "# Numerical settings.\n",
    "min_steps_per_wvl_default = 35\n",
    "num_pml_layers = 36\n",
    "\n",
    "# Output files.\n",
    "OUT = Path(\"edge_detector_outputs\")\n",
    "OUT.mkdir(exist_ok=True)\n",
    "SWEEP_CSV = OUT / \"sweep_results.csv\"\n",
    "TOP10_CSV = OUT / \"top10_submission_table.csv\"\n",
    "BEST_METRICS_CSV = OUT / \"best_candidate_metrics.csv\"\n",
    "BEST_FIELD_PNG = OUT / \"best_candidate_Ex_field.png\"\n",
    "CONVERGENCE_CSV = OUT / \"convergence_check.csv\"\n",
    "\n",
    "print(f\"lambda0 = {lambda0:.3f} um\")\n",
    "print(f\"period  = {period:.3f} um\")\n",
    "print(f\"first-order angle in air \u2248 {np.degrees(np.arcsin(lambda0 / period)):.1f} deg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60a3bc33",
   "metadata": {
    "id": "60a3bc33"
   },
   "source": [
    "## 2. Ideal Binary Phase-Step Sanity Check\n",
    "\n",
    "An ideal half-period $\\pi$-phase step suppresses the zero-order Fourier coefficient and creates strong odd diffraction orders. This analytic calculation motivates the FDTD sweep that follows: it sets the upper bound on what a real silicon ridge of finite thickness can achieve.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6fb557c2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6fb557c2",
    "outputId": "928ecd11-17c6-4cbe-b4c7-f14cf7ecff0c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m=-2: |c|^2=0.0000, phase=+3.141 rad\n",
      "m=-1: |c|^2=0.4053, phase=+1.571 rad\n",
      "m=+0: |c|^2=0.0000, phase=+3.142 rad\n",
      "m=+1: |c|^2=0.4053, phase=-1.571 rad\n",
      "m=+2: |c|^2=0.0000, phase=-3.141 rad\n",
      "phase difference A(+1)/A(-1) = -3.141 rad\n",
      "error from pi phase difference = 1.571e-04 rad\n"
     ]
    }
   ],
   "source": [
    "def binary_phase_coefficients(\n",
    "    duty=0.5, phase_step=np.pi, num_harmonics=3, num_points=20001\n",
    "):\n",
    "    \"\"\"Fourier coefficients of a one-period binary phase step.\"\"\"\n",
    "    x = np.linspace(-0.5, 0.5, num_points, endpoint=False)\n",
    "    t = np.ones_like(x, dtype=complex)\n",
    "    t[(x >= -0.5) & (x < -0.5 + duty)] = np.exp(1j * phase_step)\n",
    "\n",
    "    coeffs = {}\n",
    "    for m in range(-num_harmonics, num_harmonics + 1):\n",
    "        coeffs[m] = np.mean(t * np.exp(-1j * 2 * np.pi * m * x))\n",
    "    return coeffs\n",
    "\n",
    "\n",
    "coeffs = binary_phase_coefficients()\n",
    "for m in [-2, -1, 0, 1, 2]:\n",
    "    c = coeffs[m]\n",
    "    print(f\"m={m:+d}: |c|^2={abs(c) ** 2:.4f}, phase={np.angle(c):+.3f} rad\")\n",
    "\n",
    "phase_diff = np.angle(coeffs[1] / coeffs[-1])\n",
    "phase_error = abs(np.angle(np.exp(1j * (phase_diff - np.pi))))\n",
    "print(f\"phase difference A(+1)/A(-1) = {phase_diff:+.3f} rad\")\n",
    "print(f\"error from pi phase difference = {phase_error:.3e} rad\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5df4b155",
   "metadata": {
    "id": "5df4b155"
   },
   "source": [
    "## 3. Simulation Builder\n",
    "\n",
    "The substrate uses `td.inf` in the periodic directions. The finite silicon ridge is intentionally kept away from the exact periodic boundary by a 1 nm margin to avoid repeated geometry warnings while preserving the intended one-period phase-step grating physics. \n",
    "\n",
    "A normally incident [PlaneWave](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.PlaneWave.html) source with a [GaussianPulse](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.GaussianPulse.html) excitation is placed above the grating, and two [DiffractionMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.DiffractionMonitor.html) planes record the reflected and transmitted orders. An optional [FieldMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldMonitor.html) is attached for the best-candidate run only.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "22d30a89",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "22d30a89",
    "outputId": "8d6422bb-68a8-4272-93a1-156f5ba32400"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quick geometry check simulation built successfully.\n",
      "Simulation size: (2.2, 0.0, 4.9399999999999995)\n",
      "Number of structures: 2\n"
     ]
    }
   ],
   "source": [
    "def make_simulation(\n",
    "    duty=0.50,\n",
    "    ridge_height=0.220,\n",
    "    min_steps_per_wvl=min_steps_per_wvl_default,\n",
    "    add_field_monitor=False,\n",
    "):\n",
    "    \"\"\"Build one Tidy3D simulation for the 1D diffractive edge-detector grating.\"\"\"\n",
    "\n",
    "    # Keep the finite ridge away from the exact periodic boundary.\n",
    "    # 1 nm is large enough to avoid Tidy3D boundary-touching warnings,\n",
    "    # but negligible relative to the micron-scale grating period.\n",
    "    edge_margin = 1e-3 * um\n",
    "    ridge_width = duty * period\n",
    "    ridge_width_eff = np.clip(\n",
    "        ridge_width - 2 * edge_margin,\n",
    "        edge_margin,\n",
    "        period - 2 * edge_margin,\n",
    "    )\n",
    "    ridge_center_x = -period / 2 + edge_margin + ridge_width_eff / 2\n",
    "\n",
    "    length_z = space_below + substrate_thickness + ridge_height + space_above\n",
    "    z_bottom = -length_z / 2\n",
    "\n",
    "    z_sub_center = z_bottom + space_below + substrate_thickness / 2\n",
    "    z_ridge_center = z_bottom + space_below + substrate_thickness + ridge_height / 2\n",
    "    z_source = (\n",
    "        z_bottom + space_below + substrate_thickness + ridge_height + 0.65 * space_above\n",
    "    )\n",
    "    z_ref_mon = (\n",
    "        z_bottom + space_below + substrate_thickness + ridge_height + 0.35 * space_above\n",
    "    )\n",
    "    z_trn_mon = z_bottom + 0.55 * space_below\n",
    "\n",
    "    substrate = td.Structure(\n",
    "        geometry=td.Box(\n",
    "            center=(0, 0, z_sub_center),\n",
    "            size=(td.inf, td.inf, substrate_thickness),\n",
    "        ),\n",
    "        medium=sio2,\n",
    "    )\n",
    "\n",
    "    ridge = td.Structure(\n",
    "        geometry=td.Box(\n",
    "            center=(ridge_center_x, 0, z_ridge_center),\n",
    "            size=(ridge_width_eff, td.inf, ridge_height),\n",
    "        ),\n",
    "        medium=si,\n",
    "    )\n",
    "\n",
    "    source = td.PlaneWave(\n",
    "        center=(0, 0, z_source),\n",
    "        size=(td.inf, td.inf, 0),\n",
    "        source_time=td.GaussianPulse(freq0=freq0, fwidth=fwidth),\n",
    "        direction=\"-\",\n",
    "        pol_angle=0,\n",
    "    )\n",
    "\n",
    "    monitors = [\n",
    "        td.DiffractionMonitor(\n",
    "            center=(0, 0, z_ref_mon),\n",
    "            size=(td.inf, td.inf, 0),\n",
    "            freqs=[freq0],\n",
    "            name=\"reflection\",\n",
    "            normal_dir=\"+\",\n",
    "        ),\n",
    "        td.DiffractionMonitor(\n",
    "            center=(0, 0, z_trn_mon),\n",
    "            size=(td.inf, td.inf, 0),\n",
    "            freqs=[freq0],\n",
    "            name=\"transmission\",\n",
    "            normal_dir=\"-\",\n",
    "        ),\n",
    "    ]\n",
    "\n",
    "    if add_field_monitor:\n",
    "        monitors.append(\n",
    "            td.FieldMonitor(\n",
    "                center=(0, 0, 0),\n",
    "                size=(td.inf, 0, td.inf),\n",
    "                freqs=[freq0],\n",
    "                name=\"field_xz\",\n",
    "            )\n",
    "        )\n",
    "\n",
    "    boundary_spec = td.BoundarySpec(\n",
    "        x=td.Boundary.periodic(),\n",
    "        y=td.Boundary.periodic(),\n",
    "        z=td.Boundary(\n",
    "            minus=td.PML(num_layers=num_pml_layers),\n",
    "            plus=td.PML(num_layers=num_pml_layers),\n",
    "        ),\n",
    "    )\n",
    "\n",
    "    return td.Simulation(\n",
    "        size=(period, 0, length_z),\n",
    "        medium=air,\n",
    "        grid_spec=td.GridSpec.auto(min_steps_per_wvl=min_steps_per_wvl),\n",
    "        structures=[substrate, ridge],\n",
    "        sources=[source],\n",
    "        monitors=monitors,\n",
    "        run_time=run_time,\n",
    "        boundary_spec=boundary_spec,\n",
    "    )\n",
    "\n",
    "\n",
    "# Quick geometry check.\n",
    "sim0 = make_simulation(duty=0.50, ridge_height=0.220)\n",
    "print(\"Quick geometry check simulation built successfully.\")\n",
    "print(f\"Simulation size: {sim0.size}\")\n",
    "print(f\"Number of structures: {len(sim0.structures)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "da955ec4",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 410
    },
    "id": "da955ec4",
    "outputId": "9b52fc25-17c6-408c-e1f4-a33a2bab1b98"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Optional geometry plot.\n",
    "fig, ax = plt.subplots(1, 1, figsize=(7, 4))\n",
    "sim0.plot(y=0, ax=ax)\n",
    "ax.set_title(\"Boundary-safe unit-cell geometry, y = 0 slice\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec1d06e8",
   "metadata": {
    "id": "ec1d06e8"
   },
   "source": [
    "## 4. Diffraction-Order Objective\n",
    "\n",
    "The score rewards strong and balanced transmitted $\\pm 1$ orders, penalizes zero-order leakage, and penalizes phase deviation from $\\pi$ between $A_{+1}$ and $A_{-1}$. It is a single scalar that ranks all geometries in the sweep.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "edde84e9",
   "metadata": {
    "id": "edde84e9"
   },
   "outputs": [],
   "source": [
    "def _scalar(value):\n",
    "    return float(np.asarray(value).squeeze())\n",
    "\n",
    "\n",
    "def phase_error_to_pi(a_plus, a_minus):\n",
    "    if abs(a_plus) == 0 or abs(a_minus) == 0:\n",
    "        return np.pi\n",
    "    phase_diff = np.angle(a_plus / a_minus)\n",
    "    return abs(np.angle(np.exp(1j * (phase_diff - np.pi))))\n",
    "\n",
    "\n",
    "def diffraction_metrics(sim_data, polarization=\"p\"):\n",
    "    \"\"\"Extract edge-detector metrics from a completed Tidy3D simulation.\"\"\"\n",
    "\n",
    "    trn = sim_data[\"transmission\"]\n",
    "    ref = sim_data[\"reflection\"]\n",
    "\n",
    "    total_power = _scalar(trn.power.sum() + ref.power.sum())\n",
    "\n",
    "    p_m1 = _scalar(trn.power.sel(orders_x=-1, orders_y=0, f=freq0, method=\"nearest\"))\n",
    "    p_0 = _scalar(trn.power.sel(orders_x=0, orders_y=0, f=freq0, method=\"nearest\"))\n",
    "    p_p1 = _scalar(trn.power.sel(orders_x=+1, orders_y=0, f=freq0, method=\"nearest\"))\n",
    "\n",
    "    a_m1 = np.asarray(\n",
    "        trn.amps.sel(orders_x=-1, orders_y=0, f=freq0, method=\"nearest\").sel(\n",
    "            polarization=polarization\n",
    "        )\n",
    "    ).squeeze()\n",
    "    a_p1 = np.asarray(\n",
    "        trn.amps.sel(orders_x=+1, orders_y=0, f=freq0, method=\"nearest\").sel(\n",
    "            polarization=polarization\n",
    "        )\n",
    "    ).squeeze()\n",
    "\n",
    "    first_order_power = p_m1 + p_p1\n",
    "    balance = 1 - abs(p_p1 - p_m1) / (first_order_power + 1e-12)\n",
    "    phase_err = phase_error_to_pi(a_p1, a_m1)\n",
    "\n",
    "    edge_score = (\n",
    "        first_order_power * balance * np.exp(-((phase_err / 0.7) ** 2)) / (p_0 + 1e-3)\n",
    "    )\n",
    "\n",
    "    return {\n",
    "        \"P_total_R_plus_T\": total_power,\n",
    "        \"P_T_m1\": p_m1,\n",
    "        \"P_T_0\": p_0,\n",
    "        \"P_T_p1\": p_p1,\n",
    "        \"P_T_first_orders\": first_order_power,\n",
    "        \"balance_pm1\": balance,\n",
    "        \"phase_error_to_pi_rad\": phase_err,\n",
    "        \"phase_error_to_pi_deg\": np.degrees(phase_err),\n",
    "        \"edge_score\": edge_score,\n",
    "    }\n",
    "\n",
    "\n",
    "def show_table(df, n=10, title=\"Top candidates\"):\n",
    "    cols = [\n",
    "        \"duty\",\n",
    "        \"ridge_height_um\",\n",
    "        \"edge_score\",\n",
    "        \"P_T_m1\",\n",
    "        \"P_T_0\",\n",
    "        \"P_T_p1\",\n",
    "        \"phase_error_to_pi_deg\",\n",
    "        \"balance_pm1\",\n",
    "        \"P_total_R_plus_T\",\n",
    "    ]\n",
    "    table = df.sort_values(\"edge_score\", ascending=False)[cols].head(n).copy()\n",
    "    print(title)\n",
    "    display(\n",
    "        table.style.format(\n",
    "            {\n",
    "                \"duty\": \"{:.3f}\",\n",
    "                \"ridge_height_um\": \"{:.3f}\",\n",
    "                \"edge_score\": \"{:.4g}\",\n",
    "                \"P_T_m1\": \"{:.4f}\",\n",
    "                \"P_T_0\": \"{:.4f}\",\n",
    "                \"P_T_p1\": \"{:.4f}\",\n",
    "                \"phase_error_to_pi_deg\": \"{:.2f}\",\n",
    "                \"balance_pm1\": \"{:.3f}\",\n",
    "                \"P_total_R_plus_T\": \"{:.3f}\",\n",
    "            }\n",
    "        )\n",
    "    )\n",
    "    return table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e2c54bc",
   "metadata": {
    "id": "2e2c54bc"
   },
   "source": [
    "## 5. Parameter Sweep\n",
    "\n",
    "A [Batch](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.web.api.container.Batch.html) submits the FDTD sweep over duty cycle and ridge height. Results are cached to a CSV so the sweep is only re-run when the cache is missing.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d1a1526b",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "d1a1526b",
    "outputId": "01a9a258-493c-4bc4-f67f-40b05bc434e7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prepared 35 simulations.\n"
     ]
    }
   ],
   "source": [
    "duties = np.array([0.40, 0.45, 0.50, 0.55, 0.60])\n",
    "ridge_heights = np.array([0.160, 0.190, 0.220, 0.250, 0.280, 0.310, 0.340])\n",
    "\n",
    "sims = {}\n",
    "metadata = {}\n",
    "\n",
    "for duty in duties:\n",
    "    for height in ridge_heights:\n",
    "        name = f\"duty={duty:.2f}_height={height:.3f}um\"\n",
    "        sims[name] = make_simulation(duty=float(duty), ridge_height=float(height))\n",
    "        metadata[name] = {\"duty\": float(duty), \"ridge_height_um\": float(height)}\n",
    "\n",
    "print(f\"Prepared {len(sims)} simulations.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e490fce8",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 756,
     "referenced_widgets": [
      "8880d24324874c6991df4dc9deec0ef6",
      "59953a723b484f42b779078c663c8ba4",
      "9675dfda6ead4b0fb0fc0af0a0236722",
      "2a241320eb6e4e0799725d2dac062dd1"
     ]
    },
    "id": "e490fce8",
    "outputId": "1c277b27-6244-47ea-aab4-ba4583a9abea"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting FDTD sweep...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f92ef06f953f40a18c0548f2a9d69dcf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:42:09 -03 </span>Started working on Batch containing <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">35</span> tasks.                      \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:42:09 -03\u001b[0m\u001b[2;36m \u001b[0mStarted working on Batch containing \u001b[1;36m35\u001b[0m tasks.                      \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:43:03 -03 </span>Maximum FlexCredit cost: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0.875</span> for the whole batch.                \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:43:03 -03\u001b[0m\u001b[2;36m \u001b[0mMaximum FlexCredit cost: \u001b[1;36m0.875\u001b[0m for the whole batch.                \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>Use <span style=\"color: #008000; text-decoration-color: #008000\">'Batch.real_cost()'</span> to get the billed FlexCredit cost after    \n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>completion.                                                        \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m            \u001b[0m\u001b[2;36m \u001b[0mUse \u001b[32m'Batch.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed FlexCredit cost after    \n",
       "\u001b[2;36m             \u001b[0mcompletion.                                                        \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac82ca6f62184db69a037851a514928a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:44:35 -03 </span>Batch complete.                                                    \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:44:35 -03\u001b[0m\u001b[2;36m \u001b[0mBatch complete.                                                    \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved sweep results to edge_detector_outputs/sweep_results.csv\n",
      "Result rows: 35\n"
     ]
    }
   ],
   "source": [
    "if SWEEP_CSV.exists():\n",
    "    df = pd.read_csv(SWEEP_CSV)\n",
    "    print(f\"Loaded cached sweep results from {SWEEP_CSV}\")\n",
    "else:\n",
    "    print(\"Submitting FDTD sweep...\")\n",
    "    batch = web.Batch(simulations=sims, verbose=True)\n",
    "    batch_results = batch.run(path_dir=str(OUT / \"tidy3d_sweep_data\"))\n",
    "\n",
    "    rows = []\n",
    "    for name, sim_data in batch_results.items():\n",
    "        row = dict(metadata[name])\n",
    "        row.update(diffraction_metrics(sim_data, polarization=\"p\"))\n",
    "        rows.append(row)\n",
    "\n",
    "    df = (\n",
    "        pd.DataFrame(rows)\n",
    "        .sort_values(\"edge_score\", ascending=False)\n",
    "        .reset_index(drop=True)\n",
    "    )\n",
    "    df.to_csv(SWEEP_CSV, index=False)\n",
    "    print(f\"Saved sweep results to {SWEEP_CSV}\")\n",
    "\n",
    "print(f\"Result rows: {len(df)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b43aae27",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 400
    },
    "id": "b43aae27",
    "outputId": "71e714fc-9c6f-48d9-d93b-afd59ad8812f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submission table: top FDTD candidates\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_d220c\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_d220c_level0_col0\" class=\"col_heading level0 col0\" >duty</th>\n",
       "      <th id=\"T_d220c_level0_col1\" class=\"col_heading level0 col1\" >ridge_height_um</th>\n",
       "      <th id=\"T_d220c_level0_col2\" class=\"col_heading level0 col2\" >edge_score</th>\n",
       "      <th id=\"T_d220c_level0_col3\" class=\"col_heading level0 col3\" >P_T_m1</th>\n",
       "      <th id=\"T_d220c_level0_col4\" class=\"col_heading level0 col4\" >P_T_0</th>\n",
       "      <th id=\"T_d220c_level0_col5\" class=\"col_heading level0 col5\" >P_T_p1</th>\n",
       "      <th id=\"T_d220c_level0_col6\" class=\"col_heading level0 col6\" >phase_error_to_pi_deg</th>\n",
       "      <th id=\"T_d220c_level0_col7\" class=\"col_heading level0 col7\" >balance_pm1</th>\n",
       "      <th id=\"T_d220c_level0_col8\" class=\"col_heading level0 col8\" >P_total_R_plus_T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "      <td id=\"T_d220c_row0_col0\" class=\"data row0 col0\" >0.400</td>\n",
       "      <td id=\"T_d220c_row0_col1\" class=\"data row0 col1\" >0.310</td>\n",
       "      <td id=\"T_d220c_row0_col2\" class=\"data row0 col2\" >0.0009286</td>\n",
       "      <td id=\"T_d220c_row0_col3\" class=\"data row0 col3\" >0.3776</td>\n",
       "      <td id=\"T_d220c_row0_col4\" class=\"data row0 col4\" >0.0027</td>\n",
       "      <td id=\"T_d220c_row0_col5\" class=\"data row0 col5\" >0.3783</td>\n",
       "      <td id=\"T_d220c_row0_col6\" class=\"data row0 col6\" >140.68</td>\n",
       "      <td id=\"T_d220c_row0_col7\" class=\"data row0 col7\" >0.999</td>\n",
       "      <td id=\"T_d220c_row0_col8\" class=\"data row0 col8\" >0.994</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "      <td id=\"T_d220c_row1_col0\" class=\"data row1 col0\" >0.400</td>\n",
       "      <td id=\"T_d220c_row1_col1\" class=\"data row1 col1\" >0.340</td>\n",
       "      <td id=\"T_d220c_row1_col2\" class=\"data row1 col2\" >0.0001049</td>\n",
       "      <td id=\"T_d220c_row1_col3\" class=\"data row1 col3\" >0.3537</td>\n",
       "      <td id=\"T_d220c_row1_col4\" class=\"data row1 col4\" >0.0293</td>\n",
       "      <td id=\"T_d220c_row1_col5\" class=\"data row1 col5\" >0.3548</td>\n",
       "      <td id=\"T_d220c_row1_col6\" class=\"data row1 col6\" >140.73</td>\n",
       "      <td id=\"T_d220c_row1_col7\" class=\"data row1 col7\" >0.998</td>\n",
       "      <td id=\"T_d220c_row1_col8\" class=\"data row1 col8\" >0.994</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row2\" class=\"row_heading level0 row2\" >2</th>\n",
       "      <td id=\"T_d220c_row2_col0\" class=\"data row2 col0\" >0.600</td>\n",
       "      <td id=\"T_d220c_row2_col1\" class=\"data row2 col1\" >0.310</td>\n",
       "      <td id=\"T_d220c_row2_col2\" class=\"data row2 col2\" >7.395e-05</td>\n",
       "      <td id=\"T_d220c_row2_col3\" class=\"data row2 col3\" >0.3497</td>\n",
       "      <td id=\"T_d220c_row2_col4\" class=\"data row2 col4\" >0.0148</td>\n",
       "      <td id=\"T_d220c_row2_col5\" class=\"data row2 col5\" >0.3503</td>\n",
       "      <td id=\"T_d220c_row2_col6\" class=\"data row2 col6\" >146.28</td>\n",
       "      <td id=\"T_d220c_row2_col7\" class=\"data row2 col7\" >0.999</td>\n",
       "      <td id=\"T_d220c_row2_col8\" class=\"data row2 col8\" >0.993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row3\" class=\"row_heading level0 row3\" >3</th>\n",
       "      <td id=\"T_d220c_row3_col0\" class=\"data row3 col0\" >0.600</td>\n",
       "      <td id=\"T_d220c_row3_col1\" class=\"data row3 col1\" >0.340</td>\n",
       "      <td id=\"T_d220c_row3_col2\" class=\"data row3 col2\" >5.54e-05</td>\n",
       "      <td id=\"T_d220c_row3_col3\" class=\"data row3 col3\" >0.3410</td>\n",
       "      <td id=\"T_d220c_row3_col4\" class=\"data row3 col4\" >0.0197</td>\n",
       "      <td id=\"T_d220c_row3_col5\" class=\"data row3 col5\" >0.3413</td>\n",
       "      <td id=\"T_d220c_row3_col6\" class=\"data row3 col6\" >146.25</td>\n",
       "      <td id=\"T_d220c_row3_col7\" class=\"data row3 col7\" >1.000</td>\n",
       "      <td id=\"T_d220c_row3_col8\" class=\"data row3 col8\" >0.992</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row4\" class=\"row_heading level0 row4\" >4</th>\n",
       "      <td id=\"T_d220c_row4_col0\" class=\"data row4 col0\" >0.600</td>\n",
       "      <td id=\"T_d220c_row4_col1\" class=\"data row4 col1\" >0.280</td>\n",
       "      <td id=\"T_d220c_row4_col2\" class=\"data row4 col2\" >3.717e-05</td>\n",
       "      <td id=\"T_d220c_row4_col3\" class=\"data row4 col3\" >0.3787</td>\n",
       "      <td id=\"T_d220c_row4_col4\" class=\"data row4 col4\" >0.0328</td>\n",
       "      <td id=\"T_d220c_row4_col5\" class=\"data row4 col5\" >0.3795</td>\n",
       "      <td id=\"T_d220c_row4_col6\" class=\"data row4 col6\" >146.32</td>\n",
       "      <td id=\"T_d220c_row4_col7\" class=\"data row4 col7\" >0.999</td>\n",
       "      <td id=\"T_d220c_row4_col8\" class=\"data row4 col8\" >0.993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row5\" class=\"row_heading level0 row5\" >5</th>\n",
       "      <td id=\"T_d220c_row5_col0\" class=\"data row5 col0\" >0.600</td>\n",
       "      <td id=\"T_d220c_row5_col1\" class=\"data row5 col1\" >0.250</td>\n",
       "      <td id=\"T_d220c_row5_col2\" class=\"data row5 col2\" >1.129e-05</td>\n",
       "      <td id=\"T_d220c_row5_col3\" class=\"data row5 col3\" >0.3981</td>\n",
       "      <td id=\"T_d220c_row5_col4\" class=\"data row5 col4\" >0.1152</td>\n",
       "      <td id=\"T_d220c_row5_col5\" class=\"data row5 col5\" >0.3995</td>\n",
       "      <td id=\"T_d220c_row5_col6\" class=\"data row5 col6\" >146.35</td>\n",
       "      <td id=\"T_d220c_row5_col7\" class=\"data row5 col7\" >0.998</td>\n",
       "      <td id=\"T_d220c_row5_col8\" class=\"data row5 col8\" >0.993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row6\" class=\"row_heading level0 row6\" >6</th>\n",
       "      <td id=\"T_d220c_row6_col0\" class=\"data row6 col0\" >0.400</td>\n",
       "      <td id=\"T_d220c_row6_col1\" class=\"data row6 col1\" >0.280</td>\n",
       "      <td id=\"T_d220c_row6_col2\" class=\"data row6 col2\" >9.175e-06</td>\n",
       "      <td id=\"T_d220c_row6_col3\" class=\"data row6 col3\" >0.2508</td>\n",
       "      <td id=\"T_d220c_row6_col4\" class=\"data row6 col4\" >0.2543</td>\n",
       "      <td id=\"T_d220c_row6_col5\" class=\"data row6 col5\" >0.2517</td>\n",
       "      <td id=\"T_d220c_row6_col6\" class=\"data row6 col6\" >140.51</td>\n",
       "      <td id=\"T_d220c_row6_col7\" class=\"data row6 col7\" >0.998</td>\n",
       "      <td id=\"T_d220c_row6_col8\" class=\"data row6 col8\" >0.997</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row7\" class=\"row_heading level0 row7\" >7</th>\n",
       "      <td id=\"T_d220c_row7_col0\" class=\"data row7 col0\" >0.450</td>\n",
       "      <td id=\"T_d220c_row7_col1\" class=\"data row7 col1\" >0.280</td>\n",
       "      <td id=\"T_d220c_row7_col2\" class=\"data row7 col2\" >6.722e-06</td>\n",
       "      <td id=\"T_d220c_row7_col3\" class=\"data row7 col3\" >0.4046</td>\n",
       "      <td id=\"T_d220c_row7_col4\" class=\"data row7 col4\" >0.0171</td>\n",
       "      <td id=\"T_d220c_row7_col5\" class=\"data row7 col5\" >0.4055</td>\n",
       "      <td id=\"T_d220c_row7_col6\" class=\"data row7 col6\" >158.97</td>\n",
       "      <td id=\"T_d220c_row7_col7\" class=\"data row7 col7\" >0.999</td>\n",
       "      <td id=\"T_d220c_row7_col8\" class=\"data row7 col8\" >0.993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row8\" class=\"row_heading level0 row8\" >8</th>\n",
       "      <td id=\"T_d220c_row8_col0\" class=\"data row8 col0\" >0.400</td>\n",
       "      <td id=\"T_d220c_row8_col1\" class=\"data row8 col1\" >0.220</td>\n",
       "      <td id=\"T_d220c_row8_col2\" class=\"data row8 col2\" >6.313e-06</td>\n",
       "      <td id=\"T_d220c_row8_col3\" class=\"data row8 col3\" >0.2112</td>\n",
       "      <td id=\"T_d220c_row8_col4\" class=\"data row8 col4\" >0.2987</td>\n",
       "      <td id=\"T_d220c_row8_col5\" class=\"data row8 col5\" >0.2115</td>\n",
       "      <td id=\"T_d220c_row8_col6\" class=\"data row8 col6\" >140.75</td>\n",
       "      <td id=\"T_d220c_row8_col7\" class=\"data row8 col7\" >0.999</td>\n",
       "      <td id=\"T_d220c_row8_col8\" class=\"data row8 col8\" >0.998</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_d220c_level0_row9\" class=\"row_heading level0 row9\" >9</th>\n",
       "      <td id=\"T_d220c_row9_col0\" class=\"data row9 col0\" >0.450</td>\n",
       "      <td id=\"T_d220c_row9_col1\" class=\"data row9 col1\" >0.310</td>\n",
       "      <td id=\"T_d220c_row9_col2\" class=\"data row9 col2\" >5.068e-06</td>\n",
       "      <td id=\"T_d220c_row9_col3\" class=\"data row9 col3\" >0.3620</td>\n",
       "      <td id=\"T_d220c_row9_col4\" class=\"data row9 col4\" >0.0205</td>\n",
       "      <td id=\"T_d220c_row9_col5\" class=\"data row9 col5\" >0.3634</td>\n",
       "      <td id=\"T_d220c_row9_col6\" class=\"data row9 col6\" >158.97</td>\n",
       "      <td id=\"T_d220c_row9_col7\" class=\"data row9 col7\" >0.998</td>\n",
       "      <td id=\"T_d220c_row9_col8\" class=\"data row9 col8\" >0.993</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7d4a00058a10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved top-10 table to edge_detector_outputs/top10_submission_table.csv\n"
     ]
    }
   ],
   "source": [
    "top10 = show_table(df, n=10, title=\"Submission table: top FDTD candidates\")\n",
    "top10.to_csv(TOP10_CSV, index=False)\n",
    "print(f\"Saved top-10 table to {TOP10_CSV}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "928bf85e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 492
    },
    "id": "928bf85e",
    "outputId": "ea4d6d4d-590b-4b72-e958-e3e44282059f"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best candidate:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>duty</th>\n",
       "      <th>ridge_height_um</th>\n",
       "      <th>P_total_R_plus_T</th>\n",
       "      <th>P_T_m1</th>\n",
       "      <th>P_T_0</th>\n",
       "      <th>P_T_p1</th>\n",
       "      <th>P_T_first_orders</th>\n",
       "      <th>balance_pm1</th>\n",
       "      <th>phase_error_to_pi_rad</th>\n",
       "      <th>phase_error_to_pi_deg</th>\n",
       "      <th>edge_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.4</td>\n",
       "      <td>0.31</td>\n",
       "      <td>0.99383</td>\n",
       "      <td>0.377636</td>\n",
       "      <td>0.00269</td>\n",
       "      <td>0.378256</td>\n",
       "      <td>0.755891</td>\n",
       "      <td>0.99918</td>\n",
       "      <td>2.455331</td>\n",
       "      <td>140.680092</td>\n",
       "      <td>0.000929</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   duty  ridge_height_um  P_total_R_plus_T    P_T_m1    P_T_0    P_T_p1  \\\n",
       "0   0.4             0.31           0.99383  0.377636  0.00269  0.378256   \n",
       "\n",
       "   P_T_first_orders  balance_pm1  phase_error_to_pi_rad  \\\n",
       "0          0.755891      0.99918               2.455331   \n",
       "\n",
       "   phase_error_to_pi_deg  edge_score  \n",
       "0             140.680092    0.000929  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pivot = df.pivot(index=\"ridge_height_um\", columns=\"duty\", values=\"edge_score\")\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(7, 4))\n",
    "im = ax.imshow(\n",
    "    pivot.values,\n",
    "    origin=\"lower\",\n",
    "    aspect=\"auto\",\n",
    "    extent=[duties.min(), duties.max(), ridge_heights.min(), ridge_heights.max()],\n",
    ")\n",
    "ax.set_xlabel(\"Duty cycle\")\n",
    "ax.set_ylabel(\"Ridge height (um)\")\n",
    "ax.set_title(\"FDTD edge-detector score map\")\n",
    "plt.colorbar(im, ax=ax, label=\"edge_score\")\n",
    "plt.show()\n",
    "\n",
    "best = df.sort_values(\"edge_score\", ascending=False).iloc[0]\n",
    "print(\"Best candidate:\")\n",
    "display(best.to_frame().T)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bae7d77",
   "metadata": {
    "id": "2bae7d77"
   },
   "source": [
    "## 6. Best-Candidate Field Plot\n",
    "\n",
    "The best design is rerun with an $x$-$z$ [FieldMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldMonitor.html) so the spatial structure of the diffracted field can be visualized. The result is cached as a PNG and CSV.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ae050fdb",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000,
     "referenced_widgets": [
      "3faf6f68de634abcb8f9503daa256df3",
      "a87cf0acb896408f8b6afce714d1380f",
      "1bb8c67b55984f61a02e90ae62a44549",
      "b2c209402fec4bc8ae8d55276adf5839",
      "2014d9f70a6149158809513fd99feac5",
      "3fa82865ef4e469aaafa24bda4ccf037",
      "a46a8bd5c45f415790e4a8a6bb91b5a1",
      "c9f79d1e1d2b40d58c2c72a7cbc7e240",
      "0d31f059389b4e54be3ef716b62b3b24",
      "603fc3798b4f45498654e17a150f6788"
     ]
    },
    "id": "ae050fdb",
    "outputId": "238b7e64-6e4b-40b7-d302-40c9aa92e2dc"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:45:23 -03 </span>Created task <span style=\"color: #008000; text-decoration-color: #008000\">'FDTD_diffractive_edge_detector_best_field'</span> with      \n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>resource_id <span style=\"color: #008000; text-decoration-color: #008000\">'fdve-308fad43-a539-4f89-b47c-c7a47ea0507f'</span> and        \n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>task_type <span style=\"color: #008000; text-decoration-color: #008000\">'FDTD'</span>.                                                  \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:45:23 -03\u001b[0m\u001b[2;36m \u001b[0mCreated task \u001b[32m'FDTD_diffractive_edge_detector_best_field'\u001b[0m with      \n",
       "\u001b[2;36m             \u001b[0mresource_id \u001b[32m'fdve-308fad43-a539-4f89-b47c-c7a47ea0507f'\u001b[0m and        \n",
       "\u001b[2;36m             \u001b[0mtask_type \u001b[32m'FDTD'\u001b[0m.                                                  \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>View task using web UI at                                          \n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span><a href=\"https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a539-4f89-b47c-c7a47ea0507f\" target=\"_blank\"><span style=\"color: #008000; text-decoration-color: #008000\">'https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a53</span></a>\n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span><a href=\"https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a539-4f89-b47c-c7a47ea0507f\" target=\"_blank\"><span style=\"color: #008000; text-decoration-color: #008000\">9-4f89-b47c-c7a47ea0507f'</span></a>.                                         \n",
       "</pre>\n"
      ],
      "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=34272;https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a539-4f89-b47c-c7a47ea0507f\u001b\\\u001b[32m'https://tidy3d.simulation.cloud/workbench?\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=333896;https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a539-4f89-b47c-c7a47ea0507f\u001b\\\u001b[32mtaskId\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=34272;https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a539-4f89-b47c-c7a47ea0507f\u001b\\\u001b[32m=\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=273503;https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a539-4f89-b47c-c7a47ea0507f\u001b\\\u001b[32mfdve\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=34272;https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a539-4f89-b47c-c7a47ea0507f\u001b\\\u001b[32m-308fad43-a53\u001b[0m\u001b]8;;\u001b\\\n",
       "\u001b[2;36m             \u001b[0m\u001b]8;id=34272;https://tidy3d.simulation.cloud/workbench?taskId=fdve-308fad43-a539-4f89-b47c-c7a47ea0507f\u001b\\\u001b[32m9-4f89-b47c-c7a47ea0507f'\u001b[0m\u001b]8;;\u001b\\.                                         \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>Task folder: <a href=\"https://tidy3d.simulation.cloud/folders/folder-431883bc-afbb-4cc8-a95f-ddfeaeeb059a\" target=\"_blank\"><span style=\"color: #008000; text-decoration-color: #008000\">'default'</span></a>.                                            \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m            \u001b[0m\u001b[2;36m \u001b[0mTask folder: \u001b]8;id=172455;https://tidy3d.simulation.cloud/folders/folder-431883bc-afbb-4cc8-a95f-ddfeaeeb059a\u001b\\\u001b[32m'default'\u001b[0m\u001b]8;;\u001b\\.                                            \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c89cc401a568493f99c632a3dcd36c8a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:45:26 -03 </span>Estimated FlexCredit cost: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0.025</span>. Minimum cost depends on task     \n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>execution details. Use <span style=\"color: #008000; text-decoration-color: #008000\">'web.real_cost(task_id)'</span> to get the billed  \n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>FlexCredit cost after a simulation run.                            \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:45:26 -03\u001b[0m\u001b[2;36m \u001b[0mEstimated FlexCredit cost: \u001b[1;36m0.025\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"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:45:28 -03 </span>status = success                                                   \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:45:28 -03\u001b[0m\u001b[2;36m \u001b[0mstatus = success                                                   \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "02597ca38995473f98a1212c099cc0d0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:45:32 -03 </span>Loading simulation from edge_detector_outputs/best_field_data.hdf5 \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:45:32 -03\u001b[0m\u001b[2;36m \u001b[0mLoading simulation from edge_detector_outputs/best_field_data.hdf5 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best candidate with field monitor\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_32fe7\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_32fe7_level0_col0\" class=\"col_heading level0 col0\" >duty</th>\n",
       "      <th id=\"T_32fe7_level0_col1\" class=\"col_heading level0 col1\" >ridge_height_um</th>\n",
       "      <th id=\"T_32fe7_level0_col2\" class=\"col_heading level0 col2\" >edge_score</th>\n",
       "      <th id=\"T_32fe7_level0_col3\" class=\"col_heading level0 col3\" >P_T_m1</th>\n",
       "      <th id=\"T_32fe7_level0_col4\" class=\"col_heading level0 col4\" >P_T_0</th>\n",
       "      <th id=\"T_32fe7_level0_col5\" class=\"col_heading level0 col5\" >P_T_p1</th>\n",
       "      <th id=\"T_32fe7_level0_col6\" class=\"col_heading level0 col6\" >phase_error_to_pi_deg</th>\n",
       "      <th id=\"T_32fe7_level0_col7\" class=\"col_heading level0 col7\" >balance_pm1</th>\n",
       "      <th id=\"T_32fe7_level0_col8\" class=\"col_heading level0 col8\" >P_total_R_plus_T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_32fe7_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "      <td id=\"T_32fe7_row0_col0\" class=\"data row0 col0\" >0.400</td>\n",
       "      <td id=\"T_32fe7_row0_col1\" class=\"data row0 col1\" >0.310</td>\n",
       "      <td id=\"T_32fe7_row0_col2\" class=\"data row0 col2\" >0.0009286</td>\n",
       "      <td id=\"T_32fe7_row0_col3\" class=\"data row0 col3\" >0.3776</td>\n",
       "      <td id=\"T_32fe7_row0_col4\" class=\"data row0 col4\" >0.0027</td>\n",
       "      <td id=\"T_32fe7_row0_col5\" class=\"data row0 col5\" >0.3783</td>\n",
       "      <td id=\"T_32fe7_row0_col6\" class=\"data row0 col6\" >140.68</td>\n",
       "      <td id=\"T_32fe7_row0_col7\" class=\"data row0 col7\" >0.999</td>\n",
       "      <td id=\"T_32fe7_row0_col8\" class=\"data row0 col8\" >0.994</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7d4a00147210>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved best metrics to edge_detector_outputs/best_candidate_metrics.csv\n",
      "Saved field plot to edge_detector_outputs/best_candidate_Ex_field.png\n"
     ]
    }
   ],
   "source": [
    "if BEST_METRICS_CSV.exists() and BEST_FIELD_PNG.exists():\n",
    "    best_metrics = pd.read_csv(BEST_METRICS_CSV)\n",
    "    print(f\"Loaded cached best-candidate metrics from {BEST_METRICS_CSV}\")\n",
    "    show_table(best_metrics, n=1, title=\"Best candidate with field monitor\")\n",
    "    display(Image(filename=str(BEST_FIELD_PNG)))\n",
    "else:\n",
    "    best = df.sort_values(\"edge_score\", ascending=False).iloc[0]\n",
    "\n",
    "    sim_best = make_simulation(\n",
    "        duty=float(best[\"duty\"]),\n",
    "        ridge_height=float(best[\"ridge_height_um\"]),\n",
    "        add_field_monitor=True,\n",
    "    )\n",
    "\n",
    "    sim_best_data = web.run(\n",
    "        sim_best,\n",
    "        task_name=\"FDTD_diffractive_edge_detector_best_field\",\n",
    "        path=str(OUT / \"best_field_data.hdf5\"),\n",
    "        verbose=True,\n",
    "    )\n",
    "\n",
    "    best_metrics = pd.DataFrame(\n",
    "        [\n",
    "            {\n",
    "                \"duty\": float(best[\"duty\"]),\n",
    "                \"ridge_height_um\": float(best[\"ridge_height_um\"]),\n",
    "                **diffraction_metrics(sim_best_data, polarization=\"p\"),\n",
    "            }\n",
    "        ]\n",
    "    )\n",
    "    best_metrics.to_csv(BEST_METRICS_CSV, index=False)\n",
    "\n",
    "    show_table(best_metrics, n=1, title=\"Best candidate with field monitor\")\n",
    "\n",
    "    fig, ax = plt.subplots(1, 1, figsize=(8, 5))\n",
    "    sim_best_data.plot_field(\"field_xz\", field_name=\"Ex\", val=\"real\", f=freq0, ax=ax)\n",
    "    ax.set_title(\"Real Ex field of the best diffractive edge-detector candidate\")\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(BEST_FIELD_PNG, dpi=200, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "\n",
    "    print(f\"Saved best metrics to {BEST_METRICS_CSV}\")\n",
    "    print(f\"Saved field plot to {BEST_FIELD_PNG}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df90c1d7",
   "metadata": {
    "id": "df90c1d7"
   },
   "source": [
    "## 7. Compact Convergence Check\n",
    "\n",
    "The best geometry is rerun at `min_steps_per_wvl = 30, 40, 50` to confirm that the key diffraction metrics are stable under grid refinement.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b8b67ead",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 330,
     "referenced_widgets": [
      "9e7abd531af64c1d832c645a28b3861d",
      "5a329585270743d09abc99d2ecf9f329",
      "a8cafb11f5934e5ea26d954203f68e3c",
      "a1c8fff7dad440bd8067ae7c473b40aa"
     ]
    },
    "id": "b8b67ead",
    "outputId": "793fd886-52a2-4805-a1fc-e2eec6081f79"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c0d964be6ad346cd8ef016f75b215189",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting 3 convergence simulations...\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:45:36 -03 </span>Started working on Batch containing <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">3</span> tasks.                       \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:45:36 -03\u001b[0m\u001b[2;36m \u001b[0mStarted working on Batch containing \u001b[1;36m3\u001b[0m tasks.                       \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:45:41 -03 </span>Maximum FlexCredit cost: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0.075</span> for the whole batch.                \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:45:41 -03\u001b[0m\u001b[2;36m \u001b[0mMaximum FlexCredit cost: \u001b[1;36m0.075\u001b[0m for the whole batch.                \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>Use <span style=\"color: #008000; text-decoration-color: #008000\">'Batch.real_cost()'</span> to get the billed FlexCredit cost after    \n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">             </span>completion.                                                        \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m            \u001b[0m\u001b[2;36m \u001b[0mUse \u001b[32m'Batch.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed FlexCredit cost after    \n",
       "\u001b[2;36m             \u001b[0mcompletion.                                                        \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ad95b1466f2340b296d520b5fd905702",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">14:45:49 -03 </span>Batch complete.                                                    \n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m14:45:49 -03\u001b[0m\u001b[2;36m \u001b[0mBatch complete.                                                    \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved convergence check to edge_detector_outputs/convergence_check.csv\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_cbff9\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_cbff9_level0_col0\" class=\"col_heading level0 col0\" >min_steps_per_wvl</th>\n",
       "      <th id=\"T_cbff9_level0_col1\" class=\"col_heading level0 col1\" >edge_score</th>\n",
       "      <th id=\"T_cbff9_level0_col2\" class=\"col_heading level0 col2\" >P_T_m1</th>\n",
       "      <th id=\"T_cbff9_level0_col3\" class=\"col_heading level0 col3\" >P_T_0</th>\n",
       "      <th id=\"T_cbff9_level0_col4\" class=\"col_heading level0 col4\" >P_T_p1</th>\n",
       "      <th id=\"T_cbff9_level0_col5\" class=\"col_heading level0 col5\" >phase_error_to_pi_deg</th>\n",
       "      <th id=\"T_cbff9_level0_col6\" class=\"col_heading level0 col6\" >edge_score_rel_change_vs_50_pct</th>\n",
       "      <th id=\"T_cbff9_level0_col7\" class=\"col_heading level0 col7\" >P_T_0_rel_change_vs_50_pct</th>\n",
       "      <th id=\"T_cbff9_level0_col8\" class=\"col_heading level0 col8\" >phase_error_to_pi_deg_rel_change_vs_50_pct</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_cbff9_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "      <td id=\"T_cbff9_row0_col0\" class=\"data row0 col0\" >30</td>\n",
       "      <td id=\"T_cbff9_row0_col1\" class=\"data row0 col1\" >0.0009675</td>\n",
       "      <td id=\"T_cbff9_row0_col2\" class=\"data row0 col2\" >0.3769</td>\n",
       "      <td id=\"T_cbff9_row0_col3\" class=\"data row0 col3\" >0.0028</td>\n",
       "      <td id=\"T_cbff9_row0_col4\" class=\"data row0 col4\" >0.3772</td>\n",
       "      <td id=\"T_cbff9_row0_col5\" class=\"data row0 col5\" >140.20</td>\n",
       "      <td id=\"T_cbff9_row0_col6\" class=\"data row0 col6\" >+16.67%</td>\n",
       "      <td id=\"T_cbff9_row0_col7\" class=\"data row0 col7\" >+11.48%</td>\n",
       "      <td id=\"T_cbff9_row0_col8\" class=\"data row0 col8\" >-0.96%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_cbff9_level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "      <td id=\"T_cbff9_row1_col0\" class=\"data row1 col0\" >40</td>\n",
       "      <td id=\"T_cbff9_row1_col1\" class=\"data row1 col1\" >0.0008864</td>\n",
       "      <td id=\"T_cbff9_row1_col2\" class=\"data row1 col2\" >0.3782</td>\n",
       "      <td id=\"T_cbff9_row1_col3\" class=\"data row1 col3\" >0.0027</td>\n",
       "      <td id=\"T_cbff9_row1_col4\" class=\"data row1 col4\" >0.3788</td>\n",
       "      <td id=\"T_cbff9_row1_col5\" class=\"data row1 col5\" >141.01</td>\n",
       "      <td id=\"T_cbff9_row1_col6\" class=\"data row1 col6\" >+6.89%</td>\n",
       "      <td id=\"T_cbff9_row1_col7\" class=\"data row1 col7\" >+3.95%</td>\n",
       "      <td id=\"T_cbff9_row1_col8\" class=\"data row1 col8\" >-0.39%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_cbff9_level0_row2\" class=\"row_heading level0 row2\" >2</th>\n",
       "      <td id=\"T_cbff9_row2_col0\" class=\"data row2 col0\" >50</td>\n",
       "      <td id=\"T_cbff9_row2_col1\" class=\"data row2 col1\" >0.0008293</td>\n",
       "      <td id=\"T_cbff9_row2_col2\" class=\"data row2 col2\" >0.3790</td>\n",
       "      <td id=\"T_cbff9_row2_col3\" class=\"data row2 col3\" >0.0026</td>\n",
       "      <td id=\"T_cbff9_row2_col4\" class=\"data row2 col4\" >0.3797</td>\n",
       "      <td id=\"T_cbff9_row2_col5\" class=\"data row2 col5\" >141.56</td>\n",
       "      <td id=\"T_cbff9_row2_col6\" class=\"data row2 col6\" >+0.00%</td>\n",
       "      <td id=\"T_cbff9_row2_col7\" class=\"data row2 col7\" >+0.00%</td>\n",
       "      <td id=\"T_cbff9_row2_col8\" class=\"data row2 col8\" >+0.00%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7d49f6d88890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "convergence_steps = [30, 40, 50]\n",
    "\n",
    "if CONVERGENCE_CSV.exists():\n",
    "    conv_df = pd.read_csv(CONVERGENCE_CSV)\n",
    "    print(f\"Loaded cached convergence check from {CONVERGENCE_CSV}\")\n",
    "else:\n",
    "    best = df.sort_values(\"edge_score\", ascending=False).iloc[0]\n",
    "    duty_best = float(best[\"duty\"])\n",
    "    height_best = float(best[\"ridge_height_um\"])\n",
    "\n",
    "    conv_sims = {}\n",
    "    conv_metadata = {}\n",
    "\n",
    "    for steps in convergence_steps:\n",
    "        name = f\"best_min_steps_per_wvl={steps}\"\n",
    "        conv_sims[name] = make_simulation(\n",
    "            duty=duty_best,\n",
    "            ridge_height=height_best,\n",
    "            min_steps_per_wvl=steps,\n",
    "        )\n",
    "        conv_metadata[name] = {\n",
    "            \"min_steps_per_wvl\": steps,\n",
    "            \"duty\": duty_best,\n",
    "            \"ridge_height_um\": height_best,\n",
    "        }\n",
    "\n",
    "    print(f\"Submitting {len(conv_sims)} convergence simulations...\")\n",
    "    conv_batch = web.Batch(simulations=conv_sims, verbose=True)\n",
    "    conv_results = conv_batch.run(path_dir=str(OUT / \"tidy3d_convergence_data\"))\n",
    "\n",
    "    rows = []\n",
    "    for name, sim_data in conv_results.items():\n",
    "        row = dict(conv_metadata[name])\n",
    "        row.update(diffraction_metrics(sim_data, polarization=\"p\"))\n",
    "        rows.append(row)\n",
    "\n",
    "    conv_df = pd.DataFrame(rows).sort_values(\"min_steps_per_wvl\").reset_index(drop=True)\n",
    "\n",
    "    ref = conv_df.iloc[-1]\n",
    "    for col in [\"edge_score\", \"P_T_m1\", \"P_T_0\", \"P_T_p1\", \"phase_error_to_pi_deg\"]:\n",
    "        conv_df[f\"{col}_rel_change_vs_50_pct\"] = (\n",
    "            100 * (conv_df[col] - ref[col]) / (abs(ref[col]) + 1e-12)\n",
    "        )\n",
    "\n",
    "    conv_df.to_csv(CONVERGENCE_CSV, index=False)\n",
    "    print(f\"Saved convergence check to {CONVERGENCE_CSV}\")\n",
    "\n",
    "cols = [\n",
    "    \"min_steps_per_wvl\",\n",
    "    \"edge_score\",\n",
    "    \"P_T_m1\",\n",
    "    \"P_T_0\",\n",
    "    \"P_T_p1\",\n",
    "    \"phase_error_to_pi_deg\",\n",
    "    \"edge_score_rel_change_vs_50_pct\",\n",
    "    \"P_T_0_rel_change_vs_50_pct\",\n",
    "    \"phase_error_to_pi_deg_rel_change_vs_50_pct\",\n",
    "]\n",
    "\n",
    "display(\n",
    "    conv_df[cols].style.format(\n",
    "        {\n",
    "            \"edge_score\": \"{:.4g}\",\n",
    "            \"P_T_m1\": \"{:.4f}\",\n",
    "            \"P_T_0\": \"{:.4f}\",\n",
    "            \"P_T_p1\": \"{:.4f}\",\n",
    "            \"phase_error_to_pi_deg\": \"{:.2f}\",\n",
    "            \"edge_score_rel_change_vs_50_pct\": \"{:+.2f}%\",\n",
    "            \"P_T_0_rel_change_vs_50_pct\": \"{:+.2f}%\",\n",
    "            \"phase_error_to_pi_deg_rel_change_vs_50_pct\": \"{:+.2f}%\",\n",
    "        }\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "038d7c2f",
   "metadata": {
    "id": "038d7c2f"
   },
   "source": [
    "## 8. Conclusion\n",
    "\n",
    "The notebook demonstrates that a single-layer silicon phase-step grating on silica can implement a compact 1D optical edge detector at 1.55 \u00b5m. The FDTD sweep identifies a duty cycle and ridge height that maximize the balanced $\\pm 1$ transmitted orders while suppressing the zero order, and the convergence check shows the result is robust to grid refinement.\n",
    "\n",
    "For further reading, see the [DiffractionMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.DiffractionMonitor.html) API and the related [Multilevel blazed diffraction grating](https://www.flexcompute.com/tidy3d/examples/notebooks/GratingEfficiency/) example.\n"
   ]
  }
 ],
 "metadata": {
  "applications": [
   "Metamaterials, gratings, and other periodic structures"
  ],
  "colab": {
   "provenance": []
  },
  "description": "This notebook demonstrates how to design a 1D diffractive phase-step grating that acts as an optical edge detector using Tidy3D.",
  "feature_image": "./img/DiffractiveOpticalEdgeDetector.png",
  "features": [
   "Diffraction analysis"
  ],
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "keywords": "edge detection, diffractive grating, optical neural network, 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.7"
  },
  "title": "How to design a 1D diffractive optical edge detector using Tidy3D | Flexcompute"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}