quantcore_circuits.layouts.others.amplifiers

Parametric-amplifier cells (agent amplifiers, design decision #45): Quantcore re-drawings of the open JPA / TWPA layouts listed in components/Open Superconducting Device Layouts.md (“Parametric amplifiers”), on the PDK stack (negative mask: the etch is drawn on base_metal_gap_wo_grid, PDK 1/0) with Nb trilayer junctions.

  • SquidTermination — QPDK qpdk/cells/parametric_amplifier.py::squid_termination (+ the pump line of cpw_jpa): a CPW lead that ends in an etched pocket bridged by a trilayer SQUID to ground, and a shorted CPW pump / flux line running past the ground side of the SQUID (Yamamoto et al. 2008; Pogorzalek et al. 2017).

  • LumpedJpa — the lumped JPAs of twpa-sim (src/twpa/layout/generate.py, families jpa and squid_jpa, MIT): one junction or SQUID shunted by a capacitor, here a planar interdigital capacitor (IDC) between an island and the ground (the PDK has no MIM layer). coupling="capacitive": the island’s CPW lead is the port (put a coupling capacitor cell in front); coupling="inductive": a tapped-inductor coupling (the junction’s ground side lands on a narrow strip shared with the signal line; twpa-sim draws a pickup loop).

  • JtwpaChain — the 4WM JTWPA of twpa-sim (jtwpa4wm) and the resonantly phase-matched JTWPA of the QPDK JosephsonCircuits notebook (O’Brien et al. 2014): a series chain of trilayer junctions between CPW centre-line islands, each island shunted to ground by interdigital fingers, a lumped LC resonator on every resonator_every-th node (coupling IDC, pad, meander inductor to ground).

  • KiTwpaSerpentine — the KI-TWPA serpentine of twpa-sim src/twpa/layout/kit.py (a port of the NY CREATES research geometry, NbN): a 0.58 µm spine with 75.5 µm capacitive fingers (27.5 µm on the loaded cells), straight rows joined by U-turns whose spine width is matched in sheet squares, tapered launches to the chip CPW.

Sources were read, never imported or run (build/external/twpa-sim, build/external/quantum-rf-pdk).

LOM (qcc_lom on each class): the SQUID termination enters the λ/4 line as its inductive equivalent length (as NeckTermination); the lumped JPA is an island with its IDC capacitance, the junction / SQUID and the coupling; the JTWPA chain is one node per island (junctions in series, shunt C, resonators); the KI serpentine is one conductor (a wire between its ports) with its electrical ladder from KiTwpaSerpentine.qcc_ladder() (PDK film kinetic inductance via quantcore_circuits.circuit.kinetic).

Attributes

Classes

JtwpaChain

Series chain of cells trilayer junctions along +x (4WM JTWPA; twpa-sim jtwpa4wm; QPDK resonantly

KiTwpaSerpentine

Kinetic-inductance TWPA serpentine (twpa-sim KITLayout / kit.primitives, the NY CREATES research

LumpedJpa

Lumped JPA: a trilayer junction or SQUID to ground, shunted by an interdigital capacitor (twpa-sim jpa /

SquidTermination

CPW lead shorted to ground through a trilayer SQUID, with a shorted pump / flux line (QPDK squid_termination

Functions

cpw_gaps(dbu, x0, x1, a, b[, axis, at]) → kqcircuits.pya_resolver.pya.Region

The two gap strips of a straight CPW (centre a, gaps b) from x0 to x1 along axis (dbu).

cpw_inductance_per_m(a_um, b_um[, pdk, f_GHz]) → float

L' (H/m) of a CPW on the PDK stack, geometric + the film's kinetic inductance (cpw_properties).

drawn_junction_values(jtype, junction_params) → tuple[float | None, float, str]

(L_J nH, C_J fF, source) of the trilayer cell jtype drawn with junction_params (PDK junction rule;

instance_junction(inst, p) → tuple[float | None, float, str]

(L_J nH, C_J fF, source): the design's junction (first entry of a list) wins over the drawn values.

interdigital(dbu, x0, n, wf, gf, y_root_a, y_root_b) → tuple[kqcircuits.pya_resolver.pya.Region, float]

Fingers of an interdigital capacitor between two electrodes along y: electrode A's fingers rise from

meander_strip(dbu, x0, x1, y0, y1, width, turns) → tuple[kqcircuits.pya_resolver.pya.Region, float]

A strip of width from (centre x, y0) to (centre x, y1) meandering turns times across

shorted_line(dbu, x_axis, y_short, length, a, b) → kqcircuits.pya_resolver.pya.Region

Etch of a vertical CPW that arrives from −y and is shorted at y_short (its gaps stop there): the pump /

Module Contents

class quantcore_circuits.layouts.others.amplifiers.JtwpaChain

Bases: kqcircuits.elements.element.Element

Series chain of cells trilayer junctions along +x (4WM JTWPA; twpa-sim jtwpa4wm; QPDK resonantly phase-matched JTWPA): ports a (origin, faces −x) and b (x = 2·lead + cells·cell_pitch, faces +x), CPW a/b leads of lead_length.

Between the leads the centre line is cut into cells + 1 islands (island_width; the end islands are half islands, so the end shunts are halved, as the finite-chain convention) separated by junction_gap; each cut is bridged by the junction cell junction_type (default Quantcore Junction). Each island is shunted to ground by shunt_fingers fingers per side interleaved with ground fingers hanging from the trench walls (the chain’s ground capacitance C_g). With resonator_every = M > 0, every M-th node (resonator_offset, M, 2M, …) loses its top or bottom fingers (alternating) and gets a lumped LC resonator beyond the trench wall: a lead through a slot to an interdigital coupling capacitor (coupling_fingers), a pad (resonator_pad) and a meander inductor (inductor_turns, inductor_width) to the pocket wall — O’Brien et al. 2014 resonant phase matching.

LOM: nodes n0 … n<cells> (a → n0, b → n<cells>), a JJ between neighbours (drawn L_J / C_J, or the design’s junction), C_g to ground per node (analytic IDC), and per resonator r<k>: C_c, C_r, L_r (geometric + kinetic meander). Long chains exceed QuCat: quantcore_circuits.analysis.amplifiers solves the linear ladder (ABCD) and the coupled-mode gain from the same values.

build()
classmethod qcc_layout(params: dict) → dict

Chain coordinates (µm): junction x positions, island spans, resonator nodes / sides, trench half-width.

classmethod qcc_lom(name: str, inst, pdk)
classmethod qcc_params(params: dict) → dict
classmethod qcc_probes(params: dict) → dict

LOM node → a point on its island (µm, cell frame) for naming the FEM nets: n<k> at the middle of island k on the centre line (the simulation export probes them; no port touches the inner islands).

classmethod qcc_values(params: dict, pdk=None) → dict

Per-cell analytic values: C_g (fF, full / end island), C_c, C_r (fF), L_r (nH, geometric + kinetic), the meander length, and the drawn junction.

cell_pitch
cells
coupling_finger_length
coupling_fingers
inductor_height
inductor_turns
inductor_width
island_width
junction_gap
junction_params
junction_type
lead_length
qcc_category = 'waveguide'
resonator_every
resonator_gap
resonator_offset
resonator_pad
shunt_finger_length
shunt_finger_width
shunt_fingers
shunt_gap
wall
class quantcore_circuits.layouts.others.amplifiers.KiTwpaSerpentine

Bases: kqcircuits.elements.element.Element

Kinetic-inductance TWPA serpentine (twpa-sim KITLayout / kit.primitives, the NY CREATES research geometry; MIT): rows straight rows of periods_per_row supercells (unloaded_cells + loaded_cells cells of pitch; the loaded cells, in the middle of each supercell, have loaded_finger_length fingers) joined by U-turns of turn_radius with turn_periods supercells of radial fingers each. The turn spine is widened with a smooth-step profile (taper_cells) so its biased sheet-square count matches the straight rows (twpa-sim’s approximation, bias_ratio).

Negative mask: the etch is the spine gap (spine_gap) and each finger’s slot (finger_gap around it); the ground between rows is the chip ground plane (twpa-sim’s two separate ground combs need package grounding; here they are one plane). Launches: the spine tapers to the chip CPW (a/b) over launch_taper_length and runs launch_length straight to the ports a (row 0, input) and b (last row), both facing away from the rows. Rows run along x centred on the origin; row r is at y = (rows − 1 − 2r)·turn_radius.

build()
classmethod qcc_keepout(params: dict) → list

3/0 keep-out (local µm): filled boxes over each row band, each U-turn and each launch, grown by the PDK component margin — cheap to evaluate, unlike growing the 100 k-polygon etch itself.

classmethod qcc_ladder(params: dict, pdk=None, sheet_pH_sq: float | None = None, thickness_um: float | None = None, eps_r: float | None = None) → dict

Electrical ladder of the drawing (one cell = series L + shunt C to ground; twpa-sim Cell):

  • L_cell = L’_geo·pitch (Metal’s CPW formula for the bare spine) + L_s·(pitch/spine_width) (sheet squares of the film: the PDK’s L_s, or sheet_pH_sq) — the twpa-sim cell has 20 pH/□ × 1.5/0.58 × 1.04;

  • C_cell = two fingers, each a strip in its slot (CPW C’ of finger_width / finger_gap × finger length) + the spine to ground over the pitch outside the slots; loaded cells with loaded_finger_length;

  • the counts: cells per supercell, supercells per row / turn, total cells.

classmethod qcc_lom(name: str, inst, pdk)

One conductor between a and b (a wire when both meet pads); the ladder values ride in the notes.

qcc_rows() → tuple[list[float], float, float]
arc_points
bias_ratio
finger_gap
finger_length
finger_width
launch_length
launch_taper_length
loaded_cells
loaded_finger_length
periods_per_row
pitch
qcc_category = 'waveguide'
rows
sheet_inductance_pH_sq
spine_gap
spine_width
taper_cells
turn_periods
turn_radius
unloaded_cells
class quantcore_circuits.layouts.others.amplifiers.LumpedJpa

Bases: kqcircuits.elements.element.Element

Lumped JPA: a trilayer junction or SQUID to ground, shunted by an interdigital capacitor (twpa-sim jpa / squid_jpa, MIM shunt → planar IDC on the PDK).

Port signal at the origin faces −x (CPW a/b, lead_length long) into a pocket holding the island: a spine (spine_width) with shunt_fingers fingers on each side interleaved with ground fingers hanging from the pocket walls (finger_length / finger_width / finger_gap; one gap everywhere).

  • coupling="capacitive": the lead joins the island (the port is the island conductor; put a coupling capacitor, e.g. KQC FingerCapacitorSquare, between the feed and signal). The junction bridges a junction_gap between the island’s far end and the pocket wall; with flux_line a shorted CPW (port flux) runs past it (SQUID flux bias / pump), as SquidTermination.

  • coupling="inductive": the lead ends on a tap pad tied to the pocket floor by a strip (tap_width) — the coupling inductance shared by the signal line and the JPA loop; the junction bridges the tap pad and the island.

LOM: island with the IDC shunt C to ground (Igreja–Dias IDC + the spine, analytic), the junction / SQUID (drawn values on the PDK rule unless the design gives junction); capacitive: signal → island; inductive: tap node (small pad C) with the strip inductance to ground (geometric + kinetic, quantcore_circuits.circuit.kinetic.wire_inductance()), signal → tap.

build()
classmethod qcc_geometry(params: dict) → dict

Key coordinates (µm, local frame) of the drawing: pocket, island span, junction gap, tap.

classmethod qcc_lom(name: str, inst, pdk)
classmethod qcc_params(params: dict) → dict
classmethod qcc_values(params: dict, pdk=None) → dict

Analytic circuit values of the drawing: C_shunt (fF), the tap strip inductance (nH), tap pad C (fF).

coupling
finger_gap
finger_length
finger_width
flux_gap
flux_length
flux_line
flux_offset
flux_phi0
junction_gap
junction_params
junction_type
lead_length
qcc_category = 'resonator'
shunt_fingers
spine_width
tap_pad
tap_width
class quantcore_circuits.layouts.others.amplifiers.SquidTermination

Bases: kqcircuits.elements.element.Element

CPW lead shorted to ground through a trilayer SQUID, with a shorted pump / flux line (QPDK squid_termination and the pump of cpw_jpa).

Port a at the origin faces −x (CPW a/b); the lead runs to x = lead_length and ends on a landing head in an etched pocket pocket_width wide; a head wider than the CPW (a + 2 b) gets b of pocket before it as well (the pocket then starts at lead_length − b around the centre conductor), so the lead reaches ground only through the junction. The junction gap junction_gap beyond the head is bridged by the junction cell junction_type (default the PDK Quantcore Squid; its island side lands on the lead end, its ground side on the far pocket edge; refpoints port_squid_a / port_squid_b). With pump_line a CPW (a/b) runs along +y past the ground side of the SQUID, pump_gap of ground between the pocket and its gap, shorted pump_offset beyond the SQUID axis; its port pump is pump_length below the short and faces −y. The pump current and its return through that ground strip thread the SQUID loop (mutual M: extract it by EM; QPDK’s SAX model has none either).

LOM: the SQUID is the λ/4 line’s shorted end at its inductive equivalent length ℓ_eq = lead + L_s(Φ)/L’ (L’ of the a/b CPW incl. the film’s kinetic inductance), so f_r = f_λ/4 / (1 + L_s/L’ℓ) (Yamamoto 2008; QPDK); L_s(Φ) = L_s0/|cos πΦ/Φ0| at the static bias flux_phi0. The Kerr / 3WM nonlinearity is not in the lumped circuit: quantcore_circuits.analysis.amplifiers takes it from the same values.

build()
classmethod qcc_lom(name: str, inst, pdk)

The lead is the routed line’s last section; the SQUID adds L_s/L’ of electrical length (shorted end).

classmethod qcc_params(params: dict) → dict
classmethod qcc_squid(params: dict, inst=None) → dict

{L_s0 nH (zero flux), L_s nH (at flux_phi0), C_J fF, source}: the termination’s SQUID.

flux_phi0
head
junction_gap
junction_params
junction_type
lead_length
pocket_width
pump_gap
pump_length
pump_line
pump_offset
qcc_category = 'termination'
quantcore_circuits.layouts.others.amplifiers.cpw_gaps(dbu, x0, x1, a, b, axis='x', at=0.0) → kqcircuits.pya_resolver.pya.Region

The two gap strips of a straight CPW (centre a, gaps b) from x0 to x1 along axis (dbu).

quantcore_circuits.layouts.others.amplifiers.cpw_inductance_per_m(a_um: float, b_um: float, pdk=None, f_GHz: float = 6.5) → float

L’ (H/m) of a CPW on the PDK stack, geometric + the film’s kinetic inductance (cpw_properties).

quantcore_circuits.layouts.others.amplifiers.drawn_junction_values(jtype: str, junction_params) → tuple[float | None, float, str]

(L_J nH, C_J fF, source) of the trilayer cell jtype drawn with junction_params (PDK junction rule; SQUID: the parallel total at zero flux); (None, 0, …) for Sim / no junction.

quantcore_circuits.layouts.others.amplifiers.instance_junction(inst, p: dict) → tuple[float | None, float, str]

(L_J nH, C_J fF, source): the design’s junction (first entry of a list) wins over the drawn values.

quantcore_circuits.layouts.others.amplifiers.interdigital(dbu, x0, n, wf, gf, y_root_a, y_root_b) → tuple[kqcircuits.pya_resolver.pya.Region, float]

Fingers of an interdigital capacitor between two electrodes along y: electrode A’s fingers rise from y_root_a to y_root_b − gf, B’s hang from y_root_b to y_root_a + gf (either order of the roots), alternating along +x from x0 (A first, n fingers in all, pitch wf + gf). Returns (A ∪ B fingers as metal, x of the last finger’s far edge).

quantcore_circuits.layouts.others.amplifiers.meander_strip(dbu, x0, x1, y0, y1, width, turns) → tuple[kqcircuits.pya_resolver.pya.Region, float]

A strip of width from (centre x, y0) to (centre x, y1) meandering turns times across [x0, x1] (vertical runs, horizontal legs): the lumped inductors. Returns (metal, developed centre-line length).

quantcore_circuits.layouts.others.amplifiers.shorted_line(dbu, x_axis, y_short, length, a, b) → kqcircuits.pya_resolver.pya.Region

Etch of a vertical CPW that arrives from −y and is shorted at y_short (its gaps stop there): the pump / flux line of QPDK’s cpw_jpa (straight_shorted).

quantcore_circuits.layouts.others.amplifiers.PHI0 = 2.067833848e-15