Broadband bi-level taper polarization rotator-splitter#

This notebook contains large simulations. Running the entire notebook will cost about 30 FlexCredits.

A polarization splitter-rotator (PSR) is a key component in silicon photonics that is used to manage the polarization state of light. It is a critical component in silicon photonic integrated circuits, enabling more complex and versatile photonic devices and systems. As the name suggests, the PSR has two main functions:

Splitting: It separates incoming light into its TE and TM components. This is useful because it allows each polarization to be processed separately, which can be important for certain applications.

Rotating: It can convert light from one polarization to another. For example, it can convert TE-polarized light to TM-polarized light, or vice versa. This is important because it allows the light to be correctly interfaced with other devices that might require a specific polarization.

In another case study, we have introduced a compact PSR, which has a small footprint but narrow bandwidth. In the present study, we delve into the exploration of a broadband PSR. This device employs a bi-level taper to transition the TM0 mode input light into the TE1 mode. Subsequently, a long adiabatic coupler transforms this TE1 mode into the TE0 mode. Conversely, the TE0 input light primarily passes through the PSR with minimal alterations. The broadband PSR demonstrates superior bandwidth and insertion loss compared to the compact design, marking a significant improvement. However, it’s worth noting that this enhanced performance comes with a trade-off in terms of size. The broadband PSR has a considerably larger footprint, with a length longer than 0.5 mm, which causes a difficult simulation in conventional numerical tools. For Tidy3D, even such a large 3D full-wave simulation is fast.

The design is based on Wesley D. Sacher, Tymon Barwicz, Benjamin J. F. Taylor, and Joyce K. S. Poon, "Polarization rotator-splitters in standard active silicon photonics platforms," Opt. Express 22, 3777-3786 (2014), DOI: 10.1364/OE.22.003777.

2f8b684ad27a404883d971281437df2e

[1]:
import numpy as np
import matplotlib.pyplot as plt
import gdstk

import tidy3d as td
import tidy3d.web as web
from tidy3d.plugins.mode import ModeSolver

Simulation Setup#

The simulation wavelength range is from 1500 nm to 1580 nm.

[2]:
lda0 = 1.54  # central wavelength
ldas = np.linspace(1.5, 1.58, 101)  # wavelength range of interest
freq0 = td.C_0 / lda0  # central frequency
freqs = td.C_0 / ldas  # frequency range of interest
fwidth = 0.4 * (np.max(freqs) - np.min(freqs))  # frequency width of the source

In this wavelength range, silicon and silicon oxide have minimal dispersion. Therefore, we use a constant refractive index for both.

[3]:
# define silicon and silicon dioxide media from material library
si = td.Medium(permittivity=3.47**2)
sio2 = td.Medium(permittivity=1.44**2)

Define geometric parameters. The parameters are indicated in the figure below. In addition, we add a side wall angle to mimic realistic fabrication and see if this will degrade the device performance.

87bd545c02994bf385f0ce198c1d91c5

[4]:
L_blt = 100  # length of the bi-level taper
L_ac = 300  # length of the adiabatic coupler
L_s = 5  # length of the straight waveguide between the bi-level taper and the adiabatic coupler
L_t = 30  # length of the top waveguide taper after the adiabatic coupler

w_1 = 0.45  # input waveguide width
w_2 = 0.55  # waveguide width at the center of the bi-level taper
w_pes = 1.55  # width of the widest part of the partially etched slab
w_3 = 0.85  # waveguide width at the output of the bi-level taper
w_4 = 0.2  # waveguide width at the beginning of the bottom waveguide
w_5 = 0.65  # top waveguide width at the end of the adiabatic coupler
w_6 = 0.5  # output waveguide width
gap = 0.2  # gap size of the adiabatic coupler

t_pes = 0.09  # thickness of the partially etched slab
t_si = 0.22  # thickness of the silicon layer

inf_eff = 1e5  # effective infinity

sidewall_angle = 10 * np.pi / 180  # side wall angle

Define the partially etched slab structure.

[5]:
# define the partially etched slab
vertices = [
    (0, w_1 / 2),
    (L_blt / 2, w_pes / 2),
    (L_blt, w_3 / 2),
    (L_blt, -w_3 / 2),
    (L_blt / 2, -w_pes / 2),
    (0, -w_1 / 2),
]

partially_etched_slab = td.Structure(
    geometry=td.PolySlab(
        vertices=vertices,
        axis=2,
        slab_bounds=(0, t_pes),
        sidewall_angle=sidewall_angle,
    ),
    medium=si,
)

Define the waveguide structures.

[6]:
# define the top waveguide
vertices = [
    (-inf_eff, w_1 / 2),
    (0, w_1 / 2),
    (L_blt / 2, w_2 / 2),
    (L_blt, w_3 / 2),
    (L_blt + L_s, w_3 / 2),
    (L_blt + L_s + L_ac, -w_3 / 2 + w_5),
    (L_blt + L_s + L_ac + L_t, -w_3 / 2 + w_5 / 2 + w_6 / 2),
    (L_blt + L_s + L_ac + L_t, -w_3 / 2 + w_5 / 2 - w_6 / 2),
    (L_blt + L_s + L_ac, -w_3 / 2),
    (L_blt, -w_3 / 2),
    (L_blt / 2, -w_2 / 2),
    (0, -w_1 / 2),
    (-inf_eff, -w_1 / 2),
]

top_waveguide = td.Structure(
    geometry=td.PolySlab(
        vertices=vertices,
        axis=2,
        slab_bounds=(0, t_si),
        sidewall_angle=sidewall_angle,
    ),
    medium=si,
)

# define the bottom waveguide after the bi-level taper
vertices = [
    (L_blt + L_s, -w_3 / 2 - gap),
    (L_blt + L_s + L_ac, -w_3 / 2 - gap),
    (L_blt + L_s + L_ac, -w_3 / 2 - gap - w_6),
    (L_blt + L_s, -w_3 / 2 - gap - w_4),
]

bottom_waveguide = td.Structure(
    geometry=td.PolySlab(
        vertices=vertices,
        axis=2,
        slab_bounds=(0, t_si),
        sidewall_angle=sidewall_angle,
    ),
    medium=si,
)

Define the waveguide bends after the adiabatic coupler using gdstk. For bending structures, using gdstk is easy and convenient.

[7]:
R = 450  # bend radius
theta = np.pi / 30  # s bend angle

cell = gdstk.Cell("bends")  # define a gds cell

# define the top waveguide bend
delta = 0.01  # small offset to ensure waveguide continuity
bend_1 = gdstk.FlexPath(
    (L_blt + L_s + L_ac - delta, -w_3 / 2 - gap - w_6 / 2), w_6, layer=1, datatype=0
)
bend_1.horizontal(L_blt + L_s + L_ac)
bend_1.arc(R, np.pi / 2, np.pi / 2 - theta)
bend_1.arc(R / 3, -np.pi / 2 - theta, -np.pi / 2)
bend_1.horizontal(inf_eff)
cell.add(bend_1)

# define the bottom waveguide bend
bend_2 = gdstk.FlexPath(
    (L_blt + L_s + L_ac + L_t - delta, -w_3 / 2 + w_5 / 2), w_6, layer=1, datatype=0
)
bend_2.horizontal(L_blt + L_s + L_ac + L_t)
bend_2.arc(R, -np.pi / 2, -np.pi / 2 + theta)
bend_2.arc(R / 3, np.pi / 2 + theta, np.pi / 2)
bend_2.horizontal(inf_eff)
cell.add(bend_2)

# define the waveguide bend tidy3d geometries
bends_geo = td.PolySlab.from_gds(
    cell,
    gds_layer=1,
    axis=2,
    slab_bounds=(0, t_si),
    sidewall_angle=sidewall_angle,
)

# define the waveguide bend tidy3d structures
bends = [td.Structure(geometry=bend_geo, medium=si) for bend_geo in bends_geo]

Define source, monitors, and simulation. Here we will define a ModeSource that launches the TE0 mode into the input waveguide. Two ModeMonitors are added to the top and bottom waveguides to monitor the transmission. A FieldMonitor is added in the \(xy\) plane to visualize the field distribution.

[8]:
run_time = 15e-12  # simulation run time

Lx = 510  # simulation domain size in x
Ly = 11  # simulation domain size in y
Lz = 9 * t_si  # simulation domain size in z

x0 = 250  # simulation domain center in x
y0 = -0.5  # simulation domain center in y
z0 = t_si / 2  # simulation domain center in z

# define a mode source that launches the TE0 mode
mode_spec = td.ModeSpec(num_modes=2, target_neff=3.47)
mode_source_te = td.ModeSource(
    center=(-lda0 / 2, 0, t_si / 2),
    size=(0, 4 * w_1, 6 * t_si),
    source_time=td.GaussianPulse(freq0=freq0, fwidth=fwidth),
    direction="+",
    mode_spec=mode_spec,
    mode_index=0,
)

# define a mode monitor at the top waveguide output
mode_monitor_top = td.ModeMonitor(
    center=(x0 + Lx / 2 - lda0, 3.2, t_si / 2),
    size=mode_source_te.size,
    freqs=freqs,
    mode_spec=mode_spec,
    name="mode_top",
)

# define a mode monitor at the bottom waveguide output
mode_monitor_bottom = td.ModeMonitor(
    center=(x0 + Lx / 2 - lda0, -4.2, t_si / 2),
    size=mode_source_te.size,
    freqs=freqs,
    mode_spec=mode_spec,
    name="mode_bottom",
)

# define a field monitor to visualize field intensity distribution in the xy plane
field_monitor = td.FieldMonitor(
    center=(0, 0, t_pes),
    size=(td.inf, td.inf, 0),
    freqs=[freq0],
    interval_space=(2, 2, 1),
    name="field",
)

# define simulation
sim_te = td.Simulation(
    center=(x0, y0, z0),
    size=(Lx, Ly, Lz),
    grid_spec=td.GridSpec.auto(min_steps_per_wvl=12, wavelength=lda0),
    structures=[partially_etched_slab, top_waveguide, bottom_waveguide] + bends,
    sources=[mode_source_te],
    monitors=[mode_monitor_top, mode_monitor_bottom, field_monitor],
    run_time=run_time,
    boundary_spec=td.BoundarySpec.all_sides(boundary=td.PML()),
    medium=sio2,
)

# visualize the simulation
ax = sim_te.plot(z=t_pes)
ax.set_aspect("auto")
../_images/notebooks_BilevelPSR_17_0.png

We can also visualize the cross sections at different \(x\) positions of the bi-level taper.

[9]:
fig, ax = plt.subplots(3, 1, figsize=(4, 7), tight_layout=True)

for i in range(3):
    sim_te.plot_eps(x=i * L_blt / 2, freq=freq0, ax=ax[i])
    ax[i].set_xlim(-1, 1)
    ax[i].set_ylim(-0.1, 0.3)
../_images/notebooks_BilevelPSR_19_0.png

Mode Analysis#

We can intuitively visualize the mode evolution alone the device to see physically why it functions as a PSR. This requires us to perform mode analysis at different \(x\) positions. First, let’s perform the mode analysis at the input waveguide (\(x=0\)) and solve for two modes.

As expected, the first mode is TE0 mode and the second mode is the TM0 mode. Note that the grid looks a bit coarse. If a finer resolution for the mode profile is needed, either use a finer grid or use Tidy3D’s waveguide plugin for the same analysis.

[10]:
mode_solver = ModeSolver(
    simulation=sim_te,
    plane=td.Box(center=(0, 0, t_si/2), size=(0, 4*w_1, 5*t_si)),
    mode_spec=mode_spec,
    freqs=[freq0],
)
mode_data = mode_solver.solve()

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8,3), tight_layout=True)
mode_data.intensity.sel(mode_index=0).plot(x='y', y='z', cmap='magma', ax=ax1)
mode_data.intensity.sel(mode_index=1).plot(x='y', y='z', cmap='magma', ax=ax2)
plt.show()
../_images/notebooks_BilevelPSR_22_0.png

Similarly, we move the mode analysis plane to the bi-level taper section at \(x=L_{blt}/2\). The first mode is still the TE0 while the second mode becomes a hybrid mode due to the fact that the partially etched slab breaks the vertical mirror symmetry.

[11]:
mode_solver = mode_solver.copy(update={"plane": td.Box(center=(L_blt/2, 0, t_si/2), size=(0, 2*w_pes, 5*t_si))})
mode_data = mode_solver.solve()

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8,3), tight_layout=True)
mode_data.intensity.sel(mode_index=0).plot(x='y', y='z', cmap='magma', ax=ax1)
mode_data.intensity.sel(mode_index=1).plot(x='y', y='z', cmap='magma', ax=ax2)
plt.show()
../_images/notebooks_BilevelPSR_24_0.png

The same mode analysis at the end of the bi-level taper section shows the first mode as the TE0 and the second mode as the TE1. That is, when TM0 mode is launched at the input waveguide, it adiabatically converts into the TE1 mode.

[12]:
mode_solver = mode_solver.copy(update={"plane": td.Box(center=(L_blt + L_s, 0, t_si/2), size=(0, 3*w_3, 5*t_si))})
mode_data = mode_solver.solve()

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8,3), tight_layout=True)
mode_data.intensity.sel(mode_index=0).plot(x='y', y='z', cmap='magma', ax=ax1)
mode_data.intensity.sel(mode_index=1).plot(x='y', y='z', cmap='magma', ax=ax2)
plt.show()
../_images/notebooks_BilevelPSR_26_0.png

Lastly, mode analysis at the end of the adiabatic coupler section shows the first mode as the TE0 at the top waveguide and the second mode as the TE0 at the bottom waveguide, which indicates that with an appropriate choice of coupling length and gap size, the TE1 mode on the top waveguide will be converted into the TE0 mode at the bottom waveguide. The TE0 mode launched in the input waveguide however stays as TE0 throughout the device.

For a more detailed analysis, please refer to the reference.

[13]:
mode_solver = mode_solver.copy(update={"plane": td.Box(center=(L_blt + L_s + L_ac, 0, t_si/2), size=(0, 5*w_5, 5*t_si))})
mode_data = mode_solver.solve()

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8,3), tight_layout=True)
mode_data.intensity.sel(mode_index=0).plot(x='y', y='z', cmap='magma', ax=ax1)
mode_data.intensity.sel(mode_index=1).plot(x='y', y='z', cmap='magma', ax=ax2)
plt.show()
../_images/notebooks_BilevelPSR_28_0.png

Run a Batch Simulation#

We also want to investigate the TM mode as input. To do so, we only need to define a new ModeSource and set mode_index=1. Then a simulation is created by copying the previous simulation with the sources updated. To run both the TE and TM input simulations simultaneously, we made a simulation batch.

[14]:
# define a new mode source that launches the tm mode
mode_source_tm = mode_source_te.copy(update={"mode_index": 1})

# define a new simulation and update the source
sim_tm = sim_te.copy(update={"sources": [mode_source_tm]})

# define a simulation batch
sims = {
    "TE input": sim_te,
    "TM input": sim_tm,
}
batch = web.Batch(simulations=sims)
[11:33:49] Created task 'TE input' with task_id 'fdve-af71c363-34e0-4e40-8f4d-f4e58d54eddcv1'.        webapi.py:140
[11:33:51] Created task 'TM input' with task_id 'fdve-3d03259b-90a3-4361-94da-876d7d195228v1'.        webapi.py:140

Submit the simulation batch to the server.

[15]:
batch_results = batch.run(path_dir="data")
[11:33:55] Started working on Batch.                                                               container.py:411
[13:26:47] Batch complete.                                                                         container.py:451

Result Analysis#

We define a helper function to plot the transmission spectra of the TE and TM modes at the top and bottom output waveguides.

[16]:
def plot_transmission(sim_data):

    # get te mode amplitude in the top waveguide
    amp_top_te = sim_data["mode_top"].amps.sel(mode_index=0, direction="+")
    # calculate te mode transmission in the top waveguide
    T_top_te = np.abs(amp_top_te) ** 2
    # get tm mode amplitude in the top waveguide
    amp_top_tm = sim_data["mode_top"].amps.sel(mode_index=1, direction="+")
    # calculate tm mode transmission in the top waveguide
    T_top_tm = np.abs(amp_top_tm) ** 2
    # get te mode amplitude in the bottom waveguide
    amp_bottom_te = sim_data["mode_bottom"].amps.sel(mode_index=0, direction="+")
    # calculate te mode transmission in the bottom waveguide
    T_bottom_te = np.abs(amp_bottom_te) ** 2
    # get tm mode amplitude in the bottom waveguide
    amp_bottom_tm = sim_data["mode_bottom"].amps.sel(mode_index=1, direction="+")
    # calculate tm mode transmission in the bottom waveguide
    T_bottom_tm = np.abs(amp_bottom_tm) ** 2

    # plotting transmission spectra in dB
    plt.plot(ldas, 10 * np.log10(T_top_te), label="Top TE")
    plt.plot(ldas, 10 * np.log10(T_top_tm), label="Top TM")
    plt.plot(ldas, 10 * np.log10(T_bottom_te), label="Bottom TE")
    plt.plot(ldas, 10 * np.log10(T_bottom_tm), label="Bottom TM")

    # formatting the plot
    plt.xlim(1.5, 1.58)
    plt.ylim(-60, 1)
    plt.xlabel("Wavelength ($\mu m$)")
    plt.ylabel("Transmission (dB)")
    plt.legend()
    plt.show()

Plot the transmission spectra for the TE input case. From the transmission plot, we can see that when the input mode is TE, all power is transmitted to the TE mode in the top waveguide.

[17]:
sim_data_te = batch_results["TE input"]
plot_transmission(sim_data_te)
[13:26:50] loading SimulationData from data\fdve-af71c363-34e0-4e40-8f4d-f4e58d54eddcv1.hdf5          webapi.py:513
../_images/notebooks_BilevelPSR_38_4.png

Plot the field intensity distribution.

[18]:
ax = sim_data_te.plot_field(
    field_monitor_name="field", field_name="E", val="abs^2", vmin=0, vmax=4e3
)
ax.set_aspect("auto")
../_images/notebooks_BilevelPSR_40_0.png

Plot the transmission spectra for the TM input case. From the transmission plot, we can see that when the input mode is TM, all power is transmitted to the TE mode in the bottom waveguide.

[19]:
sim_data_tm = batch_results["TM input"]
plot_transmission(sim_data_tm)
[13:27:09] loading SimulationData from data\fdve-3d03259b-90a3-4361-94da-876d7d195228v1.hdf5          webapi.py:513
../_images/notebooks_BilevelPSR_42_4.png

Plot the field intensity distribution as before.

[20]:
ax = sim_data_tm.plot_field(
    field_monitor_name="field", field_name="E", val="abs^2", vmin=0, vmax=4e3
)
ax.set_aspect("auto")
../_images/notebooks_BilevelPSR_44_0.png

In conclusion, we see that the device functions as a PSR. The TE0 input is transmitted to the top waveguide at the output while staying as the TE0. The TM0 input is rotated to TE0 and transmitted to the bottom waveguide at the output. The loss is small in both cases.

[ ]: