RectangularWaveguideArray

class awg_designer.all.RectangularWaveguideArray

U-shaped rectangular bundle of rounded waveguides.

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

Parameters:

start_ports: PortList, required

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

delay_lengths: list, required

Delay lengths to implement in the arms

end_ports: ( PortList ), *None allowed*

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.

name: String that contains only ISO/IEC 8859-1 (extended ASCII py3) or pure ASCII (py2) characters

The unique name of the pcell

Other Parameters:

trace_template: PCell and _WaveguideTemplate, locked

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

Views

class Layout

Parameters:

fanout_route_properties: dict

Default fanout route parameters (min_straight, start_straight, end_straight).Bend_radius and rounding_algorithm are set to be the same as for the other routes (in the waveguide array).

route_properties: dict

Route properties for the waveguide array (bend_radius, rounding_algorithm, angle_stepmin_straight, start_straight, end_straight). If empty, use default values from the technology.

cover_layers:

Layers to cover the waveguide bundle with

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

spacing between the upper and bottom parts of the array

view_name: String that contains only alphanumeric characters from the ASCII set or contains _$. ASCII set is extended on PY3.

The name of the view

Examples

"""Creates an U shaped bundle based on an input star coupler with user specified route parameters."""
import si_fab.all as pdk  # noqa: F401
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.TECH.PPLAYER.SI])
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.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.NONE],
)
wg_array_lo.visualize()