luminescent 0.1.0__tar.gz

luminescent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Paul Shen
+
+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.

luminescent-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: luminescent
+Version: 0.1.0
+Summary: Calculate word counts in a text file.
+License: MIT
+Author: Paul Shen
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+

luminescent-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "luminescent"
+version = "0.1.0"
+description = "Calculate word counts in a text file."
+authors = ["Paul Shen"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+
+[tool.poetry.dev-dependencies]
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

luminescent-0.1.0/src/luminescent/__init__.py

@@ -0,0 +1,19 @@
+from .gplugins.luminescent import *
+# __all__= .gplugins.luminescent.__all__
+#
+__all__ = [
+    "LAYER_STACK",
+    "LAYER",
+    "LAYER_VIEWS",
+    "MATERIAL_LIBRARY",
+    "write_sparams",
+    "inverse_design_problem",
+    "sparams_problem",
+    "solve",
+    "apply_design",
+    "add_bbox",
+    "XMARGIN",
+    "YMARGIN",
+    "load_solution",
+    "gcells",
+]

luminescent-0.1.0/src/luminescent/gplugins/__init__.py

@@ -0,0 +1 @@
+# from luminescent

luminescent-0.1.0/src/luminescent/gplugins/luminescent/__init__.py

@@ -0,0 +1,30 @@
+# import gplugins.luminescent as gl
+from .generic_tech import (
+    LAYER_STACK, LAYER, LAYER_VIEWS
+
+)
+from .setup import *
+from .sol import *
+from .sparams import *
+from .inverse_design import *
+from .materials import MATERIAL_LIBRARY
+from .constants import *
+from .utils import *
+from . import gcells
+
+__all__ = [
+    "LAYER_STACK",
+    "LAYER",
+    "LAYER_VIEWS",
+    "MATERIAL_LIBRARY",
+    "write_sparams",
+    "inverse_design_problem",
+    "sparams_problem",
+    "solve",
+    "apply_design",
+    "add_bbox",
+    "XMARGIN",
+    "YMARGIN",
+    "load_solution",
+    "gcells",
+]

luminescent-0.1.0/src/luminescent/gplugins/luminescent/constants.py

@@ -0,0 +1,3 @@
+ZMARGIN = .4
+XMARGIN = YMARGIN = .8
+PATH = "lumi_runs"

luminescent-0.1.0/src/luminescent/gplugins/luminescent/gcells.py

@@ -0,0 +1,176 @@
+
+from gdsfactory.cross_section import Section
+from .generic_tech import LAYER_STACK, LAYER, LAYER_VIEWS
+
+import gdsfactory as gf
+import bson
+# import .utils as utils
+from .utils import *
+from .constants import *
+# from layers import *
+
+
+def bend(r, wwg=.5, lwg=1, LAYER=LAYER, **kwargs):
+    name = "bend"
+    design = gf.Component()
+    init = gf.Component()
+    test = gf.Component()
+    device = gf.Component()
+    device = gf.Component("bend")
+    prob = dict()
+
+    # if lwg == 0:
+    # lwg = 2*wwg
+    lstub = lwg/2
+    # Extrude the Path and the CrossSection
+    wg1 = device << gf.path.extrude(gf.path.straight(
+        length=lwg), layer=LAYER.WG, width=wwg)
+    wg2 = device << gf.path.extrude(gf.path.straight(
+        length=lwg), layer=LAYER.WG, width=wwg)
+    arc = device << gf.path.extrude(gf.path.arc(
+        r, start_angle=0), layer=LAYER.WG, width=wwg)
+
+    ld = wd = 2*r
+    design.add_polygon([(0, 0), (ld, 0), (ld, wd), (0, wd)],
+                       layer=LAYER.DESIGN)
+    design.add_port(name="o1", center=(0, r), width=wwg,
+                    orientation=180, layer=LAYER.WG)
+    design.add_port(name="o2", center=(r, 0), width=wwg,
+                    orientation=-90, layer=LAYER.WG)
+    design = device << design
+
+    wg1.connect("o2", design.ports["o1"])
+    wg2.connect("o2", design.ports["o2"])
+    arc.connect("o1", wg2.ports["o2"])
+
+    device.add_port("o1", port=wg1.ports["o1"])
+    device.add_port("o2", port=wg2.ports["o1"])
+
+    # utils.write_img("device", device, DESIGN)
+    # utils.write_img("guess", init, DESIGN)
+    c = add_bbox(device, layers=[LAYER.WGCLAD, LAYER.BOX],
+                 nonport_margin=0.4)
+    return c
+
+
+def mimo(l, w, wwg, m, n,
+         layer_wg=LAYER.WG, layer_wgclad=LAYER.WGCLAD, layer_box=LAYER.BOX, layer_design=LAYER.DESIGN,
+         **kwargs):
+    design = gf.Component()
+
+    c = gf.Component("mimo")
+    lwg = 2*wwg
+    p = [(0, 0), (l, 0), (l, w), (0, w)]
+    design.add_polygon(p,                       layer=layer_design)
+    c.add_polygon(p,                       layer=layer_wg)
+
+    din = w/m
+    dout = w/n
+    yin = din/2
+    yout = dout/2
+    for i in range(m):
+        name = "o"+str(i+1)
+        design.add_port(name=name, center=(0, yin), width=wwg,
+                        orientation=180, layer=layer_wg)
+        wg = c << gf.components.straight(length=lwg, width=wwg, layer=layer_wg)
+        wg.connect("o2", design.ports[name])
+        c.add_port(name=name, port=wg.ports["o1"])
+        yin += din
+    for i in range(n):
+        name = "o"+str(i+1+m)
+        design.add_port(name=name, center=(l, yout), width=wwg,
+                        orientation=0, layer=layer_wg)
+        wg = c << gf.components.straight(length=lwg, width=wwg, layer=layer_wg)
+        wg.connect("o2", design.ports[name])
+        c.add_port(name=name, port=wg.ports["o1"])
+        yout += dout
+    design = c << design
+    c = add_bbox(c, layers=[layer_wgclad, layer_box],
+                 nonport_margin=XMARGIN)
+    return c
+
+
+# def ubend_template(r, l, wwg, lwg=0,
+    #                wavelength=1.55, dx=0.05,
+    #                #    ϵcore=ϵcore, ϵclad=ϵclad,
+    #                dir="", init=None, lmin=0.1, LAYER=LAYER, **kwargs):
+    # name = "ubend"
+    # design = gf.Component("design")
+    # device = gf.Component("ubend")
+    # λ = wavelength
+
+    # if lwg == 0:
+    #     lwg = 4*wwg
+
+    # # Extrude the Path and the CrossSection
+    # wg1 = device << gf.path.extrude(gf.path.straight(
+    #     length=lwg), layer=LAYER.WG, width=wwg)
+    # wg2 = device << gf.path.extrude(gf.path.straight(
+    #     length=lwg), layer=LAYER.WG, width=wwg)
+
+    # ld = l
+    # wd = 2*r+wwg
+
+    # design.add_polygon([(0, -wd/2), (ld, -wd/2), (ld, wd/2),
+    #                     (0, wd/2)], layer=DESIGN)
+    # if init is not None:
+    #     xmin = design.xmin
+    #     ymin = design.ymin
+    #     init = design << init
+    #     init.xmin = xmin
+    #     init.ymin = ymin
+    # else:
+    #     init = gf.Component()
+    #     init.add_polygon([(0, -wd/2), (ld, -wd/2), (ld, wd/2),
+    #                       (0, wd/2)], layer=GUESS)
+    #     init = design << init
+
+    # design.add_port(name="o1", center=(0, r), width=wwg,
+    #                 orientation=180, layer=LAYER.PORT)
+    # design.add_port(name="o2", center=(0, -r), width=wwg,
+    #                 orientation=180, layer=LAYER.PORT)
+    # # design = device << design
+
+    # wg1.connect("o2", design.ports["o1"], allow_layer_mismatch=True)
+    # wg2.connect("o2", design.ports["o2"], allow_layer_mismatch=True)
+    # # stub1.connect("o2", wg1.ports["o1"])
+    # # stub2.connect("o2", wg2.ports["o1"])
+
+    # device.add_port("o1", port=wg1.ports["o1"])
+    # device.add_port("o2", port=wg2.ports["o1"])
+
+    # # design = device << design
+    # device.add_ref(design, name="design")
+    # # device << gf.components.re
+    # # device << test
+    # device.show()
+    # # init.show()
+    # sources = {
+    #     "o1": {
+    #         "port": "o1",
+    #         "wavelengths": [λ],
+    #         "mode_numbers": [0],
+    #         "powers": [1],
+    #         "width": wwg,
+    #         "endpoints": device.ports["o1"].endpoints.tolist(),
+    #         "center": (device.ports["o1"].center),
+    #         "orientation": device.ports["o1"].orientation,
+    #     }}
+    # for k in sources:
+    #     a = sources[k]["orientation"]/180*pi
+    #     normal = [cos(a), sin(a)]
+    #     sources[k]["normal"] = normal
+    #     sources[k]["center"] -= .001*np.array(normal)
+    #     sources[k]["center"] = sources[k]["center"].flatten().tolist()
+
+    # monitors = {
+    #     "o2":        {
+    #         "powers": [1],
+    #         "wavelengths": [λ],
+    #         "mode_numbers": [0],
+    #         "port": "o2"},
+    #     # {"power": 1,"wavelength": λ,"port": "o1"},
+    # }
+    # # device.metadata["sources"] = sources
+    # # device.metadata["monitors"] = monitors
+    # return device, sources, monitors, design

luminescent-0.1.0/src/luminescent/gplugins/luminescent/generic_tech.py

@@ -0,0 +1,84 @@
+import gdsfactory as gf
+from gdsfactory.generic_tech.layer_map import LAYER
+from gdsfactory.technology import LogicalLayer, LayerStack, LayerLevel
+import gdsfactory as gf
+from gdsfactory.generic_tech import LAYER, LAYER_STACK
+from gdsfactory.generic_tech.get_klayout_pyxs import get_klayout_pyxs
+from gdsfactory.technology import LayerLevel, LayerStack, LayerViews, LayerMap
+from gdsfactory.generic_tech import get_generic_pdk
+
+from gdsfactory.config import PATH
+from gdsfactory.technology import (
+    LayerLevel,
+    LayerStack,
+    LayerView,
+    LayerViews,
+    LayerMap,
+)
+
+Layer = tuple[int, int]
+
+# gf.generic_tech.
+
+
+class MyLayerMap(LayerMap):
+    WG: Layer = (1, 0)
+    WGCLAD: Layer = (111, 0)
+    BOX: Layer = (112, 0)
+    PORT: Layer = (1, 10)
+    DESIGN: Layer = (200, 0)
+    GUESS: Layer = (201, 0)
+
+
+LAYER = MyLayerMap
+
+nm = 1e-3
+thickness_wg = 220 * nm
+thickness_slab_deep_etch = 90 * nm
+thickness_slab_shallow_etch = 150 * nm
+box_thickness = 0.5
+thickness_clad = 0.5
+
+layer_core = LogicalLayer(layer=LAYER.WG)
+layer_clad = LogicalLayer(layer=LAYER.WGCLAD)
+layer_box = LogicalLayer(layer=LAYER.BOX)
+layer_design = LogicalLayer(layer=LAYER.DESIGN)
+
+LAYER_STACK.layers.update(dict(
+    core=LayerLevel(
+        layer=layer_core,
+        thickness=thickness_wg,
+        zmin=0,
+        material="Si",
+        mesh_order=2,
+    ),
+    box=LayerLevel(
+        layer=layer_box,
+        thickness=box_thickness,
+        zmin=-box_thickness,
+        material="SiO2",
+        mesh_order=9,
+    ),
+    clad=LayerLevel(
+        layer=layer_clad,
+        zmin=0.0,
+        material="SiO2",
+        thickness=thickness_clad,
+        mesh_order=10,
+    ),
+    design=LayerLevel(
+        layer=layer_design,
+        zmin=0.0,
+        material=None,
+        thickness=.0001,
+        mesh_order=100,
+    ),
+))
+
+pdk = get_generic_pdk()
+pdk.activate()
+LAYER_VIEWS = pdk.layer_views
+LAYER_VIEWS.layer_views["WGCLAD"].visible = True
+# for l in LAYER_STACK.layers.values():
+#     print(l.layer)
+#     print(l.layer.layer)

luminescent-0.1.0/src/luminescent/gplugins/luminescent/inverse_design.py

@@ -0,0 +1,124 @@
+from copy import deepcopy
+# from time import time
+import datetime
+import json
+import subprocess
+from functools import partial
+from math import cos, pi, sin
+import os
+import wave
+import matplotlib.pyplot as plt
+import numpy as np
+
+from gdsfactory.cross_section import Section
+from sortedcontainers import SortedDict, SortedSet
+from .generic_tech import LAYER_STACK, LAYER, LAYER_VIEWS
+import gdsfactory as gf
+import bson
+import scipy as sp
+from .utils import *
+from .layers import *
+from .constants import *
+from .utils import *
+from .setup import *
+from .sparams import *
+from .materials import MATERIAL_LIBRARY
+
+
+def inverse_design_problem(c,  lmin=.1, symmetries=[],
+                           tparam_targets={}, sparam_targets={},
+                           maxiters=25, eta=.1,
+                           design_region_layer=LAYER.DESIGN,
+                           design_guess_layer=LAYER.GUESS,
+                           design_layer=LAYER.WG,
+                           void_layer=LAYER.WGCLAD,
+                           layer_stack=LAYER_STACK,
+                           plot=False, approx_2D=True, **kwargs):
+    if not approx_2D:
+        raise NotImplementedError(
+            "3D inverse design feature must be requested from Luminescent AI info@luminescentai.com")
+
+    if tparam_targets:
+        target_type = "tparams"
+        targets = tparam_targets
+    elif sparam_targets:
+        target_type = "sparams"
+        targets = sparam_targets
+
+    targets = {
+        wl: {
+            longname(k): v for k, v in d.items()
+        } for wl, d in targets.items()}
+    keys = sorted(set(sum([list(d.keys()) for d in targets.values()], [])))
+    wavelengths = sorted(targets.keys())
+
+    prob = sparams_problem(c, layer_stack=layer_stack, wavelengths=wavelengths,
+                           keys=keys, approx_2D=approx_2D, ** kwargs)
+    prob["targets"] = targets
+    prob["target_type"] = target_type
+    prob["eta"] = eta
+    prob["study"] = "inverse_design"
+    polys = c.extract([design_region_layer]).get_polygons()
+    if not symmetries:
+        symmetries = [[]]*len(polys)
+    else:
+        if type(symmetries[0]) is int:
+            symmetries = [symmetries]*len(polys)
+
+    def _bbox(b):
+        return [[b.left/1e3, b.bottom/1e3], [b.right/1e3, b.top/1e3]]
+    prob["designs"] = [
+        {
+            "layer": design_layer,
+            "bbox": _bbox(p.bbox()),
+            "symmetries": s,
+            "guess": None,
+            "lmin": lmin,
+        } for p, s in zip(list(polys.values())[0], symmetries)
+    ]
+
+    prob["design_config"] = dict()
+    # prob[""]
+    l = get_layer(layer_stack, design_layer)
+    d = {"thickness": l.thickness, "material": l.material, "zmin": l.zmin}
+    # d = vars(prob["design_layer"])
+    d["ϵ"] = MATERIAL_LIBRARY[d["material"]].epsilon
+    prob["design_config"]["fill"] = d
+
+    l = get_layer(layer_stack, void_layer)
+    d = {"thickness": l.thickness, "material": l.material, "zmin": l.zmin}
+    d["ϵ"] = MATERIAL_LIBRARY[d["material"]].epsilon
+    prob["design_config"]["void"] = d
+
+    prob["design_layer"] = d
+    prob["maxiters"] = maxiters
+    return prob
+
+
+def apply_design(c0,  sol):
+    path = sol["path"]
+    a = gf.Component()
+    a.add_ref(c0)
+    dl = 0
+    for i, d in enumerate(sol["designs"]):
+        dl = d["layer"]
+        x0, y0 = d["bbox"][0]
+        x1, y1 = d["bbox"][1]
+        b = gf.Component()
+        b.add_polygon(
+            [(x0, y0), (x1, y0), (x1, y1), (x0, y1)], layer=dl)
+        a = gf.boolean(a, b, "not", layer=dl)
+    c = gf.Component()
+    c << a
+    for layer in c0.layers:
+        if layer != dl:
+            c.add_ref(c0.extract([layer]))
+    c.show()
+    pic2gds(os.path.join(path, f"design{i+1}.png"), sol["dx"])
+    g = gf.import_gds(os.path.join(path, f"design{i+1}.gds"), "TOP",
+                      read_metadata=True)
+    g = c << g
+    g.drotate(90)
+    g.xmin = x0
+    g.ymin = y0
+    return c

luminescent-0.1.0/src/luminescent/gplugins/luminescent/layers.py

@@ -0,0 +1,4 @@
+DESIGN = (100, 0)
+GUESS = (101, 0)
+p_layer = (71, 0)
+n_layer = (72, 0)

luminescent-0.1.0/src/luminescent/gplugins/luminescent/materials.py

@@ -0,0 +1,16 @@
+
+
+class Si():
+    epsilon = 3.4757**2
+
+
+class SiO2():
+    epsilon = 1.444**2
+
+
+MATERIAL_LIBRARY = {
+    "si": Si,
+    "sio2": SiO2,
+    "Si": Si,
+    "SiO2": SiO2,
+}

luminescent-0.1.0/src/luminescent/gplugins/luminescent/pcells.py

@@ -0,0 +1,119 @@
+import gdsfactory as gf
+from layers import *
+core_layer = (1, 0)
+
+
+def phase_shifter(l, wwg, nbends, ubend):
+    c = gf.Component()
+    ls = l-2*ubend.size[0]
+    s0 = c << gf.path.extrude(gf.path.straight(
+        length=ls), width=wwg, layer=core_layer)
+    s = s0
+
+    lu = ubend.size[0]
+    wdope = ubend.size[1]-wwg
+    sin = c << gf.path.extrude(gf.path.straight(
+        length=lu), width=wwg, layer=core_layer)
+    sin.connect("o2", s.ports["o1"])
+
+    for i in range(nbends+2):
+        if 0 < i < nbends+1:
+            u_ = (c << ubend)
+            p1 = "o1" if i % 2 == 1 else "o2"
+            p2 = "o2" if i % 2 == 1 else "o1"
+            u_.connect(p1, s.ports["o2"])
+            s_ = (c << gf.path.extrude(gf.path.straight(
+                length=ls), width=wwg, layer=core_layer))
+            s_.connect("o1", u_.ports[p2])
+            s = s_
+
+        pn = "p" if i % 2 == 0 else "n"
+        pn_layer = p_layer if pn == "p" else n_layer
+        label = "p doping" if pn == "p" else "n doping"
+
+        pn = c << gf.components.rectangle(size=(l, wdope), layer=pn_layer)
+        pn.xmin = c.xmin
+        if i < nbends+1:
+            pn.ymin = s.center[1]
+        else:
+            pn.ymax = s.center[1]
+        c.add_label(label, position=pn.center, layer=(501, 0))
+
+    sout = c << gf.path.extrude(gf.path.straight(
+        length=lu), width=wwg, layer=core_layer)
+    sout.connect("o1", s.ports["o2"])
+
+    heater_margin = 0.1
+    center = c.center
+    heater = c << gf.components.rectangle(
+        size=(l+2*heater_margin, c.size[1]+2*heater_margin), layer=(61, 0))
+    heater.center = center
+    c.add_label("heater pad", position=heater.bbox_np()[1], layer=(502, 0))
+
+    c.add_label("zigzag phase shifter", position=(
+        c.center[0], c.ymax), layer=(500, 0))
+    c.show()
+    return c
+
+
+def ubend_resonator(l, wwg, ubend):
+    c = gf.Component()
+    arm = gf.Component()
+    quarter = gf.Component()
+
+    r = 1
+    common_left_pad_amount = 8
+    lsb = 6
+    ls = (l-common_left_pad_amount-2*lsb-2*ubend.size[0])/2
+
+    su = quarter << gf.components.straight(
+        length=ls, width=wwg, layer=core_layer)  # Straight section
+    sc = quarter << gf.components.straight(
+        length=common_left_pad_amount/2, width=wwg, layer=core_layer)  # Straight section
+    sb = quarter << gf.components.bend_s(
+        (lsb, 1), 32, gf.cross_section.strip(wwg), )
+    sb.mirror(p1=(0, 0), p2=(1, 0))
+    sb.connect("o2", sc.ports["o1"])
+    su.connect("o2", sb.ports["o1"])
+    quarter.add_port("o1", port=su.ports["o1"])
+    quarter.add_port("o2", port=sc.ports["o2"])
+
+    coupler_margin = .15
+
+    sw = arm << quarter
+    sw.ymin = +wwg/2+coupler_margin
+    sw.xmax = 0
+
+    se = arm << quarter
+    se = se.mirror()
+    se.connect("o2", sw.ports["o2"])
+
+    arm.add_port("o1", port=sw.ports["o1"])
+    arm.add_port("o2", port=se.ports["o1"])
+    south = c << arm
+
+    ubend1 = c << ubend
+    ubend2 = c << ubend
+    ubend1.connect("o1", south.ports["o1"])
+    ubend2.connect("o2", south.ports["o2"])
+
+    north = (c << arm)
+    # north.mirror(p1=(0,0),p2=(1,0))
+    north.connect("o2", ubend1.ports["o2"])
+
+    xmin = c.xmin
+    ymin = c.ymin
+    ymax = c.ymax
+
+    leg1 = c << gf.components.straight(length=l, width=wwg, layer=core_layer)
+    # c.add_port(name="o1", center=(0, 0), width=wwg, orientation=0)
+    leg1.ymax = ymin-coupler_margin
+    leg1.xmin = xmin
+
+    leg2 = c << gf.components.straight(length=l, width=wwg, layer=core_layer)
+    leg2.ymin = ymax+coupler_margin
+    leg2.xmin = xmin
+
+    c.add_label("zigzag resonator", position=c.center)
+    c.show()
+    return c