qutegds.components package#
Components package.
Submodules#
qutegds.components.chip_layout module#
Components to mark or draw the chip boundaries.
- qutegds.components.chip_layout.centered_chip(center_comp: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | ~gdsfactory.component.Component | dict[str, typing.Any] = <function stripes_array>, size: tuple = (20000.0, 20000.0), layer: tuple[int, int] | str = (2, 0), negative: bool = False, **chip_kwargs) Component[source]#
Return chip with centered component.
- qutegds.components.chip_layout.chip_corners(chip_size: tuple = (20000.0, 20000.0), width: float = 50, layer: tuple[int, int] | str = (1, 0)) Component[source]#
Return chip corners markers.
- qutegds.components.chip_layout.chip_title(title: str = 'TITLE', length: float = 12000.0, width: float = 500, border_left: float = 30, border_top: float = 10, border_title: float = 100) Component[source]#
Return rectangle strip with padded title.
- qutegds.components.chip_layout.square_L(width: float = 1, layer: tuple[int, int] | str = (1, 0)) Component[source]#
Return L shape enclosed by a square.
- qutegds.components.chip_layout.squares_at_corner_chip(center_comp: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | ~gdsfactory.component.Component | dict[str, typing.Any] = <function stripes_array>, size: tuple = (20000.0, 20000.0), square_size: float = 500, layer: tuple[int, int] | str = (2, 0), l_corners=True, **chip_kwargs) Component[source]#
Return chip marked by squares with centered component.
qutegds.components.cpw_base module#
List of coplanar waveguide elements.
- qutegds.components.cpw_base.cpw(component_name: str = 'straight', gap: float = 3, width: float = 6, **kwargs) Component[source]#
Return simple coplanar waveguide from single component.
By default, returns negative mask of the CPW trace.
- qutegds.components.cpw_base.cpw_with_ports(gap: float = 3, width: float = 6, length: float = 1000, straight: ~collections.abc.Callable[[...], ~gdsfactory.component.Component] = <function cpw>, launcher: ~collections.abc.Callable[[...], ~gdsfactory.component.Component] = <function rf_port>) Component[source]#
CPW with ports at extremities.
gap (float): gap of the cpw line width (float): width of the cpw line length (float): length of the cpw line straight (ComponentFactory): cpw component launcher (ComponentFactory): port component
from qutegds import cpw_with_ports c = cpw_with_ports() c.plot()
[32m2025-07-30 09:02:25.629[0m | [33m[1mWARNING [0m | [36mgdsfactory.pdk[0m:[36mactivate[0m:[36m289[0m - [33m[1mUserWarning: base_pdk is deprecated. Use base_pdks instead[0m
- qutegds.components.cpw_base.rf_port(width1: float = 6, width2: float = 350, gap1: float = 3, gap2: float = 70, len_taper: float = 200, len_rect: float = 100, space_pad: float = 10, **kwargs) Component[source]#
Return rf port.
- Parameters:
width1 (float) – width of the connection to the cpw
width2 (float) – width of the port at the beginning
gap1 (float) – gap of the final cpw
gap2 (float) – gap of the bonding pad
len_taper (float) – length of the
len_rect (float) – length of the bonding pad
space_pad (float) – gap at the side of the bonding pad
from qutegds import rf_port c = rf_port() c.plot()
- qutegds.components.cpw_base.snake(*, component_name: str = 'delay_snake', gap: float = 3, width: float = 6, **kwargs) Component#
Return simple coplanar waveguide from single component.
By default, returns negative mask of the CPW trace.
- qutegds.components.cpw_base.straight_taper(straight: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | ~gdsfactory.component.Component | dict[str, typing.Any] = <function straight>, taper: ~collections.abc.Callable[[...], ~gdsfactory.component.Component] = <function taper>) Component[source]#
Return straight section connected with taper.
- Parameters:
straight (ComponentSpec) – straight section of the component
taper (ComponentFactory) – trapezoid section of the component
qutegds.components.resonator module#
resonator module.
- qutegds.components.resonator.resonator(length: float = 400.0, L0: float = 30.0, n: int = 1, width: float = 2, dy: float = 15, dx: float = 40, dc: float = 5, radius: float = 10, p: float = 0.5, bend: str | Callable[[...], Component] | Component | dict[str, Any] = 'bend_euler', cross_section: Callable[[...], CrossSection] | CrossSection | dict[str, Any] | str | Transition = 'xs_sc', **kwargs) Component[source]#
Return a meandering resonator.
- Parameters:
length (float) – Total length of the resonator.
L0 (float) – Length of the straight section.
n (int) – Number of meander loops.
width (float) – Width of the resonator’s line.
dy (float) – Half-distance between bends.
dx (float) – Distance between the coupling section and the first bend.
dc (float) – Length of the final couplng section of the resonator.
radius (float) – Radius of the bends.
p (float) – Parameter controlling the curvature of bends (default is 0.5, 0 is circle).
bend (ComponentSpec) – Type of bend used for the resonator.
cross_section (CrossSectionSpec) – Cross section specification.
**kwargs – Additional keyword arguments for gdsfactory.routing.manhattan.round_corners.
| L0 | L2 | ->-------------| | | 2 * dy |-------------------| | ^ 2 * dy | | dc |------------------------| | | dx |
- qutegds.components.resonator.resonator_array(resonators_attrs: dict[str, list], central_cpw: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | ~gdsfactory.component.Component | dict[str, typing.Any] = <function cpw_with_ports>, spacing: float = 1000.0, shift_x_top_bot: float = 0, distance: float = 5.0, start_x: float | None = None, resonator_indexes: list | None = None, resonator_label: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | ~gdsfactory.component.Component | dict[str, typing.Any] = 'text', labels_y_offset: float | None = None, **resonator_kwargs) Component[source]#
Place alternated resonators along a central CPW line.
- Parameters:
resonators_attrs (Dict[str, List]) – Dictionary with lists of attributes specific to each resonator.
central_cpw (ComponentSpec) – Component representing the central CPW line.
spacing (float) – Spacing between resonators along the central CPW line.
shift_x_top_bot (float) – Shift in placement between resonators above and below the central CPW line.
distance (float) – Distance between the central CPW and resonators coupling termination.
start_x (Optional[float]) – Starting x-coordinate for placing resonators.
resonator_indexes (Optional[list]) – List of indexes for reordering the resonators.
resonator_label (ComponentSpec) – labels for the resonators based on their order indexes.
labels_y_offset (Optional[float]) – add labels at this distance from central CPW if not None.
**resonator_kwargs – additional keyword arguments common to all resonators.
- qutegds.components.resonator.resonator_cpw(width: float = 6.0, gap: float = 3.0, termination_coupler: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | ~gdsfactory.component.Component | dict[str, typing.Any] = <function termination_closed>, termination_end: str | ~collections.abc.Callable[[...], ~gdsfactory.component.Component] | ~gdsfactory.component.Component | dict[str, typing.Any] = <function termination_open>, **resonator_kwargs) Component[source]#
Generate a cpw resonator.
- Parameters:
width (float) – of the cpw.
gap (float) – of the cpw.
termination_coupler (ComponentSpec) – termination to use at the end of the coupling section.
termination_open (ComponentSpec) – termination to use at the end of the resonator.
resonator_kwargs – keyword arguments for qutegds.components.resonator.
- qutegds.components.resonator.termination_closed(width: float = 10, angle_resolution: float = 1, gap: float = 5, layer: tuple[int, int] | str = (1, 0)) Component[source]#
Generate an closed-circuit CPW termination.
qutegds.components.simple_strip module#
Chip with straight stripes for DC characterization.
- qutegds.components.simple_strip.meandering_u_sharp(length: float = 2000.0, size: tuple[float, float] = (400, 100), width: float = 2, layer: tuple[int, int] | str = (1, 0)) Component[source]#
Return meandering U line with sharp turns.
- Parameters:
- Returns:
A gdsfactory component containing the meandering U line.
- Return type:
Component
- Raises:
ValueError – If the provided parameters cannot generate a valid meandering line.
- qutegds.components.simple_strip.strip_with_pads(length: float = 2000.0, width: float = 2, min_pad_size: float = 500, min_pad_buffer: float = 100, annotate_squares: float = 0, **kwargs) Component[source]#
Return straight with square bonding pads and annotated number of squares.
- Parameters:
from qutegds import strip_with_pads c = strip_with_pads() c.plot()
- qutegds.components.simple_strip.stripes_array(stripes: str | Callable[[...], Component] | Component | dict[str, Any] = 'strip_with_pads', target: str = 'width', values: float | list = 1, spacing: float = 2000, centered: bool = True, **kwargs) Component[source]#
Return array of evenly spaced stripes with pads.
- qutegds.components.simple_strip.u_strip_with_pads(length: float = 3000.0, u_length: float = 700, width: float = 2, min_pad_size: float = 200, min_pad_buffer: float = 100, annotate_squares: float = 0, **kwargs) Component[source]#
Return U-shaped strip with square bonding pads on the same side.
- Parameters:
length (float) – Total length of the meandering strip.
width (float) – Width of the central strip.
min_pad_size (float) – Minimum side length of the bonding pads.
min_pad_buffer (float) – Minimum additional width of the pads w.r.t the strip.
u_size (tuple[float, float]) – (max_length, height) of the U shape.
annotate_squares (float) – Size of text to plot number of squares in the central strip (0 for no annotation).
layer (LayerSpec) – Layer specification for the component.
**kwargs – Additional keyword arguments.
- Returns:
A gdsfactory component containing the U-shaped strip with pads.
- Return type:
Component