How to Add Airbridges to Superconducting Qubit Chip Designs Using SQuADDS

SQuADDS provides an AirbridgeGenerator utility that automatically places airbridge structures on coplanar waveguides (CPWs) by calculating optimal placement points and validating against existing layout components.

Adding airbridges to superconducting qubit chip designs using SQuADDS (Superconducting QUantum Architecture Design & Development Suite) streamlines the fabrication workflow for complex quantum processors. The lfl-lab/squadds repository provides dedicated components that automate the placement of these critical crossover structures on coplanar waveguides without manual coordinate calculation.

Understanding Airbridges in Superconducting Circuits

Airbridges are essential geometrical features in superconducting quantum circuits that provide electrical connectivity between different ground planes while maintaining signal isolation. These structures appear as elevated metal bridges that cross over CPW traces, preventing parasitic slotline modes and improving flux pinning in the final fabricated device.

In SQuADDS, airbridges are treated as purely geometrical mask features rather than electromagnetic simulation elements. They appear in GDS output on specific fabrication layers but do not participate in capacitance or eigenmode simulations.

Core Components for Airbridge Integration

The Airbridge QComponent

The Airbridge class in squadds/components/airbridge/airbridge.py defines the low-level geometry for individual bridge structures. This QComponent draws the complete airbridge layout including inner connection pads, the elevated bridge rectangle, and associated fabrication layers.

The component accepts parameters for crossover length, bridge width, and layer assignments, defaulting to BR_layer=31 for the bridge layer and RR_layer=30 for the release layer in standard GDS output.

The AirbridgeGenerator Utility

The AirbridgeGenerator class in squadds/components/airbridge/airbridge_generator.py provides the high-level automation interface for placing multiple airbridges across target CPWs. This utility calculates optimal placement points using its internal find_ab_placement() method, which evaluates straight sections for spacing compliance and optionally processes curved sections when add_curved_ab=True.

The generator instantiates individual Airbridge components via make_single_ab() and validates each placement against existing layout entities using validate_airbridge() to prevent overlaps with couplers or other forbidden components.

Step-by-Step Workflow to Add Airbridges

Follow this three-step process to add airbridges to your superconducting qubit chip design:

1. Create the CPW geometry – Design your resonator, transmission line, or meander using Qiskit Metal primitives such as RouteMeander or OpenToGround.

2. Configure the AirbridgeGenerator – Instantiate the generator with your design object, target CPW components, and placement parameters. Calculate the crossover_length as CPW width plus twice the gap width if you want the bridge to span the full trace:

from squadds.components.airbridge.airbridge_generator import AirbridgeGenerator

# Calculate crossover length for full trace spanning

crossover_length = cpw_width + 2 * cpw_gap

AirbridgeGenerator(
    design=design,
    target_comps=[meander],           # List of CPW components to bridge

    crossover_length=[crossover_length],
    min_spacing=0.005,                # Minimum distance between bridges (≥ CPW gap)

    pitch=0.070,                      # Center-to-center spacing between bridges

    add_curved_ab=True                # Include airbridges on curved sections

)

3. Rebuild and export – Refresh the design visualization and export to GDS for fabrication:

gui.rebuild()
gui.zoom_on_components(['meander'])
gui.screenshot()

# Export to GDS - airbridges appear on layers 30 and 31

design.export_to_gds()

Key Implementation Files in SQuADDS

The airbridge functionality is implemented across these specific source files in the lfl-lab/squadds repository:

• squadds/components/airbridge/airbridge.py – Defines the Airbridge QComponent class that generates the physical bridge geometry including pads, bridge rectangles, and layer assignments.

• squadds/components/airbridge/airbridge_generator.py – Implements the AirbridgeGenerator class containing the placement algorithm (find_ab_placement()), validation logic (validate_airbridge()), and component instantiation (make_single_ab()).

• tutorials/Tutorial-6_Adding_Airbridges.ipynb – Provides a complete end-to-end demonstration including calculation of crossover_length, generator configuration, and GDS export.

Summary

Adding airbridges to superconducting qubit chip designs using SQuADDS requires understanding the separation between geometrical mask features and electromagnetic simulation elements. The key takeaways include:

• The Airbridge QComponent in airbridge.py handles low-level geometry generation for individual bridge structures.
• The AirbridgeGenerator utility automates placement across CPW traces with configurable spacing, pitch, and curved-section support.
• Airbridges are purely geometrical features that appear in GDS output but do not participate in electromagnetic simulations.
• The generator validates placements against existing components to prevent layout conflicts.

Frequently Asked Questions

What is the crossover_length parameter in SQuADDS airbridge generation?

The crossover_length parameter defines the total length of the airbridge structure that spans across the CPW trace. To cover the full trace width plus both gaps, calculate this value as the CPW center conductor width plus twice the gap distance (width + 2 × gap). The generator accepts this as a list to accommodate multiple target components with different geometries.

Do airbridges affect electromagnetic simulations in SQuADDS?

No, airbridges are treated as purely geometrical mask features and are not included in electromagnetic simulations. They exist only in the GDS fabrication output to provide physical connectivity between ground planes and suppress unwanted slotline modes in the actual fabricated device. When running capacitance or eigenmode simulations, the airbridge geometry is ignored.

How does the AirbridgeGenerator validate placement locations?

The AirbridgeGenerator uses its internal validate_airbridge() method to check each candidate placement against existing layout components. This validation ensures that generated airbridges do not overlap with couplers, junctions, or other forbidden structures that could cause fabrication conflicts or electrical shorts. Invalid placements are automatically filtered out before the final geometry is committed to the design.

Can airbridges be placed on curved sections of coplanar waveguides?

Yes, the AirbridgeGenerator supports placement on curved CPW sections when the add_curved_ab parameter is set to True. The generator's find_ab_placement() routine calculates appropriate spacing along curved geometries while maintaining the specified minimum spacing and pitch constraints. This ensures continuous ground plane connectivity even through meandered resonator paths or curved transmission lines.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}