add MMI

app.py

@@ -1,39 +1,46 @@
 import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+
 import matplotlib.pyplot as plt
 import tempfile
 
 import gradio as gr
 
-from bpm.refractive_index import generate_waveguide_n_r2
+from bpm.refractive_index import (
+    generate_waveguide_n_r2,
+    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
 
-def run_waveguide(w, l, L, n_WG, wavelength, ind_m):
-    # Simulation setup
+def run_waveguide(w, l, L_bend, n_WG, wavelength, ind_m):
+    # --- Simulation setup (Waveguide S-bend) ---
     domain_size = 50.0
-    z_total = 500.0
-    Nx, Nz = 256, 2000
+    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)
+    n_r2 = generate_waveguide_n_r2(x, z, l, L_bend, w, n_WG, n0)
 
-    # Mode source
+    # Launch slab mode
     E0 = slab_mode_source(x, w, n_WG, n0, wavelength, ind_m, x0=0)
-    E = np.zeros((Nx, Nz), dtype=np.complex128)
+    E  = np.zeros((Nx, Nz), dtype=np.complex128)
     E[:, 0] = E0
 
-    # PML and BPM propagation
-    dx = domain_size / Nx
-    dz = z[1] - z[0]
+    # PML + BPM
+    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)
+    E_out   = run_bpm(E, n_r2, x, z, dx, dz, n0, sigma_x, wavelength)
 
-    # Plotting
-    fig, ax = plt.subplots(figsize=(8, 6))
+    # Plot
+    fig, ax = plt.subplots(figsize=(8,6))
     im = ax.imshow(
         np.abs(E_out)**2,
         extent=[x[0], x[-1], z[0], z[-1]],
@@ -41,45 +48,155 @@ def run_waveguide(w, l, L, n_WG, wavelength, ind_m):
         aspect='auto',
         cmap='inferno'
     )
+    ax.set_title("Waveguide S-bend BPM Propagation")
     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()
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".npz")
+    np.savez(tmp.name, E_out=E_out, x=x, z=z)
+    tmp.close()
+
+    return fig, tmp.name
+
+def run_mmi(z_start, L_MMI, w_MMI, w_wg, d, n_WG, wavelength, ind_m):
+    # --- Simulation setup (MMI Splitter) ---
+    domain_size = 50.0
+    z_total     = 250.0
+    Nx, Nz      = 256, 1024
+
+    x = np.linspace(-domain_size/2, domain_size/2, Nx)
+    z = np.linspace(0, z_total, Nz)
+    n0 = 1.0
 
-    return fig, tmp_file.name
+    # For simplicity, use the same core and MMI index
+    n_MMI = n_WG
+
+    # Refractive index map
+    n_r2 = generate_MMI_n_r2(
+        x, z,
+        z_MMI_start = z_start,
+        L_MMI        = L_MMI,
+        w_MMI        = w_MMI,
+        w_wg         = w_wg,
+        d            = d,
+        n_WG         = n_WG,
+        n_MMI        = n_MMI,
+        n0           = n0
+    )
+
+    # Launch slab mode in left waveguide
+    E0 = slab_mode_source(x, w_wg, n_WG, n0, wavelength, ind_m, x0=-d/2)
+    E  = np.zeros((Nx, Nz), dtype=np.complex128)
+    E[:,0] = E0
+
+    # PML + BPM
+    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)
+
+    # Plot
+    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_title("MMI Splitter BPM Propagation")
+    ax.set_xlabel("x (µm)")
+    ax.set_ylabel("z (µm)")
+    fig.colorbar(im, ax=ax, label="Intensity")
+
+    # Save data
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".npz")
+    np.savez(tmp.name, E_out=E_out, x=x, z=z)
+    tmp.close()
+
+    return fig, tmp.name
+
+def run_dispatcher(
+    sim_type,
+    # waveguide args
+    w, l, L_bend,
+    # mmi args
+    z_start, L_MMI, w_MMI, w_wg, d,
+    # common args
+    n_WG, wavelength, ind_m
+):
+    if sim_type == "Waveguide S-bend":
+        return run_waveguide(w, l, L_bend, n_WG, wavelength, ind_m)
+    else:
+        return run_mmi(z_start, L_MMI, w_MMI, w_wg, d, n_WG, wavelength, ind_m)
 
-# Build Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("## Waveguide BPM Simulation")
+    gr.Markdown("## BPM Simulation Dashboard")
+
+    # 1) Simulation selector
+    sim_type = gr.Radio(
+        choices=["Waveguide S-bend", "MMI Splitter"],
+        value="Waveguide S-bend",
+        label="Simulation Type"
+    )
 
     with gr.Row():
+        # 2) Waveguide parameters panel
+        with gr.Column(visible=True) as waveguide_panel:
+            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)")
+            Lb_slider    = gr.Slider(50.0, 500.0,value=200.0,step=10.0,label="S-bend length L (µm)")
+
+        # 3) MMI parameters panel
+        with gr.Column(visible=False) as mmi_panel:
+            z0_slider    = gr.Slider(0.0, 200.0, value=50.0, step=1.0, label="MMI start z₀ (µm)")
+            Lmmi_slider  = gr.Slider(10.0, 300.0,value=130.0,step=5.0, label="MMI length L (µm)")
+            wmmi_slider  = gr.Slider(2.0, 20.0, value=8.0,  step=0.5, label="MMI width w_MMI (µm)")
+            wwg_slider   = gr.Slider(0.5, 5.0,  value=2.0,  step=0.1, label="I/O waveguide width w_wg (µm)")
+            d_slider     = gr.Slider(1.0, 20.0, value=4.0,  step=0.5, label="Waveguide separation d (µm)")
+
+        # 4) Common parameters
         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")
+            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")
+            run_button       = gr.Button("Run BPM")
+            download_button  = gr.DownloadButton(label="Download data")
 
+        # 5) Plot output
         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])
+    # 6) Toggle panels on sim_type change
+    sim_type.change(
+        fn=lambda choice: (
+            gr.update(visible=(choice=="Waveguide S-bend")),
+            gr.update(visible=(choice=="MMI Splitter"))
+        ),
+        inputs=sim_type,
+        outputs=[waveguide_panel, mmi_panel]
+    )
 
-    # Auto-update on parameter change
-    for inp in inputs:
-        inp.change(fn=run_waveguide, inputs=inputs, outputs=[plot_output, download_button])
+    # 7) Wire up Run button + auto-update
+    all_inputs = [
+        sim_type,
+        w_slider, l_slider, Lb_slider,
+        z0_slider, Lmmi_slider, wmmi_slider, wwg_slider, d_slider,
+        n_WG_slider, wavelength_slider, ind_m_slider
+    ]
+    run_button.click(
+        fn=run_dispatcher,
+        inputs=all_inputs,
+        outputs=[plot_output, download_button]
+    )
+    for inp in all_inputs:
+        inp.change(
+            fn=run_dispatcher,
+            inputs=all_inputs,
+            outputs=[plot_output, download_button]
+        )
 
 demo.launch()
-