multiport-interferometer 0.0.1__py3-none-any.whl

multiport_interferometer/bell_decomposer.py

@@ -0,0 +1,213 @@
+
+# Portions of this file are derived from Strawberry Fields
+# Copyright 2019 Xanadu Quantum Technologies Inc.
+#
+# Modifications Copyright 2026 Carl Abi Nakad
+#
+# Modified from:
+# https://github.com/XanaduAI/strawberryfields
+#
+# Licensed under the Apache License, Version 2.0.
+# See the LICENSE file for details.
+
+import numpy as np
+from collections import defaultdict
+
+def _rectangular_compact_init(
+    U, rtol=1e-12, atol=1e-12
+):  # pylint: disable=too-many-statements, too-many-branches
+    r"""Rectangular decomposition of a unitary with sMZIs and phase-shifters, as given in FIG. 3 and "The Clements Scheme" section of (arXiv:2104.0756).
+
+    Args:
+        U (array): unitary matrix
+
+    Returns:
+        dict: A dictionary containing the following items:
+
+        * ``m``: the length of the matrix
+        * ``phi_ins``: parameter of the phase-shifter at the beginning of the mode
+        * ``sigmas``: parameter of the sMZI :math:`\frac{(\theta_1+\theta_2)}{2}`, where :math:`\theta_{1,2}` are the values of the two internal phase-shifts of sMZI
+        * ``deltas``: parameter of the sMZI :math:`\frac{(\theta_1-\theta_2)}{2}`, where :math:`\theta_{1,2}` are the values of the two internal phase-shifts of sMZI
+        * ``zetas``: parameter of the phase-shifter at the middle of the mode
+        * ``phi_outs``: parameter of the phase-shifter at the end of the mode
+
+    """
+
+    V = U.conj()
+    m = U.shape[0]
+
+    phases = {}
+    phases["m"] = m
+    phases["phi_ins"] = {}  # mode : phi
+    phases["deltas"] = {}  # (mode, layer) : delta
+    phases["sigmas"] = {}  # (mode, layer) : sigma
+    phases["zetas"] = {}  # mode : zeta
+    phases["phi_outs"] = {}  # mode : phi
+
+    for j in range(m - 1):
+        if j % 2 == 0:
+            x = m - 1
+            y = j
+            phi_j = np.angle(V[x, y + 1]) - np.angle(V[x, y])  # reversed order from paper
+            V = V @ P(j, phi_j, m)
+            phases["phi_ins"][j] = phi_j
+            for k in range(j + 1):
+                if V[x, y] == 0:
+                    delta = 0.5 * np.pi
+                else:
+                    delta = np.arctan2(-abs(V[x, y + 1]), abs(V[x, y]))
+                n = j - k
+                V_temp = V @ M(n, 0, delta, m)
+                sigma = np.angle(V_temp[x - 1, y - 1]) - np.angle(V_temp[x - 1, y])
+                V = V @ M(n, sigma, delta, m)
+                phases["deltas"][n, k] = delta
+                phases["sigmas"][n, k] = sigma
+                x -= 1
+                y -= 1
+        else:
+            x = m - j - 1
+            y = 0
+            phi_j = np.angle(V[x - 1, y]) - np.angle(V[x, y])
+            V = P(x, phi_j, m) @ V
+            phases["phi_outs"][x] = phi_j
+            for k in range(j + 1):
+                if V[x, y] == 0.0:
+                    delta = 0.5 * np.pi
+                else:
+                    delta = np.arctan2(abs(V[x - 1, y]), abs(V[x, y]))
+                V_temp = M(x - 1, 0, delta, m) @ V
+                n = m + k - j - 2
+                if j != k:
+                    sigma = np.angle(V_temp[x + 1, y + 1]) - np.angle(V_temp[x, y + 1])
+                else:
+                    sigma = 0
+                phases["deltas"][n, m - k - 1] = delta
+                phases["sigmas"][n, m - k - 1] = sigma
+                V = M(n, sigma, delta, m) @ V
+                x += 1
+                y += 1
+
+    # these next two lines are just to remove a global phase
+    zeta = -np.angle(V[0, 0])
+    V = V @ P(0, zeta, m)
+    phases["zetas"][0] = zeta
+
+    for j in range(1, m):
+        zeta = np.angle(V[0, 0]) - np.angle(V[j, j])
+        V = V @ P(j, zeta, m)
+        phases["zetas"][j] = zeta
+
+    assert np.allclose(V, np.eye(m), rtol=rtol, atol=atol), "decomposition failed"
+
+    return phases
+
+def _absorb_zeta(phases):
+    r"""Adjust rectangular decomposition to relocate residual phase-shifters of interferometer to edge-shifters, as given in FIG. 4 and "Relocating residual phase-shifts" section of (arXiv:2104.0756).
+
+    Args:
+        phases (dict): output of _rectangular_compact_init
+
+    Returns:
+        dict: A dictionary containing the following items:
+
+        * ``m``: the length of the matrix
+        * ``phi_ins``: parameter of the phase-shifter at the beginning of the mode
+        * ``sigmas``: parameter of the sMZI :math:`\frac{(\theta_1+\theta_2)}{2}`, where :math:`\theta_{1,2}` are the values of the two internal phase-shifts of sMZI
+        * ``deltas``: parameter of the sMZI :math:`\frac{(\theta_1-\theta_2)}{2}`, where :math:`\theta_{1,2}` are the values of the two internal phase-shifts of sMZI
+        * ``phi_edges``: parameters of the edge phase shifters
+        * ``phi_outs``: parameter of the phase-shifter at the end of the mode
+
+    """
+    m = phases["m"]
+    new_phases = phases.copy()
+    del new_phases["zetas"]
+    new_phases["phi_edges"] = defaultdict(float)  # (mode, layer) : phi
+
+    if m % 2 == 0:
+        new_phases["phi_outs"][0] = phases["zetas"][0]
+        for j in range(1, m):
+            zeta = phases["zetas"][j]
+            layer = m - j
+            for mode in range(j, m - 1, 2):
+                new_phases["sigmas"][mode, layer] += zeta
+            for mode in range(j + 1, m - 1, 2):
+                new_phases["sigmas"][mode, layer - 1] -= zeta
+            if layer % 2 == 1:
+                new_phases["phi_edges"][m - 1, layer] += zeta
+            else:
+                new_phases["phi_edges"][m - 1, layer - 1] -= zeta
+    else:
+        for j in range(m):
+            zeta = phases["zetas"][j]
+            layer = m - j - 1
+            for mode in range(j, m - 1, 2):
+                new_phases["sigmas"][mode, layer] += zeta
+            for mode in range(j + 1, m - 1, 2):
+                new_phases["sigmas"][mode, layer - 1] -= zeta
+            if layer % 2 == 0:
+                new_phases["phi_edges"][m - 1, layer] += zeta
+            else:
+                new_phases["phi_edges"][m - 1, layer - 1] -= zeta
+    return new_phases
+
+
+def decompose_bell(U, rtol=1e-12, atol=1e-12):
+    r"""Rectangular decomposition of a unitary with sMZIs and phase-shifters, as given in FIG. 3+4 and "The Clements Scheme" section of (arXiv:2104.0756).
+
+    Args:
+        U (array): unitary matrix
+
+    Returns:
+        dict: A dictionary containing the following items:
+
+        * ``m``: the length of the matrix
+        * ``phi_ins``: parameter of the phase-shifter at the beginning of the mode
+        * ``sigmas``: parameter of the sMZI :math:`\frac{(\theta_1+\theta_2)}{2}`, where :math:`\theta_{1,2}` are the values of the two internal phase-shifts of sMZI
+        * ``deltas``: parameter of the sMZI :math:`\frac{(\theta_1-\theta_2)}{2}`, where :math:`\theta_{1,2}` are the values of the two internal phase-shifts of sMZI
+        * ``phi_edges``: parameters of the edge phase shifters
+        * ``phi_outs``: parameter of the phase-shifter at the end of the mode
+    """
+
+    if not U.shape[0] == U.shape[1]:
+        raise ValueError("Matrix is not square")
+
+    if not np.allclose(U @ U.conj().T, np.eye(U.shape[0]), rtol=rtol, atol=atol):
+        raise ValueError("The input matrix is not unitary")
+
+    phases_temp = _rectangular_compact_init(U, rtol=rtol, atol=atol)
+    return _absorb_zeta(phases_temp)
+
+def M(n, sigma, delta, m):
+    r"""The symmetric Mach Zehnder interferometer matrix. (Eq 1 of the paper (arXiv:2104.0756).)
+
+    Args:
+        n (int): the starting mode of sMZI
+        sigma (complex): parameter of the sMZI :math:`\frac{(\theta_1+\theta_2)}{2}`, where :math:`\theta_{1,2}` are the values of the two internal phase-shifts of sMZI
+        delta (complex): parameter of the sMZI :math:`\frac{(\theta_1-\theta_2)}{2}`, where :math:`\theta_{1,2}` are the values of the two internal phase-shifts of sMZI
+        m (int): the length of the unitary matrix to be decomposed
+
+    Returns:
+        array[complex,complex]: the sMZI matrix between n-th and (n+1)-th mode
+    """
+    mat = np.identity(m, dtype=np.complex128)
+    mat[n, n] = np.exp(1j * sigma) * np.sin(delta)
+    mat[n, n + 1] = np.exp(1j * sigma) * np.cos(delta)
+    mat[n + 1, n] = np.exp(1j * sigma) * np.cos(delta)
+    mat[n + 1, n + 1] = -np.exp(1j * sigma) * np.sin(delta)
+    return mat
+
+
+def P(j, phi, m):
+    r"""The phase shifter matrix. (Eq 2 of the paper (arXiv:2104.0756).)
+
+    Args:
+        j (int): the starting mode of phase-shifter
+        phi (complex): parameter of the phase-shifter
+        m (int): the length of the unitary matrix to be decomposed
+
+    Returns:
+        array[complex,complex]: the phase-shifter matrix on the j-th mode
+    """
+    mat = np.identity(m, dtype=np.complex128)
+    mat[j, j] = np.exp(1j * phi)
+    return mat

multiport_interferometer/bell_models.py

@@ -0,0 +1,258 @@
+'''
+Script for Sax Models used
+'''
+
+import numpy as np
+from pathlib import Path
+import sax
+import pickle
+
+MODEL_DIR = Path(__file__).resolve().parent / "sax_models"
+
+'''
+calibration values from calibration notebook
+'''
+phase_offset = 3.5650791015113166
+phase_step = -1.54018263
+
+'''
+the circuit requires models with following names:
+'''
+def tbu_model(sigma, delta):
+    return calibrated_mzi_model(sig=sigma, delt = delta)
+# phase_shifter_model(): has correct name
+def edge_phase_shifter_model(phi):
+    return edge_phaser_model(phi)
+#def plain_wvgd_model(): has correct name
+
+############################################################################################################################
+'''
+Loading Sax dicts
+'''
+#############################
+'''
+phi must be in radians
+default wavegudie is the 150um waveguide
+returns sax matrix of phase with total phase= standard waveguide phase + added thermooptic
+'''
+def phaser_model(phi, waveguide='waveguide_150.pkl'):
+    filepath = MODEL_DIR / waveguide
+    with filepath.open("rb") as f:
+        ref_sdict = pickle.load(f)
+    ref_phase = np.angle(ref_sdict[('in0','out0')])
+    new = np.exp(1j*(ref_phase+phi))
+    phaser_model = sax.reciprocal({("in0", "out0"): new})
+    return phaser_model
+
+def arm_model():
+    filepath = MODEL_DIR / 's_arm.pkl'
+    with filepath.open("rb") as f:
+        arm_model = pickle.load(f)
+    return arm_model
+
+def coupler_model():
+    filepath = MODEL_DIR / "coupler_50_50_2port.pkl"
+    with filepath.open("rb") as f:
+        sax_sdict = pickle.load(f)
+    return sax_sdict
+
+def edge_wvgd_model():
+    filepath = MODEL_DIR / "straight_L10.pkl"
+    with filepath.open("rb") as f:
+        wvgd_sdict = pickle.load(f)
+    return wvgd_sdict
+
+def wvgd_model(waveguide='waveguide_150.pkl'):
+    filepath = MODEL_DIR / waveguide
+    with filepath.open("rb") as f:
+        ref_sdict = pickle.load(f)
+    return ref_sdict
+
+def s_bend_model():
+    filepath = MODEL_DIR / 's_bend.pkl'
+    with filepath.open("rb") as f:
+        arm_model = pickle.load(f)
+    return arm_model
+
+############################################################################################################################
+'''
+Plain waveguide Circuit
+'''
+##########################
+def plain_wvgd_model():
+    total_circ, info = sax.circuit(
+    netlist={
+        "instances": {
+            "lft": "connector",
+            "middle": "straight",
+            "rgt": "connector",
+        },
+        "connections": {
+            "lft,out0": "middle,in0",
+            "middle,out0": "rgt,in0",
+        },
+        "ports": {
+            "in0": "lft,in0",
+            "out0": "rgt,out0",
+        },
+    },
+    models={
+        "connector": connector_model,
+        "straight": wvgd_model,
+    },
+    )
+    return total_circ()
+############################################################################################################################
+'''
+Phase shifters Circuits
+'''
+##########################
+def connector_model():
+    total_circ, info = sax.circuit(
+    netlist={
+        "instances": {
+            "lft": "sbend",
+            "middle": "arm",
+            "rgt": "sbend",
+        },
+        "connections": {
+            "lft,out0": "middle,in0",
+            "middle,out0": "rgt,in0", 
+        },
+        "ports": {
+            "in0": "lft,in0",
+            "out0": "rgt,out0",
+        },
+    },
+    models={
+        "arm": arm_model,
+        "sbend": s_bend_model,
+    },
+    )
+    return total_circ()
+
+
+'''
+returns the sax circuit matrix for the complete arm-phase_shifter-arm component that is used in the mesh
+'''
+def phase_shifter_model(phi=0):
+    total_circ, info = sax.circuit(
+    netlist={
+        "instances": {
+            "lft": "connector",
+            "middle": "phaser",
+            "rgt": "connector",
+        },
+        "connections": {
+            "lft,out0": "middle,in0",
+            "middle,out0": "rgt,in0",
+        },
+        "ports": {
+            "in0": "lft,in0",
+            "out0": "rgt,out0",
+        },
+    },
+    models={
+        "connector": connector_model,
+        "phaser": lambda: phaser_model(phi)
+    },
+    )
+    return total_circ()
+
+def edge_phaser_model(phi=0):
+    total_circ, info = sax.circuit(
+    netlist={
+        "instances": {
+            "lft": "wvgd",
+            'rgt': 'phaser',
+        },
+        "connections": {
+            "lft,out0": "rgt,in0",
+        },
+        "ports": {
+            "in0": "lft,in0",
+            "out0": "rgt,out0",
+        },
+    },
+    models={
+        "wvgd": edge_wvgd_model,
+        "phaser": lambda: phaser_model(phi)#+2.9604398423257847),
+    },
+    )
+    return total_circ()
+
+########################################################################################################################
+'''
+MZI Model Circuits
+'''
+##############################
+
+def mzi_coupler():
+    total_circ, info = sax.circuit(
+        netlist={
+            "instances":{
+                'tl':"sbend",
+                'bl':'sbend',
+                'tr':'sbend',
+                'br':'sbend',
+                'coupler':'coupler',
+            },
+            "connections":{
+                'tl,out0':'coupler,in1',
+                'bl,out0':'coupler,in0',
+                'coupler,out1':'tr,in0',
+                'coupler,out0':'br,in0',
+            },
+            "ports":{
+                'in0':'bl,in0',
+                'in1':'tl,in0',
+                'out0':'br,out0',
+                'out1':'tr,out0',
+            },
+        },
+        models={
+            'sbend':s_bend_model,
+            'coupler':coupler_model,
+        },
+    )
+    return total_circ()
+'''
+returns the mzi smatrix, takes input delta and sigma
+'''
+def mzi_model(sigma=0,delta=0):
+    phi1 = sigma-delta
+    phi2 = sigma + delta
+    total_circ, info = sax.circuit(
+    netlist={
+        "instances": {
+            "lft": "coupler",
+            "top": "phaser1",
+            "bottom": "phaser2",
+            'rgt': 'coupler',
+        },
+        "connections": {
+            "lft,out0": "bottom,in0",
+            'lft,out1': "top,in0",
+            "top,out0": "rgt,in1",
+            "bottom,out0":"rgt,in0"
+
+        },
+        "ports": {
+            "in0": "lft,in0",
+            "in1": "lft,in1",
+            "out0": "rgt,out0",
+            "out1": "rgt,out1",
+        },
+    },
+    models={
+        "coupler": mzi_coupler,
+        "phaser1": lambda: phaser_model(phi1),
+        "phaser2": lambda: phaser_model(phi2)
+    },
+    )
+    return total_circ()
+
+def calibrated_mzi_model(sig=0, delt=0):
+    sigma_offset = 2.03765676
+    delta_offset = 3.0629742188152735
+    return mzi_model(sigma=sig+sigma_offset,delta=delt+delta_offset)

multiport_interferometer/clements_class.py

@@ -0,0 +1,220 @@
+'''
+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.
+'''
+
+import interferometer as itf
+from . import ideal_models as ideal
+import numpy as np
+import sax
+
+class Clements:
+    def __init__(self, dimension):
+        if not isinstance(dimension, int) or dimension < 2:
+            raise ValueError("Dimension must be an integer >= 2")
+        self.dimension = dimension
+        self.schematic_netlist = self.clements_circuit_schematic()
+    
+    def ideal_emulate(self,U):
+        if U.shape[0]!=self.dimension:
+            raise ValueError(f'Matrix Dimension {U.shape[0]} not compatible with Mesh Dimension {self.dimension}')
+        mods = self.clements_models_ideal(U)
+        netlist = self.schematic_netlist
+        circuit, info = sax.circuit(netlist=netlist, models = mods)
+        S = circuit()
+        return S
+    
+    def clements_circuit_schematic(self):
+        dim = self.dimension
+        last = dim-2
+        end = dim-1
+
+        instances = {}
+        connections = {}
+        ports = {}
+
+        # creating top boundary connector waveguides
+        for j in range(1, dim, 2): 
+            instances[f"wvgd_top_{j}"] = "wvgd"
+
+        #create bottom boundary connector waveguides
+        if dim % 2 == 0:
+            for j in range(1, dim, 2):
+                instances[f"wvgd_bottom_{j}"] = "wvgd"
+        else:
+            for j in range(0, dim, 2):
+                instances[f"wvgd_bottom_{j}"] = "wvgd"
+
+        # creating output edge phase shifters
+        for i in range(dim):
+            instances[f"phaser_o{i}"] = f"phaser_o{i}"
+
+        # creating top and bottom mzis
+        for i in range(0, dim, 2):
+            # top mode mzis
+            instances[f"bs_0_{i}"] = f"bs_0_{i}"
+            if dim % 2 == 0:    # even bottom mode mzis
+                instances[f"bs_{last}_{i}"] = f"bs_{last}_{i}"
+            else:   # odd bottom mode mzis
+                j = i + 1
+                if j > end:
+                    continue
+                instances[f"bs_{last}_{j}"] = f"bs_{last}_{j}"
+
+        # create middle mzis
+        for i in range(1, last):
+            if i % 2 == 0:
+                for j in np.arange(0, dim, 2):
+                    instances[f"bs_{i}_{j}"] = f"bs_{i}_{j}"
+            else:
+                for j in range(1, dim, 2):
+                    instances[f"bs_{i}_{j}"] = f"bs_{i}_{j}"
+
+        # Connecting Mesh
+        for i in range(dim-1):
+
+            # Top boundary Connections
+            if i == 0:
+                if dim % 2 == 0:
+                    for j in range(0, dim - 2, 2):
+                        connections[f"bs_{i}_{j},out0"] = f"wvgd_top_{j+1},in0"
+                        connections[f"wvgd_top_{j+1},out0"] = f"bs_{i}_{j+2},in0"
+                    connections[f"bs_{i}_{dim-2},out0"] =f"wvgd_top_{end},in0"
+                else:
+                    for j in range(0, dim - 2, 2):
+                        if j < last:
+                            connections[f"bs_{i}_{j},out0"] =f"wvgd_top_{j+1},in0"
+                        if f"bs_{i}_{j+2}" in instances:
+                            connections[f"wvgd_top_{j+1},out0"] = f"bs_{i}_{j+2},in0"
+
+            # Connecting diagonal mzis
+            for j in range(dim):
+                key = f"bs_{i}_{j}"
+                if key not in instances:
+                    continue
+                #up-right connection
+                if i > 0:
+                    upper_right = f"bs_{i-1}_{j+1}"
+                    if upper_right in instances:
+                        connections[f"bs_{i}_{j},out0"] = f"bs_{i-1}_{j+1},in1"
+                # downward-right connection
+                target = f"bs_{i+1}_{j+1}"
+                if target in instances:
+                    connections[f"bs_{i}_{j},out1"] = f"bs_{i+1}_{j+1},in0"
+
+            # bottom boundary connections
+            if i == last:
+                if dim % 2 == 0:
+                        # intermediate bottom boundary connections
+                    for j in range(1, last, 2):
+                        connections[f"bs_{last}_{j-1},out1"] = f"wvgd_bottom_{j},in0"
+                        connections[f"wvgd_bottom_{j},out0"] = f"bs_{last}_{j+1},in1"
+
+                    # final bottom boundary segment
+                    connections[f"bs_{last}_{last},out1"] = f"wvgd_bottom_{end},in0"
+                    # bottom output
+                    connections[f"wvgd_bottom_{end},out0"] = f"phaser_o{end},in0"
+                    ports[f"out{end}"] = f"phaser_o{end},out0"
+                else:
+                    # first bottom phaser
+                    connections[f"wvgd_bottom_0,out0"] = f"bs_{last}_1,in1"
+
+                    # last bottom phaser
+                    connections[f"bs_{last}_{last},out1"] = f"wvgd_bottom_{end},in0"
+
+                    # intermediate bottom phasers
+                    for j in range(2, last, 2):
+                        connections[f"bs_{i}_{j-1},out1"] = f"wvgd_bottom_{j},in0"
+                        connections[f"wvgd_bottom_{j},out0"] = f"bs_{i}_{j+1},in1"
+
+        # Connecting output phase shifters 
+        if dim % 2 == 0:
+            # top boundary output
+            connections[f"wvgd_top_{end},out0"] = "phaser_o0,in0"
+            ports["out0"] = "phaser_o0,out0"
+
+            # middle BS outputs
+            for i in range(1, last, 2):
+                connections[f"bs_{i}_{end},out0"] = f"phaser_o{i},in0"
+                connections[f"bs_{i}_{end},out1"] = f"phaser_o{i+1},in0"
+
+                ports[f"out{i}"] = f"phaser_o{i},out0"
+                ports[f"out{i+1}"] = f"phaser_o{i+1},out0"
+
+        # Connecting output phase shifters - odd
+        else:
+            output_col = end
+            for i in range(0, dim - 1, 2):
+                connections[f"bs_{i}_{output_col},out0"] = f"phaser_o{i},in0"
+                connections[f"bs_{i}_{output_col},out1"] = f"phaser_o{i+1},in0"
+                ports[f"out{i}"] = f"phaser_o{i},out0"
+                ports[f"out{i+1}"] = f"phaser_o{i+1},out0"
+            # bottom mode
+        connections[f"wvgd_bottom_{end},out0"] = f"phaser_o{end},in0"
+        ports[f"out{end}"] = f"phaser_o{end},out0"  
+
+        # input ports
+        for i in range(0, dim - 1, 2):
+            ports[f"in{i}"] = f"bs_{i}_0,in0"
+            ports[f"in{i+1}"] = f"bs_{i}_0,in1"
+
+        if dim % 2 != 0:
+            ports[f"in{end}"] = "wvgd_bottom_0,in0"
+        netlist = {}
+        netlist['instances'] = instances
+        netlist['connections'] = connections
+        netlist['ports'] = ports
+        return netlist
+    
+    def clements_models_ideal(self,U):
+        I = itf.square_decomposition(U)
+        dim = U.shape[0]
+        theta, phi = self.map_clements_bs(I)
+        phases = I.output_phases
+        models = {}
+        models['wvgd'] = ideal.ideal_waveguide
+        for i in range(dim):
+            phase = phases[i]
+            models[f"phaser_o{i}"] = lambda phase=phase: ideal.ideal_phaseshifter(phase)
+            for j in range(dim):
+                if (i,j) in phi.keys():
+                    phi_=phi[(i,j)]
+                    theta_ = theta[(i,j)]
+                    models[f"bs_{i}_{j}"] = lambda phi_=phi_, theta_ = theta_: ideal.ideal_clements_tbu_model(theta_, phi_)
+        return models
+
+    def map_clements_bs(self,I):
+        theta = {}
+        phi = {}
+        dim = self.dimension
+        mode_tracker = np.zeros(dim, dtype=int)
+
+        for BS in I.BS_list:
+            m1 = BS.mode1 - 1 
+            m2 = BS.mode2 - 1
+
+            # Physical column in Clements mesh
+            j = max(mode_tracker[m1], mode_tracker[m2])
+
+            # Physical row = upper mode
+            i = m1
+
+            theta[(i, j)] = BS.theta
+            phi[(i, j)] = BS.phi
+
+            # Both modes have now advanced one column
+            mode_tracker[m1] = j + 1
+            mode_tracker[m2] = j + 1
+
+        return theta, phi