component_from_netlist

component_from_netlist(
    netlist: dict[str, typing.Any],
) -> photonforge.Component

Create a component from a netlist description.

Args

netlist: Dictionary with the component description. The only required key is 'instances', which describes the references to all sub-components. See other keys in the example below.

Examples

>>> coupler = parametric.dual_ring_coupler(
...     port_spec="Strip",
...     coupling_distance=0.6,
...     radius=4,
... )
... bus = parametric.ring_coupler(
...     port_spec="Strip",
...     coupling_distance=0.6,
...     radius=4,
...     bus_length=5,
... )
>>> netlist1 = {
...     "name": "RING",
...     "instances": {"COUPLER": coupler, "BUS_0": bus, "BUS_1": bus},
...     "instance models": [
...         ("COUPLER", DirectionalCouplerModel(0.8, -0.5j)),
...     ],
...     "connections": [
...         (("COUPLER", "P0"), ("BUS_0", "P1")),
...         (("BUS_1", "P1"), ("COUPLER", "P3")),
...     ],
...     "ports": [
...         ("BUS_0", "P0"),
...         ("BUS_0", "P2"),
...         ("BUS_1", "P2"),
...         ("BUS_1", "P0"),
...     ],
...     "models": [CircuitModel()],
... }
>>> component1 = component_from_netlist(netlist1)

>>> netlist2 = {
...     "instances": [
...         coupler,
...         {"component": bus, "origin": (0, -12)},
...         {"component": bus, "origin": (3, 7), "rotation": 180},
...     ],
...     "virtual connections": [
...         ((0, "P0"), (1, "P1")),
...         ((0, "P2"), (1, "P3")),
...         ((2, "P3"), (0, "P1")),
...     ],
...     "routes": [
...         ((1, "P2"), (2, "P0"), {"radius": 6}),
...         ((2, "P1"), (0, "P3"), parametric.route_s_bend),
...     ],
...     "ports": [
...         (1, "P0", "In"),
...         (2, "P2", "Add"),
...     ],
...     "models": [(CircuitModel(), "Circuit")],
...     "active models": {"optical": "Circuit"},
... }
>>> component2 = component_from_netlist(netlist2)

>>> spec = cpw_spec("METAL", 3, 1)
... tl = parametric.straight(port_spec=spec, length=20)
... terminal = Terminal(
...     "METAL", Rectangle(center=(-10, 20), size=(2, 2))
... )
... tl.add_terminal(terminal, "T0")
... netlist3 = {
...     "instances": [tl],
...     "terminal routes": [
...         ((0, "T0"), (0, ("E0", "gnd0"))),
...     ],
...     "terminals": [
...         (0, "T0", "GND0"),
...         (0, ("E1", "gnd0"), "GND1"),
...     ],
... }
>>> component3 = component_from_netlist(netlist3)

The value in "instances" can be a dictionary or a list, in which case, index numbers are used in place of the keys. Each value can be a Component, a Reference, or a dictionary with keyword arguments to create a Reference.

Sub-components can receive extra models from "instance models". The last added model for each sub-component will be active.

The "connections" list specifies connections between instances. Each item is of the form ((key1, port1), (key2, port2)), indicating that the reference key1 must be transformed to have its port1 connected to port2 from the reference key2.

Items in the "routes" list contain 2 reference ports, similarly to "connections", plus an optional routing function and a dictionary of keyword arguments to the function: ((key1, port1), (key2, port2), route_function, kwargs_dict). If route_function is not provided, parametric.route is used.

A list of "terminal routes" can be also be specified analogously to "routes", with the difference that only terminal routing functions can be used and parametric.route_manhattan is the default. Terminals within ports can also be used by replacing the terminal name string with a tuple (port_name, terminal_name).

"virtual nets" (or "virtual_nets") declares N-way logical nets. Each member is (key, terminal_name) or (key, terminal_name, repetition_index); a None key denotes a named boundary terminal on the component itself.

The "ports" list specify the top-level component ports derived from instance ports from (key, port) or (key, port, new_name). The same goes for the "terminals" lists, except that terminal names can be replaced by a (port_name, terminal_name) tuple to indicate a terminals within a port.