PCells

Parametric Cells for the Generic PDK.

Consider them a foundation from which you can draw inspiration. Feel free to modify their cross-sections and layers to tailor a unique PDK suited for any foundry of your choice.

By doing so, you’ll possess a versatile, retargetable PDK, empowering you to design your circuits with speed and flexibility.

components¶

analog¶

gdsfactory.components.analog.interdigital_capacitor(fingers: int = 4, finger_length: float | int = 20.0, finger_gap: float | int = 2.0, thickness: float | int = 5.0, layer: tuple[int, int] | str | int | LayerEnum = 'WG')Component

Generates an interdigital capacitor with ports on both ends.

See for example Zhu & Wu (2000).

Parameters

• fingers – total fingers of the capacitor.

• finger_length – length of the probing fingers.

• finger_gap – length of gap between the fingers.

• thickness – Thickness of fingers and section before the fingers.

• layer – spec.

import gdsfactory as gf

c = gf.components.interdigital_capacitor(fingers=4, finger_length=20, finger_gap=2, thickness=5, layer='WG').copy()
c.draw_ports()
c.plot()

bends¶

gdsfactory.components.bends.bend_circular(radius: float | None = None, angle: float = 90.0, npoints: int | None = None, layer: gf.typings.LayerSpec | None = None, width: float | None = None, cross_section: CrossSectionSpec = 'strip', allow_min_radius_violation: bool = False)Component

Returns a radial arc.

Parameters

• radius – in um. Defaults to cross_section_radius.

• angle – angle of arc (degrees).

• npoints – number of points.

• layer – layer to use. Defaults to cross_section.layer.

• width – width to use. Defaults to cross_section.width.

• cross_section – spec (CrossSection, string or dict).

• allow_min_radius_violation – if True allows radius to be smaller than cross_section radius.

import gdsfactory as gf

c = gf.components.bend_circular(angle=90, cross_section='strip', allow_min_radius_violation=False).copy()
c.draw_ports()
c.plot()

gdsfactory.components.bends.bend_circular_heater(radius: float | None = None, angle: float = 90, npoints: int | None = None, heater_to_wg_distance: float = 1.2, heater_width: float = 0.5, layer_heater: LayerSpec = 'HEATER', cross_section: CrossSectionSpec = 'strip', allow_min_radius_violation: bool = False)Component

Creates an arc of arclength theta starting at angle start_angle.

Parameters

• radius – in um. Defaults to cross_section.radius.

• angle – angle of arc (degrees).

• npoints – Number of points used per 360 degrees.

• heater_to_wg_distance – in um.

• heater_width – in um.

• layer_heater – for heater.

• cross_section – specification (CrossSection, string, CrossSectionFactory dict).

• allow_min_radius_violation – if True allows radius to be smaller than cross_section radius.

import gdsfactory as gf

c = gf.components.bend_circular_heater(angle=90, heater_to_wg_distance=1.2, heater_width=0.5, layer_heater='HEATER', cross_section='strip', allow_min_radius_violation=False).copy()
c.draw_ports()
c.plot()

gdsfactory.components.bends.bend_euler(radius: float | None = None, angle: float = 90.0, p: float = 0.5, with_arc_floorplan: bool = True, npoints: int | None = None, layer: LayerSpec | None = None, width: float | None = None, cross_section: CrossSectionSpec = 'strip', allow_min_radius_violation: bool = False)Component

Regular degree euler bend.

Parameters

• radius – in um. Defaults to cross_section_radius.

• angle – total angle of the curve.

• p – Proportion of the curve that is an Euler curve.

• with_arc_floorplan – if True the size of the bend will be adjusted to match an arc bend with the specified radius. If False: radius is the minimum radius of curvature.

• npoints – Number of points used per 360 degrees.

• layer – layer to use. Defaults to cross_section.layer.

• width – width to use. Defaults to cross_section.width.

• cross_section – specification (CrossSection, string, CrossSectionFactory dict).

• allow_min_radius_violation – if True allows radius to be smaller than cross_section radius.

import gdsfactory as gf

c = gf.components.bend_euler(angle=90, p=0.5, with_arc_floorplan=True, cross_section='strip', allow_min_radius_violation=False).copy()
c.draw_ports()
c.plot()

gdsfactory.components.bends.bend_euler_s(radius: float | None = None, p: float = 0.5, with_arc_floorplan: bool = True, npoints: int | None = None, layer: LayerSpec | None = None, width: float | None = None, cross_section: CrossSectionSpec = 'strip', allow_min_radius_violation: bool = False, port1: str = 'o1', port2: str = 'o2')Component

Sbend made of 2 euler bends.

Parameters

• radius – in um. Defaults to cross_section_radius.

• p – Proportion of the curve that is an Euler curve.

• with_arc_floorplan – If False: radius is the minimum radius of curvature.

• npoints – Number of points used per 360 degrees.

• layer – layer to use. Defaults to cross_section.layer.

• width – width to use. Defaults to cross_section.width.

• cross_section – specification (CrossSection, string, CrossSectionFactory dict).

• allow_min_radius_violation – if True allows radius to be smaller than cross_section radius.

• port1 – input port name.

• port2 – output port name.

               _____ o2
              /
             /
            /
           /
           |
          /
         /
        /
o1_____/

import gdsfactory as gf

c = gf.components.bend_euler_s(p=0.5, with_arc_floorplan=True, cross_section='strip', allow_min_radius_violation=False, port1='o1', port2='o2').copy()
c.draw_ports()
c.plot()

gdsfactory.components.bends.bend_s(size: Size = (11.0, 1.8), npoints: int = 99, cross_section: CrossSectionSpec = 'strip', allow_min_radius_violation: bool = False, width: float | None = None)Component

Return S bend with bezier curve.

stores min_bend_radius property in self.info[‘min_bend_radius’] min_bend_radius depends on height and length

Parameters

• size – in x and y direction.

• npoints – number of points.

• cross_section – spec.

• allow_min_radius_violation – bool.

• width – width to use. Defaults to cross_section.width.

import gdsfactory as gf

c = gf.components.bend_s(size=(11, 1.8), npoints=99, cross_section='strip', allow_min_radius_violation=False).copy()
c.draw_ports()
c.plot()

gdsfactory.components.bends.bend_s_offset(offset: float = 40.0, radius: float | None = 10.0, cross_section: CrossSectionSpec = 'strip', width: float | None = None, with_euler: bool = True)gf.Component

Return S bend made of two euler bends with a straight section.

stores min_bend_radius property in self.info[‘min_bend_radius’] min_bend_radius depends on height and length

Parameters

• offset – in um.

• radius – in um. if None, uses cross_section_radius.

• cross_section – spec.

• width – width to use. Defaults to cross_section.width.

• with_euler – use euler bend instead of arc bend.

import gdsfactory as gf

c = gf.components.bend_s_offset(offset=40, radius=10, cross_section='strip', with_euler=True).copy()
c.draw_ports()
c.plot()

gdsfactory.components.bends.bezier(control_points: Coordinates = ((0.0, 0.0), (5.0, 0.0), (5.0, 1.8), (10.0, 1.8)), npoints: int = 201, with_manhattan_facing_angles: bool = True, start_angle: int | None = None, end_angle: int | None = None, cross_section: CrossSectionSpec = 'strip', bend_radius_error_type: ErrorType | None = None, allow_min_radius_violation: bool = False, width: float | None = None)Component

Returns Bezier bend.

Parameters

• control_points – list of points.

• npoints – number of points varying between 0 and 1.

• with_manhattan_facing_angles – bool.

• start_angle – optional start angle in deg.

• end_angle – optional end angle in deg.

• cross_section – spec.

• bend_radius_error_type – error type.

• allow_min_radius_violation – bool.

• width – width to use. Defaults to cross_section.width.

import gdsfactory as gf

c = gf.components.bezier(control_points=((0, 0), (5, 0), (5, 1.8), (10, 1.8)), npoints=201, with_manhattan_facing_angles=True, cross_section='strip', allow_min_radius_violation=False).copy()
c.draw_ports()
c.plot()

containers¶

gdsfactory.components.containers.add_fiber_array_optical_south_electrical_north(component: str | Callable[[...], Component] | dict[str, Any] | DKCell, pad: str | Callable[[...], Component] | dict[str, Any] | DKCell, grating_coupler: str | Callable[[...], Component] | dict[str, Any] | DKCell, cross_section_metal: CrossSection | str | dict[str, Any] | Callable[[...], CrossSection] | SymmetricalCrossSection | DCrossSection, with_loopback: bool = True, pad_pitch: float = 100.0, pitch: float = 127.0, pad_gc_spacing: float = 250.0, electrical_port_names: list[str] | None = None, electrical_port_orientation: float | None = 90, npads: int | None = None, port_types_grating_couplers: list[str] | None = None, **kwargs: Any)Component

Returns a fiber array with Optical gratings on South and Electrical pads on North.

This a test configuration for DC pads.

Parameters

• component – component spec to add fiber and pads.

• pad – pad spec.

• grating_coupler – grating coupler function.

• cross_section_metal – metal cross section.

• with_loopback – whether to add a loopback port.

• pad_pitch – spacing between pads.

• pitch – spacing between grating couplers.

• pad_gc_spacing – spacing between pads and grating couplers.

• electrical_port_names – list of electrical port names. Defaults to all.

• electrical_port_orientation – orientation of electrical ports. Defaults to 90.

• npads – number of pads. Defaults to one per electrical_port_names.

• port_types_grating_couplers – port types for grating couplers. Defaults to vertical TE, TM, and dual.

• kwargs – additional arguments.

Keyword Arguments

• layer_label – layer for settings label.

• measurement – measurement name.

• measurement_settings – measurement settings.

• analysis – analysis name.

• doe – Design of Experiment.

• anchor – anchor point for the label. Defaults to south-west “sw”. Valid options are: “n”, “s”, “e”, “w”, “ne”, “nw”, “se”, “sw”, “c”.

• gc_port_name – grating coupler input port name.

• gc_port_labels – grating coupler list of labels.

• component_name – optional for the label.

• select_ports – function to select ports.

• cross_section – cross_section function.

• get_input_labels_function – function to get input labels. None skips labels.

• layer_label – optional layer for grating coupler label.

• bend – bend spec.

• straight – straight spec.

• taper – taper spec.

• get_input_label_text_loopback_function – function to get input label test.

• get_input_label_text_function – for labels.

• fanout_length – if None, automatic calculation of fanout length.

• max_y0_optical – in um.

• with_loopback – True, adds loopback structures.

• straight_separation – from edge to edge.

• list_port_labels – None, adds TM labels to port indices in this list.

• connected_port_list_ids – names of ports only for type 0 optical routing.

• nb_optical_ports_lines – number of grating coupler lines.

• force_manhattan – False

• excluded_ports – list of port names to exclude when adding gratings.

• grating_indices – list of grating coupler indices.

• routing_straight – function to route.

• routing_method – route_single.

• gc_rotation – fiber coupler rotation in degrees. Defaults to -90.

• input_port_indexes – to connect.

import gdsfactory as gf

c = gf.components.add_fiber_array_optical_south_electrical_north(with_loopback=True, pad_pitch=100, pitch=127, pad_gc_spacing=250, electrical_port_orientation=90).copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.add_termination(component: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | dict[str, ~typing.Any] | ~kfactory.kcell.DKCell = 'straight', port_names: tuple[str, ...] | None = None, terminator: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | dict[str, ~typing.Any] | ~kfactory.kcell.DKCell = functools.partial(<function taper>, width2=0.1), terminator_port_name: str | None = None)Component

Returns component with terminator on some ports.

Parameters

• component – to add terminator.

• port_names – ports to add terminator.

• terminator – factory for the terminator.

• terminator_port_name – for the terminator to connect to the component ports.

import gdsfactory as gf

c = gf.components.add_termination(component='straight').copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.add_trenches(component: ComponentSpec = 'coupler', layer_component: LayerSpec = 'WG', layer_trench: LayerSpec = 'DEEP_ETCH', width_trench: float = 2.0, cross_section: CrossSectionSpec = 'rib_with_trenches', top: float | None = None, bot: float | None = None, right: float | None = 0, left: float | None = 0, **kwargs: Any)gf.Component

Return component with trenches.

Parameters

• component – component to add to the trenches.

• layer_component – layer of the component.

• layer_trench – layer of the trenches.

• width_trench – width of the trenches.

• cross_section – spec (CrossSection, string or dict).

• top – width of the trench on the top. If None uses width_trench.

• bot – width of the trench on the bottom. If None uses width_trench.

• right – width of the trench on the right. If None uses width_trench.

• left – width of the trench on the left. If None uses width_trench.

• kwargs – component settings.

import gdsfactory as gf

c = gf.components.add_trenches(component='coupler', layer_component='WG', layer_trench='DEEP_ETCH', width_trench=2, cross_section='rib_with_trenches', right=0, left=0).copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.add_trenches90(*, component: ComponentSpec = 'bend_euler', layer_component: LayerSpec = 'WG', layer_trench: LayerSpec = 'DEEP_ETCH', width_trench: float = 2.0, cross_section: CrossSectionSpec = 'rib_with_trenches', top: float | None = 0, bot: float | None = None, right: float | None = None, left: float | None = 0, **kwargs: Any)gf.Component

Return component with trenches.

Parameters

• component – component to add to the trenches.

• layer_component – layer of the component.

• layer_trench – layer of the trenches.

• width_trench – width of the trenches.

• cross_section – spec (CrossSection, string or dict).

• top – width of the trench on the top. If None uses width_trench.

• bot – width of the trench on the bottom. If None uses width_trench.

• right – width of the trench on the right. If None uses width_trench.

• left – width of the trench on the left. If None uses width_trench.

• kwargs – component settings.

import gdsfactory as gf

c = gf.components.add_trenches90(component='bend_euler', layer_component='WG', layer_trench='DEEP_ETCH', width_trench=2, cross_section='rib_with_trenches', top=0, left=0).copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.array(component: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'pad', columns: int = 6, rows: int = 1, column_pitch: float = 150, row_pitch: float = 150, add_ports: bool = True, size: tuple[float, float] | None = None, centered: bool = False, post_process: Sequence[_PostProcess | Callable[[Component], None] | partial[Component]] | None = None, auto_rename_ports: bool = False)Component

Returns an array of components.

Parameters

• component – to replicate.

• columns – in x.

• rows – in y.

• column_pitch – pitch between columns.

• row_pitch – pitch between rows.

• auto_rename_ports – True to auto rename ports.

• add_ports – add ports from component into the array.

• size – Optional x, y size. Overrides columns and rows.

• centered – center the array around the origin.

• post_process – function to apply to the array after creation.

Raises

• ValueError – If columns > 1 and spacing[0] = 0.

• ValueError – If rows > 1 and spacing[1] = 0.

2 rows x 4 columns

  column_pitch
  <---------->
 ___        ___       ___        ___
|   |      |   |     |   |      |   |
|___|      |___|     |___|      |___|

 ___        ___       ___        ___
|   |      |   |     |   |      |   |
|___|      |___|     |___|      |___|

import gdsfactory as gf

c = gf.components.array(component='pad', columns=6, rows=1, column_pitch=150, row_pitch=150, add_ports=True, centered=False, auto_rename_ports=False).copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.component_sequence(sequence: str, symbol_to_component: dict[str, tuple[Component, str, str]], ports_map: dict[str, tuple[str, str]] | None = None, port_name1: str = 'o1', port_name2: str = 'o2', start_orientation: float = 0.0)Component

Returns component from ASCII sequence.

if you prefix a symbol with ! it mirrors the component

Parameters

• sequence – a string or a list of symbols.

• symbol_to_component – maps symbols to (component, input, output).

• ports_map – (optional) extra port mapping using the convention. {port_name: (alias_name, port_name)}

• port_name1 – input port_name.

• port_name2 – output port_name.

• start_orientation – in degrees.

Returns

containing the sequence of sub-components

instantiated and connected together in the sequence order.

Return type

component

import gdsfactory as gf

bend180 = gf.components.bend_circular180()
wg_pin = gf.components.straight_pin(length=40)
wg = gf.components.straight()

# Define a map between symbols and (component, input port, output port)
symbol_to_component = {
    "A": (bend180, 'o1', 'o2'),
    "B": (bend180, 'o2', 'o1'),
    "H": (wg_pin, 'o1', 'o2'),
    "-": (wg, 'o1', 'o2'),
}

# Each character in the sequence represents a component
s = "AB-H-H-H-H-BA"
c = gf.components.component_sequence(sequence=s, symbol_to_component=symbol_to_component)
c.plot()

gdsfactory.components.containers.copy_layers(factory: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'cross', layers: Sequence[tuple[int, int] | str | int | LayerEnum] = ((1, 0), (2, 0)), **kwargs: Any)Component

Returns a component with the geometry copied in different layers.

Parameters

• factory – component spec.

• layers – iterable of layers.

• kwargs – keyword arguments.

import gdsfactory as gf

c = gf.components.copy_layers(factory='cross', layers=((1, 0), (2, 0))).copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.extend_ports(component: ComponentSpec = 'mmi1x2', port_names: PortNames | None = None, length: float = 5.0, extension: ComponentSpec | None = None, port1: str | None = None, port2: str | None = None, port_type: str = 'optical', centered: bool = False, cross_section: CrossSectionSpec | None = None, extension_port_names: list[str] | None = None, allow_width_mismatch: bool = False, auto_taper: bool = True, **kwargs: Any)Component

Returns a new component with some ports extended.

You can define extension Spec defaults to port cross_section of each port to extend.

Parameters

• component – component to extend ports.

• port_names – list of ports names to extend, if None it extends all ports.

• length – extension length.

• extension – function to extend ports (defaults to a straight).

• port1 – extension input port name.

• port2 – extension output port name.

• port_type – type of the ports to extend.

• centered – if True centers rectangle at (0, 0).

• cross_section – extension cross_section, defaults to port cross_section if port has no cross_section it creates one using width and layer.

• extension_port_names – extension port names add to the new component.

• allow_width_mismatch – allow width mismatches.

• auto_taper – if True adds automatic tapers.

• kwargs – cross_section settings.

Keyword Arguments

• layer – port GDS layer.

• prefix – port name prefix.

• orientation – in degrees.

• width – port width.

• layers_excluded – List of layers to exclude.

• port_type – optical, electrical, ….

• clockwise – if True, sort ports clockwise, False: counter-clockwise.

import gdsfactory as gf

c = gf.components.extend_ports(component='mmi1x2', length=5, port_type='optical', centered=False, allow_width_mismatch=False, auto_taper=True).copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.extend_ports_list(component_spec: str | Callable[[...], Component] | dict[str, Any] | DKCell, extension: str | Callable[[...], Component] | dict[str, Any] | DKCell, extension_port_name: str | None = None, ignore_ports: Sequence[str] | None = None)Component

Returns a component with an extension attached to a list of ports.

Parameters

• component_spec – component from which to get ports.

• extension – function for extension.

• extension_port_name – to connect extension.

• ignore_ports – list of port names to ignore.

gdsfactory.components.containers.splitter_chain(splitter: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'mmi1x2', columns: int = 3, bend: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'bend_s')Component

Chain of splitters.

Parameters

• splitter – splitter to chain.

• columns – number of splitters to chain.

• bend – bend to connect splitters.

           __o5
        __|
     __|  |__o4
o1 _|  |__o3
    |__o2

     __o2
o1 _|
    |__o3

import gdsfactory as gf

c = gf.components.splitter_chain(splitter='mmi1x2', columns=3, bend='bend_s').copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.splitter_tree(coupler: ComponentSpec = 'mmi1x2', noutputs: int = 4, spacing: Spacing = (90.0, 50.0), bend_s: ComponentSpec | None = 'bend_s', bend_s_xsize: float | None = None, cross_section: CrossSectionSpec = 'strip')gf.Component

Tree of power splitters.

Parameters

• coupler – coupler factory.

• noutputs – number of outputs.

• spacing – x, y spacing between couplers.

• bend_s – Sbend function for termination.

• bend_s_xsize – xsize for the sbend.

• cross_section – cross_section.

     __|
  __|  |__
_|  |__
 |__        dy

  dx

import gdsfactory as gf

c = gf.components.splitter_tree(coupler='mmi1x2', noutputs=4, spacing=(90, 50), bend_s='bend_s', cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.containers.switch_tree(*, coupler: ComponentSpec = functools.partial(<function mzi>, combiner='mmi2x2', port_e1_combiner='o3', port_e0_combiner='o4', delta_length=0, straight_x_top='straight_heater_metal', length_x=None), noutputs: int = 4, spacing: Spacing = (500, 100), bend_s: ComponentSpec | None = 'bend_s', bend_s_xsize: float | None = None, cross_section: CrossSectionSpec = 'strip')gf.Component

Tree of power splitters.

Parameters

• coupler – coupler factory.

• noutputs – number of outputs.

• spacing – x, y spacing between couplers.

• bend_s – Sbend function for termination.

• bend_s_xsize – xsize for the sbend.

• cross_section – cross_section.

     __|
  __|  |__
_|  |__
 |__        dy

  dx

import gdsfactory as gf

c = gf.components.switch_tree(noutputs=4, spacing=(500, 100), bend_s='bend_s', cross_section='strip').copy()
c.draw_ports()
c.plot()

couplers¶

gdsfactory.components.couplers.coupler(gap: float = 0.236, length: float = 20.0, dy: Delta = 4.0, dx: Delta = 10.0, cross_section: CrossSectionSpec = 'strip', allow_min_radius_violation: bool = False, bend: ComponentSpec = 'bend_s')Component

Symmetric coupler.

Parameters

• gap – between straights in um.

• length – of coupling region in um.

• dy – port to port vertical spacing in um.

• dx – length of bend in x direction in um.

• cross_section – spec (CrossSection, string or dict).

• allow_min_radius_violation – if True does not check for min bend radius.

• bend – input and output sbend components.

      dx                                 dx
   |------|                           |------|
o2 ________                           ______o3
           \                         /           |
            \        length         /            |
             ======================= gap         | dy
            /                       \            |
   ________/                         \_______    |
o1                                          o4

               coupler_straight  coupler_symmetric

import gdsfactory as gf

c = gf.components.coupler(gap=0.236, length=20, dy=4, dx=10, cross_section='strip', allow_min_radius_violation=False, bend='bend_s').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler90(gap: float = 0.2, radius: float | None = None, bend: ComponentSpec = 'bend_euler', straight: ComponentSpec = 'straight', cross_section: CrossSectionSpec = 'strip', cross_section_bend: CrossSectionSpec | None = None)Component

Straight coupled to a bend.

Parameters

• gap – um.

• radius – um.

• straight – for straight.

• bend – bend spec.

• cross_section – cross_section spec.

• cross_section_bend – optional bend cross_section spec.

     o3
      |
     /
    /
o2_/
o1___o4

import gdsfactory as gf

c = gf.components.coupler90(gap=0.2, bend='bend_euler', straight='straight', cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler90bend(radius: float = 10.0, gap: float = 0.2, bend: ComponentSpec = 'bend_euler', cross_section_inner: CrossSectionSpec = 'strip', cross_section_outer: CrossSectionSpec = 'strip')Component

Returns 2 coupled bends.

Parameters

• radius – um.

• gap – um.

• bend – for bend.

• cross_section_inner – spec inner bend.

• cross_section_outer – spec outer bend.

    r   3 4
    |   | |
    |  / /
    | / /
2____/ /
1_____/

import gdsfactory as gf

c = gf.components.coupler90bend(radius=10, gap=0.2, bend='bend_euler', cross_section_inner='strip', cross_section_outer='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler90circular(gap: float = 0.2, radius: float | None = None, *, bend: ComponentSpec = 'bend_circular', straight: ComponentSpec = 'straight', cross_section: CrossSectionSpec = 'strip', cross_section_bend: CrossSectionSpec | None = None)Component

Straight coupled to a bend.

Parameters

• gap – um.

• radius – um.

• straight – for straight.

• bend – bend spec.

• cross_section – cross_section spec.

• cross_section_bend – optional bend cross_section spec.

     o3
      |
     /
    /
o2_/
o1___o4

import gdsfactory as gf

c = gf.components.coupler90circular(gap=0.2, bend='bend_circular', straight='straight', cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_adiabatic(length1: float = 20.0, length2: float = 50.0, length3: float = 30.0, wg_sep: float = 1.0, input_wg_sep: float = 3.0, output_wg_sep: float = 3.0, dw: float = 0.1, cross_section: CrossSectionSpec = 'strip')Component

Returns 50/50 adiabatic coupler.

Design based on asymmetric adiabatic 3dB coupler designs, such as those. - Cao et al. (2010), - Xu et al. (2017) - Tamazin et al. (2018)

input Bezier curves, with poles set to half of the x-length of the S-bend. 1. is the first half of input S-bend where input widths taper by +dw and -dw 2. is the second half of the S-bend straight with constant, unbalanced widths 3. is the region where the two asymmetric straights gradually come together 4. straights taper back to the original width at a fixed distance from one another 5. is the output S-bend straight.

Parameters

• length1 – region that gradually brings the two asymmetric straights together. In this region the straight widths gradually change to be different by dw.

• length2 – coupling region, where asymmetric straights gradually become the same width.

• length3 – output region where the two straights separate.

• wg_sep – Distance between center-to-center in the coupling region (Region 2).

• input_wg_sep – Separation of the two straights at the input, center-to-center.

• output_wg_sep – Separation of the two straights at the output, center-to-center.

• dw – Change in straight width. In Region 1, top arm tapers to width+dw/2.0, bottom taper to width-dw/2.0.

• cross_section – cross_section spec.

import gdsfactory as gf

c = gf.components.coupler_adiabatic(length1=20, length2=50, length3=30, wg_sep=1, input_wg_sep=3, output_wg_sep=3, dw=0.1, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_asymmetric(gap: float = 0.234, dy: Delta = 2.5, dx: Delta = 10.0, cross_section: CrossSectionSpec = 'strip')Component

Bend coupled to straight waveguide.

Parameters

• gap – um.

• dy – port to port vertical spacing.

• dx – bend length in x direction.

• cross_section – spec.

               dx
            |-----|
             _____ o2
            /         |
      _____/          |
gap o1____________    |  dy
                   o3

import gdsfactory as gf

c = gf.components.coupler_asymmetric(gap=0.234, dy=2.5, dx=10, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_bent(gap: float = 0.2, radius: float = 26, length: float = 8.6, width1: float = 0.4, width2: float = 0.4, length_straight: float = 10, cross_section: str = 'strip')Component

Returns Broadband SOI curved / straight directional coupler.

based on: Chen et al. (2017).

Parameters

• gap – gap.

• radius – radius coupling.

• length – coupler_length.

• width1 – width1.

• width2 – width2.

• length_straight – input and output straight length.

• cross_section – cross_section.

import gdsfactory as gf

c = gf.components.coupler_bent(gap=0.2, radius=26, length=8.6, width1=0.4, width2=0.4, length_straight=10, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_broadband(w_sc: float = 0.5, gap_sc: float = 0.2, w_top: float = 0.6, gap_pc: float = 0.3, legnth_taper: float = 1.0, bend: ComponentSpec = 'bend_euler', coupler_straight: ComponentSpec = 'coupler_straight', length_coupler_straight: float = 12.4, lenght_coupler_big_gap: float = 4.7, cross_section: CrossSectionSpec = 'strip', radius: float = 10.0)Component

Returns broadband coupler component.

https://docs.flexcompute.com/projects/tidy3d/en/latest/notebooks/BroadbandDirectionalCoupler.html proposed in Zeqin Lu, Han Yun, Yun Wang, Zhitian Chen, Fan Zhang, Nicolas A. F. Jaeger, and Lukas Chrostowski, “Broadband silicon photonic directional coupler using asymmetric-waveguide based phase control,” Opt. Express 23, 3795-3808 (2015), DOI: 10.1364/OE.23.003795.

Parameters

• w_sc – width of waveguides in the symmetric coupler section.

• gap_sc – gap size between the waveguides in the symmetric coupler section.

• w_top – width of the top waveguide in the phase control section.

• gap_pc – gap size in the phase control section.

• legnth_taper – length of the tapers.

• bend – bend factory.

• coupler_straight – coupler_straight factory.

• length_coupler_straight – optimal L_1 from the 3d fdtd analysis.

• lenght_coupler_big_gap – optimal L_2 from the 3d fdtd analysis.

• cross_section – cross_section of the waveguides.

• radius – bend radius.

import gdsfactory as gf

c = gf.components.coupler_broadband(w_sc=0.5, gap_sc=0.2, w_top=0.6, gap_pc=0.3, legnth_taper=1, bend='bend_euler', coupler_straight='coupler_straight', length_coupler_straight=12.4, lenght_coupler_big_gap=4.7, cross_section='strip', radius=10).copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_full(coupling_length: float = 40.0, dx: Delta = 10.0, dy: Delta = 4.8, gap: float = 0.5, dw: float = 0.1, cross_section: CrossSectionSpec = 'strip', width: float | None = None)Component

Adiabatic Full coupler.

Design based on asymmetric adiabatic full coupler designs, such as the one reported in ‘Integrated Optic Adiabatic Devices on Silicon’ by Y. Shani, et al (IEEE Journal of Quantum Electronics, Vol. 27, No. 3 March 1991).

1. is the first half of the input S-bend straight where the input straights widths taper by +dw and -dw, 2. is the second half of the S-bend straight with constant, unbalanced widths, 3. is the coupling region where the straights from unbalanced widths to balanced widths to reverse polarity unbalanced widths, 4. is the fixed width straight that curves away from the coupling region, 5.is the final curve where the straights taper back to the regular width specified in the straight template.

Parameters

• coupling_length – Length of the coupling region in um.

• dx – Length of the bend regions in um.

• dy – Port-to-port distance between the bend regions in um.

• gap – Distance between the two straights in um.

• dw – delta width. Top arm tapers to width - dw, bottom to width + dw in um.

• cross_section – cross-section spec.

• width – width of the waveguide. If None, it will use the width of the cross_section.

import gdsfactory as gf

c = gf.components.coupler_full(coupling_length=40, dx=10, dy=4.8, gap=0.5, dw=0.1, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_ring(gap: float = 0.2, radius: float = 5.0, length_x: float = 4.0, bend: ComponentSpec = 'bend_euler', straight: ComponentSpec = 'straight', cross_section: CrossSectionSpec = 'strip', cross_section_bend: CrossSectionSpec | None = None, length_extension: float = 3)Component

Coupler for ring.

Parameters

• gap – spacing between parallel coupled straight waveguides.

• radius – of the bends.

• length_x – length of the parallel coupled straight waveguides.

• bend – 90 degrees bend spec.

• straight – straight spec.

• cross_section – cross_section spec.

• cross_section_bend – optional bend cross_section spec.

• length_extension – for the ports.

  o2            o3
   |             |
    \           /
     \         /
   ---=========---
o1    length_x   o4

import gdsfactory as gf

c = gf.components.coupler_ring(gap=0.2, radius=5, length_x=4, bend='bend_euler', straight='straight', cross_section='strip', length_extension=3).copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_straight(length: float = 10.0, gap: float = 0.27, cross_section: CrossSectionSpec = 'strip')Component

Coupler_straight with two parallel straights.

Parameters

• length – of straight.

• gap – between straights.

• cross_section – specification (CrossSection, string or dict).

o2──────▲─────────o3
        │gap
o1──────▼─────────o4

import gdsfactory as gf

c = gf.components.coupler_straight(length=10, gap=0.27, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_straight_asymmetric(length: float = 10.0, gap: float = 0.27, width_top: float = 0.5, width_bot: float = 1, cross_section: CrossSectionSpec = 'strip')Component

Coupler with two parallel straights of different widths.

Parameters

• length – of straight.

• gap – between straights.

• width_top – of top straight.

• width_bot – of bottom straight.

• cross_section – cross_section spec.

import gdsfactory as gf

c = gf.components.coupler_straight_asymmetric(length=10, gap=0.27, width_top=0.5, width_bot=1, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.couplers.coupler_symmetric(bend: ComponentSpec = 'bend_s', gap: float = 0.234, dy: Delta = 4.0, dx: Delta = 10.0, cross_section: CrossSectionSpec = 'strip')Component

Two coupled straights with bends.

Parameters

• bend – bend spec.

• gap – in um.

• dy – port to port vertical spacing.

• dx – bend length in x direction.

• cross_section – section.

          dx
       |-----|
          ___ o3
         /       |
o2 _____/        |
                 |
o1 _____         |  dy
        \        |
         \___    |
              o4

import gdsfactory as gf

c = gf.components.coupler_symmetric(bend='bend_s', gap=0.234, dy=4, dx=10, cross_section='strip').copy()
c.draw_ports()
c.plot()

detectors¶

gdsfactory.components.detectors.ge_detector_straight_si_contacts(length: float = 40.0, cross_section: CrossSectionSpec = 'pn_ge_detector_si_contacts', via_stack: ComponentSpec = 'via_stack_slab_m3', via_stack_width: float = 10.0, via_stack_spacing: float = 5.0, via_stack_offset: float = 0.0, taper_length: float = 20.0, taper_width: float = 0.8, taper_cros_section: CrossSectionSpec = 'strip')Component

Returns a straight Ge on Si detector with silicon contacts.

There are no contacts on the Ge. These detectors could have lower dark current and sensitivity compared to those with contacts in the Ge. See Chen et al., “High-Responsivity Low-Voltage 28-Gb/s Ge p-i-n Photodetector With Silicon Contacts”, Journal of Lightwave Technology 33(4), 2015.

Chen et al. (2015)

Parameters

• length – pd length.

• cross_section – for the waveguide.

• via_stack – for the via_stacks. First element

• via_stack_width – width of the via_stack.

• via_stack_spacing – spacing between via_stacks.

• via_stack_offset – with respect to the detector

• taper_length – length of the taper.

• taper_width – width of the taper.

• taper_cros_section – cross_section of the taper.

import gdsfactory as gf

c = gf.components.ge_detector_straight_si_contacts(length=40, cross_section='pn_ge_detector_si_contacts', via_stack='via_stack_slab_m3', via_stack_width=10, via_stack_spacing=5, via_stack_offset=0, taper_length=20, taper_width=0.8, taper_cros_section='strip').copy()
c.draw_ports()
c.plot()

dies¶

gdsfactory.components.dies.add_frame(component: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'rectangle', width: float = 10.0, spacing: float = 10.0, layer: tuple[int, int] | str | int | LayerEnum = 'WG')Component

Returns component with a frame around it.

Parameters

• component – Component to frame.

• width – of the frame.

• spacing – of component to frame.

• layer – frame layer.

import gdsfactory as gf

c = gf.components.add_frame(component='rectangle', width=10, spacing=10, layer='WG').copy()
c.draw_ports()
c.plot()

gdsfactory.components.dies.align_wafer(width: float = 10.0, spacing: float = 10.0, cross_length: float = 80.0, layer: tuple[int, int] | str | int | LayerEnum = 'WG', layer_cladding: tuple[int, int] | None = None, square_corner: str = 'bottom_left')Component

Returns cross inside a frame to align wafer.

Parameters

• width – in um.

• spacing – in um.

• cross_length – for the cross.

• layer – for the cross.

• layer_cladding – optional.

• square_corner – bottom_left, bottom_right, top_right, top_left.

import gdsfactory as gf

c = gf.components.align_wafer(width=10, spacing=10, cross_length=80, layer='WG', square_corner='bottom_left').copy()
c.draw_ports()
c.plot()

gdsfactory.components.dies.die(size: tuple[float, float] = (10000.0, 10000.0), street_width: float = 100.0, street_length: float = 1000.0, die_name: str | None = 'chip99', text_size: float = 100.0, text_location: str | tuple[float, float] = 'SW', layer: tuple[int, int] | str | int | LayerEnum | None = 'FLOORPLAN', bbox_layer: tuple[int, int] | str | int | LayerEnum | None = 'FLOORPLAN', text: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'text', draw_corners: bool = False)Component

Returns die with optional markers marking the boundary of the die.

Parameters

• size – x, y dimensions of the die.

• street_width – Width of the corner marks for die-sawing.

• street_length – Length of the corner marks for die-sawing.

• die_name – Label text. If None, no label is added.

• text_size – Label text size.

• text_location – {‘NW’, ‘N’, ‘NE’, ‘SW’, ‘S’, ‘SE’} or (x, y) coordinate.

• layer – For street widths. None to not draw the street widths.

• bbox_layer – optional bbox layer drawn bounding box around the die.

• text – function use for generating text. Needs to accept text, size, layer.

• draw_corners – True draws only corners. False draws a square die.

import gdsfactory as gf

c = gf.components.die(size=(10000, 10000), street_width=100, street_length=1000, die_name='chip99', text_size=100, text_location='SW', layer='FLOORPLAN', bbox_layer='FLOORPLAN', text='text', draw_corners=False).copy()
c.draw_ports()
c.plot()

gdsfactory.components.dies.die_with_pads(size: tuple[float, float] = (11470.0, 4900.0), ngratings: int = 14, npads: int = 31, grating_pitch: float = 250.0, pad_pitch: float = 300.0, grating_coupler: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'grating_coupler_te', cross_section: CrossSection | str | dict[str, Any] | Callable[[...], CrossSection] | SymmetricalCrossSection | DCrossSection = 'strip', pad: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'pad', layer_floorplan: tuple[int, int] | str | int | LayerEnum = 'FLOORPLAN', edge_to_pad_distance: float = 150.0, edge_to_grating_distance: float = 150.0, with_loopback: bool = True, loopback_radius: float | None = None)Component

A die with grating couplers and pads.

Parameters

• size – the size of the die, in um.

• ngratings – the number of grating couplers.

• npads – the number of pads.

• grating_pitch – the pitch of the grating couplers, in um.

• pad_pitch – the pitch of the pads, in um.

• grating_coupler – the grating coupler component.

• cross_section – the cross section.

• pad – the pad component.

• layer_floorplan – the layer of the floorplan.

• edge_to_pad_distance – the distance from the edge to the pads, in um.

• edge_to_grating_distance – the distance from the edge to the grating couplers, in um.

• with_loopback – if True, adds a loopback between edge GCs. Only works for rotation = 90 for now.

• loopback_radius – optional radius for loopback.

import gdsfactory as gf

c = gf.components.die_with_pads(size=(11470, 4900), ngratings=14, npads=31, grating_pitch=250, pad_pitch=300, grating_coupler='grating_coupler_te', cross_section='strip', pad='pad', layer_floorplan='FLOORPLAN', edge_to_pad_distance=150, edge_to_grating_distance=150, with_loopback=True).copy()
c.draw_ports()
c.plot()

gdsfactory.components.dies.seal_ring(size: tuple[float, float] = (500, 500), seal: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'via_stack', width: float = 10, padding: float = 10.0, with_north: bool = True, with_south: bool = True, with_east: bool = True, with_west: bool = True)Component

Returns a continuous seal ring boundary at the chip/die.

Prevents cracks from spreading and shields when connected to ground.

Parameters

• size – of the seal.

• seal – function for the seal.

• width – of the seal.

• padding – from component to seal.

• with_north – includes seal.

• with_south – includes seal.

• with_east – includes seal.

• with_west – includes seal.

import gdsfactory as gf

c = gf.components.seal_ring(size=(500, 500), seal='via_stack', width=10, padding=10, with_north=True, with_south=True, with_east=True, with_west=True).copy()
c.draw_ports()
c.plot()

gdsfactory.components.dies.seal_ring_segmented(size: tuple[float, float] = (500, 500), length_segment: float = 10, width_segment: float = 3, spacing_segment: float = 2, corner: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'via_stack_corner45_extended', via_stack: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'via_stack_m1_mtop', with_north: bool = True, with_south: bool = True, with_east: bool = True, with_west: bool = True)Component

Segmented Seal ring.

Parameters

• size – of the seal ring.

• length_segment – length of each segment.

• width_segment – width of each segment.

• spacing_segment – spacing between segments.

• corner – corner component.

• via_stack – via_stack component.

• with_north – includes seal.

• with_south – includes seal.

• with_east – includes seal.

• with_west – includes seal.

import gdsfactory as gf

c = gf.components.seal_ring_segmented(size=(500, 500), length_segment=10, width_segment=3, spacing_segment=2, corner='via_stack_corner45_extended', via_stack='via_stack_m1_mtop', with_north=True, with_south=True, with_east=True, with_west=True).copy()
c.draw_ports()
c.plot()

gdsfactory.components.dies.wafer(reticle: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'die', cols: tuple[int, ...] = (2, 6, 6, 8, 8, 6, 6, 2), xspacing: float | None = None, yspacing: float | None = None, die_name_col_row: bool = False)Component

Returns complete wafer. Useful for mask aligner steps.

Parameters

• reticle – spec for each wafer reticle.

• cols – how many columns per row.

• xspacing – optional spacing, defaults to reticle.xsize.

• yspacing – optional spacing, defaults to reticle.ysize.

• die_name_col_row – if True, die name is row_col, otherwise is a number

import gdsfactory as gf

c = gf.components.wafer(reticle='die', cols=(2, 6, 6, 8, 8, 6, 6, 2), die_name_col_row=False).copy()
c.draw_ports()
c.plot()

edge_couplers¶

gdsfactory.components.edge_couplers.edge_coupler_array(edge_coupler: str | Callable[[...], Component] | dict[str, Any] | DKCell = 'edge_coupler_silicon', n: int = 5, pitch: float = 127.0, x_reflection: bool = False, text: str | Callable[[...], Component] | dict[str, Any] | DKCell | None = 'text_rectangular', text_offset: tuple[float, float] = (10, 20), text_rotation: float = 0)Component

Fiber array edge coupler based on an inverse taper.

Each edge coupler adds a ruler for polishing.

Parameters

• edge_coupler – edge coupler spec.

• n – number of channels.

• pitch – Fiber pitch.

• x_reflection – horizontal mirror.

• text – text spec.

• text_offset – from edge coupler.

• text_rotation – text rotation in degrees.

import gdsfactory as gf

c = gf.components.edge_coupler_array(edge_coupler='edge_coupler_silicon', n=5, pitch=127, x_reflection=False, text='text_rectangular', text_offset=(10, 20), text_rotation=0).copy()
c.draw_ports()
c.plot()

gdsfactory.components.edge_couplers.edge_coupler_array_with_loopback(edge_coupler: ComponentSpec = 'edge_coupler_silicon', cross_section: CrossSectionSpec = 'strip', radius: float = 30, n: int = 8, pitch: float = 127.0, extension_length: float = 1.0, x_reflection: bool = False, text: ComponentSpec | None = 'text_rectangular', text_offset: Float2 = (0, 10), text_rotation: float = 0)Component

Fiber array edge coupler.

Parameters

• edge_coupler – edge coupler.

• cross_section – spec.

• radius – bend radius loopback (um).

• n – number of channels.

• pitch – Fiber pitch (um).

• extension_length – in um.

• x_reflection – horizontal mirror.

• text – Optional text spec.

• text_offset – x, y.

• text_rotation – text rotation in degrees.

import gdsfactory as gf

c = gf.components.edge_coupler_array_with_loopback(edge_coupler='edge_coupler_silicon', cross_section='strip', radius=30, n=8, pitch=127, extension_length=1, x_reflection=False, text='text_rectangular', text_offset=(0, 10), text_rotation=0).copy()
c.draw_ports()
c.plot()

gdsfactory.components.edge_couplers.edge_coupler_silicon(length: float = 100, width1: float = 0.5, width2: float = 0.2, with_two_ports: bool = True, port_names: tuple[str, str] = ('o1', 'o2'), port_types: tuple[str, str] = ('optical', 'edge_coupler'), cross_section: CrossSectionSpec = 'strip')Component

Edge coupler for silicon photonics.

Parameters

• length – length of the taper.

• width1 – width1 of the taper.

• width2 – width2 of the taper.

• with_two_ports – add two ports.

• port_names – tuple with port names.

• port_types – tuple with port types.

• cross_section – cross_section spec.

import gdsfactory as gf

c = gf.components.edge_coupler_silicon(length=100, width1=0.5, width2=0.2, with_two_ports=True, port_names=('o1', 'o2'), port_types=('optical', 'edge_coupler'), cross_section='strip').copy()
c.draw_ports()
c.plot()

filters¶

gdsfactory.components.filters.awg(arms: int = 10, outputs: int = 3, free_propagation_region_input_function: ComponentSpec = functools.partial(<function free_propagation_region>, inputs=1), free_propagation_region_output_function: ComponentSpec = functools.partial(<function free_propagation_region>, inputs=10, width1=10, width2=20.0), fpr_spacing: float = 50.0, arm_spacing: float = 1.0, cross_section: CrossSectionSpec = 'strip')Component

Returns a basic Arrayed Waveguide grating.

To simulate you can use https://github.com/dnrobin/awg-python

Parameters

• arms – number of arms.

• outputs – number of outputs.

• free_propagation_region_input_function – for input.

• free_propagation_region_output_function – for output.

• fpr_spacing – x separation between input/output free propagation region.

• arm_spacing – y separation between arms.

• cross_section – cross_section function.

import gdsfactory as gf

c = gf.components.awg(arms=10, outputs=3, fpr_spacing=50, arm_spacing=1, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.dbr(w1: float = 0.45, w2: float = 0.55, l1: float = 0.159, l2: float = 0.159, n: int = 10, cross_section: CrossSectionSpec = 'strip', straight_length: float = 0.01)Component

Distributed Bragg Reflector.

Parameters

• w1 – thin width in um.

• w2 – thick width in um.

• l1 – thin length in um.

• l2 – thick length in um.

• n – number of periods.

• cross_section – cross_section spec.

• straight_length – length of the straight section between cutbacks.

   l1      l2
<-----><-------->
        _________
_______|

  w1       w2       ...  n times
_______
       |_________

import gdsfactory as gf

c = gf.components.dbr(w1=0.45, w2=0.55, l1=0.159, l2=0.159, n=10, cross_section='strip', straight_length=0.01).copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.dbr_cell(w1: float = 0.45, w2: float = 0.55, l1: float = 0.159, l2: float = 0.159, cross_section: CrossSectionSpec = 'strip')Component

Distributed Bragg Reflector unit cell.

Parameters

• w1 – thin width in um.

• l1 – thin length in um.

• w2 – thick width in um.

• l2 – thick length in um.

• n – number of periods.

• cross_section – cross_section spec.

   l1      l2
<-----><-------->
        _________
_______|

  w1       w2
_______
       |_________

import gdsfactory as gf

c = gf.components.dbr_cell(w1=0.45, w2=0.55, l1=0.159, l2=0.159, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.dbr_tapered(length: float = 10.0, period: float = 0.85, dc: float = 0.5, w1: float = 0.4, w2: float = 1.0, taper_length: float = 20.0, fins: bool = False, fin_size: Size = (0.2, 0.05), cross_section: CrossSectionSpec = 'strip')Component

Distributed Bragg Reflector Cell class.

Tapers the input straight to a periodic straight structure with varying width (1-D photonic crystal).

Parameters

• length – Length of the DBR region.

• period – Period of the repeated unit.

• dc – Duty cycle of the repeated unit (must be a float between 0 and 1.0).

• w1 – thin section width. w1 = 0 corresponds to disconnected periodic blocks.

• w2 – wide section width.

• taper_length – between the input/output straight and the DBR region.

• fins – If True, adds fins to the input/output straights.

• fin_size – Specifies the x- and y-size of the fins. Defaults to 200 nm x 50 nm

• cross_section – cross_section spec.

         period
<-----><-------->
        _________
_______|

  w1       w2       ...  n times
_______
       |_________

import gdsfactory as gf

c = gf.components.dbr_tapered(length=10, period=0.85, dc=0.5, w1=0.4, w2=1, taper_length=20, fins=False, fin_size=(0.2, 0.05), cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.fiber(core_diameter: float = 10, cladding_diameter: float = 125, layer_core: tuple[int, int] | str | int | LayerEnum = 'WG', layer_cladding: tuple[int, int] | str | int | LayerEnum = 'WGCLAD')Component

Returns a fiber.

Parameters

• core_diameter – in um.

• cladding_diameter – in um.

• layer_core – layer spec for fiber core.

• layer_cladding – layer spec for fiber cladding.

import gdsfactory as gf

c = gf.components.fiber(core_diameter=10, cladding_diameter=125, layer_core='WG', layer_cladding='WGCLAD').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.fiber_array(n: int = 8, pitch: float = 127.0, core_diameter: float = 10, cladding_diameter: float = 125, layer_core: tuple[int, int] | str | int | LayerEnum = 'WG', layer_cladding: tuple[int, int] | str | int | LayerEnum = 'WGCLAD')Component

Returns a fiber array.

Parameters

• n – number of fibers.

• pitch – spacing.

• core_diameter – 10um.

• cladding_diameter – in um.

• layer_core – layer spec for fiber core.

• layer_cladding – layer spec for fiber cladding.

 pitch
  <->
 _________
|         | lid
| o o o o |
|         | base
|_________|
   length

import gdsfactory as gf

c = gf.components.fiber_array(n=8, pitch=127, core_diameter=10, cladding_diameter=125, layer_core='WG', layer_cladding='WGCLAD').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.free_propagation_region(width1: float = 2.0, width2: float = 20.0, length: float = 20.0, wg_width: float = 0.5, inputs: int = 1, outputs: int = 10, cross_section: CrossSectionSpec = 'strip')Component

Free propagation region.

Parameters

• width1 – width of the input region.

• width2 – width of the output region.

• length – length of the free propagation region.

• wg_width – waveguide width.

• inputs – number of inputs.

• outputs – number of outputs.

• cross_section – cross_section function.

      length
      <-->
        /|
       / |
width1|  | width2
       \ |
        \|

import gdsfactory as gf

c = gf.components.free_propagation_region(width1=2, width2=20, length=20, wg_width=0.5, inputs=1, outputs=10, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.loop_mirror(component: ComponentSpec = 'mmi1x2', bend90: ComponentSpec = 'bend_euler', cross_section: CrossSectionSpec = 'strip')Component

Returns Sagnac loop_mirror.

Parameters

• component – 1x2 splitter.

• bend90 – 90 deg bend.

• cross_section – cross_section settings.

import gdsfactory as gf

c = gf.components.loop_mirror(component='mmi1x2', bend90='bend_euler', cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.mode_converter(gap: float = 0.3, length: float = 10, coupler_straight_asymmetric: ComponentSpec = 'coupler_straight_asymmetric', bend: ComponentSpec = functools.partial(<function bend_s>, size=(25, 3)), taper: ComponentSpec = 'taper', mm_width: float = 1.2, mc_mm_width: float = 1, sm_width: float = 0.5, taper_length: float = 25, cross_section: CrossSectionSpec = 'strip')Component

Returns Mode converter from TE0 to TE1.

By matching the effective indices of two waveguides with different widths, light can couple from different transverse modes e.g. TE0 <-> TE1. Shu et al. (2019)

Parameters

• gap – directional coupler gap.

• length – coupler length interaction.

• coupler_straight_asymmetric – spec.

• bend – spec.

• taper – spec.

• mm_width – input/output multimode waveguide width.

• mc_mm_width – mode converter multimode waveguide width

• sm_width – single mode waveguide width.

• taper_length – taper length.

• cross_section – cross_section spec.

o2 ---           --- o4
      \         /
       \       /
        -------
o1 -----=======----- o3
        |-----|
        length

= : multimode width
- : singlemode width

import gdsfactory as gf

c = gf.components.mode_converter(gap=0.3, length=10, coupler_straight_asymmetric='coupler_straight_asymmetric', taper='taper', mm_width=1.2, mc_mm_width=1, sm_width=0.5, taper_length=25, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.polarization_splitter_rotator(width_taper_in: Float3 = (0.54, 0.69, 0.83), length_taper_in: Float2 | Float3 = (4.0, 44.0), width_coupler: Float2 = (0.9, 0.404), length_coupler: float = 7.0, gap: float = 0.15, width_out: float = 0.54, length_out: float = 14.33, dy: Delta = 5.0, cross_section: CrossSectionSpec = 'strip')Component

Returns polarization splitter rotator.

“Novel concept for ultracompact polarization splitter-rotator based on silicon nanowires.” By D. Dai, and J. E. Bowers (Optics express vol 19, no. 11 pp. 10940-10949 (2011)).

Parameters

• width_taper_in – Three west widths of the input tapers in um.

• length_taper_in – Two or three length of the bend regions in um.

• width_coupler – Top and bottom widths of the coupling region in um.

• length_coupler – Length of the coupling region in um.

• gap – Distance between the coupler in um.

• width_out – Width of the splitter region in um.

• length_out – Length of the splitter region in um.

• dy – Port-to-port distance between the splitter region in um.

• cross_section – cross-section spec.

Notes

The length of third input taper is automatically determined if only two lengths are in arguments.

import gdsfactory as gf

c = gf.components.polarization_splitter_rotator(width_taper_in=(0.54, 0.69, 0.83), length_taper_in=(4, 44), width_coupler=(0.9, 0.404), length_coupler=7, gap=0.15, width_out=0.54, length_out=14.33, dy=5, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.terminator(length: float | None = 50, cross_section_input: CrossSectionSpec = <function strip>, cross_section_tip: CrossSectionSpec | None = None, tapered_width: float = 0.2, doping_layers: LayerSpecs = ('NPP', ), doping_offset: float = 1.0)gf.Component

Returns doped taper to terminate waveguides.

Parameters

• length – distance between input and narrow tapered end.

• cross_section_input – input cross-section.

• cross_section_tip – cross-section at the end of the termination.

• tapered_width – width of the default cross-section at the end of the termination. Only used if cross_section_tip is not None.

• doping_layers – doping layers to superimpose on the taper. Default N++.

• doping_offset – offset of the doping layer beyond the bbox

import gdsfactory as gf

c = gf.components.terminator(length=50, tapered_width=0.2, doping_layers=('NPP',), doping_offset=1).copy()
c.draw_ports()
c.plot()

gdsfactory.components.filters.terminator_spiral(separation: float = 3.0, width_tip: float = 0.2, number_of_loops: float = 1, npoints: int = 1000, min_bend_radius: float | None = None, cross_section: CrossSectionSpec = 'strip')gf.Component

Returns doped taper to terminate waveguides.

Parameters

• separation – separation between the loops.

• width_tip – width of the default cross-section at the end of the termination. Only used if cross_section_tip is not None.

• number_of_loops – number of loops in the spiral.

• npoints – points for the spiral.

• min_bend_radius – minimum bend radius for the spiral.

• cross_section – input cross-section.

import gdsfactory as gf

c = gf.components.terminator_spiral(separation=3, width_tip=0.2, number_of_loops=1, npoints=1000, cross_section='strip').copy()
c.draw_ports()
c.plot()

grating_couplers¶

gdsfactory.components.grating_couplers.grating_coupler_array(grating_coupler: ComponentSpec = 'grating_coupler_elliptical', pitch: float = 127.0, n: int = 6, port_name: str = 'o1', rotation: int = -90, with_loopback: bool = False, cross_section: CrossSectionSpec = 'strip', straight_to_grating_spacing: float = 10.0, centered: bool = True, radius: float | None = None)Component

Array of grating couplers.

Parameters

• grating_coupler – ComponentSpec.

• pitch – x spacing.

• n – number of grating couplers.

• port_name – port name.

• rotation – rotation angle for each reference.

• with_loopback – if True, adds a loopback between edge GCs. Only works for rotation = 90 for now.

• cross_section – cross_section for the routing.

• straight_to_grating_spacing – spacing between the last grating coupler and the loopback.

• centered – if True, centers the array around the origin.

• radius – optional radius for routing the loopback.

import gdsfactory as gf

c = gf.components.grating_coupler_array(grating_coupler='grating_coupler_elliptical', pitch=127, n=6, port_name='o1', rotation=-90, with_loopback=False, cross_section='strip', straight_to_grating_spacing=10, centered=True).copy()
c.draw_ports()
c.plot()

gdsfactory.components.grating_couplers.grating_coupler_dual_pol(unit_cell: ComponentSpec = <function _unit_cell>, period_x: float = 0.58, period_y: float = 0.58, x_span: float = 11, y_span: float = 11, length_taper: float = 150.0, width_taper: float = 10.0, polarization: str = 'te', wavelength: float = 1.55, taper: ComponentSpec = 'taper', base_layer: LayerSpec = 'WG', cross_section: CrossSectionSpec = 'strip')Component

2 dimensional, dual polarization grating coupler.

Based on a photonic crystal with a unit cell that is usually an ellipse, a rectangle or a circle. # The default values are loosely based on Taillaert et al, # “A Compact Two-Dimensional Grating Coupler Used as a Polarization Splitter”, IEEE Phot. Techn. Lett. 15(9), 2003

Parameters

• unit_cell – component describing the unit cell of the photonic crystal.

• period_x – spacing between unit cells in the x direction [um].

• period_y – spacing between unit cells in the y direction [um].

• x_span – full x span of the photonic crystal.

• y_span – full y span of the photonic crystal.

• length_taper – taper length [um].

• width_taper – width of the taper at the grating coupler side [um].

• polarization – polarization of the grating coupler.

• wavelength – operation wavelength [um]

• taper – function to generate the tapers.

• base_layer – layer to draw over the whole photonic crystal (necessary if the unit cells are etched into a base layer).

• cross_section – for the routing waveguides.

side view
              fiber

           /  /  /  /
          /  /  /  /

        _|-|_|-|_|-|___  --> unit_cells
           base_layer |
    o1  ______________|


top view

           -------------
       // | o   o   o  |
o1 __ //  | o   o   o  |
      \\  | o   o   o  |
       \\ | o   o   o  |
           -------------
           \\         //
            \\       //
                 |
                 o2

import gdsfactory as gf

c = gf.components.grating_coupler_dual_pol(period_x=0.58, period_y=0.58, x_span=11, y_span=11, length_taper=150, width_taper=10, polarization='te', wavelength=1.55, taper='taper', base_layer='WG', cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.grating_couplers.grating_coupler_elliptical(polarization: str = 'te', taper_length: float = 16.6, taper_angle: float = 40.0, wavelength: float = 1.554, fiber_angle: float = 15.0, grating_line_width: float = 0.343, neff: float = 2.638, nclad: float = 1.443, n_periods: int = 30, big_last_tooth: bool = False, layer_slab: LayerSpec | None = 'SLAB150', slab_xmin: float = -1.0, slab_offset: float = 2.0, spiked: bool = True, cross_section: CrossSectionSpec = 'strip')Component

Grating coupler with parametrization based on Lumerical FDTD simulation.

Parameters

• polarization – te or tm.

• taper_length – taper length from input.

• taper_angle – grating flare angle.

• wavelength – grating transmission central wavelength (um).

• fiber_angle – fibre angle in degrees determines ellipticity.

• grating_line_width – in um.

• neff – tooth effective index.

• nclad – cladding effective index.

• n_periods – number of periods.

• big_last_tooth – adds a big_last_tooth.

• layer_slab – layer that protects the slab under the grating.

• slab_xmin – where 0 is at the start of the taper.

• slab_offset – in um.

• spiked – grating teeth have sharp spikes to avoid non-manhattan drc errors.

• cross_section – specification (CrossSection, string or dict).

          fiber

       /  /  /  /
      /  /  /  /

    _|-|_|-|_|-|___ layer
       layer_slab |
o1  ______________|

import gdsfactory as gf

c = gf.components.grating_coupler_elliptical(polarization='te', taper_length=16.6, taper_angle=40, wavelength=1.554, fiber_angle=15, grating_line_width=0.343, neff=2.638, nclad=1.443, n_periods=30, big_last_tooth=False, layer_slab='SLAB150', slab_xmin=-1, slab_offset=2, spiked=True, cross_section='strip').copy()
c.draw_ports()
c.plot()

gdsfactory.components.grating_couplers.grating_coupler_elliptical_arbitrary(gaps: Floats = (0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1), widths: Floats = (0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5), taper_length: float = 16.6, taper_angle: float = 60.0, wavelength: float = 1.554, fiber_angle: float = 15.0, nclad: float = 1.443, layer_slab: LayerSpec | None = 'SLAB150', layer_grating: LayerSpec | None = None, taper_to_slab_offset: float = -3.0, polarization: str = 'te', spiked: bool = True, bias_gap: float = 0, cross_section: CrossSectionSpec = 'strip')Component

Grating coupler with parametrization based on Lumerical FDTD simulation.

The ellipticity is derived from Lumerical knowledge base it depends on fiber_angle (degrees), neff, and nclad

Parameters

• gaps – list of gaps.

• widths – list of widths.

• taper_length – taper length from input.

• taper_angle – grating flare angle.

• wavelength – grating transmission central wavelength (um).

• fiber_angle – fibre angle in degrees determines ellipticity.

• nclad – cladding effective index to compute ellipticity.

• layer_slab – Optional slab.

• layer_grating – Optional layer for grating. by default None uses cross_section.layer. if different from cross_section.layer expands taper.

• taper_to_slab_offset – 0 is where taper ends.

• polarization – te or tm.

• spiked – grating teeth have spikes to avoid drc errors.

• bias_gap – etch gap (um). Positive bias increases gap and reduces width to keep period constant.

• cross_section – cross_section spec for waveguide port.

Ellipse c = (a1 ** 2 - b1 ** 2) ** 0.5 e = (1 - (b1 / a1) ** 2) ** 0.5 print(e)

          fiber

       /  /  /  /
      /  /  /  /

    _|-|_|-|_|-|___ layer
       layer_slab |
o1  ______________|