RectangularTaperedWaveguideArray

class awg_designer.all.RectangularTaperedWaveguideArray

U-shaped rectangular bundle of tapered waveguides. Similar to RectangularWaveguideArray but allows to flare out the waveguides in the straight sections.

This array of waveguides implements the delays in the AWG using a U-shaped waveguide bundle. In the straight sections, a broader waveguide can be used (straight_trace_template) to reduce loss and phase errors.

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.

straight_trace_template: PCell and _WaveguideTemplate

Waveguide template for the expanded waveguides used in the straight sections.

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

taper_length: ( float and number > 0 ), *None allowed*

Length of the taper between the regular waveguide and the expanded waveguide. If None, the default taper lengths for each transition are calculated.

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

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])

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 = 10
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_trace_template = WireWaveguideTemplate()
straight_trace_template.Layout(core_width=1.0, cladding_width=3.0)

wg_array = awg.RectangularTaperedWaveguideArray(
    start_ports=sc_in_lo.east_ports,
    delay_lengths=delay_lengths,
    straight_trace_template=straight_trace_template,
)
wg_array_lo = wg_array.Layout(
    taper_length=10.0,
    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()

import si_fab.all as pdk  # noqa: F401
from ipkiss3 import all as i3
import numpy
import awg_designer.all as awg

slab_t = awg.SlabTemplate()
slab_t.Layout(slab_layers=[i3.TECH.PPLAYER.SI])

N = 30  # number of arms
R = 100.0  # radius of the star couplers
W = 2.0  # aperture width
M = 8  # outputs

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

angle_step = i3.RAD2DEG * (W + 0.2) / R
angles_arms = numpy.linspace(-angle_step * (N - 1) / 2.0, angle_step * (N - 1) / 2.0, N)
ap_arms_in, _, trans_arms_in, trans_ports_in = awg.get_star_coupler_apertures(
    apertures_arms=[ap] * N,
    apertures_ports=[ap],
    angles_arms=angles_arms,
    angles_ports=[0],
    radius=R,
    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] * N,
        trans_in=trans_ports_in,
        trans_out=trans_arms_in,
        radius_in=R,
        radius_out=R,
        extension_angles=(10, 5),
    )
)

# Make the multi-apertures for the outputs and get the transformations for the individual apertures.
angle_step = i3.RAD2DEG * 4.7 / R
angles_ports = numpy.linspace(angle_step * (M - 1) / 2.0, -angle_step * (M - 1) / 2.0, M)
ap_arms_out, ap_out, trans_arms_out, trans_ports_out = awg.get_star_coupler_apertures(
    apertures_arms=[ap] * N,
    apertures_ports=[ap] * M,
    angles_arms=angles_arms,
    angles_ports=angles_ports,
    radius=1.5 * R,
    mounting="rowland",
    input=False,
)

# Make the output star coupler
sc_out = awg.StarCoupler(aperture_in=ap_arms_out, aperture_out=ap_out)
sc_out_lo = sc_out.Layout(
    contour=awg.get_star_coupler_extended_contour(
        apertures_in=[ap] * N,
        apertures_out=[ap] * M,
        trans_in=trans_arms_out,
        trans_out=trans_ports_out,
        radius_in=R,
        radius_out=R / 2,
        extension_angles=(10, 10),
    )
)

delays = [20.0 * i for i in range(N)]
start_ports = [port for port in sc_in_lo.ports.y_sorted() if "out" in port.name]

end_ports = [
    port
    for port in i3.SRef(reference=sc_out_lo, transformation=i3.Rotation(rotation=180)).ports
    if "in" in port.name
]

# Make a tapered rectangular waveguide array
expanded_tt = pdk.SiWireWaveguideTemplate()
expanded_tt.Layout(core_width=1.0)

waveguide_array_exp = awg.RectangularTaperedWaveguideArray(
    start_ports=start_ports, end_ports=end_ports, delay_lengths=delays, straight_trace_template=expanded_tt
)
wgarr_exp_lo = waveguide_array_exp.Layout(bundle_spacing=40)
wgarr_exp_lo.visualize()

# Plot the full awg:
rect_awg_exp = awg.ArrayedWaveguideGrating(
    star_coupler_in=sc_in, star_coupler_out=sc_out, waveguide_array=waveguide_array_exp
)

awg_exp_lo = rect_awg_exp.Layout()
awg_exp_lo.visualize(annotate=True)