PHIX ADK: IQ Modulator

In this tutorial, we will design a silicon photonic high-speed IQ modulator packaged using the Luceda Assembly Design kit for PHIX. The components are illustrated in the figure below.

The design is based on elements from SiFab, Luceda’s demonstration photonics processs design kit (PDK), combined with custom components designed in a photonics team on top of this PDK and the packaging frame from the assembly design kit.

The code used to create this design and referenced in this tutorial can be found in your Luceda Academy project in luceda_academy/designs/iq_modulator.

Why we need an IQ Modulator

High speed modulation is essential for modern communications. High-bandwidth data transmission utilizes optical communication links due to orders of magnitude lower signal losses as compared with electrical signals. Electro-optic modulation is used to take an optical carrier wave and modulate it with an electrical signal. The details of this can be seen in our tutorial Mach-Zehnder modulator

To implement a high-speed modulator, we convert phase modulated light into amplitude modulated light using an MZM. By combining two MZMs with 50/50 splitters at the input and output, it is possible to transmit two signals using one frequency thus significantly increasing the spectrum efficiency.

Fully assembled design

The GDSII file of the finalised design is generated by running the example_iqmodulator_packaged_layout.py file. Let’s go through it step by step.

Step 1: Importing the Dependencies

In Luceda IPKISS, dependencies of your design are imported at the top of your code, just like you would do for any other Python module. In our case, we import the following dependencies:

SiFab PDK: SiFab is Luceda’s demonstration PDK emulating the technology of a traditional SOI foundry. Grating couplers, splitters and bondpads will be directly imported from here.
PHIX ADK: The Assembly Design Kit (ADK) for PHIX is a design kit for packaging a photonics IC using the PHIX Characterization Package. By using the ADK, it is a lot easier to adhere to the design rules that will enable you to package and measure your chip afterwards.
pteam_library_si_fab: Local component library containing components that are shared across different designs made by your photonics team.
IQ Modulator design: This design is defined in a separate file iqmodulator_designs.py and uses ingredients from the dependencies above to create the IQ modulator.
Simulation of modulation schemes: Separate files are implemented for each modulation scheme.

luceda_academy/designs/iq_modulator/example_iqmodulator_packaged_layout.py

import si_fab.all as pdk
from iqmodulator_designs import IQModulator, PackagedIQModulator
from pteam_library_si_fab.components.mzm.pcell.cell import MZModulator

Step 2: Instantiating the Phase Shifter and the Heater

After the import statements, we instantiate the phase shifter from the SiFab PDK with the desired length. For more information about this PCell and the parameters that can be set, check out the SiFab documentation: PhaseShifterWaveguide.

luceda_academy/designs/iq_modulator/example_iqmodulator_packaged_layout.py

# Phase Shifter
ps = pdk.PhaseShifterWaveguide(
    name="phaseshifter",
    length=1000.0,
    core_width=0.45,
    rib_width=7.8,
    junction_offset=-0.1,
    p_width=4.1,
    n_width=3.9,

Next we instantiate the heater that we are going to use for the MZM later.

luceda_academy/designs/iq_modulator/example_iqmodulator_packaged_layout.py

# Phase Shifter (heater)
heater = pdk.HeatedWaveguide(name="heater")
heater.Layout(shape=[(0.0, 0.0), (100.0, 0.0)])

Step 3: Instantiating the MZM

The Mach-Zehnder modulator we will use in this tutorial is made of two arms, each with an electro-optic phase modulator and heater. The design of the MZM is explained in details in the Mach-Zehnder modulator tutorial. In step 1, we imported the MZM from the pteam_library_si_fab.components.mzm.pcell.cell Now we instantiate the MZM and we pass the phase shifter we have instantiated above to the MZM , together with parameters to adjust the metal pads size and position.

luceda_academy/designs/iq_modulator/example_iqmodulator_packaged_layout.py

# MZModulator
mzm = MZModulator(
    phaseshifter=ps,
    heater=heater,
    rf_pad_width=75,
    rf_pad_length=350,
    rf_signal_width=5.0,
    rf_ground_width=20.0,
    rf_pitch_in=200,
)

The MZM has the following layout.

Step 4: Instantiating the IQ Modulator

We next instantiate the IQ modulator by calling the IQModulator, which we have defined separately in the file iqmodulator_designs.py and imported at the top.

luceda_academy/designs/iq_modulator/example_iqmodulator_packaged_layout.py

# IQ Modulator
IQ_mod = IQModulator(mzm=mzm)

Here we see the layout of the combined MZMs making an IQ Modulator.

Step 5: Instantiating the PHIX ADK Packaging Frame

From the Luceda ADK for PHIX, we instantiate the packaged IQ modulator via the imported PackagedIQModulator from the iqmodulator PCell. The file iqmodulator_designs.py contains the parameters we will use in this design from the PHIX Characterization Package.

The PHIX Characterization Package allows the designer to work in an efficient manner by setting constraints on the design from the beginning. It contains numerous parameters that have specific requirements or boundaries that must be adhered to.

The PHIX Characterization Package contains packaging considerations such as the grating type, the number of couplers, the epoxy area, the distance to the edge, bondpad sizes and various other parameters. In the following code, we see an example of how it can be implemented.

luceda_academy/designs/iq_modulator/iqmodulator_designs.py

        from phix.all import CharacterizationPackage

        return CharacterizationPackage(
            pic_length=5325,
            pic_width=4150,
            couplers_type=True,
            couplers_number=4,
            couplers_pitch=127,
            pad_number=12,
            pad_pitch=self.pad_pitch,
            pad=self.bondpad,
            marker_layer=i3.TECH.PPLAYER.M2,
            pad_to_edge=100,
            coupler=self.gc,
        )

In this example, we use grating couplers by setting coupler_type = True. The couplers_pitch = 127 which is one of two possibilities as defined in the ADK. We also define the number of couplers, pads and the distance to to the pad edge.

We simply now instantiate the IQ modulator with the following function.

luceda_academy/designs/iq_modulator/example_iqmodulator_packaged_layout.py

# Packaged IQ modulator
IQ_mod_packaged = PackagedIQModulator(
    dut=IQ_mod,
)

The packaged layout of the IQ modulator can be seen here.

Step 6: Modulation Scheme Simulations

Modulation schemes are essential components of communication systems, enabling the efficient encoding of information onto carrier signals for transmission. By modulating parameters such as amplitude, frequency, or phase of the carrier signal, different modulation schemes offer varying degrees of spectral efficiency, robustness, and complexity. In this section we look at some common modulation schemes and how to simulate them in IPKISS.

On-Off Keying (OOK)

OOK is a simple modulation scheme in which the amplitude of the signal is modulated by varying the in-phase component of the IQ constellation diagram corresponding to “on” or “off” states.

We start by defining a simulation model for our MZM.

luceda_academy/designs/iq_modulator/simulation/simulate_mzm.py

import random

import numpy as np

import ipkiss3.all as i3
from si_fab.benches.sources import random_bitsource, rand_normal


def simulate_modulation_mzm(
    cell,
    mod_amplitude=None,
    mod_noise=None,
    opt_amplitude=None,
    opt_noise=None,
    v_mzm1=None,
    v_mzm2=None,
    bit_rate=10e9,
    n_bytes=100,
    steps_per_bit=50,
    center_wavelength=1.5,
    debug=False,

Next, the excitations with noise in the optical and electrical domain are defined.

luceda_academy/designs/iq_modulator/simulation/simulate_mzm.py

    # Define the excitations with noise on the electrical
    f_mod = random_bitsource(
        bitrate=bit_rate,
        amplitude=mod_amplitude,
        n_bytes=n_bytes,

Finally, we define a testbench with connections and a testbench model with a circuit model. The results are returned from the time domain simulation.

luceda_academy/designs/iq_modulator/simulation/simulate_mzm.py

    testbench_model = testbench.CircuitModel()
    results = testbench_model.get_time_response(
        t0=t0,
        t1=t1,
        dt=dt,
        center_wavelength=center_wavelength,
        debug=debug,
    )
    return results

Having defined a simulation model for the MZM, we can import this into an OOK simulation file. We start by importing the necessary dependencies.