Models

qpdk.models contains frequency-domain circuit models for the QPDK components, built on SAX, together with the analytical helpers used to design them. Install them with pip install qpdk[models].

SAX models

Qubits

Transmon, fluxonium, flipmon, unimon and gatemon circuits, bare or coupled to a resonator.

22 functions

#models-qubits

Resonators

Quarter- and half-wave transmission-line resonators and their coupled variants.

9 functions

#models-resonators

Couplers

Straight and ring couplers between CPW lines.

2 functions

#models-couplers

Capacitors and inductors

Interdigital and plate capacitors, meander inductors and lumped-element and nanowire resonators, including the ESR LC resonator.

7 functions

#models-lumped

Josephson junctions

Single junctions and SQUIDs.

4 functions

#models-junctions

Waveguides and interconnects

Straights, bends, tapers, launchers, airbridges, bumps, TSVs, rectangles and generic N-port blocks.

20 functions

#models-waveguides

Generic circuit elements

Opens, shorts, series and shunt elements and ideal LC resonators.

10 functions

#models-generic

Other

7 functions

#models-sax-other

Helper functions

Transmission-line parameters

Effective permittivity, characteristic impedance and propagation of CPW and microstrip lines.

11 functions

#models-transmission-lines

Qubit parameters

Conversions between circuit energies, capacitances and inductances, and unimon and gatemon spectra.

23 functions

#models-qubit-parameters

Perturbation theory

Transmon frequency and anharmonicity, dispersive shifts, Purcell decay, linewidths and dephasing.

6 functions

#models-perturbation

Component helpers

Closed-form estimates for resonators, couplers and inductors.

10 functions

#models-component-helpers

Other

9 functions

#models-helpers-other

SAX models

Frequency-domain models returning S-parameter dictionaries (sax.SDict). Pass them to sax.circuit() to simulate netlists, or call them directly with a frequency array f.

Qubits

Transmon, fluxonium, flipmon, unimon and gatemon circuits, bare or coupled to a resonator.

double_island_transmon	LC resonator model for a double-island transmon qubit.
double_island_transmon_with_bbox	LC resonator model for a double-island transmon qubit with bounding box ports.
double_island_transmon_with_resonator	Model for a double-island transmon qubit coupled to a quarter-wave resonator.
double_pad_transmon	LC resonator model for a double-pad transmon qubit.
double_pad_transmon_with_bbox	LC resonator model for a double-pad transmon qubit.
double_pad_transmon_with_resonator	Model for a double-island transmon qubit coupled to a quarter-wave resonator.
flipmon	LC resonator model for a flipmon qubit.
flipmon_with_bbox	LC resonator model for a flipmon qubit with bounding box ports.
flipmon_with_resonator	Model for a flipmon qubit coupled to a quarter-wave resonator.
fluxonium	S-parameter model for a fluxonium qubit.
fluxonium_coupled	Coupled fluxonium qubit model.
fluxonium_with_bbox	S-parameter model for a fluxonium qubit with bounding box ports.
fluxonium_with_resonator	Model for a fluxonium qubit coupled to a quarter-wave resonator.
gatemon	LC resonator model for a grounded gatemon qubit.
gatemon_coupler	Model a complete CPW section with a capacitive branch to the island.
gatemon_island	Model the island and gate terminals used by the gatemon layout.
qubit_with_resonator	Model for a transmon qubit coupled to a quarter-wave resonator.
shunted_transmon	LC resonator model for a shunted transmon qubit.
transmon_coupled	Coupled transmon qubit model.
transmon_with_resonator	Model for a transmon qubit coupled to a quarter-wave resonator.
unimon_coupled	SAX model for a capacitively coupled unimon qubit.
xmon_transmon	LC resonator model for an Xmon style transmon qubit.

double_island_transmon

qpdk.models.double_island_transmon(f=5000000000.0, capacitance=1e-13, inductance=7e-09, ground_capacitance=0.0)

LC resonator model for a double-island transmon qubit.

A double-island transmon has two superconducting islands connected by Josephson junctions, with both islands floating (not grounded). This is modeled as an ungrounded parallel LC resonator.

The qubit frequency is approximately:

\[f_\text{q} \approx \frac{1}{2\pi} \sqrt{8 E_\text{J} E_\text{C}} - E_\text{C}\]

For the LC model, the resonance frequency is:

\[f_\text{r} = \frac{1}{2\pi\sqrt{LC}}\]

Use ec_to_capacitance() and ej_to_inductance() to convert from qubit Hamiltonian parameters.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (FloatArrayLike) – Total capacitance \(C_\Sigma\) of the qubit in Farads.

• inductance (FloatArrayLike) – Josephson inductance \(L_\text{J}\) in Henries.

• ground_capacitance (FloatArrayLike) – Parasitic capacitance to ground \(C_\text{g}\) at each port in Farads.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.double_island_transmon() S-parameters for \(f\in[1,10]\,\text{GHz}\).

double_island_transmon_with_bbox

qpdk.models.double_island_transmon_with_bbox(f=5000000000.0, capacitance=1e-13, inductance=7e-09, ground_capacitance=0.0)

LC resonator model for a double-island transmon qubit with bounding box ports.

This model is the same as double_island_transmon().

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• capacitance (FloatArrayLike)

• inductance (FloatArrayLike)

• ground_capacitance (FloatArrayLike)

(Source code, svg, pdf, png)

qpdk.models.double_island_transmon_with_bbox() S-parameters for \(f\in[1,10]\,\text{GHz}\).

double_island_transmon_with_resonator

qpdk.models.double_island_transmon_with_resonator(f=5000000000.0, qubit_capacitance=1e-13, qubit_inductance=1e-09, resonator_length=5000.0, resonator_cross_section='cpw', coupling_capacitance=1e-14)

Model for a double-island transmon qubit coupled to a quarter-wave resonator.

This model is identical to qubit_with_resonator() but the qubit is set to floating.

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• qubit_capacitance (float)

• qubit_inductance (float)

• resonator_length (float)

• resonator_cross_section (str)

• coupling_capacitance (float)

(Source code, svg, pdf, png)

qpdk.models.double_island_transmon_with_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

double_pad_transmon

qpdk.models.double_pad_transmon(f=5000000000.0, capacitance=1e-13, inductance=7e-09, ground_capacitance=0.0)

LC resonator model for a double-pad transmon qubit.

Physically the double_island_transmon() model, with ports renamed to left_pad and right_pad to match the layout cell ports.

Returns:

S-parameters dictionary with ports left_pad and right_pad.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• capacitance (FloatArrayLike)

• inductance (FloatArrayLike)

• ground_capacitance (FloatArrayLike)

Schematic symbol drawn by GDSFactory+ for qpdk.models.double_pad_transmon().

(Source code, svg, pdf, png)

qpdk.models.double_pad_transmon() S-parameters for \(f\in[1,10]\,\text{GHz}\).

double_pad_transmon_with_bbox

qpdk.models.double_pad_transmon_with_bbox(f=5000000000.0, capacitance=1e-13, inductance=7e-09, ground_capacitance=0.0)

LC resonator model for a double-pad transmon qubit.

Physically the double_island_transmon() model, with ports renamed to left_pad and right_pad to match the layout cell ports.

Returns:

S-parameters dictionary with ports left_pad and right_pad.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• capacitance (FloatArrayLike)

• inductance (FloatArrayLike)

• ground_capacitance (FloatArrayLike)

Schematic symbol drawn by GDSFactory+ for qpdk.models.double_pad_transmon_with_bbox().

(Source code, svg, pdf, png)

qpdk.models.double_pad_transmon_with_bbox() S-parameters for \(f\in[1,10]\,\text{GHz}\).

double_pad_transmon_with_resonator

qpdk.models.double_pad_transmon_with_resonator(f=5000000000.0, qubit_capacitance=1e-13, qubit_inductance=1e-09, resonator_length=5000.0, resonator_cross_section='cpw', coupling_capacitance=1e-14)

Model for a double-island transmon qubit coupled to a quarter-wave resonator.

This model is identical to qubit_with_resonator() but the qubit is set to floating.

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• qubit_capacitance (float)

• qubit_inductance (float)

• resonator_length (float)

• resonator_cross_section (str)

• coupling_capacitance (float)

(Source code, svg, pdf, png)

qpdk.models.double_pad_transmon_with_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

flipmon

qpdk.models.flipmon(f=5000000000.0, capacitance=1e-13, inductance=7e-09, ground_capacitance=0.0)

LC resonator model for a flipmon qubit.

This model is identical to double_island_transmon().

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• capacitance (FloatArrayLike)

• inductance (FloatArrayLike)

• ground_capacitance (FloatArrayLike)

(Source code, svg, pdf, png)

qpdk.models.flipmon() S-parameters for \(f\in[1,10]\,\text{GHz}\).

flipmon_with_bbox

qpdk.models.flipmon_with_bbox(f=5000000000.0, capacitance=1e-13, inductance=7e-09, ground_capacitance=0.0)

LC resonator model for a flipmon qubit with bounding box ports.

This model is the same as flipmon().

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• capacitance (FloatArrayLike)

• inductance (FloatArrayLike)

• ground_capacitance (FloatArrayLike)

(Source code, svg, pdf, png)

qpdk.models.flipmon_with_bbox() S-parameters for \(f\in[1,10]\,\text{GHz}\).

flipmon_with_resonator

qpdk.models.flipmon_with_resonator(f=5000000000.0, qubit_capacitance=1e-13, qubit_inductance=1e-09, resonator_length=5000.0, resonator_cross_section='cpw', coupling_capacitance=1e-14)

Model for a flipmon qubit coupled to a quarter-wave resonator.

This model is identical to qubit_with_resonator() but the qubit is set to floating.

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• qubit_capacitance (float)

• qubit_inductance (float)

• resonator_length (float)

• resonator_cross_section (str)

• coupling_capacitance (float)

(Source code, svg, pdf, png)

qpdk.models.flipmon_with_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

fluxonium

qpdk.models.fluxonium(f=5000000000.0, capacitance=1e-14, josephson_inductance=1e-08, superinductance=5e-07, ground_capacitance=0.0)

S-parameter model for a fluxonium qubit.

A fluxonium qubit consists of a Josephson junction shunted by a large superinductance and a capacitor. In the linear regime, this is modeled as a parallel LCL circuit.

For an accurate microwave model reflecting the real physical layout, the circuit is treated as ungrounded (floating) with optional symmetric parasitic capacitances connecting both ends to ground [NLS+19].

Note

The total shunt capacitance capacitance should include the pads, junction capacitance, and parasitic meander capacitance. Spurious array self-resonance (SR) modes can be phenomenologically modeled by adding to the shunt capacitance or using a multimode model.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (float) – Total shunt capacitance \(C_\Sigma\) in Farads.

• josephson_inductance (float) – Josephson inductance \(L_\text{J}\) in Henries.

• superinductance (float) – Superinductance \(L_\text{s}\) in Henries.

• ground_capacitance (float) – Parasitic capacitance to ground \(C_\text{g}\) at each port in Farads.

Returns:

S-parameters dictionary with ports left_pad and right_pad.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.fluxonium().

(Source code, svg, pdf, png)

qpdk.models.fluxonium() S-parameters for \(f\in[1,10]\,\text{GHz}\).

fluxonium_coupled

qpdk.models.fluxonium_coupled(f=5000000000.0, capacitance=1e-14, josephson_inductance=1e-08, superinductance=5e-07, ground_capacitance=0.0, coupling_capacitance=1e-14, coupling_inductance=0.0)

Coupled fluxonium qubit model.

This model adds a coupling network to the fluxonium model.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (float) – Total shunt capacitance \(C_\Sigma\) in Farads.

• josephson_inductance (float) – Josephson inductance \(L_\text{J}\) in Henries.

• superinductance (float) – Superinductance \(L_\text{s}\) in Henries.

• ground_capacitance (float) – Parasitic capacitance to ground \(C_\text{g}\) in Farads.

• coupling_capacitance (float) – Coupling capacitance \(C_\text{c}\) in Farads.

• coupling_inductance (float) – Coupling inductance \(L_\text{c}\) in Henries.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.fluxonium_coupled() S-parameters for \(f\in[1,10]\,\text{GHz}\).

fluxonium_with_bbox

qpdk.models.fluxonium_with_bbox(f=5000000000.0, capacitance=1e-14, josephson_inductance=1e-08, superinductance=5e-07, ground_capacitance=0.0)

S-parameter model for a fluxonium qubit with bounding box ports.

This model is the same as fluxonium().

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• capacitance (float)

• josephson_inductance (float)

• superinductance (float)

• ground_capacitance (float)

Schematic symbol drawn by GDSFactory+ for qpdk.models.fluxonium_with_bbox().

(Source code, svg, pdf, png)

qpdk.models.fluxonium_with_bbox() S-parameters for \(f\in[1,10]\,\text{GHz}\).

fluxonium_with_resonator

qpdk.models.fluxonium_with_resonator(f=5000000000.0, capacitance=1e-14, josephson_inductance=1e-08, superinductance=5e-07, ground_capacitance=0.0, resonator_length=5000.0, resonator_cross_section='cpw', coupling_capacitance=1e-14)

Model for a fluxonium qubit coupled to a quarter-wave resonator.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (float) – Total shunt capacitance \(C_\Sigma\) in Farads.

• josephson_inductance (float) – Josephson inductance \(L_\text{J}\) in Henries.

• superinductance (float) – Superinductance \(L_\text{s}\) in Henries.

• ground_capacitance (float) – Parasitic capacitance to ground \(C_\text{g}\) in Farads.

• resonator_length (float) – Length of the quarter-wave resonator in µm.

• resonator_cross_section (str) – Cross-section specification for the resonator.

• coupling_capacitance (float) – Coupling capacitance between qubit and resonator in Farads.

Returns:

S-parameters dictionary.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.fluxonium_with_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

gatemon

qpdk.models.gatemon(f=5000000000.0, capacitance=1e-13, delta_ghz=50.0, transmissions=(0.8,), ground_capacitance=0.0)

LC resonator model for a grounded gatemon qubit.

The island is shunted to ground through the junction, using the same circuit as shunted_transmon(). The junction is linearised around \(\varphi = 0\): its inductance is

\[L_\text{J} = \left(\frac{\Phi_0}{2\pi}\right)^2 \frac{1}{E_\text{J}}, \qquad E_\text{J} = \left.\frac{\partial^2 U}{\partial \varphi^2}\right|_{\varphi=0} = \frac{\Delta}{4} \sum_p \tau_p ,\]

see gatemon_josephson_energy(). This small-signal model has no anharmonicity; use gatemon_frequency_and_anharmonicity() for the qubit spectrum. The defaults give \(E_\text{J} = 10\) GHz.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (FloatArrayLike) – Total capacitance \(C_\Sigma\) of the island in Farads.

• delta_ghz (FloatArrayLike) – Induced superconducting gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Gate-tuned channel transmissions \(\tau_p\).

• ground_capacitance (FloatArrayLike) – Parasitic capacitance to ground \(C_\text{g}\) at the floating port in Farads.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.gatemon() S-parameters for \(f\in[1,10]\,\text{GHz}\).

gatemon_coupler

qpdk.models.gatemon_coupler(f=5000000000.0, length=600.0, coupling_position=200.0, coupling_capacitance=5.4e-15, cross_section='cpw')

Model a complete CPW section with a capacitive branch to the island.

Split the distributed line at coupling_position and connect the lumped coupling capacitor there. Both line lengths contribute to the resonator. The nominal capacitance gives roughly 50 MHz coupling near the paper’s readout frequency; it is not a geometric extraction.

Parameters:

• f (FloatArrayLike) – Frequency in Hz.

• length (Float) – Complete coupling CPW length in µm.

• coupling_position (Float) – Capacitive tap measured from o1 in µm.

• coupling_capacitance (FloatArrayLike) – CPW-to-island capacitance in F.

• cross_section (CrossSectionSpec) – Cross-section of the CPW.

Returns:

Three-port S-parameters named o1, o2 and qubit.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.gatemon_coupler().

(Source code, svg, pdf, png)

qpdk.models.gatemon_coupler() S-parameters for \(f\in[1,10]\,\text{GHz}\).

gatemon_island

qpdk.models.gatemon_island(f=5000000000.0, capacitance=4.91e-14, gate_capacitance=2e-14, delta_ghz=50.0, transmissions=(0.8,), gate_ground_capacitance=3.5e-14)

Model the island and gate terminals used by the gatemon layout.

The readout port touches the island itself. Its coupling capacitor is in gatemon_coupler(), not in this model. The island has a grounded Josephson inductance and a shunt capacitance, with a mutual capacitance to gate. The nominal 49.1 fF shunt, 20 fF gate and external 5.4 fF readout capacitance give \(E_\text{C}/h \approx 260\,\text{MHz}\). Each contact has 18 square micrometres of top-gate overlap. With the nominal 30 nm hBN and relative permittivity 3.4, the parallel-plate estimate is about 18 fF per contact. Including the M1 feed gives rounded estimates of 20 fF to the island and 35 fF to ground. The island shunt retains the charging-energy target. A full hybrid extraction and measured flake thickness are needed to replace these estimates.

Parameters:

• f (FloatArrayLike) – Positive frequency in Hz.

• capacitance (FloatArrayLike) – Island capacitance to ground in F, excluding mutual terms.

• gate_capacitance (FloatArrayLike) – Island-to-gate capacitance in F.

• delta_ghz (FloatArrayLike) – Induced superconducting gap in GHz.

• transmissions (ArrayLike | Sequence[float]) – Gate-tuned channel transmissions. Zero opens the junction.

• gate_ground_capacitance (FloatArrayLike) – Gate capacitance to ground in F, excluding the mutual term.

Returns:

Jittable two-port S-parameters named readout and gate, referenced to 50 ohm.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.gatemon_island().

(Source code, svg, pdf, png)

qpdk.models.gatemon_island() S-parameters for \(f\in[1,10]\,\text{GHz}\).

qubit_with_resonator

qpdk.models.qubit_with_resonator(f=5000000000.0, qubit_capacitance=1e-13, qubit_inductance=1e-09, qubit_grounded=False, resonator_length=5000.0, resonator_cross_section='cpw', coupling_capacitance=1e-14)

Model for a transmon qubit coupled to a quarter-wave resonator.

This model corresponds to the layout function transmon_with_resonator().

The model combines: - A transmon qubit (LC resonator) - A quarter-wave coplanar waveguide resonator - A coupling capacitor connecting the qubit to the resonator

The qubit can be either: - A double-island transmon (qubit_grounded=False): both islands floating - A shunted transmon (qubit_grounded=True): one island grounded

Use ec_to_capacitance() and ej_to_inductance() to convert from qubit Hamiltonian parameters (\(E_\text{C}\), \(E_\text{J}\)) to circuit parameters.

Note

This function is not JIT-compiled because it depends on straight_shorted(), which internally uses cpw_parameters for transmission line modeling.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• qubit_capacitance (float) – Total capacitance \(C_\Sigma\) of the qubit in Farads. Convert from charging energy using ec_to_capacitance().

• qubit_inductance (float) – Josephson inductance \(L_\text{J}\) in Henries. Convert from Josephson energy using ej_to_inductance().

• qubit_grounded (bool) – If True, the qubit is a shunted transmon (grounded). If False, it is a double-island transmon (ungrounded).

• resonator_length (float) – Length of the quarter-wave resonator in µm.

• resonator_cross_section (str) – Cross-section specification for the resonator.

• coupling_capacitance (float) – Coupling capacitance between qubit and resonator in Farads. Use coupling_strength_to_capacitance() to convert from qubit-resonator coupling strength \(g\).

Returns:

S-parameters dictionary with ports o1 (resonator input)

and o2 (qubit ground or floating).

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.qubit_with_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

shunted_transmon

qpdk.models.shunted_transmon(f=5000000000.0, capacitance=1e-13, inductance=7e-09, ground_capacitance=0.0)

LC resonator model for a shunted transmon qubit.

A shunted transmon has one island grounded and the other island connected to the junction. This is modeled as a grounded parallel LC resonator.

The qubit frequency is approximately:

\[f_\text{q} \approx \frac{1}{2\pi} \sqrt{8 E_\text{J} E_\text{C}} - E_\text{C}\]

For the LC model, the resonance frequency is:

\[f_\text{r} = \frac{1}{2\pi\sqrt{LC}}\]

Use ec_to_capacitance() and ej_to_inductance() to convert from qubit Hamiltonian parameters.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (FloatArrayLike) – Total capacitance \(C_\Sigma\) of the qubit in Farads.

• inductance (FloatArrayLike) – Josephson inductance \(L_\text{J}\) in Henries.

• ground_capacitance (FloatArrayLike) – Parasitic capacitance to ground \(C_\text{g}\) at the floating port in Farads.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.shunted_transmon() S-parameters for \(f\in[1,10]\,\text{GHz}\).

transmon_coupled

qpdk.models.transmon_coupled(f=5000000000.0, capacitance=1e-13, inductance=1e-09, grounded=False, ground_capacitance=0.0, coupling_capacitance=1e-14, coupling_inductance=0.0)

Coupled transmon qubit model.

This model extends the basic transmon qubit by adding a coupling network consisting of a parallel capacitor and/or inductor. This can represent capacitive or inductive coupling between qubits or between a qubit and a readout resonator.

The coupling network is connected in series with the LC resonator:

For capacitive coupling (common for qubit-resonator coupling):

• Set coupling_capacitance to the coupling capacitor value

• Set coupling_inductance=0.0

For inductive coupling (common for flux-tunable coupling):

• Set coupling_inductance to the coupling inductor value

• Set coupling_capacitance=0.0 (or small value)

Use coupling_strength_to_capacitance() to convert from the qubit-resonator coupling strength \(g\) to the coupling capacitance.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (FloatArrayLike) – Total capacitance \(C_\Sigma\) of the qubit in Farads.

• inductance (FloatArrayLike) – Josephson inductance \(L_\text{J}\) in Henries.

• grounded (bool) – If True, the qubit is a shunted transmon (grounded). If False, it is a double-pad transmon (ungrounded).

• ground_capacitance (FloatArrayLike) – Parasitic capacitance to ground \(C_\text{g}\) in Farads.

• coupling_capacitance (FloatArrayLike) – Coupling capacitance \(C_\text{c}\) in Farads.

• coupling_inductance (FloatArrayLike) – Coupling inductance \(L_\text{c}\) in Henries.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.transmon_coupled() S-parameters for \(f\in[1,10]\,\text{GHz}\).

transmon_with_resonator

qpdk.models.transmon_with_resonator(f=5000000000.0, qubit_capacitance=1e-13, qubit_inductance=1e-09, qubit_grounded=False, resonator_length=5000.0, resonator_cross_section='cpw', coupling_capacitance=1e-14)

Model for a transmon qubit coupled to a quarter-wave resonator.

This model is identical to qubit_with_resonator().

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• qubit_capacitance (float)

• qubit_inductance (float)

• qubit_grounded (bool)

• resonator_length (float)

• resonator_cross_section (str)

• coupling_capacitance (float)

(Source code, svg, pdf, png)

qpdk.models.transmon_with_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

unimon_coupled

qpdk.models.unimon_coupled(f=5000000000.0, arm_length=3000.0, cross_section='cpw', junction_capacitance=5e-15, junction_inductance=-7e-09, coupling_capacitance=1e-14)

SAX model for a capacitively coupled unimon qubit.

The unimon is modeled as a closed system of two shorted quarter-wave CPW resonators connected by a Josephson junction. Interaction with the qubit is provided via a single coupling capacitor connected to one of the arms.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• arm_length (float) – Length of each quarter-wave resonator arm in µm.

• cross_section (str) – Cross-section specification for the CPW arms.

• junction_capacitance (float) – Junction capacitance \(C_\text{J}\) in Farads.

• junction_inductance (float) – Junction inductance \(L_\text{J}\) in Henries.

• coupling_capacitance (float) – Coupling capacitance \(C_\text{c}\) in Farads.

Returns:

S-parameters dictionary with a single port coupling_o3.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.unimon_coupled().

(Source code, svg, pdf, png)

qpdk.models.unimon_coupled() S-parameters for \(f\in[1,10]\,\text{GHz}\).

xmon_transmon

qpdk.models.xmon_transmon(f=5000000000.0, capacitance=1e-13, inductance=7e-09)

LC resonator model for an Xmon style transmon qubit.

An Xmon transmon is typically shunted, so this model wraps shunted_transmon().

Returns:

S-parameters dictionary.

Return type:

SDict

Parameters:

• f (FloatArrayLike)

• capacitance (FloatArrayLike)

• inductance (FloatArrayLike)

(Source code, svg, pdf, png)

qpdk.models.xmon_transmon() S-parameters for \(f\in[1,10]\,\text{GHz}\).

Resonators

Quarter- and half-wave transmission-line resonators and their coupled variants.

cpw_bulge	S-parameter model for a CPW with a locally widened centre conductor.
neck_termination	S-parameter model for a CPW shorted through a taper and a narrow neck.
quarter_wave_resonator_coupled	Model for a quarter-wave coplanar waveguide resonator coupled to a probeline.
resonator	S-parameter model for a simple transmission line resonator.
resonator_coupled	Model for a coplanar waveguide resonator coupled to a probeline.
resonator_half_wave	S-parameter model for a half-wave resonator (open at both ends).
resonator_half_wave_bulge	S-parameter model for a half-wave resonator with a central bulge.
resonator_quarter_wave	S-parameter model for a quarter-wave resonator (shorted at one end).
resonator_quarter_wave_neck	S-parameter model for a quarter-wave resonator grounded through a neck.

cpw_bulge

qpdk.models.cpw_bulge(f=5000000000.0, cross_section='cpw', bulge_width=25.0, bulge_length=50.0, taper_length=20.0, npoints=5)

S-parameter model for a CPW with a locally widened centre conductor.

Linear tapers to and from a section of width bulge_width, all with the gap of cross_section, matching qpdk.cells.vortex.cpw_bulge(). See [NP14] for the measurement.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• cross_section (CrossSectionSpec) – CPW cross-section at both ports.

• bulge_width (float) – Width of the widened centre conductor in µm.

• bulge_length (float) – Length of the full-width section in µm.

• taper_length (float) – Length of each linear taper in µm.

• npoints (int | Array) – Number of segments each taper is divided into. Must be concrete (not traced); float arrays are truncated to int.

Returns:

Two-port S-parameters with ports o1 and o2.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.cpw_bulge().

(Source code, svg, pdf, png)

qpdk.models.cpw_bulge() S-parameters for \(f\in[1,10]\,\text{GHz}\).

neck_termination

qpdk.models.neck_termination(f=5000000000.0, cross_section='cpw', taper_length=100.0, taper_shape='linear', neck_width=2.0, neck_length=325.0, window_width=380.0, npoints=10)

S-parameter model for a CPW shorted through a taper and a narrow neck.

The taper and neck run inside an etched window of width \(W\), so each segment is a CPW of strip width \(w\) and gap \((W - w)/2\). The neck joins the ground plane at the far end of the window, modelled as an ideal short. See qpdk.cells.vortex.neck_termination() for the geometry and [SNV+26] for the measurement.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• cross_section (CrossSectionSpec) – CPW cross-section at port o1.

• taper_length (float) – Length of the taper in µm.

• taper_shape (Literal['linear', 'smooth']) – "linear" or "smooth" (raised-cosine) width profile.

• 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.

• npoints (int | Array) – Number of segments the taper is divided into. Must be concrete (not traced); float arrays are truncated to int.

Returns:

One-port S-parameters with port o1.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.neck_termination().

(Source code, svg, pdf, png)

qpdk.models.neck_termination() S-parameters for \(f\in[1,10]\,\text{GHz}\).

quarter_wave_resonator_coupled

qpdk.models.quarter_wave_resonator_coupled(f=5000000000.0, length=4000.0, coupling_gap=20.0, coupling_straight_length=200.0, cross_section='cpw', cross_section_non_resonator='cpw')

Model for a quarter-wave coplanar waveguide resonator coupled to a probeline.

Parameters:

• cross_section (CrossSectionSpec) – The cross-section of the CPW.

• f (FloatArrayLike) – Frequency in Hz at which to evaluate the S-parameters.

• length (float) – Total length of the resonator in μm.

• coupling_gap (float) – Gap between the resonator and the probeline in μm.

• coupling_straight_length (float) – Length of the coupling section in μm.

• cross_section_non_resonator (CrossSectionSpec | None) – Cross-section of the coupling waveguide. If None, uses cross_section.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.quarter_wave_resonator_coupled().

(Source code, svg, pdf, png)

qpdk.models.quarter_wave_resonator_coupled() S-parameters for \(f\in[1,10]\,\text{GHz}\).

resonator

qpdk.models.resonator(f=5000000000.0, length=4000.0, cross_section='cpw')

S-parameter model for a simple transmission line resonator.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.resonator().

(Source code, svg, pdf, png)

qpdk.models.resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

resonator_coupled

qpdk.models.resonator_coupled(f=5000000000.0, length=4000.0, coupling_gap=20.0, coupling_straight_length=200.0, cross_section='cpw', cross_section_non_resonator='cpw', open_start=True, open_end=False)

Model for a coplanar waveguide resonator coupled to a probeline.

Parameters:

• cross_section (CrossSectionSpec) – The cross-section of the CPW.

• f (FloatArrayLike) – Frequency in Hz at which to evaluate the S-parameters.

• length (float) – Total length of the resonator in μm.

• coupling_gap (float) – Gap between the resonator and the probeline in μm.

• coupling_straight_length (float) – Length of the coupling section in μm.

• cross_section_non_resonator (CrossSectionSpec | None) – Cross-section of the coupling waveguide. If None, uses cross_section.

• open_start (bool) – If True, adds an electrical open at the start.

• open_end (bool) – If True, adds an electrical open at the end.

Returns:

S-parameters dictionary with 4 ports.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.resonator_coupled().

(Source code, svg, pdf, png)

qpdk.models.resonator_coupled() S-parameters for \(f\in[1,10]\,\text{GHz}\).

resonator_half_wave

qpdk.models.resonator_half_wave(f=5000000000.0, length=4000.0, cross_section='cpw')

S-parameter model for a half-wave resonator (open at both ends).

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.resonator_half_wave().

(Source code, svg, pdf, png)

qpdk.models.resonator_half_wave() S-parameters for \(f\in[1,10]\,\text{GHz}\).

resonator_half_wave_bulge

qpdk.models.resonator_half_wave_bulge(f=5000000000.0, length=8000.0, cross_section='cpw', bulge_width=25.0, bulge_length=50.0, taper_length=20.0, npoints=5)

S-parameter model for a half-wave resonator with a central bulge.

Two equal CPW sections on either side of cpw_bulge(), with open ends at ports o1 and o2.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• length (float) – Total centre-line length, including the bulge, in µm.

• 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().

• npoints (int | Array) – See cpw_bulge().

Returns:

Two-port S-parameters with ports o1 and o2.

Return type:

SDict

Raises:

ValueError – If a concrete length is shorter than the bulge.

Schematic symbol drawn by GDSFactory+ for qpdk.models.resonator_half_wave_bulge().

(Source code, svg, pdf, png)

qpdk.models.resonator_half_wave_bulge() S-parameters for \(f\in[1,10]\,\text{GHz}\).

resonator_quarter_wave

qpdk.models.resonator_quarter_wave(f=5000000000.0, length=4000.0, cross_section='cpw')

S-parameter model for a quarter-wave resonator (shorted at one end).

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.resonator_quarter_wave().

(Source code, svg, pdf, png)

qpdk.models.resonator_quarter_wave() S-parameters for \(f\in[1,10]\,\text{GHz}\).

resonator_quarter_wave_neck

qpdk.models.resonator_quarter_wave_neck(f=5000000000.0, length=4000.0, cross_section='cpw', taper_length=100.0, taper_shape='linear', neck_width=2.0, neck_length=325.0, window_width=380.0, npoints=10)

S-parameter model for a quarter-wave resonator grounded through a neck.

A CPW of length followed by neck_termination(). Port o1 is the open end, as in qpdk.cells.vortex.resonator_quarter_wave_neck().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• length (float) – CPW length from the open end to the start of the taper in µm.

• 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().

• npoints (int | Array) – See neck_termination().

Returns:

One-port S-parameters with port o1.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.resonator_quarter_wave_neck().

(Source code, svg, pdf, png)

qpdk.models.resonator_quarter_wave_neck() S-parameters for \(f\in[1,10]\,\text{GHz}\).

Couplers

Straight and ring couplers between CPW lines.

coupler_ring	S-parameter model for two coupled coplanar waveguides in a ring configuration.
coupler_straight	S-parameter model for two coupled coplanar waveguides, coupler_straight().

coupler_ring

qpdk.models.coupler_ring(f=5000000000.0, length_x=20.0, gap=16, cross_section='cpw')

S-parameter model for two coupled coplanar waveguides in a ring configuration.

The implementation is the same as straight coupler for now.

TODO: Fetch coupling capacitance from a curved simulation library.

Parameters:

• f (ArrayLike) – Array of frequency points in Hz

• length_x (int | float) – Physical length of coupling section in µm

• gap (int | float) – Gap between the coupled waveguides in µm

• cross_section (CrossSectionSpec) – The cross-section of the CPW.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.coupler_ring().

(Source code, svg, pdf, png)

qpdk.models.coupler_ring() S-parameters for \(f\in[1,10]\,\text{GHz}\).

coupler_straight

qpdk.models.coupler_straight(f=5000000000.0, length=10, gap=16, cross_section='cpw', cross_section_non_resonator=None, resonator_offset=0.0)

S-parameter model for two coupled coplanar waveguides, coupler_straight().

Parameters:

• f (ArrayLike) – Array of frequency points in Hz

• length (int | float) – Physical length of coupling section in µm

• gap (int | float) – Gap between the coupled waveguides in µm

• cross_section (CrossSectionSpec) – The cross-section of the CPW.

• cross_section_non_resonator (CrossSectionSpec | None) – Optional cross section of the upper bus.

• resonator_offset (float) – Lower trace layout offset in µm; the legacy model retains the full nominal coupling length.

Returns:

S-parameters dictionary

Return type:

SDict

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

Schematic symbol drawn by GDSFactory+ for qpdk.models.coupler_straight().

(Source code, svg, pdf, png)

qpdk.models.coupler_straight() S-parameters for \(f\in[1,10]\,\text{GHz}\).

Capacitors and inductors

Interdigital and plate capacitors, meander inductors and lumped-element and nanowire resonators, including the ESR LC resonator.

esr_lc_resonator	SAX model of qpdk.cells.esr_lc_resonator().
interdigital_capacitor	Interdigital capacitor Sax model.
lumped_element_resonator	Lumped-element LC resonator SAX model.
meander_inductor	Meander inductor SAX model.
nanowire_resonator	SAX model of qpdk.cells.nanowire_resonator().
plate_capacitor	Facing coupling pads with their finite-frame ground capacitances.
plate_capacitor_analytical	Closed-form series capacitance of two coplanar pads, without ground branches.

esr_lc_resonator

qpdk.models.esr_lc_resonator(*, f=5000000000.0, wire_width=5.0, wire_length=730.0, fingers=12, finger_length=800.0, finger_gap=50.0, finger_thickness=50.0, film_thickness=0.05, sheet_inductance=4e-13, coupling_capacitance=8.5e-15, ground_capacitance=1e-13, cross_section='cpw')

SAX model of qpdk.cells.esr_lc_resonator().

The circuit of esr_lc_resonator_parameters() is assembled from generic models: a sax.models.rf.tee() on the feedline, the coupling sax.models.rf.capacitor(), and the floating lc_resonator() with its ground_capacitance, whose far port is left open with open() [MP12]. \(|S_{21}|\) vanishes at \(\omega_\text{r}\). The feedline is treated as lossless and of zero length. At DC or with \(C_\text{c} = 0\) the branch is open and the feedline transmits fully.

Design references are [BPK+16, RPA+20].

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• wire_width (float) – Wire width in µm.

• wire_length (float) – Wire length in µm.

• fingers (int) – Number of 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 in µm.

• film_thickness (float) – Film thickness in µm.

• sheet_inductance (float) – Kinetic sheet inductance in H/□.

• coupling_capacitance (float) – Coupling capacitance in F.

• ground_capacitance (float) – Capacitance of each electrode to ground in F.

• cross_section (CrossSectionSpec) – Feedline cross-section.

Returns:

S-parameters with ports o1 and o2.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.esr_lc_resonator().

(Source code, svg, pdf, png)

qpdk.models.esr_lc_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

interdigital_capacitor

qpdk.models.interdigital_capacitor(*, f=5000000000.0, fingers=4, finger_length=20.0, finger_gap=2.0, thickness=5.0, cross_section='cpw')

Interdigital capacitor Sax model.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• fingers (int) – Total number of fingers (must be >= 2)

• finger_length (float) – Length of each finger in μm

• finger_gap (float) – Gap between adjacent fingers in μm

• thickness (float) – Thickness of fingers in μm

• cross_section (CrossSectionSpec) – Cross-section specification

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.interdigital_capacitor().

(Source code, svg, pdf, png)

qpdk.models.interdigital_capacitor() S-parameters for \(f\in[1,10]\,\text{GHz}\).

lumped_element_resonator

qpdk.models.lumped_element_resonator(*, f=5000000000.0, fingers=20, finger_length=20.0, finger_gap=2.0, finger_thickness=5.0, n_turns=15, sheet_inductance=4e-13, cross_section='meander_inductor_cross_section', grounded=False)

Lumped-element LC resonator SAX model.

Combines an interdigital capacitor and a meander inductor in parallel to form an LC resonator. The resonance frequency is:

\[f_\text{r} = \frac{1}{2\pi\sqrt{LC}}\]

where \(C\) is computed from the interdigital capacitor geometry using interdigital_capacitor_capacitance_analytical() and \(L\) is computed from the meander inductor geometry using meander_inductor_inductance_analytical().

The inductor section uses the width and gap derived from the cross_section to ensure consistent RF behavior across the meander. The vertical spacing between meander runs is set to twice the etch gap to prevent overlap of the etched regions.

See [CSD+23, KVH+11].

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• 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 in µm.

• n_turns (int) – Number of horizontal meander inductor runs (must be odd to match the cell geometry where the path spans left-to-right bus bars).

• sheet_inductance (float) – Sheet inductance per square in H/□.

• cross_section (CrossSectionSpec) – Cross-section specification. Used for substrate permittivity and to determine inductor wire width and gap.

• grounded (bool) – If True, one port of the resonator is grounded.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.lumped_element_resonator().

(Source code, svg, pdf, png)

qpdk.models.lumped_element_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

meander_inductor

qpdk.models.meander_inductor(*, f=5000000000.0, n_turns=5, turn_length=200.0, cross_section='meander_inductor_cross_section', wire_gap=None, sheet_inductance=4e-13)

Meander inductor SAX model.

Computes the inductance from the meander geometry and returns S-parameters of an equivalent lumped inductor.

The model extracts the center conductor width and gap from the provided cross-section. The vertical pitch is calculated as:

\[p = w + \text{wire gap}\]

where \(w\) is the center conductor width. Without an explicit wire_gap, the gap defaults to twice the etch-section width so that the etched regions of adjacent meander runs do not overlap and interfere with the characteristic impedance of each other, or to \(w\) for cross-sections without an etch section such as a plain microstrip.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• n_turns (int) – Number of horizontal meander runs.

• turn_length (float) – Length of each horizontal run in µm.

• cross_section (CrossSectionSpec) – Cross-section specification for the meander wire. Used to determine the wire width and the gap between runs.

• wire_gap (float | None) – Optional explicit gap between adjacent meander runs in µm. If None (default), it is inferred from the cross-section the same way the meander inductor cell does it. An explicit gap is used as is, whether or not the cross-section defines an etch section, and must be positive.

• sheet_inductance (float) – Sheet inductance per square in H/□.

Returns:

S-parameters dictionary.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.meander_inductor().

(Source code, svg, pdf, png)

qpdk.models.meander_inductor() S-parameters for \(f\in[1,10]\,\text{GHz}\).

nanowire_resonator

qpdk.models.nanowire_resonator(*, f=5000000000.0, 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, sheet_inductance=4e-11, thickness=0.015, coupling_capacitance=None, feedline_length=500.0, cross_section='cpw')

SAX model of qpdk.cells.nanowire_resonator().

The circuit is built from generic SAX elements [MP12]. The feedline is two straight() halves of feedline_length / 2, joined by a tee(). The third tee port leads through the coupling capacitor() \(C_\text{c}\) to the resonator node, where a capacitor() \(C\) and an inductor() \(L\) each end in an electrical_short() to ground:

\(|S_{21}|\) vanishes at \(\omega_\text{r} = 1/\sqrt{L (C + C_\text{c})}\). Circuit values and assumptions are those of nanowire_resonator_parameters().

Design references for the nanowire are [JCL+22, MGK+18].

Settings the cell rejects raise ValueError through validate_nanowire_layout().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• wire_width (float) – Nanowire width in µm.

• wire_length (float) – Length of each nanowire run in µm.

• n_turns (int) – Number of nanowire runs.

• wire_gap (float | None) – Gap between runs in µm. Defaults to wire_width.

• lead_length (float | None) – Length of each straight lead between the meander and a pad in µm. Defaults to wire_gap.

• corner_style (Literal['sharp', 'chamfer', 'round', 'optimal']) – Corner style of a meandered wire.

• 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 side grounds in µm.

• coupling_gap (float) – Gap between the upper pad and the feedline in µm.

• sheet_inductance (float) – Kinetic sheet inductance in H/□. The default is a TiN example, not a calibrated NbTiN value.

• thickness (float) – Film thickness in µm.

• coupling_capacitance (float | None) – Coupling capacitance in F. None derives it from the layout.

• feedline_length (float) – Length of the feedline in µm.

• cross_section (CrossSectionSpec) – Feedline cross-section.

Returns:

S-parameters with ports o1 and o2.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.nanowire_resonator().

(Source code, svg, pdf, png)

qpdk.models.nanowire_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

plate_capacitor

qpdk.models.plate_capacitor(*, f=5000000000.0, length=80.0, width=10.0, gap=7.0, offset=0.0, z_ref=50.0)

Facing coupling pads with their finite-frame ground capacitances.

Matches qpdk.cells.plate_capacitor(). Its two electrodes map to o1 and o2. Dimensions are in micrometres, frequency in Hz and reference impedance in ohms. Both ports reference the same 45 um wide ground frame, 10 um from the pad bounding box. The substrate is silicon.

Uses the complete Palace Maxwell matrix, including both pad-ground branches. Connect this pair directly in the circuit without adding those capacitances again. An isolated single pad is not this two-port environment. Out-of-domain dimensions return NaN.

Returns:

Jittable SAX S-parameters with ports o1 and o2.

Parameters:

• f (FloatArrayLike)

• length (float)

• width (float)

• gap (float)

• offset (float)

• z_ref (float)

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.plate_capacitor().

(Source code, svg, pdf, png)

qpdk.models.plate_capacitor() S-parameters for \(f\in[1,10]\,\text{GHz}\).

plate_capacitor_analytical

qpdk.models.plate_capacitor_analytical(*, f=5000000000.0, length=26.0, width=5.0, gap=7.0, cross_section='cpw')

Closed-form series capacitance of two coplanar pads, without ground branches.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (float) – Length of the capacitor pad in μm

• width (float) – Width of the capacitor pad in μm

• gap (float) – Gap between plates in μm

• cross_section (CrossSectionSpec) – Cross-section specification

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.plate_capacitor_analytical() S-parameters for \(f\in[1,10]\,\text{GHz}\).

Josephson junctions

Single junctions and SQUIDs.

josephson_junction	Josephson junction (RCSJ) small-signal Sax model.
josephson_junction_array	Josephson junction array (junction chain) small-signal Sax model.
squid_junction	DC SQUID small-signal Sax model in the zero-screening limit.
squid_termination	One-port Sax model of a CPW lead shorted to ground through a DC SQUID.

josephson_junction

qpdk.models.josephson_junction(*, f=5000000000.0, ic=1e-06, capacitance=5e-15, resistance=10000.0, ib=0.0)

Josephson junction (RCSJ) small-signal Sax model.

Linearized RCSJ model consisting of a bias-dependent Josephson inductance in parallel with capacitance and resistance.

Valid in the superconducting (zero-voltage) state and for small AC signals.

Default capacitance taken from [SFS+15].

See [McC68] for details.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• ic (Float) – Critical current \(I_\text{c}\) in Amperes

• capacitance (Float) – Junction capacitance \(C\) in Farads

• resistance (Float) – Shunt resistance \(R\) in Ohms

• ib (Float) – DC bias current \(I_\text{b}\) in Amperes (\(\|I_\text{b}\| < I_\text{c}\))

Returns:

S-parameters dictionary with ports left_wide and right_wide

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.josephson_junction().

(Source code, svg, pdf, png)

qpdk.models.josephson_junction() S-parameters for \(f\in[1,10]\,\text{GHz}\).

josephson_junction_array

qpdk.models.josephson_junction_array(*, f=5000000000.0, n_junctions=43, ic=1.7321367288181755e-07, capacitance=4e-14, ground_capacitance=4e-17, resistance=inf, ib=0.0, z0=50.0)

Josephson junction array (junction chain) small-signal Sax model.

A chain of \(N\) identical linearised junctions in series between ports o1 and o2. Each junction is the parallel RCSJ element of josephson_junction(), with Josephson inductance \(L_\text{J} = \Phi_0 / (2 \pi I_\text{c} \cos\varphi_0)\), junction capacitance \(C_\text{J}\) and resistance \(R\). Each of the \(N - 1\) interior islands has a capacitance \(C_\text{g}\) to ground:

The two-port is evaluated as the ABCD cascade

\[\begin{split}\mathbf{T} = \left(\mathbf{T}_\text{J} \mathbf{T}_\text{g}\right)^{N-1} \mathbf{T}_\text{J}, \qquad \mathbf{T}_\text{J} = \begin{pmatrix} 1 & Z_\text{J} \\ 0 & 1 \end{pmatrix}, \qquad \mathbf{T}_\text{g} = \begin{pmatrix} 1 & 0 \\ \mathrm{j} \omega C_\text{g} & 1 \end{pmatrix},\end{split}\]

with \(Z_\text{J} = (1/R + \mathrm{j}\omega C_\text{J} + 1/(\mathrm{j}\omega L_\text{J}))^{-1}\), and converted to S-parameters referenced to \(Z_0\) [MP12]. The power is taken by repeated squaring, so the cost does not grow with \(N\) and n_junctions may be traced (for example set from a SAX netlist).

For a lossless chain with both ends grounded, the cascade resonates at the normal modes of the array [MPK+12]:

\[\omega_k = \omega_\text{p} \sqrt{\frac{1 - \cos(\pi k / N)} {C_\text{g} / (2 C_\text{J}) + 1 - \cos(\pi k / N)}}, \qquad k = 1, \dots, N - 1,\]

where \(\omega_\text{p} = 1 / \sqrt{L_\text{J} C_\text{J}}\) is the plasma frequency that bounds the spectrum from above.

Assumptions:

• Small-signal, zero-voltage state: each junction is a linear inductor.

• Identical junctions and uniform \(C_\text{g}\) on the interior islands. The ground capacitance of the two end islands belongs to whatever the ports connect to, so \(N = 1\) is a single junction.

• Nearest-neighbour coupling only: no long-range island-to-island capacitance.

Default per-junction values are the fit to the 80-junction array of [MPK+12] (\(L_\text{J} = 1.9\,\text{nH}\), \(C_\text{J} = 40\,\text{fF}\), \(C_\text{g} = 0.04\,\text{fF}\)). The default \(N = 43\) matches the josephson_junction_array() cell, whose default junction count and target \(E_\text{L}\) follow [MKGD09]. The default junctions of the two differ (\(43 \times 1.9\,\text{nH} = 82\,\text{nH}\) here against the cell’s estimate of \(314\,\text{nH}\)): to simulate a laid out array, pass ic from the cell’s info["critical_current_nA"] (converted to A) together with a junction capacitance for that process.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• n_junctions (int) – Number of junctions \(N\) in the chain, \(1 \le N < 2^{24}\). Non-integer values are truncated.

• ic (Float) – Critical current \(I_\text{c}\) of each junction in Amperes.

• capacitance (Float) – Capacitance \(C_\text{J}\) of each junction in Farads.

• ground_capacitance (Float) – Capacitance \(C_\text{g}\) of each interior island to ground in Farads.

• resistance (Float) – Shunt resistance \(R\) of each junction in Ohms.

• ib (Float) – DC bias current \(I_\text{b}\) through the chain in Amperes (\(|I_\text{b}| < I_\text{c}\)).

• z0 (Float) – Reference impedance \(Z_0\) of both ports in Ohms.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

Raises:

ValueError – If a concrete n_junctions is outside \(1 \le N < 2^{24}\). A traced out-of-range value returns NaN.

Schematic symbol drawn by GDSFactory+ for qpdk.models.josephson_junction_array().

(Source code, svg, pdf, png)

qpdk.models.josephson_junction_array() S-parameters for \(f\in[1,10]\,\text{GHz}\).

squid_junction

qpdk.models.squid_junction(*, f=5000000000.0, ic_tot=2e-06, asymmetry=0.0, capacitance=1e-14, resistance=5000.0, ib=0.0, flux=0.0)

DC SQUID small-signal Sax model in the zero-screening limit.

Treats the DC SQUID as a single effective RCSJ whose critical current is tunable by an external magnetic flux. Assumes negligible loop geometric inductance.

See [KYG+07] and [Tin15] for details on asymmetric SQUIDs and effective Josephson inductance.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• ic_tot (Float) – Total critical current sum \(I_{\text{c}1} + I_{\text{c}2}\) in Amperes

• asymmetry (Float) – Junction asymmetry \((I_{\text{c}1} - I_{\text{c}2}) / I_{\text{c,tot}}\)

• capacitance (Float) – Total SQUID capacitance \(C_1 + C_2\) in Farads

• resistance (Float) – Total SQUID shunt resistance \(R_1 || R_2\) in Ohms

• ib (Float) – DC bias current \(I_\text{b}\) in Amperes

• flux (FloatArrayLike) – External magnetic flux \(\Phi_{\text{ext}}\) in Webers

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.squid_junction() S-parameters for \(f\in[1,10]\,\text{GHz}\).

squid_termination

qpdk.models.squid_termination(*, f=5000000000.0, length=10.0, cross_section='cpw', ic_tot=4.8e-06, asymmetry=0.0, capacitance=1e-14, resistance=5000.0, flux=0.0)

One-port Sax model of a CPW lead shorted to ground through a DC SQUID.

This is the termination of a flux-driven \(\lambda/4\) Josephson parametric amplifier (JPA): a CPW lead of length, then the squid_junction() admittance in series with an ideal short. It models the squid_termination() cell. The flux-tunable SQUID inductance \(L_\text{s}(\Phi) = \Phi_0 / (2 \pi I_\text{c,tot} |\cos(\pi \Phi / \Phi_0)|)\) pulls the resonance below \(\omega_{\lambda/4}\) [YIW+08].

The model neglects the loop geometric inductance, which is valid for \(\beta_\text{L} = 2 L_\text{loop} I_\text{c} / \Phi_0 \lesssim 0.1\). The default \(I_\text{c,tot} = 2 \times 2.4\,\text{µA}\) follows the low-\(\beta_\text{L}\) WMI devices [PFZ+17]. It is an assumption, not a value extracted from the layout.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Length of the CPW lead in µm

• cross_section (CrossSectionSpec) – Cross-section of the CPW lead

• ic_tot (Float) – Total critical current \(I_{\text{c}1} + I_{\text{c}2}\) in Amperes

• asymmetry (Float) – Junction asymmetry \((I_{\text{c}1} - I_{\text{c}2}) / I_{\text{c,tot}}\)

• capacitance (Float) – Total SQUID capacitance \(C_1 + C_2\) in Farads

• resistance (Float) – Total SQUID shunt resistance \(R_1 || R_2\) in Ohms

• flux (FloatArrayLike) – External magnetic flux \(\Phi_{\text{ext}}\) in Webers

Returns:

S-parameters dictionary with the single port o1

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.squid_termination() S-parameters for \(f\in[1,10]\,\text{GHz}\).

Waveguides and interconnects

Straights, bends, tapers, launchers, airbridges, bumps, TSVs, rectangles and generic N-port blocks.

airbridge	S-parameter model for a superconducting CPW airbridge.
bend_circular	S-parameter model for a circular bend, wrapped to straight().
bend_circular_all_angle	S-parameter model for a circular bend, wrapped to straight().
bend_euler	S-parameter model for an Euler bend, wrapped to straight().
bend_euler_all_angle	S-parameter model for an Euler bend, wrapped to straight().
bend_s	S-parameter model for an S-bend, wrapped to straight().
bump_transition	S-parameter model for a CPW transition through a single indium bump.
indium_bump	S-parameter model for an indium bump, wrapped to straight().
launcher	S-parameter model for a launcher, effectively a straight section followed by a taper.
nxn	NxN junction model using tee components.
rectangle	S-parameter model for a rectangular section, wrapped to straight().
straight	S-parameter model for a straight coplanar waveguide.
straight_all_angle	S-parameter model for a straight coplanar waveguide.
straight_double_open	S-parameter model for a straight waveguide with open ends.
straight_microstrip	S-parameter model for a straight microstrip transmission line.
straight_open	S-parameter model for a straight waveguide with one open end.
straight_shorted	S-parameter model for a straight waveguide with one shorted end.
taper_cross_section	S-parameter model for a cross-section taper using linear interpolation.
tsv	S-parameter model for a through-silicon via (TSV), wrapped to straight().
tsv_transition_double_sided	S-parameter model for a CPW transition through the substrate.

airbridge

qpdk.models.airbridge(f=5000000000.0, cpw_width=10.0, bridge_width=8.0, airgap_height=3.0, loss_tangent=1.2e-08)

S-parameter model for a superconducting CPW airbridge.

The airbridge is modeled as a lumped lossy shunt admittance to ground (shunt capacitance plus dielectric loss) across the CPW at the bridge location.

Ports o1 and o2 are the CPW reference planes immediately either side of the bridge, both referenced to \(Z_0 = 50\,\Omega\). The bridge footprint adds no transmission line length, so the two reference planes coincide. The landing pads of the layout cell (e1 and e2, on the AB_VIA layer) contact the ground plane and are not RF ports of this model.

Parallel plate capacitor model is as done in [CMK+14] The default value for the loss tangent \(\tan\,\delta\) is also taken from there.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• cpw_width (Float) – Width of the CPW center conductor in µm.

• bridge_width (Float) – Width of the airbridge in µm.

• airgap_height (Float) – Height of the airgap in µm.

• loss_tangent (Float) – Dielectric loss tangent of the supporting layer/residues.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.airbridge() S-parameters for \(f\in[1,10]\,\text{GHz}\).

bend_circular

qpdk.models.bend_circular(f=5000000000.0, length=1000, cross_section='cpw')

S-parameter model for a circular bend, wrapped to straight().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.bend_circular().

(Source code, svg, pdf, png)

qpdk.models.bend_circular() S-parameters for \(f\in[1,10]\,\text{GHz}\).

bend_circular_all_angle

qpdk.models.bend_circular_all_angle(f=5000000000.0, length=1000, cross_section='cpw')

S-parameter model for a circular bend, wrapped to straight().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.bend_circular_all_angle() S-parameters for \(f\in[1,10]\,\text{GHz}\).

bend_euler

qpdk.models.bend_euler(f=5000000000.0, length=1000, cross_section='cpw')

S-parameter model for an Euler bend, wrapped to straight().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.bend_euler() S-parameters for \(f\in[1,10]\,\text{GHz}\).

bend_euler_all_angle

qpdk.models.bend_euler_all_angle(f=5000000000.0, length=1000, cross_section='cpw')

S-parameter model for an Euler bend, wrapped to straight().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.bend_euler_all_angle() S-parameters for \(f\in[1,10]\,\text{GHz}\).

bend_s

qpdk.models.bend_s(f=5000000000.0, length=None, size=(20.0, 3.0), npoints=99, cross_section='cpw')

S-parameter model for an S-bend, wrapped to straight().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float | None) – Physical length in µm. When omitted, it is derived from size.

• size (Size) – Layout S-bend extent in µm.

• npoints (int | Array) – Number of points used to discretize the layout Bézier curve; a scalar array (as gdsfactoryplus model binding emits) is accepted.

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.bend_s().

(Source code, svg, pdf, png)

qpdk.models.bend_s() S-parameters for \(f\in[1,10]\,\text{GHz}\).

bump_transition

qpdk.models.bump_transition(f=5000000000.0, 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_height=10.0)

S-parameter model for a CPW transition through a single indium bump.

Port o1 is on the bottom chip and o2 on the flip-chip top chip, see bump_transition() for the geometry. The bump is the indium_bump() model, so this inherits its approximations.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• cross_section (CrossSectionSpec) – Bottom-chip CPW.

• cross_section_top (CrossSectionSpec) – Top-chip CPW.

• taper_length (Float) – Length of the bottom-chip jog into the pad in µm.

• taper_length_top (Float) – Length of the top-chip jog out of the pad in µm.

• pad_width (Float) – Signal width of the pads in µm.

• pad_gap (Float) – Gap of the pads in µm.

• pad_length (Float) – Length of each pad in µm.

• bump_height (float) – Height of the bump in µm, passed to indium_bump().

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.bump_transition().

(Source code, svg, pdf, png)

qpdk.models.bump_transition() S-parameters for \(f\in[1,10]\,\text{GHz}\).

indium_bump

qpdk.models.indium_bump(f=5000000000.0, bump_height=10.0, loss_db=1e-06)

S-parameter model for an indium bump, wrapped to straight().

The bump is a straight() of length bump_height followed by a constant, frequency-independent insertion loss loss_db per signal transition.

The default comes from Richard et al. [RBF+26], who put 1 to 6 indium transitions in series in the centre conductor of \(\lambda/4\) CPW resonators (low photon number, 15 mK) and bound the contribution of each transition to \(1/Q_\text{i}\) at \(\delta_\text{In} < 10^{-7}\). A lumped element adding \(\delta\) to \(1/Q_\text{i}\) absorbs a power fraction \(a = \delta\,\pi/2\) per pass, i.e. \(a < 1.6 \times 10^{-7}\) and \(\text{IL} = 10 \log_{10}(e)\,a < 7 \times 10^{-7}\,\text{dB}\), rounded up to \(10^{-6}\,\text{dB}\). Indium bump seams also leave stripline cavities at single-photon \(Q > 3 \times 10^8\) [LKG+20].

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• bump_height (float) – Physical height (length) of the indium bump in µm.

• loss_db (FloatArrayLike) – Insertion loss per indium bump transition in dB. Must be non-negative, a negative value gives gain.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.indium_bump() S-parameters for \(f\in[1,10]\,\text{GHz}\).

launcher

qpdk.models.launcher(f=5000000000.0, straight_length=200.0, taper_length=100.0, cross_section_big=<function launcher_cross_section_big>, cross_section_small='cpw')

S-parameter model for a launcher, effectively a straight section followed by a taper.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• straight_length (Float) – Length of the straight section in µm.

• taper_length (Float) – Length of the taper section in µm.

• cross_section_big (CrossSectionSpec) – Cross-section for the wide section.

• cross_section_small (CrossSectionSpec) – Cross-section for the narrow section.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.launcher().

nxn

qpdk.models.nxn(f=5000000000.0, west=1, east=1, north=1, south=1)

NxN junction model using tee components.

This model creates an N-port divider/combiner by chaining 3-port tee junctions. All ports are connected to a single node.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• west (int) – Number of ports on the west side.

• east (int) – Number of ports on the east side.

• north (int) – Number of ports on the north side.

• south (int) – Number of ports on the south side.

Returns:

S-parameters dictionary with ports o1, o2, …, oN.

Return type:

SDict

Raises:

ValueError – If total number of ports is not positive.

(Source code, svg, pdf, png)

qpdk.models.nxn() S-parameters for \(f\in[1,10]\,\text{GHz}\).

rectangle

qpdk.models.rectangle(f=5000000000.0, length=1000, cross_section='cpw')

S-parameter model for a rectangular section, wrapped to straight().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.rectangle() S-parameters for \(f\in[1,10]\,\text{GHz}\).

straight

qpdk.models.straight(f=5000000000.0, length=10.0, cross_section='cpw', conductor_backed=False)

S-parameter model for a straight coplanar waveguide.

Wraps sax.models.rf.coplanar_waveguide(), extracting the physical dimensions from the given cross_section and the PDK layer stack. With conductor_backed=True the line is modelled as a conductor-backed CPW instead, see cbcpw_parameters().

Computes S-parameters analytically using conformal-mapping CPW theory following Simons [Sim01] (ch. 2) and the Qucs-S CPW model (Qucs technical documentation, §12.4). Conductor thickness corrections use the first-order model of Gupta, Garg, Bahl, and Bhartia [GGBB96].

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (FloatArrayLike) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

• conductor_backed (bool) – If True, the substrate backside is metallised, see LAYER_STACK_BACKSIDE.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.straight().

(Source code, svg, pdf, png)

qpdk.models.straight() S-parameters for \(f\in[1,10]\,\text{GHz}\).

straight_all_angle

qpdk.models.straight_all_angle(f=5000000000.0, length=10.0, cross_section='cpw')

S-parameter model for a straight coplanar waveguide.

Same as straight().

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.straight_all_angle() S-parameters for \(f\in[1,10]\,\text{GHz}\).

straight_double_open

qpdk.models.straight_double_open(f=5000000000.0, length=10.0, cross_section='cpw')

S-parameter model for a straight waveguide with open ends.

Note

Ports o1 and o2 are internally open-circuited and should not be used. They are provided to match the number of ports in the layout component.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.straight_double_open() S-parameters for \(f\in[1,10]\,\text{GHz}\).

straight_microstrip

qpdk.models.straight_microstrip(f=5000000000.0, length=1000, width=10.0, h=500.0, t=0.2, ep_r=11.45, tand=0.0)

S-parameter model for a straight microstrip transmission line.

Wraps sax.models.rf.microstrip(), mapping the qpdk parameter names to the upstream model.

Computes S-parameters analytically using the Hammerstad-Jensen [HJ80] closed-form expressions for effective permittivity and characteristic impedance, as described in Pozar [MP12] (ch. 3, §3.8). Conductor thickness corrections follow Gupta et al. [GGBB96] (§2.2.4).

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• length (Float) – Physical length in µm.

• width (Float) – Strip width in µm.

• h (Float) – Substrate height in µm.

• t (Float) – Conductor thickness in µm (default 0.2 µm = 200 nm).

• ep_r (Float) – Relative permittivity of the substrate (default 11.45 for Si).

• tand (Float) – Dielectric loss tangent (default 0 — lossless).

Returns:

S-parameters dictionary.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.straight_microstrip() S-parameters for \(f\in[1,10]\,\text{GHz}\).

straight_open

qpdk.models.straight_open(f=5000000000.0, length=10.0, cross_section='cpw')

S-parameter model for a straight waveguide with one open end.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.straight_open().

(Source code, svg, pdf, png)

qpdk.models.straight_open() S-parameters for \(f\in[1,10]\,\text{GHz}\).

straight_shorted

qpdk.models.straight_shorted(f=5000000000.0, length=10.0, cross_section='cpw')

S-parameter model for a straight waveguide with one shorted end.

This may be used to model a quarter-wave coplanar waveguide resonator.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section (CrossSectionSpec) – The cross-section of the waveguide.

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.straight_shorted().

(Source code, svg, pdf, png)

qpdk.models.straight_shorted() S-parameters for \(f\in[1,10]\,\text{GHz}\).

taper_cross_section

qpdk.models.taper_cross_section(f=5000000000.0, length=10, cross_section1='cpw', cross_section2='cpw', npoints=100)

S-parameter model for a cross-section taper using linear interpolation.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• length (Float) – Physical length in µm

• cross_section1 (CrossSectionSpec) – Cross-section for the start of the taper.

• cross_section2 (CrossSectionSpec) – Cross-section for the end of the taper.

• npoints (int | Array) – Number of segments to divide the taper into for simulation. Clamped to a minimum of one segment. Ignored when both cross-sections have identical dimensions.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.taper_cross_section() S-parameters for \(f\in[1,10]\,\text{GHz}\).

tsv

qpdk.models.tsv(f=5000000000.0, via_height=1000.0, loss_db=4e-05)

S-parameter model for a through-silicon via (TSV), wrapped to straight().

The via is a straight() of length via_height followed by a constant, frequency-independent insertion loss loss_db per signal transition.

No cryogenic \(S_{21}\) measurement of a single superconducting TSV has been published, so the default is an upper bound derived from resonators interrupted by TSV transitions at single-photon power and mK temperatures. Mallek et al. [MYR+21] find no dependence of \(Q_\text{i}\) (about \(10^5\) to \(2.4 \times 10^5\), Fig. 7) on where the transition sits along a \(\lambda/4\) resonator. Taking the spread as the TSV contribution to the inverse internal quality factor bounds it at \(\delta_\text{TSV} \lesssim 1/10^5 - 1/(2.4 \times 10^5) \approx 6 \times 10^{-6}\). The best TSV-terminated resonators of Grigoras et al. [GYurttagulK+22] (\(Q_\text{i} \approx 2 \times 10^5\)) agree with this, and TSVs used as capacitors reach \(Q_\text{diel} \approx 7.5 \times 10^5\) [HWR+23]. A lumped element adding \(\delta\) to \(1/Q_\text{i}\) of a \(\lambda/4\) resonator absorbs a power fraction \(a = \delta\,\beta\ell = \delta\,\pi/2\) per pass, i.e. \(a \lesssim 9 \times 10^{-6}\) and \(\text{IL} = 10 \log_{10}(e)\,a \approx 4 \times 10^{-5}\,\text{dB}\). Weak spots in the TSV liner drop some resonators to \(Q_\text{i} \approx 10^4\) [GYurttagulK+22], about \(7 \times 10^{-4}\,\text{dB}\), which is a reasonable pessimistic corner.

A single signal TSV is also a significant impedance discontinuity [MYR+21], which this model does not include.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• via_height (float) – Physical height (length) of the TSV in µm.

• loss_db (FloatArrayLike) – Insertion loss per TSV transition in dB. Must be non-negative, a negative value gives gain.

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.tsv() S-parameters for \(f\in[1,10]\,\text{GHz}\).

tsv_transition_double_sided

qpdk.models.tsv_transition_double_sided(f=5000000000.0, 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, chip='bottom', via_height=1000.0)

S-parameter model for a CPW transition through the substrate.

Port o1 is on the front face and o2 on the backside. The via array is the tsv() model, so this inherits its approximations.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz

• cross_section (CrossSectionSpec | None) – Front-face CPW. Defaults to the chip’s front cross-section.

• cross_section_backside (CrossSectionSpec | None) – Backside CPW. Defaults to the chip’s backside cross-section.

• taper_length (Float) – Length of the front-face taper in µm.

• taper_length_backside (Float) – Length of the backside taper in µm.

• pad_width (Float) – Signal width of the pads in µm.

• pad_gap (Float) – Gap of the pads in µm.

• pad_length (Float) – Length of each pad in µm.

• chip (Literal['bottom', 'top']) – Chip the transition sits on.

• via_height (float) – Height of the TSVs in µm, passed to tsv().

Returns:

S-parameters dictionary

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.tsv_transition_double_sided().

(Source code, svg, pdf, png)

qpdk.models.tsv_transition_double_sided() S-parameters for \(f\in[1,10]\,\text{GHz}\).

Generic circuit elements

Opens, shorts, series and shunt elements and ideal LC resonators.

abcd_to_sdict	Two-port S-parameters of a network given by its ABCD (transmission) matrix.
electrical_short_2_port	Electrical short 2-port connection Sax model.
lc_resonator	LC resonator Sax model with capacitor and inductor in parallel.
lc_resonator_coupled	Coupled LC resonator Sax model.
open	Return the reflection coefficient of an ideal one-port open.
open_2_port	Return two isolated ports with ideal open reflections.
series_impedance	Two-port series impedance Sax model.
short	Return the reflection coefficient of an ideal one-port short.
short_2_port	Electrical short 2-port connection Sax model.
shunt_admittance	Two-port shunt admittance Sax model.

abcd_to_sdict

qpdk.models.abcd_to_sdict(f=5000000000.0, abcd=array([[1., 0.], [0., 1.]]), z0=50.0)

Two-port S-parameters of a network given by its ABCD (transmission) matrix.

Converts

\[\begin{split}\mathbf{T} = \begin{pmatrix} A & B \\ C & D \end{pmatrix}\end{split}\]

to S-parameters referenced to \(Z_0\) at both ports, following [MP12] (Ch. 4, Table 4.2):

\[\begin{split}\begin{aligned} S_{11} &= \frac{A + B/Z_0 - C Z_0 - D}{\Delta}, & S_{12} &= \frac{2 (AD - BC)}{\Delta}, \\ S_{21} &= \frac{2}{\Delta}, & S_{22} &= \frac{-A + B/Z_0 - C Z_0 + D}{\Delta}, \end{aligned} \qquad \Delta = A + B/Z_0 + C Z_0 + D.\end{split}\]

ABCD matrices of cascaded two-ports multiply, so a network built from series and shunt elements can be cascaded with @ (or jax.numpy.matmul()) and converted once.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz. Unused: the frequency dependence is carried by abcd. Kept so the function is a SAX model.

• abcd (ComplexArrayLike) – ABCD matrices with shape (..., 2, 2). The leading axes, for example a frequency axis, are kept in the S-parameters.

• z0 (ComplexLike) – Reference impedance \(Z_0\) of both ports in Ohms.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.abcd_to_sdict() S-parameters for \(f\in[1,10]\,\text{GHz}\).

electrical_short_2_port

qpdk.models.electrical_short_2_port(f=5000000000.0)

Electrical short 2-port connection Sax model.

Parameters:

f (FloatArrayLike) – Array of frequency points in Hz

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.electrical_short_2_port() S-parameters for \(f\in[1,10]\,\text{GHz}\).

lc_resonator

qpdk.models.lc_resonator(f=5000000000.0, capacitance=1e-13, inductance=1e-09, grounded=False, ground_capacitance=0.0)

LC resonator Sax model with capacitor and inductor in parallel.

The resonance frequency is given by:

If grounded=True, a 2-port short is connected to port o2:

Optional ground capacitances Cg can be added to both ports:

\[f_\text{r} = \frac{1}{2 \pi \sqrt{LC}}\]

For theory and relation to superconductors, see [Gao08].

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (FloatArrayLike) – Capacitance of the resonator in Farads.

• inductance (FloatArrayLike) – Inductance of the resonator in Henries.

• grounded (bool) – If True, add a 2-port ground to the second port.

• ground_capacitance (FloatArrayLike) – Parasitic capacitance to ground Cg at each port in Farads.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.lc_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

lc_resonator_coupled

qpdk.models.lc_resonator_coupled(f=5000000000.0, capacitance=1e-13, inductance=1e-09, grounded=False, ground_capacitance=0.0, coupling_capacitance=1e-14, coupling_inductance=0.0)

Coupled LC resonator Sax model.

This model extends the basic LC resonator by adding a coupling network consisting of a parallel capacitor and inductor connected in series to one port of the LC resonator.

The resonance frequency of the main LC resonator is given by:

\[f_\text{r} = \frac{1}{2 \pi \sqrt{LC}}\]

The coupling network modifies the effective coupling to the resonator.

Where \(L_\text{c}\) and \(C_\text{c}\) are the coupling inductance and capacitance, respectively.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• capacitance (FloatArrayLike) – Capacitance of the main resonator in Farads.

• inductance (FloatArrayLike) – Inductance of the main resonator in Henries.

• grounded (bool) – If True, the resonator is grounded.

• ground_capacitance (FloatArrayLike) – Parasitic capacitance to ground Cg at each port in Farads.

• coupling_capacitance (FloatArrayLike) – Coupling capacitance in Farads.

• coupling_inductance (FloatArrayLike) – Coupling inductance in Henries.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.lc_resonator_coupled() S-parameters for \(f\in[1,10]\,\text{GHz}\).

open

qpdk.models.open(f=5000000000.0)

Return the reflection coefficient of an ideal one-port open.

Parameters:

f (FloatArrayLike)

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.open().

(Source code, svg, pdf, png)

qpdk.models.open() S-parameters for \(f\in[1,10]\,\text{GHz}\).

open_2_port

qpdk.models.open_2_port(f=5000000000.0)

Return two isolated ports with ideal open reflections.

Parameters:

f (FloatArrayLike)

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.open_2_port().

(Source code, svg, pdf, png)

qpdk.models.open_2_port() S-parameters for \(f\in[1,10]\,\text{GHz}\).

series_impedance

qpdk.models.series_impedance(f=5000000000.0, z=0.0, z0=50.0)

Two-port series impedance Sax model.

See [MP12] (Ch. 4, Table 4.1, Table 4.2, Problem 4.11) for the S-parameter derivation.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• z (ComplexArrayLike) – Complex impedance in Ohms.

• z0 (float) – Reference characteristic impedance in Ohms.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.series_impedance() S-parameters for \(f\in[1,10]\,\text{GHz}\).

short

qpdk.models.short(f=5000000000.0)

Return the reflection coefficient of an ideal one-port short.

Parameters:

f (FloatArrayLike)

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.short().

(Source code, svg, pdf, png)

qpdk.models.short() S-parameters for \(f\in[1,10]\,\text{GHz}\).

short_2_port

qpdk.models.short_2_port(f=5000000000.0)

Electrical short 2-port connection Sax model.

Parameters:

f (FloatArrayLike) – Array of frequency points in Hz

Returns:

S-parameters dictionary

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.short_2_port() S-parameters for \(f\in[1,10]\,\text{GHz}\).

shunt_admittance

qpdk.models.shunt_admittance(f=5000000000.0, y=0.0, z0=50.0)

Two-port shunt admittance Sax model.

See [MP12] (Ch. 4, Table 4.1, Table 4.2, Problem 4.11) for the S-parameter derivation.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• y (ComplexArrayLike) – Complex admittance in Siemens.

• z0 (float) – Reference characteristic impedance in Ohms.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

(Source code, svg, pdf, png)

qpdk.models.shunt_admittance() S-parameters for \(f\in[1,10]\,\text{GHz}\).

Other

drum_lc_resonator	Drum LC resonator side-coupled to a feedline, SAX model.
hyperbolic_cpw_path	S-parameters of qpdk.cells.hyperbolic.hyperbolic_cpw_path().
hyperbolic_edge_resonator	S-parameters of a meandered hyperbolic-lattice edge resonator.
hyperbolic_lattice	Circuit model of a Kollár-type hyperbolic lattice of edge resonators.
hyperbolic_vertex_coupler	S-parameters of a q-pin capacitive vertex coupler.
resonator_meander	Model the meander by its total CPW electrical length.
vacuum_gap_capacitor	Vacuum-gap drum capacitor SAX model.

drum_lc_resonator

qpdk.models.drum_lc_resonator(*, f=5000000000.0, radius=7.5, gap=0.07, n_turns=75, turn_length=300.0, inductor_cross_section='meander_inductor_cross_section', sheet_inductance=4e-13, coupling_capacitance=1e-15, parasitic_capacitance=1.6e-14)

Drum LC resonator side-coupled to a feedline, SAX model.

A meander inductor \(L\) is shunted by the drum capacitance \(C_\text{d}\) (plus a parasitic \(C_\text{p}\)) and coupled to the feedline through \(C_\text{c}\), as in [PDamskaggB+15]. The drum sits at the open end of the meander, and the resonator couples capacitively to a transmission line as in [OKDamskaggP+16]. Here it hangs off a single feedline, which [MdLepinayDamskaggOKSillanpaa19] also uses for readout. [TLA+11] coupled inductively instead.

The feedline sees the shunt admittance

\[Y = \left[\frac{1}{j\omega C_\text{c}} + \frac{1}{j\omega (C_\text{d} + C_\text{p}) + 1/(j\omega L)}\right]^{-1}\]

which has its transmission zero at \(\omega_\text{r} = 1/\sqrt{L (C_\text{d} + C_\text{p} + C_\text{c})}\). \(C_\text{d}\) comes from vacuum_gap_capacitance_analytical() and \(L\) from meander_inductor_inductance_analytical(). Losses are neglected.

With \(L = 14\,\text{nH}\) and \(C = 16\,\text{fF}\) from [PDamskaggB+15] and the parallel-plate drum capacitance of 22.3 fF, the tank alone sits at \(1/(2\pi\sqrt{L(C + C_\text{d})}) = 6.87\,\text{GHz}\), against the measured 6.90 GHz. The transmission zero also loads the coupling capacitance, and the 1 fF default is not the paper’s value, so the zero of the default model is 6.71 GHz.

Limits of this lumped model:

• The meander’s own capacitance to ground is not computed. The default parasitic_capacitance is the 16 fF of [PDamskaggB+15], which belongs to that layout. It lowers \(\omega_\text{r}\) and the participation \(\eta\) of drum_electromechanical_coupling(). Pass an extracted value for any other layout.

• The default meander is about 23 mm of wire, a substantial fraction of a guided wavelength at the resonance. Distributed effects are neglected.

• coupling_capacitance is an input. It is not derived from the coupling pad of drum_lc_resonator().

Extract \(C_\text{p}\) and \(C_\text{c}\) with an EM solver before relying on the resonance frequency of a layout; drum_lc_resonator_fem_model() takes them from the Palace dataset of the default cell family.

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• radius (FloatArrayLike) – Drum bottom-electrode radius in µm.

• gap (FloatArrayLike) – Vacuum gap in µm. Defaults to the layer-stack value.

• n_turns (int) – Number of meander inductor runs.

• turn_length (float) – Length of each meander run in µm.

• inductor_cross_section (CrossSectionSpec) – Cross-section of the meander wire.

• sheet_inductance (float) – Sheet inductance per square in H/□.

• coupling_capacitance (FloatArrayLike) – Coupling capacitance \(C_\text{c}\) to the feedline in F.

• parasitic_capacitance (FloatArrayLike) – Extra capacitance \(C_\text{p}\) in parallel with the drum in F. Defaults to the 16 fF of [PDamskaggB+15].

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.drum_lc_resonator().

(Source code, svg, pdf, png)

qpdk.models.drum_lc_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

hyperbolic_cpw_path

qpdk.models.hyperbolic_cpw_path(*, f=5000000000.0, points=((0.0, 0.0), (100.0, 0.0)), radius=100.0, shorted=False, cross_section='cpw')

S-parameters of qpdk.cells.hyperbolic.hyperbolic_cpw_path().

A straight CPW of the centreline length: the polyline length minus \(2r\tan(\theta/2) - r\theta\) at every corner turning by \(\theta\).

Parameters:

• f (FloatArrayLike) – Frequency in Hz.

• points (tuple[tuple[float, float], ...]) – Waypoints in µm.

• radius (float) – Corner radius in µm.

• shorted (bool) – Short the far end, leaving only port o1.

• cross_section (CrossSectionSpec) – CPW cross-section.

Returns:

S-parameters with ports o1 and, unless shorted, o2.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.hyperbolic_cpw_path().

(Source code, svg, pdf, png)

qpdk.models.hyperbolic_cpw_path() S-parameters for \(f\in[1,10]\,\text{GHz}\).

hyperbolic_edge_resonator

qpdk.models.hyperbolic_edge_resonator(*, f=5000000000.0, length=4000.0, cross_section='cpw')

S-parameters of a meandered hyperbolic-lattice edge resonator.

The meander of qpdk.cells.hyperbolic.hyperbolic_edge_resonator() is modelled as a straight CPW of the same centreline length; bend corrections are neglected.

Parameters:

• f (FloatArrayLike) – Frequency in Hz.

• length (float) – Centreline length in µm.

• cross_section (CrossSectionSpec) – CPW cross-section.

Returns:

S-parameters with ports o1 and o2.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.hyperbolic_edge_resonator().

(Source code, svg, pdf, png)

qpdk.models.hyperbolic_edge_resonator() S-parameters for \(f\in[1,10]\,\text{GHz}\).

hyperbolic_lattice

qpdk.models.hyperbolic_lattice(*, f=5000000000.0, p=7, q=3, shells=1, 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, cross_section='cpw')

Circuit model of a Kollár-type hyperbolic lattice of edge resonators.

Builds the circuit of qpdk.cells.hyperbolic.hyperbolic_lattice() from the tiling rather than from the layout:

• one straight() of resonator_length per tiling edge, open at both ends through the couplers;

• one hyperbolic_vertex_coupler() per vertex, wired by qpdk.hyperbolic.HyperbolicTiling.pins;

• a shorted CPW stub of stub_length on every free boundary pin (a \(\lambda/4\) resonator far above the band) so boundary resonators see the same end capacitance as interior ones;

• probe ports in place of the stubs on the free pins listed in probe_pins. Their reference plane is the coupler pin, so the feed lines and launchers of the layout are not included.

One vertex of the {7,3} circuit, with three edge resonators meeting at a coupler; resonator ends at the flake boundary end on a stub or a probe:

        flowchart LR
    R1["edge resonator<br/>straight, resonator_length"] --- P1(("pin 1"))
    R2["edge resonator"] --- P2(("pin 2"))
    P3(("pin 3")) --- B["boundary: shorted stub,<br/>or probe port o1, o2, ..."]
    subgraph V["vertex coupler, Maxwell matrix C"]
        P1 ---|"C_c"| P2
        P2 ---|"C_c"| P3
        P3 ---|"C_c"| P1
    end
    V ---|"C_g from every pin"| G["ground"]
    

The circuit is solved exactly by nodal analysis rather than with sax.evaluate_circuit_fg(), which handles the circuit too but takes far longer to compile and needs far more memory at this size:

        flowchart TD
    T["hyperbolic_tiling(p, q, shells)"] --> L["lines: S to Y with Cayley,<br/>Z0 Y = C(S)"]
    T --> C["couplers: Y = jωC"]
    T --> B["stubs: S to Y"]
    L --> Y["nodal admittance matrix Y,<br/>one node per coupler pin"]
    C --> Y
    B --> Y
    Y --> K["Kron reduction onto probe nodes,<br/>Yp = Ypp - Ypi Yii⁻¹ Yip"]
    K --> S["S = C(Z0 Yp), times lead transmission t²"]
    

Each element’s S-matrix is converted to an admittance matrix referenced to the CPW impedance \(Z_0\) (_cayley()), the elements are stamped into the nodal admittance matrix \(Y\) with one node per coupler pin, the nodes without a probe are eliminated by a Schur complement (Kron reduction [DorflerB13]) and the result is converted back to \(S = (I - Z_0 Y_\text{p})(I + Z_0 Y_\text{p})^{-1}\). This is the same S-matrix SAX produces for the netlist. Frequencies are solved in batches with jax.lax.map(), so memory stays \(O(N^2)\) in the number of coupler pins.

The model is a leaf model: gdsfactoryplus calls it directly instead of expanding the layout into resonators and couplers. It is also jax.jit()-compatible with the structural arguments below held static.

Parameters:

• f (FloatArrayLike) – Frequency in Hz.

• 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.

• resonator_length (FloatArrayLike) – Length of every edge resonator in µm.

• stub_length (float) – Length of the shorted boundary stubs in µm.

• probe_pins (tuple[int, ...]) – Indices into free_pins that become ports o1, o2, … in this order.

• 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. It is part of resonator_length and stub_length, and moves the probe reference planes to the end of the probe pins’ leads, like hyperbolic_vertex_coupler().

• cross_section (CrossSectionSpec) – CPW cross-section of resonators, stubs and probes.

Returns:

S-parameters between the probe ports.

Return type:

SDict

The structural arguments p, q, shells and probe_pins fix the circuit topology, so they are converted to Python integers and must be concrete; all other arguments may be traced by jax.jit().

Raises:

ValueError – If probe_pins is empty, repeats a pin or is out of range.

Parameters:

• f (FloatArrayLike)

• p (int)

• q (int)

• shells (int)

• resonator_length (FloatArrayLike)

• stub_length (float)

• probe_pins (tuple[int, ...])

• pin_radius (float)

• pin_gap (float)

• ground_gap (float)

• lead_length (float)

• cross_section (CrossSectionSpec)

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.hyperbolic_lattice().

(Source code, svg, pdf, png)

qpdk.models.hyperbolic_lattice() S-parameters for \(f\in[1,10]\,\text{GHz}\).

hyperbolic_vertex_coupler

qpdk.models.hyperbolic_vertex_coupler(*, f=5000000000.0, q=3, pin_radius=40.0, pin_gap=4.0, ground_gap=6.0, lead_length=20.0, cross_section='cpw')

S-parameters of a q-pin capacitive vertex coupler.

The pins form a lumped capacitance network with Maxwell matrix \(C\) (hyperbolic_vertex_coupler_capacitances()). Its nodal admittance \(Y = j\omega C\) gives

\[S = (I - Z_0 Y)(I + Z_0 Y)^{-1},\]

referenced to the CPW impedance \(Z_0\) of cross_section so the pins connect directly to straight() lines. The matched leads then multiply \(S_{ij}\) by their transmission \(t^2\), moving the reference planes to the layout ports.

Parameters:

• f (FloatArrayLike) – Frequency in Hz.

• q (int) – Number of pins.

• 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 the ground plane in µm.

• lead_length (float) – Length of the CPW lead on each pin in µm.

• cross_section (CrossSectionSpec) – Cross-section of the leads.

Returns:

S-parameters with ports o1 … oq.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.hyperbolic_vertex_coupler().

(Source code, svg, pdf, png)

qpdk.models.hyperbolic_vertex_coupler() S-parameters for \(f\in[1,10]\,\text{GHz}\).

resonator_meander

qpdk.models.resonator_meander(f=5000000000.0, length=3700.0, cross_section='cpw')

Model the meander by its total CPW electrical length.

Bends are approximated as straight CPW of equal length. The layout’s meander count, bend specification, and end-bend setting do not alter this electrical model, matching the pre-section whole-device model.

Returns:

Two-port SAX S-parameters for the meander path.

Parameters:

• f (FloatArrayLike)

• length (float)

• cross_section (CrossSectionSpec)

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.resonator_meander().

(Source code, svg, pdf, png)

qpdk.models.resonator_meander() S-parameters for \(f\in[1,10]\,\text{GHz}\).

vacuum_gap_capacitor

qpdk.models.vacuum_gap_capacitor(*, f=5000000000.0, radius=7.5, gap=0.07, fringing=1.0)

Vacuum-gap drum capacitor SAX model.

A two-port series capacitor between the bottom electrode (o1) and the suspended membrane (o2), with the capacitance from vacuum_gap_capacitance_analytical() [CLS+10].

Parameters:

• f (FloatArrayLike) – Array of frequency points in Hz.

• radius (float) – Bottom-electrode radius \(a\) in µm.

• gap (float) – Vacuum gap \(d\) in µm. Defaults to the layer-stack value.

• fringing (float) – Weight of the fringing term, 1 to include it and 0 to drop it.

Returns:

S-parameters dictionary with ports o1 and o2.

Return type:

SDict

Schematic symbol drawn by GDSFactory+ for qpdk.models.vacuum_gap_capacitor().

(Source code, svg, pdf, png)

qpdk.models.vacuum_gap_capacitor() S-parameters for \(f\in[1,10]\,\text{GHz}\).

Helper functions

Analytical formulas, parameter conversions and Hamiltonians used to build and design with the SAX models above.

Transmission-line parameters

Effective permittivity, characteristic impedance and propagation of CPW and microstrip lines.

cbcpw_parameters	Effective permittivity and impedance of a conductor-backed CPW.
cpw_epsilon_eff	Effective permittivity of a CPW on a finite-height substrate.
cpw_parameters	Compute complex effective permittivity and characteristic impedance for a CPW.
cpw_thickness_correction	Apply conductor thickness correction to CPW ε_eff and Z₀.
cpw_z0	Characteristic impedance of a CPW.
cpw_z0_from_cross_section	Characteristic impedance of a CPW defined by a layout cross-section.
microstrip_epsilon_eff	Effective permittivity of a microstrip line.
microstrip_thickness_correction	Conductor thickness correction for a microstrip line.
microstrip_z0	Characteristic impedance of a microstrip line.
propagation_constant	Complex propagation constant of a quasi-TEM transmission line.
transmission_line_s_params	S-parameters of a uniform transmission line (ABCD→S conversion).

cbcpw_parameters

qpdk.models.cbcpw_parameters(w, s, h, t, ep_r)

Effective permittivity and impedance of a conductor-backed CPW.

Quasi-static conformal mapping for a CPW on a substrate of height \(h\) whose backside is metallised, Simons [Sim01] (§3.2):

\[\begin{split}\begin{aligned} k_0 &= \frac{w}{w + 2s}, \qquad k_3 = \frac{\tanh(\pi w / 4h)}{\tanh\bigl(\pi (w + 2s) / 4h\bigr)} \\ q_i &= K(k_i^2) / K(1 - k_i^2) \\ \varepsilon_\text{eff} &= \frac{q_0 + \varepsilon_\text{r} q_3 + 1.4\,t/s}{q_0 + q_3 + 1.4\,t/s} \\ Z_0 &= \frac{60\pi}{\sqrt{\varepsilon_\text{eff}}\,(q_\text{e} + q_3 q_\text{e} / q_0)} \end{aligned}\end{split}\]

The conductor thickness enters through the Gupta et al. [GGBB96] terms used by cpw_thickness_correction(): the extra \(0.7\,t/s\) slot capacitance per side and \(q_\text{e}\), the capacitance ratio for the thickness-widened \(k_\text{e}\). Applying them to both half-spaces is a heuristic, chosen so that the result reduces exactly to the thickness-corrected CPW of cpw_thickness_correction() for \(h \gg w + 2s\), where the backside metal has no effect.

Parameters:

• w (ArrayLike) – Centre-conductor width (m).

• s (ArrayLike) – Gap to ground plane (m).

• h (ArrayLike) – Substrate height (m).

• t (ArrayLike) – Conductor thickness (m).

• ep_r (ArrayLike) – Relative permittivity of the substrate.

Returns:

(ep_eff, z0) — effective permittivity and characteristic impedance (Ω).

Return type:

tuple[Array, Array]

cpw_epsilon_eff

qpdk.models.cpw_epsilon_eff(w, s, h, ep_r)

Effective permittivity of a CPW on a finite-height substrate.

\[\begin{split}\begin{aligned} k_0 &= \frac{w}{w + 2s} \\ k_1 &= \frac{\sinh(\pi w / 4h)}{\sinh\bigl(\pi(w + 2s) / 4h\bigr)} \\ q_1 &= \frac{K(k_1^2)/K(1 - k_1^2)}{K(k_0^2)/K(1 - k_0^2)} \\ \varepsilon_{\mathrm{eff}} &= 1 + \frac{q_1(\varepsilon_r - 1)}{2} \end{aligned}\end{split}\]

where \(K\) is the complete elliptic integral of the first kind in the parameter convention (\(m = k^2\)).

References

Simoons, Eq. 2.37; Ghione & Naldi

Parameters:

• w (FloatArrayLike) – Centre-conductor width (m).

• s (FloatArrayLike) – Gap to ground plane (m).

• h (FloatArrayLike) – Substrate height (m).

• ep_r (FloatArrayLike) – Relative permittivity of the substrate.

Returns:

Effective permittivity (dimensionless).

Return type:

Array

cpw_parameters

qpdk.models.cpw_parameters(width, gap, *, tand=None, conductor_backed=False)

Compute complex effective permittivity and characteristic impedance for a CPW.

Uses the JAX-jittable functions from sax.models.rf with the PDK layer stack (substrate height, conductor thickness, material permittivity).

Dielectric loss is included via the filling factor \(q\) and the provided tand:

\[\varepsilon_{\text{eff, complex}} = \varepsilon_{\text{eff}} \left( 1 - j q \frac{\varepsilon_\text{r}}{\varepsilon_{\text{eff}}} \tan \delta \right)\]

where \(q = (\varepsilon_{\text{eff}} - 1) / (\varepsilon_\text{r} - 1)\).

Conductor thickness corrections follow Gupta, Garg, Bahl & Bhartia [GGBB96] (§7.3, Eqs. 7.98-7.100).

Parameters:

• width (float) – Centre-conductor width in µm.

• gap (float) – Gap between centre conductor and ground plane in µm.

• tand (float | None) – Loss tangent \(\tan\,\delta\) of the substrate. If None, uses the PDK default.

• conductor_backed (bool) – If True, the substrate backside is metallised (see LAYER_STACK_BACKSIDE) and cbcpw_parameters() is used instead of the CPW model.

Returns:

(ep_eff, z0) — complex effective permittivity (dimensionless) and characteristic impedance (Ω).

Return type:

tuple[Array, Array]

cpw_thickness_correction

qpdk.models.cpw_thickness_correction(w, s, t, ep_eff)

Apply conductor thickness correction to CPW ε_eff and Z₀.

First-order correction from Gupta, Garg, Bahl & Bhartia

\[\begin{split}\begin{aligned} \Delta &= \frac{1.25\,t}{\pi} \left(1 + \ln\frac{4\pi w}{t}\right) \\ k_e &= k_0 + (1 - k_0^2)\,\frac{\Delta}{2s} \\ \varepsilon_{\mathrm{eff},t} &= \varepsilon_{\mathrm{eff}} - \frac{0.7\,(\varepsilon_{\mathrm{eff}} - 1)\,t/s} {K(k_0^2)/K(1-k_0^2) + 0.7\,t/s} \\ Z_{0,t} &= \frac{30\pi} {\sqrt{\varepsilon_{\mathrm{eff},t}}\; K(k_e^2)/K(1-k_e^2)} \end{aligned}\end{split}\]

References

Gupta, Garg, Bahl & Bhartia, §7.3, Eqs. 7.98-7.100

Parameters:

• w (FloatArrayLike) – Centre-conductor width (m).

• s (FloatArrayLike) – Gap to ground plane (m).

• t (FloatArrayLike) – Conductor thickness (m).

• ep_eff (FloatArrayLike) – Uncorrected effective permittivity.

Returns:

(ep_eff_t, z0_t) — thickness-corrected effective permittivity and characteristic impedance (Ω).

Return type:

tuple[Any, Any]

cpw_z0

qpdk.models.cpw_z0(w, s, ep_eff)

Characteristic impedance of a CPW.

\[Z_0 = \frac{30\pi}{\sqrt{\varepsilon_{\mathrm{eff}}} K(k_0^2)/K(1 - k_0^2)}\]

References

Simons, Eq. 2.38. Note that our \(w\) and \(s\) correspond to Simons’ \(s\) and \(w\).

Parameters:

• w (FloatArrayLike) – Centre-conductor width (m).

• s (FloatArrayLike) – Gap to ground plane (m).

• ep_eff (FloatArrayLike) – Effective permittivity (see cpw_epsilon_eff()).

Returns:

Characteristic impedance (Ω).

Return type:

Array

cpw_z0_from_cross_section

qpdk.models.cpw_z0_from_cross_section(cross_section, f=None, conductor_backed=False)

Characteristic impedance of a CPW defined by a layout cross-section.

Parameters:

• cross_section (CrossSectionSpec) – A gdsfactory cross-section specification.

• f (ArrayLike | None) – Frequency array (Hz). Used only to determine the output shape; the impedance is frequency-independent in the quasi-static model.

• conductor_backed (bool) – If True, use the conductor-backed CPW model, see cpw_parameters().

Returns:

Characteristic impedance broadcast to the shape of f (Ω).

Return type:

Array

microstrip_epsilon_eff

qpdk.models.microstrip_epsilon_eff(w, h, ep_r)

Effective permittivity of a microstrip line.

Uses the Hammerstad-Jensen formula as given in Pozar.

\[\varepsilon_{\mathrm{eff}} = \frac{\varepsilon_r + 1}{2} + \frac{\varepsilon_r - 1}{2} \left(\frac{1}{\sqrt{1 + 12h/w}} + 0.04(1 - w/h)^2 \Theta(1 - w/h)\right)\]

where the last term contributes only for narrow strips (\(w/h < 1\)).

References

Hammerstad & Jensen; Pozar, Eqs. 3.195-3.196.

Parameters:

• w (FloatArrayLike) – Strip width (m).

• h (FloatArrayLike) – Substrate height (m).

• ep_r (FloatArrayLike) – Relative permittivity of the substrate.

Returns:

Effective permittivity (dimensionless).

Return type:

Array

microstrip_thickness_correction

qpdk.models.microstrip_thickness_correction(w, h, t, ep_r, ep_eff)

Conductor thickness correction for a microstrip line.

Uses the widely-adopted Schneider correction as presented in Pozar and Gupta et al.

\[\begin{split}\begin{aligned} w_e &= w + \frac{t}{\pi} \ln\frac{4e}{\sqrt{(t/h)^2 + (t/(wPI + 1.1tPI))^2}} \\ \varepsilon_{\mathrm{eff},t} &= \varepsilon_{\mathrm{eff}} - \frac{(\varepsilon_r - 1)\,t/h} {4.6\,\sqrt{w/h}} \end{aligned}\end{split}\]

Then the corrected \(Z_0\) is computed with the effective width \(w_e\) and corrected \(\varepsilon_{\mathrm{eff},t}\).

References

Pozar, §3.8; Gupta, Garg, Bahl & Bhartia

Parameters:

• w (FloatArrayLike) – Strip width (m).

• h (FloatArrayLike) – Substrate height (m).

• t (FloatArrayLike) – Conductor thickness (m).

• ep_r (FloatArrayLike) – Relative permittivity of the substrate.

• ep_eff (FloatArrayLike) – Uncorrected effective permittivity.

Returns:

(w_eff, ep_eff_t, z0_t) — effective width (m), thickness-corrected effective permittivity, and characteristic impedance (Ω).

Return type:

tuple[Array, Array, Array]

microstrip_z0

qpdk.models.microstrip_z0(w, h, ep_eff)

Characteristic impedance of a microstrip line.

Uses the Hammerstad-Jensen approximation as given in Pozar.

\[\begin{split}\begin{aligned} Z_0 = \begin{cases} \displaystyle\frac{60}{\sqrt{\varepsilon_{\mathrm{eff}}}} \ln\!\left(\frac{8h}{w} + \frac{w}{4h}\right) & w/h \le 1 \\[6pt] \displaystyle\frac{120\pi} {\sqrt{\varepsilon_{\mathrm{eff}}}\, \bigl[w/h + 1.393 + 0.667\ln(w/h + 1.444)\bigr]} & w/h \ge 1 \end{cases} \end{aligned}\end{split}\]

References

Hammerstad & Jensen; Pozar, Eqs. 3.197-3.198.

Parameters:

• w (FloatArrayLike) – Strip width (m).

• h (FloatArrayLike) – Substrate height (m).

• ep_eff (FloatArrayLike) – Effective permittivity (see microstrip_epsilon_eff()).

Returns:

Characteristic impedance (Ω).

Return type:

Array

propagation_constant

qpdk.models.propagation_constant(f, ep_eff, tand=0.0, ep_r=1.0)

Complex propagation constant of a quasi-TEM transmission line.

For the general lossy case

\[\gamma = \alpha_d + j\,\beta\]

where the dielectric attenuation is

\[\alpha_d = \frac{\pi f}{C_{M_S}} \frac{\varepsilon_r}{\sqrt{\varepsilon_{\mathrm{eff}}}} \frac{\varepsilon_{\mathrm{eff}} - 1} {\varepsilon_r - 1} \tan\delta\]

and the phase constant is

\[\beta = \frac{2\pi f}{C_{M_S}}\,\sqrt{\varepsilon_{\mathrm{eff}}}\]

For a superconducting line (\(\tan\delta = 0\)) the propagation is purely imaginary: \(\gamma = j\beta\).

References

Pozar, §3.8

Parameters:

• f (FloatArrayLike) – Frequency (Hz).

• ep_eff (FloatArrayLike) – Effective permittivity.

• tand (FloatArrayLike) – Real dielectric loss tangent (default 0 — lossless).

• ep_r (FloatArrayLike) – Substrate relative permittivity (only needed when tand > 0).

Returns:

Complex propagation constant \(\gamma\) (1/m).

Return type:

Array

transmission_line_s_params

qpdk.models.transmission_line_s_params(gamma, z0, length, z_ref=None)

S-parameters of a uniform transmission line (ABCD→S conversion).

The ABCD matrix of a line with characteristic impedance \(Z_0\), propagation constant \(\gamma\), and length \(\ell\) is:

\[\begin{split}\begin{aligned} \begin{pmatrix} A & B \\ C & D \end{pmatrix} = \begin{pmatrix} \cosh\theta & Z_0\sinh\theta \\ \sinh\theta / Z_0 & \cosh\theta \end{pmatrix}, \quad \theta = \gamma\ell \end{aligned}\end{split}\]

Converting to S-parameters referenced to \(Z_{\mathrm{ref}}\)

\[\begin{split}\begin{aligned} S_{11} &= \frac{A + B/Z_{\mathrm{ref}} - CZ_{\mathrm{ref}} - D}{ A + B/Z_{\mathrm{ref}} + CZ_{\mathrm{ref}} + D} \\ S_{21} &= \frac{2}{A + B/Z_{\mathrm{ref}} + CZ_{\mathrm{ref}} + D} \end{aligned}\end{split}\]

When z_ref is None the reference impedance defaults to z0 (matched case), giving \(S_{11} = 0\) and \(S_{21} = e^{-\gamma\ell}\).

References

Pozar, Table 4.2

Parameters:

• gamma (ComplexLike) – Complex propagation constant (1/m).

• z0 (ComplexLike) – Characteristic impedance (Ω).

• length (FloatArrayLike) – Physical length (m).

• z_ref (ComplexLike | None) – Reference (port) impedance (Ω). Defaults to z0.

Returns:

(S11, S21) — complex S-parameter arrays.

Return type:

tuple[Array, Array]

Qubit parameters

Conversions between circuit energies, capacitances and inductances, and unimon and gatemon spectra.

andreev_bound_state_energies	Compute the positive Andreev bound state energies of a short junction.
coupling_strength_to_capacitance	Convert coupling strength \(g\) to coupling capacitance \(C_\text{c}\).
double_pad_transmon_capacitance	Return the capacitance seen by charge moving between the two pads, in F.
double_pad_transmon_fem_model	Build a linearized transmon circuit from the stored two-pad Palace matrix.
ec_to_capacitance	Convert charging energy \(E_\text{C}\) to total capacitance \(C_\Sigma\).
ej_to_inductance	Convert Josephson energy \(E_\text{J}\) to Josephson inductance \(L_\text{J}\).
el_to_arm_inductance	Convert inductive energy \(E_\text{L}\) to geometric inductance of one arm \(L\).
el_to_inductance	Convert Josephson energy \(E_\text{J}\) to Josephson inductance \(L_\text{J}\).
flipmon_ideal_bond_model	Join inner and top pads with an ideal wire, then add a linearized junction.
flipmon_readout_coupon_model	Return the complete static readout coupon as a JAX SAX model.
flipmon_unbonded_model	Return the three-electrode electrostatic coupon as a JAX SAX model.
gatemon_capacitances	Return the island capacitances of a gatemon() layout, in F.
gatemon_energies	Compute the lowest energy levels of the gatemon Hamiltonian.
gatemon_fem_model	Build a linearised gatemon circuit from the stored Palace matrix.
gatemon_frequency_and_anharmonicity	Compute the qubit frequency and anharmonicity of a gatemon.
gatemon_hamiltonian	Build the gatemon Hamiltonian matrix in the charge basis.
gatemon_josephson_energy	Compute the effective Josephson energy of a gatemon junction.
gatemon_potential	Compute the even-parity junction potential of a gatemon.
gatemon_supercurrent	Compute the current-phase relation of a gatemon junction.
transmon_readout_coupon_model	Return the complete static readout coupon as a JAX SAX model.
unimon_energies	Compute the lowest energy eigenvalues of the unimon Hamiltonian.
unimon_frequency_and_anharmonicity	Compute the qubit transition frequency and anharmonicity of the unimon.
unimon_hamiltonian	Build the unimon Hamiltonian matrix in the harmonic-oscillator basis.

andreev_bound_state_energies

qpdk.models.andreev_bound_state_energies(phi, delta_ghz=50.0, transmissions=(0.8,))

Compute the positive Andreev bound state energies of a short junction.

\[E_p(\varphi) = \Delta \sqrt{1 - \tau_p \sin^2(\varphi / 2)}\]

Parameters:

• phi (ArrayLike) – Superconducting phase difference \(\varphi\) in radians.

• delta_ghz (ArrayLike) – Induced superconducting gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Channel transmissions \(\tau_p\).

Returns:

Array of shape (*jnp.shape(phi), n_channels) with the energies in GHz.

Return type:

Array

coupling_strength_to_capacitance

qpdk.models.coupling_strength_to_capacitance(g_ghz, c_sigma, c_r, f_q_ghz, f_r_ghz)

Convert coupling strength \(g\) to coupling capacitance \(C_\text{c}\).

In the dispersive limit (\(g \ll f_\text{q}, f_\text{r}\)), the coupling strength can be related to a coupling capacitance via:

\[g \approx \frac{1}{2} \frac{C_\text{c}}{\sqrt{C_\Sigma C_\text{r}}} \sqrt{f_\text{q} f_\text{r}}\]

Solving for \(C_\text{c}\):

\[C_\text{c} = \frac{2g}{\sqrt{f_\text{q} f_\text{r}}} \sqrt{C_\Sigma C_\text{r}}\]

See [KKY+19, Sav23] for details.

Parameters:

• g_ghz (ArrayLike) – Coupling strength in GHz.

• c_sigma (ArrayLike) – Total qubit capacitance in Farads.

• c_r (ArrayLike) – Total resonator capacitance in Farads.

• f_q_ghz (ArrayLike) – Qubit frequency in GHz.

• f_r_ghz (ArrayLike) – Resonator frequency in GHz.

Returns:

Coupling capacitance in Farads.

Return type:

Array

Example

>>> C_c = coupling_strength_to_capacitance(
...     g_ghz=0.1,
...     c_sigma=100e-15,  # 100 fF
...     c_r=50e-15,  # 50 fF
...     f_q_ghz=5.0,
...     f_r_ghz=7.0,
... )
>>> print(f"{C_c * 1e15:.2f} fF")

double_pad_transmon_capacitance

qpdk.models.double_pad_transmon_capacitance(*, pad_width=250.0, pad_height=400.0, pad_gap=20.0, ground_clearance=200.0)

Return the capacitance seen by charge moving between the two pads, in F.

Both pads float inside a 300 um wide coplanar ground frame on silicon. Dimensions are in um. The stored Palace matrix includes pad-to-pad and pad-to-ground fields; differential_capacitance() combines them for equal and opposite pad charges.

The junction and neighbouring devices are omitted. Add the junction’s capacitance in parallel before computing \(E_\text{C}=e^2/(2C)\). Dimensions outside the stored grid return NaN. Supports JIT, vmap and grad.

Returns:

Differential pad capacitance in F, excluding the junction capacitance.

Parameters:

• pad_width (float)

• pad_height (float)

• pad_gap (float)

• ground_clearance (float)

Return type:

Array

double_pad_transmon_fem_model

qpdk.models.double_pad_transmon_fem_model(*, inductance, junction_capacitance=0.0)

Build a linearized transmon circuit from the stored two-pad Palace matrix.

Supply the Josephson inductance in H and additional junction capacitance in F. The returned JAX model accepts frequency in Hz, z_ref in ohms, and pad_width, pad_height, pad_gap, ground_clearance in um. Its left_pad and right_pad ports both reference the finite ground frame. All pad-to-ground and mutual capacitances are retained.

This describes small oscillations, not the nonlinear qubit spectrum. No readout, feedline, package lid or backside ground is included. See junction_model() for the circuit convention.

Returns:

Jittable two-port SAX model with explicit junction parameters.

Parameters:

• inductance (float)

• junction_capacitance (float)

Return type:

Model

ec_to_capacitance

qpdk.models.ec_to_capacitance(ec_ghz)

Convert charging energy \(E_\text{C}\) to total capacitance \(C_\Sigma\).

The charging energy is related to capacitance by:

\[E_\text{C} = \frac{e^2}{2 C_\Sigma}\]

where \(e\) is the electron charge.

Parameters:

ec_ghz (ArrayLike) – Charging energy in GHz.

Returns:

Total capacitance in Farads.

Return type:

Array

Example

>>> C = ec_to_capacitance(0.2)  # 0.2 GHz (200 MHz) charging energy
>>> print(f"{C * 1e15:.1f} fF")  # ~96 fF

ej_to_inductance

qpdk.models.ej_to_inductance(ej_ghz)

Convert Josephson energy \(E_\text{J}\) to Josephson inductance \(L_\text{J}\).

The Josephson energy is related to inductance by:

\[E_\text{J} = \frac{\Phi_0^2}{4 \pi^2 L_\text{J}} = \frac{(\hbar / 2e)^2}{L_\text{J}}\]

This is equivalent to:

\[L_\text{J} = \frac{\Phi_0}{2 \pi I_\text{c}}\]

where \(I_\text{c}\) is the critical current and \(\Phi_0\) is the magnetic flux quantum.

Parameters:

ej_ghz (ArrayLike) – Josephson energy in GHz.

Returns:

Josephson inductance in Henries.

Return type:

Array

Example

>>> L = ej_to_inductance(20.0)  # 20 GHz Josephson energy
>>> print(f"{L * 1e9:.2f} nH")  # ~1.0 nH

el_to_arm_inductance

qpdk.models.el_to_arm_inductance(el_ghz)

Convert inductive energy \(E_\text{L}\) to geometric inductance of one arm \(L\).

The total inductive energy \(E_\text{L}\) of the unimon is related to the geometric inductance of its two arms (in series) by:

\[E_\text{L} = \frac{\Phi_0^2}{4 \pi^2 \cdot 2 L} = \frac{(\hbar / 2e)^2}{2 L}\]

Solving for the inductance \(L\) of a single arm:

\[L = \frac{\Phi_0^2}{8 \pi^2 E_\text{L}}\]

Parameters:

el_ghz (ArrayLike) – Inductive energy in GHz.

Returns:

Geometric inductance of one arm in Henries.

Return type:

Array

Example

>>> L = el_to_arm_inductance(5.0)  # 5 GHz inductive energy
>>> print(f"{L * 1e9:.2f} nH")

el_to_inductance

qpdk.models.el_to_inductance(ej_ghz)

Convert Josephson energy \(E_\text{J}\) to Josephson inductance \(L_\text{J}\).

The Josephson energy is related to inductance by:

\[E_\text{J} = \frac{\Phi_0^2}{4 \pi^2 L_\text{J}} = \frac{(\hbar / 2e)^2}{L_\text{J}}\]

This is equivalent to:

\[L_\text{J} = \frac{\Phi_0}{2 \pi I_\text{c}}\]

where \(I_\text{c}\) is the critical current and \(\Phi_0\) is the magnetic flux quantum.

Parameters:

ej_ghz (ArrayLike) – Josephson energy in GHz.

Returns:

Josephson inductance in Henries.

Return type:

Array

Example

>>> L = ej_to_inductance(20.0)  # 20 GHz Josephson energy
>>> print(f"{L * 1e9:.2f} nH")  # ~1.0 nH

flipmon_ideal_bond_model

qpdk.models.flipmon_ideal_bond_model(*, inductance, junction_capacitance=0.0)

Join inner and top pads with an ideal wire, then add a linearized junction.

Supply the Josephson inductance in H and additional junction capacitance in F. The returned JAX model accepts the same geometry and frequency arguments as flipmon_unbonded_model(). Its ports are inner_pad and outer_ring, both referenced to chip ground.

The ideal wire preserves capacitance to ground but adds no bump field or inductance. This reduction has no finite-bump validation and describes small oscillations, not the nonlinear qubit spectrum. See junction_model() for the circuit convention.

Returns:

Jittable two-port model with explicit junction parameters.

Parameters:

• inductance (float)

• junction_capacitance (float)

Return type:

Model

flipmon_readout_coupon_model

qpdk.models.flipmon_readout_coupon_model()

Return the complete static readout coupon as a JAX SAX model.

The ports include a separate unbonded top pad in addition to island_a, island_b, readout and feedline. Each port references chip ground. The returned model accepts pad_length, pad_offset, feedline_gap and coupling_length in um, frequency f in Hz and z_ref in ohms.

The feedline ends are cut open and the entire readout conductor shares one potential. This does not describe a shorted resonator mode. Adding it to a distributed circuit would duplicate route and ground capacitance. No driven/eigenmode or resonance validation is implied.

Returns:

Jittable five-port static coupon model; out-of-grid inputs return NaN.

Return type:

Model

flipmon_unbonded_model

qpdk.models.flipmon_unbonded_model()

Return the three-electrode electrostatic coupon as a JAX SAX model.

inner_pad, outer_ring and top_pad remain separate ports, all referenced to the two chip ground frames. The coupon has two 300 um silicon chips and 0.2 um metal. It omits the junction and bonding bump. The returned model accepts chip_gap, alignment, inner_radius and top_radius in um, frequency f in Hz and z_ref in ohms. Alignment shifts the top pad horizontally while ground frames stay fixed. Dimensions outside the stored grid return NaN.

Returns:

Jittable three-port model retaining all Maxwell capacitances.

Return type:

Model

gatemon_capacitances

qpdk.models.gatemon_capacitances(*, island_size=150.0, pocket_gap=60.0, pocket_gap_top=40.0, gate_tip_gap=5.0, dataset='gatemon_palace')

Return the island capacitances of a gatemon() layout, in F.

Dimensions are in µm and follow the dataset recipe’s layout rule. The nominal point matches the default device. Below 150 µm, the contact and gate-tip dimensions scale with the island. The gate feed moves right as needed to retain its hBN landing clearance. The Palace Maxwell matrix gives

• \(C_\Sigma = C_{ii}\), the total island capacitance, so \(E_\text{C} = e^2 / 2 C_\Sigma\),

• \(C_\text{g} = -C_{ig}\) to the gate line, which sets the island offset charge \(n_\text{g} = C_\text{g} V_\text{g} / 2e\),

• \(C_\text{c} = -C_{ir}\) to the readout CPW over the pocket.

The bundled recipe extracts only M1 sheets. Contact leads, the local top gate, hBN and thermal oxide need a separate calculation. Its \(C_\text{g}\) is coupling to the M1 feed, not the nanotube gate lever arm.

\(C_\Sigma\) already includes \(C_\text{g}\) and \(C_\text{c}\). The junction is omitted; add its capacitance to \(C_\Sigma\) before computing \(E_\text{C}\), then pass \(E_\text{C}\) to gatemon_frequency_and_anharmonicity() for the spectrum. Dimensions outside the stored grid return NaN. Supports JIT, vmap and grad.

Parameters:

• island_size (ArrayLike) – Side of the square island in µm.

• pocket_gap (ArrayLike) – Etched gap around the island sides and bottom in µm.

• pocket_gap_top (ArrayLike) – Etched gap between the island and the readout in µm.

• gate_tip_gap (ArrayLike) – Lateral gap from hBN to the M1 gate landing in µm.

• dataset (Dataset | Path | str) – Dataset or path with terminals island, gate, readout.

Returns:

(C_sigma, C_g, C_c) in F, each with the broadcast input shape.

Return type:

tuple[Array, Array, Array]

gatemon_energies

qpdk.models.gatemon_energies(ec_ghz=0.26, delta_ghz=50.0, transmissions=(0.8,), n_g=0.0, n_max=30, n_levels=5)

Compute the lowest energy levels of the gatemon Hamiltonian.

Diagonalises gatemon_hamiltonian() and returns the n_levels lowest eigenvalues relative to the ground state.

Parameters:

• ec_ghz (ArrayLike) – Charging energy \(E_\text{C}\) in GHz.

• delta_ghz (ArrayLike) – Induced superconducting gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Channel transmissions \(\tau_p\).

• n_g (ArrayLike) – Offset charge \(n_\text{g}\) in units of \(2e\).

• n_max (int) – Charge basis truncation, see gatemon_hamiltonian().

• n_levels (int) – Number of levels to return.

Returns:

Array of shape (n_levels,) with energies in GHz, ground state at zero.

Return type:

Array

gatemon_fem_model

qpdk.models.gatemon_fem_model(*, delta_ghz=50.0, transmissions=(0.8,), junction_capacitance=0.0, dataset='gatemon_palace')

Build a linearised gatemon circuit from the stored Palace matrix.

The ports island, gate and readout all reference chip ground. Their admittance is \(j\omega C\) from the full Maxwell matrix, plus the junction between the island and ground,

\[Y_\text{J} = \frac{1}{j\omega L_\text{J}} + j\omega C_\text{J}, \qquad L_\text{J} = \left(\frac{\Phi_0}{2\pi}\right)^2 \frac{1}{E_\text{J}},\]

with \(E_\text{J}\) from the Andreev bound states (gatemon_josephson_energy()). The returned JAX model accepts frequency in Hz, z_ref in ohms, delta_ghz, transmissions and junction_capacitance, and the layout dimensions of gatemon_capacitances() in µm.

This describes small oscillations around \(\varphi = 0\), not the nonlinear spectrum. The readout port is an open CPW segment: drive it for the coupling, but its self-capacitance belongs to the segment, so do not add it to a distributed resonator model.

The bundled recipe includes only M1 sheets. Its matrix omits the contact leads, local top gate, hBN and thermal oxide, so it does not determine the nanotube’s gate lever arm or the complete capacitance of the hybrid device.

Parameters:

• delta_ghz (float) – Default induced gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Default channel transmissions \(\tau_p\).

• junction_capacitance (float) – Default extra junction capacitance in F.

• dataset (Dataset | Path | str) – Dataset or path with terminals island, gate, readout.

Returns:

Jittable three-port SAX model.

Return type:

SDictModel

gatemon_frequency_and_anharmonicity

qpdk.models.gatemon_frequency_and_anharmonicity(ec_ghz=0.26, delta_ghz=50.0, transmissions=(0.8,), n_g=0.0, n_max=30)

Compute the qubit frequency and anharmonicity of a gatemon.

\[f_{01} = E_1 - E_0, \qquad \alpha = f_{12} - f_{01} = E_2 - 2 E_1\]

with \(E_0 = 0\). The anharmonicity is negative. For a tunnel junction with \(E_\text{J} \gg E_\text{C}\), \(\alpha \approx -E_\text{C}\). For a single channel near \(\tau = 1\) its magnitude drops towards \(E_\text{C}/4\) [KCH+18].

Parameters:

• ec_ghz (ArrayLike) – Charging energy \(E_\text{C}\) in GHz.

• delta_ghz (ArrayLike) – Induced superconducting gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Channel transmissions \(\tau_p\).

• n_g (ArrayLike) – Offset charge \(n_\text{g}\) in units of \(2e\).

• n_max (int) – Charge basis truncation, see gatemon_hamiltonian().

Returns:

Tuple of (f01_ghz, alpha_ghz).

Return type:

tuple[Array, Array]

Example

>>> f01, alpha = gatemon_frequency_and_anharmonicity(
...     ec_ghz=0.26, delta_ghz=50.0, transmissions=(0.8,)
... )

gatemon_hamiltonian

qpdk.models.gatemon_hamiltonian(ec_ghz=0.26, delta_ghz=50.0, transmissions=(0.8,), n_g=0.0, n_max=30)

Build the gatemon Hamiltonian matrix in the charge basis.

\[\hat{H} = 4 E_\text{C} (\hat{n} - n_\text{g})^2 + U(\hat{\varphi}), \qquad U(\varphi) = -\Delta \sum_p \sqrt{1 - \tau_p \sin^2(\varphi / 2)}\]

The potential is \(2\pi\)-periodic, so it is expanded numerically in Fourier harmonics \(U(\varphi) = \sum_k U_k e^{i k \varphi}\) with an FFT. Since \(e^{i k \hat{\varphi}}\) shifts the charge by \(k\) Cooper pairs, the matrix elements are \(H_{nm} = 4 E_\text{C} (n - n_\text{g})^2 \delta_{nm} + U_{|n-m|}\). For a tunnel junction only \(U_{\pm 1} = -E_\text{J}/2\) survives, recovering the transmon Hamiltonian of [KYG+07]. Higher transmissions add longer-range couplings [KCH+18].

Parameters:

• ec_ghz (ArrayLike) – Charging energy \(E_\text{C}\) in GHz. The default is the value of device A in [RAP+25].

• delta_ghz (ArrayLike) – Induced superconducting gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Channel transmissions \(\tau_p\).

• n_g (ArrayLike) – Offset charge \(n_\text{g}\) in units of \(2e\).

• n_max (int) – Charge basis truncation; the basis is \(n \in \{-n_{\max}, \dots, n_{\max}\}\).

Returns:

A (2*n_max+1, 2*n_max+1) real symmetric matrix in GHz.

Return type:

Array

Notes

JAX supplies the FFT and Hermitian eigensolver; only the junction potential and its charge-basis mapping are specific to this model. For eigenstates, tensor products or time evolution, pass this matrix to QuTiP with its optional JAX backend. Install qpdk[models,qutip]. Setting isherm=True keeps the Hermiticity check static under JIT.

Example

Build a JAX-backed QuTiP operator without changing the global backend:

import qutip as qt
import qutip_jax

H = qt.Qobj(gatemon_hamiltonian(), dtype="jax", isherm=True)
energies, states = H.eigenstates(eigvals=3)

H is in GHz. QuTiP time evolution uses angular frequencies, so use 2 * jnp.pi * H with times in ns.

gatemon_josephson_energy

qpdk.models.gatemon_josephson_energy(delta_ghz=50.0, transmissions=(0.8,))

Compute the effective Josephson energy of a gatemon junction.

The effective Josephson energy is the curvature of the junction potential at \(\varphi = 0\),

\[E_\text{J} = \left.\frac{\partial^2 U}{\partial \varphi^2}\right|_{\varphi=0} = \frac{\Delta}{4} \sum_p \tau_p ,\]

which equals the Josephson energy of the \(-E_\text{J}\cos\varphi\) potential obtained in the tunnel limit \(\tau_p \to 0\).

Parameters:

• delta_ghz (ArrayLike) – Induced superconducting gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Channel transmissions \(\tau_p\).

Returns:

Effective Josephson energy in GHz.

Return type:

Array

gatemon_potential

qpdk.models.gatemon_potential(phi, delta_ghz=50.0, transmissions=(0.8,))

Compute the even-parity junction potential of a gatemon.

\[U(\varphi) = -\Delta \sum_p \sqrt{1 - \tau_p \sin^2(\varphi / 2)}\]

Parameters:

• phi (ArrayLike) – Superconducting phase difference \(\varphi\) in radians.

• delta_ghz (ArrayLike) – Induced superconducting gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Channel transmissions \(\tau_p\).

Returns:

Potential energy in GHz, with the shape of phi.

Return type:

Array

gatemon_supercurrent

qpdk.models.gatemon_supercurrent(phi, delta_ghz=50.0, transmissions=(0.8,), temperature=0.0)

Compute the current-phase relation of a gatemon junction.

\[I(\varphi) = -\frac{2e}{\hbar} \sum_p \tanh\left(\frac{E_p}{2 k_\text{B} T}\right) \frac{\partial E_p}{\partial \varphi}\]

At \(T = 0\) this is \((2e/\hbar)\,\partial U/\partial\varphi\). The critical current of a single ballistic channel (\(\tau = 1\), \(T = 0\)) is \(e\Delta/\hbar\), reached as \(\varphi \to \pi\). Exactly at \(\tau = 1\), \(\varphi = \pi\) the current is discontinuous and this function returns 0.

Parameters:

• phi (ArrayLike) – Superconducting phase difference \(\varphi\) in radians.

• delta_ghz (ArrayLike) – Induced superconducting gap \(\Delta\) in GHz.

• transmissions (ArrayLike | Sequence[float]) – Channel transmissions \(\tau_p\).

• temperature (ArrayLike) – Temperature \(T\) in Kelvin.

Returns:

Supercurrent in Amperes, with the shape of phi.

Return type:

Array

transmon_readout_coupon_model

qpdk.models.transmon_readout_coupon_model()

Return the complete static readout coupon as a JAX SAX model.

The ports are island_a, island_b, readout and feedline. Each port references chip ground. The returned model accepts pad_length, pad_offset, feedline_gap and coupling_length in um, frequency f in Hz and z_ref in ohms. Feedline gaps from 14 to 20 um retain a ground strip between the coupled lines.

The feedline ends are cut open and the entire readout conductor shares one potential. This does not describe a shorted resonator mode. Adding it to a distributed circuit would duplicate route and ground capacitance. No driven/eigenmode or resonance validation is implied.

Returns:

Jittable four-port static coupon model; out-of-grid inputs return NaN.

Return type:

Model

unimon_energies

qpdk.models.unimon_energies(ec_ghz=1.0, el_ghz=5.0, ej_ghz=10.0, phi_ext=3.141592653589793, n_max=30, n_levels=5)

Compute the lowest energy eigenvalues of the unimon Hamiltonian.

Diagonalises the Hamiltonian returned by unimon_hamiltonian() and returns the n_levels lowest eigenvalues, shifted so that the ground state energy is zero.

Parameters:

• ec_ghz (float) – Charging energy \(E_\text{C}\) in GHz.

• el_ghz (float) – Inductive energy \(E_\text{L}\) in GHz.

• ej_ghz (float) – Josephson energy \(E_\text{J}\) in GHz.

• phi_ext (float) – External flux \(\varphi_{\text{ext}}\) in radians.

• n_max (int) – Basis truncation, see unimon_hamiltonian().

• n_levels (int) – Number of lowest energy levels to return.

Returns:

Array of shape (n_levels,) with energies in GHz, referenced to the ground state.

Return type:

Array

Example

>>> energies = unimon_energies(ec_ghz=1.0, el_ghz=5.0, ej_ghz=10.0)
>>> f_01 = float(energies[1])  # qubit frequency in GHz
>>> alpha = float(energies[2] - 2 * energies[1])  # anharmonicity

unimon_frequency_and_anharmonicity

qpdk.models.unimon_frequency_and_anharmonicity(ec_ghz=1.0, el_ghz=5.0, ej_ghz=10.0, phi_ext=3.141592653589793, n_max=30)

Compute the qubit transition frequency and anharmonicity of the unimon.

The qubit frequency is

\[f_{01} = E_1 - E_0\]

and the anharmonicity is

\[\alpha = (E_2 - E_1) - (E_1 - E_0) = E_2 - 2 E_1\]

(since \(E_0 = 0\) after shifting).

Parameters:

• ec_ghz (float) – Charging energy \(E_\text{C}\) in GHz.

• el_ghz (float) – Inductive energy \(E_\text{L}\) in GHz.

• ej_ghz (float) – Josephson energy \(E_\text{J}\) in GHz.

• phi_ext (float) – External flux \(\varphi_{\text{ext}}\) in radians.

• n_max (int) – Basis truncation, see unimon_hamiltonian().

Returns:

Tuple of (frequency_ghz, anharmonicity_ghz).

Return type:

tuple[float, float]

Example

>>> f01, alpha = unimon_frequency_and_anharmonicity(
...     ec_ghz=1.0, el_ghz=5.0, ej_ghz=10.0
... )
>>> print(f"f_01 = {f01:.3f} GHz, alpha = {alpha:.3f} GHz")

unimon_hamiltonian

qpdk.models.unimon_hamiltonian(ec_ghz=1.0, el_ghz=5.0, ej_ghz=10.0, phi_ext=3.141592653589793, n_max=30)

Build the unimon Hamiltonian matrix in the harmonic-oscillator basis.

The effective single-mode unimon Hamiltonian is

\[\hat{H} = 4 E_\text{C} \hat{n}^2 + \tfrac{1}{2} E_\text{L} (\hat{\varphi} - \varphi_{\text{ext}})^2 - E_\text{J} \cos\hat{\varphi}\]

Energy Scales and Physics: - \(E_\text{J}\): The Josephson energy of the single non-linear junction. - \(E_\text{C}\): The effective charging energy. The large geometric capacitance

of the CPW resonator means this is lower than typical transmons.

• \(E_\text{L}\): The inductive energy provided by the CPW resonator shunting the junction. The unimon operates in the regime \(E_\text{L} \sim E_\text{J}\).

Similarities to Fluxonium: The effective single-mode circuit model of the unimon is mathematically identical to a fluxonium qubit. The inductive shunt (provided by the CPW resonators) guarantees there are no isolated superconducting islands, making the unimon intrinsically immune to dephasing caused by low-frequency \(1/f\) charge noise.

Phase and Charge Operators: Because the unimon is inductively shunted, its potential energy features a quadratic term \(\tfrac{1}{2} E_\text{L} \hat{\varphi}^2\), meaning the potential is not \(2\pi\)-periodic. Thus, the phase operator \(\hat{\varphi}\) must be treated as an extended, non-compact variable. Consequently, the conjugate charge variable \(n\) is continuous, rather than taking discrete integer values as it does for a transmon.

Note on this implementation: The Hamiltonian is represented in the eigenbasis of the harmonic part \(4 E_\text{C} \hat{n}^2 + \tfrac{1}{2} E_\text{L} \hat{\varphi}^2\), truncated to \(2 n_{\max} + 1\) states, with \(\hat{\varphi} = \varphi_\text{zpf} (\hat{a} + \hat{a}^\dagger)\), \(\hat{n} = \tfrac{i}{2 \varphi_\text{zpf}} (\hat{a}^\dagger - \hat{a})\) and \(\varphi_\text{zpf} = (2 E_\text{C} / E_\text{L})^{1/4}\). \(\cos\hat{\varphi}\) is evaluated from the eigendecomposition of the truncated \(\hat{\varphi}\).

See [HKC+22] and [TVT+24].

Parameters:

• ec_ghz (float) – Charging energy \(E_\text{C}\) in GHz.

• el_ghz (float) – Inductive energy \(E_\text{L}\) in GHz.

• ej_ghz (float) – Josephson energy \(E_\text{J}\) in GHz.

• phi_ext (float) – External flux bias \(\varphi_{\text{ext}}\) in radians (reduced flux-quantum units). The optimal operating point is \(\pi\).

• n_max (int) – Basis truncation; Hilbert-space dimension is \(2 n_{\max} + 1\).

Returns:

A (2*n_max+1, 2*n_max+1) Hermitian matrix (in GHz).

Return type:

Array

Perturbation theory

Transmon frequency and anharmonicity, dispersive shifts, Purcell decay, linewidths and dephasing.

dispersive_shift	Compute the dispersive shift numerically.
dispersive_shift_to_coupling	Compute the coupling strength from a target dispersive shift.
ej_ec_to_frequency_and_anharmonicity	Convert \(E_\text{J}\) and \(E_\text{C}\) to qubit frequency and anharmonicity.
measurement_induced_dephasing	Estimate measurement-induced dephasing rate.
purcell_decay_rate	Estimate the Purcell decay rate of a transmon through a resonator.
resonator_linewidth_from_q	Compute resonator linewidth from external quality factor.

dispersive_shift

qpdk.models.dispersive_shift(ω_t_ghz, ω_r_ghz, α_ghz, g_ghz)

Compute the dispersive shift numerically.

Evaluates the second-order dispersive shift for a transmon coupled to a resonator. Uses the analytical formula derived from perturbation theory (without the rotating wave approximation) [BGGW21, KYG+07]:

\[\chi = \frac{2g^2}{\Delta} - \frac{2g^2}{\Delta + \alpha} + \frac{2g^2}{\omega_\text{t} + \omega_\text{r}} - \frac{2g^2}{\omega_\text{t} + \omega_\text{r} + \alpha}\]

where \(\Delta = \omega_\text{t} - \omega_\text{r}\) and \(\chi = (E_{11} - E_{10}) - (E_{01} - E_{00})\). The first two terms give the rotating-wave-approximation (RWA) contribution

\[\chi_\text{RWA} = \frac{2 \alpha g^2}{\Delta(\Delta + \alpha)}\]

and the last two are corrections from the counter-rotating terms. For a transmon (\(\alpha < 0\)) dispersive below the resonator (\(\Delta < 0\), \(|\Delta| > |\alpha|\)), \(\chi\) is negative.

All parameters are in GHz, and the returned value is also in GHz.

Parameters:

• ω_t_ghz (ArrayLike) – Transmon frequency in GHz.

• ω_r_ghz (ArrayLike) – Resonator frequency in GHz.

• α_ghz (ArrayLike) – Transmon anharmonicity in GHz (negative for a transmon, \(\alpha \approx -E_\text{C}\)).

• g_ghz (ArrayLike) – Coupling strength in GHz.

Returns:

Dispersive shift \(\chi\) in GHz.

Return type:

Array

Example

>>> χ = dispersive_shift(5.0, 7.0, -0.2, 0.1)
>>> print(f"χ = {χ * 1e3:.2f} MHz")

dispersive_shift_to_coupling

qpdk.models.dispersive_shift_to_coupling(χ_ghz, ω_t_ghz, ω_r_ghz, α_ghz)

Compute the coupling strength from a target dispersive shift.

Inverts the dispersive shift relation to find the coupling strength \(g\) required to achieve a desired \(\chi\). Uses only the dominant rotating-wave term [KYG+07]:

\[g \approx \sqrt{\frac{\chi\,\Delta\,(\Delta + \alpha)}{2\alpha}}\]

where \(\Delta = \omega_\text{t} - \omega_\text{r}\).

Note

The expression under the square root may be negative when the sign of the target \(\chi\) is inconsistent with the detuning and anharmonicity (e.g., positive \(\chi\) with \(\Delta < 0\)). In that case the absolute value is taken so that the returned coupling strength is always real and non-negative, but the caller should verify self-consistency via dispersive_shift().

Parameters:

• χ_ghz (ArrayLike) – Target dispersive shift in GHz (typically negative).

• ω_t_ghz (ArrayLike) – Transmon frequency in GHz.

• ω_r_ghz (ArrayLike) – Resonator frequency in GHz.

• α_ghz (ArrayLike) – Transmon anharmonicity in GHz (negative for a transmon, \(\alpha \approx -E_\text{C}\)).

Returns:

Coupling strength \(g\) in GHz.

Return type:

float | Array

Example

>>> g = dispersive_shift_to_coupling(-0.001, 5.0, 7.0, -0.2)
>>> print(f"g = {g * 1e3:.1f} MHz")

ej_ec_to_frequency_and_anharmonicity

qpdk.models.ej_ec_to_frequency_and_anharmonicity(ej_ghz, ec_ghz)

Convert \(E_\text{J}\) and \(E_\text{C}\) to qubit frequency and anharmonicity.

Uses the standard transmon approximations [KYG+07]:

\[\begin{split}\begin{aligned} \omega_\text{q} &\approx \sqrt{8 E_\text{J} E_\text{C}} - E_\text{C} \\ \alpha &\approx -E_\text{C} \end{aligned}\end{split}\]

Parameters:

• ej_ghz (ArrayLike) – Josephson energy in GHz.

• ec_ghz (ArrayLike) – Charging energy in GHz.

Returns:

Tuple of (ω_q_ghz, α_ghz).

Return type:

tuple[float | Array, float | Array]

Example

>>> ω_q, α = ej_ec_to_frequency_and_anharmonicity(20.0, 0.2)
>>> print(f"ω_q = {ω_q:.2f} GHz, α = {α:.1f} GHz")

measurement_induced_dephasing

qpdk.models.measurement_induced_dephasing(χ_ghz, κ_ghz, n_bar)

Estimate measurement-induced dephasing rate.

During dispersive readout, photons in the resonator cause additional dephasing of the qubit [BGGW21, GBS+06]:

\[\Gamma_\phi = \frac{8 \chi^2 \bar{n}}{\kappa}\]

where \(\bar{n}\) is the mean photon number in the resonator.

Parameters:

• χ_ghz (ArrayLike) – Dispersive shift in GHz.

• κ_ghz (ArrayLike) – Resonator linewidth in GHz.

• n_bar (ArrayLike) – Mean photon number in the resonator during measurement.

Returns:

Measurement-induced dephasing rate in GHz.

Return type:

float | Array

Example

>>> Γ_φ = measurement_induced_dephasing(-0.001, 0.001, 5.0)
>>> print(f"Γ_φ = {Γ_φ * 1e6:.1f} kHz")

purcell_decay_rate

qpdk.models.purcell_decay_rate(g_ghz, ω_t_ghz, ω_r_ghz, κ_ghz)

Estimate the Purcell decay rate of a transmon through a resonator.

The Purcell effect limits qubit lifetime when coupled to a lossy resonator. In the dispersive regime [BGGW21, HSJ+08]:

\[\gamma_\text{Purcell} = \kappa \left(\frac{g}{\Delta}\right)^2\]

where \(\kappa\) is the resonator decay rate and \(\Delta = \omega_\text{t} - \omega_\text{r}\).

Parameters:

• g_ghz (ArrayLike) – Coupling strength in GHz.

• ω_t_ghz (ArrayLike) – Transmon frequency in GHz.

• ω_r_ghz (ArrayLike) – Resonator frequency in GHz.

• κ_ghz (ArrayLike) – Resonator linewidth (decay rate) in GHz.

Returns:

Purcell decay rate in GHz.

Return type:

float | Array

Example

>>> γ = purcell_decay_rate(0.1, 5.0, 7.0, 0.001)
>>> T_purcell = 1 / (γ * 1e9)
>>> print(f"T_Purcell = {T_purcell * 1e6:.0f} µs")

resonator_linewidth_from_q

qpdk.models.resonator_linewidth_from_q(ω_r_ghz, q_ext)

Compute resonator linewidth from external quality factor.

Converts external quality factor to linewidth (half-linewidth at half-maximum) [GFB+08, MP12]:

\[\kappa = \frac{\omega_\text{r}}{Q_\text{ext}}\]

Parameters:

• ω_r_ghz (ArrayLike) – Resonator frequency in GHz.

• q_ext (ArrayLike) – External quality factor.

Returns:

Resonator linewidth \(\kappa\) in GHz.

Return type:

float | Array

Example

>>> κ = resonator_linewidth_from_q(7.0, 10_000)
>>> print(f"κ = {κ * 1e6:.1f} kHz")

Component helpers

Closed-form estimates for resonators, couplers and inductors.

cpw_cpw_coupling_capacitance	Look up Palace coupling capacitance between two parallel CPWs.
esr_lc_resonator_parameters	Circuit parameters of qpdk.cells.esr_lc_resonator().
esr_mode_volume	Magnetic mode volume of an LC resonator with a thin-strip inductor.
grounded_pad_capacitance_analytical	Capacitance between a coplanar pad and a ground plane edge.
meander_inductor_fullwave_model	Build a two-port model from the stored Palace frequency sweeps.
meander_inductor_ground_capacitance	Look up the capacitance of an equipotential winding to its ground frame.
meander_inductor_inductance_analytical	Analytical formula for meander inductor inductance.
nanowire_pad_capacitances_analytical	Pad-to-ground and pad-to-feedline capacitance of the nanowire resonator.
resonator_frequency	Calculate the resonance frequency of a quarter- or half-wave CPW resonator.
thin_strip_magnetic_field	Magnetic field of an infinite thin strip carrying a uniform current.

cpw_cpw_coupling_capacitance

qpdk.models.cpw_cpw_coupling_capacitance(f, length, gap, cross_section)

Look up Palace coupling capacitance between two parallel CPWs.

The uniform sheet dataset supplies mutual capacitance per length. Values outside its width, outer-slot and inter-trace-gap domain return NaN. Its inner ground strip has width max(gap - 2 * cpw_gap, 0), matching the etch masks of coupler_straight. Dielectric half-space scaling accounts for cross-section permittivity; kinetic inductance, thickness and fringing are omitted.

Parameters:

• f (FloatArrayLike) – Frequency array in Hz.

• length (ArrayLike) – The coupling length in µm.

• gap (ArrayLike) – The gap between the two center conductors in µm.

• cross_section (CrossSectionSpec) – The cross-section of the CPW.

Returns:

The total coupling capacitance in Farads.

Return type:

float | Array

Note

Raises ValueError via get_cpw_dimensions() if the cross-section has no section with ‘etch’ in its name, so the CPW gap cannot be determined, or if the conductor width or etch gap is not positive.

esr_lc_resonator_parameters

qpdk.models.esr_lc_resonator_parameters(wire_width=5.0, wire_length=730.0, fingers=12, finger_length=800.0, finger_gap=50.0, finger_thickness=50.0, film_thickness=0.05, sheet_inductance=4e-13, coupling_capacitance=8.5e-15, ground_capacitance=1e-13, cross_section='cpw')

Circuit parameters of qpdk.cells.esr_lc_resonator().

The resonator floats: the wire \(L\) bridges the two electrodes of the interdigital capacitor \(C\), as in [RPA+20]. Each electrode has a capacitance \(C_\text{g}\) to the ground plane, and the electrode next to the feedline couples to it through \(C_\text{c}\):

The differential mode across \(L\) sees \(C\) in parallel with the series combination of the two \(C_\text{g}\) branches, one of them loaded by \(C_\text{c}\):

\[\begin{split}L &= L_\text{geo} + L_\square N_\square \\ C_\text{eff} &= C + \frac{C_\text{g} (C_\text{g} + C_\text{c})} {2 C_\text{g} + C_\text{c}} \\ \omega_\text{r} &= \frac{1}{\sqrt{L C_\text{eff}}} \\ \alpha &= \frac{C_\text{g}}{2 C_\text{g} + C_\text{c}} \\ Q_\text{c} &= \frac{2 C_\text{eff}} {\omega_\text{r} C_\text{c}^2 Z_0 \alpha^2}\end{split}\]

\(L_\text{geo}\) is the self-inductance of the wire as a rectangular strip from self_inductance_strip(), \(N_\square = \ell/w\) its square count, and \(C\) the interdigital capacitance from interdigital_capacitor_capacitance_analytical(). \(\alpha\) is the fraction of the resonator voltage that appears on electrode A, so only \(\alpha V\) drives the coupling capacitor and \(Q_\text{c}\) grows as \(1/\alpha^2\). With \(C_\text{g} = 0\) the resonator has no return path and decouples from the feedline. \(Q_\text{c}\) follows from the feedline loading electrode A with \(Z_0/2\) through \(C_\text{c}\), valid for \(\omega_\text{r} C_\text{c} Z_0 \ll 1\).

For the wire of [BPK+16] (5 µm × 730 µm, 50 nm film) \(L_\text{geo} = 0.90\) nH, against the \(Z_0/\omega_0 = 0.97\) nH that the paper’s 44 Ω and 7.26 GHz imply. The defaults give \(f_\text{r} \approx 6.9\) GHz and \(Q_\text{c} \approx 3 \times 10^4\).

Assumptions:

• The resonator is linear and lossless: no kinetic-inductance nonlinearity, and the internal quality factor is infinite.

• \(L\) counts the wire only. The leads joining it to the bus bars and the stray inductance of the electrodes are neglected. For the bowtie capacitor of [RPA+20], \(Z_\text{c} \approx 15\) Ω at 7.25 GHz implies \(L \approx 0.33\) nH, far above the ~11 pH geometric inductance of its 10 µm wire, so this model underestimates \(L\) for such short wires.

• The resonator is coupled to an on-chip feedline. Both references instead place it in a 3D cavity driven by antennas.

• The feedline and the circuit are referenced to \(Z_0 = 50\) Ω, the reference impedance of the generic models used in esr_lc_resonator(); the default cpw cross-section is 49.3 Ω.

• \(C_\text{c}\) and \(C_\text{g}\) are parameters, not derived from coupling_gap and ground_gap, and both electrodes share one \(C_\text{g}\). The 100 fF default for \(C_\text{g}\) is an order-of-magnitude coplanar estimate for ~2 mm of electrode edge 50 µm from the ground plane. The 8.5 fF default for \(C_\text{c}\) is chosen to give \(Q_\text{c} \approx 3 \times 10^4\), the external quality factor of [RPA+20]; it does not describe the default cell, whose 1.15 mm bus bar 50 µm from the feedline is of order 0.1 pF. Set both from a capacitance extraction of the layout.

• The 0.4 pH/□ sheet inductance is the PDK default for the base metal; the references do not state one for their 50 nm Al films.

Parameters:

• wire_width (float) – Wire width in µm.

• wire_length (float) – Wire length in µm.

• fingers (int) – Number of 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 in µm.

• film_thickness (float) – Film thickness in µm, used for \(L_\text{geo}\).

• sheet_inductance (float) – Kinetic sheet inductance \(L_\square\) in H/□.

• coupling_capacitance (float) – Coupling capacitance \(C_\text{c}\) in F.

• ground_capacitance (float) – Capacitance \(C_\text{g}\) of each electrode to ground in F.

• cross_section (CrossSectionSpec) – Feedline cross-section, used for the substrate permittivity.

Returns:

Dictionary with wire_squares, geometric_inductance, kinetic_inductance, inductance (H), capacitance (F), coupling_capacitance (F), ground_capacitance (F), effective_capacitance (F), z0 (Ω), resonance_frequency (Hz) and coupling_quality_factor.

Return type:

dict[str, Array | float]

esr_mode_volume

qpdk.models.esr_mode_volume(wire_width, inductance)

Magnetic mode volume of an LC resonator with a thin-strip inductor.

The magnetic mode volume is the field energy over the energy density at the spins, \(V_\text{m} = \int |\mathbf{B}|^2\,\mathrm{d}V / |\delta B_1|^2\). The field energy of a current \(\delta i\) in the inductance \(L\) is \(\int |\mathbf{B}|^2\,\mathrm{d}V = \mu_0 L\,\delta i^2\). Taking \(\delta B_1\) at the wire surface from thin_strip_magnetic_field(), \(\delta B_1 = \mu_0 \delta i/(2w)\), gives

\[V_\text{m} = \frac{\mu_0 L\,\delta i^2}{\delta B_1^2} = \frac{4 w^2 L}{\mu_0},\]

independent of \(\delta i\). With the single-photon current \(\delta i = \omega_0\sqrt{\hbar/2Z_\text{c}}\) of [RPA+20] this is the volume in \(\delta B_1 = \sqrt{\mu_0 \hbar \omega_0 / 2 V_\text{m}}\).

Neither design reference states a closed-form mode volume; both quote volumes from EM field simulations [BPK+16, RPA+20]. With their own \(L = Z_\text{c}/\omega_0\) this estimate gives 0.077 nL against “~0.02 nl” and 10.5 fL against “~6 fL”: the same order of magnitude, not a reproduction. The derivation counts \(L\) as magnetic-field energy, so pass the geometric inductance: kinetic inductance stores energy in the electrons, not the field. The comparison with the papers’ \(Z_\text{c}/\omega_0\) therefore overstates the volume where kinetic inductance contributes, and for Ranjan’s 10 µm wire most of that \(L\) is stray inductance of the capacitor rather than of the wire. The uniform-current approximation of thin_strip_magnetic_field() applies.

Parameters:

• wire_width (ArrayLike) – Wire width \(w\) in µm.

• inductance (ArrayLike) – Inductance \(L\) in H whose field energy is counted.

Returns:

Mode volume in µm³ (1 µm³ = 1 fL).

Return type:

Array

grounded_pad_capacitance_analytical

qpdk.models.grounded_pad_capacitance_analytical(pad_width, pad_height, gap, ep_r)

Capacitance between a coplanar pad and a ground plane edge.

The pad is a strip of width \(W\) (pad_height) and length \(\ell\) (pad_width) at distance \(s\) from the straight edge of a semi-infinite ground plane in the same plane.

The 2D capacitance of two coplanar electrodes on a line depends only on the cross ratio of their four edge positions, because a Möbius map of the half plane preserves both the cross ratio and the capacitance. For edges at \(-\infty, 0, s, s + W\) the cross ratio is \(\lambda = W/(W + s)\), and two symmetric pads with edges at \(\pm 1, \pm 1/k\) have \(\lambda = \bigl((1 - k)/(1 + k)\bigr)^2\). So the grounded pad has the capacitance of symmetric coplanar pads with modulus

\[k = \frac{1 - \sqrt{\lambda}}{1 + \sqrt{\lambda}},\]

which plate_capacitor_capacitance_analytical() evaluates [CSD+23]. Fringe fields at the two ends of the pad are neglected.

The cross-ratio mapping above is derived here from conformal invariance, not quoted from a reference; tests/models/test_nanowire.py checks it against the symmetric-pad formula.

Parameters:

• pad_width (ArrayLike) – Pad length \(\ell\) along the ground edge in µm.

• pad_height (ArrayLike) – Pad width \(W\) across the gap in µm.

• gap (ArrayLike) – Gap \(s\) between the pad and the ground edge in µm.

• ep_r (ArrayLike) – Relative permittivity of the substrate.

Returns:

Capacitance in F.

Return type:

Array

meander_inductor_fullwave_model

qpdk.models.meander_inductor_fullwave_model(n_turns=5)

Build a two-port model from the stored Palace frequency sweeps.

Select 3, 5 or 7 turns when creating the model. The returned JAX model accepts f in Hz from 0.5 to 20 GHz, turn_length from 100 to 300 um, wire_width from 1 to 2 um and wire_gap from 2 to 8 um. Omitted geometry arguments use the middle grid coordinates. Values outside the stored ranges return NaN.

The o1 and o2 reference planes are the winding ends, normalized to 50 ohms. A finite ground frame is 100 um wide and 20 um from the winding. Both winding and frame have a fixed sheet inductance of 0.4 pH per square. The silicon coupon omits material loss and allows radiation through its outer boundary.

Parameters:

n_turns (int) – Number of horizontal runs, selected before JIT compilation.

Returns:

Jittable SAX model interpolating the complex scattering matrix.

Return type:

Model

meander_inductor_ground_capacitance

qpdk.models.meander_inductor_ground_capacitance(*, turn_length=200.0, wire_width=2.0, wire_gap=4.0, n_turns=3)

Look up the capacitance of an equipotential winding to its ground frame.

Dimensions are in micrometres. The Palace coupon uses a silicon substrate and a 100 um wide coplanar frame, 20 um from the winding bounding box. Both winding ends share one potential. This common-mode capacitance does not describe a voltage varying along the winding, its inductance or its self-resonance. Use the analytical inductance model separately.

Parameters:

• turn_length (float) – Horizontal run length, between 100 and 300 um.

• wire_width (float) – Winding width, between 1 and 2 um.

• wire_gap (float) – Gap between runs, between 2 and 8 um.

• n_turns (int) – Discrete variant: 3, 5 or 7; static when using JIT.

Returns:

Common-mode winding-to-ground capacitance in F. Dimensions outside the stored grid return NaN.

Return type:

Array

meander_inductor_inductance_analytical

qpdk.models.meander_inductor_inductance_analytical(n_turns, turn_length, wire_width, wire_gap, sheet_inductance, thickness=None)

Analytical formula for meander inductor inductance.

The total inductance is the sum of geometric and kinetic contributions:

\[L_{\text{total}} = L_\text{g} + L_\text{k}\]

The geometric inductance \(L_\text{g}\) is calculated by summing the self-inductances of all horizontal segments and the mutual inductances between all pairs of parallel segments, following [CSD+23]:

\[L_\text{g} = N L_\text{s} + 2 \sum_{k=1}^{N-1} (N-k) (-1)^k L_\text{m}(k p)\]

where \(N\) is the number of turns and \(p\) is the pitch.

The kinetic inductance \(L_\text{k}\) is calculated from the sheet inductance \(L_\square\):

\[L_\text{k} = L_\square \cdot \frac{\ell_{\text{total}}}{w}\]

Parameters:

• n_turns (int) – Number of horizontal meander runs.

• turn_length (float) – Length of each horizontal run in µm.

• wire_width (float) – Width of the meander wire in µm.

• wire_gap (float) – Gap between adjacent meander runs in µm.

• sheet_inductance (float) – Sheet inductance per square in H/□.

• thickness (float | None) – Thickness of the metal film in µm. If None, it is fetched from the PDK technology parameters.

Returns:

Total inductance in Henries.

Return type:

Array

nanowire_pad_capacitances_analytical

qpdk.models.nanowire_pad_capacitances_analytical(pad_width, pad_height, pad_separation, pad_ground_gap, coupling_gap, centre_width, centre_gap, ep_r)

Pad-to-ground and pad-to-feedline capacitance of the nanowire resonator.

All conductors are zero-thickness sheets on the substrate surface, so each 2D cross-section is a set of electrodes on a line and its capacitances follow from conformal mapping with \(\varepsilon_\text{eff} = (\varepsilon_\text{r} + 1)/2\). Two such cross-sections are superposed:

• Across the feedline, along the pad width \(\ell\), the line holds the ground pad (a half line, at pad_separation \(d\) from the pad), the pad of height \(h\), the feedline centre conductor of width \(w\) at coupling_gap \(g\), and the feedline ground at centre_gap \(s\). With \(C_{X}\) the capacitance between electrode \(X\) and the other two shorted together, the mutual capacitance of pad and centre conductor is

  \[C_\text{c} = \frac{\ell}{2} \bigl(C_\text{pad} + C_\text{centre} - C_\text{ground}\bigr),\]

  an approximation to the three-electrode mutual capacitance, within the method-of-moments band given below. Each \(C_X\) is a two-electrode capacitance with the modulus of grounded_pad_capacitance_analytical().

• The pad-to-ground capacitance is the pad against the ground pad alone, from grounded_pad_capacitance_analytical() with gap \(d\), plus the pad against the side grounds at pad_ground_gap over its height \(h\), as a CPW centre conductor of width \(\ell\).

Superposing the two directions neglects the pad corners and ends. Checked against a method-of-moments extraction of the drawn 3D geometry (pad, ground pad, side grounds and a 10/6 µm feedline on silicon) at five geometries with \(\ell\) = 200–300 µm, \(h\) = 80–150 µm, \(d\) = 40–60 µm, \(g\) = 4–10 µm and pad_ground_gap = 20–50 µm, \(C_\text{c}\) agrees within −10 % to +2 %, low for larger \(g\) because end fringing to the centre conductor is neglected, and the pad-to-ground capacitance within +3 % to +7 %. The reference values are in tests/models/test_nanowire.py.

Parameters:

• pad_width (ArrayLike) – Pad size \(\ell\) along the feedline in µm.

• pad_height (ArrayLike) – Pad size \(h\) across the feedline in µm.

• pad_separation (ArrayLike) – Gap \(d\) between the pad and the ground pad in µm.

• pad_ground_gap (ArrayLike) – Gap between the pad and the side grounds in µm.

• coupling_gap (ArrayLike) – Gap \(g\) between the pad and the centre conductor in µm.

• centre_width (ArrayLike) – Feedline centre conductor width \(w\) in µm.

• centre_gap (ArrayLike) – Feedline gap \(s\) in µm.

• ep_r (ArrayLike) – Relative permittivity of the substrate.

Returns:

Tuple of the pad-to-ground capacitance and the coupling capacitance \(C_\text{c}\), both in F.

Return type:

tuple[Array, Array]

resonator_frequency

qpdk.models.resonator_frequency(*, length, epsilon_eff=None, media=None, cross_section='cpw', is_quarter_wave=True)

Calculate the resonance frequency of a quarter- or half-wave CPW resonator.

\[\begin{split}\begin{aligned} f &= \frac{v_\text{p}}{4L} \text{(quarter-wave resonator)} \\ f &= \frac{v_\text{p}}{2L} \text{(half-wave resonator)} \end{aligned}\end{split}\]

The phase velocity is \(v_\text{p} = c_0 / \sqrt{\varepsilon_{\text{eff}}}\).

See [MP12, Sim01] for details.

Parameters:

• length (float) – Length of the resonator in μm.

• epsilon_eff (float | None) – Effective permittivity. If None (default), computed from cross_section using cpw_parameters().

• media (Any) – Deprecated. Use epsilon_eff or cross_section instead.

• cross_section (CrossSectionSpec) – Cross-section specification (used only when epsilon_eff and media are not provided).

• is_quarter_wave (bool) – If True, calculates for a quarter-wave resonator; if False, for a half-wave resonator. default is True.

Returns:

Resonance frequency in Hz.

Return type:

float

thin_strip_magnetic_field

qpdk.models.thin_strip_magnetic_field(current, width, height, x=0.0)

Magnetic field of an infinite thin strip carrying a uniform current.

The strip lies in the plane \(y = 0\) between \(x = \pm w/2\) and carries the current \(I\) along \(+z\), spread uniformly over its width. Integrating the field of a line current, \(\mu_0 I/(2\pi r)\), across the strip with the Biot–Savart law [Gri17] gives, for \(y > 0\),

\[\begin{split}B_x &= -\frac{\mu_0 I}{2\pi w}\left[ \arctan\frac{x + w/2}{y} - \arctan\frac{x - w/2}{y}\right] \\ B_y &= \frac{\mu_0 I}{4\pi w} \ln\frac{(x + w/2)^2 + y^2}{(x - w/2)^2 + y^2}\end{split}\]

Above the centre of the strip, \(B_x = -\mu_0 I \arctan(w/2y)/(\pi w)\), which tends to \(-\mu_0 I/(2w)\) at the surface and to the line-current field far away. By mirror symmetry the field at depth \(y\) below the strip, where the spins of an ESR sample sit, has \(B_x\) reversed and \(B_y\) unchanged.

Uniform-current approximation: a superconducting strip carries most of its current near the edges [BPK+16], so close to the strip the real field is larger near the edges and smaller above the centre than this formula gives. The strip thickness is neglected.

Parameters:

• current (ArrayLike) – Current \(I\) in A.

• width (ArrayLike) – Strip width \(w\) in µm.

• height (ArrayLike) – Position \(y\) relative to the strip plane in µm, nonzero. Negative values are below the strip.

• x (ArrayLike) – Lateral position measured from the strip centre in µm.

Returns:

Tuple (B_x, B_y) in T.

Return type:

tuple[Array, Array]

Other

drum_capacitance_reduction	Reduce a drum resonator Maxwell matrix to \((C_\text{c}, C_\text{p}, C_\text{d})\).
drum_capacitances	Return the extracted capacitances of a drum_lc_resonator() layout, in F.
drum_effective_mass	Effective mass of the fundamental drum mode.
drum_electromechanical_coupling	Electromechanical coupling of a drum-capacitor LC resonator.
drum_lc_resonator_fem_model	Build drum_lc_resonator() with capacitances from the Palace dataset.
drum_single_photon_coupling	Single-photon electromechanical coupling rate of a drum resonator.
drum_zero_point_motion	Zero-point motion of a mechanical mode.
hyperbolic_vertex_coupler_capacitances	Pin-to-pin and pin-to-ground capacitance of a q-pin vertex coupler.
vacuum_gap_capacitance_analytical	Capacitance of a circular vacuum-gap parallel-plate capacitor.

drum_capacitance_reduction

qpdk.models.drum_capacitance_reduction(maxwell, weights)

Reduce a drum resonator Maxwell matrix to \((C_\text{c}, C_\text{p}, C_\text{d})\).

The terminals are node, membrane, feed and the meander blocks, in that order. weights are their voltages relative to the node at the lumped resonance: 1 for the node, 0 for the grounded membrane and the feedline, and the mean position along the wire for each meander block. With \(v\) the weights and \(C\) the matrix, the charge on the feed and on the membrane gives

\[C_\text{c} = -\sum_j C_{\text{feed},j} v_j, \qquad C_\text{d} = -\sum_j C_{\text{membrane},j} v_j,\]

and the rest of the stored energy, \(v^\mathsf{T} C v - C_\text{c} - C_\text{d}\), is the parasitic \(C_\text{p}\) to ground, including the meander’s own capacitance. The three add up to the total energy, so a meander block at weight \(v\) coupled to the feed adds \(v\) to \(C_\text{c}\) and \(v^2 - v\) to \(C_\text{p}\).

Parameters:

• maxwell (ArrayLike) – Maxwell capacitance matrices in F, shape (..., T, T).

• weights (ArrayLike) – Terminal voltages relative to the node, shape (T,).

Returns:

(C_c, C_p, C_d) in F with the leading shape of maxwell.

Return type:

tuple[Array, Array, Array]

drum_capacitances

qpdk.models.drum_capacitances(*, coupling_gap=6.0, coupling_pad_size=20.0, radius=7.5, turn_length=300.0, dataset='drum_lc_resonator_palace')

Return the extracted capacitances of a drum_lc_resonator() layout, in F.

Dimensions are in µm and match the cell arguments; the dataset fixes the other cell arguments at their defaults, including 75 meander runs. The defaults are the default cell. See drum_capacitance_reduction() for how the Palace Maxwell matrix becomes

• \(C_\text{c}\), the coupling to the feedline,

• \(C_\text{p}\), the parasitic capacitance to ground of the pad, wiring and meander, weighted by the meander’s linear voltage profile,

• \(C_\text{d}\), the drum capacitance at the stack’s vacuum gap, including fringing and the electrode lead under the membrane.

At the default point the meander blocks give 3.3 fF of the 5.1 fF coupling and the pad 1.8 fF, so the assumed voltage profile matters as much as the pad. A larger coupling_pad_size also moves the meander farther from the feedline, so \(C_\text{c}\) is not monotonic in the pad size: 10 µm, 20 µm and 40 µm give 6.17 fF, 5.05 fF and 5.10 fF at the other defaults.

The bundled dataset drum_lc_resonator_palace holds the 54 solved geometries; without it every value is NaN and a warning is issued once. Dimensions outside the stored grid also return NaN. Supports JIT, vmap and grad.

Parameters:

• coupling_gap (ArrayLike) – Gap between the coupling pad and the feedline in µm.

• coupling_pad_size (ArrayLike) – Side of the square coupling pad in µm.

• radius (ArrayLike) – Drum bottom-electrode radius in µm.

• turn_length (ArrayLike) – Length of each meander run in µm.

• dataset (Dataset | Path | str) – Dataset or path with terminals node, membrane, feed and meander_* and terminal_weights provenance.

Returns:

(C_c, C_p, C_d) in F, each with the broadcast input shape.

Return type:

tuple[Array, Array, Array]

drum_effective_mass

qpdk.models.drum_effective_mass(radius, thickness=0.12, density=2700.0, mass_factor=1.0)

Effective mass of the fundamental drum mode.

\[m_\text{eff} = \mu\,\rho \pi a^2 t\]

With the default \(\mu = 1\) the effective mass is the full disc mass. This choice is the uniform-plate (piston) picture behind \(G = -\omega_\text{c}/(2d)\) in [TLA+11]. For its 15 µm diameter, 100 nm thick Al drum the disc mass is 47.7 pg, close to the quoted \(m \approx 50\,\text{pg}\), and it gives \(x_\text{zp} = 4.06\,\text{fm}\) at 10.69 MHz, matching the quoted 4.1 fm.

For the default 120 nm drum of [PDamskaggB+15] the disc mass is 57.3 pg and \(x_\text{zp} = 3.4\,\text{fm}\) at 13.03 MHz, against the quoted \(x_\text{zp} \sim 5\,\text{fm}\). That paper does not state its effective-mass convention, so it does not fix \(\mu\).

A clamped-membrane mode shape changes both \(m_\text{eff}\) and \(\partial C/\partial x\). That correction is not part of the cited model; mass_factor only scales the mass. Referred to the centre displacement, the fundamental \(J_0(j_{0,1} r/a)\) mode of a clamped circular membrane has \(\mu = J_1(j_{0,1})^2 \approx 0.27\), which gives 6.5 fm for the default drum. Use it only together with a mode-weighted \(\partial C/\partial x\), see drum_electromechanical_coupling().

Parameters:

• radius (ArrayLike) – Drum radius \(a\) in µm.

• thickness (ArrayLike) – Membrane thickness \(t\) in µm.

• density (ArrayLike) – Membrane mass density \(\rho\) in kg/m³.

• mass_factor (ArrayLike) – Dimensionless effective-mass factor \(\mu\).

Returns:

The effective mass in kg.

Return type:

Array

drum_electromechanical_coupling

qpdk.models.drum_electromechanical_coupling(resonance_frequency, gap=0.07, participation=1.0)

Electromechanical coupling of a drum-capacitor LC resonator.

For a parallel-plate capacitor \(C = \varepsilon_0 A/(d - x)\), where \(x\) is the membrane displacement toward the bottom electrode, and \(\omega_\text{c} = 1/\sqrt{LC}\), [TLA+11] gives for \(x \ll d\)

\[G = \frac{\mathrm{d}\omega_\text{c}}{\mathrm{d}x} = -\eta \frac{\omega_\text{c}}{2d}\]

where \(\eta\) is the fraction of the total resonator capacitance that the drum provides.

This expression treats the whole membrane as a rigid plate. With the clamped edge, only the centre moves fully, so the parallel-plate \(\partial C/\partial x\) overestimates \(g_0\) by about a factor of two [CZK+20]. For the default drum the parallel-plate \(\varepsilon_0 \pi a^2/d^2\) is 319 nF/m, against the \(\partial C_\text{g}/\partial x \sim 120\,\text{nF/m}\) quoted by [PDamskaggB+15]. Scale participation if a mode-weighted value is known.

The default \(\eta = 1\) is the limit in which the drum provides all of the resonator capacitance, as for Teufel et al. For the default drum_lc_resonator() the drum gives 22.9 fF of 39.9 fF, so \(\eta \approx 0.57\); pass it explicitly.

Parameters:

• resonance_frequency (ArrayLike) – Resonance frequency \(\omega_\text{c}/2\pi\) in Hz.

• gap (ArrayLike) – Vacuum gap \(d\) in µm.

• participation (ArrayLike) – Capacitance participation ratio \(\eta\).

Returns:

\(G\) in rad·s⁻¹·m⁻¹. Divide by \(2\pi\) for Hz/m.

Return type:

Array

drum_lc_resonator_fem_model

qpdk.models.drum_lc_resonator_fem_model(*, dataset='drum_lc_resonator_palace')

Build drum_lc_resonator() with capacitances from the Palace dataset.

\(C_\text{c}\) and \(C_\text{p}\) come from drum_capacitances() at the layout dimensions. The extracted drum capacitance replaces the analytical one at the stack gap, so the model’s parasitic_capacitance is \(C_\text{p} + C_\text{d}^\text{FEM} - C_\text{d}^\text{analytical}(d_0)\). A different gap still moves only the analytical parallel-plate term, so membrane motion is modelled as in drum_lc_resonator() around the extracted total.

The returned model takes f in Hz, the four layout dimensions of drum_capacitances() in µm, gap in µm and sheet_inductance in H/□. The meander has the dataset’s 75 runs. It returns NaN until the dataset exists, and outside the dataset’s grid. The lumped-model limits of drum_lc_resonator() still apply: the default meander is electrically long at its resonance.

Parameters:

dataset (Dataset | Path | str) – Dataset or path accepted by drum_capacitances().

Returns:

Jittable two-port SAX model with ports o1 and o2.

Return type:

SDictModel

drum_single_photon_coupling

qpdk.models.drum_single_photon_coupling(resonance_frequency, effective_mass, gap=0.07, participation=1.0, mechanical_frequency=13032000.0)

Single-photon electromechanical coupling rate of a drum resonator.

\[g_0 = |G|\,x_\text{zp}\]

with \(G\) from drum_electromechanical_coupling() and \(x_\text{zp}\) from drum_zero_point_motion() [TLA+11].

Parameters:

• resonance_frequency (ArrayLike) – Resonance frequency \(\omega_\text{c}/2\pi\) in Hz.

• effective_mass (ArrayLike) – Effective mass \(m_\text{eff}\) in kg.

• gap (ArrayLike) – Vacuum gap \(d\) in µm.

• participation (ArrayLike) – Capacitance participation ratio \(\eta\).

• mechanical_frequency (ArrayLike) – Mechanical frequency \(\Omega_\text{m}/2\pi\) in Hz.

Returns:

\(g_0\) in rad/s. Divide by \(2\pi\) for Hz.

Return type:

Array

drum_zero_point_motion

qpdk.models.drum_zero_point_motion(effective_mass, mechanical_frequency=13032000.0)

Zero-point motion of a mechanical mode.

\[x_\text{zp} = \sqrt{\frac{\hbar}{2 m_\text{eff} \Omega_\text{m}}}\]

as used in [TLA+11].

Parameters:

• effective_mass (ArrayLike) – Effective mass \(m_\text{eff}\) in kg.

• mechanical_frequency (ArrayLike) – Mechanical frequency \(\Omega_\text{m}/2\pi\) in Hz.

Returns:

The zero-point motion in m.

Return type:

Array

hyperbolic_vertex_coupler_capacitances

qpdk.models.hyperbolic_vertex_coupler_capacitances(q=3, pin_radius=40.0, pin_gap=4.0, ground_gap=6.0, cross_section='cpw')

Pin-to-pin and pin-to-ground capacitance of a q-pin vertex coupler.

The coupler is a metal disk of radius pin_radius cut into q sectors by radial gaps of width pin_gap and surrounded by a ground clearance of width ground_gap (see qpdk.cells.hyperbolic.hyperbolic_vertex_coupler()). Each gap is treated as a pair of coplanar pads of length pin_radius and width pin_radius / 2 with plate_capacitor_capacitance_analytical(), and each sector’s arc as a pad of the same width facing the ground plane. Only neighbouring sectors are coupled; for \(q > 3\) the weaker coupling across the disk is neglected, so the hopping between edges is not uniform and the line-graph picture holds only approximately.

Returns:

coupling between neighbouring pins and capacitance of each pin to ground.

Return type:

(C_c, C_g) in farads

Parameters:

• q (int)

• pin_radius (float)

• pin_gap (float)

• ground_gap (float)

• cross_section (CrossSectionSpec)

vacuum_gap_capacitance_analytical

qpdk.models.vacuum_gap_capacitance_analytical(radius, gap, fringing=1.0)

Capacitance of a circular vacuum-gap parallel-plate capacitor.

The parallel-plate term follows [CLS+10, TLA+11]. The fringing correction is Kirchhoff’s asymptotic result for two coaxial circular plates of radius \(a\) at separation \(d \ll a\), as given in [NJ09]:

\[C = \frac{\varepsilon_0 \pi a^2}{d} + f\,\varepsilon_0 a \left[\ln\!\left(\frac{16 \pi a}{d}\right) - 1\right]\]

where \(f\) switches the fringing term on (1) or off (0).

Assumptions: zero-thickness plates of equal radius in vacuum, no ground plane nearby. For a 15 µm diameter drum with a 70 nm gap the fringing term adds 2.2 %. The vacuum_gap_capacitor() cell draws a membrane larger than the bottom electrode, with a grounded ring a few µm away, so this term is only an estimate of the fringing there.

Parameters:

• radius (ArrayLike) – Radius \(a\) of the overlapping plates in µm.

• gap (ArrayLike) – Vacuum gap \(d\) in µm.

• fringing (ArrayLike) – Weight \(f\) of the fringing term, 1 to include it and 0 for the bare parallel-plate value.

Returns:

The capacitance in F.

Return type:

Array

References

[BPK+16] (1,2,3,4)

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.

[BGGW21] (1,2,3)

Alexandre Blais, Arne L. Grimsmo, S. M. Girvin, and Andreas Wallraff. Circuit quantum electrodynamics. Reviews of Modern Physics, 93(2):025005, May 2021. doi:10.1103/RevModPhys.93.025005.

[CZK+20]

D. Cattiaux, X. Zhou, S. Kumar, I. Golokolenov, R. R. Gazizulin, A. Luck, L. Mercier de Lépinay, M. Sillanpää, A. D. Armour, A. Fefferman, and E. Collin. Beyond linear coupling in microwave optomechanics. Physical Review Research, 2(3):033480, September 2020. doi:10.1103/PhysRevResearch.2.033480.

[CSD+23] (1,2,3)

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.

[CMK+14]

Zijun Chen, A. Megrant, J. Kelly, R. Barends, J. Bochmann, Yu Chen, B. Chiaro, A. Dunsworth, E. Jeffrey, J. Y. Mutus, P. J. J. O'Malley, C. Neill, P. Roushan, D. Sank, A. Vainsencher, J. Wenner, T. C. White, A. N. Cleland, and John M. Martinis. Fabrication and characterization of aluminum airbridges for superconducting microwave circuits. Applied Physics Letters, February 2014. doi:10.1063/1.4863745.

[CLS+10] (1,2)

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.

[DorflerB13]

Florian Dörfler and Francesco Bullo. Kron reduction of graphs with applications to electrical networks. IEEE Transactions on Circuits and Systems I: Regular Papers, 60(1):150–163, 2013. arXiv:1102.2950, doi:10.1109/TCSI.2012.2215780.

[GBS+06]

J. Gambetta, A. Blais, D. I. Schuster, A. Wallraff, L. Frunzio, J. Majer, M. H. Devoret, S. M. Girvin, and R. J. Schoelkopf. Qubit-photon interactions in a cavity: measurement-induced dephasing and number splitting. Physical Review A, 74(4):042318, October 2006. doi:10.1103/PhysRevA.74.042318.

[Gao08]

Jiansong Gao. The Physics of Superconducting Microwave Resonators. PhD thesis, California Institute of Technology, 2008. doi:10.7907/RAT0-VM75.

[Gri17]

David J. Griffiths. Introduction to Electrodynamics. Cambridge University Press, 4 edition, 2017. ISBN 978-1-108-42041-9. doi:10.1017/9781108333511.

[GYurttagulK+22] (1,2)

K. Grigoras, N. Yurttagül, J.-P. Kaikkonen, E. T. Mannila, P. Eskelinen, D. P. Lozano, H.-X. Li, M. Rommel, D. Shiri, N. Tiencken, S. Simbierowicz, A. Ronzani, J. Hätinen, D. Datta, V. Vesterinen, L. Grönberg, J. Biznárová, A. Fadavi Roudsari, S. Kosen, A. Osman, M. Prunnila, J. Hassel, J. Bylander, and J. Govenius. Qubit-compatible substrates with superconducting through-silicon vias. IEEE Transactions on Quantum Engineering, 3:5100310, 2022. doi:10.1109/TQE.2022.3209881.

[GGBB96] (1,2,3,4)

Kuldip C. Gupta, R. Garg, I. Bahl, and P. Bhartia. Microstrip Lines and Slotlines. Artech House, Boston, 2. ed edition, 1996. ISBN 978-0-89006-766-6.

[GFB+08]

M. Göppl, A. Fragner, M. Baur, R. Bianchetti, S. Filipp, J. M. Fink, P. J. Leek, G. Puebla, L. Steffen, and A. Wallraff. Coplanar waveguide resonators for circuit quantum electrodynamics. Journal of Applied Physics, 104(11):113904, December 2008. doi:10.1063/1.3010859.

[HJ80]

E. Hammerstad and O. Jensen. Accurate Models for Microstrip Computer-Aided Design. In 1980 IEEE MTT-S International Microwave Symposium Digest, 407–409. Washington, DC, USA, 1980. IEEE. doi:10.1109/MWSYM.1980.1124303.

[HWR+23]

Thomas M. Hazard, Wayne Woods, Danna Rosenberg, Rabi Das, Cyrus F. Hirjibehedin, David K. Kim, Jeffery Knecht, Justin Mallek, Alexander Melville, Bethany M. Niedzielski, Kyle Serniak, Katrina M. Sliwa, Donna-Ruth W. Yost, Jonilyn L. Yoder, William D. Oliver, and Mollie E. Schwartz. Characterization of superconducting through-silicon vias as capacitive elements in quantum circuits. Applied Physics Letters, 123(15):154004, 2023. doi:10.1063/5.0170055.

[HSJ+08]

A. A. Houck, J. A. Schreier, B. R. Johnson, J. M. Chow, Jens Koch, J. M. Gambetta, D. I. Schuster, L. Frunzio, M. H. Devoret, S. M. Girvin, and R. J. Schoelkopf. Controlling the spontaneous emission of a superconducting transmon qubit. Physical Review Letters, 101(8):080502, August 2008. doi:10.1103/PhysRevLett.101.080502.

[HKC+22]

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.

[JCL+22]

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.

[KVH+11]

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.

[KYG+07] (1,2,3,4,5)

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.

[KKY+19]

P. Krantz, M. Kjaergaard, F. Yan, T. P. Orlando, S. Gustavsson, and W. D. Oliver. A quantum engineer's guide to superconducting qubits. Applied Physics Reviews, 6(2):021318, June 2019. doi:10.1063/1.5089550.

[KCH+18] (1,2)

A. Kringhøj, L. Casparis, M. Hell, T. W. Larsen, F. Kuemmeth, M. Leijnse, K. Flensberg, P. Krogstrup, J. Nygård, K. D. Petersson, and C. M. Marcus. Anharmonicity of a superconducting qubit with a few-mode Josephson junction. Physical Review B, 97(6):060508, February 2018. doi:10.1103/PhysRevB.97.060508.

[LKG+20]

Chan U Lei, Lev Krayzman, Suhas Ganjam, Luigi Frunzio, and Robert J. Schoelkopf. High coherence superconducting microwave cavities with indium bump bonding. Applied Physics Letters, 116(15):154002, 2020. doi:10.1063/5.0003907.

[MP12] (1,2,3,4,5,6,7,8,9)

David M. Pozar. Microwave Engineering. John Wiley & Sons, Inc., 4 edition, 2012. ISBN 978-0-470-63155-3.

[MGK+18]

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.

[MYR+21] (1,2)

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.

[MKGD09]

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.

[MPK+12] (1,2)

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.

[McC68]

D. E. McCumber. Effect of ac impedance on dc voltage-current characteristics of superconductor weak-link junctions. Journal of Applied Physics, 39(7):3113–3118, June 1968. doi:10.1063/1.1656743.

[MdLepinayDamskaggOKSillanpaa19]

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.

[NLS+19]

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.

[NJ09]

Martin Karl Norgren and B. Lars G. Jonsson. The capacitance of the circular parallel plate capacitor obtained by solving the Love integral equation using an analytic expansion of the kernel. Progress In Electromagnetics Research, 97:357–372, 2009. doi:10.2528/PIER09092503.

[NP14]

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.

[OKDamskaggP+16]

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.

[PDamskaggB+15] (1,2,3,4,5,6)

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.

[PFZ+17]

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.

[RPA+20] (1,2,3,4,5,6)

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.

[RBF+26]

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.

[RAP+25]

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.

[Sav23]

Niko Savola. Design and modelling of long-coherence qubits using energy participation ratios. Master's thesis, Aalto University, February 2023. URN:NBN:fi:aalto-202305213270.

[SFS+15]

A V Shcherbakova, K G Fedorov, K V Shulga, V V Ryazanov, V V Bolginov, V A Oboznov, S V Egorov, V O Shkolnikov, M J Wolf, D Beckmann, and A V Ustinov. Fabrication and measurements of hybrid Nb/Al Josephson junctions and flux qubits with \mkbibemph \ensuremath \pi -shifters. Superconductor Science and Technology, 28(2):025009, February 2015. doi:10.1088/0953-2048/28/2/025009.

[SNV+26]

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.

[Sim01] (1,2,3)

Rainee Simons. Coplanar Waveguide Circuits, Components, and Systems. Number v. 165 in Wiley Series in Microwave and Optical Engineering. Wiley Interscience, New York, 2001. ISBN 978-0-471-46393-1. doi:10.1002/0471224758.

[TLA+11] (1,2,3,4,5,6)

J. D. Teufel, Dale Li, M. S. Allman, K. Cicak, A. J. Sirois, J. D. Whittaker, and R. W. Simmonds. Circuit cavity electromechanics in the strong-coupling regime. Nature, 471(7337):204–208, March 2011. doi:10.1038/nature09898.

[Tin15]

Michael Tinkham. Introduction to Superconductivity. Dover Books on Physics. Dover Publ, Mineola, NY, 2 ed edition, 2015. ISBN 978-0-486-43503-9.

[TVT+24]

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.

[YIW+08]

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.