workshop_part_1.ipynb

{"cells":[{"cell_type":"markdown","source":["<font color=\"#de3023\"><h1><b>REMINDER: MAKE A COPY OF THIS NOTEBOOK</b></h1></font>"],"metadata":{"id":"L_N_nw3Jitsb"},"id":"L_N_nw3Jitsb"},{"cell_type":"markdown","source":["For Google Colab users"],"metadata":{"id":"jeSm5G8ukJR7"},"id":"jeSm5G8ukJR7"},{"cell_type":"code","source":["!pip install gdsfactory==7.3.2\n","!pip install klayout"],"metadata":{"id":"o09UQOsnYpQO","colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"status":"ok","timestamp":1692924563677,"user_tz":420,"elapsed":32041,"user":{"displayName":"Nate Palmquist","userId":"09827099203523851911"}},"outputId":"116839fa-0600-4d0b-80bc-231ee7c6b69c"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["Collecting gdsfactory==7.3.2\n","  Downloading gdsfactory-7.3.2-py3-none-any.whl (799 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m799.1/799.1 kB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hCollecting flatdict (from gdsfactory==7.3.2)\n","  Downloading flatdict-4.0.1.tar.gz (8.3 kB)\n","  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Collecting gdstk<1 (from gdsfactory==7.3.2)\n","  Downloading gdstk-0.9.42-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.2 MB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m22.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hRequirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (3.1.2)\n","Collecting loguru<1 (from gdsfactory==7.3.2)\n","  Downloading loguru-0.7.0-py3-none-any.whl (59 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.0/60.0 kB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hRequirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (3.7.1)\n","Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (1.23.5)\n","Collecting omegaconf<3 (from gdsfactory==7.3.2)\n","  Downloading omegaconf-2.3.0-py3-none-any.whl (79 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.5/79.5 kB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hCollecting orjson (from gdsfactory==7.3.2)\n","  Downloading orjson-3.9.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (139 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m139.9/139.9 kB\u001b[0m \u001b[31m14.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hRequirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (1.5.3)\n","Collecting pydantic<2 (from gdsfactory==7.3.2)\n","  Downloading pydantic-1.10.12-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m39.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hRequirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (6.0.1)\n","Collecting qrcode (from gdsfactory==7.3.2)\n","  Downloading qrcode-7.4.2-py3-none-any.whl (46 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.2/46.2 kB\u001b[0m \u001b[31m4.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hCollecting rectpack (from gdsfactory==7.3.2)\n","  Downloading rectpack-0.2.2.tar.gz (17 kB)\n","  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: rich in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (13.5.2)\n","Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (1.10.1)\n","Requirement already satisfied: shapely<3 in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (2.0.1)\n","Requirement already satisfied: toolz in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (0.12.0)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (4.66.1)\n","Collecting types-PyYAML (from gdsfactory==7.3.2)\n","  Downloading types_PyYAML-6.0.12.11-py3-none-any.whl (14 kB)\n","Requirement already satisfied: typer in /usr/local/lib/python3.10/dist-packages (from gdsfactory==7.3.2) (0.9.0)\n","Collecting watchdog (from gdsfactory==7.3.2)\n","  Downloading watchdog-3.0.0-py3-none-manylinux2014_x86_64.whl (82 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m82.1/82.1 kB\u001b[0m \u001b[31m8.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hCollecting antlr4-python3-runtime==4.9.* (from omegaconf<3->gdsfactory==7.3.2)\n","  Downloading antlr4-python3-runtime-4.9.3.tar.gz (117 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m117.0/117.0 kB\u001b[0m \u001b[31m10.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: typing-extensions>=4.2.0 in /usr/local/lib/python3.10/dist-packages (from pydantic<2->gdsfactory==7.3.2) (4.7.1)\n","Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->gdsfactory==7.3.2) (2.1.3)\n","Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->gdsfactory==7.3.2) (1.1.0)\n","Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->gdsfactory==7.3.2) (0.11.0)\n","Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->gdsfactory==7.3.2) (4.42.0)\n","Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->gdsfactory==7.3.2) (1.4.4)\n","Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->gdsfactory==7.3.2) (23.1)\n","Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->gdsfactory==7.3.2) (9.4.0)\n","Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->gdsfactory==7.3.2) (3.1.1)\n","Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->gdsfactory==7.3.2) (2.8.2)\n","Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->gdsfactory==7.3.2) (2023.3)\n","Collecting pypng (from qrcode->gdsfactory==7.3.2)\n","  Downloading pypng-0.20220715.0-py3-none-any.whl (58 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.1/58.1 kB\u001b[0m \u001b[31m5.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hRequirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/dist-packages (from rich->gdsfactory==7.3.2) (3.0.0)\n","Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from rich->gdsfactory==7.3.2) (2.16.1)\n","Requirement already satisfied: click<9.0.0,>=7.1.1 in /usr/local/lib/python3.10/dist-packages (from typer->gdsfactory==7.3.2) (8.1.7)\n","Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/dist-packages (from markdown-it-py>=2.2.0->rich->gdsfactory==7.3.2) (0.1.2)\n","Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->gdsfactory==7.3.2) (1.16.0)\n","Building wheels for collected packages: antlr4-python3-runtime, flatdict, rectpack\n","  Building wheel for antlr4-python3-runtime (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for antlr4-python3-runtime: filename=antlr4_python3_runtime-4.9.3-py3-none-any.whl size=144555 sha256=5254e809ba5ad2af685f9ffd8a00a38ea5bb21bd95c427edea06288af660db82\n","  Stored in directory: /root/.cache/pip/wheels/12/93/dd/1f6a127edc45659556564c5730f6d4e300888f4bca2d4c5a88\n","  Building wheel for flatdict (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for flatdict: filename=flatdict-4.0.1-py3-none-any.whl size=6929 sha256=1d782779ad47165f103e9dd5951b7d46ce4e931f6dfefdce656302eb54e40ab3\n","  Stored in directory: /root/.cache/pip/wheels/71/12/62/88c5bf37619c2d7481eedb8abd0dde6674e88dce45a7805a6f\n","  Building wheel for rectpack (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for rectpack: filename=rectpack-0.2.2-py3-none-any.whl size=19333 sha256=6fe4f21092f480d53c74812767dd7f79c4fff266acb0b81880e66a06a61cc6bc\n","  Stored in directory: /root/.cache/pip/wheels/e9/ea/e9/cd0237c0ccb9cb7312bb94cc023689592c4f07e4f3b1b9dd00\n","Successfully built antlr4-python3-runtime flatdict rectpack\n","Installing collected packages: types-PyYAML, rectpack, pypng, flatdict, antlr4-python3-runtime, watchdog, qrcode, pydantic, orjson, omegaconf, loguru, gdstk, gdsfactory\n","  Attempting uninstall: pydantic\n","    Found existing installation: pydantic 2.2.0\n","    Uninstalling pydantic-2.2.0:\n","      Successfully uninstalled pydantic-2.2.0\n","Successfully installed antlr4-python3-runtime-4.9.3 flatdict-4.0.1 gdsfactory-7.3.2 gdstk-0.9.42 loguru-0.7.0 omegaconf-2.3.0 orjson-3.9.5 pydantic-1.10.12 pypng-0.20220715.0 qrcode-7.4.2 rectpack-0.2.2 types-PyYAML-6.0.12.11 watchdog-3.0.0\n"]},{"output_type":"display_data","data":{"application/vnd.colab-display-data+json":{"pip_warning":{"packages":["pydevd_plugins"]}}},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Collecting klayout\n","  Downloading klayout-0.28.11-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (22.5 MB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m22.5/22.5 MB\u001b[0m \u001b[31m2.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hInstalling collected packages: klayout\n","Successfully installed klayout-0.28.11\n"]}],"id":"o09UQOsnYpQO"},{"cell_type":"code","source":["import gdsfactory as gf\n","gf.CONF.display_type = 'klayout' # for plotting in Colab notebook"],"metadata":{"id":"k-iw2RqvkEAn","executionInfo":{"status":"ok","timestamp":1692924565985,"user_tz":420,"elapsed":2313,"user":{"displayName":"Nate Palmquist","userId":"09827099203523851911"}}},"id":"k-iw2RqvkEAn","execution_count":3,"outputs":[]},{"cell_type":"markdown","source":["# **`gdsfactory` workshop part 1**"],"metadata":{"id":"ZQq5C7iojnpl"},"id":"ZQq5C7iojnpl"},{"cell_type":"markdown","metadata":{"id":"6c4c0e4c"},"source":["# Component\n","\n","A `Component` is like an empty canvas, where you can add polygons, references to other Components and ports (to connect to other components)\n","\n","![](https://i.imgur.com/oeuKGsc.png)\n","\n","In gdsfactory **all dimensions** are in **microns**"],"id":"6c4c0e4c"},{"cell_type":"code","execution_count":4,"metadata":{"id":"34975127","colab":{"base_uri":"https://localhost:8080/","height":722},"executionInfo":{"status":"ok","timestamp":1692924567564,"user_tz":420,"elapsed":1590,"user":{"displayName":"Nate Palmquist","userId":"09827099203523851911"}},"outputId":"9d185a08-4ba9-4545-c317-73fe536ce2fd"},"outputs":[{"output_type":"stream","name":"stderr","text":["\u001b[32m2023-08-25 00:49:25.613\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mgdsfactory.pdk\u001b[0m:\u001b[36mget_active_pdk\u001b[0m:\u001b[36m697\u001b[0m - \u001b[33m\u001b[1mNo active PDK. Activating generic PDK.\n","\u001b[0m\n","\u001b[32m2023-08-25 00:49:26.300\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mgdsfactory.technology.layer_views\u001b[0m:\u001b[36m__init__\u001b[0m:\u001b[36m810\u001b[0m - \u001b[1mImporting LayerViews from YAML file: '/usr/local/lib/python3.10/dist-packages/gdsfactory/generic_tech/layer_views.yaml'.\u001b[0m\n","\u001b[32m2023-08-25 00:49:26.319\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mgdsfactory.pdk\u001b[0m:\u001b[36mactivate\u001b[0m:\u001b[36m317\u001b[0m - \u001b[1m'generic' PDK is now active\u001b[0m\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 800x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["import gdsfactory as gf\n","\n","E = gf.components.ellipse(radii=(10, 5), layer=(1, 0))\n","R = gf.components.rectangle(size=[15, 5], layer=(2, 0))\n","C = gf.geometry.boolean(A=E, B=R, operation=\"not\", precision=1e-6, layer=(3, 0))\n","# Other operations include 'and', 'or', 'xor', or equivalently 'A-B', 'B-A', 'A+B'\n","\n","# Plot the originals and the result\n","D = gf.Component(\"bool\")\n","D.add_ref(E)\n","D.add_ref(R).movey(-1.5)\n","D.add_ref(C).movex(30)\n","D.plot()"],"id":"34975127"},{"cell_type":"markdown","metadata":{"id":"ea481eac"},"source":["## Polygons\n","\n","You can add polygons to different layers."],"id":"ea481eac"},{"cell_type":"code","execution_count":5,"metadata":{"id":"c58f78fe","colab":{"base_uri":"https://localhost:8080/","height":688},"executionInfo":{"status":"ok","timestamp":1692924761614,"user_tz":420,"elapsed":920,"user":{"displayName":"Nate Palmquist","userId":"09827099203523851911"}},"outputId":"f1816413-3e15-478b-9431-42fbcf1212f7"},"outputs":[{"output_type":"stream","name":"stderr","text":["\u001b[32m2023-08-25 00:52:40.684\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mgdsfactory.technology.layer_views\u001b[0m:\u001b[36m__init__\u001b[0m:\u001b[36m810\u001b[0m - \u001b[1mImporting LayerViews from YAML file: '/usr/local/lib/python3.10/dist-packages/gdsfactory/generic_tech/layer_views.yaml'.\u001b[0m\n","\u001b[32m2023-08-25 00:52:40.698\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mgdsfactory.pdk\u001b[0m:\u001b[36mactivate\u001b[0m:\u001b[36m317\u001b[0m - \u001b[1m'generic' PDK is now active\u001b[0m\n"]},{"output_type":"display_data","data":{"text/plain":[],"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"]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 80\u001b[0m\u001b[1;36m0x600\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"],"image/png":"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\n"},"metadata":{}}],"source":["import gdsfactory as gf\n","from gdsfactory.generic_tech import get_generic_pdk\n","\n","gf.config.rich_output()\n","\n","PDK = get_generic_pdk()\n","PDK.activate()\n","\n","\n","@gf.cell\n","def demo_polygons():\n","    # Create a blank component (essentially an empty GDS cell with some special features)\n","    c = gf.Component()\n","\n","    # Create and add a polygon from separate lists of x points and y points\n","    # (Can also be added like [(x1,y1), (x2,y2), (x3,y3), ... ]\n","    poly1 = c.add_polygon(\n","        [(-8, 6, 7, 9), (-6, 8, 17, 5)], layer=1\n","    )  # GDS layers are tuples of ints (but if we use only one number it assumes the other number is 0)\n","    return c\n","\n","\n","c = demo_polygons()\n","c.plot()  # show it in KLayout"],"id":"c58f78fe"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"b7f80e84"},"outputs":[],"source":["c = gf.Component(\"enclosure1\")\n","r = c << gf.components.ring_single()\n","c.plot()"],"id":"b7f80e84"},{"cell_type":"markdown","metadata":{"lines_to_next_cell":2,"id":"dc692338"},"source":["## Connect **ports**\n","\n","Components can have a \"Port\" that allows you to connect ComponentReferences together like legos.\n","\n","You can write a simple function to make a rectangular straight, assign ports to the ends, and then connect those rectangles together.\n","\n","Notice that `connect` transform each reference but things won't remain connected if you move any of the references afterwards.\n"],"id":"dc692338"},{"cell_type":"code","execution_count":6,"metadata":{"id":"e3f6a43e","colab":{"base_uri":"https://localhost:8080/","height":633},"executionInfo":{"status":"ok","timestamp":1692924932686,"user_tz":420,"elapsed":574,"user":{"displayName":"Nate Palmquist","userId":"09827099203523851911"}},"outputId":"e2c636ae-566b-4635-81f5-b6bd4c01f3df"},"outputs":[{"output_type":"display_data","data":{"text/plain":[],"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"]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 80\u001b[0m\u001b[1;36m0x600\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"],"image/png":"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\n"},"metadata":{}}],"source":["@gf.cell\n","def straight(length=10, width=1, layer=(1, 0)):\n","    WG = gf.Component()\n","    WG.add_polygon([(0, 0), (length, 0), (length, width), (0, width)], layer=layer)\n","    WG.add_port(\n","        name=\"o1\", center=[0, width / 2], width=width, orientation=180, layer=layer\n","    )\n","    WG.add_port(\n","        name=\"o2\", center=[length, width / 2], width=width, orientation=0, layer=layer\n","    )\n","    return WG\n","\n","\n","c = gf.Component(\"straights_not_connected\")\n","\n","wg1 = c << straight(length=6, width=2.5, layer=1)\n","wg2 = c << straight(length=11, width=2.5, layer=2)\n","wg3 = c << straight(length=15, width=2.5, layer=3)\n","wg2.movey(10).rotate(10)\n","wg3.movey(20).rotate(15)\n","\n","c.plot()"],"id":"e3f6a43e"},{"cell_type":"markdown","metadata":{"id":"86a940b7"},"source":["Now we can connect everything together using the ports:\n","\n","Each straight has two ports: 'o1' and 'o2', respectively on the East and West sides of the rectangular straight component. These are arbitrary\n","names defined in our straight() function above"],"id":"86a940b7"},{"cell_type":"code","execution_count":7,"metadata":{"id":"1ac597c3","colab":{"base_uri":"https://localhost:8080/","height":633},"executionInfo":{"status":"ok","timestamp":1692925146226,"user_tz":420,"elapsed":839,"user":{"displayName":"Nate Palmquist","userId":"09827099203523851911"}},"outputId":"046ac7d7-49e4-451c-9d04-68858f47bdd3"},"outputs":[{"output_type":"display_data","data":{"text/plain":[],"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"]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 80\u001b[0m\u001b[1;36m0x600\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"],"image/png":"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\n"},"metadata":{}}],"source":["# Let's keep wg1 in place on the bottom, and connect the other straights to it.\n","# To do that, on wg2 we'll grab the \"o1\" port and connect it to the \"o2\" on wg1:\n","wg2.connect(\"o1\", wg1.ports[\"o2\"])\n","# Next, on wg3 let's grab the \"o1\" port and connect it to the \"o2\" on wg2:\n","wg3.connect(\"o1\", wg2.ports[\"o2\"])\n","\n","c.plot()"],"id":"1ac597c3"},{"cell_type":"markdown","metadata":{"id":"8ceab3a7"},"source":["Ports can be added by copying existing ports. In the example below, ports are added at the component-level on c from the existing ports of children wg1 and wg3\n","(i.e. eastmost and westmost ports)"],"id":"8ceab3a7"},{"cell_type":"code","execution_count":8,"metadata":{"id":"80da9d4f","colab":{"base_uri":"https://localhost:8080/","height":633},"executionInfo":{"status":"ok","timestamp":1692925211464,"user_tz":420,"elapsed":562,"user":{"displayName":"Nate Palmquist","userId":"09827099203523851911"}},"outputId":"40ca9cee-eaaa-49a4-ad29-1d0848a0bdac"},"outputs":[{"output_type":"display_data","data":{"text/plain":[],"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"]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 80\u001b[0m\u001b[1;36m0x600\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"],"image/png":"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\n"},"metadata":{}}],"source":["c.add_port(\"o1\", port=wg1.ports[\"o1\"])\n","c.add_port(\"o2\", port=wg3.ports[\"o2\"])\n","c.plot()"],"id":"80da9d4f"},{"cell_type":"markdown","metadata":{"id":"aae942de"},"source":["## Write\n","\n","You can write your Component to:\n","\n","- GDS file (Graphical Database System) or OASIS for chips.\n","- gerber for PCB.\n","- STL for 3d printing."],"id":"aae942de"},{"cell_type":"code","execution_count":9,"metadata":{"id":"bfb2ef8e","colab":{"base_uri":"https://localhost:8080/","height":650},"executionInfo":{"status":"ok","timestamp":1692925242786,"user_tz":420,"elapsed":798,"user":{"displayName":"Nate Palmquist","userId":"09827099203523851911"}},"outputId":"f7238564-dc6c-4f07-826e-75a9b2702d03"},"outputs":[{"output_type":"stream","name":"stderr","text":["\u001b[32m2023-08-25 01:00:41.815\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mgdsfactory.component\u001b[0m:\u001b[36m_write_library\u001b[0m:\u001b[36m1909\u001b[0m - \u001b[1mWrote to 'demo.gds'\u001b[0m\n"]},{"output_type":"display_data","data":{"text/plain":[],"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"]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 80\u001b[0m\u001b[1;36m0x600\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"],"image/png":"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\n"},"metadata":{}}],"source":["import gdsfactory as gf\n","\n","c = gf.components.cross()\n","c.write_gds(\"demo.gds\")\n","c.plot()"],"id":"bfb2ef8e"},{"cell_type":"markdown","metadata":{"id":"eebb788e"},"source":["You can see the GDS file in Klayout viewer.\n","\n","Sometimes you also want to save the GDS together with metadata (settings, port names, widths, locations ...) in YAML"],"id":"eebb788e"},{"cell_type":"code","execution_count":null,"metadata":{"id":"885df462"},"outputs":[],"source":["c.write_gds(\"demo.gds\", with_metadata=True)"],"id":"885df462"},{"cell_type":"code","execution_count":null,"metadata":{"id":"ece04c5f"},"outputs":[],"source":["c.write_oas(\"demo.oas\")"],"id":"ece04c5f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"666a3a49"},"outputs":[],"source":["c.write_stl(\"demo.stl\")"],"id":"666a3a49"},{"cell_type":"code","execution_count":null,"metadata":{"id":"6b10a8eb"},"outputs":[],"source":["scene = c.to_3d()\n","scene.show()"],"id":"6b10a8eb"},{"cell_type":"markdown","metadata":{"id":"31a27ff6"},"source":["## Importing GDS files"],"id":"31a27ff6"},{"cell_type":"markdown","metadata":{"id":"0f26e0a1"},"source":["`gf.import_gds()` allows you to easily import external GDSII files.  It imports a single cell from the external GDS file and converts it into a gdsfactory component."],"id":"0f26e0a1"},{"cell_type":"code","execution_count":null,"metadata":{"id":"e2137531"},"outputs":[],"source":["D = gf.components.ellipse()\n","D.write_gds(\"myoutput.gds\")\n","D2 = gf.import_gds(gdspath=\"myoutput.gds\", cellname=None, flatten=False)\n","D2.plot()"],"id":"e2137531"},{"cell_type":"markdown","metadata":{"id":"e2dec483"},"source":["# Generic_tech\n","\n","gdsfactory includes a generic Technology module in `gdsfactory.generic_tech` that you can use as an inspiration to create your own.\n","\n","## LayerMap\n","\n","A layer map maps layer names to a integer numbers pair  (GDSlayer, GDSpurpose)\n","\n","Each foundry uses different GDS layer numbers for different process steps.\n","\n","We follow the generic layer numbers from the book \"Silicon Photonics Design: From Devices to Systems Lukas Chrostowski, Michael Hochberg\".\n","\n","| GDS (layer, purpose) | layer_name | Description                                                 |\n","| -------------------- | ---------- | ----------------------------------------------------------- |\n","| 1 , 0                | WG         | 220 nm Silicon core                                         |\n","| 2 , 0                | SLAB150    | 150nm Silicon slab (70nm shallow Etch for grating couplers) |\n","| 3 , 0                | SLAB90     | 90nm Silicon slab (for modulators)                          |\n","| 4, 0                 | DEEPTRENCH | Deep trench                                                 |\n","| 47, 0                | MH         | heater                                                      |\n","| 41, 0                | M1         | metal 1                                                     |\n","| 45, 0                | M2         | metal 2                                                     |\n","| 40, 0                | VIAC       | VIAC to contact Ge, NPP or PPP                              |\n","| 44, 0                | VIA1       | VIA1                                                        |\n","| 46, 0                | PADOPEN    | Bond pad opening                                            |\n","| 51, 0                | UNDERCUT   | Undercut                                                    |\n","| 66, 0                | TEXT       | Text markup                                                 |\n","| 64, 0                | FLOORPLAN  | Mask floorplan                                              |\n"],"id":"e2dec483"},{"cell_type":"code","execution_count":null,"metadata":{"id":"5a06078f"},"outputs":[],"source":["\n","from pydantic import BaseModel\n","\n","import gdsfactory as gf\n","from gdsfactory.generic_tech import LAYER, LAYER_STACK\n","from gdsfactory.generic_tech.get_klayout_pyxs import get_klayout_pyxs\n","from gdsfactory.technology import LayerLevel, LayerStack, LayerViews\n","from gdsfactory.generic_tech import get_generic_pdk"],"id":"5a06078f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"d1086f0c"},"outputs":[],"source":["Layer = tuple[int, int]\n","\n","gf.config.rich_output()\n","PDK = get_generic_pdk()\n","PDK.activate()\n","\n","\n","class GenericLayerMap(BaseModel):\n","    \"\"\"Generic layermap based on book.\n","\n","    Lukas Chrostowski, Michael Hochberg, \"Silicon Photonics Design\",\n","    Cambridge University Press 2015, page 353\n","    You will need to create a new LayerMap with your specific foundry layers.\n","    \"\"\"\n","\n","    WAFER: Layer = (99999, 0)\n","\n","    WG: Layer = (1, 0)\n","    WGCLAD: Layer = (111, 0)\n","    SLAB150: Layer = (2, 0)\n","    SLAB90: Layer = (3, 0)\n","    DEEPTRENCH: Layer = (4, 0)\n","    GE: Layer = (5, 0)\n","    UNDERCUT: Layer = (6, 0)\n","    WGN: Layer = (34, 0)\n","    WGN_CLAD: Layer = (36, 0)\n","\n","    N: Layer = (20, 0)\n","    NP: Layer = (22, 0)\n","    NPP: Layer = (24, 0)\n","    P: Layer = (21, 0)\n","    PP: Layer = (23, 0)\n","    PPP: Layer = (25, 0)\n","    GEN: Layer = (26, 0)\n","    GEP: Layer = (27, 0)\n","\n","    HEATER: Layer = (47, 0)\n","    M1: Layer = (41, 0)\n","    M2: Layer = (45, 0)\n","    M3: Layer = (49, 0)\n","    VIAC: Layer = (40, 0)\n","    VIA1: Layer = (44, 0)\n","    VIA2: Layer = (43, 0)\n","    PADOPEN: Layer = (46, 0)\n","\n","    DICING: Layer = (100, 0)\n","    NO_TILE_SI: Layer = (71, 0)\n","    PADDING: Layer = (67, 0)\n","    DEVREC: Layer = (68, 0)\n","    FLOORPLAN: Layer = (64, 0)\n","    TEXT: Layer = (66, 0)\n","    PORT: Layer = (1, 10)\n","    PORTE: Layer = (1, 11)\n","    PORTH: Layer = (70, 0)\n","    SHOW_PORTS: Layer = (1, 12)\n","    LABEL: Layer = (201, 0)\n","    LABEL_SETTINGS: Layer = (202, 0)\n","    TE: Layer = (203, 0)\n","    TM: Layer = (204, 0)\n","    DRC_MARKER: Layer = (205, 0)\n","    LABEL_INSTANCE: Layer = (206, 0)\n","    ERROR_MARKER: Layer = (207, 0)\n","    ERROR_PATH: Layer = (208, 0)\n","\n","    SOURCE: Layer = (110, 0)\n","    MONITOR: Layer = (101, 0)\n","\n","    class Config:\n","        \"\"\"pydantic config.\"\"\"\n","\n","        frozen = True\n","        extra = \"forbid\"\n","\n","\n","LAYER = GenericLayerMap()\n","LAYER"],"id":"d1086f0c"},{"cell_type":"markdown","metadata":{"id":"c60cbd2f"},"source":["### Extract layers\n","\n","You can also extract layers using the `extract` function. This function returns a new flattened Component that contains the extracted layers.\n","A flat Component does not have references, and all the polygons are absorbed into the top cell."],"id":"c60cbd2f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a475d9da"},"outputs":[],"source":["from gdsfactory.generic_tech import get_generic_pdk\n","\n","PDK = get_generic_pdk()\n","PDK.activate()\n","\n","LAYER_VIEWS = PDK.layer_views\n","c = LAYER_VIEWS.preview_layerset()\n","c.plot()"],"id":"a475d9da"},{"cell_type":"markdown","metadata":{"id":"2e21eb2f"},"source":["## LayerStack\n","\n","Each layer also includes the information of thickness and position of each layer after fabrication.\n","\n","This LayerStack can be used for creating a 3D model with `Component.to_3d` or running Simulations.\n","\n","A GDS has different layers to describe the different fabrication process steps. And each grown layer needs thickness information and z-position in the stack.\n","\n","![layer stack](https://i.imgur.com/GUb1Kav.png)\n","\n","Lets define the layer stack for the generic layers in the generic_technology."],"id":"2e21eb2f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"1959c56d"},"outputs":[],"source":["from gdsfactory.generic_tech.layer_map import LAYER\n","from gdsfactory.technology import LayerLevel, LayerStack\n","\n","nm = 1e-3\n","\n","\n","def get_layer_stack(\n","    thickness_wg: float = 220 * nm,\n","    thickness_slab_deep_etch: float = 90 * nm,\n","    thickness_slab_shallow_etch: float = 150 * nm,\n","    sidewall_angle_wg: float = 10,\n","    thickness_clad: float = 3.0,\n","    thickness_nitride: float = 350 * nm,\n","    thickness_ge: float = 500 * nm,\n","    gap_silicon_to_nitride: float = 100 * nm,\n","    zmin_heater: float = 1.1,\n","    zmin_metal1: float = 1.1,\n","    thickness_metal1: float = 700 * nm,\n","    zmin_metal2: float = 2.3,\n","    thickness_metal2: float = 700 * nm,\n","    zmin_metal3: float = 3.2,\n","    thickness_metal3: float = 2000 * nm,\n","    substrate_thickness: float = 10.0,\n","    box_thickness: float = 3.0,\n","    undercut_thickness: float = 5.0,\n",") -> LayerStack:\n","    \"\"\"Returns generic LayerStack.\n","\n","    based on paper https://www.degruyter.com/document/doi/10.1515/nanoph-2013-0034/html\n","\n","    Args:\n","        thickness_wg: waveguide thickness in um.\n","        thickness_slab_deep_etch: for deep etched slab.\n","        thickness_shallow_etch: thickness for the etch.\n","        sidewall_angle_wg: waveguide side angle.\n","        thickness_clad: cladding thickness in um.\n","        thickness_nitride: nitride thickness in um.\n","        thickness_ge: germanium thickness.\n","        gap_silicon_to_nitride: distance from silicon to nitride in um.\n","        zmin_heater: TiN heater.\n","        zmin_metal1: metal1.\n","        thickness_metal1: metal1 thickness.\n","        zmin_metal2: metal2.\n","        thickness_metal2: metal2 thickness.\n","        zmin_metal3: metal3.\n","        thickness_metal3: metal3 thickness.\n","        substrate_thickness: substrate thickness in um.\n","        box_thickness: bottom oxide thickness in um.\n","        undercut_thickness: thickness of the silicon undercut.\n","    \"\"\"\n","\n","    thickness_deep_etch = thickness_wg - thickness_slab_deep_etch\n","    thickness_shallow_etch = thickness_wg - thickness_slab_shallow_etch\n","\n","    class GenericLayerStack(LayerStack):\n","        substrate = LayerLevel(\n","            layer=LAYER.WAFER,\n","            thickness=substrate_thickness,\n","            zmin=-substrate_thickness - box_thickness,\n","            material=\"si\",\n","            mesh_order=99,\n","        )\n","        box = LayerLevel(\n","            layer=LAYER.WAFER,\n","            thickness=box_thickness,\n","            zmin=-box_thickness,\n","            material=\"sio2\",\n","            mesh_order=99,\n","        )\n","        core = LayerLevel(\n","            layer=(1, 0),\n","            thickness=thickness_wg,\n","            zmin=0.0,\n","            material=\"si\",\n","            mesh_order=2,\n","            sidewall_angle=sidewall_angle_wg,\n","            width_to_z=0.5,\n","        )\n","        shallow_etch = LayerLevel(\n","            layer=LAYER.SHALLOW_ETCH,\n","            thickness=thickness_shallow_etch,\n","            zmin=0.0,\n","            material=\"si\",\n","            mesh_order=1,\n","            layer_type=\"etch\",\n","            into=[\"core\"],\n","            derived_layer=(2, 0),\n","        )\n","        deep_etch = LayerLevel(\n","            layer=LAYER.DEEP_ETCH,\n","            thickness=thickness_deep_etch,\n","            zmin=0.0,\n","            material=\"si\",\n","            mesh_order=1,\n","            layer_type=\"etch\",\n","            into=[\"core\"],\n","            derived_layer=LAYER.SLAB90,\n","        )\n","        clad = LayerLevel(\n","            # layer=LAYER.WGCLAD,\n","            layer=LAYER.WAFER,\n","            zmin=0.0,\n","            material=\"sio2\",\n","            thickness=thickness_clad,\n","            mesh_order=10,\n","        )\n","        slab150 = LayerLevel(\n","            layer=(2, 0),\n","            thickness=150e-3,\n","            zmin=0,\n","            material=\"si\",\n","            mesh_order=3,\n","        )\n","        slab90 = LayerLevel(\n","            layer=LAYER.SLAB90,\n","            thickness=thickness_slab_deep_etch,\n","            zmin=0.0,\n","            material=\"si\",\n","            mesh_order=2,\n","        )\n","        nitride = LayerLevel(\n","            layer=LAYER.WGN,\n","            thickness=thickness_nitride,\n","            zmin=thickness_wg + gap_silicon_to_nitride,\n","            material=\"sin\",\n","            mesh_order=2,\n","        )\n","        ge = LayerLevel(\n","            layer=LAYER.GE,\n","            thickness=thickness_ge,\n","            zmin=thickness_wg,\n","            material=\"ge\",\n","            mesh_order=1,\n","        )\n","        undercut = LayerLevel(\n","            layer=LAYER.UNDERCUT,\n","            thickness=-undercut_thickness,\n","            zmin=-box_thickness,\n","            material=\"air\",\n","            z_to_bias=[\n","                [0, 0.3, 0.6, 0.8, 0.9, 1],\n","                [-0, -0.5, -1, -1.5, -2, -2.5],\n","            ],\n","            mesh_order=1,\n","        )\n","        via_contact = LayerLevel(\n","            layer=LAYER.VIAC,\n","            thickness=zmin_metal1 - thickness_slab_deep_etch,\n","            zmin=thickness_slab_deep_etch,\n","            material=\"Aluminum\",\n","            mesh_order=1,\n","            sidewall_angle=-10,\n","            width_to_z=0,\n","        )\n","        metal1 = LayerLevel(\n","            layer=LAYER.M1,\n","            thickness=thickness_metal1,\n","            zmin=zmin_metal1,\n","            material=\"Aluminum\",\n","            mesh_order=2,\n","        )\n","        heater = LayerLevel(\n","            layer=LAYER.HEATER,\n","            thickness=750e-3,\n","            zmin=zmin_heater,\n","            material=\"TiN\",\n","            mesh_order=1,\n","        )\n","        via1 = LayerLevel(\n","            layer=LAYER.VIA1,\n","            thickness=zmin_metal2 - (zmin_metal1 + thickness_metal1),\n","            zmin=zmin_metal1 + thickness_metal1,\n","            material=\"Aluminum\",\n","            mesh_order=2,\n","        )\n","        metal2 = LayerLevel(\n","            layer=LAYER.M2,\n","            thickness=thickness_metal2,\n","            zmin=zmin_metal2,\n","            material=\"Aluminum\",\n","            mesh_order=2,\n","        )\n","        via2 = LayerLevel(\n","            layer=LAYER.VIA2,\n","            thickness=zmin_metal3 - (zmin_metal2 + thickness_metal2),\n","            zmin=zmin_metal2 + thickness_metal2,\n","            material=\"Aluminum\",\n","            mesh_order=1,\n","        )\n","        metal3 = LayerLevel(\n","            layer=LAYER.M3,\n","            thickness=thickness_metal3,\n","            zmin=zmin_metal3,\n","            material=\"Aluminum\",\n","            mesh_order=2,\n","        )\n","\n","    return GenericLayerStack()\n","\n","\n","LAYER_STACK = get_layer_stack()\n","layer_stack220 = LAYER_STACK"],"id":"1959c56d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"b54a90ab"},"outputs":[],"source":["import gdsfactory as gf\n","\n","c = gf.components.straight_heater_metal(length=40)\n","c.plot()"],"id":"b54a90ab"},{"cell_type":"code","execution_count":null,"metadata":{"id":"26483a57"},"outputs":[],"source":["scene = c.to_3d(layer_stack=layer_stack220)\n","scene.show()"],"id":"26483a57"},{"cell_type":"code","execution_count":null,"metadata":{"id":"055d1178"},"outputs":[],"source":["import gdsfactory as gf\n","\n","c = gf.components.taper_strip_to_ridge_trenches()\n","c.plot()"],"id":"055d1178"},{"cell_type":"code","execution_count":null,"metadata":{"id":"1621b195"},"outputs":[],"source":["scene = c.to_3d(layer_stack=layer_stack220)\n","scene.show()"],"id":"1621b195"},{"cell_type":"code","execution_count":null,"metadata":{"id":"963f2dd9"},"outputs":[],"source":["# lets assume we have 900nm silicon instead of 220nm, You will see a much thicker waveguide under the metal heater.\n","layer_stack900 = get_layer_stack(thickness_wg=900 * nm)\n","scene = c.to_3d(layer_stack=layer_stack900)\n","scene.show()"],"id":"963f2dd9"},{"cell_type":"code","execution_count":null,"metadata":{"id":"1f229127"},"outputs":[],"source":["import gdsfactory as gf\n","\n","c = gf.components.grating_coupler_elliptical_trenches()\n","c.plot()"],"id":"1f229127"},{"cell_type":"code","execution_count":null,"metadata":{"id":"42476c5c"},"outputs":[],"source":["scene = c.to_3d()\n","scene.show()"],"id":"42476c5c"},{"cell_type":"markdown","metadata":{"id":"da50e315"},"source":["## 3D rendering\n","\n","To render components in 3D you will need to define two things:\n","\n","1. LayerStack: for each layer contains thickness of each material and z position\n","2. LayerViews: for each layer contains view (color, pattern, opacity). You can load it with `gf.technology.LayerView.load_lyp()`"],"id":"da50e315"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f67c093d"},"outputs":[],"source":["heater = gf.components.straight_heater_metal(length=50)\n","heater.plot()"],"id":"f67c093d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"01f1769a"},"outputs":[],"source":["scene = heater.to_3d()\n","scene.show()"],"id":"01f1769a"},{"cell_type":"markdown","source":[],"metadata":{"id":"5MPfDHSDp5Q5"},"id":"5MPfDHSDp5Q5"},{"cell_type":"markdown","source":[],"metadata":{"id":"vTxLqeCBp74n"},"id":"vTxLqeCBp74n"},{"cell_type":"markdown","id":"3f251bfe","metadata":{"id":"3f251bfe"},"source":["As the sequence is defined as a string you can use the string operations to easily build complex sequences"]},{"cell_type":"markdown","source":[],"metadata":{"id":"-4-PBhwOnAC2"},"id":"-4-PBhwOnAC2"},{"cell_type":"markdown","id":"a899fccf","metadata":{"id":"a899fccf"},"source":["# References and ports\n","\n","gdsfactory defines your component once in memory and can add multiple References (Instances) to the same component."]},{"cell_type":"markdown","id":"1964be47","metadata":{"id":"1964be47"},"source":["As you build components you can include references to other components. Adding a reference is like having a pointer to a component.\n","\n","The GDSII specification allows the use of references, and similarly gdsfactory uses them (with the `add_ref()` function).\n","what is a reference? Simply put:  **A reference does not contain any geometry. It only *points* to an existing geometry**.\n","\n","Say you have a ridiculously large polygon with 100 billion vertices that you call BigPolygon. It's huge, and you need to use it in your design 250 times.\n","Well, a single copy of BigPolygon takes up 1MB of memory, so you don't want to make 250 copies of it\n","You can instead *references* the polygon 250 times.\n","Each reference only uses a few bytes of memory -- it only needs to know the memory address of BigPolygon, position, rotation and mirror.\n","This way, you can keep one copy of BigPolygon and use it again and again.\n","\n","You can start by making a blank `Component` and add a single polygon to it."]},{"cell_type":"code","execution_count":null,"id":"c7fe5dcc","metadata":{"id":"c7fe5dcc"},"outputs":[],"source":["import gdsfactory as gf\n","from gdsfactory.generic_tech import get_generic_pdk\n","\n","gf.config.rich_output()\n","PDK = get_generic_pdk()\n","PDK.activate()\n","\n","# Create a blank Component\n","p = gf.Component(\"component_with_polygon\")\n","\n","# Add a polygon\n","xpts = [0, 0, 5, 6, 9, 12]\n","ypts = [0, 1, 1, 2, 2, 0]\n","p.add_polygon([xpts, ypts], layer=(2, 0))\n","\n","# plot the Component with the polygon in it\n","p.plot()"]},{"cell_type":"markdown","id":"ec3e3272","metadata":{"id":"ec3e3272"},"source":["Now, you want to reuse this polygon repeatedly without creating multiple copies of it.\n","\n","To do so, you need to make a second blank `Component`, this time called `c`.\n","\n","In this new Component you *reference* our Component `p` which contains our polygon."]},{"cell_type":"code","execution_count":null,"id":"b86841d2","metadata":{"id":"b86841d2"},"outputs":[],"source":["c = gf.Component(\"Component_with_references\")  # Create a new blank Component\n","poly_ref = c.add_ref(p)  # Reference the Component \"p\" that has the polygon in it\n","c.plot()"]},{"cell_type":"markdown","id":"b71a2bc4","metadata":{"id":"b71a2bc4"},"source":["you just made a copy of your polygon -- but remember, you didn't actually\n","make a second polygon, you just made a reference (aka pointer) to the original\n","polygon.  Let's add two more references to `c`:"]},{"cell_type":"code","execution_count":null,"id":"dffa672a","metadata":{"id":"dffa672a"},"outputs":[],"source":["poly_ref2 = c.add_ref(p)  # Reference the Component \"p\" that has the polygon in it\n","poly_ref3 = c.add_ref(p)  # Reference the Component \"p\" that has the polygon in it\n","c.plot()"]},{"cell_type":"markdown","id":"ea6c483d","metadata":{"id":"ea6c483d"},"source":["Now you have 3x polygons all on top of each other.  Again, this would appear\n","useless, except that you can manipulate each reference independently. Notice that\n","when you called `c.add_ref(p)` above, we saved the result to a new variable each\n","time (`poly_ref`, `poly_ref2`, and `poly_ref3`)?  You can use those variables to\n","reposition the references."]},{"cell_type":"code","execution_count":null,"id":"d1898e38","metadata":{"id":"d1898e38"},"outputs":[],"source":["poly_ref2.rotate(90)  # Rotate the 2nd reference we made 90 degrees\n","poly_ref3.rotate(180)  # Rotate the 3rd reference we made 180 degrees\n","c.plot()"]},{"cell_type":"markdown","id":"d0aa0866","metadata":{"id":"d0aa0866"},"source":["Now you're getting somewhere! You've only had to make the polygon once, but you're\n","able to reuse it as many times as you want.\n","\n","## Modifying the referenced geometry\n","\n","What happens when you change the original geometry that the reference points to?  In your case, your references in\n","`c` all point to the Component `p` that with the original polygon.  Let's try\n","adding a second polygon to `p`.\n","\n","First you add the second polygon and make sure `P` looks like you expect:"]},{"cell_type":"code","execution_count":null,"id":"ad32843e","metadata":{"id":"ad32843e"},"outputs":[],"source":["# Add a 2nd polygon to \"p\"\n","xpts = [14, 14, 16, 16]\n","ypts = [0, 2, 2, 0]\n","p.add_polygon([xpts, ypts], layer=(1, 0))\n","p"]},{"cell_type":"markdown","id":"9ad4db54","metadata":{"id":"9ad4db54"},"source":["That looks good.  Now let's find out what happened to `c` that contains the\n","three references.  Keep in mind that you have not modified `c` or executed any\n","functions/operations on `c` -- all you have done is modify `p`."]},{"cell_type":"code","execution_count":null,"id":"a598c2b7","metadata":{"id":"a598c2b7"},"outputs":[],"source":["c.plot()"]},{"cell_type":"markdown","id":"39f210b2","metadata":{"id":"39f210b2"},"source":[" **When you modify the original geometry, all of the\n","references automatically reflect the modifications.**  This is very powerful,\n","because you can use this to make very complicated designs from relatively simple\n","elements in a computation- and memory-efficient way.\n","\n","Let's try making references a level deeper by referencing `c`.  Note here we use\n","the `<<` operator to add the references -- this is just shorthand, and is\n","exactly equivalent to using `add_ref()`"]},{"cell_type":"code","execution_count":null,"id":"fb70c0c1","metadata":{"id":"fb70c0c1"},"outputs":[],"source":["c2 = gf.Component(\"array_sample\")  # Create a new blank Component\n","d_ref1 = c2.add_ref(c)  # Reference the Component \"c\" that 3 references in it\n","d_ref2 = c2 << c  # Use the \"<<\" operator to create a 2nd reference to c.plot()\n","d_ref3 = c2 << c  # Use the \"<<\" operator to create a 3rd reference to c.plot()\n","\n","d_ref1.move([20, 0])\n","d_ref2.move([40, 0])\n","\n","c2"]},{"cell_type":"markdown","id":"2659e1ea","metadata":{"id":"2659e1ea"},"source":["As you've seen you have two ways to add a reference to our component:\n","\n","1. create the reference and add it to the component"]},{"cell_type":"code","execution_count":null,"id":"f15dac63","metadata":{"id":"f15dac63"},"outputs":[],"source":["c = gf.Component(\"reference_sample\")\n","w = gf.components.straight(width=0.6)\n","wr = w.ref()\n","c.add(wr)\n","c.plot()"]},{"cell_type":"markdown","id":"77717357","metadata":{"id":"77717357"},"source":["2. or do it in a single line"]},{"cell_type":"code","execution_count":null,"id":"48859d0d","metadata":{"id":"48859d0d"},"outputs":[],"source":["c = gf.Component(\"reference_sample_shorter_syntax\")\n","wr = c << gf.components.straight(width=0.6)\n","c.plot()"]},{"cell_type":"markdown","id":"1b979cd0","metadata":{"id":"1b979cd0"},"source":["in both cases you can move the reference `wr` after created"]},{"cell_type":"code","execution_count":null,"id":"617f6c64","metadata":{"id":"617f6c64"},"outputs":[],"source":["c = gf.Component(\"two_references\")\n","wr1 = c << gf.components.straight(width=0.6)\n","wr2 = c << gf.components.straight(width=0.6)\n","wr2.movey(10)\n","c.add_ports(wr1.get_ports_list(), prefix=\"bot_\")\n","c.add_ports(wr2.get_ports_list(), prefix=\"top_\")"]},{"cell_type":"code","execution_count":null,"id":"46c06793","metadata":{"id":"46c06793"},"outputs":[],"source":["c.ports"]},{"cell_type":"markdown","id":"7cbbe71b","metadata":{"id":"7cbbe71b"},"source":["You can also auto_rename ports using gdsfactory default convention, where ports are numbered clockwise starting from the bottom left"]},{"cell_type":"code","execution_count":null,"id":"c66d68fe","metadata":{"id":"c66d68fe"},"outputs":[],"source":["c.auto_rename_ports()"]},{"cell_type":"code","execution_count":null,"id":"0a3a546f","metadata":{"id":"0a3a546f"},"outputs":[],"source":["c.ports"]},{"cell_type":"code","execution_count":null,"id":"aca431f4","metadata":{"id":"aca431f4"},"outputs":[],"source":["c.plot()"]},{"cell_type":"markdown","id":"6219b993","metadata":{"id":"6219b993"},"source":["## Arrays of references\n","\n","In GDS, there's a type of structure called a \"ComponentReference\" which takes a cell and repeats it NxM times on a fixed grid spacing. For convenience, `Component` includes this functionality with the add_array() function.\n","Note that CellArrays are not compatible with ports (since there is no way to access/modify individual elements in a GDS cellarray)\n","\n","gdsfactory also provides with more flexible arrangement options if desired, see for example `grid()` and `packer()`.\n","\n","As well as `gf.components.array`\n","\n","Let's make a new Component and put a big array of our Component `c` in it:"]},{"cell_type":"code","execution_count":null,"id":"afdb6767","metadata":{"id":"afdb6767"},"outputs":[],"source":["c3 = gf.Component(\"array_of_references\")  # Create a new blank Component\n","aref = c3.add_array(\n","    c, columns=6, rows=3, spacing=[20, 15]\n",")  # Reference the Component \"c\" 3 references in it with a 3 rows, 6 columns array\n","c3"]},{"cell_type":"markdown","id":"d2590c0c","metadata":{"id":"d2590c0c"},"source":["CellArrays don't have ports and there is no way to access/modify individual elements in a GDS cellarray.\n","\n","gdsfactory provides you with similar functions in `gf.components.array` and `gf.components.array_2d`"]},{"cell_type":"code","execution_count":null,"id":"0dff1293","metadata":{"lines_to_next_cell":2,"id":"0dff1293"},"outputs":[],"source":["c4 = gf.Component(\"demo_array\")  # Create a new blank Component\n","aref = c4 << gf.components.array(component=c, columns=3, rows=2)\n","c4.add_ports(aref.get_ports_list())\n","c4"]},{"cell_type":"code","execution_count":null,"id":"cd0db0af","metadata":{"lines_to_next_cell":2,"id":"cd0db0af"},"outputs":[],"source":["help(gf.components.array)"]},{"cell_type":"markdown","id":"e52fd1e7","metadata":{"lines_to_next_cell":2,"id":"e52fd1e7"},"source":["You can also create an array of references for periodic structures. Let's create a [Distributed Bragg Reflector](https://picwriter.readthedocs.io/en/latest/components/dbr.html)\n"]},{"cell_type":"code","execution_count":null,"id":"9fd2d7ef","metadata":{"id":"9fd2d7ef"},"outputs":[],"source":["@gf.cell\n","def dbr_period(w1=0.5, w2=0.6, l1=0.2, l2=0.4, straight=gf.components.straight):\n","    \"\"\"Return one DBR period.\"\"\"\n","    c = gf.Component()\n","    r1 = c << straight(length=l1, width=w1)\n","    r2 = c << straight(length=l2, width=w2)\n","    r2.connect(port=\"o1\", destination=r1.ports[\"o2\"])\n","    c.add_port(\"o1\", port=r1.ports[\"o1\"])\n","    c.add_port(\"o2\", port=r2.ports[\"o2\"])\n","    return c\n","\n","\n","l1 = 0.2\n","l2 = 0.4\n","n = 3\n","period = dbr_period(l1=l1, l2=l2)\n","period"]},{"cell_type":"code","execution_count":null,"id":"e71f5839","metadata":{"id":"e71f5839"},"outputs":[],"source":["dbr = gf.Component(\"DBR\")\n","dbr.add_array(period, columns=n, rows=1, spacing=(l1 + l2, 100))\n","dbr"]},{"cell_type":"markdown","id":"34335b79","metadata":{"id":"34335b79"},"source":["Finally we need to add ports to the new component"]},{"cell_type":"code","execution_count":null,"id":"7bf3eec3","metadata":{"id":"7bf3eec3"},"outputs":[],"source":["p0 = dbr.add_port(\"o1\", port=period.ports[\"o1\"])\n","p1 = dbr.add_port(\"o2\", port=period.ports[\"o2\"])\n","\n","p1.center = [(l1 + l2) * n, 0]\n","dbr"]},{"cell_type":"markdown","id":"72de73dc","metadata":{"id":"72de73dc"},"source":["## Connect references\n","\n","We have seen that once you create a reference you can manipulate the reference to move it to a location. Here we are going to connect that reference to a port. Remember that we follow that a certain reference `source` connects to a `destination` port"]},{"cell_type":"code","execution_count":null,"id":"09351861","metadata":{"id":"09351861"},"outputs":[],"source":["bend = gf.components.bend_circular()\n","bend"]},{"cell_type":"code","execution_count":null,"id":"88d3dc55","metadata":{"id":"88d3dc55"},"outputs":[],"source":["c = gf.Component(\"sample_reference_connect\")\n","\n","mmi = c << gf.components.mmi1x2()\n","b = c << gf.components.bend_circular()\n","b.connect(\"o1\", destination=mmi.ports[\"o2\"])\n","\n","c.add_port(\"o1\", port=mmi.ports[\"o1\"])\n","c.add_port(\"o2\", port=b.ports[\"o2\"])\n","c.add_port(\"o3\", port=mmi.ports[\"o3\"])\n","c.plot()"]},{"cell_type":"markdown","id":"3b5cb9ea","metadata":{"id":"3b5cb9ea"},"source":["You can also access the ports directly from the references"]},{"cell_type":"code","execution_count":null,"id":"0fb1b2ed","metadata":{"id":"0fb1b2ed"},"outputs":[],"source":["c = gf.Component(\"sample_reference_connect_simpler\")\n","\n","mmi = c << gf.components.mmi1x2()\n","b = c << gf.components.bend_circular()\n","b.connect(\"o1\", destination=mmi[\"o2\"])\n","\n","c.add_port(\"o1\", port=mmi[\"o1\"])\n","c.add_port(\"o2\", port=b[\"o2\"])\n","c.add_port(\"o3\", port=mmi[\"o3\"])\n","c.plot()"]},{"cell_type":"markdown","id":"339cb714","metadata":{"id":"339cb714"},"source":["Notice that `connect` mates two ports together and does not imply that ports will remain connected.\n"]},{"cell_type":"markdown","id":"0b95a477","metadata":{"id":"0b95a477"},"source":["## Port\n","\n","You can name the ports as you want and use `gf.port.auto_rename_ports(prefix='o')` to rename them later on.\n","\n","Here is the default naming convention.\n","\n","Ports are numbered clock-wise starting from the bottom left corner.\n","\n","Optical ports have `o` prefix and Electrical ports `e` prefix.\n","\n","The port naming comes in most cases from the `gdsfactory.cross_section`. For example:\n","\n","- `gdsfactory.cross_section.strip`  has ports `o1` for input and `o2` for output.\n","- `gdsfactory.cross_section.metal1` has ports `e1` for input and `e2` for output."]},{"cell_type":"code","execution_count":null,"id":"e6ed4ac1","metadata":{"id":"e6ed4ac1"},"outputs":[],"source":["size = 4\n","c = gf.components.nxn(west=2, south=2, north=2, east=2, xsize=size, ysize=size)\n","c.plot()"]},{"cell_type":"code","execution_count":null,"id":"bf640ce3","metadata":{"id":"bf640ce3"},"outputs":[],"source":["c = gf.components.straight_heater_metal(length=30)\n","c.plot()"]},{"cell_type":"code","execution_count":null,"id":"adade3db","metadata":{"id":"adade3db"},"outputs":[],"source":["c.ports"]},{"cell_type":"markdown","id":"da96738f","metadata":{"id":"da96738f"},"source":["You can get the optical ports by `layer`"]},{"cell_type":"code","execution_count":null,"id":"34e988fa","metadata":{"id":"34e988fa"},"outputs":[],"source":["c.get_ports_dict(layer=(1, 0))"]},{"cell_type":"markdown","id":"5339aa2a","metadata":{"id":"5339aa2a"},"source":["or by `width`"]},{"cell_type":"code","execution_count":null,"id":"1bf81664","metadata":{"id":"1bf81664"},"outputs":[],"source":["c.get_ports_dict(width=0.5)"]},{"cell_type":"code","execution_count":null,"id":"475a1ba0","metadata":{"id":"475a1ba0"},"outputs":[],"source":["c0 = gf.components.straight_heater_metal()\n","c0.ports"]},{"cell_type":"code","execution_count":null,"id":"00325e72","metadata":{"id":"00325e72"},"outputs":[],"source":["c1 = c0.copy()\n","c1.auto_rename_ports_layer_orientation()\n","c1.ports"]},{"cell_type":"code","execution_count":null,"id":"a49b679c","metadata":{"id":"a49b679c"},"outputs":[],"source":["c2 = c0.copy()\n","c2.auto_rename_ports()\n","c2.ports"]},{"cell_type":"markdown","id":"d3897c76","metadata":{"id":"d3897c76"},"source":["You can also rename them with a different port naming convention\n","\n","- prefix: add `e` for electrical `o` for optical\n","- clockwise\n","- counter-clockwise\n","- orientation `E` East, `W` West, `N` North, `S` South\n","\n","\n","Here is the default one we use (clockwise starting from bottom left west facing port)\n","\n","```\n","             3   4\n","             |___|_\n","         2 -|      |- 5\n","            |      |\n","         1 -|______|- 6\n","             |   |\n","             8   7\n","\n","```"]},{"cell_type":"code","execution_count":null,"id":"381765cd","metadata":{"id":"381765cd"},"outputs":[],"source":["c = gf.Component(\"demo_ports\")\n","nxn = gf.components.nxn(west=2, north=2, east=2, south=2, xsize=4, ysize=4)\n","ref = c.add_ref(nxn)\n","c.add_ports(ref.ports)\n","c.plot()"]},{"cell_type":"code","execution_count":null,"id":"1805d846","metadata":{"id":"1805d846"},"outputs":[],"source":["ref.get_ports_list()  # by default returns ports clockwise starting from bottom left west facing port"]},{"cell_type":"code","execution_count":null,"id":"93498f52","metadata":{"id":"93498f52"},"outputs":[],"source":["c.auto_rename_ports()\n","c.plot()"]},{"cell_type":"markdown","id":"434a8597","metadata":{"id":"434a8597"},"source":["You can also get the ports counter-clockwise\n","\n","```\n","             4   3\n","             |___|_\n","         5 -|      |- 2\n","            |      |\n","         6 -|______|- 1\n","             |   |\n","             7   8\n","\n","```"]},{"cell_type":"code","execution_count":null,"id":"a89f5f01","metadata":{"id":"a89f5f01"},"outputs":[],"source":["c.auto_rename_ports_counter_clockwise()\n","c.plot()"]},{"cell_type":"code","execution_count":null,"id":"5e64d75b","metadata":{"id":"5e64d75b"},"outputs":[],"source":["c.get_ports_list(clockwise=False)"]},{"cell_type":"code","execution_count":null,"id":"1fb91cac","metadata":{"id":"1fb91cac"},"outputs":[],"source":["c.ports_layer"]},{"cell_type":"code","execution_count":null,"id":"4cf2cb74","metadata":{"id":"4cf2cb74"},"outputs":[],"source":["c.port_by_orientation_cw(\"W0\")"]},{"cell_type":"code","execution_count":null,"id":"5aa8e2a6","metadata":{"id":"5aa8e2a6"},"outputs":[],"source":["c.port_by_orientation_ccw(\"W1\")"]},{"cell_type":"markdown","id":"e49a5258","metadata":{"id":"e49a5258"},"source":["Lets extend the East facing ports (orientation = 0 deg)"]},{"cell_type":"code","execution_count":null,"id":"39a4e83b","metadata":{"id":"39a4e83b"},"outputs":[],"source":["cross_section = gf.cross_section.strip()\n","\n","nxn = gf.components.nxn(\n","    west=2, north=2, east=2, south=2, xsize=4, ysize=4, cross_section=cross_section\n",")\n","c = gf.components.extension.extend_ports(component=nxn, orientation=0)\n","c.plot()"]},{"cell_type":"code","execution_count":null,"id":"3c433ace","metadata":{"id":"3c433ace"},"outputs":[],"source":["c.ports"]},{"cell_type":"code","execution_count":null,"id":"9ddffac7","metadata":{"id":"9ddffac7"},"outputs":[],"source":["df = c.get_ports_pandas()\n","df"]},{"cell_type":"code","execution_count":null,"id":"45d120c8","metadata":{"id":"45d120c8"},"outputs":[],"source":["df[df.port_type == \"optical\"]"]},{"cell_type":"markdown","id":"1115a662","metadata":{"id":"1115a662"},"source":["## Port markers (Pins)\n","\n","You can add pins (port markers) to each port. Different foundries do this differently, so gdsfactory supports all of them.\n","\n","- square with port inside the component.\n","- square centered (half inside, half outside component).\n","- triangular pointing towards the outside of the port.\n","- path (SiEPIC).\n","\n","\n","by default Component.show() will add triangular pins, so you can see the direction of the port in Klayout."]},{"cell_type":"code","execution_count":null,"id":"88473af0","metadata":{"id":"88473af0"},"outputs":[],"source":["gf.components.mmi1x2(decorator=gf.add_pins.add_pins)"]},{"cell_type":"code","execution_count":null,"id":"f6a000a6","metadata":{"id":"f6a000a6"},"outputs":[],"source":["gf.components.mmi1x2(decorator=gf.add_pins.add_pins_triangle)"]},{"cell_type":"markdown","id":"8f2f6c9a","metadata":{"id":"8f2f6c9a"},"source":["## Component_sequence\n","\n","When you have repetitive connections you can describe the connectivity as an ASCII map"]},{"cell_type":"code","execution_count":null,"id":"c1c47676","metadata":{"id":"c1c47676"},"outputs":[],"source":["bend180 = gf.components.bend_circular180()\n","wg_pin = gf.components.straight_pin(length=40)\n","wg = gf.components.straight()\n","\n","# Define a map between symbols and (component, input port, output port)\n","symbol_to_component = {\n","    \"D\": (bend180, \"o1\", \"o2\"),\n","    \"C\": (bend180, \"o2\", \"o1\"),\n","    \"P\": (wg_pin, \"o1\", \"o2\"),\n","    \"-\": (wg, \"o1\", \"o2\"),\n","}\n","\n","# Generate a sequence\n","# This is simply a chain of characters. Each of them represents a component\n","# with a given input and and a given output\n","\n","sequence = \"DC-P-P-P-P-CD\"\n","component = gf.components.component_sequence(\n","    sequence=sequence, symbol_to_component=symbol_to_component\n",")\n","component.name = \"component_sequence\"\n","component"]},{"cell_type":"markdown","metadata":{"id":"461099cd"},"source":["You can install the klayout klive plugin to be able to see live updates on your GDS files:"],"id":"461099cd"},{"cell_type":"markdown","metadata":{"id":"b806af34"},"source":["![KLayout package](https://i.imgur.com/IZWH6U0.png)"],"id":"b806af34"},{"cell_type":"markdown","metadata":{"id":"0384f6f8"},"source":["# Movement\n","\n","You can move, rotate and mirror ComponentReference as well as `Port`, `Polygon`, `ComponentReference`, `Label`, and `Group`"],"id":"0384f6f8"},{"cell_type":"code","execution_count":null,"metadata":{"id":"153ac6d4"},"outputs":[],"source":["import gdsfactory as gf\n","from gdsfactory.generic_tech import get_generic_pdk\n","\n","gf.config.rich_output()\n","\n","PDK = get_generic_pdk()\n","\n","PDK.activate()\n","\n","# Start with a blank Component\n","c = gf.Component(\"demo_movement\")\n","\n","# Create some more Components with shapes\n","T = gf.components.text(\"hello\", size=10, layer=(1, 0))\n","E = gf.components.ellipse(radii=(10, 5), layer=(2, 0))\n","R = gf.components.rectangle(size=(10, 3), layer=(3, 0))\n","\n","# Add the shapes to D as references\n","text = c << T\n","ellipse = c << E\n","rect1 = c << R\n","rect2 = c << R\n","\n","c.plot()"],"id":"153ac6d4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a07392c0"},"outputs":[],"source":["c = gf.Component(\"move_one_ellipse\")\n","e1 = c << gf.components.ellipse(radii=(10, 5), layer=(2, 0))\n","e2 = c << gf.components.ellipse(radii=(10, 5), layer=(2, 0))\n","e1.movex(10)\n","c.plot()"],"id":"a07392c0"},{"cell_type":"code","execution_count":null,"metadata":{"id":"911985e1"},"outputs":[],"source":["c = gf.Component(\"move_one_ellipse_xmin\")\n","e1 = c << gf.components.ellipse(radii=(10, 5), layer=(2, 0))\n","e2 = c << gf.components.ellipse(radii=(10, 5), layer=(2, 0))\n","e2.xmin = e1.xmax\n","c.plot()"],"id":"911985e1"},{"cell_type":"markdown","metadata":{"id":"c0d211ec"},"source":["Now you can practice move and rotate the objects."],"id":"c0d211ec"},{"cell_type":"code","execution_count":null,"metadata":{"id":"6f1d9a89"},"outputs":[],"source":["c = gf.Component(\"two_ellipses_on_top_of_each_other\")\n","E = gf.components.ellipse(radii=(10, 5), layer=(2, 0))\n","e1 = c << E\n","e2 = c << E\n","c.plot()"],"id":"6f1d9a89"},{"cell_type":"code","execution_count":null,"metadata":{"id":"e2c7351d"},"outputs":[],"source":["c = gf.Component(\"ellipse_moved\")\n","e = gf.components.ellipse(radii=(10, 5), layer=(2, 0))\n","e1 = c << e\n","e2 = c << e\n","e2.move(origin=[5, 5], destination=[10, 10])  # Translate by dx = 5, dy = 5\n","c.plot()"],"id":"e2c7351d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"fb0873c7"},"outputs":[],"source":["c = gf.Component(\"ellipse_moved_v2\")\n","e = gf.components.ellipse(radii=(10, 5), layer=(2, 0))\n","e1 = c << e\n","e2 = c << e\n","e2.move([5, 5])  # Translate by dx = 5, dy = 5\n","c.plot()"],"id":"fb0873c7"},{"cell_type":"code","execution_count":null,"metadata":{"id":"33013003"},"outputs":[],"source":["c = gf.Component(\"rectangles\")\n","r = gf.components.rectangle(size=(10, 5), layer=(2, 0))\n","rect1 = c << r\n","rect2 = c << r\n","\n","rect1.rotate(45)  # Rotate the first straight by 45 degrees around (0,0)\n","rect2.rotate(\n","    -30, center=[1, 1]\n",")  # Rotate the second straight by -30 degrees around (1,1)\n","c.plot()"],"id":"33013003"},{"cell_type":"code","execution_count":null,"metadata":{"id":"10bfe651"},"outputs":[],"source":["c = gf.Component(\"mirror_demo\")\n","text = c << gf.components.text(\"hello\")\n","text.mirror(p1=[1, 1], p2=[1, 3])  # Reflects across the line formed by p1 and p2\n","c.plot()"],"id":"10bfe651"},{"cell_type":"code","execution_count":null,"metadata":{"id":"20f97fbc"},"outputs":[],"source":["c = gf.Component(\"hello\")\n","text = c << gf.components.text(\"hello\")\n","c.plot()"],"id":"20f97fbc"},{"cell_type":"markdown","metadata":{"id":"81f91f70"},"source":["Each Component and ComponentReference object has several properties which can be\n","used\n","to learn information about the object (for instance where it's center coordinate\n","is).  Several of these properties can actually be used to move the geometry by\n","assigning them new values.\n","\n","Available properties are:\n","\n","- `xmin` / `xmax`: minimum and maximum x-values of all points within the object\n","- `ymin` / `ymax`: minimum and maximum y-values of all points within the object\n","- `x`: centerpoint between minimum and maximum x-values of all points within the\n","object\n","- `y`: centerpoint between minimum and maximum y-values of all points within the\n","object\n","- `bbox`: bounding box (see note below) in format ((xmin,ymin),(xmax,ymax))\n","- `center`: center of bounding box"],"id":"81f91f70"},{"cell_type":"code","execution_count":null,"metadata":{"id":"254b7855"},"outputs":[],"source":["print(\"bounding box:\")\n","print(\n","    text.bbox\n",")  # Will print the bounding box of text in terms of [(xmin, ymin), (xmax, ymax)]\n","print(\"xsize and ysize:\")\n","print(text.xsize)  # Will print the width of text in the x dimension\n","print(text.ysize)  # Will print the height of text in the y dimension\n","print(\"center:\")\n","print(text.center)  # Gives you the center coordinate of its bounding box\n","print(\"xmax\")\n","print(text.xmax)  # Gives you the rightmost (+x) edge of the text bounding box"],"id":"254b7855"},{"cell_type":"markdown","metadata":{"id":"3e6393de"},"source":["Let's use these properties to manipulate our shapes to arrange them a little\n","better"],"id":"3e6393de"},{"cell_type":"code","execution_count":null,"metadata":{"id":"1bc02048"},"outputs":[],"source":["c = gf.Component(\"canvas\")\n","text = c << gf.components.text(\"hello\")\n","E = gf.components.ellipse(radii=(10, 5), layer=(3, 0))\n","R = gf.components.rectangle(size=(10, 5), layer=(2, 0))\n","rect1 = c << R\n","rect2 = c << R\n","ellipse = c << E\n","\n","c.plot()"],"id":"1bc02048"},{"cell_type":"code","execution_count":null,"metadata":{"id":"69a64d6d"},"outputs":[],"source":["# First let's center the ellipse\n","ellipse.center = [\n","    0,\n","    0,\n","]  # Move the ellipse such that the bounding box center is at (0,0)\n","\n","# Next, let's move the text to the left edge of the ellipse\n","text.y = (\n","    ellipse.y\n",")  # Move the text so that its y-center is equal to the y-center of the ellipse\n","text.xmax = ellipse.xmin  # Moves the ellipse so its xmax == the ellipse's xmin\n","\n","# Align the right edge of the rectangles with the x=0 axis\n","rect1.xmax = 0\n","rect2.xmax = 0\n","\n","# Move the rectangles above and below the ellipse\n","rect1.ymin = ellipse.ymax + 5\n","rect2.ymax = ellipse.ymin - 5\n","\n","c.plot()"],"id":"69a64d6d"},{"cell_type":"markdown","metadata":{"id":"e2ee53ab"},"source":["In addition to working with the properties of the references inside the\n","Component,\n","we can also manipulate the whole Component if we want.  Let's try mirroring the\n","whole Component `D`:"],"id":"e2ee53ab"},{"cell_type":"code","execution_count":null,"metadata":{"id":"84a8af68"},"outputs":[],"source":["print(c.xmax)  # Prints out '10.0'\n","\n","c2 = c.mirror((0, 1))  # Mirror across line made by (0,0) and (0,1)\n","c2.plot()"],"id":"84a8af68"},{"cell_type":"markdown","metadata":{"id":"bd2d47bd"},"source":["A bounding box is the smallest enclosing box which contains all points of the geometry."],"id":"bd2d47bd"},{"cell_type":"code","execution_count":null,"metadata":{"id":"5b339180"},"outputs":[],"source":["c = gf.Component(\"hi_bbox\")\n","text = c << gf.components.text(\"hi\")\n","bbox = text.bbox\n","c << gf.components.bbox(bbox=bbox, layer=(2, 0))\n","c.plot()"],"id":"5b339180"},{"cell_type":"code","execution_count":null,"metadata":{"id":"fccbfc3c"},"outputs":[],"source":["# gf.get_padding_points can also add a bbox with respect to the bounding box edges\n","c = gf.Component(\"sample_padding\")\n","text = c << gf.components.text(\"bye\")\n","device_bbox = text.bbox\n","c.add_polygon(gf.get_padding_points(text, default=1), layer=(2, 0))\n","c.plot()"],"id":"fccbfc3c"},{"cell_type":"markdown","metadata":{"id":"47b3064a"},"source":["When we query the properties of D, they will be calculated with respect to this\n","bounding-rectangle.  For instance:"],"id":"47b3064a"},{"cell_type":"code","execution_count":null,"metadata":{"id":"389cd7a4"},"outputs":[],"source":["print(\"Center of Component c:\")\n","print(c.center)\n","\n","print(\"X-max of Component c:\")\n","print(c.xmax)"],"id":"389cd7a4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"505a11be"},"outputs":[],"source":["D = gf.Component(\"rect\")\n","R = gf.components.rectangle(size=(10, 3), layer=(2, 0))\n","rect1 = D << R\n","D.plot()"],"id":"505a11be"},{"cell_type":"markdown","metadata":{"id":"57733ef8"},"source":["You can chain many of the movement/manipulation functions because they all return the object they manipulate.\n","\n","For instance you can combine two expressions:"],"id":"57733ef8"},{"cell_type":"code","execution_count":null,"metadata":{"id":"d1ded436"},"outputs":[],"source":["rect1.rotate(angle=37)\n","rect1.move([10, 20])\n","D.plot()"],"id":"d1ded436"},{"cell_type":"markdown","metadata":{"id":"0c8a7e54"},"source":["...into this single-line expression"],"id":"0c8a7e54"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4fd28010"},"outputs":[],"source":["D = gf.Component(\"single_expression\")\n","R = gf.components.rectangle(size=(10, 3), layer=(2, 0))\n","rect1 = D << R\n","rect1.rotate(angle=37).move([10, 20])\n","D.plot()"],"id":"4fd28010"},{"cell_type":"markdown","source":[],"metadata":{"id":"4WM_UvsYm_1T"},"id":"4WM_UvsYm_1T"},{"cell_type":"markdown","source":[],"metadata":{"id":"i1bXu3wAnJm3"},"id":"i1bXu3wAnJm3"},{"cell_type":"markdown","metadata":{"id":"1f7b5623"},"source":["# Cell\n","\n","A cell is a function that returns a Component.\n","\n","Make sure you add the `@cell` decorator to each function that returns a Component.\n","\n","`@cell` comes from PCell `parametric cell`, where the function returns a different Component depending on the input parameters.\n","\n","Why do we need cells?\n","\n","- In GDS each component must have a unique name. Ideally the name is also consistent from run to run, in case you want to merge GDS files that were created at different times or computers.\n","- Two components stored in the GDS file cannot have the same name. They need to be references (instances) of the same component. See `References tutorial`. That way we only have to store the component in memory once and all the references are just pointers to that component.\n","\n","What does the `@cell` decorator does?\n","\n","1. Gives the component a unique name depending on the parameters that you pass to it.\n","2. Creates a cache of components where we use the name as the key. The first time the function runs, the cache stores the component, so the second time, you get the component directly from the cache, so you don't create the same component twice.\n","\n","\n","A decorator is a function that runs over a function, so when you do.\n","\n","```python\n","@gf.cell\n","def mzi_with_bend():\n","    c = gf.Component()\n","    mzi = c << gf.components.mzi()\n","    bend = c << gf.components.bend_euler()\n","    return c\n","```\n","it's equivalent to\n","\n","```python\n","def mzi_with_bend():\n","    c = gf.Component()\n","    mzi = c << gf.components.mzi()\n","    bend = c << gf.components.bend_euler(radius=radius)\n","    return c\n","\n","\n","mzi_with_bend_decorated = gf.cell(mzi_with_bend)\n","```\n","\n","Lets see how it works."],"id":"1f7b5623"},{"cell_type":"code","execution_count":null,"metadata":{"id":"831747be"},"outputs":[],"source":["import gdsfactory as gf\n","from gdsfactory.cell import print_cache\n","from gdsfactory.generic_tech import get_generic_pdk\n","\n","gf.config.rich_output()\n","\n","PDK = get_generic_pdk()\n","PDK.activate()\n","\n","\n","def mzi_with_bend(radius: float = 10.0) -> gf.Component:\n","    c = gf.Component(\"Unnamed_cells_can_cause_issues\")\n","    mzi = c << gf.components.mzi()\n","    bend = c << gf.components.bend_euler(radius=radius)\n","    bend.connect(\"o1\", mzi.ports[\"o2\"])\n","    return c\n","\n","\n","c = mzi_with_bend()\n","print(f\"this cell {c.name!r} does NOT get automatic name\")\n","c.plot()"],"id":"831747be"},{"cell_type":"code","execution_count":null,"metadata":{"id":"ea3ea4d3"},"outputs":[],"source":["mzi_with_bend_decorated = gf.cell(mzi_with_bend)\n","c = mzi_with_bend_decorated(radius=10)\n","print(f\"this cell {c.name!r} gets automatic name thanks to the `cell` decorator\")\n","c.plot()"],"id":"ea3ea4d3"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_end_of_cell_marker":2,"lines_to_next_cell":2,"id":"74330d4d"},"outputs":[],"source":["@gf.cell\n","def mzi_with_bend(radius: float = 10.0) -> gf.Component:\n","    c = gf.Component()\n","    mzi = c << gf.components.mzi()\n","    bend = c << gf.components.bend_euler(radius=radius)\n","    bend.connect(\"o1\", mzi.ports[\"o2\"])\n","    return c\n","\n","\n","print(f\"this cell {c.name!r} gets automatic name thanks to the `cell` decorator\")\n","c.plot()"],"id":"74330d4d"},{"cell_type":"markdown","source":[],"metadata":{"id":"I9UZPa7AnvTz"},"id":"I9UZPa7AnvTz"},{"cell_type":"markdown","metadata":{"id":"9cced668"},"source":["# Path and CrossSection\n","\n","You can create a `Path` in gdsfactory and extrude it with an arbitrary `CrossSection`.\n","\n","Lets create a path:\n","\n","- Create a blank `Path`.\n","- Append points to the `Path` either using the built-in functions (`arc()`, `straight()`, `euler()` ...) or by providing your own lists of points\n","- Specify `CrossSection` with layers and offsets.\n","- Extrude `Path` with a `CrossSection` to create a Component with the path polygons in it.\n"],"id":"9cced668"},{"cell_type":"code","execution_count":null,"metadata":{"id":"16c7b67a"},"outputs":[],"source":["from functools import partial\n","\n","import matplotlib.pyplot as plt\n","import numpy as np\n","\n","import gdsfactory as gf\n","from gdsfactory.cross_section import Section\n","from gdsfactory.generic_tech import get_generic_pdk\n","\n","gf.config.rich_output()\n","PDK = get_generic_pdk()\n","PDK.activate()"],"id":"16c7b67a"},{"cell_type":"markdown","metadata":{"id":"3d01bec8"},"source":["## Path\n","\n","The first step is to generate the list of points we want the path to follow.\n","Let's start out by creating a blank `Path` and using the built-in functions to\n","make a few smooth turns."],"id":"3d01bec8"},{"cell_type":"code","execution_count":null,"metadata":{"id":"827e352d"},"outputs":[],"source":["p1 = gf.path.straight(length=5)\n","p2 = gf.path.euler(radius=5, angle=45, p=0.5, use_eff=False)\n","p = p1 + p2\n","f = p.plot()"],"id":"827e352d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"0668b20c"},"outputs":[],"source":["p1 = gf.path.straight(length=5)\n","p2 = gf.path.euler(radius=5, angle=45, p=0.5, use_eff=False)\n","p = p2 + p1\n","f = p.plot()"],"id":"0668b20c"},{"cell_type":"code","execution_count":null,"metadata":{"id":"72427613"},"outputs":[],"source":["P = gf.Path()\n","P += gf.path.arc(radius=10, angle=90)  # Circular arc\n","P += gf.path.straight(length=10)  # Straight section\n","P += gf.path.euler(radius=3, angle=-90)  # Euler bend (aka \"racetrack\" curve)\n","P += gf.path.straight(length=40)\n","P += gf.path.arc(radius=8, angle=-45)\n","P += gf.path.straight(length=10)\n","P += gf.path.arc(radius=8, angle=45)\n","P += gf.path.straight(length=10)\n","\n","f = P.plot()"],"id":"72427613"},{"cell_type":"code","execution_count":null,"metadata":{"id":"7e220227"},"outputs":[],"source":["p2 = P.copy().rotate()\n","f = p2.plot()"],"id":"7e220227"},{"cell_type":"code","execution_count":null,"metadata":{"id":"5de8dbb5"},"outputs":[],"source":["P.points - p2.points"],"id":"5de8dbb5"},{"cell_type":"markdown","metadata":{"id":"d7a67a12"},"source":["You can also modify our Path in the same ways as any other gdsfactory object:\n","\n","- Manipulation with `move()`, `rotate()`, `mirror()`, etc\n","- Accessing properties like `xmin`, `y`, `center`, `bbox`, etc"],"id":"d7a67a12"},{"cell_type":"code","execution_count":null,"metadata":{"id":"8afec04e"},"outputs":[],"source":["P.movey(10)\n","P.xmin = 20\n","f = P.plot()"],"id":"8afec04e"},{"cell_type":"markdown","metadata":{"id":"2182a3be"},"source":["You can also check the length of the curve with the `length()` method:"],"id":"2182a3be"},{"cell_type":"code","execution_count":null,"metadata":{"id":"839c771a"},"outputs":[],"source":["P.length()"],"id":"839c771a"},{"cell_type":"markdown","metadata":{"id":"5a4e6bf2"},"source":["## CrossSection\n","\n","Now that you've got your path defined, the next step is to define the cross-section of the path. To do this, you can create a blank `CrossSection` and add whatever cross-sections you want to it.\n","You can then combine the `Path` and the `CrossSection` using the `gf.path.extrude()` function to generate a Component:\n","\n","\n","### Option 1: Single layer and width cross-section\n","\n","The simplest option is to just set the cross-section to be a constant width by passing a number to `extrude()` like so:"],"id":"5a4e6bf2"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a502d743"},"outputs":[],"source":["# Extrude the Path and the CrossSection\n","c = gf.path.extrude(P, layer=(1, 0), width=1.5)\n","c.plot()"],"id":"a502d743"},{"cell_type":"markdown","metadata":{"id":"e4807989"},"source":["### Option 2: Linearly-varying width\n","\n","A slightly more advanced version is to make the cross-section width vary linearly from start to finish by passing a 2-element list to `extrude()` like so:"],"id":"e4807989"},{"cell_type":"code","execution_count":null,"metadata":{"id":"b62473fc"},"outputs":[],"source":["# Extrude the Path and the CrossSection\n","c = gf.path.extrude(P, layer=(1, 0), widths=(1, 3))\n","c.plot()"],"id":"b62473fc"},{"cell_type":"markdown","metadata":{"id":"a6bc6b11"},"source":["### Option 3: Arbitrary Cross-section\n","\n","You can also extrude an arbitrary cross_section"],"id":"a6bc6b11"},{"cell_type":"markdown","metadata":{"id":"fedd19c6"},"source":["Now, what if we want a more complicated straight?  For instance, in some\n","photonic applications it's helpful to have a shallow etch that appears on either\n","side of the straight (often called a trench or sleeve).  Additionally, it might be nice\n","to have a Port on either end of the center section so we can snap other\n","geometries to it.  Let's try adding something like that in:"],"id":"fedd19c6"},{"cell_type":"code","execution_count":null,"metadata":{"id":"0a1f7c01"},"outputs":[],"source":["p = gf.path.straight()\n","\n","# Add a few \"sections\" to the cross-section\n","s1 = gf.Section(width=2, offset=2, layer=(2, 0))\n","s2 = gf.Section(width=2, offset=-2, layer=(2, 0))\n","x = gf.CrossSection(\n","    width=1, offset=0, layer=(1, 0), port_names=(\"in\", \"out\"), sections=[s1, s2]\n",")\n","\n","c = gf.path.extrude(p, cross_section=x)\n","c.plot()"],"id":"0a1f7c01"},{"cell_type":"code","execution_count":null,"metadata":{"id":"e09a503d"},"outputs":[],"source":["p = gf.path.arc()\n","\n","# Combine the Path and the CrossSection\n","b = gf.path.extrude(p, cross_section=x)\n","b.plot()"],"id":"e09a503d"},{"cell_type":"markdown","metadata":{"id":"bf8c2af4"},"source":["An arbitrary cross-section can also help place components along a path.\n","This component can be useful for defining wiring vias."],"id":"bf8c2af4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"cdd256a3"},"outputs":[],"source":["import gdsfactory as gf\n","from gdsfactory.cross_section import ComponentAlongPath\n","\n","# Create the path\n","p = gf.path.straight()\n","p += gf.path.arc(10)\n","p += gf.path.straight()\n","\n","# Define a cross-section with a via\n","via = ComponentAlongPath(\n","    component=gf.c.rectangle(size=(1, 1), centered=True), spacing=5, padding=2\n",")\n","x = gf.CrossSection(\n","    width=0.5, offset=0, layer=(1, 0), port_names=(\"in\", \"out\"), vias=[via]\n",")\n","\n","# Combine the path with the cross-section\n","c = gf.path.extrude(p, cross_section=x)\n","c.plot()"],"id":"cdd256a3"},{"cell_type":"code","execution_count":null,"metadata":{"id":"abff41ca"},"outputs":[],"source":["import gdsfactory as gf\n","from gdsfactory.cross_section import ComponentAlongPath\n","\n","# Create the path\n","p = gf.path.straight()\n","p += gf.path.arc(10)\n","p += gf.path.straight()\n","\n","# Define a cross-section with a via\n","via0 = ComponentAlongPath(component=gf.c.via1(), spacing=5, padding=2, offset=0)\n","viap = ComponentAlongPath(component=gf.c.via1(), spacing=5, padding=2, offset=+2)\n","vian = ComponentAlongPath(component=gf.c.via1(), spacing=5, padding=2, offset=-2)\n","x = gf.CrossSection(\n","    width=0.5,\n","    offset=0,\n","    layer=(1, 0),\n","    port_names=(\"in\", \"out\"),\n","    vias=[via0, viap, vian],\n",")\n","\n","# Combine the path with the cross-section\n","c = gf.path.extrude(p, cross_section=x)\n","c.plot()"],"id":"abff41ca"},{"cell_type":"markdown","metadata":{"id":"f54c0294"},"source":["## Building Paths quickly\n","\n","You can pass `append()` lists of path segments.  This makes it easy to combine\n","paths very quickly.  Below we show 3 examples using this functionality:\n","\n","**Example 1:** Assemble a complex path by making a list of Paths and passing it\n","to `append()`"],"id":"f54c0294"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a49efc48"},"outputs":[],"source":["P = gf.Path()\n","\n","# Create the basic Path components\n","left_turn = gf.path.euler(radius=4, angle=90)\n","right_turn = gf.path.euler(radius=4, angle=-90)\n","straight = gf.path.straight(length=10)\n","\n","# Assemble a complex path by making list of Paths and passing it to `append()`\n","P.append(\n","    [\n","        straight,\n","        left_turn,\n","        straight,\n","        right_turn,\n","        straight,\n","        straight,\n","        right_turn,\n","        left_turn,\n","        straight,\n","    ]\n",")\n","\n","f = P.plot()"],"id":"a49efc48"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a68ad58c"},"outputs":[],"source":["P = (\n","    straight\n","    + left_turn\n","    + straight\n","    + right_turn\n","    + straight\n","    + straight\n","    + right_turn\n","    + left_turn\n","    + straight\n",")\n","f = P.plot()"],"id":"a68ad58c"},{"cell_type":"markdown","metadata":{"id":"b52bafad"},"source":["**Example 2:** Create an \"S-turn\" just by making a list of `[left_turn,\n","right_turn]`"],"id":"b52bafad"},{"cell_type":"code","execution_count":null,"metadata":{"id":"5007e6b9"},"outputs":[],"source":["P = gf.Path()\n","\n","# Create an \"S-turn\" just by making a list\n","s_turn = [left_turn, right_turn]\n","\n","P.append(s_turn)\n","f = P.plot()"],"id":"5007e6b9"},{"cell_type":"markdown","metadata":{"id":"e0d9a917"},"source":["**Example 3:** Repeat the S-turn 3 times by nesting our S-turn list in another\n","list"],"id":"e0d9a917"},{"cell_type":"code","execution_count":null,"metadata":{"id":"ec4f37e4"},"outputs":[],"source":["P = gf.Path()\n","\n","# Create an \"S-turn\" using a list\n","s_turn = [left_turn, right_turn]\n","\n","# Repeat the S-turn 3 times by nesting our S-turn list 3x times in another list\n","triple_s_turn = [s_turn, s_turn, s_turn]\n","\n","P.append(triple_s_turn)\n","f = P.plot()"],"id":"ec4f37e4"},{"cell_type":"markdown","metadata":{"id":"e549b763"},"source":["Note you can also use the Path() constructor to immediately construct your Path:"],"id":"e549b763"},{"cell_type":"code","execution_count":null,"metadata":{"id":"2faddafb"},"outputs":[],"source":["P = gf.Path([straight, left_turn, straight, right_turn, straight])\n","f = P.plot()"],"id":"2faddafb"},{"cell_type":"markdown","metadata":{"id":"0a366377"},"source":["## Waypoint smooth paths\n","\n","You can also build smooth paths between waypoints with the `smooth()` function"],"id":"0a366377"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c0a3d215"},"outputs":[],"source":["points = np.array([(20, 10), (40, 10), (20, 40), (50, 40), (50, 20), (70, 20)])\n","plt.plot(points[:, 0], points[:, 1], \".-\")\n","plt.axis(\"equal\")"],"id":"c0a3d215"},{"cell_type":"code","execution_count":null,"metadata":{"id":"7ac3e8ab"},"outputs":[],"source":["points = np.array([(20, 10), (40, 10), (20, 40), (50, 40), (50, 20), (70, 20)])\n","\n","P = gf.path.smooth(\n","    points=points,\n","    radius=2,\n","    bend=gf.path.euler,  # Alternatively, use pp.arc\n","    use_eff=False,\n",")\n","f = P.plot()"],"id":"7ac3e8ab"},{"cell_type":"markdown","metadata":{"id":"c38ad2de"},"source":["## Waypoint sharp paths\n","\n","It's also possible to make more traditional angular paths (e.g. electrical wires) in a few different ways.\n","\n","**Example 1:** Using a simple list of points"],"id":"c38ad2de"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f600bf32"},"outputs":[],"source":["P = gf.Path([(20, 10), (30, 10), (40, 30), (50, 30), (50, 20), (70, 20)])\n","f = P.plot()"],"id":"f600bf32"},{"cell_type":"markdown","metadata":{"id":"a59758b9"},"source":["**Example 2:** Using the \"turn and move\" method, where you manipulate the end angle of the Path so that when you append points to it, they're in the correct direction.  *Note: It is crucial that the number of points per straight section is set to 2 (`gf.path.straight(length, num_pts = 2)`) otherwise the extrusion algorithm will show defects.*"],"id":"a59758b9"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a207e813"},"outputs":[],"source":["P = gf.Path()\n","P += gf.path.straight(length=10, npoints=2)\n","P.end_angle += 90  # \"Turn\" 90 deg (left)\n","P += gf.path.straight(length=10, npoints=2)  # \"Walk\" length of 10\n","P.end_angle += -135  # \"Turn\" -135 degrees (right)\n","P += gf.path.straight(length=15, npoints=2)  # \"Walk\" length of 10\n","P.end_angle = 0  # Force the direction to be 0 degrees\n","P += gf.path.straight(length=10, npoints=2)  # \"Walk\" length of 10\n","f = P.plot()"],"id":"a207e813"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"57aed261"},"outputs":[],"source":["s1 = gf.Section(width=1.5, offset=2.5, layer=(2, 0))\n","s2 = gf.Section(width=1.5, offset=-2.5, layer=(3, 0))\n","X = gf.CrossSection(width=1, offset=0, layer=(1, 0), sections=[s1, s2])\n","component = gf.path.extrude(P, X)\n","component.plot()"],"id":"57aed261"},{"cell_type":"markdown","metadata":{"lines_to_next_cell":2,"id":"1bec4c0b"},"source":["## Custom curves\n","\n","Now let's have some fun and try to make a loop-de-loop structure with parallel\n","straights and several Ports.\n","\n","To create a new type of curve we simply make a function that produces an array\n","of points.  The best way to do that is to create a function which allows you to\n","specify a large number of points along that curve -- in the case below, the\n","`looploop()` function outputs 1000 points along a looping path.  Later, if we\n","want reduce the number of points in our geometry we can trivially `simplify` the\n","path.\n"],"id":"1bec4c0b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"7a33ddab"},"outputs":[],"source":["def looploop(num_pts=1000):\n","    \"\"\"Simple limacon looping curve\"\"\"\n","    t = np.linspace(-np.pi, 0, num_pts)\n","    r = 20 + 25 * np.sin(t)\n","    x = r * np.cos(t)\n","    y = r * np.sin(t)\n","    return np.array((x, y)).T\n","\n","\n","# Create the path points\n","P = gf.Path()\n","P.append(gf.path.arc(radius=10, angle=90))\n","P.append(gf.path.straight())\n","P.append(gf.path.arc(radius=5, angle=-90))\n","P.append(looploop(num_pts=1000))\n","P.rotate(-45)\n","\n","# Create the crosssection\n","s1 = gf.Section(width=0.5, offset=2, layer=(2, 0))\n","s2 = gf.Section(width=0.5, offset=4, layer=(3, 0))\n","s3 = gf.Section(width=1, offset=0, layer=(4, 0))\n","X = gf.CrossSection(\n","    width=1.5, offset=0, layer=(1, 0), port_names=[\"in\", \"out\"], sections=[s1, s2, s3]\n",")\n","\n","c = gf.path.extrude(P, X)\n","c.plot()"],"id":"7a33ddab"},{"cell_type":"markdown","metadata":{"id":"e97259b0"},"source":["You can create Paths from any array of points -- just be sure that they form\n","smooth curves!  If we examine our path `P` we can see that all we've simply\n","created a long list of points:"],"id":"e97259b0"},{"cell_type":"code","execution_count":null,"metadata":{"id":"5fb9bdad"},"outputs":[],"source":["path_points = P.points  # Curve points are stored as a numpy array in P.points\n","print(np.shape(path_points))  # The shape of the array is Nx2\n","print(len(P))  # Equivalently, use len(P) to see how many points are inside"],"id":"5fb9bdad"},{"cell_type":"code","source":[],"metadata":{"id":"LhVaN-Dkru5C"},"id":"LhVaN-Dkru5C","execution_count":null,"outputs":[]},{"cell_type":"code","source":[],"metadata":{"id":"bSw27h65sx1c"},"id":"bSw27h65sx1c","execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"ccdffd91"},"source":["# Shapes and generic cells\n","\n","gdsfactory provides some generic parametric cells in `gf.components` that you can customize for your application."],"id":"ccdffd91"},{"cell_type":"markdown","metadata":{"id":"d69cce15"},"source":["## Basic shapes"],"id":"d69cce15"},{"cell_type":"markdown","metadata":{"id":"a3a6990f"},"source":["### Rectangle\n","\n","To create a simple rectangle, there are two functions:\n","\n","``gf.components.rectangle()`` can create a basic rectangle:"],"id":"a3a6990f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"35de5398"},"outputs":[],"source":["import gdsfactory as gf\n","from gdsfactory.generic_tech import get_generic_pdk\n","\n","gf.config.rich_output()\n","\n","PDK = get_generic_pdk()\n","PDK.activate()\n","\n","r1 = gf.components.rectangle(size=(4.5, 2), layer=(1, 0))\n","r1"],"id":"35de5398"},{"cell_type":"markdown","metadata":{"id":"bf3d5854"},"source":["``gf.components.bbox()`` can also create a rectangle based on a bounding box.\n","This is useful if you want to create a rectangle which exactly surrounds a piece of existing geometry.\n","For example, if we have an arc geometry and we want to define a box around it, we can use ``gf.components.bbox()``:"],"id":"bf3d5854"},{"cell_type":"code","execution_count":null,"metadata":{"id":"3be8e4fe"},"outputs":[],"source":["c = gf.Component()\n","arc = c << gf.components.bend_circular(radius=10, width=0.5, angle=90, layer=(1, 0))\n","arc.rotate(90)\n","# Draw a rectangle around the arc we created by using the arc's bounding box\n","rect = c << gf.components.bbox(bbox=arc.bbox, layer=(0, 0))\n","c.plot()"],"id":"3be8e4fe"},{"cell_type":"markdown","metadata":{"id":"a0ab8177"},"source":["### Cross\n","\n","The ``gf.components.cross()`` function creates a cross structure:"],"id":"a0ab8177"},{"cell_type":"code","execution_count":null,"metadata":{"id":"781466d3"},"outputs":[],"source":["gf.components.cross(length=10, width=0.5, layer=(1, 0))"],"id":"781466d3"},{"cell_type":"markdown","metadata":{"id":"6377f034"},"source":["### Ellipse\n","\n","The ``gf.components.ellipse()`` function creates an ellipse by defining the major and minor radii:"],"id":"6377f034"},{"cell_type":"code","execution_count":null,"metadata":{"id":"9b013a01"},"outputs":[],"source":["gf.components.ellipse(radii=(10, 5), angle_resolution=2.5, layer=(1, 0))"],"id":"9b013a01"},{"cell_type":"markdown","metadata":{"id":"0ae228b9"},"source":["### Circle\n","\n","The ``gf.components.circle()`` function creates a circle:"],"id":"0ae228b9"},{"cell_type":"code","execution_count":null,"metadata":{"id":"bce14d03"},"outputs":[],"source":["gf.components.circle(radius=10, angle_resolution=2.5, layer=(1, 0))"],"id":"bce14d03"},{"cell_type":"markdown","metadata":{"id":"0271befb"},"source":["### Ring\n","\n","The ``gf.components.ring()`` function creates a ring.  The radius refers to the center radius of the ring structure (halfway between the inner and outer radius)."],"id":"0271befb"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4eca3bf6"},"outputs":[],"source":["gf.components.ring(radius=5, width=0.5, angle_resolution=2.5, layer=(1, 0))"],"id":"4eca3bf6"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a2c4b9e5"},"outputs":[],"source":["gf.components.ring_single(\n","    width=0.5, gap=0.2, radius=10, length_x=4, length_y=2, layer=(1, 0)\n",")"],"id":"a2c4b9e5"},{"cell_type":"code","execution_count":null,"metadata":{"id":"9073db49"},"outputs":[],"source":["import gdsfactory as gf\n","\n","gf.components.ring_double(\n","    width=0.5, gap=0.2, radius=10, length_x=4, length_y=2, layer=(1, 0)\n",")"],"id":"9073db49"},{"cell_type":"code","execution_count":null,"metadata":{"id":"2722a19c"},"outputs":[],"source":["gf.components.ring_double(\n","    width=0.5,\n","    gap=0.2,\n","    radius=10,\n","    length_x=4,\n","    length_y=2,\n","    layer=(1, 0),\n","    bend=gf.components.bend_circular,\n",")"],"id":"2722a19c"},{"cell_type":"markdown","metadata":{"id":"4cba1a0a"},"source":["### Bend circular\n","\n","The ``gf.components.bend_circular()`` function creates an arc.  The radius refers to the center radius of the arc (halfway between the inner and outer radius)."],"id":"4cba1a0a"},{"cell_type":"code","execution_count":null,"metadata":{"id":"2e57add3"},"outputs":[],"source":["gf.components.bend_circular(radius=2.0, width=0.5, angle=90, npoints=720, layer=(1, 0))"],"id":"2e57add3"},{"cell_type":"markdown","metadata":{"id":"f81055a6"},"source":["### Bend euler\n","\n","The ``gf.components.bend_euler()`` function creates an adiabatic bend in which the bend radius changes gradually. Euler bends have lower loss than circular bends.\n"],"id":"f81055a6"},{"cell_type":"code","execution_count":null,"metadata":{"id":"dd29182f"},"outputs":[],"source":["gf.components.bend_euler(radius=2.0, width=0.5, angle=90, npoints=720, layer=(1, 0))"],"id":"dd29182f"},{"cell_type":"markdown","metadata":{"id":"52fe4c69"},"source":["### Tapers\n","\n","`gf.components.taper()`is defined by setting its length and its start and end length.  It has two ports, ``1`` and ``2``, on either end, allowing you to easily connect it to other structures."],"id":"52fe4c69"},{"cell_type":"code","execution_count":null,"metadata":{"id":"993424a6"},"outputs":[],"source":["gf.components.taper(length=10, width1=6, width2=4, port=None, layer=(1, 0))"],"id":"993424a6"},{"cell_type":"markdown","metadata":{"id":"9fefcf92"},"source":["`gf.components.ramp()` is a structure is similar to `taper()` except it is asymmetric.  It also has two ports, ``1`` and ``2``, on either end."],"id":"9fefcf92"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a8351e44"},"outputs":[],"source":["gf.components.ramp(length=10, width1=4, width2=8, layer=(1, 0))"],"id":"a8351e44"},{"cell_type":"markdown","metadata":{"id":"ae94418c"},"source":["### Common compound shapes"],"id":"ae94418c"},{"cell_type":"markdown","metadata":{"id":"7394e7b4"},"source":["The `gf.components.L()` function creates a \"L\" shape with ports on either end named ``1`` and ``2``."],"id":"7394e7b4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"54765670"},"outputs":[],"source":["gf.components.L(width=7, size=(10, 20), layer=(1, 0))"],"id":"54765670"},{"cell_type":"markdown","metadata":{"id":"273120ed"},"source":["The `gf.components.C()` function creates a \"C\" shape with ports on either end named ``1`` and ``2``."],"id":"273120ed"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4e4021d9"},"outputs":[],"source":["gf.components.C(width=7, size=(10, 20), layer=(1, 0))"],"id":"4e4021d9"},{"cell_type":"markdown","metadata":{"id":"6318543b"},"source":["## Text\n","\n","Gdsfactory has an implementation of the DEPLOF font with the majority of english ASCII characters represented (thanks to phidl)"],"id":"6318543b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"3ed6c2e3"},"outputs":[],"source":["gf.components.text(\n","    text=\"Hello world!\\nMultiline text\\nLeft-justified\",\n","    size=10,\n","    justify=\"left\",\n","    layer=(1, 0),\n",")\n","# `justify` should be either 'left', 'center', or 'right'"],"id":"3ed6c2e3"},{"cell_type":"markdown","metadata":{"id":"bb3bc9e6"},"source":["## Lithography structures\n","\n","### Step-resolution\n","\n","The `gf.components.litho_steps()` function creates lithographic test structure that is useful for measuring resolution of photoresist or electron-beam resists.  It provides both positive-tone and negative-tone resolution tests."],"id":"bb3bc9e6"},{"cell_type":"code","execution_count":null,"metadata":{"id":"95bc0330"},"outputs":[],"source":["D = gf.components.litho_steps(\n","    line_widths=[1, 2, 4, 8, 16], line_spacing=10, height=100, layer=(1, 0)\n",")\n","D.plot()"],"id":"95bc0330"},{"cell_type":"markdown","metadata":{"id":"a5a831a2"},"source":["### Calipers (inter-layer alignment)"],"id":"a5a831a2"},{"cell_type":"markdown","metadata":{"id":"c8e7923b"},"source":["The `gf.components.litho_calipers()` function is used to detect offsets in multilayer fabrication.  It creates a two sets of notches on different layers.  When an fabrication error/offset occurs, it is easy to detect how much the offset is because both center-notches are no longer aligned."],"id":"c8e7923b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"cd5f2da9"},"outputs":[],"source":["D = gf.components.litho_calipers(\n","    notch_size=[1, 5],\n","    notch_spacing=2,\n","    num_notches=7,\n","    offset_per_notch=0.1,\n","    row_spacing=0,\n","    layer1=(1, 0),\n","    layer2=(2, 0),\n",")\n","D.plot()"],"id":"cd5f2da9"},{"cell_type":"markdown","metadata":{"id":"7de695e2"},"source":["## Paths\n","\n","See **Path tutorial** for more details -- this is just an enumeration of the available built-in Path functions"],"id":"7de695e2"},{"cell_type":"markdown","metadata":{"id":"3ca391bf"},"source":["### Circular arc"],"id":"3ca391bf"},{"cell_type":"code","execution_count":null,"metadata":{"id":"d53acc4b"},"outputs":[],"source":["P = gf.path.arc(radius=10, angle=135, npoints=720)\n","f = P.plot()"],"id":"d53acc4b"},{"cell_type":"markdown","metadata":{"id":"bf27793e"},"source":["### Straight"],"id":"bf27793e"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4de59917"},"outputs":[],"source":["import gdsfactory as gf\n","\n","P = gf.path.straight(length=5, npoints=100)\n","f = P.plot()"],"id":"4de59917"},{"cell_type":"markdown","metadata":{"id":"01c6d976"},"source":["### Euler curve\n","\n","Also known as a straight-to-bend, clothoid, racetrack, or track transition, this Path tapers adiabatically from straight to curved.  Often used to minimize losses in photonic straights.  If `p < 1.0`, will create a \"partial euler\" curve as described in Vogelbacher et. al. https://dx.doi.org/10.1364/oe.27.031394.  If the `use_eff` argument is false, `radius` corresponds to minimum radius of curvature of the bend.  If `use_eff`  is true, `radius` corresponds to the \"effective\" radius of the bend-- The curve will be scaled such that the endpoints match an arc with parameters `radius` and `angle`."],"id":"01c6d976"},{"cell_type":"code","execution_count":null,"metadata":{"id":"df25d2ce"},"outputs":[],"source":["P = gf.path.euler(radius=3, angle=90, p=1.0, use_eff=False, npoints=720)\n","f = P.plot()"],"id":"df25d2ce"},{"cell_type":"markdown","metadata":{"id":"6b2b4fee"},"source":["### Smooth path from waypoints"],"id":"6b2b4fee"},{"cell_type":"code","execution_count":null,"metadata":{"id":"94beafe2"},"outputs":[],"source":["import numpy as np\n","\n","import gdsfactory as gf\n","\n","points = np.array([(20, 10), (40, 10), (20, 40), (50, 40), (50, 20), (70, 20)])\n","\n","P = gf.path.smooth(\n","    points=points,\n","    radius=2,\n","    bend=gf.path.euler,\n","    use_eff=False,\n",")\n","f = P.plot()"],"id":"94beafe2"},{"cell_type":"markdown","metadata":{"id":"ab4dd7c9"},"source":["### Delay spiral"],"id":"ab4dd7c9"},{"cell_type":"code","execution_count":null,"metadata":{"id":"7791f5f1"},"outputs":[],"source":["c = gf.components.spiral_double()\n","c.plot()"],"id":"7791f5f1"},{"cell_type":"code","execution_count":null,"metadata":{"id":"9deb4072"},"outputs":[],"source":["c = gf.components.spiral_inner_io()\n","c.plot()"],"id":"9deb4072"},{"cell_type":"code","execution_count":null,"metadata":{"id":"ad599864"},"outputs":[],"source":["c = gf.components.spiral_external_io()\n","c.plot()"],"id":"ad599864"},{"cell_type":"markdown","metadata":{"id":"0899df44"},"source":["## Useful contact pads / connectors\n","\n","These functions are common shapes with ports, often used to make contact pads"],"id":"0899df44"},{"cell_type":"code","execution_count":null,"metadata":{"id":"711bbf42"},"outputs":[],"source":["c = gf.components.compass(size=(4, 2), layer=(1, 0))\n","c.plot()"],"id":"711bbf42"},{"cell_type":"code","execution_count":null,"metadata":{"id":"52f75bf1"},"outputs":[],"source":["c = gf.components.nxn(north=3, south=4, east=0, west=0)\n","c.plot()"],"id":"52f75bf1"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4a2e468a"},"outputs":[],"source":["c = gf.components.pad()\n","c.plot()"],"id":"4a2e468a"},{"cell_type":"code","execution_count":null,"metadata":{"id":"103efdad"},"outputs":[],"source":["c = gf.components.pad_array90(columns=3)\n","c.plot()"],"id":"103efdad"},{"cell_type":"markdown","metadata":{"id":"bda78006"},"source":["## Chip / die template"],"id":"bda78006"},{"cell_type":"code","execution_count":null,"metadata":{"id":"20bfd039"},"outputs":[],"source":["import gdsfactory as gf\n","\n","D = gf.components.die(\n","    size=(10000, 5000),  # Size of die\n","    street_width=100,  # Width of corner marks for die-sawing\n","    street_length=1000,  # Length of corner marks for die-sawing\n","    die_name=\"chip99\",  # Label text\n","    text_size=500,  # Label text size\n","    text_location=\"SW\",  # Label text compass location e.g. 'S', 'SE', 'SW'\n","    layer=(2, 0),\n","    bbox_layer=(3, 0),\n",")\n","D"],"id":"20bfd039"},{"cell_type":"markdown","metadata":{"id":"9b3ef85e"},"source":["## Optimal superconducting curves\n","\n","The following structures are meant to reduce \"current crowding\" in superconducting thin-film structures (such as superconducting nanowires).\n","They are the result of conformal mapping equations derived in  Clem, J. & Berggren, K. \"[Geometry-dependent critical currents in superconducting nanocircuits.\" Phys. Rev. B 84, 1–27 (2011).](http://dx.doi.org/10.1103/PhysRevB.84.174510)"],"id":"9b3ef85e"},{"cell_type":"code","execution_count":null,"metadata":{"id":"ee8e5b79"},"outputs":[],"source":["import gdsfactory as gf\n","\n","c = gf.components.optimal_hairpin(\n","    width=0.2, pitch=0.6, length=10, turn_ratio=4, num_pts=50, layer=(2, 0)\n",")\n","c.plot()"],"id":"ee8e5b79"},{"cell_type":"code","execution_count":null,"metadata":{"id":"9f8a2a57"},"outputs":[],"source":["c = gf.c.optimal_step(\n","    start_width=10,\n","    end_width=22,\n","    num_pts=50,\n","    width_tol=1e-3,\n","    anticrowding_factor=1.2,\n","    symmetric=False,\n","    layer=(2, 0),\n",")\n","c.plot()"],"id":"9f8a2a57"},{"cell_type":"code","execution_count":null,"metadata":{"id":"51bd9c6c"},"outputs":[],"source":["c = gf.c.optimal_90deg(width=100.0, num_pts=15, length_adjust=1, layer=(2, 0))\n","c.plot()"],"id":"51bd9c6c"},{"cell_type":"code","execution_count":null,"metadata":{"id":"04ca11ee"},"outputs":[],"source":["c = gf.c.snspd(\n","    wire_width=0.2,\n","    wire_pitch=0.6,\n","    size=(10, 8),\n","    num_squares=None,\n","    turn_ratio=4,\n","    terminals_same_side=False,\n","    layer=(2, 0),\n",")\n","c.plot()"],"id":"04ca11ee"},{"cell_type":"markdown","metadata":{"id":"d0ceca27"},"source":["# Geometry\n","\n","gdsfactory provides you with some geometric functions"],"id":"d0ceca27"},{"cell_type":"markdown","metadata":{"id":"ce6fb437"},"source":["## Boolean / outline / offset / invert\n","There are several common boolean-type operations available in the geometry library.  These include typical boolean operations (and/or/not/xor), offsetting (expanding/shrinking polygons), outlining, and inverting."],"id":"ce6fb437"},{"cell_type":"markdown","metadata":{"id":"be279223"},"source":["### Boolean\n","\n","\n","The ``gf.geometry.boolean()`` function can perform AND/OR/NOT/XOR operations, and will return a new geometry with the result of that operation."],"id":"be279223"},{"cell_type":"code","execution_count":null,"metadata":{"id":"X_h4y-4YrvVd"},"outputs":[],"source":["import gdsfactory as gf\n","\n","E = gf.components.ellipse(radii=(10, 5), layer=(1, 0))\n","R = gf.components.rectangle(size=[15, 5], layer=(2, 0))\n","C = gf.geometry.boolean(A=E, B=R, operation=\"not\", precision=1e-6, layer=(3, 0))\n","# Other operations include 'and', 'or', 'xor', or equivalently 'A-B', 'B-A', 'A+B'\n","\n","# Plot the originals and the result\n","D = gf.Component(\"bool\")\n","D.add_ref(E)\n","D.add_ref(R).movey(-1.5)\n","D.add_ref(C).movex(30)\n","D.plot()"],"id":"X_h4y-4YrvVd"},{"cell_type":"markdown","metadata":{"id":"708b681a"},"source":["To learn how booleans work you can try all the different operations `not`, `and`, `or`, `xor`"],"id":"708b681a"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c4cc4d0e"},"outputs":[],"source":["import gdsfactory as gf\n","\n","operation = \"not\"\n","operation = \"and\"\n","operation = \"or\"\n","operation = \"xor\"\n","\n","r1 = (8, 8)\n","r2 = (11, 4)\n","r1 = (80, 80)\n","r2 = (110, 40)\n","\n","angle_resolution = 0.1\n","\n","c1 = gf.components.ellipse(radii=r1, layer=(1, 0), angle_resolution=angle_resolution)\n","c2 = gf.components.ellipse(radii=r2, layer=(1, 0), angle_resolution=angle_resolution)"],"id":"c4cc4d0e"},{"cell_type":"code","execution_count":null,"metadata":{"id":"87e2c1b1"},"outputs":[],"source":["%time\n","\n","c3 = gf.geometry.boolean_klayout(\n","    c1, c2, operation=operation, layer1=(1, 0), layer2=(1, 0), layer3=(1, 0)\n",")  # KLayout booleans\n","c3.plot()"],"id":"87e2c1b1"},{"cell_type":"code","execution_count":null,"metadata":{"id":"30de3cc1"},"outputs":[],"source":["%time\n","c4 = gf.geometry.boolean(c1, c2, operation=operation)\n","c4.plot()"],"id":"30de3cc1"},{"cell_type":"markdown","metadata":{"id":"a2fa5a25"},"source":["### Offset\n","\n","The ``offset()`` function takes the polygons of the input geometry, combines them together, and expands/contracts them.\n","The function returns polygons on a single layer and does not respect layers."],"id":"a2fa5a25"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c63ac1b9"},"outputs":[],"source":["import gdsfactory as gf\n","\n","# Create `T`, an ellipse and rectangle which will be offset (expanded / contracted)\n","T = gf.Component(\"ellipse_and_rectangle\")\n","e = T << gf.components.ellipse(radii=(10, 5), layer=(1, 0))\n","r = T << gf.components.rectangle(size=[15, 5], layer=(2, 0))\n","r.move([3, -2.5])\n","\n","Texpanded = gf.geometry.offset(T, distance=2, precision=1e-6, layer=(2, 0))\n","Texpanded.name = \"expanded\"\n","Tshrink = gf.geometry.offset(T, distance=-1.5, precision=1e-6, layer=(2, 0))\n","Tshrink.name = \"shrink\"\n","\n","# Plot the original geometry, the expanded, and the shrunk versions\n","offsets = gf.Component(\"top\")\n","t1 = offsets.add_ref(T)\n","t2 = offsets.add_ref(Texpanded)\n","t3 = offsets.add_ref(Tshrink)\n","offsets.distribute([t1, t2, t3], direction=\"x\", spacing=5)\n","offsets"],"id":"c63ac1b9"},{"cell_type":"markdown","metadata":{"id":"dfc0cfe2"},"source":["`gf.geometry.offset` is also useful for remove acute angle DRC errors.\n","\n","You can do a positive offset to grow the polygons followed by a negative offset."],"id":"dfc0cfe2"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"bf3f6452"},"outputs":[],"source":["c = gf.Component(\"demo_dataprep\")\n","c1 = gf.components.coupler_ring(cladding_layers=[(2, 0)], cladding_offsets=[0.5])\n","d = 0.8\n","c2 = gf.geometry.offset(c1, distance=+d, layer=(2, 0))\n","c3 = gf.geometry.offset(c2, distance=-d, layer=(2, 0))\n","c << c1\n","c << c3\n","c.plot()"],"id":"bf3f6452"},{"cell_type":"markdown","metadata":{"id":"e2a63141"},"source":["### Outline\n","\n","The ``outline()`` function takes the polygons of the input geometry then performs an offset and \"not\" boolean operation to create an outline.  The function returns polygons on a single layer -- it does not respect layers."],"id":"e2a63141"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c12944e0"},"outputs":[],"source":["import gdsfactory as gf\n","\n","# Create a blank device and add two shapes\n","X = gf.Component(\"outline_demo\")\n","X.add_ref(gf.components.cross(length=25, width=1, layer=(1, 0)))\n","X.add_ref(gf.components.ellipse(radii=[10, 5], layer=(2, 0)))\n","\n","O = gf.geometry.outline(X, distance=1.5, precision=1e-6, layer=(3, 0))\n","\n","# Plot the original geometry and the result\n","c = gf.Component(\"outline_compare\")\n","c.add_ref(X)\n","c.add_ref(O).movex(30)\n","c.plot()"],"id":"c12944e0"},{"cell_type":"markdown","metadata":{"id":"43b7bb15"},"source":["The ``open_ports`` argument opens holes in the outlined geometry at each Port location.\n","\n","- If not False, holes will be cut in the outline such that the Ports are not covered.\n","- If True, the holes will have the same width as the Ports.\n","- If a float, the holes will be widened by that value.\n","- If a float equal to the outline ``distance``, the outline will be flush with the port (useful positive-tone processes)."],"id":"43b7bb15"},{"cell_type":"code","execution_count":null,"metadata":{"id":"3d214535"},"outputs":[],"source":["gf.components.L(width=7, size=(10, 20), layer=(1, 0))"],"id":"3d214535"},{"cell_type":"code","execution_count":null,"metadata":{"id":"36907613"},"outputs":[],"source":["# Outline the geometry and open a hole at each port\n","gf.geometry.outline(offsets, distance=5, open_ports=False, layer=(2, 0))  # No holes"],"id":"36907613"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f9ac805d"},"outputs":[],"source":["gf.geometry.outline(\n","    offsets, distance=5, open_ports=True, layer=(2, 0)\n",")  # Hole is the same width as the port"],"id":"f9ac805d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"2b03aa4b"},"outputs":[],"source":["gf.geometry.outline(\n","    offsets, distance=5, open_ports=10, layer=(2, 0)\n",")  # Change the hole size by entering a float"],"id":"2b03aa4b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"02433196"},"outputs":[],"source":["gf.geometry.outline(\n","    offsets, distance=5, open_ports=5, layer=(2, 0)\n",")  # Creates flush opening (open_ports > distance)"],"id":"02433196"},{"cell_type":"markdown","metadata":{"id":"d5d1b5b2"},"source":["### Invert\n","\n","The ``gf.boolean.invert()`` function creates an inverted version of the input geometry.  The function creates a rectangle around the geometry (with extra padding of distance ``border``), then subtract all polygons from all layers from that rectangle, resulting in an inverted version of the geometry."],"id":"d5d1b5b2"},{"cell_type":"code","execution_count":null,"metadata":{"id":"33950ca5"},"outputs":[],"source":["import gdsfactory as gf\n","\n","E = gf.components.ellipse(radii=(10, 5))\n","D = gf.geometry.invert(E, border=0.5, precision=1e-6, layer=(2, 0))\n","D.plot()"],"id":"33950ca5"},{"cell_type":"markdown","metadata":{"id":"11d3ab04"},"source":["### Union\n","\n","The ``union()`` function is a \"join\" function, and is functionally identical to the \"OR\" operation of ``gf.boolean()``.  The one difference is it's able to perform this function layer-wise, so each layer can be individually combined."],"id":"11d3ab04"},{"cell_type":"code","execution_count":null,"metadata":{"id":"8ef38cfd"},"outputs":[],"source":["import gdsfactory as gf\n","\n","D = gf.Component(\"union\")\n","e0 = D << gf.components.ellipse(layer=(1, 0))\n","e1 = D << gf.components.ellipse(layer=(2, 0))\n","e2 = D << gf.components.ellipse(layer=(3, 0))\n","e3 = D << gf.components.ellipse(layer=(4, 0))\n","e4 = D << gf.components.ellipse(layer=(5, 0))\n","e5 = D << gf.components.ellipse(layer=(6, 0))\n","\n","e1.rotate(15 * 1)\n","e2.rotate(15 * 2)\n","e3.rotate(15 * 3)\n","e4.rotate(15 * 4)\n","e5.rotate(15 * 5)\n","\n","D.plot()"],"id":"8ef38cfd"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f46c3b8a"},"outputs":[],"source":["# We have two options to unioning - take all polygons, regardless of\n","# layer, and join them together (in this case on layer (2,0) like so:\n","D_joined = gf.geometry.union(D, by_layer=False, layer=(2, 0))\n","D_joined"],"id":"f46c3b8a"},{"cell_type":"code","execution_count":null,"metadata":{"id":"199da361"},"outputs":[],"source":["# Or we can perform the union operate by-layer\n","D_joined_by_layer = gf.geometry.union(D, by_layer=True)\n","D_joined_by_layer"],"id":"199da361"},{"cell_type":"markdown","metadata":{"id":"875b9b52"},"source":["### XOR / diff\n","\n","The ``xor_diff()`` function can be used to compare two geometries and identify where they are different.  Specifically, it performs a layer-wise XOR operation.  If two geometries are identical, the result will be an empty Component.  If they are not identical, any areas not shared by the two geometries will remain."],"id":"875b9b52"},{"cell_type":"code","execution_count":null,"metadata":{"id":"2c7c0adc"},"outputs":[],"source":["import gdsfactory as gf\n","\n","A = gf.Component(\"A\")\n","A.add_ref(gf.components.ellipse(radii=[10, 5], layer=(1, 0)))\n","A.add_ref(gf.components.text(\"A\")).move([3, 0])\n","\n","B = gf.Component(\"B\")\n","B.add_ref(gf.components.ellipse(radii=[11, 4], layer=(1, 0))).movex(4)\n","B.add_ref(gf.components.text(\"B\")).move([3.2, 0])\n","X = gf.geometry.xor_diff(A=A, B=B, precision=1e-6)\n","\n","# Plot the original geometry and the result\n","# Upper left: A / Upper right: B\n","# Lower left: A and B / Lower right: A xor B \"diff\" comparison\n","D = gf.Component(\"xor_diff\")\n","D.add_ref(A).move([-15, 25])\n","D.add_ref(B).move([15, 25])\n","D.add_ref(A).movex(-15)\n","D.add_ref(B).movex(-15)\n","D.add_ref(X).movex(15)\n","D.plot()"],"id":"2c7c0adc"},{"cell_type":"code","source":[],"metadata":{"id":"FMa39X7Wr6Wq"},"id":"FMa39X7Wr6Wq","execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"6f31040c"},"source":["# Grid / pack / align / distribute"],"id":"6f31040c"},{"cell_type":"markdown","metadata":{"id":"bc9158ad"},"source":["## Grid\n","\n","\n","The ``gf.components.grid()`` function can take a list (or 2D array) of objects and arrange them along a grid. This is often useful for making parameter sweeps.   If the `separation` argument is true, grid is arranged such that the elements are guaranteed not to touch, with a `spacing` distance between them.  If `separation` is false, elements are spaced evenly along a grid. The `align_x`/`align_y` arguments specify intra-row/intra-column alignment.  The `edge_x`/`edge_y` arguments specify inter-row/inter-column alignment (unused if `separation = True`)."],"id":"bc9158ad"},{"cell_type":"code","execution_count":null,"metadata":{"id":"10adb8c2"},"outputs":[],"source":["import gdsfactory as gf\n","\n","components_list = []\n","for width1 in [1, 6, 9]:\n","    for width2 in [1, 2, 4, 8]:\n","        D = gf.components.taper(length=10, width1=width1, width2=width2, layer=(1, 0))\n","        components_list.append(D)\n","\n","c = gf.grid(\n","    components_list,\n","    spacing=(5, 1),\n","    separation=True,\n","    shape=(3, 4),\n","    align_x=\"x\",\n","    align_y=\"y\",\n","    edge_x=\"x\",\n","    edge_y=\"ymax\",\n",")\n","c.plot()"],"id":"10adb8c2"},{"cell_type":"markdown","metadata":{"id":"d208e6a4"},"source":["## Pack\n","\n","\n","The ``gf.pack()`` function packs geometries together into rectangular bins. If a ``max_size`` is specified, the function will create as many bins as is necessary to pack all the geometries and then return a list of the filled-bin Components.\n","\n","Here we generate several random shapes then pack them together automatically. We allow the bin to be as large as needed to fit all the Components by specifying ``max_size = (None, None)``.  By setting ``aspect_ratio = (2,1)``, we specify the rectangular bin it tries to pack them into should be twice as wide as it is tall:"],"id":"d208e6a4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"cf682313"},"outputs":[],"source":["import numpy as np\n","\n","import gdsfactory as gf\n","\n","np.random.seed(5)\n","D_list = [gf.components.rectangle(size=(i, i)) for i in range(1, 10)]\n","\n","D_packed_list = gf.pack(\n","    D_list,  # Must be a list or tuple of Components\n","    spacing=1.25,  # Minimum distance between adjacent shapes\n","    aspect_ratio=(2, 1),  # (width, height) ratio of the rectangular bin\n","    max_size=(None, None),  # Limits the size into which the shapes will be packed\n","    density=1.05,  # Values closer to 1 pack tighter but require more computation\n","    sort_by_area=True,  # Pre-sorts the shapes by area\n",")\n","D = D_packed_list[0]  # Only one bin was created, so we plot that\n","D"],"id":"cf682313"},{"cell_type":"markdown","metadata":{"id":"8fe88ea4"},"source":["Say we need to pack many shapes into multiple 500x500 unit die. If we set ``max_size = (500,500)`` the shapes will be packed into as many 500x500 unit die as required to fit them all:"],"id":"8fe88ea4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"b4da150a"},"outputs":[],"source":["np.random.seed(1)\n","D_list = [\n","    gf.components.ellipse(radii=tuple(np.random.rand(2) * n + 2)) for n in range(120)\n","]\n","D_packed_list = gf.pack(\n","    D_list,  # Must be a list or tuple of Components\n","    spacing=4,  # Minimum distance between adjacent shapes\n","    aspect_ratio=(1, 1),  # Shape of the box\n","    max_size=(500, 500),  # Limits the size into which the shapes will be packed\n","    density=1.05,  # Values closer to 1 pack tighter but require more computation\n","    sort_by_area=True,  # Pre-sorts the shapes by area\n",")\n","\n","# Put all packed bins into a single device and spread them out with distribute()\n","F = gf.Component(\"packed\")\n","[F.add_ref(D) for D in D_packed_list]\n","F.distribute(elements=\"all\", direction=\"x\", spacing=100, separation=True)\n","F"],"id":"b4da150a"},{"cell_type":"markdown","metadata":{"id":"e337e5b4"},"source":["Note that the packing problem is an NP-complete problem, so ``gf.components.packer()`` may be slow if there are more than a few hundred Components to pack (in that case, try pre-packing a few dozen at a time then packing the resulting bins). Requires the ``rectpack`` python package."],"id":"e337e5b4"},{"cell_type":"markdown","metadata":{"lines_to_next_cell":2,"id":"9b1749cc"},"source":["## Distribute\n","\n","\n","The ``distribute()`` function allows you to space out elements within a Component evenly in the x or y direction.  It is meant to duplicate the distribute functionality present in Inkscape / Adobe Illustrator:"],"id":"9b1749cc"},{"cell_type":"markdown","metadata":{"id":"c3bd98cf"},"source":["![](https://i.imgur.com/dC74M8x.png)"],"id":"c3bd98cf"},{"cell_type":"markdown","metadata":{"id":"a2a7019c"},"source":["Say we start out with a few random-sized rectangles we want to space out:"],"id":"a2a7019c"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4a20b0a6"},"outputs":[],"source":["c = gf.Component(\"rectangles\")\n","# Create different-sized rectangles and add them to D\n","[\n","    c.add_ref(\n","        gf.components.rectangle(size=[n * 15 + 20, n * 15 + 20], layer=(2, 0))\n","    ).move([n, n * 4])\n","    for n in [0, 2, 3, 1, 2]\n","]\n","c.plot()"],"id":"4a20b0a6"},{"cell_type":"markdown","metadata":{"id":"cbe0d9cc"},"source":["Oftentimes, we want to guarantee some distance between the objects.  By setting ``separation = True`` we move each object such that there is ``spacing`` distance between them:"],"id":"cbe0d9cc"},{"cell_type":"code","execution_count":null,"metadata":{"id":"be60b0af"},"outputs":[],"source":["D = gf.Component(\"rectangles_separated\")\n","# Create different-sized rectangles and add them to D\n","[\n","    D.add_ref(gf.components.rectangle(size=[n * 15 + 20, n * 15 + 20])).move((n, n * 4))\n","    for n in [0, 2, 3, 1, 2]\n","]\n","# Distribute all the rectangles in D along the x-direction with a separation of 5\n","D.distribute(\n","    elements=\"all\",  # either 'all' or a list of objects\n","    direction=\"x\",  # 'x' or 'y'\n","    spacing=5,\n","    separation=True,\n",")\n","D"],"id":"be60b0af"},{"cell_type":"markdown","metadata":{"id":"943f26b3"},"source":["Alternatively, we can spread them out on a fixed grid by setting ``separation = False``. Here we align the left edge (``edge = 'min'``) of each object along a grid spacing of 100:"],"id":"943f26b3"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c63156f3"},"outputs":[],"source":["D = gf.Component(\"spacing100\")\n","[\n","    D.add_ref(gf.components.rectangle(size=[n * 15 + 20, n * 15 + 20])).move((n, n * 4))\n","    for n in [0, 2, 3, 1, 2]\n","]\n","D.distribute(\n","    elements=\"all\", direction=\"x\", spacing=100, separation=False, edge=\"xmin\"\n",")  # edge must be either 'xmin' (left), 'xmax' (right), or 'x' (center)\n","D"],"id":"c63156f3"},{"cell_type":"markdown","metadata":{"id":"1669909f"},"source":["The alignment can be done along the right edge as well by setting ``edge = 'max'``, or along the center by setting ``edge = 'center'`` like in the following:"],"id":"1669909f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"7a13c698"},"outputs":[],"source":["D = gf.Component(\"alignment\")\n","[\n","    D.add_ref(gf.components.rectangle(size=[n * 15 + 20, n * 15 + 20])).move(\n","        (n - 10, n * 4)\n","    )\n","    for n in [0, 2, 3, 1, 2]\n","]\n","D.distribute(\n","    elements=\"all\", direction=\"x\", spacing=100, separation=False, edge=\"x\"\n",")  # edge must be either 'xmin' (left), 'xmax' (right), or 'x' (center)\n","D"],"id":"7a13c698"},{"cell_type":"markdown","metadata":{"id":"9f9e8603"},"source":["## Align\n","\n","\n","The ``align()`` function allows you to elements within a Component horizontally or vertically.  It is meant to duplicate the alignment functionality present in Inkscape / Adobe Illustrator:"],"id":"9f9e8603"},{"cell_type":"markdown","metadata":{"id":"280c89b0"},"source":["![](https://i.imgur.com/rqzunXM.png)"],"id":"280c89b0"},{"cell_type":"markdown","metadata":{"id":"c8054db0"},"source":["Say we ``distribute()`` a few objects, but they're all misaligned:"],"id":"c8054db0"},{"cell_type":"code","execution_count":null,"metadata":{"id":"52e8c94b"},"outputs":[],"source":["D = gf.Component(\"distribute\")\n","# Create different-sized rectangles and add them to D then distribute them\n","[\n","    D.add_ref(gf.components.rectangle(size=[n * 15 + 20, n * 15 + 20])).move((n, n * 4))\n","    for n in [0, 2, 3, 1, 2]\n","]\n","D.distribute(elements=\"all\", direction=\"x\", spacing=5, separation=True)\n","D"],"id":"52e8c94b"},{"cell_type":"markdown","metadata":{"id":"97c95038"},"source":["we can use the ``align()`` function to align their top edges (``alignment = 'ymax'):"],"id":"97c95038"},{"cell_type":"code","execution_count":null,"metadata":{"id":"0db7d1c6"},"outputs":[],"source":["D = gf.Component(\"align\")\n","# Create different-sized rectangles and add them to D then distribute them\n","[\n","    D.add_ref(gf.components.rectangle(size=[n * 15 + 20, n * 15 + 20])).move((n, n * 4))\n","    for n in [0, 2, 3, 1, 2]\n","]\n","D.distribute(elements=\"all\", direction=\"x\", spacing=5, separation=True)\n","\n","# Align top edges\n","D.align(elements=\"all\", alignment=\"ymax\")\n","D"],"id":"0db7d1c6"},{"cell_type":"markdown","metadata":{"id":"fcd47e6f"},"source":["or align their centers (``alignment = 'y'):"],"id":"fcd47e6f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c7bbab67"},"outputs":[],"source":["D = gf.Component(\"distribute_align_y\")\n","# Create different-sized rectangles and add them to D then distribute them\n","[\n","    D.add_ref(gf.components.rectangle(size=[n * 15 + 20, n * 15 + 20])).move((n, n * 4))\n","    for n in [0, 2, 3, 1, 2]\n","]\n","D.distribute(elements=\"all\", direction=\"x\", spacing=5, separation=True)\n","\n","# Align top edges\n","D.align(elements=\"all\", alignment=\"y\")\n","D"],"id":"c7bbab67"},{"cell_type":"markdown","metadata":{"id":"ed27a41a"},"source":["other valid alignment options include ``'xmin', 'x', 'xmax', 'ymin', 'y', and 'ymax'``"],"id":"ed27a41a"},{"cell_type":"code","source":[],"metadata":{"id":"tIxpzZXbsOVU"},"id":"tIxpzZXbsOVU","execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"130854ea"},"source":["# Components with hierarchy\n","\n","![](https://i.imgur.com/3pczkyM.png)\n","\n","You can define components Parametric cells (waveguides, bends, couplers) with basic input parameters (width, length, radius ...) and reuse the PCells in more complex PCells."],"id":"130854ea"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"dac6d91e"},"outputs":[],"source":["from functools import partial\n","\n","import toolz\n","\n","import gdsfactory as gf\n","from gdsfactory.generic_tech import get_generic_pdk\n","from gdsfactory.typings import ComponentSpec, CrossSectionSpec\n","\n","gf.config.rich_output()\n","PDK = get_generic_pdk()\n","PDK.activate()"],"id":"dac6d91e"},{"cell_type":"markdown","metadata":{"lines_to_next_cell":2,"id":"e29e1d3c"},"source":["**Problem**\n","\n","When using hierarchical cells where you pass `N` subcells with `M` parameters you can end up with `N*M` parameters. This is make code hard to read.\n"],"id":"e29e1d3c"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"8c3fed51"},"outputs":[],"source":["@gf.cell\n","def bend_with_straight_with_too_many_input_parameters(\n","    bend=gf.components.bend_euler,\n","    straight=gf.components.straight,\n","    length: float = 3,\n","    angle: float = 90.0,\n","    p: float = 0.5,\n","    with_arc_floorplan: bool = True,\n","    npoints: int | None = None,\n","    direction: str = \"ccw\",\n","    with_bbox: bool = True,\n","    cross_section: CrossSectionSpec = \"strip\",\n",") -> gf.Component:\n","    \"\"\" \"As hierarchical cells become more complex, the number of input parameters can increase significantly.\"\"\"\n","    c = gf.Component()\n","    b = bend(\n","        angle=angle,\n","        p=p,\n","        with_arc_floorplan=with_arc_floorplan,\n","        npoints=npoints,\n","        direction=direction,\n","        with_bbox=with_bbox,\n","        cross_section=cross_section,\n","    )\n","    s = straight(length=length, with_bbox=with_bbox, cross_section=cross_section)\n","\n","    bref = c << b\n","    sref = c << s\n","\n","    sref.connect(\"o2\", bref.ports[\"o2\"])\n","    c.info[\"length\"] = b.info[\"length\"] + s.info[\"length\"]\n","    return c\n","\n","\n","c = bend_with_straight_with_too_many_input_parameters()\n","c.plot()"],"id":"8c3fed51"},{"cell_type":"markdown","metadata":{"lines_to_next_cell":2,"id":"18aed6ed"},"source":["**Solution**\n","\n","You can use a ComponentSpec parameter for every subcell. The ComponentSpec can be a dictionary with arbitrary number of settings, a string, or a function.\n","\n","## ComponentSpec\n","\n","When defining a `Parametric cell` you can use other `ComponentSpec` as an arguments. It can be a:\n","\n","1. string: function name of a cell registered on the active PDK. `\"bend_circular\"`\n","2. dict: `dict(component='bend_circular', settings=dict(radius=20))`\n","3. function: Using `functools.partial` you can customize the default parameters of a function.\n"],"id":"18aed6ed"},{"cell_type":"code","execution_count":null,"metadata":{"id":"d0f74a62"},"outputs":[],"source":["@gf.cell\n","def bend_with_straight(\n","    bend: ComponentSpec = gf.components.bend_euler,\n","    straight: ComponentSpec = gf.components.straight,\n",") -> gf.Component:\n","    \"\"\"Much simpler version.\n","\n","    Args:\n","        bend: input bend.\n","        straight: output straight.\n","    \"\"\"\n","    c = gf.Component()\n","    b = gf.get_component(bend)\n","    s = gf.get_component(straight)\n","\n","    bref = c << b\n","    sref = c << s\n","\n","    sref.connect(\"o2\", bref.ports[\"o2\"])\n","    c.info[\"length\"] = b.info[\"length\"] + s.info[\"length\"]\n","    return c\n","\n","\n","c = bend_with_straight()\n","c.plot()"],"id":"d0f74a62"},{"cell_type":"markdown","metadata":{"id":"b3170703"},"source":["### 1. string\n","\n","You can use any string registered in the `Pdk`. Go to the PDK tutorial to learn how to register cells in a PDK."],"id":"b3170703"},{"cell_type":"code","execution_count":null,"metadata":{"id":"743ebbcb"},"outputs":[],"source":["c = bend_with_straight(bend=\"bend_circular\")\n","c.plot()"],"id":"743ebbcb"},{"cell_type":"markdown","metadata":{"id":"cacfd150"},"source":["### 2. dict\n","\n","You can pass a dict of settings."],"id":"cacfd150"},{"cell_type":"code","execution_count":null,"metadata":{"id":"01b3e651"},"outputs":[],"source":["c = bend_with_straight(bend=dict(component=\"bend_circular\", settings=dict(radius=20)))\n","c.plot()"],"id":"01b3e651"},{"cell_type":"markdown","metadata":{"id":"712a9442"},"source":["### 3. function\n","\n","You can pass a function of a function with customized default input parameters `from functools import partial`\n","\n","Partial lets you define different default parameters for a function, so you can modify the default settings for each child cell."],"id":"712a9442"},{"cell_type":"code","execution_count":null,"metadata":{"id":"8621584b"},"outputs":[],"source":["c = bend_with_straight(bend=partial(gf.components.bend_circular, radius=30))\n","c.plot()"],"id":"8621584b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"04cc16fe"},"outputs":[],"source":["bend20 = partial(gf.components.bend_circular, radius=20)\n","b = bend20()\n","b.plot()"],"id":"04cc16fe"},{"cell_type":"code","execution_count":null,"metadata":{"id":"50773c23"},"outputs":[],"source":["type(bend20)"],"id":"50773c23"},{"cell_type":"code","execution_count":null,"metadata":{"id":"90779bdc"},"outputs":[],"source":["bend20.func.__name__"],"id":"90779bdc"},{"cell_type":"code","execution_count":null,"metadata":{"id":"92e724b2"},"outputs":[],"source":["bend20.keywords"],"id":"92e724b2"},{"cell_type":"code","execution_count":null,"metadata":{"id":"83888d06"},"outputs":[],"source":["b = bend_with_straight(bend=bend20)\n","print(b.metadata[\"info\"][\"length\"])\n","b.plot()"],"id":"83888d06"},{"cell_type":"code","execution_count":null,"metadata":{"id":"452b394f"},"outputs":[],"source":["# You can still modify the bend to have any bend radius\n","b3 = bend20(radius=10)\n","b3.plot()"],"id":"452b394f"},{"cell_type":"markdown","metadata":{"id":"d62b08f5"},"source":["## PDK custom fab\n","\n","You can define a new PDK by creating function that customize partial parameters of the generic functions.\n","\n","Lets say that this PDK uses layer (41, 0) for the pads (instead of the layer used in the generic pad function)."],"id":"d62b08f5"},{"cell_type":"code","execution_count":null,"metadata":{"id":"e08ef064"},"outputs":[],"source":["pad_custom_layer = partial(gf.components.pad, layer=(41, 0))"],"id":"e08ef064"},{"cell_type":"code","execution_count":null,"metadata":{"id":"6b854e54"},"outputs":[],"source":["c = pad_custom_layer()\n","c.plot()"],"id":"6b854e54"},{"cell_type":"markdown","metadata":{"id":"11c2e999"},"source":["## Composing functions\n","\n","You can combine more complex functions out of smaller functions.\n","\n","Lets say that we want to add tapers and grating couplers to a wide waveguide."],"id":"11c2e999"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f76fb265"},"outputs":[],"source":["c1 = gf.components.straight()\n","c1.plot()"],"id":"f76fb265"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c75d99bb"},"outputs":[],"source":["straight_wide = partial(gf.components.straight, width=3)\n","c3 = straight_wide()\n","c3.plot()"],"id":"c75d99bb"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4cc24fb7"},"outputs":[],"source":["c1 = gf.components.straight(width=3)\n","c1.plot()"],"id":"4cc24fb7"},{"cell_type":"code","execution_count":null,"metadata":{"id":"b1a189bd"},"outputs":[],"source":["c2 = gf.add_tapers(c1)\n","c2.plot()"],"id":"b1a189bd"},{"cell_type":"code","execution_count":null,"metadata":{"id":"0643f726"},"outputs":[],"source":["c2.metadata_child[\"changed\"]  # You can still access the child metadata"],"id":"0643f726"},{"cell_type":"code","execution_count":null,"metadata":{"id":"835304e7"},"outputs":[],"source":["c3 = gf.routing.add_fiber_array(c2, with_loopback=False)\n","c3.plot()"],"id":"835304e7"},{"cell_type":"code","execution_count":null,"metadata":{"id":"78e86be2"},"outputs":[],"source":["c3.metadata_child[\"changed\"]  # You can still access the child metadata"],"id":"78e86be2"},{"cell_type":"markdown","metadata":{"id":"2981940d"},"source":["Lets do it with a **single** step thanks to `toolz.pipe`"],"id":"2981940d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"28ab65c0"},"outputs":[],"source":["add_fiber_array = partial(gf.routing.add_fiber_array, with_loopback=False)\n","add_tapers = gf.add_tapers\n","\n","# pipe is more readable than the equivalent add_fiber_array(add_tapers(c1))\n","c3 = toolz.pipe(c1, add_tapers, add_fiber_array)\n","c3"],"id":"28ab65c0"},{"cell_type":"markdown","metadata":{"id":"78c26b51"},"source":["we can even combine `add_tapers` and `add_fiber_array` thanks to `toolz.compose` or `toolz.compose`\n","\n","For example:"],"id":"78c26b51"},{"cell_type":"code","execution_count":null,"metadata":{"id":"701a01cd"},"outputs":[],"source":["add_tapers_fiber_array = toolz.compose_left(add_tapers, add_fiber_array)\n","c4 = add_tapers_fiber_array(c1)\n","c4.plot()"],"id":"701a01cd"},{"cell_type":"markdown","metadata":{"id":"d5902091"},"source":["is equivalent to"],"id":"d5902091"},{"cell_type":"code","execution_count":null,"metadata":{"id":"9dfacb7a"},"outputs":[],"source":["c5 = add_fiber_array(add_tapers(c1))\n","c5.plot()"],"id":"9dfacb7a"},{"cell_type":"markdown","metadata":{"id":"f2ac8c72"},"source":["as well as equivalent to"],"id":"f2ac8c72"},{"cell_type":"code","execution_count":null,"metadata":{"id":"14c28b54"},"outputs":[],"source":["add_tapers_fiber_array = toolz.compose(add_fiber_array, add_tapers)\n","c6 = add_tapers_fiber_array(c1)\n","c6.plot()"],"id":"14c28b54"},{"cell_type":"markdown","metadata":{"id":"62d9ea17"},"source":["or"],"id":"62d9ea17"},{"cell_type":"code","execution_count":null,"metadata":{"id":"efecd8ee"},"outputs":[],"source":["c7 = toolz.pipe(c1, add_tapers, add_fiber_array)\n","c7.plot()"],"id":"efecd8ee"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4664b872"},"outputs":[],"source":["c7.metadata_child[\"changed\"]  # You can still access the child metadata"],"id":"4664b872"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f749ae41"},"outputs":[],"source":["c7.metadata[\"child\"][\"child\"][\"name\"]"],"id":"f749ae41"},{"cell_type":"code","execution_count":null,"metadata":{"id":"22110a13"},"outputs":[],"source":["c7.metadata[\"child\"][\"child\"][\"function_name\"]"],"id":"22110a13"},{"cell_type":"code","execution_count":null,"metadata":{"id":"37010b53"},"outputs":[],"source":["c7.metadata[\"changed\"].keys()"],"id":"37010b53"},{"cell_type":"code","source":[],"metadata":{"id":"jBVOBCGLsd3M"},"id":"jBVOBCGLsd3M","execution_count":null,"outputs":[]},{"cell_type":"code","source":[],"metadata":{"id":"pE3ZWsFGs3nr"},"id":"pE3ZWsFGs3nr","execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"6266fdee"},"source":["# Routing\n","\n","Optical and high speed RF ports have an orientation that routes need to follow to avoid sharp turns that produce reflections.\n","\n","we have routing functions that route:\n","\n","- single route between 2 ports\n","    - `get_route`\n","    - `get_route_from_steps`\n","    - `get_route_astar`\n","- group of routes between 2 groups of ports using a river/bundle/bus router. At the moment it works only when all ports on each group have the same orientation.\n","    - `get_bundle`\n","    - `get_bundle_from_steps`\n","\n","\n","The most useful function is `get_bundle` which supports both single and groups of routes, and can also route with length matching, which ensures that all routes have the same length.\n","\n","The biggest limitation is that it requires to have all the ports with the same orientation, for that you can use `gf.routing.route_ports_to_side`"],"id":"6266fdee"},{"cell_type":"code","execution_count":null,"metadata":{"id":"b9fd9534"},"outputs":[],"source":["from functools import partial\n","\n","import gdsfactory as gf\n","from gdsfactory.cell import cell\n","from gdsfactory.component import Component\n","from gdsfactory.generic_tech import get_generic_pdk\n","from gdsfactory.port import Port\n","\n","gf.config.rich_output()\n","PDK = get_generic_pdk()\n","PDK.activate()"],"id":"b9fd9534"},{"cell_type":"code","execution_count":null,"metadata":{"id":"cf89285f"},"outputs":[],"source":["c = gf.Component(\"sample_no_routes\")\n","mmi1 = c << gf.components.mmi1x2()\n","mmi2 = c << gf.components.mmi1x2()\n","mmi2.move((100, 50))\n","c.plot()"],"id":"cf89285f"},{"cell_type":"markdown","metadata":{"id":"08100fe6"},"source":["## get_route\n","\n","`get_route` returns a Manhattan route between 2 ports"],"id":"08100fe6"},{"cell_type":"code","execution_count":null,"metadata":{"id":"67fea8f4"},"outputs":[],"source":["help(gf.routing.get_route)"],"id":"67fea8f4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"45d1892a"},"outputs":[],"source":["c = gf.Component(\"sample_connect\")\n","mmi1 = c << gf.components.mmi1x2()\n","mmi2 = c << gf.components.mmi1x2()\n","mmi2.move((100, 50))\n","route = gf.routing.get_route(mmi1.ports[\"o2\"], mmi2.ports[\"o1\"])\n","c.add(route.references)\n","c.plot()"],"id":"45d1892a"},{"cell_type":"code","execution_count":null,"metadata":{"id":"8b657c5b"},"outputs":[],"source":["route"],"id":"8b657c5b"},{"cell_type":"markdown","metadata":{"id":"510966f2"},"source":["**Problem**: get_route with obstacles\n","\n","sometimes there are obstacles that connect strip does not see!"],"id":"510966f2"},{"cell_type":"code","execution_count":null,"metadata":{"id":"274962bb"},"outputs":[],"source":["c = gf.Component(\"sample_problem\")\n","mmi1 = c << gf.components.mmi1x2()\n","mmi2 = c << gf.components.mmi1x2()\n","mmi2.move((110, 50))\n","x = c << gf.components.cross(length=20)\n","x.move((135, 20))\n","route = gf.routing.get_route(mmi1.ports[\"o2\"], mmi2.ports[\"o2\"])\n","c.add(route.references)\n","c.plot()"],"id":"274962bb"},{"cell_type":"markdown","metadata":{"id":"d729a8f3"},"source":["**Solutions:**\n","\n","- specify the route steps\n","\n","## get_route_from_steps\n","\n","`get_route_from_steps` is a manual version of `get_route` where you can define only the new steps `x` or `y` together with increments `dx` or `dy`"],"id":"d729a8f3"},{"cell_type":"code","execution_count":null,"metadata":{"id":"7ccfda81"},"outputs":[],"source":["c = gf.Component(\"get_route_from_steps\")\n","w = gf.components.straight()\n","left = c << w\n","right = c << w\n","right.move((100, 80))\n","\n","obstacle = gf.components.rectangle(size=(100, 10))\n","obstacle1 = c << obstacle\n","obstacle2 = c << obstacle\n","obstacle1.ymin = 40\n","obstacle2.xmin = 25\n","\n","port1 = left.ports[\"o2\"]\n","port2 = right.ports[\"o2\"]\n","\n","routes = gf.routing.get_route_from_steps(\n","    port1=port1,\n","    port2=port2,\n","    steps=[\n","        {\"x\": 20, \"y\": 0},\n","        {\"x\": 20, \"y\": 20},\n","        {\"x\": 120, \"y\": 20},\n","        {\"x\": 120, \"y\": 80},\n","    ],\n",")\n","c.add(routes.references)\n","c.plot()"],"id":"7ccfda81"},{"cell_type":"code","execution_count":null,"metadata":{"id":"5d6e9253"},"outputs":[],"source":["c = gf.Component(\"get_route_from_steps_shorter_syntax\")\n","w = gf.components.straight()\n","left = c << w\n","right = c << w\n","right.move((100, 80))\n","\n","obstacle = gf.components.rectangle(size=(100, 10))\n","obstacle1 = c << obstacle\n","obstacle2 = c << obstacle\n","obstacle1.ymin = 40\n","obstacle2.xmin = 25\n","\n","port1 = left.ports[\"o2\"]\n","port2 = right.ports[\"o2\"]\n","\n","routes = gf.routing.get_route_from_steps(\n","    port1=port1,\n","    port2=port2,\n","    steps=[\n","        {\"x\": 20},\n","        {\"y\": 20},\n","        {\"x\": 120},\n","        {\"y\": 80},\n","    ],\n",")\n","c.add(routes.references)\n","c.plot()"],"id":"5d6e9253"},{"cell_type":"markdown","metadata":{"id":"a98264e0"},"source":["## get_route_astar\n","\n","A* is a routing algorithm to avoid obstacles.\n","See [wikipedia](https://en.wikipedia.org/wiki/A*_search_algorithm) and [animation](https://github.com/zhm-real/PathPlanning)\n","\n","The main issue is that it only works for a single route."],"id":"a98264e0"},{"cell_type":"code","execution_count":null,"metadata":{"id":"86cd03c8"},"outputs":[],"source":["c = gf.Component(\"get_route_astar\")\n","cross_section = gf.get_cross_section(\"metal1\", width=3)\n","w = gf.components.straight(cross_section=cross_section)\n","\n","left = c << w\n","right = c << w\n","right.move((100, 80))\n","\n","obstacle = gf.components.rectangle(size=(100, 3), layer=\"M1\")\n","obstacle1 = c << obstacle\n","obstacle2 = c << obstacle\n","obstacle1.ymin = 40\n","obstacle2.xmin = 25\n","\n","port1 = left.ports[\"e2\"]\n","port2 = right.ports[\"e2\"]\n","\n","routes = gf.routing.get_route_astar(\n","    component=c,\n","    port1=port1,\n","    port2=port2,\n","    cross_section=cross_section,\n","    resolution=5,\n","    distance=6.5,\n",")\n","\n","c.add(routes.references)\n","c.plot()"],"id":"86cd03c8"},{"cell_type":"markdown","metadata":{"id":"7f8b036b"},"source":["By default it avoids all obstacles on every layer, but you can explicitly define the layers to avoid using `avoid_layers`."],"id":"7f8b036b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"110cff5c"},"outputs":[],"source":["c = gf.Component(\"get_route_astar_avoid_layers\")\n","cross_section = gf.get_cross_section(\"metal1\", width=3)\n","w = gf.components.straight(cross_section=cross_section)\n","\n","left = c << w\n","right = c << w\n","right.move((100, 80))\n","\n","obstacle = gf.components.rectangle(size=(100, 3), layer=\"WG\")\n","obstacle1 = c << obstacle\n","obstacle2 = c << obstacle\n","obstacle1.ymin = 40\n","obstacle2.xmin = 25\n","\n","port1 = left.ports[\"e2\"]\n","port2 = right.ports[\"e2\"]\n","\n","routes = gf.routing.get_route_astar(\n","    component=c,\n","    port1=port1,\n","    port2=port2,\n","    cross_section=cross_section,\n","    resolution=10,\n","    distance=6.5,\n","    avoid_layers=(\"M1\",),\n",")\n","\n","c.add(routes.references)\n","c.plot()"],"id":"110cff5c"},{"cell_type":"code","execution_count":null,"metadata":{"id":"b8abc7da"},"outputs":[],"source":["c = gf.Component(\"get_route_astar_strip\")\n","rect1 = c << gf.components.rectangle()\n","rect2 = c << gf.components.rectangle()\n","rect3 = c << gf.components.rectangle((2, 2), layer=(1, 0))\n","rect2.move(destination=(8, 4))\n","rect3.move(destination=(5.5, 1.5))\n","\n","port1 = gf.Port(\n","    \"o1\", 0, rect1.center + (0, 3), cross_section=gf.get_cross_section(\"strip\")\n",")\n","port2 = port1.copy(\"o2\")\n","port2.orientation = 180\n","port2.center = rect2.center + (0, -3)\n","c.add_ports([port1, port2])\n","route = gf.routing.get_route_astar(c, port1, port2, radius=0.5, width=0.5, distance=0.5)\n","c.add(route.references)\n","\n","c.plot()"],"id":"b8abc7da"},{"cell_type":"code","execution_count":null,"metadata":{"id":"1f659d39"},"outputs":[],"source":["c = gf.Component(\"get_route_astar_strip_avoid_layers\")\n","rect1 = c << gf.components.rectangle()\n","rect2 = c << gf.components.rectangle()\n","rect3 = c << gf.components.rectangle((2, 2), layer=(2, 0))\n","rect2.move(destination=(8, 4))\n","rect3.move(destination=(5.5, 1.5))\n","\n","port1 = gf.Port(\n","    \"o1\", 0, rect1.center + (0, 3), cross_section=gf.get_cross_section(\"strip\")\n",")\n","port2 = port1.copy(\"o2\")\n","port2.orientation = 180\n","port2.center = rect2.center + (0, -3)\n","c.add_ports([port1, port2])\n","route = gf.routing.get_route_astar(\n","    c, port1, port2, radius=0.5, width=0.5, avoid_layers=[(1, 0)]\n",")\n","c.add(route.references)\n","c.plot()"],"id":"1f659d39"},{"cell_type":"markdown","metadata":{"id":"ce6acda6"},"source":["The resolution decides how many \"leaps/hops\" the algorithm has to do. For a layout like this, where the default resolution (1 micron) is much smaller than the distance between the obstacles (~15+ microns), it has to step through too many points and that takes a long time. Increasing the resolution to about 5 microns fixes it (for this layout)."],"id":"ce6acda6"},{"cell_type":"code","execution_count":null,"metadata":{"id":"3608f731"},"outputs":[],"source":["c = gf.Component(\"get_route_astar_resolution\")\n","w = gf.components.straight()\n","left = c << w\n","right = c << w\n","right.move((100, 80))\n","\n","obstacle = gf.components.rectangle(size=(100, 10))\n","obstacle1 = c << obstacle\n","obstacle2 = c << obstacle\n","obstacle1.ymin = 40\n","obstacle2.xmin = 25\n","\n","port1 = left.ports[\"o2\"]\n","port2 = right.ports[\"o2\"]\n","\n","route = gf.routing.get_route_astar(\n","    component=c,\n","    port1=port1,\n","    port2=port2,\n","    resolution=5,\n","    distance=5.5,\n","    radius=5,\n",")\n","c.add(route.references)\n","c.plot()"],"id":"3608f731"},{"cell_type":"markdown","metadata":{"id":"81c458ea"},"source":["## get_bundle\n","\n","To route groups of ports avoiding waveguide collisions, you should use `get_bundle` instead of `get_route`.\n","\n","`get_bundle` uses a river/bundle/bus router.\n","\n","At the moment it works only when each group of ports have the same orientation.\n"],"id":"81c458ea"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f5c6a27c"},"outputs":[],"source":["ys_right = [0, 10, 20, 40, 50, 80]\n","pitch = 127.0\n","N = len(ys_right)\n","ys_left = [(i - N / 2) * pitch for i in range(N)]\n","layer = (1, 0)\n","\n","right_ports = [\n","    gf.Port(f\"R_{i}\", center=(0, ys_right[i]), width=0.5, orientation=180, layer=layer)\n","    for i in range(N)\n","]\n","left_ports = [\n","    gf.Port(f\"L_{i}\", center=(-200, ys_left[i]), width=0.5, orientation=0, layer=layer)\n","    for i in range(N)\n","]\n","\n","# you can also mess up the port order and it will sort them by default\n","left_ports.reverse()\n","\n","c = gf.Component(name=\"connect_bundle_v2\")\n","routes = gf.routing.get_bundle(\n","    left_ports, right_ports, sort_ports=True, start_straight_length=100\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"f5c6a27c"},{"cell_type":"code","execution_count":null,"metadata":{"id":"be03f99c"},"outputs":[],"source":["xs_top = [0, 10, 20, 40, 50, 80]\n","pitch = 127.0\n","N = len(xs_top)\n","xs_bottom = [(i - N / 2) * pitch for i in range(N)]\n","layer = (1, 0)\n","\n","top_ports = [\n","    gf.Port(f\"top_{i}\", center=(xs_top[i], 0), width=0.5, orientation=270, layer=layer)\n","    for i in range(N)\n","]\n","\n","bot_ports = [\n","    gf.Port(\n","        f\"bot_{i}\",\n","        center=(xs_bottom[i], -300),\n","        width=0.5,\n","        orientation=90,\n","        layer=layer,\n","    )\n","    for i in range(N)\n","]\n","\n","c = gf.Component(name=\"connect_bundle_separation\")\n","routes = gf.routing.get_bundle(\n","    top_ports, bot_ports, separation=5.0, end_straight_length=100\n",")\n","for route in routes:\n","    c.add(route.references)\n","\n","c.plot()"],"id":"be03f99c"},{"cell_type":"markdown","metadata":{"lines_to_next_cell":2,"id":"8ce7f5d0"},"source":["`get_bundle` can also route bundles through corners\n"],"id":"8ce7f5d0"},{"cell_type":"code","execution_count":null,"metadata":{"id":"2e69035f"},"outputs":[],"source":["@cell\n","def test_connect_corner(N=6, config=\"A\"):\n","    d = 10.0\n","    sep = 5.0\n","    top_cell = gf.Component()\n","    layer = (1, 0)\n","\n","    if config in [\"A\", \"B\"]:\n","        a = 100.0\n","        ports_A_TR = [\n","            Port(\n","                f\"A_TR_{i}\",\n","                center=(d, a / 2 + i * sep),\n","                width=0.5,\n","                orientation=0,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_A_TL = [\n","            Port(\n","                f\"A_TL_{i}\",\n","                center=(-d, a / 2 + i * sep),\n","                width=0.5,\n","                orientation=180,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_A_BR = [\n","            Port(\n","                f\"A_BR_{i}\",\n","                center=(d, -a / 2 - i * sep),\n","                width=0.5,\n","                orientation=0,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_A_BL = [\n","            Port(\n","                f\"A_BL_{i}\",\n","                center=(-d, -a / 2 - i * sep),\n","                width=0.5,\n","                orientation=180,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_A = [ports_A_TR, ports_A_TL, ports_A_BR, ports_A_BL]\n","\n","        ports_B_TR = [\n","            Port(\n","                f\"B_TR_{i}\",\n","                center=(a / 2 + i * sep, d),\n","                width=0.5,\n","                orientation=90,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_B_TL = [\n","            Port(\n","                f\"B_TL_{i}\",\n","                center=(-a / 2 - i * sep, d),\n","                width=0.5,\n","                orientation=90,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_B_BR = [\n","            Port(\n","                f\"B_BR_{i}\",\n","                center=(a / 2 + i * sep, -d),\n","                width=0.5,\n","                orientation=270,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_B_BL = [\n","            Port(\n","                f\"B_BL_{i}\",\n","                center=(-a / 2 - i * sep, -d),\n","                width=0.5,\n","                orientation=270,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_B = [ports_B_TR, ports_B_TL, ports_B_BR, ports_B_BL]\n","\n","    elif config in [\"C\", \"D\"]:\n","        a = N * sep + 2 * d\n","        ports_A_TR = [\n","            Port(\n","                f\"A_TR_{i}\",\n","                center=(a, d + i * sep),\n","                width=0.5,\n","                orientation=0,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_A_TL = [\n","            Port(\n","                f\"A_TL_{i}\",\n","                center=(-a, d + i * sep),\n","                width=0.5,\n","                orientation=180,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_A_BR = [\n","            Port(\n","                f\"A_BR_{i}\",\n","                center=(a, -d - i * sep),\n","                width=0.5,\n","                orientation=0,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_A_BL = [\n","            Port(\n","                f\"A_BL_{i}\",\n","                center=(-a, -d - i * sep),\n","                width=0.5,\n","                orientation=180,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_A = [ports_A_TR, ports_A_TL, ports_A_BR, ports_A_BL]\n","\n","        ports_B_TR = [\n","            Port(\n","                f\"B_TR_{i}\",\n","                center=(d + i * sep, a),\n","                width=0.5,\n","                orientation=90,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_B_TL = [\n","            Port(\n","                f\"B_TL_{i}\",\n","                center=(-d - i * sep, a),\n","                width=0.5,\n","                orientation=90,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_B_BR = [\n","            Port(\n","                f\"B_BR_{i}\",\n","                center=(d + i * sep, -a),\n","                width=0.5,\n","                orientation=270,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_B_BL = [\n","            Port(\n","                f\"B_BL_{i}\",\n","                center=(-d - i * sep, -a),\n","                width=0.5,\n","                orientation=270,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports_B = [ports_B_TR, ports_B_TL, ports_B_BR, ports_B_BL]\n","\n","    if config in [\"A\", \"C\"]:\n","        for ports1, ports2 in zip(ports_A, ports_B):\n","            routes = gf.routing.get_bundle(ports1, ports2, layer=(2, 0), radius=5)\n","            for route in routes:\n","                top_cell.add(route.references)\n","\n","    elif config in [\"B\", \"D\"]:\n","        for ports1, ports2 in zip(ports_A, ports_B):\n","            routes = gf.routing.get_bundle(ports2, ports1, layer=(2, 0), radius=5)\n","            for route in routes:\n","                top_cell.add(route.references)\n","\n","    return top_cell\n","\n","\n","c = test_connect_corner(config=\"A\")\n","c.plot()"],"id":"2e69035f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"599a4b5b"},"outputs":[],"source":["c = test_connect_corner(config=\"C\")\n","c.plot()"],"id":"599a4b5b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"847dfbbe"},"outputs":[],"source":["@cell\n","def test_connect_bundle_udirect(dy=200, orientation=270, layer=(1, 0)):\n","    xs1 = [-100, -90, -80, -55, -35, 24, 0] + [200, 210, 240]\n","    axis = \"X\" if orientation in [0, 180] else \"Y\"\n","    pitch = 10.0\n","    N = len(xs1)\n","    xs2 = [70 + i * pitch for i in range(N)]\n","\n","    if axis == \"X\":\n","        ports1 = [\n","            Port(\n","                f\"top_{i}\",\n","                center=(0, xs1[i]),\n","                width=0.5,\n","                orientation=orientation,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports2 = [\n","            Port(\n","                f\"bottom_{i}\",\n","                center=(dy, xs2[i]),\n","                width=0.5,\n","                orientation=orientation,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","    else:\n","        ports1 = [\n","            Port(\n","                f\"top_{i}\",\n","                center=(xs1[i], 0),\n","                width=0.5,\n","                orientation=orientation,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","        ports2 = [\n","            Port(\n","                f\"bottom_{i}\",\n","                center=(xs2[i], dy),\n","                width=0.5,\n","                orientation=orientation,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","    top_cell = Component()\n","    routes = gf.routing.get_bundle(ports1, ports2, radius=10.0)\n","    for route in routes:\n","        top_cell.add(route.references)\n","\n","    return top_cell\n","\n","\n","c = test_connect_bundle_udirect()\n","c.plot()"],"id":"847dfbbe"},{"cell_type":"code","execution_count":null,"metadata":{"id":"7819d90a"},"outputs":[],"source":["@cell\n","def test_connect_bundle_u_indirect(dy=-200, orientation=180, layer=(1, 0)):\n","    xs1 = [-100, -90, -80, -55, -35] + [200, 210, 240]\n","    axis = \"X\" if orientation in [0, 180] else \"Y\"\n","    pitch = 10.0\n","    N = len(xs1)\n","    xs2 = [50 + i * pitch for i in range(N)]\n","\n","    a1 = orientation\n","    a2 = a1 + 180\n","\n","    if axis == \"X\":\n","        ports1 = [\n","            Port(f\"top_{i}\", center=(0, xs1[i]), width=0.5, orientation=a1, layer=layer)\n","            for i in range(N)\n","        ]\n","\n","        ports2 = [\n","            Port(\n","                f\"bot_{i}\",\n","                center=(dy, xs2[i]),\n","                width=0.5,\n","                orientation=a2,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","    else:\n","        ports1 = [\n","            Port(f\"top_{i}\", center=(xs1[i], 0), width=0.5, orientation=a1, layer=layer)\n","            for i in range(N)\n","        ]\n","\n","        ports2 = [\n","            Port(\n","                f\"bot_{i}\",\n","                center=(xs2[i], dy),\n","                width=0.5,\n","                orientation=a2,\n","                layer=layer,\n","            )\n","            for i in range(N)\n","        ]\n","\n","    top_cell = Component()\n","    routes = gf.routing.get_bundle(\n","        ports1,\n","        ports2,\n","        bend=gf.components.bend_euler,\n","        radius=5,\n","    )\n","    for route in routes:\n","        top_cell.add(route.references)\n","\n","    return top_cell\n","\n","\n","c = test_connect_bundle_u_indirect(orientation=0)\n","c.plot()"],"id":"7819d90a"},{"cell_type":"code","execution_count":null,"metadata":{"id":"0ab82af5"},"outputs":[],"source":["@gf.cell\n","def test_north_to_south(layer=(1, 0)):\n","    dy = 200.0\n","    xs1 = [-500, -300, -100, -90, -80, -55, -35, 200, 210, 240, 500, 650]\n","\n","    pitch = 10.0\n","    N = len(xs1)\n","    xs2 = [-20 + i * pitch for i in range(N // 2)]\n","    xs2 += [400 + i * pitch for i in range(N // 2)]\n","\n","    a1 = 90\n","    a2 = a1 + 180\n","\n","    ports1 = [\n","        gf.Port(f\"top_{i}\", center=(xs1[i], 0), width=0.5, orientation=a1, layer=layer)\n","        for i in range(N)\n","    ]\n","\n","    ports2 = [\n","        gf.Port(f\"bot_{i}\", center=(xs2[i], dy), width=0.5, orientation=a2, layer=layer)\n","        for i in range(N)\n","    ]\n","\n","    c = gf.Component()\n","    routes = gf.routing.get_bundle(ports1, ports2, auto_widen=False)\n","    for route in routes:\n","        c.add(route.references)\n","\n","    return c\n","\n","\n","c = test_north_to_south()\n","c.plot()"],"id":"0ab82af5"},{"cell_type":"code","execution_count":null,"metadata":{"id":"117493ff"},"outputs":[],"source":["@gf.cell\n","def demo_connect_bundle():\n","    \"\"\"combines all the connect_bundle tests\"\"\"\n","    y = 400.0\n","    x = 500\n","    y0 = 900\n","    dy = 200.0\n","    c = gf.Component()\n","    for j, s in enumerate([-1, 1]):\n","        for i, orientation in enumerate([0, 90, 180, 270]):\n","            ci = test_connect_bundle_u_indirect(dy=s * dy, orientation=orientation)\n","            ref = ci.ref(position=(i * x, j * y))\n","            c.add(ref)\n","\n","            ci = test_connect_bundle_udirect(dy=s * dy, orientation=orientation)\n","            ref = ci.ref(position=(i * x, j * y + y0))\n","            c.add(ref)\n","\n","    for i, config in enumerate([\"A\", \"B\", \"C\", \"D\"]):\n","        ci = test_connect_corner(config=config)\n","        ref = ci.ref(position=(i * x, 1700))\n","        c.add(ref)\n","\n","    return c\n","\n","\n","c = demo_connect_bundle()\n","c.plot()"],"id":"117493ff"},{"cell_type":"code","execution_count":null,"metadata":{"id":"fbeb1f49"},"outputs":[],"source":["c = gf.Component(\"route_bend_5um\")\n","c1 = c << gf.components.mmi2x2()\n","c2 = c << gf.components.mmi2x2()\n","\n","c2.move((100, 50))\n","routes = gf.routing.get_bundle(\n","    [c1.ports[\"o4\"], c1.ports[\"o3\"]], [c2.ports[\"o1\"], c2.ports[\"o2\"]], radius=5\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"fbeb1f49"},{"cell_type":"code","execution_count":null,"metadata":{"id":"656de595"},"outputs":[],"source":["c = gf.Component(\"electrical\")\n","c1 = c << gf.components.pad()\n","c2 = c << gf.components.pad()\n","c2.move((200, 100))\n","routes = gf.routing.get_bundle(\n","    [c1.ports[\"e3\"]], [c2.ports[\"e1\"]], cross_section=gf.cross_section.metal1\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"656de595"},{"cell_type":"code","execution_count":null,"metadata":{"id":"a7af15f3"},"outputs":[],"source":["c = gf.Component(\"get_bundle_with_ubends_bend_from_top\")\n","pad_array = gf.components.pad_array()\n","\n","c1 = c << pad_array\n","c2 = c << pad_array\n","c2.rotate(90)\n","c2.movex(1000)\n","c2.ymax = -200\n","\n","routes_bend180 = gf.routing.get_routes_bend180(\n","    ports=c2.get_ports_list(),\n","    radius=75 / 2,\n","    cross_section=gf.cross_section.metal1,\n","    bend_port1=\"e1\",\n","    bend_port2=\"e2\",\n",")\n","c.add(routes_bend180.references)\n","\n","routes = gf.routing.get_bundle(\n","    c1.get_ports_list(), routes_bend180.ports, cross_section=gf.cross_section.metal1\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"a7af15f3"},{"cell_type":"code","execution_count":null,"metadata":{"id":"d9d39b05"},"outputs":[],"source":["c = gf.Component(\"get_bundle_with_ubends_bend_from_bottom\")\n","pad_array = gf.components.pad_array()\n","\n","c1 = c << pad_array\n","c2 = c << pad_array\n","c2.rotate(90)\n","c2.movex(1000)\n","c2.ymax = -200\n","\n","routes_bend180 = gf.routing.get_routes_bend180(\n","    ports=c2.get_ports_list(),\n","    radius=75 / 2,\n","    cross_section=gf.cross_section.metal1,\n","    bend_port1=\"e2\",\n","    bend_port2=\"e1\",\n",")\n","c.add(routes_bend180.references)\n","\n","routes = gf.routing.get_bundle(\n","    c1.get_ports_list(), routes_bend180.ports, cross_section=gf.cross_section.metal1\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"d9d39b05"},{"cell_type":"markdown","metadata":{"id":"e2697c11"},"source":["**Problem**\n","\n","Sometimes 90 degrees routes do not have enough space for a Manhattan route"],"id":"e2697c11"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c7e757f4"},"outputs":[],"source":["c = gf.Component(\"route_fail_1\")\n","c1 = c << gf.components.nxn(east=3, ysize=20)\n","c2 = c << gf.components.nxn(west=3)\n","c2.move((80, 0))\n","c.plot()"],"id":"c7e757f4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"80c35fd6"},"outputs":[],"source":["c = gf.Component(\"route_fail_v2\")\n","c1 = c << gf.components.nxn(east=3, ysize=20)\n","c2 = c << gf.components.nxn(west=3)\n","c2.move((80, 0))\n","routes = gf.routing.get_bundle(\n","    c1.get_ports_list(orientation=0),\n","    c2.get_ports_list(orientation=180),\n","    auto_widen=False,\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"80c35fd6"},{"cell_type":"code","execution_count":null,"metadata":{"id":"20c025f1"},"outputs":[],"source":["c = gf.Component(\"route_fail_v3\")\n","pitch = 2.0\n","ys_left = [0, 10, 20]\n","N = len(ys_left)\n","ys_right = [(i - N / 2) * pitch for i in range(N)]\n","layer = (1, 0)\n","\n","right_ports = [\n","    gf.Port(f\"R_{i}\", center=(0, ys_right[i]), width=0.5, orientation=180, layer=layer)\n","    for i in range(N)\n","]\n","left_ports = [\n","    gf.Port(f\"L_{i}\", center=(-50, ys_left[i]), width=0.5, orientation=0, layer=layer)\n","    for i in range(N)\n","]\n","left_ports.reverse()\n","routes = gf.routing.get_bundle(right_ports, left_ports, radius=5)\n","\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"20c025f1"},{"cell_type":"markdown","metadata":{"id":"51730078"},"source":["**Solution**\n","\n","Add Sbend routes using `get_bundle_sbend`"],"id":"51730078"},{"cell_type":"code","execution_count":null,"metadata":{"id":"9e2c6333"},"outputs":[],"source":["c = gf.Component(\"route_solution_1_get_bundle_sbend\")\n","c1 = c << gf.components.nxn(east=3, ysize=20)\n","c2 = c << gf.components.nxn(west=3)\n","c2.move((80, 0))\n","routes = gf.routing.get_bundle_sbend(\n","    c1.get_ports_list(orientation=0), c2.get_ports_list(orientation=180)\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"9e2c6333"},{"cell_type":"markdown","metadata":{"id":"d9a28362"},"source":["You can also `get_bundle` adding `with_sbend=True`"],"id":"d9a28362"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"bef4e9e4"},"outputs":[],"source":["c = gf.Component(\"route_solution_2_get_bundle\")\n","c1 = c << gf.components.nxn(east=3, ysize=20)\n","c2 = c << gf.components.nxn(west=3)\n","c2.move((80, 0))\n","routes = gf.routing.get_bundle(\n","    c1.get_ports_list(orientation=0),\n","    c2.get_ports_list(orientation=180),\n","    with_sbend=True,\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"bef4e9e4"},{"cell_type":"markdown","metadata":{"id":"2256c9ed"},"source":["### get_bundle with path_length_match\n","\n","Sometimes you need to route two groups of ports keeping the same route lengths."],"id":"2256c9ed"},{"cell_type":"code","execution_count":null,"metadata":{"id":"74ef586f"},"outputs":[],"source":["c = gf.Component(\"path_length_match_routing\")\n","dy = 2000.0\n","xs1 = [-500, -300, -100, -90, -80, -55, -35, 200, 210, 240, 500, 650]\n","\n","pitch = 100.0\n","N = len(xs1)\n","xs2 = [-20 + i * pitch for i in range(N)]\n","\n","a1 = 90\n","a2 = a1 + 180\n","layer = (1, 0)\n","\n","ports1 = [\n","    gf.Port(f\"top_{i}\", center=(xs1[i], 0), width=0.5, orientation=a1, layer=layer)\n","    for i in range(N)\n","]\n","ports2 = [\n","    gf.Port(f\"bot_{i}\", center=(xs2[i], dy), width=0.5, orientation=a2, layer=layer)\n","    for i in range(N)\n","]\n","\n","routes = gf.routing.get_bundle(\n","    ports1,\n","    ports2,\n","    path_length_match_loops=1,\n","    path_length_match_modify_segment_i=-2,\n","    end_straight_length=800,\n",")\n","\n","for route in routes:\n","    c.add(route.references)\n","    print(route.length)\n","c.plot_klayout()\n","c.show()"],"id":"74ef586f"},{"cell_type":"markdown","metadata":{"id":"7868c12c"},"source":["### path_length_match with extra length\n","\n","You can also add some extra length to all the routes"],"id":"7868c12c"},{"cell_type":"code","execution_count":null,"metadata":{"id":"13eaa3ae"},"outputs":[],"source":["c = gf.Component(\"get_bundle_path_length_match_extra_length\")\n","\n","dy = 2000.0\n","xs1 = [-500, -300, -100, -90, -80, -55, -35, 200, 210, 240, 500, 650]\n","\n","pitch = 100.0\n","N = len(xs1)\n","xs2 = [-20 + i * pitch for i in range(N)]\n","\n","a1 = 90\n","a2 = a1 + 180\n","layer = (1, 0)\n","\n","ports1 = [\n","    gf.Port(f\"top_{i}\", center=(xs1[i], 0), width=0.5, orientation=a1, layer=layer)\n","    for i in range(N)\n","]\n","ports2 = [\n","    gf.Port(f\"bot_{i}\", center=(xs2[i], dy), width=0.5, orientation=a2, layer=layer)\n","    for i in range(N)\n","]\n","\n","routes = gf.routing.get_bundle(\n","    ports1,\n","    ports2,\n","    path_length_match_extra_length=44,\n","    path_length_match_loops=2,\n","    end_straight_length=800,\n",")\n","for route in routes:\n","    c.add(route.references)\n","    print(route.length)\n","c.plot()"],"id":"13eaa3ae"},{"cell_type":"markdown","metadata":{"id":"b64d4782"},"source":["### path length match with extra loops\n","\n","You can also increase the number of loops"],"id":"b64d4782"},{"cell_type":"code","execution_count":null,"metadata":{"id":"2c84c94e"},"outputs":[],"source":["c = gf.Component(\"get_route_path_length_match_nb_loops\")\n","\n","dy = 2000.0\n","xs1 = [-500, -300, -100, -90, -80, -55, -35, 200, 210, 240, 500, 650]\n","\n","pitch = 200.0\n","N = len(xs1)\n","xs2 = [-20 + i * pitch for i in range(N)]\n","\n","a1 = 90\n","a2 = a1 + 180\n","layer = (1, 0)\n","\n","ports1 = [\n","    gf.Port(f\"top_{i}\", center=(xs1[i], 0), width=0.5, orientation=a1, layer=layer)\n","    for i in range(N)\n","]\n","ports2 = [\n","    gf.Port(f\"bot_{i}\", center=(xs2[i], dy), width=0.5, orientation=a2, layer=layer)\n","    for i in range(N)\n","]\n","\n","routes = gf.routing.get_bundle(\n","    ports1,\n","    ports2,\n","    path_length_match_loops=2,\n","    auto_widen=False,\n","    end_straight_length=800,\n","    separation=30,\n",")\n","for route in routes:\n","    c.add(route.references)\n","    print(route.length)\n","c.plot()"],"id":"2c84c94e"},{"cell_type":"markdown","metadata":{"id":"b59aed82"},"source":["Sometimes you need to modify `separation` to ensure waveguides don't overlap."],"id":"b59aed82"},{"cell_type":"code","execution_count":null,"metadata":{"id":"59b1c2e2"},"outputs":[],"source":["c = gf.Component(\"problem_path_length_match\")\n","c1 = c << gf.components.straight_array(spacing=90)\n","c2 = c << gf.components.straight_array(spacing=5)\n","c2.movex(200)\n","c1.y = 0\n","c2.y = 0\n","\n","routes = gf.routing.get_bundle(\n","    c1.get_ports_list(orientation=0),\n","    c2.get_ports_list(orientation=180),\n","    end_straight_length=0,\n","    start_straight_length=0,\n","    separation=30,  # not enough\n","    radius=5,\n","    path_length_match_loops=1,\n",")\n","\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"59b1c2e2"},{"cell_type":"code","execution_count":null,"metadata":{"id":"682ce6c1"},"outputs":[],"source":["c = gf.Component(\"solution_path_length_match\")\n","c1 = c << gf.components.straight_array(spacing=90)\n","c2 = c << gf.components.straight_array(spacing=5)\n","c2.movex(200)\n","c1.y = 0\n","c2.y = 0\n","\n","routes = gf.routing.get_bundle(\n","    c1.get_ports_list(orientation=0),\n","    c2.get_ports_list(orientation=180),\n","    end_straight_length=0,\n","    start_straight_length=0,\n","    separation=80,  # increased\n","    path_length_match_loops=1,\n","    radius=5,\n",")\n","\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"682ce6c1"},{"cell_type":"markdown","metadata":{"id":"0442b264"},"source":["### get bundle with different orientation ports\n","\n","When trying to route ports with different orientations you need to bring them to a common `x` or `y`\n","\n","\n","1. Use `route_ports_to_side` to bring all the ports to a common angle orientation and x or y.\n","2. Use `get_bundle` to connect to the other group of ports."],"id":"0442b264"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c3adaa8f"},"outputs":[],"source":["from gdsfactory.samples.big_device import big_device\n","\n","c = gf.Component(\"sample_route\")\n","c1 = c << big_device()\n","c2 = c << gf.components.grating_coupler_array(n=len(c1.ports), rotation=-90)\n","\n","routes, ports = gf.routing.route_ports_to_side(c1.ports, side=\"south\")\n","for route in routes:\n","    c.add(route.references)\n","\n","c2.ymin = -600\n","c2.x = 0\n","\n","routes = gf.routing.get_bundle(ports, c2.ports)\n","for route in routes:\n","    c.add(route.references)\n","\n","c.plot_klayout()\n","c.show()"],"id":"c3adaa8f"},{"cell_type":"markdown","metadata":{"id":"d50567e7"},"source":["## get_bundle_from_steps\n","\n","This is a manual version of `get_bundle` that is more convenient than defining the waypoints."],"id":"d50567e7"},{"cell_type":"code","execution_count":null,"metadata":{"id":"e90c02ca"},"outputs":[],"source":["c = gf.Component(\"get_route_from_steps_sample\")\n","w = gf.components.array(\n","    partial(gf.components.straight, layer=(2, 0)),\n","    rows=3,\n","    columns=1,\n","    spacing=(0, 50),\n",")\n","\n","left = c << w\n","right = c << w\n","right.move((200, 100))\n","p1 = left.get_ports_list(orientation=0)\n","p2 = right.get_ports_list(orientation=180)\n","\n","routes = gf.routing.get_bundle_from_steps(\n","    p1,\n","    p2,\n","    steps=[{\"x\": 150}],\n",")\n","\n","for route in routes:\n","    c.add(route.references)\n","\n","c.plot()"],"id":"e90c02ca"},{"cell_type":"code","source":[],"metadata":{"id":"9kxaUzRmtJty"},"id":"9kxaUzRmtJty","execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"dd481d4f"},"source":["# Routing to IO\n","\n","## Routing electrical\n","\n","For routing low speed DC electrical ports you can use sharp corners instead of smooth bends.\n","\n","You can also define `port.orientation = None` to ignore the port orientation for low speed DC ports."],"id":"dd481d4f"},{"cell_type":"markdown","metadata":{"id":"4ebaf7f0"},"source":["For single route between ports you can use `get_route_electrical`\n","\n","### get_route_electrical\n","\n","\n","`get_route_electrical` has `bend = wire_corner` with a 90deg bend corner."],"id":"4ebaf7f0"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f6174479"},"outputs":[],"source":["from functools import partial\n","\n","import gdsfactory as gf\n","from gdsfactory.generic_tech import get_generic_pdk\n","from gdsfactory.samples.big_device import big_device\n","\n","gf.config.rich_output()\n","PDK = get_generic_pdk()\n","PDK.activate()\n","\n","c = gf.Component(\"pads\")\n","pt = c << gf.components.pad_array(orientation=270, columns=3)\n","pb = c << gf.components.pad_array(orientation=90, columns=3)\n","pt.move((70, 200))\n","c.plot()"],"id":"f6174479"},{"cell_type":"code","execution_count":null,"metadata":{"id":"9584b957"},"outputs":[],"source":["c = gf.Component(\"pads_with_routes_with_bends\")\n","pt = c << gf.components.pad_array(orientation=270, columns=3)\n","pb = c << gf.components.pad_array(orientation=90, columns=3)\n","pt.move((70, 200))\n","route = gf.routing.get_route_electrical(\n","    pt.ports[\"e11\"], pb.ports[\"e11\"], bend=\"bend_euler\", radius=30\n",")\n","c.add(route.references)\n","c.plot()"],"id":"9584b957"},{"cell_type":"code","execution_count":null,"metadata":{"id":"374342ed"},"outputs":[],"source":["c = gf.Component(\"pads_with_routes_with_wire_corners\")\n","pt = c << gf.components.pad_array(orientation=270, columns=3)\n","pb = c << gf.components.pad_array(orientation=90, columns=3)\n","pt.move((70, 200))\n","route = gf.routing.get_route_electrical(\n","    pt.ports[\"e11\"], pb.ports[\"e11\"], bend=\"wire_corner\"\n",")\n","c.add(route.references)\n","c.plot()"],"id":"374342ed"},{"cell_type":"code","execution_count":null,"metadata":{"id":"bd134375"},"outputs":[],"source":["c = gf.Component(\"pads_with_routes_with_wire_corners_no_orientation\")\n","pt = c << gf.components.pad_array(orientation=None, columns=3)\n","pb = c << gf.components.pad_array(orientation=None, columns=3)\n","pt.move((70, 200))\n","route = gf.routing.get_route_electrical(\n","    pt.ports[\"e11\"], pb.ports[\"e11\"], bend=\"wire_corner\"\n",")\n","c.add(route.references)\n","c.plot()"],"id":"bd134375"},{"cell_type":"code","execution_count":null,"metadata":{"id":"7df51530"},"outputs":[],"source":["c = gf.Component(\"multi-layer\")\n","columns = 2\n","ptop = c << gf.components.pad_array(columns=columns)\n","pbot = c << gf.components.pad_array(orientation=90, columns=columns)\n","\n","ptop.movex(300)\n","ptop.movey(300)\n","route = gf.routing.get_route_electrical_multilayer(\n","    ptop.ports[\"e11\"],\n","    pbot.ports[\"e11\"],\n","    end_straight_length=100,\n",")\n","c.add(route.references)\n","c.plot()"],"id":"7df51530"},{"cell_type":"markdown","metadata":{"id":"4421d52b"},"source":["There is also `bend = wire_corner45` for 45deg bend corner with parametrizable \"radius\":"],"id":"4421d52b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"3ad5812e"},"outputs":[],"source":["c = gf.Component(\"pads_with_routes_with_wire_corner45\")\n","pt = c << gf.components.pad_array(orientation=270, columns=1)\n","pb = c << gf.components.pad_array(orientation=90, columns=1)\n","pt.move((300, 300))\n","route = gf.routing.get_route_electrical(\n","    pt.ports[\"e11\"], pb.ports[\"e11\"], bend=\"wire_corner45\", radius=30\n",")\n","c.add(route.references)\n","c.plot()"],"id":"3ad5812e"},{"cell_type":"code","execution_count":null,"metadata":{"id":"aeff59d5"},"outputs":[],"source":["c = gf.Component(\"pads_with_routes_with_wire_corner45\")\n","pt = c << gf.components.pad_array(orientation=270, columns=1)\n","pb = c << gf.components.pad_array(orientation=90, columns=1)\n","pt.move((300, 300))\n","route = gf.routing.get_route_electrical(\n","    pt.ports[\"e11\"], pb.ports[\"e11\"], bend=\"wire_corner45\", radius=100\n",")\n","c.add(route.references)\n","c.plot()"],"id":"aeff59d5"},{"cell_type":"markdown","metadata":{"id":"eee799ac"},"source":["### route_quad"],"id":"eee799ac"},{"cell_type":"code","execution_count":null,"metadata":{"id":"875b7176"},"outputs":[],"source":["c = gf.Component(\"pads_route_quad\")\n","pt = c << gf.components.pad_array(orientation=270, columns=3)\n","pb = c << gf.components.pad_array(orientation=90, columns=3)\n","pt.move((100, 200))\n","route = c << gf.routing.route_quad(pt.ports[\"e11\"], pb.ports[\"e11\"], layer=(49, 0))\n","c.plot()"],"id":"875b7176"},{"cell_type":"markdown","metadata":{"id":"dbf8904c"},"source":["### get_route_from_steps"],"id":"dbf8904c"},{"cell_type":"code","execution_count":null,"metadata":{"id":"235071b3"},"outputs":[],"source":["c = gf.Component(\"pads_route_from_steps\")\n","pt = c << gf.components.pad_array(orientation=270, columns=3)\n","pb = c << gf.components.pad_array(orientation=90, columns=3)\n","pt.move((100, 200))\n","route = gf.routing.get_route_from_steps(\n","    pb.ports[\"e11\"],\n","    pt.ports[\"e11\"],\n","    steps=[\n","        {\"y\": 200},\n","    ],\n","    cross_section=\"metal_routing\",\n","    bend=gf.components.wire_corner,\n",")\n","c.add(route.references)\n","c.plot()"],"id":"235071b3"},{"cell_type":"code","execution_count":null,"metadata":{"id":"561e463f"},"outputs":[],"source":["c = gf.Component(\"pads_route_from_steps_None_orientation\")\n","pt = c << gf.components.pad_array(orientation=None, columns=3)\n","pb = c << gf.components.pad_array(orientation=None, columns=3)\n","pt.move((100, 200))\n","route = gf.routing.get_route_from_steps(\n","    pb.ports[\"e11\"],\n","    pt.ports[\"e11\"],\n","    steps=[\n","        {\"y\": 200},\n","    ],\n","    cross_section=\"metal_routing\",\n","    bend=gf.components.wire_corner,\n",")\n","c.add(route.references)\n","c.plot()"],"id":"561e463f"},{"cell_type":"markdown","metadata":{"id":"6eef6569"},"source":["### get_bundle_electrical\n","\n","For routing groups of ports you can use `get_bundle` that returns a bundle of routes using a bundle router (also known as bus or river router)"],"id":"6eef6569"},{"cell_type":"code","execution_count":null,"metadata":{"id":"889626ce"},"outputs":[],"source":["c = gf.Component(\"pads_bundle\")\n","pt = c << gf.components.pad_array(orientation=270, columns=3)\n","pb = c << gf.components.pad_array(orientation=90, columns=3)\n","pt.move((100, 200))\n","\n","routes = gf.routing.get_bundle_electrical(\n","    pb.ports, pt.ports, end_straight_length=60, separation=30\n",")\n","\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"889626ce"},{"cell_type":"markdown","metadata":{"id":"aa6005f4"},"source":["### get_bundle_from_steps_electrical"],"id":"aa6005f4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"ecf7a272"},"outputs":[],"source":["c = gf.Component(\"pads_bundle_steps\")\n","pt = c << gf.components.pad_array(\n","    partial(gf.components.pad, size=(30, 30)),\n","    orientation=270,\n","    columns=3,\n","    spacing=(50, 0),\n",")\n","pb = c << gf.components.pad_array(orientation=90, columns=3)\n","pt.move((300, 500))\n","\n","routes = gf.routing.get_bundle_from_steps_electrical(\n","    pb.ports, pt.ports, end_straight_length=60, separation=30, steps=[{\"dy\": 100}]\n",")\n","\n","for route in routes:\n","    c.add(route.references)\n","\n","c.plot()"],"id":"ecf7a272"},{"cell_type":"markdown","metadata":{"id":"55e35e6f"},"source":["### get_bundle_electrical_multilayer\n","\n","To avoid metal crossings you can use one metal layer."],"id":"55e35e6f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"22e855c1"},"outputs":[],"source":["c = gf.Component(\"get_bundle_multi_layer\")\n","columns = 2\n","ptop = c << gf.components.pad_array(columns=columns)\n","pbot = c << gf.components.pad_array(orientation=90, columns=columns)\n","\n","ptop.movex(300)\n","ptop.movey(300)\n","routes = gf.routing.get_bundle_electrical_multilayer(\n","    ptop.ports, pbot.ports, end_straight_length=100, separation=20\n",")\n","for route in routes:\n","    c.add(route.references)\n","c.plot()"],"id":"22e855c1"},{"cell_type":"markdown","metadata":{"id":"1460b976"},"source":["## Routing to pads\n","\n","You can also route to electrical pads."],"id":"1460b976"},{"cell_type":"code","execution_count":null,"metadata":{"id":"cd17582d"},"outputs":[],"source":["c = gf.components.straight_heater_metal(length=100.0)\n","cc = gf.routing.add_pads_bot(component=c, port_names=(\"l_e4\", \"r_e4\"), fanout_length=50)\n","cc.plot()"],"id":"cd17582d"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"230676fa"},"outputs":[],"source":["c = gf.components.straight_heater_metal(length=100.0)\n","cc = gf.routing.add_pads_top(component=c)\n","cc.plot()"],"id":"230676fa"},{"cell_type":"code","execution_count":null,"metadata":{"id":"e28720d5"},"outputs":[],"source":["c = gf.components.straight_heater_metal(length=100.0)\n","cc = gf.routing.add_pads_top(component=c, port_names=(\"l_e2\", \"r_e2\"))\n","cc.plot()"],"id":"e28720d5"},{"cell_type":"code","execution_count":null,"metadata":{"id":"33340c1f"},"outputs":[],"source":["n = west = north = south = east = 10\n","spacing = 20\n","c = gf.components.nxn(\n","    xsize=n * spacing,\n","    ysize=n * spacing,\n","    west=west,\n","    east=east,\n","    north=north,\n","    south=south,\n","    port_type=\"electrical\",\n","    wg_width=10,\n",")\n","c.plot()"],"id":"33340c1f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"13fd2656"},"outputs":[],"source":["cc = gf.routing.add_pads_top(component=c)\n","cc.plot()"],"id":"13fd2656"},{"cell_type":"markdown","metadata":{"id":"daccc0ba"},"source":["## Routing to optical terminations\n","\n","### Route to Fiber Array\n","\n","You can route to a fiber array."],"id":"daccc0ba"},{"cell_type":"code","execution_count":null,"metadata":{"id":"f8f188ca"},"outputs":[],"source":["component = big_device(nports=10)\n","c = gf.routing.add_fiber_array(component=component, radius=10.0, fanout_length=60.0)\n","c.plot()"],"id":"f8f188ca"},{"cell_type":"markdown","metadata":{"id":"e74d5ed4"},"source":["You can also mix and match TE and TM grating couplers. Notice that the `TM` polarization grating coupler is bigger."],"id":"e74d5ed4"},{"cell_type":"code","execution_count":null,"metadata":{"id":"2c477819"},"outputs":[],"source":["import gdsfactory as gf\n","\n","c = gf.components.mzi_phase_shifter()\n","gcte = gf.components.grating_coupler_te\n","\n","cc = gf.routing.add_fiber_array(\n","    component=c,\n","    optical_routing_type=2,\n","    grating_coupler=[\n","        gf.components.grating_coupler_te,\n","        gf.components.grating_coupler_tm,\n","    ],\n","    radius=20,\n",")\n","cc.plot()"],"id":"2c477819"},{"cell_type":"markdown","metadata":{"id":"7e2fbecd"},"source":["### Route to Single fibers\n","\n","You can route to a single fiber input and single fiber output."],"id":"7e2fbecd"},{"cell_type":"code","execution_count":null,"metadata":{"id":"165f7c06"},"outputs":[],"source":["c = gf.components.ring_single()\n","cc = gf.routing.add_fiber_single(component=c)\n","cc.plot()"],"id":"165f7c06"},{"cell_type":"markdown","metadata":{"id":"ca763ce2"},"source":["### Route to edge couplers\n","\n","You can also route Edge couplers to a fiber array or to both sides of the chip.\n","\n","For routing to both sides you can follow different strategies:\n","\n","1. Place the edge couplers and route your components to the edge couplers.\n","2. Extend your component ports to each side.\n","3. Anything you imagine ..."],"id":"ca763ce2"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"2f60030d"},"outputs":[],"source":["import numpy as np\n","\n","import gdsfactory as gf\n","from gdsfactory.generic_tech import LAYER\n","\n","\n","@gf.cell\n","def sample_die(size=(8e3, 40e3), y_spacing: float = 10) -> gf.Component:\n","    \"\"\"Returns a sample die\n","\n","    Args:\n","        size: size of the die.\n","        y_spacing: spacing between components.\n","\n","    Returns:\n","        c: a sample die.\n","\n","    \"\"\"\n","    c = gf.Component()\n","\n","    die = c << gf.c.rectangle(size=np.array(size), layer=LAYER.FLOORPLAN, centered=True)\n","    die = c << gf.c.rectangle(\n","        size=np.array(size) - 2 * np.array((50, 50)),\n","        layer=LAYER.FLOORPLAN,\n","        centered=True,\n","    )\n","    ymin = die.ymin\n","    ec = gf.components.edge_coupler_silicon()\n","\n","    cells = gf.components.cells\n","    skip = [\n","        \"component_lattice\",\n","        \"component_sequence\",\n","        \"extend_port\",\n","        \"extend_ports_list\",\n","        \"die\",\n","        \"wafer\",\n","    ]\n","    for component_name in skip:\n","        cells.pop(component_name, None)\n","\n","    for component in cells.values():\n","        ci = component()\n","        ci = (\n","            gf.routing.add_pads_top(\n","                ci,\n","                pad=gf.components.pad,\n","                pad_spacing=150,\n","            )\n","            if ci.get_ports_list(port_type=\"electrical\")\n","            else ci\n","        )\n","        ref = c << ci\n","        ref.ymin = ymin\n","        ref.x = 0\n","        ymin = ref.ymax + y_spacing\n","\n","        routes_left, ports_left = gf.routing.route_ports_to_side(\n","            ref.get_ports_list(orientation=180),\n","            cross_section=\"strip\",\n","            side=\"west\",\n","            x=die.xmin + ec.xsize,\n","        )\n","        for route in routes_left:\n","            c.add(route.references)\n","\n","        routes_right, ports_right = gf.routing.route_ports_to_side(\n","            ref.get_ports_list(orientation=0),\n","            cross_section=\"strip\",\n","            x=die.xmax - ec.xsize,\n","            side=\"east\",\n","        )\n","        for route in routes_right:\n","            c.add(route.references)\n","\n","        for port in ports_right:\n","            ref = c << ec\n","            ref.connect(\"o1\", port)\n","            text = c << gf.c.text(\n","                text=f\"{ci.name}-{port.name.split('_')[0]}\", size=10, layer=LAYER.MTOP\n","            )\n","            text.xmax = ref.xmax - 10\n","            text.y = ref.y\n","\n","        for port in ports_left:\n","            ref = c << ec\n","            ref.connect(\"o1\", port)\n","            text = c << gf.c.text(\n","                text=f\"{ci.name}-{port.name.split('_')[0]}\", size=10, layer=LAYER.MTOP\n","            )\n","            text.xmin = ref.xmin + 10\n","            text.y = ref.y\n","\n","    return c\n","\n","\n","if __name__ == \"__main__\":\n","    c = sample_die(cache=False)\n","    c.show(show_ports=True)\n","    c.plot()"],"id":"2f60030d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"cc012d22"},"outputs":[],"source":[],"id":"cc012d22"},{"cell_type":"markdown","metadata":{"id":"26dc1285"},"source":["# PDK examples\n","\n","Different PDKs have different component libraries, design rules and layer stacks (GDS layers, materials and thickness).\n","\n","When you install a PDK you have to make sure you also installed the correct version of gdsfactory.\n","\n","Notice that some PDKs may have require different gdsfactory versions."],"id":"26dc1285"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"2c90e444"},"outputs":[],"source":["from collections.abc import Callable\n","from functools import partial\n","\n","from pydantic import BaseModel\n","\n","import gdsfactory as gf\n","from gdsfactory.add_pins import add_pin_rectangle_inside\n","from gdsfactory.component import Component\n","from gdsfactory.config import CONF\n","from gdsfactory.cross_section import cross_section\n","from gdsfactory.technology import (\n","    LayerLevel,\n","    LayerStack,\n","    LayerView,\n","    LayerViews,\n",")\n","from gdsfactory.typings import Layer\n","from gdsfactory.config import print_version_pdks, print_version_plugins\n","from gdsfactory.generic_tech import get_generic_pdk\n","\n","gf.config.rich_output()\n","nm = 1e-3"],"id":"2c90e444"},{"cell_type":"code","execution_count":null,"metadata":{"id":"ea3e96ab"},"outputs":[],"source":["CONF.display_type = \"klayout\"\n","\n","p = gf.get_active_pdk()\n","p.name"],"id":"ea3e96ab"},{"cell_type":"code","execution_count":null,"metadata":{"id":"915d35d0"},"outputs":[],"source":["print_version_plugins()"],"id":"915d35d0"},{"cell_type":"code","execution_count":null,"metadata":{"id":"4db183b8"},"outputs":[],"source":["print_version_pdks()"],"id":"4db183b8"},{"cell_type":"markdown","metadata":{"lines_to_next_cell":2,"id":"f5709771"},"source":["### FabA\n","\n","FabA only has one waveguide layer available that is defined in GDS layer (30, 0)\n","\n","The waveguide traces are 2um wide."],"id":"f5709771"},{"cell_type":"code","execution_count":null,"metadata":{"id":"85cf7ffa"},"outputs":[],"source":["class LayerMap(BaseModel):\n","    WG: Layer = (34, 0)\n","    SLAB150: Layer = (2, 0)\n","    DEVREC: Layer = (68, 0)\n","    PORT: Layer = (1, 10)\n","    PORTE: Layer = (1, 11)\n","    TE: Layer = (203, 0)\n","    TM: Layer = (204, 0)\n","    TEXT: Layer = (66, 0)\n","\n","\n","LAYER = LayerMap()\n","\n","\n","class FabALayerViews(LayerViews):\n","    WG = LayerView(color=\"gold\")\n","    SLAB150 = LayerView(color=\"red\")\n","    TE = LayerView(color=\"green\")\n","\n","\n","LAYER_VIEWS = FabALayerViews(layer_map=LAYER.dict())\n","\n","\n","def get_layer_stack_faba(\n","    thickness_wg: float = 500 * nm, thickness_slab: float = 150 * nm\n",") -> LayerStack:\n","    \"\"\"Returns fabA LayerStack\"\"\"\n","\n","    class FabALayerStack(LayerStack):\n","        strip = LayerLevel(\n","            layer=LAYER.WG,\n","            thickness=thickness_wg,\n","            zmin=0.0,\n","            material=\"si\",\n","        )\n","        strip2 = LayerLevel(\n","            layer=LAYER.SLAB150,\n","            thickness=thickness_slab,\n","            zmin=0.0,\n","            material=\"si\",\n","        )\n","\n","    return FabALayerStack()\n","\n","\n","LAYER_STACK = get_layer_stack_faba()\n","\n","WIDTH = 2\n","\n","# Specify a cross_section to use\n","strip = partial(gf.cross_section.cross_section, width=WIDTH, layer=LAYER.WG)\n","\n","mmi1x2 = partial(\n","    gf.components.mmi1x2,\n","    width=WIDTH,\n","    width_taper=WIDTH,\n","    width_mmi=3 * WIDTH,\n","    cross_section=strip,\n",")\n","\n","generic_pdk = get_generic_pdk()\n","\n","fab_a = gf.Pdk(\n","    name=\"Fab_A\",\n","    cells=dict(mmi1x2=mmi1x2),\n","    cross_sections=dict(strip=strip),\n","    layers=LAYER.dict(),\n","    base_pdk=generic_pdk,\n","    sparameters_path=gf.config.sparameters_path,\n","    layer_views=LAYER_VIEWS,\n","    layer_stack=LAYER_STACK,\n",")\n","fab_a.activate()\n","\n","gc = partial(\n","    gf.components.grating_coupler_elliptical_te, layer=LAYER.WG, cross_section=strip\n",")\n","\n","c = gf.components.mzi()\n","c_gc = gf.routing.add_fiber_array(component=c, grating_coupler=gc, with_loopback=False)\n","c_gc.plot()"],"id":"85cf7ffa"},{"cell_type":"code","execution_count":null,"metadata":{"id":"9f070fd1"},"outputs":[],"source":["scene = c_gc.to_3d()\n","scene.show(show_ports=True)"],"id":"9f070fd1"},{"cell_type":"markdown","metadata":{"id":"f779a815"},"source":["### FabB\n","\n","FabB has photonic waveguides that require rectangular cladding layers to avoid dopants\n","\n","Lets say that the waveguides are defined in layer (2, 0) and are 0.3um wide, 1um thick\n"],"id":"f779a815"},{"cell_type":"code","execution_count":null,"metadata":{"id":"8d3ab3ee"},"outputs":[],"source":["nm = 1e-3\n","\n","\n","class LayerMap(BaseModel):\n","    WG: Layer = (2, 0)\n","    SLAB150: Layer = (3, 0)\n","    DEVREC: Layer = (68, 0)\n","    PORT: Layer = (1, 10)\n","    PORTE: Layer = (1, 11)\n","    TE: Layer = (203, 0)\n","    TM: Layer = (204, 0)\n","    TEXT: Layer = (66, 0)\n","    LABEL: Layer = (201, 0)\n","    DOPING_BLOCK1: Layer = (61, 0)\n","    DOPING_BLOCK2: Layer = (62, 0)\n","\n","\n","LAYER = LayerMap()\n","\n","\n","# The LayerViews class supports grouping LayerViews within each other.\n","# These groups are maintained when exporting a LayerViews object to a KLayout layer properties (.lyp) file.\n","class FabBLayerViews(LayerViews):\n","    WG = LayerView(color=\"red\")\n","    SLAB150 = LayerView(color=\"blue\")\n","    TE = LayerView(color=\"green\")\n","    PORT = LayerView(color=\"green\", alpha=0)\n","\n","    class DopingBlockGroup(LayerView):\n","        DOPING_BLOCK1 = LayerView(color=\"green\", alpha=0)\n","        DOPING_BLOCK2 = LayerView(color=\"green\", alpha=0)\n","\n","    DopingBlocks = DopingBlockGroup()\n","\n","\n","LAYER_VIEWS = FabBLayerViews(layer_map=LAYER)\n","\n","\n","def get_layer_stack_fab_b(\n","    thickness_wg: float = 1000 * nm, thickness_slab: float = 150 * nm\n",") -> LayerStack:\n","    \"\"\"Returns fabA LayerStack.\"\"\"\n","\n","    class FabBLayerStack(LayerStack):\n","        strip = LayerLevel(\n","            layer=LAYER.WG,\n","            thickness=thickness_wg,\n","            zmin=0.0,\n","            material=\"si\",\n","        )\n","        strip2 = LayerLevel(\n","            layer=LAYER.SLAB150,\n","            thickness=thickness_slab,\n","            zmin=0.0,\n","            material=\"si\",\n","        )\n","\n","    return FabBLayerStack()\n","\n","\n","LAYER_STACK = get_layer_stack_fab_b()\n","\n","\n","WIDTH = 0.3\n","BBOX_LAYERS = (LAYER.DOPING_BLOCK1, LAYER.DOPING_BLOCK2)\n","BBOX_OFFSETS = (3, 3)\n","\n","# use cladding_layers and cladding_offsets if the foundry prefers conformal blocking doping layers instead of squared\n","# bbox_layers and bbox_offsets makes rectangular waveguides.\n","strip = partial(\n","    gf.cross_section.cross_section,\n","    width=WIDTH,\n","    layer=LAYER.WG,\n","    # bbox_layers=BBOX_LAYERS,\n","    # bbox_offsets=BBOX_OFFSETS,\n","    cladding_layers=BBOX_LAYERS,\n","    cladding_offsets=BBOX_OFFSETS,\n",")\n","\n","straight = partial(gf.components.straight, cross_section=strip)\n","bend_euler = partial(gf.components.bend_euler, cross_section=strip)\n","mmi1x2 = partial(\n","    gf.components.mmi1x2,\n","    cross_section=strip,\n","    width=WIDTH,\n","    width_taper=WIDTH,\n","    width_mmi=4 * WIDTH,\n",")\n","mzi = partial(gf.components.mzi, cross_section=strip, splitter=mmi1x2)\n","gc = partial(\n","    gf.components.grating_coupler_elliptical_te, layer=LAYER.WG, cross_section=strip\n",")\n","\n","cells = dict(\n","    gc=gc,\n","    mzi=mzi,\n","    mmi1x2=mmi1x2,\n","    bend_euler=bend_euler,\n","    straight=straight,\n","    taper=gf.components.taper,\n",")\n","cross_sections = dict(strip=strip)\n","\n","pdk = gf.Pdk(\n","    name=\"fab_b\",\n","    cells=cells,\n","    cross_sections=cross_sections,\n","    layers=LAYER.dict(),\n","    sparameters_path=gf.config.sparameters_path,\n","    layer_views=LAYER_VIEWS,\n","    layer_stack=LAYER_STACK,\n",")\n","pdk.activate()\n","\n","\n","c = mzi()\n","wg_gc = gf.routing.add_fiber_array(\n","    component=c, grating_coupler=gc, cross_section=strip, with_loopback=False\n",")\n","wg_gc.plot()"],"id":"8d3ab3ee"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c1e7bab9"},"outputs":[],"source":["scene = wg_gc.to_3d()\n","scene.show(show_ports=True)"],"id":"c1e7bab9"},{"cell_type":"markdown","metadata":{"id":"15022c72"},"source":["### FabC\n","\n","Lets assume that fab C has similar technology to the generic PDK in gdsfactory and that you just want to remap some layers, and adjust the widths.\n"],"id":"15022c72"},{"cell_type":"code","execution_count":null,"metadata":{"lines_to_next_cell":2,"id":"413b8b61"},"outputs":[],"source":["nm = 1e-3\n","\n","\n","class LayerMap(BaseModel):\n","    WG: Layer = (10, 1)\n","    WG_CLAD: Layer = (10, 2)\n","    WGN: Layer = (34, 0)\n","    WGN_CLAD: Layer = (36, 0)\n","    SLAB150: Layer = (2, 0)\n","    DEVREC: Layer = (68, 0)\n","    PORT: Layer = (1, 10)\n","    PORTE: Layer = (1, 11)\n","    TE: Layer = (203, 0)\n","    TM: Layer = (204, 0)\n","    TEXT: Layer = (66, 0)\n","    LABEL: Layer = (201, 0)\n","\n","\n","LAYER = LayerMap()\n","WIDTH_NITRIDE_OBAND = 0.9\n","WIDTH_NITRIDE_CBAND = 1.0\n","PORT_TYPE_TO_LAYER = dict(optical=(100, 0))\n","\n","\n","# This is something you usually define in KLayout\n","class FabCLayerViews(LayerViews):\n","    WG = LayerView(color=\"black\")\n","    SLAB150 = LayerView(color=\"blue\")\n","    WGN = LayerView(color=\"orange\")\n","    WGN_CLAD = LayerView(color=\"blue\", alpha=0, visible=False)\n","\n","    class SimulationGroup(LayerView):\n","        TE = LayerView(color=\"green\")\n","        PORT = LayerView(color=\"green\", alpha=0)\n","\n","    Simulation = SimulationGroup()\n","\n","    class DopingGroup(LayerView):\n","        DOPING_BLOCK1 = LayerView(color=\"green\", alpha=0, visible=False)\n","        DOPING_BLOCK2 = LayerView(color=\"green\", alpha=0, visible=False)\n","\n","    Doping = DopingGroup()\n","\n","\n","LAYER_VIEWS = FabCLayerViews(layer_map=LAYER)\n","\n","\n","def get_layer_stack_fab_c(\n","    thickness_wg: float = 350.0 * nm, thickness_clad: float = 3.0\n",") -> LayerStack:\n","    \"\"\"Returns generic LayerStack\"\"\"\n","\n","    class FabCLayerStack(LayerStack):\n","        core = LayerLevel(\n","            layer=LAYER.WGN,\n","            thickness=thickness_wg,\n","            zmin=0,\n","        )\n","        clad = LayerLevel(\n","            layer=LAYER.WGN_CLAD,\n","            thickness=thickness_clad,\n","            zmin=0,\n","        )\n","\n","    return FabCLayerStack()\n","\n","\n","LAYER_STACK = get_layer_stack_fab_c()\n","\n","\n","def add_pins(\n","    component: Component,\n","    function: Callable = add_pin_rectangle_inside,\n","    pin_length: float = 0.5,\n","    port_layer: Layer = LAYER.PORT,\n","    **kwargs,\n",") -> Component:\n","    \"\"\"Add Pin port markers.\n","\n","    Args:\n","        component: to add ports.\n","        function: to add pins.\n","        pin_length: in um.\n","        port_layer: spec.\n","        kwargs: function kwargs.\n","    \"\"\"\n","    for p in component.ports.values():\n","        function(\n","            component=component,\n","            port=p,\n","            layer=port_layer,\n","            layer_label=port_layer,\n","            pin_length=pin_length,\n","            **kwargs,\n","        )\n","    return component\n","\n","\n","# cross_section constants\n","bbox_layers = [LAYER.WGN_CLAD]\n","bbox_offsets = [3]\n","\n","# Nitride Cband\n","xs_nc = partial(\n","    cross_section,\n","    width=WIDTH_NITRIDE_CBAND,\n","    layer=LAYER.WGN,\n","    bbox_layers=bbox_layers,\n","    bbox_offsets=bbox_offsets,\n","    add_pins=add_pins,\n",")\n","# Nitride Oband\n","xs_no = partial(\n","    cross_section,\n","    width=WIDTH_NITRIDE_OBAND,\n","    layer=LAYER.WGN,\n","    bbox_layers=bbox_layers,\n","    bbox_offsets=bbox_offsets,\n","    add_pins=add_pins,\n",")\n","\n","\n","cross_sections = dict(xs_nc=xs_nc, xs_no=xs_no, strip=xs_nc)\n","\n","# LEAF cells have pins\n","mmi1x2_nc = partial(\n","    gf.components.mmi1x2,\n","    width=WIDTH_NITRIDE_CBAND,\n","    cross_section=xs_nc,\n",")\n","mmi1x2_no = partial(\n","    gf.components.mmi1x2,\n","    width=WIDTH_NITRIDE_OBAND,\n","    cross_section=xs_no,\n",")\n","bend_euler_nc = partial(\n","    gf.components.bend_euler,\n","    cross_section=xs_nc,\n",")\n","straight_nc = partial(\n","    gf.components.straight,\n","    cross_section=xs_nc,\n",")\n","bend_euler_no = partial(\n","    gf.components.bend_euler,\n","    cross_section=xs_no,\n",")\n","straight_no = partial(\n","    gf.components.straight,\n","    cross_section=xs_no,\n",")\n","\n","gc_nc = partial(\n","    gf.components.grating_coupler_elliptical_te,\n","    grating_line_width=0.6,\n","    layer=LAYER.WGN,\n","    cross_section=xs_nc,\n",")\n","\n","# HIERARCHICAL cells are made of leaf cells\n","mzi_nc = partial(\n","    gf.components.mzi,\n","    cross_section=xs_nc,\n","    splitter=mmi1x2_nc,\n","    straight=straight_nc,\n","    bend=bend_euler_nc,\n",")\n","mzi_no = partial(\n","    gf.components.mzi,\n","    cross_section=xs_no,\n","    splitter=mmi1x2_no,\n","    straight=straight_no,\n","    bend=bend_euler_no,\n",")\n","\n","\n","cells = dict(\n","    mmi1x2_nc=mmi1x2_nc,\n","    mmi1x2_no=mmi1x2_no,\n","    bend_euler_nc=bend_euler_nc,\n","    bend_euler_no=bend_euler_no,\n","    straight_nc=straight_nc,\n","    straight_no=straight_no,\n","    gc_nc=gc_nc,\n","    mzi_nc=mzi_nc,\n","    mzi_no=mzi_no,\n",")\n","\n","pdk = gf.Pdk(\n","    name=\"fab_c\",\n","    cells=cells,\n","    cross_sections=cross_sections,\n","    layers=LAYER.dict(),\n","    sparameters_path=gf.config.sparameters_path,\n","    layer_views=LAYER_VIEWS,\n","    layer_stack=LAYER_STACK,\n",")\n","pdk.activate()"],"id":"413b8b61"},{"cell_type":"code","execution_count":null,"metadata":{"id":"57d1ed8d"},"outputs":[],"source":["LAYER_VIEWS.layer_map.values()"],"id":"57d1ed8d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c209824d"},"outputs":[],"source":["mzi = mzi_nc()\n","mzi_gc = gf.routing.add_fiber_single(\n","    component=mzi,\n","    grating_coupler=gc_nc,\n","    cross_section=xs_nc,\n","    optical_routing_type=1,\n","    straight=straight_nc,\n","    bend=bend_euler_nc,\n",")\n","mzi_gc.plot()"],"id":"c209824d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"abe29fdd"},"outputs":[],"source":["c = mzi_gc.to_3d()\n","c.show(show_ports=True)"],"id":"abe29fdd"},{"cell_type":"code","execution_count":null,"metadata":{"id":"683f676b"},"outputs":[],"source":["ls = get_layer_stack_fab_c()"],"id":"683f676b"},{"cell_type":"code","source":[],"metadata":{"id":"s1f5Scc_uCwL"},"id":"s1f5Scc_uCwL","execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"7e5e5867"},"source":["# Import PDK\n","\n","## Import PDK from GDS files\n","\n","To import a PDK from GDS files into gdsfactory you need:\n","\n","- GDS file with all the cells that you want to import in the PDK (or separate GDS files, where each file contains a GDS design).\n","\n","Ideally you also get:\n","\n","- Klayout layer properties files, to define the Layers that you can use when creating new custom Components. This allows you to define the LayerMap that maps Layer_name to (GDS_LAYER, GDS_PuRPOSE).\n","- layer_stack information (material index, thickness, z positions of each layer).\n","- DRC rules. If you don't get this you can easily build one using klayout.\n","\n","GDS files are great for describing geometry thanks to the concept of References, where you store any geometry only once in memory.\n","\n","For storing device metadata (settings, port locations, port widths, port angles ...) there is no clear standard.\n","\n","`gdsfactory` stores the that metadata in `YAML` files, and also has functions to add pins\n","\n","- `Component.write_gds()` saves GDS\n","- `Component.write_gds_metadata()` save GDS + YAML metadata"],"id":"7e5e5867"},{"cell_type":"code","execution_count":null,"metadata":{"id":"183c5ddd"},"outputs":[],"source":["\n","# Lets generate the script that we need to have to each GDS cell into gdsfactory\n","import gdsfactory as gf\n","from gdsfactory.config import PATH\n","from gdsfactory.generic_tech import get_generic_pdk\n","from gdsfactory.technology import lyp_to_dataclass\n","\n","gf.config.rich_output()\n","PDK = get_generic_pdk()\n","PDK.activate()\n","\n","c = gf.components.mzi()\n","c.plot()"],"id":"183c5ddd"},{"cell_type":"markdown","metadata":{"id":"a03cec61"},"source":["You can write **GDS** files only"],"id":"a03cec61"},{"cell_type":"code","execution_count":null,"metadata":{"id":"53cf4e8c"},"outputs":[],"source":["gdspath = c.write_gds(\"extra/mzi.gds\")"],"id":"53cf4e8c"},{"cell_type":"markdown","metadata":{"id":"5fa01ea9"},"source":["Or **GDS** with **YAML** metadata information (ports, settings, cells ...)"],"id":"5fa01ea9"},{"cell_type":"code","execution_count":null,"metadata":{"id":"caa08555"},"outputs":[],"source":["gdspath = c.write_gds(\"extra/mzi.gds\", with_metadata=True)"],"id":"caa08555"},{"cell_type":"markdown","metadata":{"id":"9cfa42e7"},"source":["This created a `mzi.yml` file that contains:\n","- ports\n","- cells (flat list of cells)\n","- info (function name, module, changed settings, full settings, default settings)"],"id":"9cfa42e7"},{"cell_type":"code","execution_count":null,"metadata":{"id":"959d572e"},"outputs":[],"source":["c.metadata.keys()"],"id":"959d572e"},{"cell_type":"markdown","metadata":{"id":"a0e0dfe7"},"source":["You can read GDS files into gdsfactory thanks to the `import_gds` function\n","\n","`import_gds` reads the same GDS file from disk without losing any information"],"id":"a0e0dfe7"},{"cell_type":"code","execution_count":null,"metadata":{"id":"1726460e"},"outputs":[],"source":["gf.clear_cache()\n","\n","c = gf.import_gds(gdspath, read_metadata=True)\n","c.plot()"],"id":"1726460e"},{"cell_type":"code","execution_count":null,"metadata":{"id":"973c7187"},"outputs":[],"source":["c2 = gf.import_gds(gdspath, name=\"mzi_sample\", read_metadata=True)\n","c2.plot()"],"id":"973c7187"},{"cell_type":"code","execution_count":null,"metadata":{"id":"278967bd"},"outputs":[],"source":["c2.name"],"id":"278967bd"},{"cell_type":"code","execution_count":null,"metadata":{"id":"1eeda5b0"},"outputs":[],"source":["c3 = gf.routing.add_fiber_single(c2)\n","c3.plot()"],"id":"1eeda5b0"},{"cell_type":"code","execution_count":null,"metadata":{"id":"20c1ce90"},"outputs":[],"source":["gdspath = c3.write_gds(\"extra/pdk.gds\", with_metadata=True)"],"id":"20c1ce90"},{"cell_type":"code","execution_count":null,"metadata":{"id":"df1e1350"},"outputs":[],"source":["gf.labels.write_labels.write_labels_klayout(gdspath, layer_label=(201, 0))"],"id":"df1e1350"},{"cell_type":"markdown","metadata":{"id":"4ca55908"},"source":["### add ports from pins\n","\n","Sometimes the GDS does not have YAML metadata, therefore you need to figure out the port locations, widths and orientations.\n","\n","gdsfactory provides you with functions that will add ports to the component by looking for pins shapes on a specific layers (port_markers or pins)\n","\n","There are different pin standards supported to automatically add ports to components:\n","\n","- PINs towards the inside of the port (port at the outer part of the PIN)\n","- PINs with half of the pin inside and half outside (port at the center of the PIN)\n","- PIN with only labels (no shapes). You have to manually specify the width of the port.\n","\n","\n","Lets add pins, save a GDS and then import it back."],"id":"4ca55908"},{"cell_type":"code","execution_count":null,"metadata":{"id":"02fa6caf"},"outputs":[],"source":["c = gf.components.straight(\n","    decorator=gf.add_pins.add_pins\n",")  # add pins inside the component\n","c.plot()"],"id":"02fa6caf"},{"cell_type":"code","execution_count":null,"metadata":{"id":"39ff2902"},"outputs":[],"source":["gdspath = c.write_gds(\"extra/wg.gds\")"],"id":"39ff2902"},{"cell_type":"code","execution_count":null,"metadata":{"id":"fa6a3b7f"},"outputs":[],"source":["gf.clear_cache()\n","c2 = gf.import_gds(gdspath)\n","c2"],"id":"fa6a3b7f"},{"cell_type":"code","execution_count":null,"metadata":{"id":"ba5de210"},"outputs":[],"source":["c2.ports  # import_gds does not automatically add the pins"],"id":"ba5de210"},{"cell_type":"code","execution_count":null,"metadata":{"id":"10362c7b"},"outputs":[],"source":["c3 = gf.import_gds(gdspath, decorator=gf.add_ports.add_ports_from_markers_inside)\n","c3"],"id":"10362c7b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"c765788e"},"outputs":[],"source":["c3.ports"],"id":"c765788e"},{"cell_type":"markdown","metadata":{"id":"36a8a926"},"source":["Foundries provide PDKs in different formats and commercial tools.\n","\n","The easiest way to import a PDK into gdsfactory is to:\n","\n","1. have each GDS cell into a separate GDS file\n","2. have one GDS file with all the cells inside\n","3. Have a KLayout layermap. Makes easier to create the layermap.\n","\n","With that you can easily create the PDK as as python package.\n","\n","Thanks to having a gdsfactory PDK as a python package you can:\n","\n","- version control your PDK using GIT to keep track of changes and work on a team\n","    - write tests of your pdk components to avoid unwanted changes from one component to another.\n","    - ensure you maintain the quality of the PDK with continuous integration checks\n","    - pin the version of gdsfactory, so new updates of gdsfactory won't affect your code\n","- name your PDK version using [semantic versioning](https://semver.org/). For example patches increase the last number (0.0.1 -> 0.0.2)\n","- install your PDK easily `pip install pdk_fab_a` and easily interface with other tools\n","\n","\n","\n","To create a **Python** package you can start from a customizable template (thanks to cookiecutter)\n","\n","You can create a python package by running this 2 commands inside a terminal:\n","\n","```\n","pip install cookiecutter\n","cookiecutter https://github.com/joamatab/cookiecutter-pypackage-minimal\n","```\n","\n","It will ask you some questions to fill in the template (name of the package being the most important)\n","\n","\n","Then you can add the information about the GDS files and the Layers inside that package"],"id":"36a8a926"},{"cell_type":"code","execution_count":null,"metadata":{"id":"5274ec6b"},"outputs":[],"source":["print(lyp_to_dataclass(PATH.klayout_lyp))"],"id":"5274ec6b"},{"cell_type":"code","execution_count":null,"metadata":{"id":"aaf9b780"},"outputs":[],"source":["# lets create a sample PDK (for demo purposes only) using GDSfactory\n","# if the PDK is in a commercial tool you can also do this. Make sure you save a single pdk.gds\n","\n","sample_pdk_cells = gf.grid(\n","    [\n","        gf.components.straight,\n","        gf.components.bend_euler,\n","        gf.components.grating_coupler_elliptical,\n","    ]\n",")\n","sample_pdk_cells.write_gds(\"extra/pdk.gds\")\n","sample_pdk_cells"],"id":"aaf9b780"},{"cell_type":"code","execution_count":null,"metadata":{"id":"6f88d633"},"outputs":[],"source":["sample_pdk_cells.get_dependencies()"],"id":"6f88d633"},{"cell_type":"code","execution_count":null,"metadata":{"id":"e39db396"},"outputs":[],"source":["# we write the sample PDK into a single GDS file\n","gf.clear_cache()\n","gf.write_cells.write_cells(\n","    gdspath=\"extra/pdk.gds\", dirpath=\"extra/gds\", recursively=True\n",")"],"id":"e39db396"},{"cell_type":"code","execution_count":null,"metadata":{"id":"adfde83a"},"outputs":[],"source":["print(gf.write_cells.get_import_gds_script(\"extra/gds\"))"],"id":"adfde83a"},{"cell_type":"markdown","metadata":{"id":"e984571d"},"source":["You can also include the code to plot each fix cell in the docstring."],"id":"e984571d"},{"cell_type":"code","execution_count":null,"metadata":{"id":"52f08227"},"outputs":[],"source":["print(gf.write_cells.get_import_gds_script(\"extra/gds\", module=\"samplepdk.components\"))"],"id":"52f08227"},{"cell_type":"markdown","metadata":{"id":"bfcc1326"},"source":["## Import PDK from other python packages\n","\n","You can Write the cells to GDS and use the\n","\n","Ideally you also start transitioning your legacy code Pcells into gdsfactory syntax. It's a great way to learn the gdsfactory way!\n","\n","Here is some advice:\n","\n","- Ask your foundry for the gdsfactory PDK.\n","- Leverage the generic pdk cells available in gdsfactory.\n","- Write tests for your cells.\n","- Break the cells into small reusable functions.\n","- use GIT to track changes.\n","- review your code with your colleagues and other gdsfactory developers to get feedback. This is key to get better at coding gdsfactory.\n","- get rid of any warnings you see."],"id":"bfcc1326"},{"cell_type":"markdown","metadata":{"id":"f21d93b9"},"source":["## Build your own PDK\n","\n","You can create a PDK as a python library using a cookiecutter template. For example, you can use this one.\n","\n","```\n","pip install cookiecutter\n","cookiecutter https://github.com/joamatab/cookiecutter-pypackage-minimal\n","```\n","\n","Or you can fork the ubcpdk and create new PCell functions that use the correct layers for your foundry. For example.\n","\n","```\n","\n","from pydantic import BaseModel\n","\n","\n","class LayerMap(BaseModel):\n","    WGCORE = (3, 0)\n","    LABEL = (100, 0)\n","    DEVREC: Layer = (68, 0)\n","    LABEL: Layer = (10, 0)\n","    PORT: Layer = (1, 10)  # PinRec\n","    PORTE: Layer = (1, 11)  # PinRecM\n","    FLOORPLAN: Layer = (99, 0)\n","\n","    TE: Layer = (203, 0)\n","    TM: Layer = (204, 0)\n","    TEXT: Layer = (66, 0)\n","    LABEL_INSTANCE: Layer = (66, 0)\n","\n","\n","LAYER = LayerMap()\n","\n","```"],"id":"f21d93b9"}],"metadata":{"jupytext":{"cell_metadata_filter":"-all","custom_cell_magics":"kql"},"kernelspec":{"display_name":"base","language":"python","name":"python3"},"colab":{"provenance":[],"collapsed_sections":["ccdffd91","d0ceca27"]}},"nbformat":4,"nbformat_minor":5}