ConnectElectricalBundle

class ipkiss3.all.ConnectElectricalBundle

Connects multiple ports together using a bundle of electrical wires separated by a fixed distance.

A Manhattan bundle consists of customizable fanouts at the start and at the end, with a Manhattan array between them.

A fanout routes inputs to evenly spaced outputs. The Manhattan array routes evenly spaced inputs to evenly spaced outputs using Manhattan routing.

Parameters:

trace_template: PCell and _TraceTemplate, required

Trace template to use for the traces in the bundle

end_fanout: _BundleFanout, required

The type of fanout to use at the end (if needed).

start_fanout: _BundleFanout, required

The type of fanout to use at the start (if needed).

min_gap: float and number > 0, optional

Minimum gap (edge-to-edge) between two adjacent wires

end_angle: ( float ), optional, *None allowed*

Angle of the start ports, pointing towards the route

start_angle: ( float ), optional, *None allowed*

Angle of the start ports, pointing towards the route

control_point_reference: optional, *None allowed*

Port (instance:port identifier or an actual i3.Port) belonging to the waveguide that will be used as a reference to define the control points in the bundle. If None, use the first port defined in the list of connections.

control_points: list, optional

Control the routing by passing through a list of i3.H / i3.V instances. See also the parameter control_point_reference to identify relative to which port / waveguide the control points pass. When using i3.START, this refers to the port at the start of the bundle before the fanout.

name: ( str and String that contains only ISO/IEC 8859-1 (extended ASCII py3) or pure ASCII (py2) characters ), optional, *None allowed*

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

The length of the straight end section of the route.

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

The length of the straight start section of the route.

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

The minimum length of any straight sections in the route.

angle_step: float and number > 0, optional

Angle step for rounding.

rounding_algorithm: optional

Rounding algorithm (ShapeRound, ShapeRoundAdiabaticSpline, …). Takes a shape as input and returns a new (rounded) shape.

bend_radius: float and number > 0, optional

Bend radius for the auto-generated bends

pitch: float and number > 0, optional

Fixed spacing between the routes. Defaults to the minimum spacing allowed by the technology.

Other Parameters:

cover_layers: locked

min_spacing: locked

See also

ConnectManhattanBundle

ConnectElectrical

SBendFanout

ManhattanFanout

Notes

The routing uses the same algorithm as ConnectManhattan, but ensures that wires are routed together as an array with a given pitch. To ensure all wires can be routed correctly, we route the center wire, and we increment the bend radius with half the width of the bundle.

For the control points, only horizontal i3.H / vertical i3.V control points can be used. Be aware that these control points are only applicable to the array section (the middle section) of the bundle. See the examples for an illustration.

Currently, i3.SBendFanout and i3.ManhattanFanout are the predefined fanout types that can be used for the start_fanout and end_fanout properties.

Examples

import si_fab.all as pdk  # noqa: F401
import ipkiss3.all as i3

bp = pdk.BondPad()
M1_wire_tpl = pdk.M1WireTemplate().Layout(width=5)

circuit = i3.Circuit(
    insts={
        "pad1": bp,
        "pad2": bp,
        "pad3": bp,
        "pad4": bp,
        "pad5": bp,
        "pad6": bp,
    },
    specs=[
        i3.Place("pad1:m1", (0.0, -100.0)),
        i3.Place("pad2:m1", (0.0, 0.0)),
        i3.Place("pad3:m1", (0.0, 100.0)),
        i3.Place("pad4:m1", (500.0, 200)),
        i3.Place("pad5:m1", (500.0, 400)),
        i3.Place("pad6:m1", (500.0, 600)),
        i3.ConnectElectricalBundle(
            connections=[
                ("pad1:m1", "pad4:m1"),
                ("pad2:m1", "pad5:m1"),
                ("pad3:m1", "pad6:m1"),
            ],
            start_angle=0,
            start_straight=50,
            start_fanout=i3.SBendFanout(),
            end_angle=180.0,
            end_straight=50,
            end_fanout=i3.SBendFanout(),
            trace_template=M1_wire_tpl,
            pitch=10,
            min_gap=5,
        ),
    ],
)

circuit_lo = circuit.Layout()
circuit_lo.visualize()

Using control line and reference to route the electrical bundle:

import si_fab.all as pdk  # noqa: F401
import ipkiss3.all as i3
import matplotlib.pyplot as plt

bp = pdk.BondPad()
M1_wire_tpl = pdk.M1WireTemplate().Layout(width=5)
circuit = i3.Circuit(
    insts={
        "pad1": bp,
        "pad2": bp,
        "pad3": bp,
        "pad4": bp,
        "pad5": bp,
        "pad6": bp,
    },
    specs=[
        i3.Place("pad1:m1", (0.0, -100.0)),
        i3.Place("pad2:m1", (0.0, 0.0)),
        i3.Place("pad3:m1", (0.0, 100.0)),
        i3.Place("pad4:m1", (0.0, 400)),
        i3.Place("pad5:m1", (0.0, 500)),
        i3.Place("pad6:m1", (0.0, 600)),
        i3.ConnectElectricalBundle(
            connections=[
                ("pad1:m1", "pad6:m1"),
                ("pad2:m1", "pad5:m1"),
                ("pad3:m1", "pad4:m1"),
            ],
            start_angle=0,
            start_straight=50,
            start_fanout=i3.SBendFanout(),
            end_angle=0.0,
            end_straight=50,
            end_fanout=i3.SBendFanout(),
            trace_template=M1_wire_tpl,
            pitch=10,
            min_gap=5,
            control_points=[i3.V(200)],
            control_point_reference="pad2:m1",
        ),
    ],
)

circuit_lo = circuit.Layout()
circuit_lo.visualize(show=False)

plt.axvline(x=200, color="k", linestyle="--")
plt.show()

Use different types of fanout at the start and the end:

import si_fab.all as pdk  # noqa
import ipkiss3.all as i3

class RoutedElectricalBundle(i3.Circuit):
    num_routes = i3.PositiveIntProperty(default=32)
    pad_pitch = i3.PositiveNumberProperty(default=20)
    vertical_distance = i3.PositiveNumberProperty(default=1000.0)
    horizontal_distance = i3.PositiveNumberProperty(default=1000.0)
    wire_width = i3.PositiveNumberProperty(default=2.0)

    def _default_insts(self):
        pad = pdk.BondPad()
        insts = {"pad_west_{}".format(i): pad for i in range(self.num_routes)}
        insts.update({"pad_east_{}".format(i): pad for i in range(self.num_routes)})
        return insts

    def _default_specs(self):
        place_specs = [
            i3.Place("pad_west_{}:m1".format(i), position=(i * self.pad_pitch, 0.0), angle=-90)
            for i in range(self.num_routes)
        ]
        place_specs += [
            i3.Place(
                "pad_east_{}:m1".format(i),
                position=(self.horizontal_distance + i * self.pad_pitch, -self.vertical_distance),
                angle=90,
            )
            for i in range(self.num_routes)
        ]
        route_specs = [
            i3.ConnectElectricalBundle(
                connections=[
                    ("pad_west_{}:m1".format(i), "pad_east_{}:m1".format(i)) for i in range(self.num_routes)
                ],
                start_angle=-90,
                start_straight=50,
                start_fanout=i3.SBendFanout(),
                end_angle=90,
                end_straight=50,
                end_fanout=i3.ManhattanFanout(output_direction=i3.WEST),
                trace_template=pdk.M1WireTemplate().Layout(width=5),
                pitch=10,  # Spacing between the routes in the array
                min_gap=5,  # Minimum gap between two wires,
            )
        ]
        return place_specs + route_specs

bundle_circuit = RoutedElectricalBundle(
    num_routes=30, pad_pitch=100.0, horizontal_distance=2000.0, vertical_distance=2000.0
)
bundle_circuit.get_default_view(i3.LayoutView).visualize()