Complete Silicon Microring Implementation

A tool-by-tool recipe using only free/academic licenses to achieve Q ≈ 1950, ER ≥ 20 dB, FSR ≈ 100 GHz at λ = 1550 nm

Target Specifications

Quality Factor
Q ≈ 1950
Extinction Ratio
ER ≥ 20 dB
Free Spectral Range
FSR ≈ 100 GHz
Center Wavelength
λ = 1550 nm

0 Quick Design Math – Pick the Ring Radius First

For a single-mode Si core (450 × 220 nm) the group index ng ≈ 4.2.

$$\text{FSR}_{\text{freq}} = \frac{c}{2\pi n_g R} \quad \Rightarrow \quad R = \frac{c}{2\pi n_g \text{FSR}}$$

$$R = \frac{3.0 \times 10^8}{2\pi (4.2)(100 \times 10^9)} \approx 114 \text{ μm}$$

Use R ≈ 115 µm; a 200 nm bus–ring gap gives critical coupling → ER ≥ 20 dB with round-trip loss ≤ 2 dB. (You can verify the exact gap with the sweep in Step 3.)

1 Layout Generation with gdsfactory

Python 
import gdsfactory as gf
import gplugins.tidy3d as gt

Si = gf.get_layer("WG")          # 220-nm Si device layer
WG_W = 0.45                      # µm

ring = gf.components.ring_single(
    radius=115,
    gap=0.20,                    # start value; will sweep later
    width=WG_W,
    layer=Si
)
ring.show()                      # opens KLayout if installed
ring.write_gds("ring115.gds")

2 Eigen-mode Sanity Check (Meep / MPB)

Before a 3-D FDTD, confirm that the straight waveguide is single-mode:

Python 
from meep import mpb

# Simple slab mode solver. Replace with your MPB wrapper of choice.
# Verify n_eff ≈ 2.45 for TE mode at 1550 nm

3 3-D FDTD Sweep (Tidy3D Cloud, Free Credits)

Python 
import tidy3d as td
import numpy as np
from gplugins.tidy3d.bend import simulate_ring

radii = [114, 115, 116]              # µm
gaps  = np.linspace(0.15, 0.25, 5)  # µm

for R in radii:
    for g in gaps:
        task = simulate_ring(radius=R, gap=g, wavelength=1.55, res=30)
        sim_data = task.run(path=".", verbose=False)
        sim_data.to_file(f"R{R}_g{g}.hdf5")

Tidy3D Free Credits

Each job costs only a handful of FlexCredits. Students get 10 credits/month free at flexcompute.com

Analyze one spectrum:

Python 
import numpy as np, h5py, matplotlib.pyplot as plt, scipy.optimize as opt

λ, S = load_sparam("R115_g0.20.hdf5")           # your helper function
# Fit a Lorentzian to get Q and ER
(f0, Q, ER_dB) = fit_lorentzian(λ, S)           # returns centre freq etc.

4 Create a Compact Model for Circuit Sims

Python 
import gplugins.sax as gsax           # uses SAX/Caphe under the hood

s = gsax.load_sparameters("R115_g0.20.hdf5")
ring_compact = gsax.model_from_sparameters(s)
# save to YAML so any Caphe‐compatible solver can read it
ring_compact.to_file("ring115.yaml")

You can now drop this ring115.yaml into a larger PIC (e.g., a four-channel WDM mux) and obtain S-matrix or time-domain eye diagrams in Caphe / simphony.

5 Verification at the PIC Level

Python 
import caphe

# Tiny WDM tester: laser → ring → photodiode
net = caphe.Net()
# (Instantiate laser, waveguides and photodiode; connect YAML ring block.)
results = net.solve_sparameters()
# Plot pass-band ripple, out-of-band rejection, group delay …

Confirm ΔλFSR ≈ 0.80 nm (~100 GHz) between successive drops and verify < ±0.05 dB ripple over the 3-dB bandwidth.

6 Delivery Package

Layout File

ring115.gds

Final mask cell ready for fabrication

FDTD Results

R115_g0.20.hdf5

Raw FDTD fields & S-parameters

Compact Model

ring115.yaml

Circuit-level behavioral model

Report

report.pdf

One-pager with layout, field snapshots, Lorentzian fit, spec table

Optional Enhancement

Add a Caphe project file showing a four-channel WDM demo that achieves < –25 dB crosstalk.

7 What to Tweak Next

Goal Change
Higher Q (same FSR) Increase radius slightly & taper the coupling region to reduce scattering
Thermal tuning Draw a TiN heater above the ring; simulate ΔN/ΔT with Lumerical HEAT or COMSOL
Footprint reduction Move to SiN 400 × 300 nm – lower ng → same FSR with R ≈ 75 µm
8-channel DWDM Cascade 8 identical rings with λ-offset radii (ΔR ≈ 0.9 µm per 100 GHz shift)

🎉 Success!

You now have a reproducible, fabrication-ready silicon microring WDM filter that hits the target Q, ER, and FSR — and you did it entirely with open-source Python plus free cloud FDTD resources. Happy simulating!

Appendix: Helper Functions

Python 
def fit_lorentzian(wavelength, transmission):
    """Extract Q-factor and extinction ratio from transmission spectrum"""
    from scipy.signal import find_peaks
    from scipy.optimize import curve_fit
    
    # Find resonance dips
    peaks, properties = find_peaks(-transmission, height=0.1)
    
    if len(peaks) == 0:
        raise ValueError("No resonances found in spectrum")
    
    # Select strongest resonance
    peak_idx = peaks[np.argmax(properties['peak_heights'])]
    
    # Define Lorentzian function
    def lorentzian(x, x0, gamma, A, offset):
        return offset - A * gamma**2 / ((x - x0)**2 + gamma**2)
    
    # Fit region around peak
    fit_range = 50  # indices
    start = max(0, peak_idx - fit_range)
    end = min(len(wavelength), peak_idx + fit_range)
    
    x_fit = wavelength[start:end]
    y_fit = transmission[start:end]
    
    # Initial guess
    x0_guess = wavelength[peak_idx]
    gamma_guess = 0.0004  # ~0.8nm FWHM
    A_guess = 1 - np.min(y_fit)
    offset_guess = np.max(y_fit)
    
    # Perform fit
    popt, _ = curve_fit(lorentzian, x_fit, y_fit, 
                       p0=[x0_guess, gamma_guess, A_guess, offset_guess])
    
    # Extract parameters
    center_wavelength = popt[0]
    fwhm = 2 * popt[1]
    Q = center_wavelength / fwhm
    ER_dB = -10 * np.log10(np.min(y_fit) / np.max(y_fit))
    
    return center_wavelength, Q, ER_dB