RectangularWaveguideArray

class awg_designer.all.RectangularWaveguideArray(*args, **kwargs)

U-shaped rectangular bundle of rounded waveguides.

This array of waveguides implements the delays in the AWG using a U-shaped waveguide bundle.

Parameters:

delay_lengths: list, required

Delay lengths to implement in the arms

start_ports: PortList, required

Ports that define the starting position, the angle, and the trace template for each waveguide in the array.

end_ports: optional

Ports that define the relative ending position, the angle, and the trace template for each waveguide in the array. Only the distances between the neighboring ports are used, as the waveguide array decides how large the array has to be in order to meet the specifications. It then translates the output accordingly. When None, assume these are the same as start_ports.

cell_instances: _PCellInstanceDict, optional

name: optional

The unique name of the pcell

trace_template: PCell and _WaveguideTemplate, locked

Waveguide template to use for drawing the bundles. Derived from the reference ports.

Views

Layout

Parameters:

bundle_spacing: float and Real, number and number >= 0, optional

spacing between the upper and bottom parts of the array

cover_layers: optional

Layers to cover the waveguide bundle with

route_properties: dict, optional

Default route parameters (bend_radius, rounding_algorithm, angle_step min_straight, start_straight, end_straight)

view_name: str, optional

The name of the view

grids_per_unit: locked

Number of grid cells per design unit

units_per_grid: locked

Ratio of grid cell and design unit

grid: float and number > 0, locked

design grid. Extracted by default from TECH.METRICS.GRID

unit: float and number > 0, locked

design unit. Extracted by default from TECH.METRICS.UNIT

Examples

"""Creates an U shaped bundle based on an input star coupler with user specified route parameters.

"""
from technologies import silicon_photonics
import ipkiss3.all as i3
import awg_designer.all as awg
import numpy as np
from picazzo3.traces.wire_wg.trace import WireWaveguideTemplate

slab_t = awg.SlabTemplate()
slab_t.Layout(slab_layers=[i3.PPLayer(i3.TECH.PROCESS.WG, i3.TECH.PURPOSE.DF_AREA)])
slab_t.SlabModes(modes=[awg.SimpleSlabMode(name="TE0", n_eff=2.8, n_g=3.2, polarization="TE")])

num_arms = 44  # number of arms
radius = 150.0  # radius of the star couplers
width = 2.0  # aperture width

# Make virtual aperture
ap = awg.OpenWireWgAperture(slab_template=slab_t)
ap_lo = ap.Layout(aperture_core_width=width, aperture_edge_width=1.0)

# Make a multi-aperture for the arms consisting of num_arms apertures like these, arranged in a circle
angle_step = i3.RAD2DEG * (width + 0.2) / radius
angles_arms = np.linspace(-angle_step * (num_arms - 1) / 2.0, angle_step * (num_arms - 1) / 2.0, num_arms)
ap_arms_in, _, trans_arms_in, trans_ports_in = awg.get_star_coupler_apertures(
    apertures_arms=[ap] * num_arms,
    apertures_ports=[ap],
    angles_arms=angles_arms,
    angles_ports=[0],
    radius=radius,
    mounting='confocal',
    input=True
)

# Make the input star coupler
sc_in = awg.StarCoupler(aperture_in=ap,
                        aperture_out=ap_arms_in)

sc_in_lo = sc_in.Layout(
    contour=awg.get_star_coupler_extended_contour(
        apertures_in=[ap],
        apertures_out=[ap] * num_arms,
        trans_in=trans_ports_in,
        trans_out=trans_arms_in,
        radius_in=radius,
        radius_out=radius,
        extension_angles=(10, 5)
    )
)

# bundle parameters
delay = 50
delay_lengths = [delay * i for i in range(num_arms)]
bundle_spacing = 100

route_properties = {
    'min_straight': 2.0,
    'start_straight': 1.0,
    'end_straight': 1.0,
    'bend_radius': 5.0,
    'rounding_algorithm': i3.ShapeRound,
    'angle_step': 1.0
}

straight_tmpl = WireWaveguideTemplate()
straight_tmpl.Layout(core_width=i3.TECH.WG.WIRE_WIDTH)
straight_tmpl.CircuitModel(n_eff=2.81, n_g=4.2)

wg_array = awg.RectangularWaveguideArray(
    start_ports=sc_in_lo.east_ports,
    delay_lengths=delay_lengths
)
wg_array_lo = wg_array.Layout(
    bundle_spacing=bundle_spacing,  # spacing of the input and the output ports
    route_properties=route_properties,
    cover_layers=[i3.TECH.PPLAYER.WG.CLADDING]
)
wg_array_lo.visualize()