init

.gitignore

@@ -0,0 +1,8 @@
+
+/tests/__pycache__
+/my_bpm.egg-info
+/bpm/__pycache__
+*.png
+/gds_designs/gds_env
+gds_designs/.DS_Store
+.DS_Store

LICENSE

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

README.md

@@ -1,13 +1,82 @@
----
-title: BPM
-emoji: 📈
-colorFrom: green
-colorTo: pink
-sdk: gradio
-sdk_version: 5.28.0
-app_file: app.py
-pinned: false
-short_description: beam go brrrr
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# BPM
+Beam Propagation Method
+
+**BPM** is a Python library for simulating beam propagation in integrated photonics using the Beam Propagation Method (BPM). The package provides functions to generate refractive index distributions for various structures (e.g., lenses, waveguides, and MMI splitters), a mode solver for slab waveguides, and BPM propagation routines with support for Perfectly Matched Layers (PML) for absorbing boundary conditions.
+
+Currently it is 2D only, and use analytic solutions to launch slab modes. Propagation direction is upward and is called z. Transverse direction is x.
+
+## Features
+
+- Generate refractive index distributions:
+  - Spherical lens
+  - S-bend waveguide
+  - MMI-based splitter
+- Solve for guided slab waveguide modes (even/odd modes)
+- BPM propagation using a Runge-Kutta integrator
+- PML boundary absorption
+- [] Import from GDSII
+
+## Installation
+
+Clone the repository and install using pip:
+
+```bash
+git clone https://github.com/jwt625/bpm.git
+cd bpm
+pip install -e .
+```
+
+
+## Examples
+
+Slab mode solver and launcher:
+
+![image](https://github.com/user-attachments/assets/5aad97f5-7521-431d-8578-9c7655831798)
+
+
+Refractive index distribution of an MMI:
+
+![image](https://github.com/user-attachments/assets/e15c0aac-7a6e-419b-9484-62c910e5ca1e)
+
+
+Simulated example MMI:
+
+![image](https://github.com/user-attachments/assets/d3ee4359-02d7-42cb-b568-d2f0eb55f7a0)
+
+
+Simulated example S bend. The waveguide is multimode:
+
+![image](https://github.com/user-attachments/assets/fdf6e0ba-5684-4312-8bb1-c2ab070e5de5)
+
+
+
+
+## References
+
+
+Optical tomographic reconstruction based on multi-slice wave propagation method
+- https://doi.org/10.1364/OE.25.022595
+
+Light propagation through microlenses: a new simulation method
+- https://doi.org/10.1364/AO.32.004984
+
+
+Light propagation in graded-index optical fibers
+- https://doi.org/10.1364/AO.17.003990
+- this one is a classic
+
+
+Numerical Simulation of Optical Wave Propagation with Examples in MATLAB
+- https://spie.org/publications/book/866274
+
+Photonic Devices for Telecommunications
+- https://link.springer.com/book/10.1007/978-3-642-59889-0
+- chapter 2
+
+### Papers cited in chapter 2.2.1 of the book:
+
+- Chung1990: An assessment of finite difference beam propagation method
+	- https://ieeexplore.ieee.org/abstract/document/59679
+- Vassallo1992: Improvement of finite difference methods for step-index optical waveguides
+	- https://digital-library.theiet.org/doi/abs/10.1049/ip-j.1992.0024
+

app.py

@@ -0,0 +1,85 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import tempfile
+
+import gradio as gr
+
+from bpm.refractive_index import generate_waveguide_n_r2
+from bpm.mode_solver import slab_mode_source
+from bpm.core import run_bpm
+from bpm.pml import generate_sigma_x
+
+def run_waveguide(w, l, L, n_WG, wavelength, ind_m):
+    # Simulation setup
+    domain_size = 50.0
+    z_total = 500.0
+    Nx, Nz = 256, 2000
+    x = np.linspace(-domain_size/2, domain_size/2, Nx)
+    z = np.linspace(0, z_total, Nz)
+    n0 = 1.0
+
+    # Refractive index map
+    n_r2 = generate_waveguide_n_r2(x, z, l, L, w, n_WG, n0)
+
+    # Mode source
+    E0 = slab_mode_source(x, w, n_WG, n0, wavelength, ind_m, x0=0)
+    E = np.zeros((Nx, Nz), dtype=np.complex128)
+    E[:, 0] = E0
+
+    # PML and BPM propagation
+    dx = domain_size / Nx
+    dz = z[1] - z[0]
+    sigma_x = generate_sigma_x(x, dx, wavelength, domain_size)
+    E_out = run_bpm(E, n_r2, x, z, dx, dz, n0, sigma_x, wavelength)
+
+    # Plotting
+    fig, ax = plt.subplots(figsize=(8, 6))
+    im = ax.imshow(
+        np.abs(E_out)**2,
+        extent=[x[0], x[-1], z[0], z[-1]],
+        origin='lower',
+        aspect='auto',
+        cmap='inferno'
+    )
+    ax.set_xlabel("x (µm)")
+    ax.set_ylabel("z (µm)")
+    ax.set_title("Waveguide BPM Propagation")
+    fig.colorbar(im, ax=ax, label="Intensity")
+
+    # Save data for download
+    tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".npz")
+    np.savez(tmp_file.name, E_out=E_out, x=x, z=z)
+    tmp_file.close()
+
+    return fig, tmp_file.name
+
+# Build Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("## Waveguide BPM Simulation")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            w_slider = gr.Slider(0.1, 5.0, value=1.0, step=0.1, label="Waveguide width w (µm)")
+            l_slider = gr.Slider(0.0, 10.0, value=5.0, step=0.1, label="Lateral offset l (µm)")
+            L_slider = gr.Slider(50.0, 500.0, value=200.0, step=10.0, label="S-bend length L (µm)")
+            n_WG_slider = gr.Slider(1.0, 2.0, value=1.1, step=0.01, label="Core refractive index n_WG")
+            wavelength_slider = gr.Slider(0.4, 1.6, value=0.532, step=0.01, label="Wavelength λ (µm)")
+            ind_m_slider = gr.Slider(0, 4, value=0, step=1, label="Mode index ind_m")
+
+            run_button = gr.Button("Run BPM")
+            download_button = gr.DownloadButton(label="Download data")
+
+        with gr.Column(scale=2):
+            plot_output = gr.Plot()
+
+    inputs = [w_slider, l_slider, L_slider, n_WG_slider, wavelength_slider, ind_m_slider]
+
+    # Connect run button
+    run_button.click(fn=run_waveguide, inputs=inputs, outputs=[plot_output, download_button])
+
+    # Auto-update on parameter change
+    for inp in inputs:
+        inp.change(fn=run_waveguide, inputs=inputs, outputs=[plot_output, download_button])
+
+demo.launch()
+

bpm/__init__.py

@@ -0,0 +1,8 @@
+"""
+my_bpm: A beam propagation method (BPM) simulation library for integrated photonics.
+"""
+
+from .core import run_bpm, compute_dE_dz
+from .refractive_index import generate_lens_n_r2, generate_waveguide_n_r2, generate_MMI_n_r2
+from .mode_solver import slab_mode_source
+from .pml import generate_sigma_x

bpm/core.py

@@ -0,0 +1,46 @@
+import numpy as np
+
+# Global factors; these might be computed more dynamically in a full implementation.
+laplacian_factor = None
+index_factor = None
+
+def compute_dE_dz(E_slice, n_r2_slice, dx, n0, sigma_x, k0):
+    """
+    Compute the derivative dE/dz using the BPM equation:
+    
+      ∂E/∂z = (i/(2 k0 n0)) (∂^2 E/∂x^2) + i (k0/(2 n0)) [n_r^2 - n0^2] E - sigma(x) E
+    """
+    # Finite-difference Laplacian in x
+    laplacian_E = (np.roll(E_slice, 1, axis=0) - 2 * E_slice + np.roll(E_slice, -1, axis=0)) / dx**2
+    laplacian_term = (1j / (2 * k0 * n0)) * laplacian_E
+    index_term = 1j * (k0 / (2 * n0)) * (n_r2_slice - n0**2) * E_slice
+    damping_term = - sigma_x * E_slice
+    return laplacian_term + index_term + damping_term
+
+def run_bpm(E, n_r2, x, z, dx, dz, n0, sigma_x, wavelength):
+    """
+    Run the BPM propagation using an RK4 integrator.
+    
+    Parameters:
+      E: initial field (2D array, shape (len(x), len(z)); only E[:,0] is used)
+      n_r2: refractive index squared distribution (2D array, shape (len(x), len(z)))
+      x, z: transverse and propagation coordinates
+      dx, dz: grid spacings in x and z
+      n0: background refractive index
+      sigma_x: 1D array for PML damping in x
+      wavelength: wavelength in um
+    
+    Returns:
+      E: propagated field (2D array)
+    """
+    k0 = 2 * np.pi / wavelength
+    Nz = len(z)
+    for zi in range(1, Nz):
+        E_prev = E[:, zi-1]
+        n_r2_slice = n_r2[:, zi-1]
+        k1 = dz * compute_dE_dz(E_prev, n_r2_slice, dx, n0, sigma_x, k0)
+        k2 = dz * compute_dE_dz(E_prev + k1/2, n_r2_slice, dx, n0, sigma_x, k0)
+        k3 = dz * compute_dE_dz(E_prev + k2/2, n_r2_slice, dx, n0, sigma_x, k0)
+        k4 = dz * compute_dE_dz(E_prev + k3, n_r2_slice, dx, n0, sigma_x, k0)
+        E[:, zi] = E_prev + (k1 + 2*k2 + 2*k3 + k4) / 6
+    return E

bpm/mode_solver.py

@@ -0,0 +1,132 @@
+import numpy as np
+import warnings
+
+def slab_mode_source(x, w, n_WG, n0, wavelength, ind_m=0, x0=0):
+    """
+    Returns the normalized TE mode profile for a symmetric slab waveguide with a lateral shift x0.
+    """
+    k0 = 2 * np.pi / wavelength
+
+    def f_even(beta):
+        if beta < n0*k0 or beta > n_WG*k0:
+            return None
+        inside = n_WG**2 * k0**2 - beta**2
+        outside = beta**2 - n0**2 * k0**2
+        if inside <= 0 or outside <= 0:
+            return None
+        kx = np.sqrt(inside)
+        kappa = np.sqrt(outside)
+        return kx * np.tan(kx * w / 2) - kappa
+
+    def f_odd(beta):
+        if beta < n0*k0 or beta > n_WG*k0:
+            return None
+        inside = n_WG**2 * k0**2 - beta**2
+        outside = beta**2 - n0**2 * k0**2
+        if inside <= 0 or outside <= 0:
+            return None
+        kx = np.sqrt(inside)
+        kappa = np.sqrt(outside)
+        sin_term = np.sin(kx * w / 2)
+        if abs(sin_term) < 1e-12:
+            return None
+        return - kx * (np.cos(kx * w / 2) / sin_term) - kappa
+
+    def valid_even(beta):
+        inside = n_WG**2 * k0**2 - beta**2
+        if inside <= 0:
+            return False
+        kx = np.sqrt(inside)
+        theta = kx * w / 2
+        m = int(np.floor(2 * theta / np.pi))
+        if m % 2 == 0:
+            if m == 0 and theta > (np.pi/2 - 0.1):
+                return False
+            return True
+        return False
+
+    def valid_odd(beta):
+        inside = n_WG**2 * k0**2 - beta**2
+        if inside <= 0:
+            return False
+        kx = np.sqrt(inside)
+        theta = kx * w / 2
+        m = int(np.floor(2 * theta / np.pi))
+        return (m % 2 == 1)
+
+    N = 2000
+    beta_scan = np.linspace(n0*k0, n_WG*k0, N)
+    even_intervals = []
+    odd_intervals = []
+    f_even_vals = [f_even(b) for b in beta_scan]
+    f_odd_vals = [f_odd(b) for b in beta_scan]
+    for i in range(N-1):
+        if (f_even_vals[i] is not None) and (f_even_vals[i+1] is not None):
+            if f_even_vals[i] * f_even_vals[i+1] < 0:
+                even_intervals.append((beta_scan[i], beta_scan[i+1]))
+        if (f_odd_vals[i] is not None) and (f_odd_vals[i+1] is not None):
+            if f_odd_vals[i] * f_odd_vals[i+1] < 0:
+                odd_intervals.append((beta_scan[i], beta_scan[i+1]))
+                
+    def refine_root(f, b_left, b_right):
+        for _ in range(50):
+            b_mid = 0.5*(b_left+b_right)
+            val_mid = f(b_mid)
+            if val_mid is None:
+                b_right = b_mid
+                continue
+            if abs(val_mid) < 1e-9:
+                return b_mid
+            val_left = f(b_left)
+            if val_left is None or val_left*val_mid > 0:
+                b_left = b_mid
+            else:
+                b_right = b_mid
+        return b_mid
+
+    even_roots = []
+    for (b_left, b_right) in even_intervals:
+        root = refine_root(f_even, b_left, b_right)
+        if valid_even(root):
+            even_roots.append(root)
+    odd_roots = []
+    for (b_left, b_right) in odd_intervals:
+        root = refine_root(f_odd, b_left, b_right)
+        if valid_odd(root):
+            odd_roots.append(root)
+
+    modes = [("even", r) for r in even_roots] + [("odd", r) for r in odd_roots]
+    modes_sorted = sorted(modes, key=lambda tup: tup[1], reverse=True)
+    if len(modes_sorted) == 0:
+        raise ValueError("No guided slab modes found in [n0*k0, n_WG*k0].")
+    if ind_m >= len(modes_sorted):
+        warnings.warn(
+            f"Requested mode index {ind_m} >= found modes ({len(modes_sorted)}). Using highest mode index {len(modes_sorted)-1}.",
+            UserWarning
+        )
+        ind_m = len(modes_sorted) - 1
+
+    parity, beta_chosen = modes_sorted[ind_m]
+    inside = n_WG**2 * k0**2 - beta_chosen**2
+    outside = beta_chosen**2 - n0**2 * k0**2
+    kx = np.sqrt(inside)
+    kappa = np.sqrt(outside)
+
+    E = np.zeros_like(x, dtype=np.complex128)
+    if parity == "even":
+        for i, xi in enumerate(x):
+            xp = xi - x0
+            if abs(xp) <= w/2:
+                E[i] = np.cos(kx * xp)
+            else:
+                E[i] = np.cos(kx * (w/2)) * np.exp(-kappa * (abs(xp)-w/2))
+    else:
+        for i, xi in enumerate(x):
+            xp = xi - x0
+            if abs(xp) <= w/2:
+                E[i] = np.sin(kx * xp)
+            else:
+                E[i] = np.sign(xp) * np.sin(kx * (w/2)) * np.exp(-kappa * (abs(xp)-w/2))
+    norm = np.sqrt(np.trapz(np.abs(E)**2, x))
+    E /= norm
+    return E

bpm/pml.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+def generate_sigma_x(x, dx, wavelength, domain_size, sigma_max=0.5, pml_factor=5):
+    """
+    Generate the 1D PML damping profile sigma(x) for the x-dimension.
+    
+    Parameters:
+      x : 1D numpy array of x coordinates.
+      dx : grid spacing in x.
+      wavelength : wavelength in microns.
+      domain_size : total transverse domain size (in microns).
+      sigma_max : maximum damping value (default 0.5).
+      pml_factor : number of wavelengths to use for the PML thickness.
+    
+    Returns:
+      sigma_x : 1D numpy array of damping values.
+    """
+    pml_thickness = int(pml_factor * wavelength / dx)
+    pml_width = pml_thickness * dx
+    x_edge = domain_size / 2 - pml_width
+    sigma_x = np.where(np.abs(x) > x_edge,
+                       sigma_max * ((np.abs(x) - x_edge) / pml_width) ** 2,
+                       0)
+    return sigma_x

bpm/refractive_index.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+def generate_lens_n_r2(x, z, lens_diameter, lens_thickness, R1, R2, n_lens, n0, lens_center_z, x_lens):
+    """
+    Generate the squared refractive index distribution for a spherical lens.
+    """
+    Nx = len(x)
+    Nz = len(z)
+    n_r2 = np.full((Nx, Nz), n0**2, dtype=np.float64)
+    z1 = lens_center_z - lens_thickness / 2.0
+    z2 = lens_center_z + lens_thickness / 2.0
+    z_first = z1 + (R1 - np.sqrt(np.maximum(R1**2 - (x - x_lens)**2, 0)))
+    z_second = z2 - (R2 - np.sqrt(np.maximum(R2**2 - (x - x_lens)**2, 0)))
+    for ix in range(Nx):
+        if abs(x[ix] - x_lens) > lens_diameter / 2:
+            continue
+        in_lens = (z >= z_first[ix]) & (z <= z_second[ix])
+        n_r2[ix, in_lens] = n_lens**2
+    return n_r2
+
+def generate_waveguide_n_r2(x, z, l, L, w, n_WG, n0):
+    """
+    Generate the squared refractive index distribution for an S-bend waveguide.
+    """
+    Nx = len(x)
+    Nz = len(z)
+    n_r2 = np.full((Nx, Nz), n0**2, dtype=np.float64)
+    x_c = (l / L) * z - (l / (2 * np.pi)) * np.sin((2 * np.pi / L) * z)
+    x_c = np.clip(x_c, 0, l)
+    for iz in range(Nz):
+        lower_edge = x_c[iz] - w / 2.0
+        upper_edge = x_c[iz] + w / 2.0
+        in_wg = (x >= lower_edge) & (x <= upper_edge)
+        n_r2[in_wg, iz] = n_WG**2
+    return n_r2
+
+def generate_MMI_n_r2(x, z, z_MMI_start, L_MMI, w_MMI, w_wg, d, n_WG, n_MMI, n0):
+    """
+    Generate the squared refractive index distribution for an MMI-based splitter.
+    """
+    Nx = len(x)
+    Nz = len(z)
+    X, Z = np.meshgrid(x, z, indexing="ij")
+    n_r2 = np.full((Nx, Nz), n0**2, dtype=np.float64)
+    z_MMI_end = z_MMI_start + L_MMI
+    mask_input = (Z < z_MMI_start) & (((np.abs(X + d/2) <= w_wg/2) | (np.abs(X - d/2) <= w_wg/2)))
+    mask_MMI = (Z >= z_MMI_start) & (Z <= z_MMI_end) & (np.abs(X) <= w_MMI/2)
+    mask_output = (Z > z_MMI_end) & (((np.abs(X + d/2) <= w_wg/2) | (np.abs(X - d/2) <= w_wg/2)))
+    n_r2[mask_input] = n_WG**2
+    n_r2[mask_output] = n_WG**2
+    n_r2[mask_MMI] = n_MMI**2
+    return n_r2

examples/example_mmi.py

@@ -0,0 +1,82 @@
+#%%
+import numpy as np
+import plotly.graph_objects as go
+from bpm.refractive_index import generate_MMI_n_r2
+from bpm.mode_solver import slab_mode_source
+from bpm.core import run_bpm
+from bpm.pml import generate_sigma_x
+
+# Simulation parameters
+domain_size = 50.0   # um (transverse)
+z_total = 250.0       # um (propagation length)
+Nx = 256
+Nz = 1024
+x = np.linspace(-domain_size/2, domain_size/2, Nx)
+z = np.linspace(0, z_total, Nz)
+
+# MMI structure parameters
+z_MMI_start = 50.0    
+L_MMI = 130.0          # MMI region length = 40 um
+w_MMI = 8.0          # MMI region width = 40 um
+w_wg = 2.0            
+d = 4.0              
+
+n0 = 1.0      
+n_WG = 1.1    
+n_MMI = 1.1   
+
+n_r2 = generate_MMI_n_r2(x, z, z_MMI_start, L_MMI, w_MMI, w_wg, d, n_WG, n_MMI, n0)
+
+# Launch a slab mode from the left input waveguide
+# Shift the launched mode so that its center aligns with x = -d/2.
+E0 = slab_mode_source(x, w=w_wg, n_WG=n_WG, n0=n0, wavelength=0.532, ind_m=0, x0=-d/2)
+
+# Create initial field
+E = np.zeros((Nx, Nz), dtype=np.complex128)
+E[:, 0] = E0
+
+# Generate PML profile in x
+dx = domain_size / Nx
+sigma_x = generate_sigma_x(x, dx, 0.532, domain_size, sigma_max=0.5, pml_factor=5)
+
+# Run BPM propagation
+E_out = run_bpm(E, n_r2, x, z, dx, z[1]-z[0], n0, sigma_x, 0.532)
+
+# Plot final intensity using Plotly
+fig1 = go.Figure(data=go.Heatmap(
+    z=(np.abs(E_out)**2).T,
+    x=x,
+    y=z,
+    colorscale='inferno',
+    colorbar=dict(title='Intensity')
+))
+
+fig1.update_layout(
+    title='MMI Splitter BPM Propagation',
+    xaxis_title='x (um)',
+    yaxis_title='z (um)',
+    width=800,
+    height=600
+)
+
+fig1.show()
+
+# Plot refractive index profile using Plotly
+fig2 = go.Figure(data=go.Heatmap(
+    z=np.sqrt(n_r2).T,
+    x=x,
+    y=z,
+    colorscale='inferno',
+    colorbar=dict(title='Refractive Index')
+))
+
+fig2.update_layout(
+    title='Refractive Index Profile',
+    xaxis_title='x (um)',
+    yaxis_title='z (um)',
+    width=800,
+    height=600
+)
+
+fig2.show()
+# %%

examples/example_waveguide.py

@@ -0,0 +1,46 @@
+#%%
+import numpy as np
+import matplotlib.pyplot as plt
+from bpm.refractive_index import generate_waveguide_n_r2
+from bpm.mode_solver import slab_mode_source
+from bpm.core import run_bpm
+from bpm.pml import generate_sigma_x
+
+# Simulation parameters
+domain_size = 50.0   # um
+z_total = 500.0      # um
+Nx = 256
+Nz = 2000
+x = np.linspace(-domain_size/2, domain_size/2, Nx)
+z = np.linspace(0, z_total, Nz)
+
+# Waveguide parameters
+l = 5.0   # lateral offset
+L = 200.0  # length of S-bend
+w = 1.0    # waveguide width
+n0 = 1.0
+n_WG = 1.1
+
+n_r2 = generate_waveguide_n_r2(x, z, l, L, w, n_WG, n0)
+
+# Launch a mode; here we use a mode source with no shift (x0 = 0)
+E0 = slab_mode_source(x, w, n_WG, n0, wavelength=0.532, ind_m=0, x0=0)
+E = np.zeros((Nx, Nz), dtype=np.complex128)
+E[:, 0] = E0
+
+dx = domain_size / Nx
+sigma_x = generate_sigma_x(x, dx, 0.532, domain_size, sigma_max=0.5, pml_factor=5)
+
+E_out = run_bpm(E, n_r2, x, z, dx, z[1]-z[0], n0, sigma_x, 0.532)
+
+plt.figure(figsize=(8,6))
+plt.imshow((np.abs(E_out)**2).T, extent=[x[0], x[-1], z[0], z[-1]],
+           origin='lower', aspect='auto', cmap='inferno',
+           vmin=0, vmax=0.6)
+plt.xlabel("x (um)")
+plt.ylabel("z (um)")
+plt.title("Waveguide BPM Propagation")
+plt.colorbar(label="Intensity")
+plt.show()
+
+# %%

requirements.txt

@@ -0,0 +1,4 @@
+numpy
+matplotlib
+pytest
+plotly

setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='my_bpm',
+    version='0.1.0',
+    description='A BPM simulation library for integrated photonics',
+    author='Your Name',
+    author_email='your.email@example.com',
+    url='https://github.com/jwt625/bpm',  # adjust as needed
+    packages=find_packages(),
+    install_requires=[
+        'numpy',
+        'matplotlib',
+    ],
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Science/Research',
+        'Programming Language :: Python :: 3',
+    ],
+)

tests/__init__.py

@@ -0,0 +1 @@
+# This file can be empty; it just makes 'tests' a package.

tests/test_core.py

@@ -0,0 +1,46 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from bpm.core import run_bpm, compute_dE_dz
+from bpm.pml import generate_sigma_x
+
+def test_core_propagation_plot():
+    # Simulation parameters
+    domain_size = 50  # um
+    wavelength = 0.532
+    n0 = 1.0
+    Nx = 256
+    Nz = 100
+    dx = domain_size / Nx
+    dz = 2 * dx
+    x = np.linspace(-domain_size/2, domain_size/2, Nx)
+    z = np.linspace(0, dz * Nz, Nz)
+    
+    # Create an initial Gaussian field
+    E_init = np.exp(-x**2 / 2)
+    # Make the field 2D (each column is the same as initial condition)
+    E = np.tile(E_init, (Nz, 1)).T  # shape (Nx, Nz)
+    
+    # Use a homogeneous refractive index distribution (n0 everywhere)
+    n_r2 = np.full((Nx, Nz), n0**2, dtype=np.float64)
+    
+    # Generate the PML damping profile in x
+    sigma_x = generate_sigma_x(x, dx, wavelength, domain_size, sigma_max=0.5, pml_factor=5)
+    
+    # Run BPM propagation
+    E_out = run_bpm(E.copy(), n_r2, x, z, dx, dz, n0, sigma_x, wavelength)
+    
+    # Plot the final intensity distribution
+    plt.figure(figsize=(8, 6))
+    plt.imshow(np.abs(E_out)**2, extent=[x[0], x[-1], z[0], z[-1]],
+               origin='lower', aspect='auto', cmap='inferno')
+    plt.xlabel("x (um)")
+    plt.ylabel("z (um)")
+    plt.title("Final Field Intensity from BPM Propagation")
+    plt.colorbar(label="Intensity")
+    plt.tight_layout()
+    # Save the figure as a PNG file
+    plt.savefig("core_test_field.png")
+    plt.close()
+
+if __name__ == "__main__":
+    test_core_propagation_plot()

tests/test_mode_solver.py

@@ -0,0 +1,52 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.tools as tls
+import plotly.io as pio
+import warnings
+from bpm.mode_solver import slab_mode_source
+
+def test_slab_mode_plot():
+    # Define transverse coordinate and waveguide parameters
+    x = np.linspace(-10, 10, 1000)  # Adjust range/resolution as needed
+    w = 5.0         # waveguide width in microns
+    n_WG = 1.1      # core refractive index
+    n0 = 1.0        # cladding refractive index
+    wavelength = 0.532  # in microns
+
+    # Try to compute up to 5 modes
+    num_modes = 5
+    mode_fields = []
+    mode_indices = []
+
+    for m in range(num_modes):
+        try:
+            E_mode = slab_mode_source(x, w, n_WG, n0, wavelength, ind_m=m)
+            mode_fields.append(E_mode)
+            mode_indices.append(m)
+        except Exception as err:
+            warnings.warn(f"Mode {m} not found: {err}. Stopping mode search.")
+            break
+
+    # Plot the real part of each mode with an offset for clarity
+    plt.rcParams.update({'font.size': 14})
+    fig, ax = plt.subplots(figsize=(8, 6))
+    offset = 1.0  # Vertical offset between mode plots
+    for i, E_mode in enumerate(mode_fields):
+        ax.plot(x, np.real(E_mode) + i * offset, label=f"Mode {mode_indices[i]}")
+    ax.set_xlabel("x (µm)")
+    ax.set_ylabel("Field amplitude (Real part)")
+    ax.set_title("Slab Waveguide TE Modes")
+    ax.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    # Save the plot as a PNG file
+    plt.savefig("test_mode_solver.png")
+    # plt.show()
+
+    # Optionally convert the matplotlib figure to a Plotly figure for interactive viewing
+    # plotly_fig = tls.mpl_to_plotly(fig)
+    # plotly_fig.update_layout(legend=dict(font=dict(size=12)))
+    # pio.show(plotly_fig)
+
+if __name__ == "__main__":
+    test_slab_mode_plot()

tests/test_refractive_index.py

@@ -0,0 +1,43 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from bpm.refractive_index import generate_MMI_n_r2
+
+def test_refractive_index_distribution():
+    # Simulation parameters
+    domain_size = 50.0  # um, transverse extent
+    Nx = 256
+    Nz = 512
+    x = np.linspace(-domain_size / 2, domain_size / 2, Nx)
+    z = np.linspace(0, 200, Nz)
+    
+    # MMI structure parameters:
+    z_MMI_start = 50.0    # MMI region begins at z = 50 um
+    L_MMI = 130.0          # MMI region length = 40 um
+    w_MMI = 8.0          # MMI region width = 40 um
+    w_wg = 2.0            # input/output waveguide width = 4 um
+    d = 4.0              # center-to-center separation of waveguides = 12 um
+    
+    # Refractive indices:
+    n0 = 1.0      # background index
+    n_WG = 1.1    # waveguide index
+    n_MMI = 1.1   # MMI region index
+    
+    # Generate the refractive index distribution.
+    n_r2 = generate_MMI_n_r2(x, z, z_MMI_start, L_MMI, w_MMI, w_wg, d, n_WG, n_MMI, n0)
+    
+    # Plot the refractive index distribution (plotting sqrt(n_r2) to get n_r).
+    plt.figure(figsize=(8, 6))
+    plt.imshow(np.sqrt(n_r2).T, extent=[x[0], x[-1], z[0], z[-1]],
+               origin='lower', aspect='auto', cmap='viridis')
+    plt.xlabel("x (um)")
+    plt.ylabel("z (um)")
+    plt.title("MMI Splitter Refractive Index Distribution (n_r)")
+    plt.colorbar(label="n_r")
+    plt.tight_layout()
+    
+    # Save the plot as a PNG file
+    plt.savefig("refractive_index_test.png")
+    plt.close()
+
+if __name__ == "__main__":
+    test_refractive_index_distribution()