multiport-interferometer 0.0.1__py3-none-any.whl

multiport_interferometer/__init__.py

@@ -0,0 +1,7 @@
+
+from .functions import sdict_to_matrix, bell_circuit_schematic, decom_to_model
+from .ideal_models import ideal_bell_models, ideal_clements_tbu_model, ideal_mzi, ideal_phaseshifter, ideal_waveguide
+from .bell_decomposer import decompose_bell
+from .bell_class import Bell
+from .clements_class import Clements
+from .bell_models import phase_shifter_model, edge_phaser_model, mzi_model, calibrated_mzi_model, plain_wvgd_model

multiport_interferometer/bell_class.py

@@ -0,0 +1,324 @@
+'''
+Copyright 2026 Carl Abi Nakad
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+'''
+
+from . import bell_components
+from . import bell_decomposer
+from . import functions as f
+import sax
+import numpy as np
+try:
+    from . import bell_models
+except ImportError:
+    bell_models=None
+import gdsfactory as gf
+
+class Bell:
+    def __init__(self, dimension):
+        if not isinstance(dimension, int) or dimension < 2:
+            raise ValueError("Dimension must be an integer >= 2")
+        self.dimension = dimension
+        self.components = self.load_components() #dictionaro of components
+        self.gds_component, self.sax_netlist = self.build()
+        if bell_models is not None:
+            self.models = self.load_models()
+            self.phase_offset = bell_models.phase_offset
+            self.phase_step = bell_models.phase_step
+        else:
+            self.models = None
+            print("No models.py found. SAX models were not loaded.")
+
+    def gds(self):
+        return self.gds_component
+        
+    def load_components(self):
+        return {"tbu":bell_components.tbu,
+                "phase_shifter": bell_components.phase_shifter,
+                "edge_phase_shifter": bell_components.edge_phase_shifter,
+                "waveguide": bell_components.plain_wvgd,
+                "edge_waveguide":bell_components.edge_wvgd
+                }
+
+    def load_models(self):
+        return {"tbu_model":bell_models.tbu_model,
+                "phase_shifter_model": bell_models.phase_shifter_model,
+                "edge_phase_shifter_model": bell_models.edge_phase_shifter_model,
+                "plain_wvgd_model": bell_models.plain_wvgd_model}
+
+    def emulate(self, target):
+        if np.shape(target)[0] != self.dimension:
+            raise ValueError("Target matrix incompatible with Interferometer Dimension")
+        decom = bell_decomposer.decompose_bell(target)
+        self.values = f.decom_to_model(self.models,decom)
+        circuit, info = sax.circuit(netlist=self.sax_netlist, models = self.values)
+        S = circuit()
+        return S
+    def phase_corrected(self, S):
+        correction = self.phase_offset + (self.dimension-2)*self.phase_step
+        Smat = f.sdict_to_matrix(S)*np.exp(-1j*correction)
+        return Smat
+
+    def build(self):
+        bell_components._check_pdk()
+        dim = self.dimension
+        c = gf.Component()
+        mzi_cell = self.components["tbu"]()
+        phaser_cell = self.components["phase_shifter"]()
+        edge_phaser_cell = self.components["edge_phase_shifter"]()
+        plain_wvgd = self.components["waveguide"]()
+        edge_wvgd = self.components["edge_waveguide"]()
+
+        last = dim-2
+        end = dim-1
+
+        instances = {}
+        connections = {}
+        ports = {}
+
+        phase_i = [None]*dim
+        phase_o = [None]*dim
+        phasers = {}
+        mzms = {}
+        wvgds = {}
+
+        # creating top boundary connector waveguides
+        for j in range(1, dim, 2): 
+            wvgds[(j)] = c<<plain_wvgd
+            instances[f"wvgd_{j}"] = "wvgd"
+
+        # creating bottom boundary phase shifters
+        if dim % 2 == 0: 
+            for j in range(1, dim, 2):
+                phasers[(end, j)] = c << phaser_cell
+                instances[f"phaser_{end}_{j}"] = f"phaser_{end}_{j}"
+        else:
+            for j in range(0, dim, 2):
+                phasers[(end, j)] = c << phaser_cell
+                instances[f"phaser_{end}_{j}"] = f"phaser_{end}_{j}"
+
+        # creating input and output edge phase shifters
+        if dim%2!=0:
+            for i in range(0,dim,2):
+                if i>0:
+                    phaser_o = c << edge_phaser_cell
+                    phaser_o.mirror_x()
+                    phase_o[i-1] = phaser_o
+                    phase_i[i-1] = c<<edge_wvgd
+                    instances[f"phaser_o{i-1}"] = f"phaser_o{i-1}"
+                    instances[f"phaser_i{i-1}"] = f"phaser_i{i-1}"
+                if i<dim-1:
+                    phaser_i = c << edge_phaser_cell
+                    phase_i[i] = phaser_i
+                    phase_o[i] = c<<edge_wvgd
+                    instances[f"phaser_i{i}"] = f"phaser_i{i}"
+                    instances[f"phaser_o{i}"] = f"phaser_o{i}"
+                else:
+                    phase_i[i] = c<<edge_wvgd
+                    phase_o[i] = c<<edge_wvgd
+                    instances[f"phaser_i{i}"] = f"phaser_i{i}"
+                    instances[f"phaser_o{i}"] = f"phaser_o{i}"
+        else:
+            for i in range(dim):
+                if i%2==0:
+                    if i<dim:
+                        phaser_i =c<<edge_phaser_cell
+                        phase_i[i] = phaser_i
+                        phaser_o = c<<edge_phaser_cell
+                        phase_o[i] = phaser_o
+                        instances[f"phaser_i{i}"] = f"phaser_i{i}"
+                        instances[f"phaser_o{i}"] = f"phaser_o{i}"
+                    else:
+                        phase_i[i] = c<<edge_wvgd
+                        phase_o[i] = c<<edge_wvgd
+                        instances[f"phaser_i{i}"] = f"phaser_i{i}"
+                        instances[f"phaser_o{i}"] = f"phaser_o{i}"
+                else:
+                    phase_i[i] = c<<edge_wvgd
+                    phase_o[i] = c<<edge_wvgd
+                    instances[f"phaser_i{i}"] = f"phaser_i{i}"
+                    instances[f"phaser_o{i}"] = f"phaser_o{i}"
+
+        # creating top and bottom mzis
+        for i in range(0, dim, 2):
+            # top mode mzis
+            mzm_top = c << mzi_cell
+            mzms[f"(0_{i})"] = mzm_top
+            instances[f"mzm_0_{i}"] = f"mzm_0_{i}"
+            if dim % 2 == 0:    # even bottom mode mzis
+                mzm_bottom = c << mzi_cell
+                mzms[f"({last}_{i})"] = mzm_bottom
+                instances[f"mzm_{last}_{i}"] = f"mzm_{last}_{i}"
+            else:   # odd bottom mode mzis
+                j = i + 1
+                if j > end:
+                    continue
+                mzm_bottom = c << mzi_cell
+                mzms[f"({last}_{j})"] = mzm_bottom
+                instances[f"mzm_{last}_{j}"] = f"mzm_{last}_{j}"
+
+        # create middle mzis
+        for i in range(1, last):
+            if i % 2 == 0:
+                for j in np.arange(0, dim, 2):
+                    mzm = c << mzi_cell
+                    mzms[f"({i}_{j})"] = mzm
+                    instances[f"mzm_{i}_{j}"] = f"mzm_{i}_{j}"
+            else:
+                for j in range(1, dim, 2):
+                    mzm = c << mzi_cell
+                    mzms[f"({i}_{j})"] = mzm
+                    instances[f"mzm_{i}_{j}"] = f"mzm_{i}_{j}"
+
+        # Connecting Mesh
+        for i in range(dim):
+
+            # Top boundary Connections
+            if i == 0:
+                if dim % 2 == 0:
+                    for j in range(0, dim - 2, 2):
+                        p = wvgds[(j+1)]
+                        p.connect("o1",mzms[f"({i}_{j})"].ports["o3"])
+                        mzms[f"({i}_{j+2})"].connect("o2",p.ports["o2"])
+                        connections[f"mzm_{i}_{j},out0"] = f"wvgd_{j+1},in0"
+                        connections[f"wvgd_{j+1},out0"] = f"mzm_{i}_{j+2},in0"
+                    p = wvgds[(end)]
+                    p.connect("o1",mzms[f"({i}_{dim-2})"].ports["o3"])
+                    connections[f"mzm_{i}_{dim-2},out0"] =f"wvgd_{end},in0"
+                else:
+                    for j in range(0, dim - 2, 2):
+                        p = wvgds[(j+1)]
+                        if j < last:
+                            p.connect("o1",mzms[f"({i}_{j})"].ports["o3"])
+                            connections[f"mzm_{i}_{j},out0"] =f"wvgd_{j+1},in0"
+                        if f"({i}_{j+2})" in mzms:
+                            mzms[f"({i}_{j+2})"].connect("o2",p.ports["o2"])
+                            connections[f"wvgd_{j+1},out0"] = f"mzm_{i}_{j+2},in0"
+
+            # Connecting diagonal mzis
+            for j in range(dim):
+                key = f"({i}_{j})"
+                if key not in mzms:
+                    continue
+                #up-right connection
+                if i > 0:
+                    upper_right = f"({i-1}_{j+1})"
+                    if upper_right in mzms:
+                        mzms[key].connect("o3",mzms[upper_right].ports["o1"])
+                        connections[f"mzm_{i}_{j},out0"] = f"mzm_{i-1}_{j+1},in1"
+                # downward-right connection
+                target = f"({i+1}_{j+1})"
+                if target in mzms:
+                    mzms[target].connect("o2", mzms[key].ports["o4"])
+                    connections[f"mzm_{i}_{j},out1"] = f"mzm_{i+1}_{j+1},in0"
+
+            # bottom boundary connections
+            if i == last:
+                if dim % 2 == 0:
+                    for j in range(1, last, 2):
+                        p = phasers[(end, j)]
+                        p.connect("o1", mzms[f"({i}_{j-1})"].ports["o4"])
+                        p.connect("o2", mzms[f"({i}_{j+1})"].ports["o1"])
+                        connections[f"mzm_{i}_{j-1},out1"] = f"phaser_{end}_{j},in0"
+                        connections[f"phaser_{end}_{j},out0"] = f"mzm_{i}_{j+1},in1"
+                    # last bottom phaser
+                    p = phasers[(end, end)]
+                    p.connect("o1", mzms[f"({last}_{last})"].ports["o4"])
+                    connections[f"mzm_{last}_{last},out1"] = f"phaser_{end}_{end},in0"
+                else:
+                    # first bottom phaser
+                    p = phasers[(end, 0)]
+                    p.connect("o2", mzms[f"({last}_1)"].ports["o1"])
+                    connections[f"phaser_{end}_0,out0"] = f"mzm_{last}_1,in1"
+
+                    # last bottom phaser
+                    p = phasers[(end, end)]
+                    p.connect("o1",mzms[f"({last}_{last})"].ports["o4"])
+                    connections[f"mzm_{last}_{last},out1"] = f"phaser_{end}_{end},in0"
+
+                    # intermediate bottom phasers
+                    for j in range(2, last, 2):
+                        p = phasers[(end, j)]
+                        p.connect("o1",mzms[f"({i}_{j-1})"].ports["o4"])
+                        connections[f"mzm_{i}_{j-1},out1"] = f"phaser_{end}_{j},in0"
+                        p.connect("o2",mzms[f"({i}_{j+1})"].ports["o1"])
+                        connections[f"phaser_{end}_{j},out0"] = f"mzm_{i}_{j+1},in1"
+
+        # connecting input phaseshifters
+        for i in range(0, dim - 1, 2):
+            phase_i[i].connect("o2",mzms[f"({i}_0)"].ports["o2"])
+            connections[f"phaser_i{i},out0"] = f"mzm_{i}_0,in0" #these are sax connections, port naming is swapped with the gds naming because sax component models using standard matrix convention
+            phase_i[i+1].connect("o2",mzms[f"({i}_0)"].ports["o1"])
+            connections[f"phaser_i{i+1},out0"] = f"mzm_{i}_0,in1"
+            c.add_port(f"in{i}",port=phase_i[i].ports["o1"])
+            ports[f"in{i}"] = f"phaser_i{i},in0"
+            c.add_port(f"in{i+1}",port=phase_i[i+1].ports["o1"])
+            ports[f"in{i+1}"] = f"phaser_i{i+1},in0"
+
+        # odd final input phaseshifter
+        if dim % 2 != 0:
+            phase_i[end].connect("o2",phasers[(end, 0)].ports["o1"])
+            connections[f"phaser_i{end},out0"] = f"phaser_{end}_0,in0"
+            c.add_port(f"in{end}",port=phase_i[end].ports["o1"])
+            ports[f"in{end}"] = f"phaser_i{end},in0"
+
+        # Connecting output phase shifters - Even
+        if dim % 2 == 0:
+            # top mode
+            phase_o[0].connect("o2",wvgds[(end)].ports["o2"])
+            connections[f"wvgd_{end},out0"] = "phaser_o0,in0"
+            c.add_port("out0",port=phase_o[0].ports["o1"])
+            ports["out0"] = "phaser_o0,out0"
+
+            # middle modes
+            for i in range(1, end, 2):
+                phase_o[i].connect("o2",mzms[f"({i}_{end})"].ports["o3"])
+                phase_o[i+1].connect("o2",mzms[f"({i}_{end})"].ports["o4"])
+                connections[f"mzm_{i}_{end},out0"] = f"phaser_o{i},in0"
+                connections[f"mzm_{i}_{end},out1"] = f"phaser_o{i+1},in0"
+                c.add_port(f"out{i}",port=phase_o[i].ports["o1"])
+                c.add_port(f"out{i+1}",port=phase_o[i+1].ports["o1"])
+                ports[f"out{i}"] = f"phaser_o{i},out0"
+                ports[f"out{i+1}"] = f"phaser_o{i+1},out0"
+
+            # bottom mode
+            phase_o[end].connect("o2", phasers[(end, end)].ports["o2"])
+            connections[f"phaser_{end}_{end},out0"] = f"phaser_o{end},in0"
+            c.add_port(f"out{end}", port=phase_o[end].ports["o1"])
+            ports[f"out{end}"] = f"phaser_o{end},out0"
+
+        # Connecting output phase shifters - Even
+        else:
+            output_col = end
+            for i in range(0, dim - 1, 2):
+                phase_o[i].connect("o2", mzms[f"({i}_{output_col})"].ports["o3"])
+                connections[f"mzm_{i}_{output_col},out0"] = f"phaser_o{i},in0"
+                phase_o[i+1].connect("o2", mzms[f"({i}_{output_col})"].ports["o4"])
+                connections[f"mzm_{i}_{output_col},out1"] = f"phaser_o{i+1},in0"
+                c.add_port(f"out{i}", port=phase_o[i].ports["o1"])
+                ports[f"out{i}"] = f"phaser_o{i},out0"
+                c.add_port(f"out{i+1}", port=phase_o[i+1].ports["o1"])
+                ports[f"out{i+1}"] = f"phaser_o{i+1},out0"
+                
+            # bottom mode
+            phase_o[end].connect("o2", phasers[(end, end)].ports["o2"])
+            connections[f"phaser_{end}_{end},out0"] = f"phaser_o{end},in0"
+            c.add_port(f"out{end}", port=phase_o[end].ports["o1"])
+            ports[f"out{end}"] = f"phaser_o{end},out0"
+        
+        netlist = {}
+        netlist["instances"]=instances
+        netlist["connections"]=connections
+        netlist["ports"]=ports
+        return c, netlist

multiport_interferometer/bell_components.py

@@ -0,0 +1,219 @@
+'''
+File of my custom gdsfactory component functions to be used in the project
+'''
+
+import gdsfactory as gf
+import uuid
+
+# I use the Si 220 cband pdk from cornerstone
+from cspdk.si220.cband import cells, PDK, LAYER_STACK
+
+def activate_pdk():
+    PDK.activate()
+
+def _check_pdk():
+    if gf.get_active_pdk().name != PDK.name:
+        raise RuntimeError("Activate the Cornerstone Si220 C-band PDK first.")
+
+'''
+The circuit requires the 4 component names: 
+'''
+def tbu():
+    return mzi()
+def phase_shifter():
+    return phaser()
+def edge_phase_shifter():
+    return edge_phaser()
+def plain_wvgd():
+    return plain()
+#def edge_wvgd(): already exists with correct name
+
+'''
+the actual gdscomponents:
+'''
+
+phaser_len = 150
+
+@gf.cell
+def s_bend():
+    c = gf.Component()
+    bend = cells.bend_euler()
+    up = c << bend
+    down = c<< bend
+    up.rotate(90)
+    down.rotate(-90)
+    down.connect("o1", up.ports["o1"])
+    c.add_port("o1", port=up.ports["o2"])
+    c.add_port("o2", port = down.ports["o2"])
+    return c
+
+@gf.cell 
+def mzi():
+    c = gf.Component()
+    coupler = cells.coupler()
+    phaser = cells.straight_heater_metal(length = phaser_len)
+    bend = s_bend()
+    i_up = c<<bend
+    i_down = c<<bend
+    i_down.mirror()
+    o_up = c << bend
+    o_down = c<<bend
+    o_up.mirror()
+    top = c<<phaser
+    bottom = c<<phaser
+    top_left= c<<bend
+    top_left.mirror()
+    top_right = c<<bend
+    bottom_left = c<<bend
+    bottom_right = c<<bend
+    bottom_right.mirror()
+    coupler1 = c<<coupler
+    coupler2 = c<<coupler
+    i_down.connect("o1", coupler1.ports["o1"])
+    i_up.connect("o1", coupler1.ports["o2"])
+    top_left.connect("o1", coupler1.ports["o3"])
+    bottom_left.connect("o1", coupler1.ports["o4"])
+    top.connect("o1", top_left["o2"])
+    bottom.connect("o1", bottom_left["o2"])
+    top_right.connect("o1", top['o2'])
+    bottom_right.connect("o1", bottom['o2'])
+    coupler2.connect("o1", bottom_right["o2"])
+    coupler2.connect("o2", top_right["o2"])
+    o_up.connect('o1', coupler2["o3"])
+    o_down.connect('o1', coupler2["o4"])
+    c.add_port(name="o1", port=i_down['o2'])
+    c.add_port(name = 'o2', port=i_up['o2'])
+    c.add_port(name = 'o3', port=o_up['o2'])
+    c.add_port(name = 'o4', port=o_down['o2'])
+    return c
+
+@gf.cell
+def edge_phaser(phase_len=phaser_len):
+    c = gf.Component()
+    wvgd = cells.straight(cross_section="strip")
+    phaser = cells.straight_heater_metal(length= phase_len)
+    w = c<<wvgd
+    p = c<<phaser
+    p.connect("o1", w["o2"])
+    c.add_port(name="o1", port = w["o1"])
+    c.add_port(name = "o2", port=p["o2"])
+    return c
+
+@gf.cell
+def edge_wvgd(phase_len=phaser_len):
+    c = gf.Component()
+    wvgd1 = cells.straight(cross_section="strip")
+    wvgd2 = cells.straight(length= phase_len)
+    w1 = c<<wvgd1
+    w2 = c<<wvgd2
+    w2.connect("o1", w1["o2"])
+    c.add_port(name="o1", port = w1["o1"])
+    c.add_port(name = "o2", port=w2["o2"])
+    return c
+
+def coupler_single_arm(keep="top"):
+    c = gf.Component(f"coupler_single_arm_{keep}_{uuid.uuid4().hex[:6]}")
+
+    cp = cells.coupler()
+    cp = cp.copy()
+    cp.flatten()
+
+    WG_LAYER = gf.get_active_pdk().layers.WG
+    wg = cp.extract(layers=[WG_LAYER])
+
+    bbox = wg.bbox()
+    xmin = bbox.left
+    xmax = bbox.right
+    ymin = bbox.bottom
+    ymax = bbox.top
+    ymid = (ymin + ymax) / 2
+
+    if keep == "top":
+        y0 = ymid
+        height = ymax - ymid
+    else:
+        y0 = ymin
+        height = ymid - ymin
+
+    clip = gf.components.rectangle(
+        size=(xmax - xmin, height),
+        layer=WG_LAYER,
+    )
+
+    clip_component = gf.Component(f"clip_{uuid.uuid4().hex[:6]}")
+    r = clip_component << clip
+    r.move((xmin, y0))
+
+    arm = gf.boolean(
+        A=wg,
+        B=clip_component,
+        operation="and",
+        layer=WG_LAYER,
+    )
+
+    c << arm
+
+    cp_original = cells.coupler()
+    cp_ports = list(cp_original.ports)
+
+    if keep == "top":
+        selected_ports = [p for p in cp_ports if p.center[1] > ymid]
+    else:
+        selected_ports = [p for p in cp_ports if p.center[1] < ymid]
+
+    selected_ports = sorted(selected_ports, key=lambda p: p.center[0])
+
+    c.add_port(name="o1", port=selected_ports[0])
+    c.add_port(name="o2", port=selected_ports[1])
+
+    return c
+
+@gf.cell
+def phaser(phase_len=phaser_len):
+    c = gf.Component()
+    bottom = coupler_single_arm("bottom")
+    bend = s_bend()
+    phase_shift = cells.straight_heater_metal(length =phase_len)
+    i = c<<bend
+    o = c<<bend
+    o.mirror()
+    left = c<<bend
+    left.mirror()
+    right = c<<bend
+    s1 = c<<bottom
+    s2 = c<<bottom
+    phaser = c<<phase_shift
+    s1.connect("o1", i["o2"])
+    left.connect("o1", s1['o2'])
+    phaser.connect("o1", left['o2'])
+    right.connect('o1', phaser['o2'])
+    s2.connect('o1', right['o2'])
+    o.connect('o1', s2['o2'])
+    c.add_port(name='o1', port=i['o1'])
+    c.add_port(name = 'o2', port=o['o2'])
+    return c
+
+@gf.cell
+def plain(lent=phaser_len):
+    c = gf.Component()
+    bottom = coupler_single_arm("bottom")
+    bend = s_bend()
+    straight = cells.straight(length =lent)
+    i = c<<bend
+    o = c<<bend
+    o.mirror()
+    left = c<<bend
+    left.mirror()
+    right = c<<bend
+    s1 = c<<bottom
+    s2 = c<<bottom
+    wvgd = c<<straight
+    s1.connect("o1", i["o2"])
+    left.connect("o1", s1['o2'])
+    wvgd.connect("o1", left['o2'])
+    right.connect('o1', wvgd['o2'])
+    s2.connect('o1', right['o2'])
+    o.connect('o1', s2['o2'])
+    c.add_port(name='o1', port=i['o1'])
+    c.add_port(name = 'o2', port=o['o2'])
+    return c