RectangularTaperedWaveguideArray

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

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:

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.

straight_trace_template: PCell and _WaveguideTemplate, optional

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

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)

taper_length: optional

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: 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

from technologies import silicon_photonics
from ipkiss3 import all as i3
import numpy
import awg_designer.all as awg

slab_t = awg.SlabTemplate()
slab_t.Layout(slab_layers=[i3.PPLayer(i3.TECH.PROCESS.WG, i3.TECH.PURPOSE.DF_AREA)])

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_lo = 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. * 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 = ap.trace_template.modified_copy()
expanded_tt.get_default_view(i3.LayoutView).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)
../../../../_images/awg_designer-all-RectangularTaperedWaveguideArray-1_00.png
../../../../_images/awg_designer-all-RectangularTaperedWaveguideArray-1_01.png
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)])

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.WG.CLADDING]
)

wg_array_lo.visualize()
../../../../_images/awg_designer-all-RectangularTaperedWaveguideArray-2.png