SWaveguideArray

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

S-shaped bundle of rounded waveguides.

This array of waveguides implements the delays in the AWG using a S-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 including a 180 degree rotation.

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:

cover_layers: optional

Layers to cover the waveguide bundle with

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

Additional offset to east of the output ports

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

Additional offset to south of the output ports

route_properties: dict, optional

Default route parameters (bend_radius, rounding_algorithm, angle_stepmin_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 S 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 = 10
delay_lengths = [delay * i for i in range(num_arms)]
offset_south = 70
offset_east = 10

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.SWaveguideArray(
    start_ports=sc_in_lo.east_ports,
    delay_lengths=delay_lengths
)
wg_array_lo = wg_array.Layout(
    offset_output_ports_south=offset_south,  # moves additionally the output star coupler to south
    offset_output_ports_east=offset_east,  # moves additionally the output star coupler to east
    route_properties=route_properties,
    cover_layers=[i3.TECH.PPLAYER.WG.CLADDING]
)

wg_array_lo.visualize()
../../../../_images/awg_designer-all-SWaveguideArray-1.png