Split SiEPIC in separate packages for Si and SiN

Signed-off-by: Lucas Heitzmann Gabrielli <lucas@flexcompute.com>

Author: lucas-flexcompute

.github/workflows/build-packages.yml

@@ -8,19 +8,24 @@ on:
 
 jobs:
   build:
-    name: Build wheels on manylinux2014
+    strategy:
+      fail-fast: false
+      matrix:
+        package_dir: [si, sin]
+    name: Build wheels on manylinux2014 (${{ matrix.package_dir }})
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
       - name: Install pypa/build
         run: python3 -m pip install build --user
       - name: Build a binary wheel and a source tarball
+        working-directory: ${{ matrix.package_dir }}
         run: python3 -m build
       - uses: actions/upload-artifact@v4
         with:
-          path: ./dist/*
-          name: artifact
+          path: ./${{ matrix.package_dir }}/dist/*
+          name: artifact-${{ matrix.package_dir }}
 
   upload_pypi:
     name: Upload wheel to PyPI
@@ -31,6 +36,7 @@ jobs:
     steps:
       - uses: actions/download-artifact@v4
         with:
+          pattern: artifact-*
           path: dist
           merge-multiple: true
       - uses: pypa/gh-action-pypi-publish@v1.12.4

.github/workflows/run-tests.yml

@@ -9,23 +9,28 @@ jobs:
       matrix:
         os: [ubuntu-latest, macos-latest]
         python-version: ['3.10', '3.14']
-    name: Test for ${{ matrix.python-version }} on ${{ matrix.os }}
+        package_dir: [si, sin]
+    name: Test ${{ matrix.package_dir }} for ${{ matrix.python-version }} on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
           cache: 'pip'
+          cache-dependency-path: ${{ matrix.package_dir }}/pyproject.toml
       - name: Install Python dependencies
+        working-directory: ${{ matrix.package_dir }}
         run: |
           python -m pip install --upgrade pip
           pip install --upgrade setuptools wheel pip-tools
           python -m piptools compile --resolver=backtracking --extra=test -o requirements.txt pyproject.toml
           pip install -r requirements.txt
       - name: Build and install
+        working-directory: ${{ matrix.package_dir }}
         run: pip install .
       - name: Test
+        working-directory: ${{ matrix.package_dir }}
         run: |
           export SIMCLOUD_APIKEY=${{ secrets.SIMCLOUD_APIKEY }}
           pytest

README.md

@@ -1,94 +1,6 @@
 # SiEPIC Forge
 
-This python module implements the [SiEPIC EBeam
+Main repository for the [SiEPIC EBeam
 PDK](https://github.com/SiEPIC/SiEPIC_EBeam_PDK) for Si and SiN processes as
 components and technology specifications for
 [PhotonForge](https://docs.flexcompute.com/projects/photonforge/)
-
-
-## Installation
-
-### Python interface
-
-Installation via `pip`:
-
-    pip install siepic-forge
-
-
-## Usage
-
-The simplest way to use the this PDK in PhotonForge is to set its technology as
-default:
-
-    import photonforge as pf
-    import siepic_forge as siepic
-
-    tech = siepic.ebeam_si()
-    pf.config.default_technology = tech
-
-
-The `ebeam_si` function creates a parametric technology and accepts a number of
-parameters to fine-tune the technology. The EBeam SiN process is available
-through the `ebeam_sin` parametric technology.
-
-PDK components are available through the `component` function, which takes a
-component name as first argument. The list of component names is available as a
-set `component_names`:
-
-    print(siepic.component_names)
-    
-    pdk_component = siepic.component("ebeam_y_1550")
-
-
-More information can be obtained in the documentation for each function:
-
-    help(siepic.ebeam_si)
-
-    help(siepic.ebeam_sin)
-
-    help(siepic.component)
-
-
-## Warnings
-
-Please note that the 3D structures obtained by extrusion through this module's
-technologies are a best approximation of the intended fabricated structures,
-but the actual final dimensions may differ due to several fabrication-specific
-effects. In particular, doping profiles are represented with hard-boundary,
-homogeneous solids, but, in practice will present process-dependent variations
-with smooth boundaries.
-
-
-## References
-
-Process stack and other information obtained from [ANT
-NanoSOI](https://www.appliednt.com/nanosoi/).
-
-The GDSII cell library comes from the main PDK repository.
-
-
-## Third-Party Licenses
-
-- [`SiEPIC_EBeam_PDK`](https://github.com/SiEPIC/SiEPIC_EBeam_PDK)
-
-  > This project is licensed under the terms of the MIT license.
-  > 
-  > Copyright (c) 2016-2020, Lukas Chrostowski and contributors
-  > 
-  > Permission is hereby granted, free of charge, to any person obtaining a
-  > copy of this software and associated documentation files (the "Software"),
-  > to deal in the Software without restriction, including without limitation
-  > the rights to use, copy, modify, merge, publish, distribute, sublicense,
-  > and/or sell copies of the Software, and to permit persons to whom the
-  > Software is furnished to do so, subject to the following conditions:
-  > 
-  > The above copyright notice and this permission notice shall be included in
-  > all copies or substantial portions of the Software.
-  > 
-  > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  > IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  > FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  > AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  > LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-  > FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-  > DEALINGS IN THE SOFTWARE.

component_converter.py

@@ -1,12 +1,78 @@
-import photonforge as pf
-import siepic_forge as siepic
 import pathlib
+import subprocess
+import sys
+
 import numpy
+import photonforge as pf
+
+sys.path.append("./si")
+sys.path.append("./sin")
+
+import siepic_si_forge as siepic_si
+import siepic_sin_forge as siepic_sin
+
+preambles = {
+    "si": """import math
+
+_symmetries_3port = [("P1", "P2", {"P0": "P0", "P2": "P1"})]
+
+_symmetries_crossing = [
+    ("P0", "P1", {"P1": "P0", "P2": "P3", "P3": "P2"}),
+    ("P0", "P2", {"P1": "P3", "P2": "P1", "P3": "P0"}),
+    ("P0", "P3", {"P1": "P2", "P2": "P0", "P3": "P1"}),
+]
+
+_waist = 5.0
+
+_angle = 8 * math.pi / 180
+_vx8 = math.sin(_angle)
+_vy8 = -math.cos(_angle)
+
+_angle = 7 * math.pi / 180
+_tm1550_vx = math.sin(_angle)
+_tm1550_vy = -math.cos(_angle)
 
+_angle = -21 * math.pi / 180
+_te1550_vx = math.sin(_angle)
+_te1550_vy = -math.cos(_angle)
 
-for path in pathlib.Path("siepic_forge/library").iterdir():
-    family = path.stem
-    technology = siepic.ebeam_sin() if "SiN" in family else siepic.ebeam_si()
+_component_data = {
+""",
+    "sin": """import math
+
+_symmetries_3port = [("P1", "P2", {"P0": "P0", "P2": "P1"})]
+
+_symmetries_crossing = [
+    ("P0", "P1", {"P1": "P0", "P2": "P3", "P3": "P2"}),
+    ("P2", "P3", {"P0": "P1", "P1": "P0", "P3": "P2"}),
+]
+
+_symmetries_directional_coupler = [
+    ("P0", "P1", {"P1": "P0", "P2": "P3", "P3": "P2"}),
+    ("P0", "P2", {"P1": "P3", "P2": "P0", "P3": "P1"}),
+    ("P0", "P3", {"P1": "P2", "P2": "P1", "P3": "P0"}),
+]
+
+_symmetries_mmi22 = _symmetries_directional_coupler
+
+_waist = 5.0
+
+_angle = 8 * math.pi / 180
+_vx8 = math.sin(_angle)
+_vy8 = -math.cos(_angle)
+
+_angle = 10 * math.pi / 180
+_te895_vx = math.sin(_angle)
+_te895_vy = -math.cos(_angle)
+
+_component_data = {
+""",
+}
+
+for family, preamble in preambles.items():
+    lines = []
+    technology = siepic_sin.ebeam() if family == "sin" else siepic_si.ebeam()
+    path = pathlib.Path(f"{family}/siepic_{family}_forge/library")
     for gds_name in sorted(path.glob("*.gds")):
         components = pf.load_layout(gds_name, technology=technology)
         for comp_name in sorted(c.name for c in pf.find_top_level(*components.values())):
@@ -28,7 +94,9 @@
                 for spec in technology.ports:
                     for port in comp.detect_ports([spec], (pin - 0.005, pin + 0.005)):
                         if numpy.allclose(port.center, pin):
-                            candidates.append((tuple(float(x) for x in pin), int(port.input_direction), spec))
+                            candidates.append(
+                                (tuple(float(x) for x in pin), int(port.input_direction), spec)
+                            )
                 if len(candidates) == 0:
                     print(f"# WARN: Missing port {tuple(float(x) for x in pin)}.")
                 ports.extend(candidates)
@@ -38,11 +106,8 @@
 
             model = "None" if len(ports) < 2 or comp.name.endswith("BB") else "{}"
 
-            print(
-                f"""{comp.name!r}: (
-    {family!r},
-    {gds_name.stem!r},
-    [{ports}],
-    {model},
-),"""
-            )
+            lines.append(f"{comp.name!r}: ({gds_name.stem!r}, [{ports}], {model}),")
+
+    output = pathlib.Path(__file__).parent / family / f"siepic_{family}_forge" / "_component_data.py"
+    output.write_text(preamble + "\n".join(lines) + "\n}")
+    subprocess.run(["ruff", "format", output], check=True)

extrusion_profile.py

@@ -1,11 +1,16 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+import sys
 
-import siepic_forge as siepic
+sys.path.append("./si")
+sys.path.append("./sin")
+
+import siepic_si_forge as siepic_si
+import siepic_sin_forge as siepic_sin
 from matplotlib import pyplot
 
-siepic.plot_cross_section()
+siepic_si.plot_cross_section()
 
-siepic.plot_cross_section(siepic.ebeam_sin())
+siepic_sin.plot_cross_section()
 
 pyplot.show()

layer_converter.py

@@ -113,7 +113,7 @@ def parse(layers, node, description=""):
 if __name__ == "__main__":
     if len(sys.argv) < 2:
         raise RuntimeError(
-            "Please run the script providing the path for the layer properties file: EBeam.lyp"
+            "Please run the script providing the path for the layer properties file: NanoSOI_layers.lyp"
         )
 
     layers = {}
@@ -152,14 +152,17 @@ def parse(layers, node, description=""):
             layers[k][0] = f"{n} {names[n]}"
         names[n] += 1
 
-    lines = [
-        "import photonforge as pf",
-        "_layers = {",
-    ] + [
-        "\t{!r} : pf.LayerSpec({}, {!r}, {!r}, {!r}),".format(*v) for _, v in sorted(layers.items())
-    ]
-    lines.append("}")
-
-    output = pathlib.Path(__file__).parent / "siepic_forge" / "_layers.py"
-    output.write_text("\n".join(lines))
-    subprocess.run(["ruff", "format", output], check=True)
+    for family, skip_layers in (("si", [(4, 0)]), ("sin", [(1, 0), (2, 0)])):
+        lines = [
+            "import photonforge as pf",
+            "_layers = {",
+        ] + [
+            "\t{!r} : pf.LayerSpec({}, {!r}, {!r}, {!r}),".format(*v)
+            for k, v in sorted(layers.items())
+            if k not in skip_layers
+        ]
+        lines.append("}")
+
+        output = pathlib.Path(__file__).parent / family / f"siepic_{family}_forge" / "_layers.py"
+        output.write_text("\n".join(lines))
+        subprocess.run(["ruff", "format", output], check=True)