PCells#
Components are grouped by their tags. Each component is listed once, under
its main category; the badges under each entry show all of its tags.
17 components
25 components
8 components
7 components
3 components
1 component
1 component
8 components
3 components
12 components
1 component
Qubits#
Transmons#
double_pad_transmon#
qubits transmons
- qpdk.cells.double_pad_transmon(pad_size=(250.0, 400.0), pad_gap=15.0, junction_spec=<function squid_junction>, junction_displacement=None, layer_metal=<LayerMapQPDK.M1_DRAW: 1>)[source]#
Creates a double capacitor pad transmon qubit with Josephson junction.
A transmon qubit consists of two capacitor pads connected by a Josephson junction. The junction creates an anharmonic oscillator that can be used as a qubit.
See [KYG+07] for details.
- Parameters:
pad_size (tuple[float, float]) – (width, height) of each capacitor pad in μm.
pad_gap (float) – Gap between the two capacitor pads in μm.
junction_spec (ComponentSpec) – Component specification for the Josephson junction component.
junction_displacement (DCplxTrans | float | None) – Optional complex transformation, or in-place rotation in degrees, to apply to the junction.
layer_metal (LayerSpec) – Layer for the metal pads.
- Returns:
A gdsfactory component with the transmon geometry.
- Return type:
Component
double_pad_transmon_with_bbox#
qubits transmons
- qpdk.cells.double_pad_transmon_with_bbox(bbox_extension=200.0, pad_size=(250.0, 400.0), pad_gap=15.0, junction_spec=<function squid_junction>, junction_displacement=None, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, layer_etch=<LayerMapQPDK.M1_ETCH: 47>)[source]#
Creates a double capacitor pad transmon qubit with Josephson junction and an etched bounding box.
See
double_pad_transmon()for more details.- Parameters:
bbox_extension (float) – Extension size for the bounding box in μm.
pad_size (tuple[float, float]) – (width, height) of each capacitor pad in μm.
pad_gap (float) – Gap between the two capacitor pads in μm.
junction_spec (ComponentSpec) – Component specification for the Josephson junction component.
junction_displacement (DCplxTrans | float | None) – Optional complex transformation, or in-place rotation in degrees, to apply to the junction.
layer_metal (LayerSpec) – Layer for the metal pads.
layer_etch (LayerSpec) – Layer for the etched bounding box.
- Returns:
A gdsfactory component with the transmon geometry and etched box.
- Return type:
Component
double_pad_transmon_with_resonator#
qubits resonators transmons
- qpdk.cells.double_pad_transmon_with_resonator(*, qubit='double_pad_transmon_with_bbox', resonator=functools.partial(<function resonator_quarter_wave>, start_with_bend=True, length=4000, meanders=6), resonator_meander_start=(-900, -1200), resonator_length=5000.0, resonator_meanders=5, resonator_bend_spec='bend_circular', resonator_cross_section='cpw', resonator_open_start=False, resonator_open_end=True, coupler=functools.partial(<function plate_capacitor_single>, width=20, length=394), qubit_rotation=90, coupler_port='left_pad', coupler_offset=(-45, 0))#
Returns a transmon qubit coupled to a quarter wave resonator.
- Parameters:
qubit (ComponentSpec) – Qubit component.
resonator (ComponentSpec) – Resonator component.
resonator_meander_start (tuple[float, float]) – (x, y) position of the start of the resonator meander.
resonator_length (float) – Length of the resonator in µm.
resonator_meanders (int) – Number of meander sections for the resonator.
resonator_bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
resonator_cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
resonator_open_start (bool) – If True, adds an etch section at the start of the resonator.
resonator_open_end (bool) – If True, adds an etch section at the end of the resonator.
coupler (ComponentSpec) – Coupler spec.
qubit_rotation (float) – Rotation angle for the qubit in degrees.
coupler_port (str) – Name of the qubit port to position the coupler relative to.
coupler_offset (tuple[float, float]) – (x, y) offset for the coupler position.
- Return type:
Component
double_pad_transmon_with_resonator_and_probeline#
couplers qubits resonators transmons
- qpdk.cells.double_pad_transmon_with_resonator_and_probeline(*, qubit='double_pad_transmon_with_bbox', resonator=functools.partial(<function resonator_quarter_wave>, start_with_bend=True, length=4000, meanders=6), resonator_meander_start=(-900, -1200), resonator_length=5000.0, resonator_meanders=5, resonator_bend_spec='bend_circular', resonator_cross_section='cpw', resonator_open_start=False, resonator_open_end=True, coupler=functools.partial(<function plate_capacitor_single>, width=20, length=394), qubit_rotation=90, coupler_port='left_pad', coupler_offset=(-45, 0), probeline_coupler=<function coupler_straight>, probeline_coupling_gap=16.0, probeline_coupling_length=None)#
Returns a transmon qubit coupled to a quarter wave resonator and a probeline.
Uses a
coupler_straight()to couple the resonator to a probeline. The coupling section is inserted at the start of the resonator meander, with one waveguide carrying the resonator signal and the other providing ports for probeline routing.- Parameters:
qubit (ComponentSpec) – Qubit component.
resonator (ComponentSpec) – Resonator component.
resonator_meander_start (tuple[float, float]) – (x, y) position of the start of the resonator meander.
resonator_length (float) – Length of the resonator in µm.
resonator_meanders (int) – Number of meander sections for the resonator.
resonator_bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
resonator_cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
resonator_open_start (bool) – If True, adds an etch section at the start of the resonator.
resonator_open_end (bool) – If True, adds an etch section at the end of the resonator.
coupler (ComponentSpec) – Coupler spec.
qubit_rotation (float) – Rotation angle for the qubit in degrees.
coupler_port (str) – Name of the qubit port to position the coupler relative to.
coupler_offset (tuple[float, float]) – (x, y) offset for the coupler position.
probeline_coupler (ComponentSpec) – Component spec for the probeline coupling section.
probeline_coupling_gap (float) – Gap between the resonator and probeline waveguides in the coupling section in µm.
probeline_coupling_length (float | None) – Length of the coupling section in µm.
- Return type:
Component
flipmon#
flip-chip qubits transmons
- qpdk.cells.flipmon(inner_circle_radius=60.0, outer_ring_radius=110.0, outer_ring_width=60.0, top_circle_radius=110.0, junction_spec=<function squid_junction_long>, junction_displacement=None, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, layer_metal_top=<LayerMapQPDK.M2_DRAW: 3>, junction_position_rotation=0.0, bump_diameter=15.0)[source]#
Creates a circular transmon qubit with flipmon geometry.
A circular variant of the transmon qubit with another circle as the inner pad.
See [LWJ+25, LZY+21] for details about the flipmon design.
- Parameters:
inner_circle_radius (float) – Central radius of the inner circular capacitor pad in μm.
outer_ring_radius (float) – Central radius of the outer circular capacitor pad in μm.
outer_ring_width (float) – Width of the outer circular capacitor pad in μm.
top_circle_radius (float) – Central radius of the top circular capacitor pad in μm. There is no separate width as the filled circle is not a ring.
bump_diameter (float) – Diameter of the central indium bump in μm.
junction_spec (ComponentSpec) – Component specification for the Josephson junction component.
junction_displacement (DCplxTrans | float | None) – Optional complex transformation, or in-place rotation in degrees, to apply to the junction.
layer_metal (LayerSpec) – Layer for the metal pads.
layer_metal_top (LayerSpec) – Layer for the other metal layer pad for flip-chip.
junction_position_rotation (float) – Rotation in degrees about the ring center, relocating the junction around the ring.
- Returns:
A gdsfactory component with the circular transmon geometry.
- Return type:
Component
flipmon_with_bbox#
flip-chip qubits transmons
- qpdk.cells.flipmon_with_bbox(inner_circle_radius=60.0, outer_ring_radius=110.0, outer_ring_width=60.0, top_circle_radius=110.0, junction_spec=<function squid_junction_long>, junction_displacement=None, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, layer_metal_top=<LayerMapQPDK.M2_DRAW: 3>, layer_etch=<LayerMapQPDK.M1_ETCH: 47>, layer_etch_top=<LayerMapQPDK.M2_ETCH: 48>, m1_etch_extension_gap=30.0, m2_etch_extension_gap=40.0, junction_position_rotation=0.0, bump_diameter=15.0)[source]#
Creates a circular transmon qubit with flipmon geometry and a circular etched bounding box.
See
flipmon()for more details.- Parameters:
inner_circle_radius (float) – Central radius of the inner circular capacitor pad in μm.
outer_ring_radius (float) – Central radius of the outer circular capacitor pad in μm.
outer_ring_width (float) – Width of the outer circular capacitor pad in μm.
top_circle_radius (float) – Central radius of the top circular capacitor pad in μm.
bump_diameter (float) – Diameter of the central indium bump in μm.
junction_spec (ComponentSpec) – Component specification for the Josephson junction component.
junction_displacement (DCplxTrans | float | None) – Optional complex transformation, or in-place rotation in degrees, to apply to the junction.
layer_metal (LayerSpec) – Layer for the metal pads.
layer_metal_top (LayerSpec) – Layer for the other metal layer pad for flip-chip.
layer_etch (LayerSpec) – Layer for the M1 etched bounding box.
layer_etch_top (LayerSpec) – Layer for the M2 etched bounding box.
m1_etch_extension_gap (float) – Radius extension length for the M1 etch bounding box in μm.
m2_etch_extension_gap (float) – Radius extension length for the M2 etch bounding box in μm.
junction_position_rotation (float) – Rotation in degrees about the ring center, relocating the junction around the ring.
- Returns:
A gdsfactory component with the flipmon geometry and etched box.
- Return type:
Component
flipmon_with_resonator#
qubits resonators transmons
- qpdk.cells.flipmon_with_resonator(*, qubit='flipmon_with_bbox', resonator=functools.partial(<function resonator_quarter_wave>, start_with_bend=True, length=4000, meanders=6), resonator_meander_start=(-900, -1200), resonator_length=5000.0, resonator_meanders=5, resonator_bend_spec='bend_circular', resonator_cross_section='cpw', resonator_open_start=False, resonator_open_end=True, coupler=functools.partial(<function plate_capacitor_single>, width=10, length=58), qubit_rotation=-90, coupler_port='outer_ring_outside', coupler_offset=(-10, 0))#
Returns a transmon qubit coupled to a quarter wave resonator.
- Parameters:
qubit (ComponentSpec) – Qubit component.
resonator (ComponentSpec) – Resonator component.
resonator_meander_start (tuple[float, float]) – (x, y) position of the start of the resonator meander.
resonator_length (float) – Length of the resonator in µm.
resonator_meanders (int) – Number of meander sections for the resonator.
resonator_bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
resonator_cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
resonator_open_start (bool) – If True, adds an etch section at the start of the resonator.
resonator_open_end (bool) – If True, adds an etch section at the end of the resonator.
coupler (ComponentSpec) – Coupler spec.
qubit_rotation (float) – Rotation angle for the qubit in degrees.
coupler_port (str) – Name of the qubit port to position the coupler relative to.
coupler_offset (tuple[float, float]) – (x, y) offset for the coupler position.
- Return type:
Component
flipmon_with_resonator_and_probeline#
couplers qubits resonators transmons
- qpdk.cells.flipmon_with_resonator_and_probeline(*, qubit=functools.partial(<function flipmon_with_bbox>, junction_position_rotation=180), resonator=functools.partial(<function resonator_quarter_wave>, start_with_bend=True, length=4000, meanders=6), resonator_meander_start=(-900, -1200), resonator_length=5000.0, resonator_meanders=5, resonator_bend_spec='bend_circular', resonator_cross_section='cpw', resonator_open_start=False, resonator_open_end=True, coupler=functools.partial(<function plate_capacitor_single>, width=10, length=58), qubit_rotation=-90, coupler_port='outer_ring_outside', coupler_offset=(-10, 0), probeline_coupler=<function coupler_straight>, probeline_coupling_gap=16.0, probeline_coupling_length=None)#
Returns a transmon qubit coupled to a quarter wave resonator and a probeline.
Uses a
coupler_straight()to couple the resonator to a probeline. The coupling section is inserted at the start of the resonator meander, with one waveguide carrying the resonator signal and the other providing ports for probeline routing.- Parameters:
qubit (ComponentSpec) – Qubit component.
resonator (ComponentSpec) – Resonator component.
resonator_meander_start (tuple[float, float]) – (x, y) position of the start of the resonator meander.
resonator_length (float) – Length of the resonator in µm.
resonator_meanders (int) – Number of meander sections for the resonator.
resonator_bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
resonator_cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
resonator_open_start (bool) – If True, adds an etch section at the start of the resonator.
resonator_open_end (bool) – If True, adds an etch section at the end of the resonator.
coupler (ComponentSpec) – Coupler spec.
qubit_rotation (float) – Rotation angle for the qubit in degrees.
coupler_port (str) – Name of the qubit port to position the coupler relative to.
coupler_offset (tuple[float, float]) – (x, y) offset for the coupler position.
probeline_coupler (ComponentSpec) – Component spec for the probeline coupling section.
probeline_coupling_gap (float) – Gap between the resonator and probeline waveguides in the coupling section in µm.
probeline_coupling_length (float | None) – Length of the coupling section in µm.
- Return type:
Component
transmon_with_resonator#
qubits resonators transmons
- qpdk.cells.transmon_with_resonator(qubit='double_pad_transmon_with_bbox', resonator=functools.partial(<function resonator_quarter_wave>, start_with_bend=True, length=4000, meanders=6), resonator_meander_start=(-900, -1200), resonator_length=5000.0, resonator_meanders=5, resonator_bend_spec='bend_circular', resonator_cross_section='cpw', resonator_open_start=False, resonator_open_end=True, coupler=functools.partial(<function plate_capacitor_single>, width=20, length=394), qubit_rotation=90, coupler_port='left_pad', coupler_offset=(-45, 0))[source]#
Returns a transmon qubit coupled to a quarter wave resonator.
- Parameters:
qubit (ComponentSpec) – Qubit component.
resonator (ComponentSpec) – Resonator component.
resonator_meander_start (tuple[float, float]) – (x, y) position of the start of the resonator meander.
resonator_length (float) – Length of the resonator in µm.
resonator_meanders (int) – Number of meander sections for the resonator.
resonator_bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
resonator_cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
resonator_open_start (bool) – If True, adds an etch section at the start of the resonator.
resonator_open_end (bool) – If True, adds an etch section at the end of the resonator.
coupler (ComponentSpec) – Coupler spec.
qubit_rotation (float) – Rotation angle for the qubit in degrees.
coupler_port (str) – Name of the qubit port to position the coupler relative to.
coupler_offset (tuple[float, float]) – (x, y) offset for the coupler position.
- Return type:
transmon_with_resonator_and_probeline#
couplers qubits resonators transmons
- qpdk.cells.transmon_with_resonator_and_probeline(qubit='double_pad_transmon_with_bbox', resonator=functools.partial(<function resonator_quarter_wave>, start_with_bend=True, length=4000, meanders=6), resonator_meander_start=(-900, -1200), resonator_length=5000.0, resonator_meanders=5, resonator_bend_spec='bend_circular', resonator_cross_section='cpw', resonator_open_start=False, resonator_open_end=True, coupler=functools.partial(<function plate_capacitor_single>, width=20, length=394), qubit_rotation=90, coupler_port='left_pad', coupler_offset=(-45, 0), probeline_coupler=<function coupler_straight>, probeline_coupling_gap=16.0, probeline_coupling_length=None)[source]#
Returns a transmon qubit coupled to a quarter wave resonator and a probeline.
Uses a
coupler_straight()to couple the resonator to a probeline. The coupling section is inserted at the start of the resonator meander, with one waveguide carrying the resonator signal and the other providing ports for probeline routing.- Parameters:
qubit (ComponentSpec) – Qubit component.
resonator (ComponentSpec) – Resonator component.
resonator_meander_start (tuple[float, float]) – (x, y) position of the start of the resonator meander.
resonator_length (float) – Length of the resonator in µm.
resonator_meanders (int) – Number of meander sections for the resonator.
resonator_bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
resonator_cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
resonator_open_start (bool) – If True, adds an etch section at the start of the resonator.
resonator_open_end (bool) – If True, adds an etch section at the end of the resonator.
coupler (ComponentSpec) – Coupler spec.
qubit_rotation (float) – Rotation angle for the qubit in degrees.
coupler_port (str) – Name of the qubit port to position the coupler relative to.
coupler_offset (tuple[float, float]) – (x, y) offset for the coupler position.
probeline_coupler (ComponentSpec) – Component spec for the probeline coupling section.
probeline_coupling_gap (float) – Gap between the resonator and probeline waveguides in the coupling section in µm.
probeline_coupling_length (float | None) – Length of the coupling section in µm.
- Return type:
xmon_transmon#
qubits transmons
- qpdk.cells.xmon_transmon(arm_width=(30.0, 20.0, 30.0, 20.0), arm_lengths=(160.0, 120.0, 160.0, 120.0), gap_width=10.0, junction_spec=<function squid_junction>, junction_displacement=None, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, layer_etch=<LayerMapQPDK.M1_ETCH: 47>)[source]#
Creates an Xmon style transmon qubit with cross-shaped geometry.
An Xmon transmon consists of a cross-shaped capacitor pad with four arms extending from a central region, connected by a Josephson junction at the center. The design provides better control over the coupling to readout resonators and neighboring qubits through the individual arm geometries.
See [BKM+13] for details about the Xmon design.
- Parameters:
arm_width (tuple[float, float, float, float]) – Tuple of (top, right, bottom, left) arm widths in μm.
arm_lengths (tuple[float, float, float, float]) – Tuple of (top, right, bottom, left) arm lengths in μm. Computed from center to end of each arm.
gap_width (float) – Width of the etched gap around arms in μm.
junction_spec (ComponentSpec) – Component specification for the Josephson junction component.
junction_displacement (DCplxTrans | float | None) – Optional complex transformation, or in-place rotation in degrees, to apply to the junction.
layer_metal (LayerSpec) – Layer for the metal pads.
layer_etch (LayerSpec) – Layer for the etched regions.
- Returns:
A gdsfactory component with the Xmon transmon geometry.
- Return type:
Component
Other Qubits#
fluxonium#
inductors qubits
- qpdk.cells.fluxonium(pad_size=(250.0, 400.0), pad_gap=25.0, junction_spec=<function josephson_junction>, junction_displacement=None, junction_margin=1.0, inductor_n_turns=155, inductor_margin_x=1.0, inductor_cross_section=<function superinductor_cross_section>, connection_wire_width=2.0, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, inductor='meander', inductor_array_spec=<function josephson_junction_array>)[source]#
Creates a fluxonium qubit with capacitor pads, Josephson junction, and superinductor.
- Parameters:
pad_size (tuple[float, float]) – (width, height) of each capacitor pad in µm.
pad_gap (float) – Gap between the two capacitor pads in µm.
junction_spec (ComponentSpec) – Component specification for the Josephson junction.
junction_displacement (DCplxTrans | None) – Optional transformation applied to the junction.
junction_margin (float) – Vertical margin between the junction and capacitor pads in µm.
inductor_n_turns (int) – Number of horizontal meander runs. Must be odd.
inductor_margin_x (float) – Horizontal margin for the inductor in µm.
inductor_cross_section (CrossSectionSpec) – Cross-section for the meander inductor.
connection_wire_width (float) – Width of the connecting wires in µm.
layer_metal (LayerSpec) – Layer for the metal pads and connection wires.
inductor (Literal['meander', 'array']) – Superinductor implementation.
"meander"draws a kinetic-inductance meander."array"draws a Josephson junction array frominductor_array_specinstead, as in [MKGD09].inductor_array_spec (ComponentSpec) – Component specification for the junction array, used when
inductor="array". Its porto1must face west ando2east, i.e. an even number of folds. The metal wires overlap half of the array’slead_length(0.5 µm if it has none), so they never reach the end islands.
- Returns:
The fluxonium component.
- Raises:
ValueError – If inductor_n_turns is even, if pad_gap is too small, or if the junction array does not fit between the pads.
- Return type:
fluxonium_with_bbox#
inductors qubits
- qpdk.cells.fluxonium_with_bbox(bbox_extension=200.0, pad_size=(250.0, 400.0), pad_gap=25.0, junction_spec=<function josephson_junction>, junction_displacement=None, junction_margin=1.0, inductor_n_turns=155, inductor_margin_x=1.0, inductor_cross_section=<function superinductor_cross_section>, connection_wire_width=2.0, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, inductor='meander', inductor_array_spec=<function josephson_junction_array>)[source]#
Fluxonium with an etched bounding box.
- Parameters:
bbox_extension (float) – Extension of the bounding box from the fluxonium edge in µm.
pad_size (tuple[float, float]) – (width, height) of each capacitor pad in µm.
pad_gap (float) – Gap between the two capacitor pads in µm.
junction_spec (ComponentSpec) – Component specification for the Josephson junction.
junction_displacement (DCplxTrans | None) – Optional transformation applied to the junction.
junction_margin (float) – Vertical margin between the junction and capacitor pads in µm.
inductor_n_turns (int) – Number of horizontal meander runs. Must be odd.
inductor_margin_x (float) – Horizontal margin for the inductor in µm.
inductor_cross_section (CrossSectionSpec) – Cross-section for the meander inductor.
connection_wire_width (float) – Width of the connecting wires in µm.
layer_metal (LayerSpec) – Layer for the metal pads and connection wires.
inductor (Literal['meander', 'array']) – Superinductor implementation.
"meander"draws a kinetic-inductance meander."array"draws a Josephson junction array frominductor_array_specinstead, as in [MKGD09].inductor_array_spec (ComponentSpec) – Component specification for the junction array, used when
inductor="array". Its porto1must face west ando2east, i.e. an even number of folds.
- Returns:
The fluxonium component with a bounding box.
- Return type:
gatemon#
qubits
- qpdk.cells.gatemon(island_size=(150.0, 150.0), pocket_gap=60.0, pocket_gap_top=40.0, electrode_size=(60.0, 60.0), electrode_spacing=100.0, lead_width=2.0, junction_length=1.0, junction_width=0.002, junction_offset=20.0, nanotube_contact_overlap=0.5, hbn_size=(80.0, 80.0), size_patch=(60.0, 50.0), electrode_offset=-40.0, gate_offset=100.0, gate_tip_width=16.0, gate_tip_gap=5.0, gate_length=50.0, gate_cross_section='cpw', layer_metal=<LayerMapQPDK.M1_DRAW: 1>, layer_etch=<LayerMapQPDK.M1_ETCH: 47>)[source]#
Create a gatemon with contact pads, rectangular hBN and a boxy top gate.
The upper Nb/Au pad overlaps the island and its lower counterpart overlaps ground. Thin contact stems approach each other beneath the island’s left half, then branch right to the nanotube. The top gate has a rectangular tip over the weak link and a right-angle elbow onto exposed M1. A rectangular hBN footprint encloses the tube and insulates every gate/contact overlap. Al reconnection pads overlap the Nb/Au and M1 pads.
The contact proportions follow Fig. 1b of [RAP+25], with idealized rectangular hBN and gate geometry. Register the actual flake and nanotube positions before fabrication.
CNTis a native GDS placement path of nominal width, with overlap onto both contacts. The weak link belongs in the circuit model and is excluded from the PEC extrusions inqpdk.tech.LAYER_STACK_GATEMON.- Parameters:
island_size (tuple[float, float]) – Island (width, height) in µm.
pocket_gap (float) – Gap between the island and the pocket side walls in µm.
pocket_gap_top (float) – Gap from the island to the readout side of the pocket in µm.
electrode_size (tuple[float, float]) – Nb/Au landing-pad (width, height) in µm.
electrode_spacing (float) – Gap between the two landing pads in µm.
lead_width (float) – Width of the Nb/Au stems and contact branches in µm.
junction_length (float) – Gap between the contact tips in µm.
junction_width (float) – Width of the nanotube placement trace in µm.
junction_offset (float) – Horizontal distance from the stems to the weak link in µm.
nanotube_contact_overlap (float) – Tube overlap onto each contact tip in µm.
hbn_size (tuple[float, float]) – Rectangular hBN footprint (width, height) in µm.
size_patch (tuple[float, float]) – Al contact-reconnection pad (width, height) in µm.
electrode_offset (float) – Horizontal position of the contact stems relative to the island.
gate_offset (float) – Horizontal distance from the stems to the M1 gate feed in µm.
gate_tip_width (float) – Width of the top-gate tip and neck in µm.
gate_tip_gap (float) – Lateral clearance from hBN to the M1 gate landing in µm.
gate_length (float) – M1 gate-feed length beyond the pocket in µm.
gate_cross_section (CrossSectionSpec) – Cross-section of the gate feed at the cell boundary.
layer_metal (LayerSpec) – Layer for M1 metal.
layer_etch (LayerSpec) – Layer for the etched pocket.
- Returns:
Gatemon with readout, gate and junction placement ports.
- Raises:
ValueError – If dimensions are invalid, pads or gate leave the pocket, the nanotube is exposed, or a gate/contact overlap lacks hBN.
- Return type:
unimon#
qubits
- qpdk.cells.unimon(arm_length=3000.0, arm_meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', junction_spec=functools.partial(<function squid_junction>, junction_spec=functools.partial(<function josephson_junction>, junction_overlap_displacement=1.8, wide_straight_length=4.0, narrow_straight_length=0.5, taper_length=4)), junction_gap=10.0, junction_etch_width=22.0)[source]#
Creates a unimon qubit from two grounded \(\lambda/4\) CPW resonator arms connected by a SQUID junction.
The unimon is a superconducting qubit consisting of a single Josephson junction (or SQUID for flux tunability) embedded in the center of a two grounded \(\lambda/4\) CPW resonators, providing a large geometric inductance that, together with the Josephson nonlinearity, yields high anharmonicity and resilience to charge noise.
See [HKC+22, TVT+24] for details.
- Parameters:
arm_length (float) – Length of each \(\lambda/4\) resonator arm in µm.
arm_meanders (int) – Number of meander sections in each arm.
bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
cross_section (CrossSectionSpec) – Cross-section specification for the resonator arms.
junction_spec (ComponentSpec) – Component specification for the junction (SQUID) component.
junction_gap (float) – Length of the etched gap on which the junction sits in µm.
junction_etch_width (float) – Width of the etched region where the junction sits in µm.
- Returns:
A gdsfactory component with the unimon qubit geometry.
- Return type:
Component
unimon_arm#
qubits resonators
- qpdk.cells.unimon_arm(arm_length=3000.0, arm_meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', junction_gap=6.0)[source]#
Creates a quarter-wave resonator arm for the unimon qubit.
- Parameters:
arm_length (float) – Length of the resonator arm in µm.
arm_meanders (int) – Number of meanders in the arm.
bend_spec (ComponentSpec) – Specification for the bend component.
cross_section (CrossSectionSpec) – Cross-section specification for the arm.
junction_gap (float) – Gap for the junction in µm.
- Returns:
The quarter-wave resonator arm component.
- Return type:
Component
unimon_coupled#
couplers qubits
- qpdk.cells.unimon_coupled(arm_length=3000.0, arm_meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', junction_spec=functools.partial(<function squid_junction>, junction_spec=functools.partial(<function josephson_junction>, junction_overlap_displacement=1.8, wide_straight_length=4.0, narrow_straight_length=0.5, taper_length=4)), junction_gap=6.0, junction_etch_width=22.0, coupling_gap=30.0, coupling_angle=180.0, coupling_extension_length=50.0, cross_section_non_resonator='cpw')[source]#
Creates a unimon qubit with a half-circle coupling waveguide for readout.
This component combines a
unimon()qubit with a half-circle coupler placed at a specified gap for proximity coupling to a readout resonator.
- Parameters:
arm_length (float) – Length of each \(\lambda/4\) resonator arm in µm.
arm_meanders (int) – Number of meander sections in each arm.
bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
cross_section (CrossSectionSpec) – Cross-section specification for the resonator arms.
junction_spec (ComponentSpec) – Component specification for the junction (SQUID) component.
junction_gap (float) – Length of the etched gap on which the junction sits in µm.
junction_etch_width (float) – Width of the etched region where the junction sits in µm.
coupling_gap (float) – Edge-to-edge gap between M1_DRAW centre conductors of the unimon resonator and the coupling waveguide in µm. The coupling radius is automatically computed as
meander_radius + coupling_gap + width_resonator/2 + width_coupler/2to ensure a uniform gap across the bend.coupling_angle (float) – Angle of the circular arc in degrees.
coupling_extension_length (float) – Length of the straight sections extending from the ends of the half-circle in μm.
cross_section_non_resonator (CrossSectionSpec) – Cross-section for the coupling waveguide.
- Returns:
A gdsfactory component with the unimon and half-circle coupler.
- Return type:
Component
Resonators#
cpw_jpa#
junctions resonators
- qpdk.cells.cpw_jpa(length=4680.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', coupling_capacitor_spec=functools.partial(<function interdigital_capacitor>, fingers=8, finger_length=50.0), termination_spec=<function squid_termination>, pump_length=200.0, pump_gap=2.0, pump_offset=20.0)[source]#
Flux-driven \(\lambda/4\) CPW Josephson parametric amplifier.
The signal port
o1couples throughcoupling_capacitor_specinto a meandered \(\lambda/4\) resonator. The resonator ends intermination_spec, which shorts it to ground through a DC SQUID. The pump lineo2is a shorted CPW that runs perpendicular to the resonator, past the ground side of the SQUID, as in the WMI devices of [PFZ+17]. Only apump_gapwide strip of ground plane separates the pump slot from the ground-side SQUID contacts, and the short sitspump_offsetbeyond the SQUID. The pump current and its return through that strip couple to the SQUID loop through a mutual inductance \(M\) [LIK+14, YIW+08]. The pump-to-loop distance is not reported in these sources, sopump_gapandpump_offsetare design variables. The SAX models do not include \(M\); it has to be extracted by EM simulation. The static flux bias comes from an off-chip coil.With the SQUID inductance \(L_\text{s}\) the resonance is [YIW+08]:
\[\omega_\text{r}(\Phi) \approx \frac{\omega_{\lambda/4}}{1 + L_\text{s}(\Phi) / L_\text{r}}, \qquad L_\text{s}(\Phi) = \frac{\Phi_0}{2 \pi I_\text{c,tot} |\cos(\pi \Phi / \Phi_0)|},\]where \(L_\text{r}\) is the total inductance of the \(\lambda/4\) line. The default coupling capacitor is about \(28\,\text{fF}\), close to the \(30\,\text{fF}\) of the WMI devices with \(Q_\text{ext} \approx 300\) [PFZ+17]. With the default \(I_\text{c,tot} = 4.8\,\text{µA}\) of
squid_termination(), the SAX model of the default layout resonates at \(6.07\,\text{GHz}\) at zero flux and \(5.93\,\text{GHz}\) at \(0.3\,\Phi_0\), with \(Q_\text{ext} \approx 290\).
- Parameters:
length (float) – Realized \(\lambda/4\) line length in µm, from the coupling capacitor to the SQUID pocket. Includes the termination’s CPW lead.
meanders (int) – Number of meander sections.
bend_spec (ComponentSpec) – Specification for the meander bends.
cross_section (CrossSectionSpec) – Cross-section of the resonator, the pump line, the coupling capacitor and the termination lead.
coupling_capacitor_spec (ComponentSpec) – Two-port coupling capacitor between
o1and the open end of the resonator.termination_spec (ComponentSpec) – One-port SQUID termination, see
squid_termination(). It must provide asquidport and thelength,pocket_widthandloop_areainfo entries.pump_length (float) – Length of the pump CPW line in µm.
pump_gap (float) – Width in µm of the ground-plane strip between the ground-side SQUID contacts and the pump line slot.
pump_offset (float) – Distance in µm from the SQUID centre to the pump short, along the pump line, so the pump runs past the whole SQUID.
- Returns:
The JPA with signal port
o1and pump porto2.- Return type:
Component
- Raises:
ValueError – If
lengthdoes not exceed the termination lead length.
drum_lc_resonator#
capacitors couplers inductors resonators
- qpdk.cells.drum_lc_resonator(radius=7.5, support='rim', n_turns=75, turn_length=300.0, inductor_cross_section='meander_inductor_cross_section', coupling_gap=6.0, coupling_pad_size=20.0, margin=10.0, cross_section='cpw')[source]#
Creates a drum LC resonator side-coupled to a CPW feedline.
A meander inductor is shunted to ground by a
vacuum_gap_capacitor()at its open end, forming the mechanically compliant LC circuit of [PDamskaggB+15]. The resonator couples capacitively to the feedline through a pad atcoupling_gapfrom the centre conductor, after the capacitively coupled drum cavities of [OKDamskaggP+16]. The bottom electrode is the hot node and the membrane is grounded through the drum ring.![o1 =================================== o2 feedline [pad] +------------+--+ | meander L +--(drum)--GND +------------+ GND](_images/svgbob-8d4e1f123b3628f66f5f16ff5e1f63c1f2cbe413.svg)
![o1 =================================== o2 feedline [pad] +------------+--+ | meander L +--(drum)--GND +------------+ GND](_images/svgbob-8d4e1f123b3628f66f5f16ff5e1f63c1f2cbe413_dark.svg)
The etched window sits below the feedline’s lower ground plane, which is kept intact except for a notch around the pad. The notch leaves
coupling_gapof clearance to the ground on the sides of the pad.The resonance is \(\omega_\text{r} = 1/\sqrt{L (C_\text{d} + C_\text{p} + C_\text{c})}\) in the lumped model, see
qpdk.models.drum.drum_lc_resonator(), which also lists what that model leaves out. The default meander is about 23 mm of wire, a substantial fraction of a guided wavelength near 7 GHz on silicon, so this layout is not a lumped inductor there and its real resonances differ from that model. Simulate the layout before relying on its frequency.- Parameters:
radius (float) – Drum bottom-electrode radius in µm.
support (Literal['rim', 'legs']) – How the drum membrane is held,
"rim"or"legs".n_turns (int) – Number of meander inductor runs. Must be odd. The default gives about 14 nH, the inductance of [PDamskaggB+15].
turn_length (float) – Length of each meander run in µm.
inductor_cross_section (CrossSectionSpec) – Cross-section of the meander wire, the drum leads and the internal wiring.
coupling_gap (float) – Gap between the coupling pad and the feedline centre conductor in µm.
coupling_pad_size (float) – Side length of the square coupling pad in µm.
margin (float) – Spacing in µm between the pad, inductor, drum and the edge of the etched window.
cross_section (CrossSectionSpec) – Cross-section of the feedline.
- Returns:
The resonator with feedline ports
o1ando2.- Return type:
Component
- Raises:
ValueError – If
n_turnsis even or a spacing is not positive.
esr_lc_resonator#
capacitors inductors resonators
- qpdk.cells.esr_lc_resonator(wire_width=5.0, wire_length=730.0, fingers=12, finger_length=800.0, finger_gap=50.0, finger_thickness=50.0, coupling_gap=50.0, ground_gap=50.0, feedline_length=2000.0, cross_section='cpw')[source]#
Planar LC resonator for inductive-detection electron spin resonance.
A floating
interdigital_capacitor()whose two electrodes are bridged by a short, narrow wire that forms the inductance. The microwave magnetic field is concentrated around the wire, where the spins sit [BPK+16, RPA+20].The capacitor is rotated so that its bus bars run parallel to a CPW feedline. The upper bus bar sits
coupling_gapbelow the feedline centre conductor and couples to it capacitively. Both bus bars extend to the right past the last finger to a rail, onefinger_gapaway, that joins them: a lead as wide as a finger runs from each bus bar towards the middle of the rail, and the wire spans the remainingwire_lengthbetween the two leads. Neither electrode touches the ground plane, so the resonator couples to ground only through its stray capacitances:
As in [RPA+20], the wire sits midway between the two electrodes. Both references float the resonator in a 3D cavity and drive it with antennas; here it is coupled to an on-chip CPW instead.
info["wire_squares"]iswire_length / wire_width.info["mode_volume"]isqpdk.models.esr.esr_mode_volume()in µm³ (1 µm³ = 1 fL), evaluated with the geometric inductance of the wire alone for aESR_FILM_THICKNESSfilm. That counts only the field energy of the wire, so the stray inductance of the leads and the capacitor electrodes is excluded. The matching SAX model isqpdk.models.esr_lc_resonator().- Parameters:
wire_width (float) – Wire width in µm, between 0.1 and 5.
wire_length (float) – Wire length in µm, at most
finger_length + finger_gap, the span between the bus bars.fingers (int) – Number of capacitor fingers (at least 2).
finger_length (float) – Length of each capacitor finger in µm.
finger_gap (float) – Gap between adjacent capacitor fingers, and between the last finger and the rail, in µm.
finger_thickness (float) – Width of each capacitor finger, of the bus bars and of the leads in µm.
coupling_gap (float) – Gap between the feedline centre conductor and the upper bus bar in µm.
ground_gap (float) – Gap between the resonator and the surrounding ground plane in µm.
feedline_length (float) – Length of the feedline in µm.
cross_section (CrossSectionSpec) – Cross-section of the feedline.
- Returns:
Component with feedline ports
o1ando2.- Raises:
ValueError – If the wire width is out of range,
fingersis below 2, a length is not positive, the wire is wider than a lead or longer than the span between the bus bars, the bus-bar length is off the 2 nm grid, or the feedline is shorter than the etch window.- Return type:
hyperbolic_edge_resonator#
resonators
- qpdk.cells.hyperbolic_edge_resonator(length=4000.0, end=(1000.0, 0.0), start_angle=0.0, end_angle=0.0, region=None, bend_radius=30.0, margin=25.0, end_straight=70.0, cross_section='cpw')[source]#
Return a meandered CPW resonator of exact length between two points.
The resonator starts at port
o1at the origin travelling alongstart_angleand ends at porto2atendtravelling alongend_angle, so both ends can meet couplers at arbitrary angles. In between it meanders with legs perpendicular to the line between its two end straights,2 bend_radiusapart and joined by U-turns as inresonator(), alternating sides and staying at leastmarginfrom the edges of the convexregion. The leg height is solved so the centreline length equalslength;info["length"]holds the extruded length.Both ends are left as plain CPW ends: in
hyperbolic_lattice()they connect galvanically to coupler pins, which set the open-end boundary condition.- Parameters:
length (float) – Centreline length in µm.
end (tuple[float, float]) – Position of
o2relative too1in µm.start_angle (float) – Travel direction at
o1in degrees.end_angle (float) – Travel direction at
o2in degrees.region (Sequence[tuple[float, float]] | None) – Convex polygon the meander must stay inside, relative to
o1. Defaults to a square witho1andendon a diagonal.bend_radius (float) – Radius of the meander bends in µm; the legs are twice this apart.
margin (float) – Minimum distance from the centreline to the
regionedge in µm.end_straight (float) – Straight run at each end before the first bend in µm.
cross_section (CrossSectionSpec) – CPW cross-section.
- Returns:
Component with ports
o1ando2.- Raises:
ValueError – If
regioncannot hold a resonator of this length.- Return type:
hyperbolic_lattice#
chips lattices resonators
- qpdk.cells.hyperbolic_lattice(p=7, q=3, shells=1, disk_radius=6000.0, resonator_length=7500.0, stub_length=400.0, probe_pins=(11, 0), pin_radius=40.0, pin_gap=4.0, ground_gap=6.0, lead_length=20.0, bend_radius=30.0, margin=25.0, boundary_apex=0.6, feed_length=1000.0, cross_section='cpw')[source]#
Return a Kollár-type hyperbolic lattice of CPW edge resonators.
Every edge of the {p,q} tiling from
qpdk.hyperbolic.hyperbolic_tiling()carries ahyperbolic_edge_resonator()and every vertex ahyperbolic_vertex_coupler()[KollarFH19]. The line between two pin rims isresonator_lengthlong, so the couplers’ leads count towards it. In full-wave operation the lattice realises line-graph tight binding with \(t < 0\) and a flat band at \(\omega_0 - 2|t|\); for \(q > 3\) only approximately, since the coupler disk couples only neighbouring pins.Free coupler pins on the boundary get a shorted CPW stub of
stub_length(a \(\lambda/4\) resonator far above the band), so boundary resonators see the same end loading as interior ones. The free pins listed inprobe_pinsinstead route to launchers, exposed as portso1,o2, … in that order.Each resonator meanders inside the quadrilateral of its two vertices and the centroids of the two adjacent faces. A boundary edge has only one face; its outer apex is that centroid mirrored across the edge and pulled in by
boundary_apexand clipped to the bisector with each neighbouring boundary edge.The defaults fit {7,3} and {5,4} with one shell. More shells or larger
pneed a largerdisk_radius(two shells of {7,3} fit at 12000 µm), and the defaultprobe_pinsneed at least 12 free pins.Simulate the lattice with
qpdk.models.hyperbolic.hyperbolic_lattice(); a SAX circuit built from the netlist is too large to compile.- Parameters:
p (int) – Polygon side count of the tiling.
q (int) – Polygons per vertex, i.e. coupler pins.
shells (int) – Polygon rings around the central polygon.
disk_radius (float) – Radius of the Poincaré disk on the chip in µm.
resonator_length (float) – Pin-rim to pin-rim length of each edge resonator in µm.
stub_length (float) – Pin-rim to short length of each boundary stub in µm.
probe_pins (Sequence[int]) – Indices into
qpdk.hyperbolic.HyperbolicTiling.free_pinsrouted to launchers.pin_radius (float) – Coupler disk radius in µm.
pin_gap (float) – Coupler radial gap in µm.
ground_gap (float) – Coupler ground clearance in µm.
lead_length (float) – Coupler lead length in µm.
bend_radius (float) – Meander bend radius in µm; the legs are twice this apart.
margin (float) – Minimum distance from a resonator centreline to its region edge in µm.
boundary_apex (float) – Scale of the mirrored outer apex of boundary edges.
feed_length (float) – Straight run from a probe pin before turning to its launcher in µm.
cross_section (CrossSectionSpec) – CPW cross-section.
- Returns:
Component with one port per probe pin.
- Raises:
ValueError – If
probe_pinsis invalid or a resonator does not fit.- Return type:
lumped_element_resonator#
capacitors inductors resonators
- qpdk.cells.lumped_element_resonator(fingers=20, finger_length=20.0, finger_gap=2.0, finger_thickness=5.0, n_turns=15, bus_bar_spacing=4.0, cross_section=<function meander_inductor_cross_section>, etch_bbox_margin=2.0)[source]#
Creates a lumped-element resonator combining an interdigital capacitor and a meander inductor.
The resonator consists of an interdigital capacitor section (providing capacitance) connected in parallel with a meander inductor section (providing inductance) via shared bus bars. The resonance frequency is:
\[f_\text{r} = \frac{1}{2\pi\sqrt{LC}}\]
Similar structures are described in [CSD+23, KVH+11].
- Parameters:
fingers (int) – Number of interdigital capacitor fingers.
finger_length (float) – Length of each capacitor finger in µm.
finger_gap (float) – Gap between adjacent capacitor fingers in µm.
finger_thickness (float) – Width of each capacitor finger and bus bar in µm.
n_turns (int) – Number of horizontal meander inductor runs.
bus_bar_spacing (float) – Vertical spacing between the capacitor and inductor sections in µm.
cross_section (CrossSectionSpec) – Cross-section specification for the inductor and ports.
etch_bbox_margin (float) – Margin around the structure for the etch region in µm.
- Returns:
- A gdsfactory component with the lumped-element resonator
geometry and two ports (‘o1’ and ‘o2’).
- Return type:
Component
- Raises:
ValueError – If n_turns is even, bus_bar_spacing <= 0, or if the resultant meander run length is non-positive.
nanowire_resonator#
inductors resonators
- qpdk.cells.nanowire_resonator(wire_width=0.1, wire_length=40.0, n_turns=1, wire_gap=None, lead_length=None, corner_style='sharp', radius=None, pad_width=300.0, pad_height=150.0, pad_ground_gap=50.0, coupling_gap=4.0, contact_overlap=2.0, feedline_length=500.0, cross_section='cpw', wire_layer=<LayerMapQPDK.NbTiN: 18>)[source]#
Creates a lumped resonator from a high-kinetic-inductance nanowire.
A nanowire on
wire_layerjoins two capacitor pads. The upper pad sitscoupling_gapbelow the centre conductor of a CPW feedline and couples to it capacitively. The lower pad is tied to the ground plane along its bottom edge, so the resonator is a parallel LC to ground, shunt-coupled to the feedline:
The wire is straight for
n_turns=1, or ameander_inductor()with vertical runs of lengthwire_lengthotherwise, son_turnsmust be odd for the wire to end on the opposite pad. The meander sitslead_lengthaway from both pads and joins each pad through one straight lead from its end run, so the wire contacts each pad once and the U-turns stay clear of the metal.info["n_squares"]is the drawn square count between the pad edges:qpdk.tech.meander_n_squares_drawn()for the meander pluslead_length / wire_widthfor each lead. Thecontact_overlapstubs under the pads are not counted.Design references for the nanowire geometry and its kinetic inductance are [JCL+22, MGK+18]. The matching SAX model is
qpdk.models.nanowire_resonator().- Parameters:
wire_width (float) – Nanowire width in µm, between 0.05 and 1.
wire_length (float) – Length of each nanowire run in µm. The gap between the pads is
wire_length + 2 * lead_length.n_turns (int) – Number of nanowire runs (odd). 1 gives a straight wire.
wire_gap (float | None) – Gap between adjacent runs in µm. Defaults to
wire_width.lead_length (float | None) – Length of the straight leads between the meander and each pad in µm, which is also the clearance between the U-turns and the pads. Defaults to
wire_gap.corner_style (Literal['sharp', 'chamfer', 'round', 'optimal']) – Corner style of a meandered wire, see
meander_inductor().radius (float | None) – Centreline radius for
"round"corners in µm.pad_width (float) – Pad size along the feedline in µm.
pad_height (float) – Pad size across the feedline in µm.
pad_ground_gap (float) – Gap between the pads and the ground plane at the sides in µm.
coupling_gap (float) – Gap between the feedline centre conductor and the upper pad in µm.
contact_overlap (float) – Length of the nanowire stubs that overlap the pads in µm.
feedline_length (float) – Length of the feedline in µm.
cross_section (CrossSectionSpec) – Cross-section of the feedline.
wire_layer (LayerSpec) – Layer of the nanowire.
- Returns:
Component with feedline ports
o1ando2.- Raises:
ValueError – If the wire width is out of range,
n_turnsis even or not positive, a length is not positive, or the wire does not fit between the pads or the feedline is too short.- Return type:
neck_termination#
resonators waveguides
- qpdk.cells.neck_termination(cross_section='cpw', taper_length=100.0, taper_shape='linear', neck_width=2.0, neck_length=325.0, window_width=380.0, trap_hole_rows=4, trap_hole_size=4.0, trap_hole_pitch=5.5, trap_hole_offset=6.0, trap_hole_keepout=24.0)[source]#
Shorted CPW termination through a taper and a narrow neck.
Geometry of the grounded end of the resonators in Shulga et al. [SNV+26]. The centre conductor tapers from the CPW width to
neck_widthand continues as a straight neck that joins the ground plane at the far edge of a rectangular etched window, so the neck is a strip in a ground opening rather than a CPW with a fixed gap. The ground plane around the window focuses the applied field unevenly onto the taper and neck, and the neck sits at the current antinode, so a single trapped vortex shifts the resonance by a measurable amount. An optional ring of square etched holes along the two long sides and the far end of the window traps vortices in the ground plane, with a hole-free column where the neck current enters the ground. The ring is left open at the port end, where the CPW enters. Holes in the rest of the ground plane are left toqpdk.utils.fill_magnetic_vortices().The paper states the 325 µm neck length and the 1-10 µm neck widths: 1 µm showed single-vortex frequency steps, 5 µm did not, and a 2 µm neck stayed free of vortices after cooling in 113 µT. The taper length (about 100 µm) and the window size (about 380 µm by 425 µm) are estimated from its figures, and the paper does not describe the taper profile. In the paper vortices sit preferentially in the taper. Sharp corners crowd the current and lower the vortex-entry current [CB11]. The default linear taper only has shallow kinks at its ends (about 2° for the defaults), so the effect is small;
taper_shape="smooth"removes them with a raised-cosine profile, which matters for short tapers.The hole defaults follow the usual rules for flux-trap arrays: the superconducting web between holes (1.5 µm) is narrower than the neck, so the holes trap before the neck does [NP14], and the first row is 6 µm from the window edge. Chiaro et al. found that holes 6 µm or more from a CPW gap edge add no measurable dielectric loss [CMD+16]. The window sits near the voltage node of the resonator, so its edges see a weaker electric field than a CPW gap at the open end, and the same margin is conservative here. At the far end the ground return current crowds around the junction with the neck, so the hole-free column
trap_hole_keepoutmust stay wider than the neck. For 1 µm necks use a narrower web (trap_hole_pitch - trap_hole_size); the cell logs a warning when the web is not narrower than the neck.Thresholds from
vortex_trapping_threshold()are field-cooled estimates for an isolated strip. They ignore the flux focusing of the nearby ground planes, which lowers the real threshold (the 8 µm bulge of [NP14] trapped at 42 µT against the 53 µT the formula gives), so use them to compare widths, not as absolute fields. Zero-field-cooled entry and microwave drive can trap vortices at much lower fields, and similar frequency jumps have been seen in resonators without a neck [KVK+26], so measure a resonator without a neck on the same chip as a control.
- Parameters:
cross_section (CrossSectionSpec) – CPW cross-section at port
o1.taper_length (float) – Length of the taper in µm.
taper_shape (Literal['linear', 'smooth']) –
"linear"for a straight-sided taper,"smooth"for a raised-cosine width profile with no corners.neck_width (float) – Width of the neck in µm.
neck_length (float) – Length of the neck in µm.
window_width (float) – Width of the etched window across the line in µm. The window length is
taper_length + neck_length.trap_hole_rows (int) – Number of rows in the ring of flux-trapping holes around the window. Zero disables the holes.
trap_hole_size (float) – Side of each square hole in µm.
trap_hole_pitch (float) – Centre-to-centre hole spacing in µm.
trap_hole_offset (float) – Width of the ground strip between the window and the first row of holes in µm.
trap_hole_keepout (float) – Minimum width of the hole-free column centred on the neck at the far end of the window in µm. The grid can make the column wider.
- Returns:
Component with a single port
o1.- Raises:
ValueError – If a dimension is out of range.
- Return type:
quarter_wave_resonator_coupled#
couplers resonators
- qpdk.cells.quarter_wave_resonator_coupled(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=False, end_with_bend=False, cross_section_non_resonator='cpw', coupling_straight_length=200.0, coupling_gap=20.0)[source]#
Creates a quarter-wave resonator with a coupling waveguide.
Composes a straight coupler, the meander, and explicit open and short terminations. The meander starts at the coupler output so that the trace leaves the coupling gap at
coupling_straight_length. Layouts with no usable first straight section retain the unsplit coupled-resonator cell.The terminations are fixed: the coupled end is open and the far end is shorted. Use
resonator_coupled()if other terminations are needed.
- Parameters:
length (float) – Length of the resonator in μm.
meanders (int) – Number of meander sections to fit the resonator in a compact area.
bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
start_with_bend (bool) – If True, starts the resonator with a bend.
end_with_bend (bool) – If True, ends the resonator with a bend.
cross_section_non_resonator (CrossSectionSpec) – Cross-section specification for the coupling waveguide.
coupling_straight_length (float) – Length of the coupling waveguide section in μm.
coupling_gap (float) – Gap between the resonator and coupling waveguide in μm.
- Returns:
The coupled quarter-wave resonator component.
- Raises:
ValueError – If the requested length is too short for its meanders.
- Return type:
resonator#
resonators
- qpdk.cells.resonator(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=False, end_with_bend=False, open_start=True, open_end=False)[source]#
Creates a meandering coplanar waveguide resonator.
Changing open_start and open_end appropriately allows creating a shorted quarter-wave resonator or an open half-wave resonator.
See [MP12] for details
- Parameters:
length (float) – Length of the resonator in μm.
meanders (int) – Number of meander sections to fit the resonator in a compact area.
bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
start_with_bend (bool) – If True, starts the resonator with a bend.
end_with_bend (bool) – If True, ends the resonator with a bend.
open_start (bool) – If True, adds an etch section at the start of the resonator.
open_end (bool) – If True, adds an etch section at the end of the resonator.
- Returns:
A gdsfactory component with meandering resonator geometry.
- Return type:
Component
- Raises:
ValueError – If length is too short for the requested meanders.
resonator_coupled#
couplers resonators
- qpdk.cells.resonator_coupled(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=False, end_with_bend=False, open_start=True, open_end=False, cross_section_non_resonator='cpw', coupling_straight_length=200.0, coupling_gap=20.0)[source]#
Creates a meandering coplanar waveguide resonator with a coupling waveguide.
This component combines a resonator with a parallel coupling waveguide placed at a specified gap for proximity coupling. Similar to the design described in [BM18].
- Parameters:
length (float) – Length of the resonator in μm.
meanders (int) – Number of meander sections to fit the resonator in a compact area.
bend_spec (ComponentSpec) – Specification for the bend component used in meanders.
cross_section (CrossSectionSpec) – Cross-section specification for the resonator.
start_with_bend (bool) – If True, starts the resonator with a bend.
end_with_bend (bool) – If True, ends the resonator with a bend.
open_start (bool) – If True, adds an etch section at the start of the resonator.
open_end (bool) – If True, adds an etch section at the end of the resonator.
cross_section_non_resonator (CrossSectionSpec) – Cross-section specification for the coupling waveguide.
coupling_straight_length (float) – Length of the coupling waveguide section in μm.
coupling_gap (float) – Gap between the resonator and coupling waveguide in μm. Measured from edges of the center conductors.
- Returns:
A gdsfactory component with meandering resonator and coupling waveguide.
- Return type:
Component
resonator_half_wave#
resonators
- qpdk.cells.resonator_half_wave(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=False, end_with_bend=False, open_start=True, open_end=True)[source]#
Return a half-wave resonator with its schematic and model boundary.
- Parameters:
length (float) – Total resonator length in µm.
meanders (int) – Number of meander bends.
bend_spec (ComponentSpec) – Component used for each bend.
cross_section (CrossSectionSpec) – Resonator cross section.
start_with_bend (bool) – Start the path with a bend.
end_with_bend (bool) – End the path with a bend.
open_start (bool) – Leave the start open instead of shorting it.
open_end (bool) – Leave the end open instead of shorting it.
- Return type:
resonator_half_wave_bend_both#
resonators
- qpdk.cells.resonator_half_wave_bend_both(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=True, end_with_bend=True, open_start=True, open_end=True)#
Return a half-wave resonator with its schematic and model boundary.
- Parameters:
length (float) – Total resonator length in µm.
meanders (int) – Number of meander bends.
bend_spec (ComponentSpec) – Component used for each bend.
cross_section (CrossSectionSpec) – Resonator cross section.
start_with_bend (bool) – Start the path with a bend.
end_with_bend (bool) – End the path with a bend.
open_start (bool) – Leave the start open instead of shorting it.
open_end (bool) – Leave the end open instead of shorting it.
- Return type:
Component
resonator_half_wave_bend_end#
resonators
- qpdk.cells.resonator_half_wave_bend_end(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=False, end_with_bend=True, open_start=True, open_end=True)#
Return a half-wave resonator with its schematic and model boundary.
- Parameters:
length (float) – Total resonator length in µm.
meanders (int) – Number of meander bends.
bend_spec (ComponentSpec) – Component used for each bend.
cross_section (CrossSectionSpec) – Resonator cross section.
start_with_bend (bool) – Start the path with a bend.
end_with_bend (bool) – End the path with a bend.
open_start (bool) – Leave the start open instead of shorting it.
open_end (bool) – Leave the end open instead of shorting it.
- Return type:
Component
resonator_half_wave_bend_start#
resonators
- qpdk.cells.resonator_half_wave_bend_start(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=True, end_with_bend=False, open_start=True, open_end=True)#
Return a half-wave resonator with its schematic and model boundary.
- Parameters:
length (float) – Total resonator length in µm.
meanders (int) – Number of meander bends.
bend_spec (ComponentSpec) – Component used for each bend.
cross_section (CrossSectionSpec) – Resonator cross section.
start_with_bend (bool) – Start the path with a bend.
end_with_bend (bool) – End the path with a bend.
open_start (bool) – Leave the start open instead of shorting it.
open_end (bool) – Leave the end open instead of shorting it.
- Return type:
Component
resonator_half_wave_bulge#
resonators
- qpdk.cells.resonator_half_wave_bulge(length=8000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', bulge_width=25.0, bulge_length=50.0, taper_length=20.0)[source]#
Half-wave resonator with a
cpw_bulge()at its centre.The centre of an open-ended half-wave resonator is the current antinode of the fundamental mode (and a current node of the first harmonic), as in [NP14]. The bulge sits in the middle of the central meander row, so
meandersmust be even.- Parameters:
length (float) – Total centre-line length, including bends and the bulge, in µm.
meanders (int) – Number of meander bends. Must be even.
bend_spec (ComponentSpec) – Bend used in the meanders.
cross_section (CrossSectionSpec) – CPW cross-section of the resonator.
bulge_width (float) – See
cpw_bulge().bulge_length (float) – See
cpw_bulge().taper_length (float) – See
cpw_bulge().
- Returns:
Component with open-end ports
o1ando2.- Raises:
ValueError – If
meandersis odd orlengthis too short.- Return type:
resonator_meander#
resonators
- qpdk.cells.resonator_meander(length=3700.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', end_with_bend=False)[source]#
Return the modeled CPW path from the first bend to the shorted end.
- Parameters:
- Return type:
resonator_quarter_wave#
resonators
- qpdk.cells.resonator_quarter_wave(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=False, end_with_bend=False, open_start=False, open_end=True)[source]#
Return a quarter-wave resonator with its schematic and model boundary.
- Parameters:
length (float) – Total resonator length in µm.
meanders (int) – Number of meander bends.
bend_spec (ComponentSpec) – Component used for each bend.
cross_section (CrossSectionSpec) – Resonator cross section.
start_with_bend (bool) – Start the path with a bend.
end_with_bend (bool) – End the path with a bend.
open_start (bool) – Leave the start open instead of shorting it.
open_end (bool) – Leave the end open instead of shorting it.
- Return type:
resonator_quarter_wave_bend_both#
resonators
- qpdk.cells.resonator_quarter_wave_bend_both(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=True, end_with_bend=True, open_start=False, open_end=True)#
Return a quarter-wave resonator with its schematic and model boundary.
- Parameters:
length (float) – Total resonator length in µm.
meanders (int) – Number of meander bends.
bend_spec (ComponentSpec) – Component used for each bend.
cross_section (CrossSectionSpec) – Resonator cross section.
start_with_bend (bool) – Start the path with a bend.
end_with_bend (bool) – End the path with a bend.
open_start (bool) – Leave the start open instead of shorting it.
open_end (bool) – Leave the end open instead of shorting it.
- Return type:
Component
resonator_quarter_wave_bend_end#
resonators
- qpdk.cells.resonator_quarter_wave_bend_end(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=False, end_with_bend=True, open_start=False, open_end=True)#
Return a quarter-wave resonator with its schematic and model boundary.
- Parameters:
length (float) – Total resonator length in µm.
meanders (int) – Number of meander bends.
bend_spec (ComponentSpec) – Component used for each bend.
cross_section (CrossSectionSpec) – Resonator cross section.
start_with_bend (bool) – Start the path with a bend.
end_with_bend (bool) – End the path with a bend.
open_start (bool) – Leave the start open instead of shorting it.
open_end (bool) – Leave the end open instead of shorting it.
- Return type:
Component
resonator_quarter_wave_bend_start#
resonators
- qpdk.cells.resonator_quarter_wave_bend_start(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', *, start_with_bend=True, end_with_bend=False, open_start=False, open_end=True)#
Return a quarter-wave resonator with its schematic and model boundary.
- Parameters:
length (float) – Total resonator length in µm.
meanders (int) – Number of meander bends.
bend_spec (ComponentSpec) – Component used for each bend.
cross_section (CrossSectionSpec) – Resonator cross section.
start_with_bend (bool) – Start the path with a bend.
end_with_bend (bool) – End the path with a bend.
open_start (bool) – Leave the start open instead of shorting it.
open_end (bool) – Leave the end open instead of shorting it.
- Return type:
Component
resonator_quarter_wave_neck#
resonators
- qpdk.cells.resonator_quarter_wave_neck(length=4000.0, meanders=6, bend_spec=<function bend_circular>, cross_section='cpw', taper_length=100.0, taper_shape='linear', neck_width=2.0, neck_length=325.0, window_width=380.0, trap_hole_rows=4, trap_hole_size=4.0, trap_hole_pitch=5.5, trap_hole_offset=6.0, trap_hole_keepout=24.0)[source]#
Quarter-wave resonator grounded through a
neck_termination().The open end carries the coupling port
o1. At the grounded end, the current antinode, the line turns away from the meander with a 90° bend and ends in the taper, neck and etched window of [SNV+26], so the window does not overlap the meander.- Parameters:
length (float) – CPW length from the open end to the start of the taper, including the 90° bend, in µm.
meanders (int) – Number of meander sections.
bend_spec (ComponentSpec) – Bend used in the meanders and for the turn into the window.
cross_section (CrossSectionSpec) – CPW cross-section of the resonator.
taper_length (float) – See
neck_termination().taper_shape (Literal['linear', 'smooth']) – See
neck_termination().neck_width (float) – See
neck_termination().neck_length (float) – See
neck_termination().window_width (float) – See
neck_termination().trap_hole_rows (int) – See
neck_termination().trap_hole_size (float) – See
neck_termination().trap_hole_pitch (float) – See
neck_termination().trap_hole_offset (float) – See
neck_termination().trap_hole_keepout (float) – See
neck_termination().
- Returns:
Component with the open-end port
o1.- Return type:
straight_double_open#
resonators waveguides
- qpdk.cells.straight_double_open(length=10.0, cross_section=<function coplanar_waveguide>, npoints=2)[source]#
Returns a straight waveguide with etched gaps at both ends.
Note
This may be treated as a \(\lambda/2\) straight resonator in some contexts.
straight_open#
resonators terminations waveguides
- qpdk.cells.straight_open(length=10.0, cross_section=<function coplanar_waveguide>, npoints=2)[source]#
Returns a straight waveguide with etched gap at one end.
straight_shorted#
resonators terminations waveguides
- qpdk.cells.straight_shorted(length=10.0, cross_section=<function coplanar_waveguide>, npoints=2)[source]#
Return a straight waveguide whose far end is shorted.
The CPW slots stop at the far end, joining its center trace to ground.
Josephson Junctions#
josephson_junction#
junctions
- qpdk.cells.josephson_junction(junction_overlap_displacement=1.8, wide_straight_length=8.3, narrow_straight_length=0.5, taper_length=4.7, cross_section_wide=<function josephson_junction_cross_section_wide>, cross_section_narrow=<function josephson_junction_cross_section_narrow>, layer_patch=<LayerMapQPDK.JJ_PATCH: 54>, size_patch=(1.5, 1.0))[source]#
Creates a single Josephson junction component.
A Josephson junction consists of two superconducting electrodes separated by a thin insulating barrier allowing tunnelling.
- Parameters:
junction_overlap_displacement (float) – Displacement of the overlap region in µm. Measured from the centers of the junction ports.
wide_straight_length (float) – Length of the wide straight section in µm.
narrow_straight_length (float) – Length of the narrow straight section in µm.
taper_length (float) – Length of the taper section in µm.
cross_section_wide (CrossSectionSpec) – Cross-section specification for the wide section.
cross_section_narrow (CrossSectionSpec) – Cross-section specification for the narrow section.
layer_patch (LayerSpec) – Layer for the patch that creates the overlap region.
size_patch (tuple[float, float]) – Size of the patch that creates the overlap region.
- Returns:
The Josephson junction component.
- Return type:
josephson_junction_array#
inductors junctions
- qpdk.cells.josephson_junction_array(n_junctions=43, junction_area=0.5, island_length=0.3, island_width=2.0, pitch=0.465, layout_style='dolan', n_folds=0, fold_spacing=4.0, lead_length=1.0, ground_plane_distance=None, critical_current_density=0.09, layer_junction=<LayerMapQPDK.JJ_AREA: 13>, layer_patch=<LayerMapQPDK.JJ_PATCH: 54>, layer_etch=<LayerMapQPDK.M1_ETCH: 47>)[source]#
Creates a chain of Josephson junctions in series between two ports.
The array is used as a superinductance, for example in the fluxonium [MKGD09, MPK+12], or as a junction-chain transmission line. Island \(i\) (\(i = 0, \dots, N\)) sits at \(i p\) along the unfolded chain and junction \(k\) sits between islands \(k\) and \(k + 1\).
- Layout styles:
"dolan": collinear islands ofisland_length×island_widthseparated by the bridge gap \(p - l\). This is the mask of a shadow-evaporated bridge chain. The junction overlap,junction_area / island_width, comes from the evaporation angle and is not drawn."manhattan": overlap junctions on a straight chain. Islands are bars alternating at ±45° to the chain axis, i.e. along the two evaporation axes, so adjacent narrow tips of width \(\sqrt{A}\) cross at right angles and draw the junction overlap \(A\).
With
n_folds > 0the chain zig-zags inn_folds + 1rows spaced byfold_spacing. The junctions are split as evenly as possible over the rows, and the island at each row end is joined to the first island of the next row by a vertical connector (island_lengthwide for Dolan, \(\sqrt{A}\) for Manhattan). The drawn islands are checked for unintended contact: Dolan islands must not touch, and Manhattan islands may overlap only their chain neighbours, in exactly the junction area.The
infodictionary reports the number of junctions, the total junction area \(N A\), the area and perimeter of one interior island (as drawn), the chain length \(N p\), the critical current \(I_\text{c} = J_\text{c} A\) in nA, and the estimated inductances \(L_\text{J} = \Phi_0 / (2 \pi J_\text{c} A)\) and \(L_\text{array} = N L_\text{J}\) in nH, which neglect the kinetic and geometric inductance of the islands.Defaults reproduce the array of [MKGD09]: \(N = 43\) junctions of \(0.25 \times 2\,\mu\text{m}^2\) in a \(20\,\mu\text{m}\) chain, with \(J_\text{c}\) set so that \(L_\text{array}\) matches the reported \(E_L = 0.52\,\text{GHz}\).
- Parameters:
n_junctions (int) – Number of junctions \(N\) in the chain.
junction_area (float) – Area \(A\) of each junction in µm².
island_length (float) – Length \(l\) of each island along the chain (Dolan) or of the wide body of each bar (Manhattan) in µm.
island_width (float) – Width of each island in µm. For Dolan this is also the junction width.
pitch (float) – Island-to-island pitch \(p\) along the chain in µm.
layout_style (Literal['dolan', 'manhattan']) –
"dolan"or"manhattan".n_folds (int) – Number of folds.
0draws a straight chain.fold_spacing (float) – Centre-to-centre spacing between rows in µm.
lead_length (float) – Length of the contact lead at each end in µm.
ground_plane_distance (float | None) – If given, draw a ground-plane clearance on
layer_etchthat extends this far beyond the chain bounding box in µm.critical_current_density (float) – Critical current density \(J_\text{c}\) in µA/µm², used only for the
infoinductance estimate.layer_junction (LayerSpec) – Layer for the islands and leads.
layer_patch (TypeAliasForwardRef('LayerSpec') | None) – Layer for the contact patches on the leads, or
None.layer_etch (LayerSpec) – Layer for the optional ground-plane clearance.
- Returns:
The junction array component with ports
o1ando2.- Raises:
ValueError – If the geometry is inconsistent.
- Return type:
josephson_junction_array_compact#
inductors junctions
- qpdk.cells.josephson_junction_array_compact(n_junctions=43, junction_area=0.5, island_length=0.3, island_width=2.0, pitch=0.465, layout_style='dolan', n_folds=2, fold_spacing=4.0, lead_length=1.0, ground_plane_distance=None, critical_current_density=0.09, layer_junction=<LayerMapQPDK.JJ_AREA: 13>, layer_patch=<LayerMapQPDK.JJ_PATCH: 54>, layer_etch=<LayerMapQPDK.M1_ETCH: 47>)[source]#
Creates a folded Josephson junction array that fits a compact bounding box.
Same as
josephson_junction_array()withn_foldsdefaulting to 2, so the chain zig-zags in three rows and both ports face away from each other.
- Parameters:
n_junctions (int) – Number of junctions \(N\) in the chain.
junction_area (float) – Area \(A\) of each junction in µm².
island_length (float) – Length of each island along the chain in µm.
island_width (float) – Width of each island in µm.
pitch (float) – Island-to-island pitch along the chain in µm.
layout_style (Literal['dolan', 'manhattan']) –
"dolan"or"manhattan".n_folds (int) – Number of folds.
fold_spacing (float) – Centre-to-centre spacing between rows in µm.
lead_length (float) – Length of the contact lead at each end in µm.
ground_plane_distance (float | None) – Optional ground-plane clearance in µm.
critical_current_density (float) – Critical current density in µA/µm².
layer_junction (LayerSpec) – Layer for the islands and leads.
layer_patch (TypeAliasForwardRef('LayerSpec') | None) – Layer for the contact patches on the leads, or
None.layer_etch (LayerSpec) – Layer for the optional ground-plane clearance.
- Returns:
The folded junction array component.
- Return type:
josephson_junction_long#
junctions
- qpdk.cells.josephson_junction_long(**kwargs)[source]#
Josephson junction with wide_straight_length=12.
- Returns:
The Josephson junction component with long wires.
- Return type:
single_josephson_junction_wire#
junctions
- qpdk.cells.single_josephson_junction_wire(wide_straight_length=8.3, narrow_straight_length=0.5, taper_length=4.7, cross_section_wide=<function josephson_junction_cross_section_wide>, cross_section_narrow=<function josephson_junction_cross_section_narrow>, layer_patch=<LayerMapQPDK.JJ_PATCH: 54>, size_patch=(1.5, 1.0))[source]#
Creates a single wire to use in a Josephson junction.
- Parameters:
wide_straight_length (float) – Length of the wide straight section in µm.
narrow_straight_length (float) – Length of the narrow straight section in µm.
taper_length (float) – Length of the taper section in µm.
cross_section_wide (CrossSectionSpec) – Cross-section specification for the wide section.
cross_section_narrow (CrossSectionSpec) – Cross-section specification for the narrow section.
layer_patch (LayerSpec) – Layer for the patch that creates the overlap region.
size_patch (tuple[float, float]) – Size of the patch that creates the overlap region.
- Returns:
The junction wire component.
- Return type:
squid_junction#
junctions
- qpdk.cells.squid_junction(junction_spec=<function josephson_junction>, loop_area=4)[source]#
Creates a SQUID (Superconducting Quantum Interference Device) junction component.
A SQUID consists of two Josephson junctions connected in parallel, forming a loop.
See [CB04] for details.
squid_junction_long#
junctions
- qpdk.cells.squid_junction_long(**kwargs)[source]#
SQUID junction with josephson_junction_long.
- Returns:
The SQUID junction component with long wires.
- Return type:
squid_termination#
junctions terminations
- qpdk.cells.squid_termination(length=10.0, cross_section='cpw', junction_spec=functools.partial(<function squid_junction>, junction_spec=functools.partial(<function josephson_junction>, junction_overlap_displacement=1.8, wide_straight_length=4.0, narrow_straight_length=0.5, taper_length=4)))[source]#
CPW lead shorted to the ground plane through a DC SQUID.
The lead ends in an etched pocket that separates the centre conductor from the ground plane. The SQUID bridges the pocket, so the centre conductor reaches ground only through the SQUID, as in the flux-driven JPA of [YIW+08]. The pocket length follows from the SQUID: the pocket edges run through the centres of the
JJ_PATCHcontact patches, so the lead-side patches land half on the lead and the ground-side patches half on the ground plane.
- Parameters:
length (float) – Length of the CPW lead in µm.
cross_section (CrossSectionSpec) – Cross-section of the CPW lead. The pocket spans the full CPW width, centre conductor plus both gaps.
junction_spec (ComponentSpec) – Component specification for the SQUID.
- Returns:
The SQUID termination with CPW port
o1and asquidplacement port at the SQUID centre.- Return type:
Component
- Raises:
ValueError – If the SQUID has no
JJ_PATCHcontacts on one side, its lead-side contacts overhang the centre conductor, or a contact lies wholly over the pocket.
Couplers#
coupler_ring#
couplers waveguides
- qpdk.cells.coupler_ring(length_x=20, gap=16, cross_section='cpw', bend=<function bend_circular>)[source]#
Return a ring coupler fed by a straight bus.
coupler_straight#
couplers waveguides
- qpdk.cells.coupler_straight(length=10, gap=16, cross_section='cpw', cross_section_non_resonator=None, resonator_offset=0.0)[source]#
Return two parallel coupled waveguides.
- Parameters:
length (float) – Coupling length in μm.
gap (float) – Edge-to-edge conductor gap in μm.
cross_section (CrossSectionSpec) – Cross-section specification.
cross_section_non_resonator (CrossSectionSpec | None) – Optional cross section for the upper bus.
resonator_offset (float) – Shift the lower trace to the right, in µm.
- Return type:
gatemon_coupler#
couplers
- qpdk.cells.gatemon_coupler(length=600.0, coupling_position=200.0, island_width=150.0, pocket_gap_top=40.0, qubit_side='bottom', coupling_capacitance=5.4e-15, cross_section='cpw')[source]#
Return a passing CPW with a capacitive island reference port.
The qubit port sits at the island edge across the etched gap. Its circuit branch represents a lumped capacitance, so no metal spur crosses that gap. The capacitance is a nominal circuit estimate, not a layout extraction.
- Parameters:
length (float) – Complete CPW length in µm.
coupling_position (float) – Island center measured from o1 in µm.
island_width (float) – Width of the island reference plane in µm.
pocket_gap_top (float) – Clearance from island to the CPW conductor edge in µm.
qubit_side (str) – Island side of the CPW, bottom or top.
coupling_capacitance (float) – Nominal mutual capacitance in F for the SAX model.
cross_section (CrossSectionSpec) – Cross-section of the passing CPW.
- Returns:
CPW with o1, o2 and qubit ports.
- Raises:
ValueError – If the island reference plane lies outside the line.
- Return type:
half_circle_coupler#
capacitors couplers
- qpdk.cells.half_circle_coupler(radius=50.0, angle=180.0, extension_length=10.0, cross_section='cpw', extra_straight_length=20.0, open_end=True)[source]#
Creates a half-circle coupler for readout.
This coupler consists of a circular bend (typically 180 degrees) that wraps around a resonator arm for capacitive coupling.
- Parameters:
radius (float) – Inner radius of the half-circle in μm.
angle (float) – Angle of the circular arc in degrees.
extension_length (float) – Length of the straight sections extending from the ends of the half-circle in μm.
cross_section (CrossSectionSpec) – Cross-section specification for the coupler.
extra_straight_length (float) – Length of the straight section extending from the bottom of the half-circle in μm.
open_end (bool) – If True, adds an etched gap at the ends of the extensions.
- Returns:
A gdsfactory component with the half-circle coupler geometry.
- Return type:
Component
hyperbolic_vertex_coupler#
capacitors couplers
- qpdk.cells.hyperbolic_vertex_coupler(q=3, rotation=0.0, pin_radius=40.0, pin_gap=4.0, ground_gap=6.0, lead_length=20.0, cross_section='cpw')[source]#
Return a
q-pin capacitive coupler for a hyperbolic lattice vertex.A metal disk of radius
pin_radiusis cut intoqpie-slice pins by radial gaps of widthpin_gapand isolated from ground by a ring of widthground_gap. Each pin feeds a short CPW lead, so the resonators of theqlattice edges meeting at the vertex couple through the gaps [KollarFH19].
Pin
kpoints alongrotation + 360 k / qdegrees. Its port sits at the end of the lead, snapped to the 1 nm grid, and faces away from the disk centre along the snapped direction (generally not Manhattan).- Parameters:
q (int) – Number of pins (edges meeting at the vertex).
rotation (float) – Direction of pin 0 in degrees.
pin_radius (float) – Radius of the metal disk in µm.
pin_gap (float) – Width of the radial gaps between pins in µm.
ground_gap (float) – Clearance between the disk and ground in µm.
lead_length (float) – Length of the CPW lead beyond the disk in µm.
cross_section (CrossSectionSpec) – CPW cross-section of the leads.
- Returns:
Component with ports
o1…oq.- Raises:
ValueError – If
q < 2or the pins are too narrow for the leads.- Return type:
plate_capacitor#
capacitors couplers
- qpdk.cells.plate_capacitor(length=80.0, width=10.0, gap=7.0, offset=0.0)[source]#
Two facing plate capacitor pads with the dataset’s coplanar ground frame.
Reuses two
plate_capacitor_single()cells. The first pad is centered at the origin and the second is shifted vertically byoffset. Portso1ando2lie at the outer ends of the pads’ short CPW necks. A grounded frame, 45 um wide and 10 um from the electrode bounding box, matchesqpdk.models.plate_capacitor()on silicon. The frame is part of the modeled environment and surrounds both port reference planes.The model includes the coupling and both capacitances to ground. Its validated dimensions are length 40 to 120 um, width 5 to 20 um, gap 4 to 10 um and offset -12 to 12 um. The lookup returns NaN outside that range.
- Parameters:
- Returns:
Component with two signal ports and an implicit common ground.
- Raises:
ValueError – If length, width or gap is not positive.
- Return type:
plate_capacitor_single#
capacitors couplers
- qpdk.cells.plate_capacitor_single(length=26.0, width=5.0, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, etch_layer='M1_ETCH', etch_bbox_margin=2.0, cross_section='cpw')[source]#
Creates a single plate capacitor for coupling.
This is essentially half of a
plate_capacitor().
- Parameters:
length (float) – Length (vertical extent) of the capacitor pad in μm.
width (float) – Width (horizontal extent) of the capacitor pad in μm.
layer_metal (LayerSpec) – Layer for the metal pad.
etch_layer (TypeAliasForwardRef('LayerSpec') | None) – Optional layer for etching around the capacitor.
etch_bbox_margin (float) – Margin around the capacitor for the etch layer in μm.
cross_section (CrossSectionSpec) – Cross-section for the short straight from the etch box capacitor.
- Returns:
A gdsfactory component with the plate capacitor geometry.
- Raises:
ValueError – If width or length is not positive.
- Return type:
Capacitors#
interdigital_capacitor#
capacitors
- qpdk.cells.interdigital_capacitor(fingers=4, finger_length=20.0, finger_gap=2.0, thickness=5.0, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, etch_layer='M1_ETCH', etch_bbox_margin=2.0, cross_section='cpw')[source]#
Generate an interdigital capacitor component with ports on both ends.
An interdigital capacitor consists of interleaved metal fingers that create a distributed capacitance. This component creates a planar capacitor with two sets of interleaved fingers extending from opposite ends.
See for example [LeiZhuW00].
Note
finger_length=0effectively provides a parallel plate capacitor. The capacitance scales approximately linearly with the number of fingers and finger length.The matching SAX model is
interdigital_capacitor(). The single-sided variant is its own factory,interdigital_capacitor_half(), with a different port contract.- Parameters:
fingers (int) – Total number of fingers of the capacitor (must be >= 1).
finger_length (float) – Length of each finger in μm.
finger_gap (float) – Gap between adjacent fingers in μm.
thickness (float) – Thickness of fingers and the base section in μm.
layer_metal (LayerSpec) – Layer for the metal fingers.
etch_layer (TypeAliasForwardRef('LayerSpec') | None) – Optional layer for etching around the capacitor.
etch_bbox_margin (float) – Margin around the capacitor for the etch layer in μm.
cross_section (CrossSectionSpec) – Cross-section for the short straight from the etch box capacitor.
- Returns:
- A gdsfactory component with the interdigital capacitor geometry
and two ports (‘o1’ and ‘o2’) on opposing sides.
- Return type:
Component
interdigital_capacitor_half#
capacitors
- qpdk.cells.interdigital_capacitor_half(fingers=4, finger_length=20.0, finger_gap=2.0, thickness=5.0, layer_metal=<LayerMapQPDK.M1_DRAW: 1>, etch_layer='M1_ETCH', etch_bbox_margin=2.0, cross_section='cpw')[source]#
Generate a single-sided interdigital capacitor with a single port.
This is one comb of the interdigital capacitor, for layouts whose second plate is a separate object. It exposes only port ‘o1’, so the two-port
interdigital_capacitor()model does not describe it and no SAX model is registered for this factory.- Parameters:
fingers (int) – Total number of fingers of the capacitor (must be >= 1).
finger_length (float) – Length of each finger in μm.
finger_gap (float) – Gap between adjacent fingers in μm.
thickness (float) – Thickness of fingers and the base section in μm.
layer_metal (LayerSpec) – Layer for the metal fingers.
etch_layer (TypeAliasForwardRef('LayerSpec') | None) – Optional layer for etching around the capacitor.
etch_bbox_margin (float) – Margin around the capacitor for the etch layer in μm.
cross_section (CrossSectionSpec) – Cross-section for the short straight from the etch box capacitor.
- Returns:
- A gdsfactory component with the single-sided interdigital
capacitor geometry and a single port (‘o1’).
- Return type:
Component
vacuum_gap_capacitor#
capacitors
- qpdk.cells.vacuum_gap_capacitor(radius=7.5, support='rim', etch_gap=2.0, rim_width=3.0, n_legs=4, leg_width=2.0, cross_section=<function meander_inductor_cross_section>)[source]#
Creates a suspended vacuum-gap parallel-plate (drum) capacitor.
A circular bottom electrode of radius \(a\) in
M1sits under an aluminium membrane onVG_TOP, separated by the vacuum gap \(d\) of the layer stack, after [CLS+10, PDamskaggB+15]. The membrane is clamped onto anM1ring around the electrode, either along its whole edge (support="rim") or throughn_legsradial legs (support="legs").VG_SACmarks the sacrificial layer under the suspended part.In the Aalto process the membrane is evaporated on a sacrificial amorphous-silicon layer that is etched away to release it [MdLepinayDamskaggOKSillanpaa19]. Here the membrane lands on
M1, since the layer stack measures the gap from the top ofM1.The suspended part spans the electrode plus the etched gap to the ring, a diameter of \(2(a + \text{etch\_gap})\). With the defaults that is 19 µm over a 15 µm electrode, so the mechanics of the drawn membrane are not those of the 15 µm drum of [PDamskaggB+15].
Port
o1connects to the bottom electrode through a lead that passes under the membrane in a slot of the ring. Porto2connects to the ring and through it to the membrane. The plate overlap is set by the bottom electrode, so the parallel-plate capacitance is \(C = \varepsilon_0 \pi a^2 / d\), seeqpdk.models.drum.vacuum_gap_capacitance_analytical().- Parameters:
radius (float) – Bottom-electrode radius \(a\) in µm.
support (Literal['rim', 'legs']) – How the membrane is held,
"rim"or"legs".etch_gap (float) – Etched gap in µm between electrode and ring, and between ring and ground.
rim_width (float) – Width of the
M1ring the membrane lands on, in µm.n_legs (int) – Number of radial legs for
support="legs".leg_width (float) – Width of each leg in µm for
support="legs".cross_section (CrossSectionSpec) – Cross-section of the two leads and ports.
- Returns:
- The drum capacitor with ports
o1(bottom electrode) and o2(membrane).
- The drum capacitor with ports
- Return type:
Component
- Raises:
ValueError – If a dimension is not positive,
supportis unknown,n_legs< 1, or a leg would land on the lead slot.
Inductors#
meander_inductor#
inductors
- qpdk.cells.meander_inductor(n_turns=5, turn_length=200.0, cross_section=<function meander_inductor_cross_section>, wire_gap=None, etch_bbox_margin=2.0, add_etch=True, corner_style='sharp', radius=None)[source]#
Creates a meander inductor with Manhattan routing using a narrow wire.
The inductor consists of multiple horizontal runs connected by short vertical segments at alternating ends, forming a serpentine (meander) path. The total inductance is dominated by kinetic inductance for superconducting thin films.
Similar structures are described in [CSD+23, KVH+11].
- Parameters:
n_turns (int) – Number of horizontal meander runs (must be >= 1).
turn_length (float) – Length of each horizontal run in µm.
cross_section (CrossSectionSpec) – Cross-section specification for the meander wire. The center conductor width and etch gap are derived from this specification. The meander’s vertical pitch is the wire width plus the run-to-run gap, which defaults to twice the etch gap so that the etched regions of adjacent runs do not overlap, maintaining the characteristic impedance of each run.
wire_gap (float | None) – Optional explicit gap between adjacent inductor runs in µm. If None (default), it’s inferred as 2x the etch gap from the cross-section, or the wire width if it has no etch section.
etch_bbox_margin (float) – Extra margin around the inductor for the etch bounding box in µm. This margin is added in addition to the etch region defined in the cross-section.
add_etch (bool) – Whether to add the etch bounding box. Defaults to True.
corner_style (Literal['sharp', 'chamfer', 'round', 'optimal']) –
Shape of the U-turn corners, all within the same bounding box:
"sharp": Manhattan corners (the original geometry)."chamfer": the outer corner of each 90° bend is cut at 45° so the wire keeps its width \(w\) along the diagonal."round": circular arcs of centreline radiusradius."optimal": the current-crowding-free hairpin contour of [CB11], drawn withgdsfactory.components.optimal_hairpin(). Each hairpin spans half a run.
radius (float | None) – Centreline radius of
"round"corners in µm, with \(w/2 < R \\le p/2\) for pitch \(p\). Defaults to \(p/2\), which makes each U-turn a semicircle. Ignored for other styles.
- Returns:
- A gdsfactory component with the meander inductor geometry
and two ports (‘o1’ and ‘o2’).
infoholdstotal_wire_length: centreline length of the sharp meander in µm.n_squares:total_wire_length / w, which counts every corner square as one square. The SAX model uses this value.n_squares_drawn: squares of the drawn polygon for the chosencorner_style, fromqpdk.tech.meander_n_squares_drawn(). A sharp 90° corner counts 0.559 squares [HH63].n_squares_convention: the corner rule used forn_squares_drawn.
- Return type:
Component
- Raises:
ValueError – If n_turns < 1, turn_length <= 0, wire_gap is not positive, radius is out of range, the runs are too short for the chosen corners, or corner_style is unknown.
Detectors#
snspd#
detectors
- qpdk.cells.snspd(wire_width=0.2, wire_pitch=0.6, size=(10, 8), num_squares=None, turn_ratio=4, terminals_same_side=False, layer=<LayerMapQPDK.NbTiN: 18>, port_type='electrical')[source]#
Creates an optimally-rounded SNSPD.
- Parameters:
wire_width (float) – Width of the wire.
wire_pitch (float) – Distance between two adjacent wires. Must be greater than width.
size (Size) – Float2 (width, height) of the rectangle formed by the outer boundary of the SNSPD.
num_squares (int | None) – int | None = None Total number of squares inside the SNSPD length. If given, overrides size with an approximately square SNSPD. The meander count is quantized to whole wire pitches, so the achieved square count (reported in info[“num_squares”]) is close to but not exactly the requested one.
turn_ratio (float) – float Specifies how much of the SNSPD width is dedicated to the 180 degree turn. A turn_ratio of 10 will result in 20% of the width being comprised of the turn.
terminals_same_side (bool) – If True, both ports will be located on the same side of the SNSPD.
layer (LayerSpec) – layer spec to put polygon geometry on.
port_type (Literal['electrical', 'optical']) – type of port to add to the component (“electrical” or “optical”).
- Returns:
A Component containing the SNSPD geometry.
- Raises:
ValueError – If parameters are invalid or the SNSPD is too small for at least 3 meanders.
- Return type:
Interconnects#
3D Integration#
bump_transition#
3d-integration flip-chip interconnects waveguides
- qpdk.cells.bump_transition(cross_section='cpw', cross_section_top='cpw_top', taper_length=10.0, taper_length_top=10.0, pad_width=30.0, pad_gap=6.0, pad_length=30.0, bump_diameter=15.0, n_ground_bumps_per_side=0, ground_bump_pitch=30.0, ground_bump_distance=15.0)[source]#
CPW transition between the two chips of a flip-chip stack through one indium bump.
Follows the indium transition of [RBF+26] (Fig. A5b) and the bump-interrupted resonators of [RKD+17] (Fig. 4b): the CPW is routed from one chip to the other with the centre conductor kept galvanically continuous through a single indium bump. The bottom-chip CPW (
o1, onM1) widens over a short jog into a closed pad, and the top-chip CPW (o2, onM2) leaves an identical pad in the opposite direction. The defaults use a 15 µm bump on 30 µm square pads, the landing pad size [FML+17] found sufficient for 15 µm indium pillars at ±2 µm bonder alignment.In those works the ground planes are tied together by a field of bumps across the whole chip rather than by bumps dedicated to each transition, so place an
indium_bump_array()alongside.n_ground_bumps_per_sideoptionally adds ground bumps next to the pads.Both chips are drawn in the same (bottom-chip, top-down) coordinate frame, so the pads overlap and the bump lands on both.
- Parameters:
cross_section (CrossSectionSpec) – Bottom-chip CPW cross-section at
o1.cross_section_top (CrossSectionSpec) – Top-chip CPW cross-section at
o2.taper_length (float) – Length of the bottom-chip jog from the CPW into the pad in µm.
taper_length_top (float) – Length of the top-chip jog from the pad into the CPW in µm.
pad_width (float) – Centre-conductor width of both pads in µm.
pad_gap (float) – Gap between the pads and ground in µm.
pad_length (float) – Length of the pads along the propagation direction in µm.
bump_diameter (float) – Indium bump diameter in µm.
n_ground_bumps_per_side (int) – Number of optional ground bumps on each side of the pads.
ground_bump_pitch (float) – Centre-to-centre pitch of the ground bumps (along x) in µm.
ground_bump_distance (float) – Distance from the ground-plane edge to the ground bump centres in µm.
- Returns:
Component with the bottom-chip port
o1and the top-chip porto2.- Raises:
ValueError – If the bump does not fit in the pad, or the ground bumps reach into the CPW gap.
- Return type:
indium_bump#
3d-integration flip-chip interconnects
- qpdk.cells.indium_bump(diameter=15.0)[source]#
Creates an indium bump component for 3D integration.
See [RKD+17] for details.
indium_bump_array#
3d-integration flip-chip interconnects
- qpdk.cells.indium_bump_array(columns=4, rows=4, pitch=200.0, diameter=15.0)[source]#
Creates a rectangular field of indium bumps centred at the origin.
Use it to tie the ground planes of the two chips of a flip-chip stack together, away from any CPW gaps.
- Parameters:
- Returns:
A gdsfactory Component with
columns * rowsindium bumps.- Return type:
tsv#
3d-integration interconnects
- qpdk.cells.tsv(width=10.0, length=20.0, pad_margin=2.0, chip='bottom')[source]#
Creates a slot-shaped superconducting through-silicon via (TSV).
The default \(10 \times 20\,\text{µm}\) slot is the TSV of [MYR+21], see also [YSM+20]. Use
width == lengthfor a round via.Landing pads on the front- and backside metal enclose the via by
pad_margin, so the via stays covered by metal even when placed next to an etched gap.With
chip="top"the via runs through the flip-chip top chip, onTSV2with pads onM2andMB2, seeLAYER_STACK_FLIP_CHIP_BACKSIDE.
- Parameters:
- Returns:
A gdsfactory Component representing the TSV.
- Raises:
ValueError – If
lengthis smaller thanwidth.- Return type:
tsv_transition#
3d-integration interconnects waveguides
- qpdk.cells.tsv_transition(cross_section=None, taper_length=100.0, pad_width=40.0, pad_gap=24.0, pad_length=30.0, via_width=10.0, via_length=20.0, via_pad_margin=2.0, n_signal_vias=2, signal_via_pitch=20.0, n_ground_vias_per_side=4, ground_via_pitch=30.0, ground_via_distance=15.0, chip='bottom')[source]#
Front-side CPW tapered into a TSV landing pad.
The CPW widens linearly over
taper_lengthinto a pad carryingn_signal_viasparallel signal TSVs, surrounded by2 * n_ground_vias_per_sideTSVs stitching the front and back ground planes. On the backside, the signal TSVs land on an isolatedMBpad of the same size, clear of the backside ground bypad_gap. Connect other backside structures at thebacksideplacement port. Withchip="top"the same transition is built on the flip-chip top chip, fromM2toMB2.The defaults follow the transition of [MYR+21], Fig. 6: two signal TSVs in parallel (a single TSV gives a large impedance mismatch) and eight ground TSVs. The pad gap keeps the pad close to the aspect ratio \(w / (w + 2s)\) of the default \(50\,\Omega\) CPW; the taper and pad dimensions are the knobs to optimise the transition impedance, see the
palace_tsv_transitionnotebook.![o o o o <- ground TSVs ___________________ o1 ── / [==] | \ [==] | <- signal TSVs in pad ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾ o o o o](_images/svgbob-a3e8b6673a83fce86fe4b875d84eb9cc9d378495.svg)
![o o o o <- ground TSVs ___________________ o1 ── / [==] | \ [==] | <- signal TSVs in pad ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾ o o o o](_images/svgbob-a3e8b6673a83fce86fe4b875d84eb9cc9d378495_dark.svg)
- Parameters:
cross_section (TypeAliasForwardRef('CrossSectionSpec') | None) – Front-side CPW cross-section at the
o1port.Noneuses the front cross-section ofchip.taper_length (float) – Length of the linear taper from the CPW to the pad in µm.
pad_width (float) – Centre-conductor width of the pad in µm.
pad_gap (float) – Gap between the pad and ground in µm.
pad_length (float) – Length of the pad along the propagation direction in µm.
via_width (float) – TSV width in µm.
via_length (float) – TSV length in µm.
via_pad_margin (float) – TSV landing-pad enclosure in µm.
n_signal_vias (int) – Number of parallel signal TSVs in the pad.
signal_via_pitch (float) – Centre-to-centre pitch of the signal TSVs (along y) in µm.
n_ground_vias_per_side (int) – Number of ground TSVs on each side of the pad.
ground_via_pitch (float) – Centre-to-centre pitch of the ground TSVs (along x) in µm.
ground_via_distance (float) – Distance from the ground-plane edge to the ground TSV centres in µm.
chip (Literal['bottom', 'top']) – Chip the TSVs go through,
"bottom"or"top".
- Returns:
Component with the CPW port
o1and thebacksideplacement port at the signal TSVs.- Return type:
tsv_transition_double_sided#
3d-integration interconnects waveguides
- qpdk.cells.tsv_transition_double_sided(cross_section=None, cross_section_backside=None, taper_length=100.0, taper_length_backside=100.0, pad_width=40.0, pad_gap=24.0, pad_length=30.0, via_width=10.0, via_length=20.0, via_pad_margin=2.0, n_signal_vias=2, signal_via_pitch=20.0, n_ground_vias_per_side=4, ground_via_pitch=30.0, ground_via_distance=15.0, chip='bottom')[source]#
CPW transition from the front side to the backside through TSVs.
A front-side CPW (
o1, onM1) tapers into a pad, the signal passes throughn_signal_viasparallel TSVs, and a backside CPW (o2, onMB) tapers out of an identical pad in the opposite direction.2 * n_ground_vias_per_sideTSVs stitch the front and back ground planes around the pad. This is the side A to side B transition of [MYR+21], Fig. 6.Simulate it with
LAYER_STACK_BACKSIDE; the backside metal also turns every CPW on the chip into a conductor-backed CPW, see theconductor_backedoption ofcpw_parameters(). Withchip="top"it runs fromM2toMB2through the flip-chip top chip instead, seeLAYER_STACK_FLIP_CHIP_BACKSIDE.![front (M1) back (MB) ______________________ o1 ── / [==] \ ── o2 \ [==] / ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾](_images/svgbob-416d0a961053889d5f71af445b0c864bf014d7cf.svg)
![front (M1) back (MB) ______________________ o1 ── / [==] \ ── o2 \ [==] / ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾](_images/svgbob-416d0a961053889d5f71af445b0c864bf014d7cf_dark.svg)
- Parameters:
cross_section (TypeAliasForwardRef('CrossSectionSpec') | None) – Front-side CPW cross-section at
o1.Noneuses the front cross-section ofchip.cross_section_backside (TypeAliasForwardRef('CrossSectionSpec') | None) – Backside CPW cross-section at
o2.Noneuses the back cross-section ofchip.taper_length (float) – Length of the front-side taper in µm.
taper_length_backside (float) – Length of the backside taper in µm.
pad_width (float) – Centre-conductor width of both pads in µm.
pad_gap (float) – Gap between the pads and ground in µm.
pad_length (float) – Length of the pads along the propagation direction in µm.
via_width (float) – TSV width in µm.
via_length (float) – TSV length in µm.
via_pad_margin (float) – TSV landing-pad enclosure in µm.
n_signal_vias (int) – Number of parallel signal TSVs.
signal_via_pitch (float) – Centre-to-centre pitch of the signal TSVs (along y) in µm.
n_ground_vias_per_side (int) – Number of ground TSVs on each side of the pads.
ground_via_pitch (float) – Centre-to-centre pitch of the ground TSVs (along x) in µm.
ground_via_distance (float) – Distance from the ground-plane edge to the ground TSV centres in µm.
chip (Literal['bottom', 'top']) – Chip the TSVs go through,
"bottom"or"top".
- Returns:
Component with the front-side port
o1and the backside porto2.- Return type:
Other Interconnects#
airbridge#
interconnects
- qpdk.cells.airbridge(bridge_length=30.0, bridge_width=8.0, pad_width=15.0, pad_length=12.0, bridge_layer=<LayerMapQPDK.AB_DRAW: 51>, pad_layer=<LayerMapQPDK.AB_VIA: 52>)[source]#
Generate a superconducting airbridge component.
Creates an airbridge consisting of a suspended bridge span and landing pads on either side. The bridge allows transmission lines to cross over each other without electrical contact, which is essential for complex quantum circuit routing without crosstalk.
The bridge_layer (AB_DRAW) represents the elevated metal bridge structure, while the pad_layer (AB_VIA) represents the contact/landing pads that connect to the underlying circuit.
Note
To be used with
ComponentAlongPaththe unrotated version should be oriented for placement on a horizontal line.- Parameters:
bridge_length (float) – Total length of the airbridge span in µm.
bridge_width (float) – Width of the suspended bridge in µm.
pad_width (float) – Width of the landing pads in µm.
pad_length (float) – Length of each landing pad in µm.
bridge_layer (LayerSpec) – Layer for the suspended bridge metal (default: AB_DRAW).
pad_layer (LayerSpec) – Layer for the landing pads/contacts (default: AB_VIA).
- Returns:
Component containing the airbridge geometry with appropriate ports.
- Return type:
launcher#
interconnects waveguides
- qpdk.cells.launcher(straight_length=200.0, taper_length=100.0, cross_section_big=<function launcher_cross_section_big>, cross_section_small='cpw')[source]#
Generate an RF launcher pad for wirebonding or probe testing.
Creates a launcher component consisting of a straight section with large cross-section connected to a tapered transition down to a smaller cross-section. This design facilitates RF signal access through probes or wirebonds while maintaining good impedance matching.
The default dimensions are taken from [TSK+25].
- Parameters:
straight_length (float) – Length of the straight, wirebond landing area, section in µm.
taper_length (float) – Length of the taper section in µm.
cross_section_big (CrossSectionSpec) – Cross-section specification for the large end of the launcher (probe/wirebond interface).
cross_section_small (CrossSectionSpec) – Cross-section specification for the small end of the launcher (circuit interface).
- Returns:
- A gdsfactory component containing the complete launcher
geometry with one output port (“o1”) at the small end.
- Return type:
Component
Terminations#
open#
terminations
- qpdk.cells.open()[source]#
Return a layout-free ideal one-port open for schematic simulation.
- Return type:
open_2_port#
terminations
- qpdk.cells.open_2_port(cross_section=<function coplanar_waveguide>)[source]#
Return an etched open end with an isolated external model port.
- Parameters:
cross_section (CrossSectionSpec) – Cross section of the connected resonator trace.
- Return type:
short#
terminations
- qpdk.cells.short()[source]#
Return a layout-free ideal one-port short for schematic simulation.
- Return type:
Waveguides#
Bends#
bend_circular#
bend circular waveguides
- qpdk.cells.bend_circular(angle=90.0, radius=100.0, npoints=None, cross_section=<function coplanar_waveguide>, allow_min_radius_violation=True, **kwargs)[source]#
Returns circular bend.
Cross-sections have a minimum value of allowed bend radius, which is half their total width. If the user-specified radius is smaller than this value, it is adjusted to the minimum acceptable one.
- Parameters:
angle (float) – Angle of the bend in degrees.
radius (float) – Radius of the bend in μm.
npoints (int | None) – Number of points for the bend (optional, cannot be used with angular_step).
cross_section (CrossSectionSpec) – Cross-section specification.
allow_min_radius_violation (bool) – Allow radius smaller than cross-section radius.
**kwargs – Additional arguments passed to gf.c.bend_circular (e.g., angular_step).
- Return type:
bend_circular_all_angle#
bend circular waveguides
- qpdk.cells.bend_circular_all_angle(radius=100.0, angle=90.0, npoints=None, layer=None, cross_section=<function coplanar_waveguide>, allow_min_radius_violation=True)[source]#
Returns circular bend with arbitrary angle.
bend_euler#
bend euler waveguides
- qpdk.cells.bend_euler(angle=90.0, p=0.5, with_arc_floorplan=True, npoints=720, cross_section=<function coplanar_waveguide>, allow_min_radius_violation=True, **kwargs)[source]#
Regular degree euler bend.
- Parameters:
angle (float) – Angle of the bend in degrees.
p (float) – Fraction of the bend that is curved (0-1).
with_arc_floorplan (bool) – Include arc floorplan.
npoints (int) – Number of points for the bend.
cross_section (CrossSectionSpec) – Cross-section specification.
allow_min_radius_violation (bool) – Allow radius smaller than cross-section radius.
**kwargs – Additional arguments passed to gf.c.bend_euler.
- Returns:
The euler bend component.
- Return type:
bend_euler_all_angle#
bend euler waveguides
- qpdk.cells.bend_euler_all_angle(radius=None, angle=90.0, p=0.5, with_arc_floorplan=True, npoints=None, layer=None, cross_section=<function coplanar_waveguide>, allow_min_radius_violation=True)[source]#
Returns regular degree euler bend with arbitrary angle.
- Parameters:
angle (float) – Angle of the bend in degrees.
p (float) – Fraction of the bend that is curved (0-1).
with_arc_floorplan (bool) – Include arc floorplan.
layer (LayerSpec | None) – Layer specification.
cross_section (CrossSectionSpec) – Cross-section specification.
allow_min_radius_violation (bool) – Allow radius smaller than cross-section radius.
- Return type:
bend_s#
bend s waveguides
- qpdk.cells.bend_s(size=(20.0, 3.0), npoints=99, cross_section=<function coplanar_waveguide>, allow_min_radius_violation=True, **kwargs)[source]#
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 (Size) – Tuple of (length, offset) for the S bend in μm.
npoints (int) – Number of points used to discretize the Bézier curve.
cross_section (CrossSectionSpec) – Cross-section specification.
allow_min_radius_violation (bool) – Allow radius smaller than cross-section radius.
**kwargs – Additional arguments passed to gf.c.bend_s.
- Return type:
Other Waveguides#
cpw_bulge#
waveguides
- qpdk.cells.cpw_bulge(cross_section='cpw', bulge_width=25.0, bulge_length=50.0, taper_length=20.0)[source]#
CPW section with a locally widened centre conductor.
Following Nsanzineza and Plourde [NP14], the wide section has a lower trapping threshold (
vortex_trapping_threshold()scales as \(1/w^2\)) so that, placed at the current antinode of a resonator, it is where vortices are trapped first. The gap is kept constant, so the ground-plane edges flare with the conductor; the paper does not state how its gap behaves.The paper used a 3 µm line widened to 8 µm over 50 µm. It observed the first vortex at 42 µT and then one more for every 5 µT, which matches one flux quantum per bulge area. The cell reports this step as
bulge_flux_step\(= \Phi_0 / (w_\text{b} l_\text{b})\). The taper length is not given in the paper. The defaultbulge_widthis close to the paper’s width ratio (8/3) on the PDK’s 10 µm CPW. To reproduce the paper usecross_section=coplanar_waveguide(width=3, gap=2)andbulge_width=8.For the bulge to trap first it must be the widest conductor in the resonator: in the paper the 6 µm coupler trapped next, at 72 µT. Ground planes need flux-trap holes whose web is narrower than the line, for example
qpdk.utils.fill_magnetic_vortices().
- Parameters:
- Returns:
Component with ports
o1ando2.- Raises:
ValueError – If a dimension is out of range.
- Return type:
hyperbolic_cpw_path#
waveguides
- qpdk.cells.hyperbolic_cpw_path(points=((0.0, 0.0), (100.0, 0.0)), radius=100.0, shorted=False, cross_section='cpw')[source]#
CPW along
pointswith rounded corners, ports at the first and last point.hyperbolic_lattice()uses it for the boundary stubs and probe feeds. The direction is baked into the cell so it can be placed off-axis without an off-grid rotation. Withshortedthe far end is a short likestraight_shorted()ando2only marks it.- Parameters:
- Returns:
Component with ports
o1(start) ando2(end).- Return type:
nxn#
waveguides
- qpdk.cells.nxn(xsize=10.0, ysize=10.0, wg_width=10.0, layer=<LayerMapQPDK.M1_DRAW: 1>, wg_margin=0.0, north=1, east=1, south=1, west=1, cross_section=<function coplanar_waveguide>)[source]#
Returns an NxN junction with ports on each side.
- Parameters:
xsize (float) – Horizontal size of the junction in μm.
ysize (float) – Vertical size of the junction in μm.
wg_width (float) – Width of the waveguides in μm.
layer (LayerSpec) – Layer specification.
wg_margin (float) – Margin from edge to waveguide in μm.
north (int) – Number of ports on the north side.
east (int) – Number of ports on the east side.
south (int) – Number of ports on the south side.
west (int) – Number of ports on the west side.
cross_section (CrossSectionSpec) – Cross-section specification.
- Return type:
rectangle#
waveguides
- qpdk.cells.rectangle(size=(4.0, 2.0), layer='M1_DRAW', centered=False, port_type='electrical', port_orientations=(180, 90, 0, -90))[source]#
Returns a rectangle.
- Parameters:
- Return type:
straight#
waveguides
- qpdk.cells.straight(length=10.0, cross_section=<function coplanar_waveguide>, npoints=2)[source]#
Returns a straight waveguide.
straight_all_angle#
waveguides
- qpdk.cells.straight_all_angle(length=10.0, npoints=2, cross_section=<function coplanar_waveguide>)[source]#
Returns a Straight waveguide with offgrid ports.
- Parameters:
- Return type:
o1 ──────────────── o2 length
tee#
waveguides
- qpdk.cells.tee(cross_section='cpw')[source]#
Returns a three-way tee waveguide.
- Parameters:
cross_section (CrossSectionSpec) – specification (CrossSection, string or dict).
- Return type:
Chip#
chip_edge#
chip
- qpdk.cells.chip_edge(size=(10000.0, 10000.0), width=200.0, layer='M1_ETCH', footprint_layer=None)[source]#
Returns a chip edge component with hollow rectangle frame.
Creates a rectangular frame (hollow rectangle) on an etched metal layer, typically used to define chip edge regions for proper fabrication.
- Parameters:
size (tuple[float, float]) – (tuple) Width and height of the chip edge area.
width (float) – Width/thickness of the etched frame border.
layer (LayerSpec) – Layer to put the etched frame on.
footprint_layer (LayerSpec | None) – Optional layer to fill the whole chip area on, such as
SUBSTRATEfor the bottom chip orSUBSTRATE_TOPfor the flip-chip top chip. The 3D preview builds that chip’s substrate and ground planes from it.
- Return type:
References#
R. Barends, J. Kelly, A. Megrant, D. Sank, E. Jeffrey, Y. Chen, Y. Yin, B. Chiaro, J. Mutus, C. Neill, P. O'Malley, P. Roushan, J. Wenner, T. C. White, A. N. Cleland, and John M. Martinis. Coherent Josephson Qubit Suitable for Scalable Quantum Integrated Circuits. Physical Review Letters, 111(8):080502, August 2013. doi:10.1103/PhysRevLett.111.080502.
Ilya Besedin and Alexey P Menushenkov. Quality factor of a transmission line coupled coplanar waveguide resonator. EPJ Quantum Technology, 5(1):2, December 2018. doi:10.1140/epjqt/s40507-018-0066-3.
A. Bienfait, J. J. Pla, Y. Kubo, M. Stern, X. Zhou, C. C. Lo, C. D. Weis, T. Schenkel, M. L. W. Thewalt, D. Vion, D. Esteve, B. Julsgaard, K. Mølmer, J. J. L. Morton, and P. Bertet. Reaching the quantum limit of sensitivity in electron spin resonance. Nature Nanotechnology, 11(3):253–257, March 2016. doi:10.1038/nnano.2015.282.
Qi-Ming Chen, Priyank Singh, Rostislav Duda, Giacomo Catto, Aarne Keränen, Arman Alizadeh, Timm Mörstedt, Aashish Sah, András Gunyhó, Wei Liu, and Mikko Möttönen. Compact inductor-capacitor resonators at sub-gigahertz frequencies. Physical Review Research, 5(4):043126, November 2023. doi:10.1103/PhysRevResearch.5.043126.
B. Chiaro, A. Megrant, A. Dunsworth, Z. Chen, R. Barends, B. Campbell, Y. Chen, A. Fowler, I. C. Hoi, E. Jeffrey, J. Kelly, J. Mutus, C. Neill, P. J. J. O'Malley, C. Quintana, P. Roushan, D. Sank, A. Vainsencher, J. Wenner, T. C. White, and John M. Martinis. Dielectric surface loss in superconducting resonators with flux-trapping holes. Superconductor Science and Technology, 29(10):104006, 2016. doi:10.1088/0953-2048/29/10/104006.
Katarina Cicak, Dale Li, Joshua A. Strong, Michael S. Allman, Fabio Altomare, Adam J. Sirois, Jed D. Whittaker, John D. Teufel, and Raymond W. Simmonds. Low-loss superconducting resonant circuits using vacuum-gap-based microwave components. Applied Physics Letters, 96(9):093502, March 2010. doi:10.1063/1.3304168.
John Clarke and Alex I. Braginski. The SQUID Handbook. Wiley-VCH, Weinheim, 2004. ISBN 978-3-527-40229-8.
John R. Clem and Karl K. Berggren. Geometry-dependent critical currents in superconducting nanocircuits. Physical Review B, 84(17):174510, November 2011. doi:10.1103/PhysRevB.84.174510.
B. Foxen, J. Y. Mutus, E. Lucero, R. Graff, A. Megrant, Yu Chen, C. Quintana, B. Burkett, J. Kelly, E. Jeffrey, Yan Yang, Anthony Yu, K. Arya, R. Barends, Zijun Chen, B. Chiaro, A. Dunsworth, A. Fowler, C. Gidney, M. Giustina, T. Huang, P. Klimov, M. Neeley, C. Neill, P. Roushan, D. Sank, A. Vainsencher, J. Wenner, T. C. White, and John M. Martinis. Qubit compatible superconducting interconnects. Quantum Science and Technology, 3(1):014005, December 2017. arXiv:1708.04270, doi:10.1088/2058-9565/aa94fc.
F. B. Hagedorn and P. M. Hall. Right-angle bends in thin strip conductors. Journal of Applied Physics, 34(1):128–133, January 1963. doi:10.1063/1.1729052.
Eric Hyyppa, Suman Kundu, Chun Fai Chan, András Gunyhó, Juho Hotari, David Janzso, Kristinn Juliusson, Olavi Kiuru, Janne Kotilahti, Alessandro Landra, Wei Liu, Fabian Marxer, Akseli Mäkinen, Jean-Luc Orgiazzi, Mario Partanen, Jukka Räbinä, Joni Rönkkö, Mykhailo Seppälä, Slawomir Simbierowicz, Vasilii Sokolov, Jani Suuronen, Francesca Tozzini, Mikko Tuokkola, Jami Viitanen, Visa Vesterinen, Zijun Zhang, Leif Grönberg, Joonas Govenius, and Mikko Möttönen. Unimon qubit. Nature Communications, 13(1):6895, November 2022. doi:10.1038/s41467-022-34614-w.
Chaitali Joshi, Wenyuan Chen, Henry G. LeDuc, Peter K. Day, and Mohammad Mirhosseini. Strong kinetic-inductance kerr nonlinearity with titanium nitride nanowires. Physical Review Applied, 18(6):064088, December 2022. doi:10.1103/PhysRevApplied.18.064088.
Dmitrii S. Kalashnikov, Denis Yu. Vodolazov, Ruslan I. Kinzibaev, Andrei G. Shishkin, and Vasily S. Stolyarov. Equidistant resonance jumps in superconducting coplanar resonators driven by Abrikosov vortices. Physical Review B, 114:024502, 2026. doi:10.1103/d3wg-6ls3.
Z. Kim, C. P. Vlahacos, J. E. Hoffman, J. A. Grover, K. D. Voigt, B. K. Cooper, C. J. Ballard, B. S. Palmer, M. Hafezi, J. M. Taylor, J. R. Anderson, A. J. Dragt, C. J. Lobb, L. A. Orozco, S. L. Rolston, and F. C. Wellstood. Thin-film superconducting resonator tunable to the ground-state hyperfine splitting of ⁸⁷Rb. AIP Advances, 1(4):042107, December 2011. doi:10.1063/1.3651466.
Jens Koch, Terri M. Yu, Jay Gambetta, A. A. Houck, D. I. Schuster, J. Majer, Alexandre Blais, M. H. Devoret, S. M. Girvin, and R. J. Schoelkopf. Charge-insensitive qubit design derived from the Cooper pair box. Physical Review A, 76(4):042319, October 2007. doi:10.1103/PhysRevA.76.042319.
Alicia J. Kollár, Mattias Fitzpatrick, and Andrew A. Houck. Hyperbolic lattices in circuit quantum electrodynamics. Nature, 571(7763):45–50, July 2019. arXiv:1802.09549, doi:10.1038/s41586-019-1348-3.
Xuegang Li, Junhua Wang, Yao-Yao Jiang, Guang-Ming Xue, Xiaoxia Cai, Jun Zhou, Ming Gong, Zhao-Feng Liu, Shuang-Yu Zheng, Deng-Ke Ma, Mo Chen, Wei-Jie Sun, Shuang Yang, Fei Yan, Yi-Rong Jin, S. P. Zhao, Xue-Feng Ding, and Hai-Feng Yu. Cosmic-ray-induced correlated errors in superconducting qubit array. Nature Communications, 16(1):4677, May 2025. doi:10.1038/s41467-025-59778-z.
Xuegang Li, Yingshan Zhang, Chuhong Yang, Zhiyuan Li, Junhua Wang, Tang Su, Mo Chen, Yongchao Li, Chengyao Li, Zhenyu Mi, Xuehui Liang, Chenlu Wang, Zhen Yang, Yulong Feng, Kehuan Linghu, Huikai Xu, Jiaxiu Han, Weiyang Liu, Peng Zhao, Teng Ma, Ruixia Wang, Jingning Zhang, Yu Song, Pei Liu, Ziting Wang, Zhaohua Yang, Guangming Xue, Yirong Jin, and Haifeng Yu. Vacuum-gap transmon qubits realized using flip-chip technology. Applied Physics Letters, 119(18):184003, November 2021. doi:10.1063/5.0068255.
Z. R. Lin, K. Inomata, K. Koshino, W. D. Oliver, Y. Nakamura, J. S. Tsai, and T. Yamamoto. Josephson parametric phase-locked oscillator and its application to dispersive readout of superconducting qubits. Nature Communications, 5(1):4480, 2014. doi:10.1038/ncomms5480.
David M. Pozar. Microwave Engineering. John Wiley & Sons, Inc., 4 edition, 2012. ISBN 978-0-470-63155-3.
N. Maleeva, L. Grünhaupt, T. Klein, F. Levy-Bertrand, O. Dupre, M. Calvo, F. Valenti, P. Winkel, F. Friedrich, W. Wernsdorfer, A. V. Ustinov, H. Rotzinger, A. Monfardini, M. V. Fistul, and I. M. Pop. Circuit quantum electrodynamics of granular aluminum resonators. Nature Communications, 9(1):3889, September 2018. doi:10.1038/s41467-018-06386-9.
Justin L. Mallek, Donna-Ruth W. Yost, Danna Rosenberg, Jonilyn L. Yoder, Gregory Calusine, Matt Cook, Rabindra Das, Alexandra Day, Evan Golden, David K. Kim, Jeffery Knecht, Bethany M. Niedzielski, Mollie Schwartz, Arjan Sevi, Corey Stull, Wayne Woods, Andrew J. Kerman, and William D. Oliver. Fabrication of superconducting through-silicon vias. March 2021. doi:10.48550/arXiv.2103.08536.
Vladimir E. Manucharyan, Jens Koch, Leonid I. Glazman, and Michel H. Devoret. Fluxonium: Single Cooper-Pair Circuit Free of Charge Offsets. Science, 326(5949):113–116, October 2009. doi:10.1126/science.1175552.
Nicholas A. Masluk, Ioan M. Pop, Archana Kamal, Zlatko K. Minev, and Michel H. Devoret. Microwave Characterization of Josephson Junction Arrays: Implementing a Low Loss Superinductance. Physical Review Letters, 109(13):137002, September 2012. doi:10.1103/PhysRevLett.109.137002.
Laure Mercier de Lépinay, Erno Damskägg, Caspar F. Ockeloen-Korppi, and Mika A. Sillanpää. Realization of directional amplification in a microwave optomechanical device. Physical Review Applied, 11(3):034027, March 2019. doi:10.1103/PhysRevApplied.11.034027.
Long B. Nguyen, Yen-Hsiang Lin, Aaron Somoroff, Raymond Mencia, Nicholas Grabon, and Vladimir E. Manucharyan. High-Coherence Fluxonium Qubit. Physical Review X, 9(4):041041, December 2019. doi:10.1103/PhysRevX.9.041041.
I. Nsanzineza and B. L. T. Plourde. Trapping a single vortex and reducing quasiparticles in a superconducting resonator. Physical Review Letters, 113(11):117002, 2014. doi:10.1103/PhysRevLett.113.117002.
C. F. Ockeloen-Korppi, E. Damskägg, J.-M. Pirkkalainen, T. T. Heikkilä, F. Massel, and M. A. Sillanpää. Low-noise amplification and frequency conversion with a multiport microwave optomechanical device. Physical Review X, 6(4):041024, October 2016. doi:10.1103/PhysRevX.6.041024.
J.-M. Pirkkalainen, E. Damskägg, M. Brandt, F. Massel, and M. A. Sillanpää. Squeezing of quantum noise of motion in a micromechanical resonator. Physical Review Letters, 115(24):243601, December 2015. doi:10.1103/PhysRevLett.115.243601.
S. Pogorzalek, K. G. Fedorov, L. Zhong, J. Goetz, F. Wulschner, M. Fischer, P. Eder, E. Xie, K. Inomata, T. Yamamoto, Y. Nakamura, A. Marx, F. Deppe, and R. Gross. Hysteretic flux response and nondegenerate gain of flux-driven Josephson parametric amplifiers. Physical Review Applied, 8(2):024012, 2017. doi:10.1103/PhysRevApplied.8.024012.
V. Ranjan, S. Probst, B. Albanese, T. Schenkel, D. Vion, D. Esteve, J. J. L. Morton, and P. Bertet. Electron spin resonance spectroscopy with femtoliter detection volume. Applied Physics Letters, 116(18):184002, May 2020. doi:10.1063/5.0004322.
L. Richard, N. Bruckmoser, J. Feigl, D. Bunch, A. Bhattacharjee, L. Koch, I. Tsitsilin, V. P. Bader, H. Hu, L. Södergren, and S. Filipp. Accurate gap control of 3D-integrated superconducting quantum circuits using asymmetric indium architecture and multi-angle flip-chip bonding. October 2026. doi:10.48550/arXiv.2610.21435.
H. Riechert, S. Annabi, A. Peugeot, H. Duprez, M. Hantute, K. Watanabe, T. Taniguchi, E. Arrighi, J. Griesmar, J.-D. Pillet, and L. Bretheau. The carbon nanotube gatemon qubit. Nature Communications, 16(1):7197, August 2025. doi:10.1038/s41467-025-62283-y.
D. Rosenberg, D. Kim, R. Das, D. Yost, S. Gustavsson, D. Hover, P. Krantz, A. Melville, L. Racz, G. O. Samach, S. J. Weber, F. Yan, J. L. Yoder, A. J. Kerman, and W. D. Oliver. 3D integrated superconducting qubits. npj Quantum Information, 3(1):42, October 2017. doi:10.1038/s41534-017-0044-0.
Kirill Shulga, Shunsuke Nishimura, Pavel A. Volkov, Miu Hirano, Toshiaki Inada, Ryota Hasegawa, Takeyuki Tsuji, Takayuki Iwasaki, Mutsuko Hatano, Kento Sasaki, and Kensuke Kobayashi. Observation of individual vortex penetration in a coplanar superconducting resonator. Physical Review Letters, 137:116001, 2026. doi:10.1103/4zw3-hm6t.
Sasu Tuohino, Vasilii Vadimov, Wallace Teixeira, Tommi Malmelin, Matti Silveri, and Mikko Möttönen. Multimode physics of the unimon circuit. Physical Review Research, 6(3):033001, July 2024. doi:10.1103/PhysRevResearch.6.033001.
Mikko Tuokkola, Yoshiki Sunada, Heidi Kivijärvi, Jonatan Albanese, Leif Grönberg, Jukka-Pekka Kaikkonen, Visa Vesterinen, Joonas Govenius, and Mikko Möttönen. Methods to achieve near-millisecond energy relaxation and dephasing times for a superconducting transmon qubit. Nature Communications, 16(1):5421, July 2025. doi:10.1038/s41467-025-61126-0.
T. Yamamoto, K. Inomata, M. Watanabe, K. Matsuba, T. Miyazaki, W. D. Oliver, Y. Nakamura, and J. S. Tsai. Flux-driven Josephson parametric amplifier. Applied Physics Letters, 93(4):042510, July 2008. arXiv:0808.1386, doi:10.1063/1.2964182.
D. R. W. Yost, M. E. Schwartz, J. Mallek, D. Rosenberg, C. Stull, J. L. Yoder, G. Calusine, M. Cook, R. Das, A. L. Day, E. B. Golden, D. K. Kim, A. Melville, B. M. Niedzielski, W. Woods, A. J. Kerman, and W. D. Oliver. Solid-state qubits integrated with superconducting through-silicon vias. npj Quantum Information, 6(1):59, July 2020. doi:10.1038/s41534-020-00289-8.
Lei Zhu and Ke Wu. Accurate circuit model of interdigital capacitor and its application to design of new quasi-lumped miniaturized filters with suppression of harmonic resonance. IEEE Transactions on Microwave Theory and Techniques, 48(3):347–356, March 2000. doi:10.1109/22.826833.