Ligentec: Arrayed waveguide grating (AWG) for integrated optical coherence tomography

Note

This application example requires the Luceda PDK for Ligentec’s AN150 platform. Please contact Ligentec to obtain access to this PDK.

Introduction

Arrayed waveguide gratings (AWGs) are (de)multiplexing devices with a wide array of applications. One such application is optical coherence tomography (OCT) which is used in medical applications such as retinal imaging [1]. OCT can be described as an optical version of ultrasound imaging. In OCT, a broadband light beam is split into two beams. One of these beams penetrates into the object (such as a human retina) to be imaged and is reflected from it at a range of different depths [2]. The other beam is reflected from a reference mirror and follows a known path. The two reflected beams are then recombined, causing interference between them [2]. The frequencies of the recombined beam are then separated by a spectrometer, conventionally a diffraction grating [3]. Using the output of the spectrometer, one can then reconstruct the structure of the object at the range of depths in which it is imaged. By scanning the OCT system over the two transverse directions, a 3D image of the object can then be reconstructed.

Set-up for OCT. Image from [4]_. — Set-up for OCT. Image from [4].

However, OTC is typically implemented using bulk optical components that are expensive and take a lot of space [1]. The solution is therefore to integrate the spectrometer component in an integrated circuit [1]. This is achieved by implementing that component with an AWG.

The performance of an OCT system is determined by several different metrics. Two of these metrics are the axial resolution and its imaging depth. The former describes how close together along the axial direction (i.e. along the depth) different parts of the object’s structure can be resolved. The latter describes how deeply an object can be imaged.

Light penetrating into a sample to be imaged. Here, we show the two main figures of merit: the axial resolution and the imaging depth. The axial resolution determines how close together along the longitudinal direction different structures can be imaged.

Illustration of the AWG figure of merits.

These metrics are both related to the specifications of the spectrometer, in this case the AWG, and of the light source. In particular, the axial resolution is inversely proportional to the effective bandwidth of the detected light. This depends on both the bandwidth of the light source and that of the AWG. This means that, provided that it remains smaller than the bandwidth of the light source, the greater the bandwidth of AWG, the finer the axial resolution [5] [6]. The maximum imaging depth, on the other hand, is directly proportional to the spectral sampling interval and thus the channel spacing [5] [6]. The practical imaging depth is, however, of also limited by the material properties (scattering and absorption) and the crosstalk, which we will explain later. This means that there is trade-off: if you reduce the channel spacing of the AWG, you will increase the imaging depth of the OCT system but you will reduce its axial resolution for the same number of output channels. To have high resolution and imaging depth, an AWG with a large number of output channels is needed. Fortunately, the Luceda AWG Designer is capable of helping you design and simulate such a large AWG.

In this application example, our goal is to implement such an AWG for OCT applications, using this paper [1] published by the Nature group as a reference. The AWG they have fabricated and characterized in that paper is already able to perform well enough for commercial applications. With the help of this tutorial, you will be able to fabricate such an AWG too. This AWG operates in the very near infrared region and so is fabricated in silicon nitride which is transparent in this region. It has 256 output channels around a central wavelength of 794 nm and a channel spacing of 0.09 nm.

../../../_images/rect_awg_layout_large.png

As it takes time to implement and simulate such a large AWG, in this application example, we will begin by implementing an AWG with 64 output channels spaced 0.2 nm apart. You will be invited to change some parameters so as to see how the layout and light output of the AWG changes. In your own time, you may then decide to build the large AWG we show above.

Similarly to the Getting Started with Luceda AWG Designer and Organizing your AWG design project tutorials, in this application example we will go through the following steps:

AWG generation
- We will start by instantiating the subcomponents from the Ligentec PDK.
- Then, we will synthesize the AWG, i.e. derive its implementation parameters.
- Finally, we will assemble the AWG based on a U-shaped rectangular waveguide array.
AWG simulation and analysis
In this step, we simulate the AWG we just assembled and then analyze its results to see how well it performs.
AWG finalization
In the last step, we finalize the AWG design and route it to the edge couplers, so that it is ready for use.

These steps are all implemented in a number of custom functions: generate_awg, simulate_awg, analyse_awg and finalise_awg. These functions are very similar to the functions of the same name in the Organizing your AWG design project tutorial and serve the same purpose. A more detailed look on these functions can be seen in that tutorial.

As in the Organizing your AWG design project tutorial, we also have a script that we call example_generate_awg.py that calls these functions and goes through all these steps. The script can be customized to skip certain steps, depending on the goal. The full script can be found below.

luceda-academy/training/topical_training/oct_awg/example_generate_awg.py

import ligentec_an150.all as pdk  # noqa: F401
import ipkiss3.all as i3
import numpy as np
import os
from rect_awg.generate import generate_awg
from rect_awg.simulate import simulate_awg
from rect_awg.analyze import analyze_awg
from rect_awg.finalize import finalize_awg

# Actions
generate = True
simulate = True and generate
analyze = True
finalize = True and generate
plot_layout = False and generate
plot_sim_results = True
write_gds = True

# Specifications
center_wavelength = 0.800
channel_spacing = 0.2 * 1e-3
n_channels = 64
fsr_wavelength = (n_channels + 1) * channel_spacing

n_arms = None
min_bend_radius = 50
output_spacing = 0.2

simulation_wavelength_range = fsr_wavelength * 1.1
n_wavs_channel = 5

# Creating a folder for results
this_dir = os.path.abspath(os.path.dirname(__file__))
designs_dir = os.path.join(this_dir, "designs")
if not os.path.exists(designs_dir):
    os.mkdir(designs_dir)
save_dir = os.path.join(
    designs_dir,
    f"oct_awg_{center_wavelength:.1f}_{fsr_wavelength:.3f}_{output_spacing:.1f}",
)
if not os.path.exists(save_dir):
    os.mkdir(save_dir)

# Simulation specs
wavelengths = np.linspace(
    center_wavelength - 0.5 * simulation_wavelength_range,
    center_wavelength + 0.5 * simulation_wavelength_range,
    int(n_wavs_channel * simulation_wavelength_range / channel_spacing),
)

# Bare AWG
if generate:
    awg = generate_awg(
        center_wavelength=center_wavelength,
        channel_spacing=channel_spacing,
        fsr_wavelength=fsr_wavelength,
        n_channels=n_channels,
        n_arms=n_arms,
        output_spacing=output_spacing,
        min_bend_radius=min_bend_radius,
        plot=plot_layout,
        save_dir=save_dir,
        write_gds=write_gds,
        tag="bare",
    )

if simulate:
    smat = simulate_awg(
        awg=awg,
        wavelengths=wavelengths,
        save_dir=save_dir,
        tag="bare",
    )
else:
    path = os.path.join(save_dir, f"smatrix_bare.s{n_channels + 1}p")
    smat = i3.device_sim.SMatrix1DSweep.from_touchstone(path, unit="um") if os.path.exists(path) else None

if analyze:
    if smat is None:
        raise Exception(
            "Simulation data for the bare AWG is not available."
            "Please run the simulation first or set analyze to False."
        )
    else:
        analyze_awg(
            awg_s=smat,
            center_wavelength=center_wavelength,
            channel_spacing=channel_spacing,
            n_channels=n_channels,
            plot=plot_sim_results,
            save_dir=save_dir,
            tag="bare",
        )

# Finished AWG
if finalize:
    finalized_awg = finalize_awg(
        awg=awg,
        save_dir=save_dir,
        tag="finalized",
        write_gds=write_gds,
    )

    if simulate:
        smat_finalized = simulate_awg(
            awg=finalized_awg,
            wavelengths=wavelengths,
            save_dir=save_dir,
            tag="finalized",
        )
    else:
        path = os.path.join(save_dir, f"smatrix_finalized.s{n_channels + 1}p")
        smat_finalized = i3.device_sim.SMatrix1DSweep.from_touchstone(path, unit="um") if os.path.exists(path) else None

    if analyze:
        if smat_finalized is None:
            raise Exception(
                "Simulation data for the finalized AWG is not available."
                "Please run the simulation first or set analyze to False."
            )
        else:
            analyze_awg(
                awg_s=smat_finalized,
                center_wavelength=center_wavelength,
                channel_spacing=channel_spacing,
                n_channels=n_channels,
                peak_threshold=-25.0,
                plot=plot_sim_results,
                save_dir=save_dir,
                tag="finalized",
            )

../../../_images/rect_awg_layout_routed.png

../../../_images/output_spectrum_finalized.png

Generation

We generate the AWG with our generate_awg function using a similar procedure to that explained in the page AWG generation: Synthesis. Since this AWG is fabricated in a SiN platform, to recreate it, we must use the technology from a SiN foundry. For this application example, we chose the silicon nitride PDK from Ligentec which we import at the start of our script.