def get_input_label(
port,
gc,
gc_index=None,
gc_port_name="W0",
layer_label=LAYER.LABEL,
component_name=None,
):
"""
Generate a label with component info for a given grating coupler.
This is the label used by T&M to extract grating coupler coordinates
and match it to the component.
"""
text = get_optical_text(port=port,
gc=gc,
gc_index=gc_index,
component_name=component_name)
if gc_port_name is None:
gc_port_name = list(gc.ports.values())[0].name
label = pd.Label(
text=text,
position=gc.ports[gc_port_name].midpoint,
anchor="o",
layer=layer_label,
)
return label
def get_input_labels(
io_gratings,
ordered_ports,
component_name,
layer_label=layer_label,
gc_port_name=gc_port_name,
port_index=1,
):
""" get labels for all component ports """
if port_index == -1:
return get_input_labels_all(
io_gratings=io_gratings,
ordered_ports=ordered_ports,
component_name=component_name,
gc_port_name=gc_port_name,
port_index=port_index,
)
gc = io_gratings[port_index]
port = ordered_ports[1]
text = get_optical_text(port=port,
gc=gc,
gc_index=port_index,
component_name=component_name)
print(text)
layer, texttype = pd._parse_layer(layer_label)
label = pd.Label(
text=text,
position=gc.ports[gc_port_name].midpoint,
anchor="o",
layer=layer,
texttype=texttype,
)
return [label]
def get_input_label_electrical(port,
index=0,
component_name=None,
layer_label=LAYER.LABEL):
"""
Generate a label to test component info for a given grating coupler.
This is the label used by T&M to extract grating coupler coordinates
and match it to the component.
"""
if component_name:
name = component_name
elif type(port.parent) == pp.Component:
name = port.parent.name
else:
name = port.parent.ref_cell.name
text = "elec_{}_({})_{}".format(index, name, port.name)
gds_layer_label, gds_datatype_label = pd._parse_layer(layer_label)
label = pd.Label(
text=text,
position=port.midpoint,
anchor="o",
layer=gds_layer_label,
texttype=gds_datatype_label,
)
return label
def get_input_label(
port: Port,
gc: ComponentReference,
gc_index: Optional[int] = None,
gc_port_name: str = "W0",
layer_label: ListConfig = pp.LAYER.LABEL,
component_name: Optional[str] = None,
) -> Label:
"""
Generate a label with component info for a given grating coupler.
This is the label used by T&M to extract grating coupler coordinates
and match it to the component.
"""
text = get_optical_text(port=port,
gc=gc,
gc_index=gc_index,
component_name=component_name)
if gc_port_name is None:
gc_port_name = list(gc.ports.values())[0].name
layer, texttype = pd._parse_layer(layer_label)
label = pd.Label(
text=text,
position=gc.ports[gc_port_name].midpoint,
anchor="o",
layer=layer,
texttype=texttype,
)
return label
def get_input_labels(
io_gratings: List[ComponentReference],
ordered_ports: List[Port],
component_name: str,
layer_label: Tuple[int, int] = LAYER.LABEL,
gc_port_name: str = "W0",
port_index: int = 1,
) -> List[Label]:
"""Return labels (elements list) for all component ports."""
if port_index == -1:
return get_input_labels_all(
io_gratings=io_gratings,
ordered_ports=ordered_ports,
component_name=component_name,
layer_label=layer_label,
gc_port_name=gc_port_name,
)
gc = io_gratings[port_index]
port = ordered_ports[1]
text = get_optical_text(port=port,
gc=gc,
gc_index=port_index,
component_name=component_name)
layer, texttype = pd._parse_layer(layer_label)
label = pd.Label(
text=text,
position=gc.ports[gc_port_name].midpoint,
anchor="o",
layer=layer,
texttype=texttype,
)
return [label]
def add_label(component, text, position=(0, 0), layer=pp.LAYER.LABEL):
gds_layer_label, gds_datatype_label = pd._parse_layer(layer)
label = pd.Label(
text=text,
position=position,
anchor="o",
layer=gds_layer_label,
texttype=gds_datatype_label,
)
component.add(label)
return component
def label(text, position=(0, 0), layer=66):
gds_layer_label, gds_datatype_label = pd._parse_layer(layer)
label_ref = pd.Label(
text=text,
position=position,
anchor="o",
layer=gds_layer_label,
texttype=gds_datatype_label,
)
return label_ref
def label(
text: str = "abc",
position: Tuple[float, float] = (0.0, 0.0),
layer: Tuple[int, int] = pp.LAYER.TEXT,
) -> Label:
gds_layer_label, gds_datatype_label = pd._parse_layer(layer)
label_ref = pd.Label(
text=text,
position=position,
anchor="o",
layer=gds_layer_label,
texttype=gds_datatype_label,
)
return label_ref
def get_input_label(
port,
gc,
gc_index=None,
gc_port_name="W0",
layer_label=LAYER.LABEL,
component_name=None,
):
"""
Generate a label with component info for a given grating coupler.
This is the label used by T&M to extract grating coupler coordinates
and match it to the component.
"""
polarization = gc.get_property("polarization")
wavelength_nm = gc.get_property("wavelength")
if component_name:
name = component_name
elif type(port.parent) == pp.Component:
name = port.parent.name
else:
name = port.parent.ref_cell.name
if isinstance(gc_index, int):
text = "opt_{}_{}_({})_{}_{}".format(polarization, int(wavelength_nm),
name, gc_index, port.name)
else:
text = "opt_{}_{}_({})_{}".format(polarization, int(wavelength_nm),
name, port.name)
if gc_port_name is None:
gc_port_name = list(gc.ports.values())[0].name
label = pd.Label(
text=text,
position=gc.ports[gc_port_name].midpoint,
anchor="o",
layer=layer_label,
)
return label
def get_input_label_electrical(
port: Port,
gc_index: int = 0,
component_name: Optional[str] = None,
layer_label: Layer = pp.LAYER.LABEL,
gc: Optional[ComponentReference] = None,
):
"""
Generate a label to test component info for a given electrical port.
This is the label used by T&M to extract grating coupler coordinates
and match it to the component.
Args:
port:
gc_index: index of the label
component_name:
layer_label:
gc: ignored
"""
if component_name:
name = component_name
elif isinstance(port.parent, pp.Component):
name = port.parent.name
else:
name = port.parent.ref_cell.name
text = f"elec_{gc_index}_({name})_{port.name}"
layer, texttype = pd._parse_layer(layer_label)
label = pd.Label(
text=text,
position=port.midpoint,
anchor="o",
layer=layer,
texttype=texttype,
)
return label
def get_input_label(
port: Port,
gc: ComponentReference,
gc_index: Optional[int] = None,
gc_port_name: str = "o1",
layer_label: Layer = gf.LAYER.LABEL,
component_name: Optional[str] = None,
get_input_label_text_function=get_input_label_text,
) -> Label:
"""Returns a label with component info for a given grating coupler.
Test equipment to extract grating coupler coordinates and match it to the component.
Args:
port: port to label
gc: grating coupler reference
gc_index: grating coupler index
gc_port_name: name of grating coupler port
layer_label: layer of the label
component_name: for the label
get_input_label_text_function: function to get input label
"""
text = get_input_label_text_function(port=port,
gc=gc,
gc_index=gc_index,
component_name=component_name)
if gc_port_name is None:
gc_port_name = list(gc.ports.values())[0].name
layer, texttype = pd._parse_layer(layer_label)
return pd.Label(
text=text,
position=gc.ports[gc_port_name].midpoint,
anchor="o",
layer=layer,
texttype=texttype,
)
def add_fiber_single(
component: Component,
grating_coupler: Callable = grating_coupler_te,
layer_label: Tuple[int, int] = LAYER.LABEL,
optical_io_spacing: int = 50,
bend_factory: Callable = bend_circular,
straight_factory: Callable = waveguide,
taper_factory: Callable = taper,
taper_length: float = 10.0,
route_filter: Callable = connect_strip_way_points,
min_input2output_spacing: int = 127,
optical_routing_type: int = 2,
with_align_ports: bool = True,
component_name: Optional[str] = None,
gc_port_name: str = "W0",
**kwargs,
) -> Component:
r"""returns component with grating ports and labels on each port
can add align_ports reference structure
Args:
component: to connect
grating_coupler: grating coupler instance, function or list of functions
layer_label: LAYER.LABEL
optical_io_spacing: SPACING_GC
bend_factory: bend_circular
straight_factory: waveguide
fanout_length: None # if None, automatic calculation of fanout length
max_y0_optical: None
with_align_ports: True, adds loopback structures
waveguide_separation: 4.0
bend_radius: BEND_RADIUS
list_port_labels: None, adds TM labels to port indices in this list
connected_port_list_ids: None # only for type 0 optical routing
nb_optical_ports_lines: 1
force_manhattan: False
excluded_ports:
grating_indices: None
routing_method: connect_strip
gc_port_name: W0
optical_routing_type: None: autoselection, 0: no extension
gc_rotation: -90
component_name: name of component
taper_factory: taper
.. code::
fiber
______
/| | |
/ | | |
W0| | | |
\ | | |
| \|_|_|_
|
xmin = 0
.. plot::
:include-source:
import pp
from pp.routing import add_fiber_array
c = pp.c.crossing()
cc = add_fiber_array(c)
pp.plotgds(cc)
"""
component = component() if callable(component) else component
gc = grating_coupler = (grating_coupler()
if callable(grating_coupler) else grating_coupler)
gc_port_to_edge = abs(gc.xmax - gc.ports[gc_port_name].midpoint[0])
port_width_gc = grating_coupler.ports[gc_port_name].width
optical_ports = component.get_ports_list(port_type="optical")
port_width_component = optical_ports[0].width
if port_width_component != port_width_gc:
component = add_tapers(
component,
taper_factory(length=taper_length,
width1=port_width_gc,
width2=port_width_component),
)
component_name = component_name or component.name
name = f"{component_name}_{grating_coupler.name}"
elements, grating_couplers = route_fiber_single(
component,
component_name=component_name,
optical_io_spacing=optical_io_spacing,
bend_factory=bend_factory,
straight_factory=straight_factory,
route_filter=route_filter,
grating_coupler=grating_coupler,
layer_label=layer_label,
optical_routing_type=optical_routing_type,
min_input2output_spacing=min_input2output_spacing,
gc_port_name=gc_port_name,
**kwargs,
)
c = Component(name=name)
cr = c << component
cr.rotate(90)
for e in elements:
c.add(e)
for gc in grating_couplers:
c.add(gc)
for pname, p in component.ports.items():
if p.port_type != "optical":
c.add_port(pname, port=p)
if isinstance(grating_coupler, list):
grating_couplers = [call_if_func(g) for g in grating_coupler]
grating_coupler = grating_couplers[0]
else:
grating_coupler = call_if_func(grating_coupler)
grating_couplers = [grating_coupler]
if with_align_ports:
length = c.ysize - 2 * gc_port_to_edge
wg = c << straight_factory(length=length)
wg.rotate(90)
wg.xmax = (c.xmin - optical_io_spacing
if abs(c.xmin) > abs(optical_io_spacing) else c.xmin -
optical_io_spacing)
wg.ymin = c.ymin + gc_port_to_edge
gci = c << grating_coupler
gco = c << grating_coupler
gci.connect(gc_port_name, wg.ports["W0"])
gco.connect(gc_port_name, wg.ports["E0"])
gds_layer_label, gds_datatype_label = pd._parse_layer(layer_label)
port = wg.ports["E0"]
text = get_optical_text(port,
grating_coupler,
0,
component_name=f"loopback_{component.name}")
label = pd.Label(
text=text,
position=port.midpoint,
anchor="o",
layer=gds_layer_label,
texttype=gds_datatype_label,
)
c.add(label)
port = wg.ports["W0"]
text = get_optical_text(port,
grating_coupler,
1,
component_name=f"loopback_{component.name}")
label = pd.Label(
text=text,
position=port.midpoint,
anchor="o",
layer=gds_layer_label,
texttype=gds_datatype_label,
)
c.add(label)
return c