quantcore_circuits.sim_tools.builder¶
Design sim-group → KQC Simulation.
For a sim_groups entry the builder:
derives a simulation design: junctions of the selected qubits become KQC
"Sim"junctions; for capacitance analyses, selected routes attached to selected instances are cut (removed) and replaced by a short waveguide-to-port stub at that port, so the coupler becomes its own net (the resonator itself is modelled as a transmission line in LOM); no ground grid, no chip frame;builds it and cuts out the box spanned by the selected instances/routes plus
margin_um;adds ports: junction
InternalPort(eigenmode / driven: L at the design flux and C_J as the LOM takes them,lumped_junction(); capacitance: a placeholder L, the gap stays open), waveguide-to-port stubs, and one port per route crossing the box edge — anEdgePortfor capacitance analyses; for eigenmode, where KQC forbids edge ports, a 50 Ω lumpedInternalPortnext to the edge (KQC’suse_internal_ports="at_edge"geometry), so the crossing line is terminated and the eigenmode Q gives κ / Purcell. Where a straight line crosses the box edge at an angle, that port sits on the line’s own axis just inside the box, its cut square to the line (line_port(); driven: the same lumped port instead of a wave port);passes the PDK stack (substrate, permittivity, box heights).
The group name "chip" (unless the design defines its own) means the whole chip: every instance and route is kept
uncut, the box is the chip box, and each cell exposing lumped_signal/lumped_ground refpoints (bond pads) gets a
50 Ω lumped port. In other groups, the selected pads get that port, and so do the pads that terminate the
selection (snapped to a selected instance, or at an end of a selected route): a selected feedline is never floating.
The returned SimSetup records the port number → design name mapping used later to label C-matrices.
Attributes¶
Classes¶
The metal of |
|
The 50 Ω port of a straight line the box edge crosses at an angle, on the line's own axis ( |
|
Functions¶
|
"capacitance", "eigenmode", "driven" or a plugin's kind (see |
|
Create the KQC |
|
How the 50 Ω port of the line crossing the box edge at |
|
The route's centre conductor ( |
|
KQC faces on which |
|
A port polygon KQC built on slanted edges (C6b): its corners are the found edges' end points on the database |
|
Whether KQC builds the polygon of the 50 Ω edge port at crossing |
|
KQC |
|
Routes whose box crossing lies on a junction island (a galvanic lead line leaving the box: the island would be |
|
Routes whose centre conductor is galvanically grounded (they must not become C-matrix nets). |
|
The sim group |
|
A KQC element that joins two faces: a TSV ( |
|
A junction cell — KQC |
|
|
|
FEM net labels on the two sides of a qubit's junction: ( |
|
|
|
Labels for signal conductors no probe named (C7): a piece of a selected cell's own line (its waveguide path; |
|
|
|
The 50 Ω port of the line crossing the box edge at |
|
Whether KQC builds the polygon of the 50 Ω port cut from |
|
(L nH, C_J fF) of a qubit's junction as a lumped RLC sheet (eigenmode, driven): the values its LOM takes |
|
KQC |
|
The junction port sheet as a |
|
Label KQC's signal excitations by probing points: the first probe inside an excitation's metal names it. |
|
The face an instance is placed on: the first of its |
|
The face the CPW at plan port |
|
The KQC faces a sim group's lines run on (always with the PDK face): each selected route's centre line (a |
|
Port data with the builder's junction sheet ( |
|
|
|
Copy of |
|
Rewrite each polygon of the simulation GDS |
|
Move box edges so every line that leaves the box is cut on a straight section (C6): the eigenmode / driven |
|
Remove geometry a simulation must not contain from a built layout, in place. |
|
Remove the TSVs and bumps that have no face to land on in |
|
|
Module Contents¶
- class quantcore_circuits.sim_tools.builder.FaceMetal(result, box: kqcircuits.pya_resolver.pya.DBox, face: str, etch=(), metal=(), smooth: float = 0.0)¶
The metal of
faceinsideboxas KQC’sSimulationbuilds it: box − (gap − addition), plusetchboxes (on the gap layer) andmetalboxes (addition), optionally with the etchsmooth-ed (µm, the sim-only bend simplification).piecesare its conductors;boxed[k]: piece k touches the box edge (ground).- classmethod from_etch(etch: kqcircuits.pya_resolver.pya.Region, box: kqcircuits.pya_resolver.pya.DBox, dbu: float = 0.001) FaceMetal¶
A FaceMetal of a plain etch region (dbu units): synthetic geometry for tests.
- max_points() int¶
Most points of one metal or gap polygon as a GDS writer stores it (holes keyholed into the hull).
- on_edge(p: kqcircuits.pya_resolver.pya.DPoint, tol: float = KQC_EDGE_TOL_UM) bool¶
plies on a metal edge (where KQC’sfind_edge_from_point_in_polygonsfinds one).
- piece_at(p: kqcircuits.pya_resolver.pya.DPoint) int | None¶
The conductor at
p(None in etch); a point on an edge belongs to the piece it touches.
- class quantcore_circuits.sim_tools.builder.LinePort¶
The 50 Ω port of a straight line the box edge crosses at an angle, on the line’s own axis (
line_port()). The cut runs fromsignalalongdirection(a − 2·over_etchinglong,a + bwide, square to the line); the stub fromsignalout to the box edge stays metal, as the at-edge port’s 1 µm stub.- angle: float¶
- direction: kqcircuits.pya_resolver.pya.DVector¶
- edge: kqcircuits.pya_resolver.pya.DPoint¶
- signal: kqcircuits.pya_resolver.pya.DPoint¶
- class quantcore_circuits.sim_tools.builder.SimPortInfo¶
- excitation: str | None = None¶
- kind: str¶
- name: str¶
- number: int¶
- class quantcore_circuits.sim_tools.builder.SimSetup¶
- port_labels() dict[int, str]¶
- analysis: str¶
- box: kqcircuits.pya_resolver.pya.DBox | None = None¶
- design: quantcore_circuits.design.Design¶
- geometry: dict¶
- group: str¶
- nets: dict[int, str]¶
- notes: list[str] = []¶
- ports: list[SimPortInfo] = []¶
- routes: list[str] = []¶
- simulation: kqcircuits.simulations.simulation.Simulation¶
- waveguide_length: float = 100.0¶
- quantcore_circuits.sim_tools.builder.analysis_kind(analysis: str) str¶
“capacitance”, “eigenmode”, “driven” or a plugin’s kind (see
quantcore_circuits.plugins).
- quantcore_circuits.sim_tools.builder.build_simulation(source, group: str, analysis: str, waveguide_length: float = 100.0, airbridges: bool | None = None, **sim_params) SimSetup¶
Create the KQC
Simulationforgroup/analysis(see module docstring).The simulated geometry never has the ground grid (cheese). Airbridges are dropped for speed unless
airbridges=True(or the group’ssettings["airbridges"]); a note flags crossing bridges whose line is then open at the crossing.Faces: a group whose lines run on more than the PDK face (a route through a bump connector onto
2b1, a TSV to1b1, an instance placed on another face) is simulated with all the faces it needs (sim_face_stack()): bumps and TSVs stay as KQC’s PEC pillars joining the faces, lines leaving the box on another face get their port on that face.settings["face_stack"](a KQC face stack) andsettings["chip_distance"](µm) override it.
- quantcore_circuits.sim_tools.builder.crossing_port(path: kqcircuits.pya_resolver.pya.Region, spines: list[list[kqcircuits.pya_resolver.pya.DPoint]], lith: kqcircuits.pya_resolver.pya.Region, box: kqcircuits.pya_resolver.pya.DBox, pos: kqcircuits.pya_resolver.pya.DPoint, a: float, b: float, dbu: float, over_etching: float = 0.0)¶
How the 50 Ω port of the line crossing the box edge at
posis built (C6):"edge"— a square crossing where KQC’s at-edge port works (edge_port_ok(),crossing_square(); the port as it always was); aLinePort— a straight line crossing at an angle, the port on its own axis (line_port(),line_port_ok()); None — neither (a bend, a taper:straighten_box()moves the edge; if the edge stays, the port has no polygon).path: the route’s centre conductor,spines: its centre lines.
- quantcore_circuits.sim_tools.builder.crossing_square(path: kqcircuits.pya_resolver.pya.Region, box: kqcircuits.pya_resolver.pya.DBox, pos: kqcircuits.pya_resolver.pya.DPoint, a: float, b: float, dbu: float) bool¶
The route’s centre conductor (
path) crosses the box edge atposroughly at 90°: inside a band as deep as the 50 Ω edge port (1 + a + b) it is one piece,atoa + b/2wide along the edge, reaching across the band. Rules out an edge that runs along the line (a bend tangent to the edge) or a diagonal crossing, where KQC may still find edges but the port and the cut are skewed (a straight one gets aline_port()).
- quantcore_circuits.sim_tools.builder.drawn_faces(layout, cell, names) set[str]¶
KQC faces on which
cell(with its sub-cells) has shapes on one of the KQC layersnames.
- quantcore_circuits.sim_tools.builder.edge_midpoint_locations(p: dict) dict¶
A port polygon KQC built on slanted edges (C6b): its corners are the found edges’ end points on the database grid, so the drawn signal / ground points (off the grid) can lie a fraction of a nm off the polygon’s slanted sides, and AEDT then refuses the port’s current line (“Both endpoints of the directed line must lie on the boundary face”). The exported locations become the midpoints of KQC’s own signal and ground edges, which lie on the polygon; KQC’s nets were assigned from the drawn points already. Without a polygon nothing changes.
- quantcore_circuits.sim_tools.builder.edge_port_ok(lith: kqcircuits.pya_resolver.pya.Region, box: kqcircuits.pya_resolver.pya.DBox, pos: kqcircuits.pya_resolver.pya.DPoint, a: float, b: float, dbu: float) bool¶
Whether KQC builds the polygon of the 50 Ω edge port at crossing
pos(seebuild_simulation(): signal 1 µm inside the box edge, groundafurther in, the line etched between thema + bwide): after that etch both points must lie on a metal edge. On a bend, a taper or a diagonal they do not and AEDT skips the port (C6; a straight diagonal gets its port on its own axis instead,line_port()).lith: the face’s etch (gap − addition), uncut by the box.
- quantcore_circuits.sim_tools.builder.face_stack_of(faces) list[str]¶
KQC
face_stackforfaces: the run ofFACE_ORDERfrom the lowest to the highest of them. A face in between is simulated too, as KQC models every face in the stack: metal wherever the design does not etch it.
- quantcore_circuits.sim_tools.builder.galvanic_routes(fm: FaceMetal, islands: set[int], crossings) tuple[set[str], set[int]]¶
Routes whose box crossing lies on a junction island (a galvanic lead line leaving the box: the island would be joined to the box edge = ground) and the islands still on the box edge without such a route (C4).
- quantcore_circuits.sim_tools.builder.grounded_routes(design: quantcore_circuits.design.Design) set[str]¶
Routes whose centre conductor is galvanically grounded (they must not become C-matrix nets).
A route is grounded if an end is a short: a free end with
term == 0, a hanger withend == "short", or a port that the cell class lists inqcc_shorted_ports(e.g. the Xmon flux-line tip).
- quantcore_circuits.sim_tools.builder.group_spec(design: quantcore_circuits.design.Design, group: str) quantcore_circuits.design.schema.SimGroup¶
The sim group
groupofdesign;"chip"defaults to the whole chip with nothing cut.
- quantcore_circuits.sim_tools.builder.is_face_connector(cell_ref: str) bool¶
A KQC element that joins two faces: a TSV (
Tsvsubclasses) or a flip-chip bump connector (FlipChipConnectorsubclasses,FlipChipConnectorRf).
- quantcore_circuits.sim_tools.builder.is_junction_cell(cell_ref: str) bool¶
A junction cell — KQC
Junctionsubclasses (Manhattan, NoSquid, Sim, SuperInductor, …), the Quantcore trilayer cells, Metal junctions (metal:SNAIL, …: categoryjunction). They belong in a qubit’s gap (or a code-built layout’s): placed on their own they are not a qubit, so the export gives them no qubit treatment (seebuild_simulation(): a junction port only where the cell bridges two different conductors).
- quantcore_circuits.sim_tools.builder.junction_gap(fm: FaceMetal, a: kqcircuits.pya_resolver.pya.DPoint, b: kqcircuits.pya_resolver.pya.DPoint, reach: float = JJ_AXIS_REACH_UM)¶
(signal point, ground point)on the facing edges of the two conductors a junction drawn froma(island side) tobbridges, found along its axis — wherever its pins sit: on the edges, inside the metal (a junction overlapping into the islands) or short of them (a pin in a cut-out, StarQubit’s line ending between its two leads). Among the gaps between two different conductors on the axis (not two box-edge grounds) the one overlapping the pins’ span, nearest its middle, wins. None if there is none (both ends on one conductor, a zero-length junction).
- quantcore_circuits.sim_tools.builder.junction_nets(name: str, inst, pdk) tuple[str, str | None]¶
FEM net labels on the two sides of a qubit’s junction: (
squid_aside,squid_bside or None = ground).Taken from the component’s LOM model (island labels such as
Q1.island, orQ1.island1/Q1.island2for a floating transmon, whose junction connects two islands);<name>.islandwhen there is no model.
- quantcore_circuits.sim_tools.builder.junction_sheet(fm: FaceMetal, sig: kqcircuits.pya_resolver.pya.DPoint, gnd: kqcircuits.pya_resolver.pya.DPoint, width: float = 10.0, min_width: float = 0.5, clearance: float = JJ_SHEET_CLEARANCE_UM)¶
(polygon points, width): the junction’s lumped sheet betweengndandsig(points on the two metal edges): a strip on the axis,widthwide or narrower until no metal lies withinclearanceof it away from its ends (metal along its long sides would short the lumped element), cut to the gap (its ends follow the metal edges, so nothing of the sheet lies on metal and both ends touch a conductor). None if not evenmin_widthfits.
- quantcore_circuits.sim_tools.builder.label_unnamed(sim, nets: dict[int, str], result, select: list[str], design: quantcore_circuits.design.Design, faces: list[str] | None = None) dict[int, str]¶
Labels for signal conductors no probe named (C7): a piece of a selected cell’s own line (its waveguide path; a spiral cut where a dropped airbridge crossed) → the cell’s LOM island when it has exactly one (
X.res#2), a piece of a route’s line → the route; any other conductor inside a selected cell →<cell>.floating[k](floating parts such as a coupler’s cross, ground enclosed by the cell); elsefloating<k>.faces: route lines on each of these faces (a multi-face group); default1t1.
- quantcore_circuits.sim_tools.builder.lead_open_ends(fm: FaceMetal, ports: dict, islands: dict[str, set[int]], connected: set[str], default_ab: tuple) list[tuple[str, kqcircuits.pya_resolver.pya.DPolygon]]¶
[(port key, etch polygon)]: an open end (blong,a + 2bwide) beyond each unconnected port of a simulated qubit whose own junction island (islands: qubit → its island pieces) runs through the port into the ground plane (the island piece reaches the box edge) — a galvanic lead left unrouted (TwoPadTransmon’sleftlead ends on the pocket edge). Unetched, it joins the island to the ground plane; the fab cell is unchanged, the etch goes into the simulation only (C4).
- quantcore_circuits.sim_tools.builder.line_port(spines: list[list[kqcircuits.pya_resolver.pya.DPoint]], box: kqcircuits.pya_resolver.pya.DBox, pos: kqcircuits.pya_resolver.pya.DPoint, a: float, b: float) LinePort | None¶
The 50 Ω port of the line crossing the box edge at
pos, on the line’s own axis (C6b). KQC’s at-edge port cuts along the box normal: where the line crosses at an angle its points miss the metal edges, the port has no polygon and AEDT skips it. Here the cut is square to the line,a + bwide, with its corner nearest the box edge 1 µm inside it (the at-edge port’s signal point); the line must run straight from the edge tobpast the cut. At 90° this is the at-edge geometry.spines: the route’s centre lines (_route_spines()). None on a bend or a taper (straighten_box()moves the edge) and for a line within 90° −LINE_PORT_MAX_ANGLE_DEGof the edge.
- quantcore_circuits.sim_tools.builder.line_port_ok(lith: kqcircuits.pya_resolver.pya.Region, box: kqcircuits.pya_resolver.pya.DBox, edge: kqcircuits.pya_resolver.pya.DPoint, signal: kqcircuits.pya_resolver.pya.DPoint, ground: kqcircuits.pya_resolver.pya.DPoint, etch_width: float, dbu: float) bool¶
Whether KQC builds the polygon of the 50 Ω port cut from
signaltoground,etch_widthwide (both points on a metal edge after the cut, asedge_port_ok()checks), and the cut parts the line: the stub beyond the signal side is not the line beyond the ground side, and it reaches the box edge (edge: where the line crosses it) like the at-edge port’s stub.lith: the face’s etch (gap − addition), uncut by the box.
- quantcore_circuits.sim_tools.builder.lumped_junction(name: str, inst, pdk, notes: list | None = None) tuple[float, float]¶
(L nH, C_J fF) of a qubit’s junction as a lumped RLC sheet (eigenmode, driven): the values its LOM takes (
instance_junction(): the design’s junction, else the drawn trilayer junction on the PDK rule), L at the design flux.notesgets the source; raises when there is no L, saying where to set it.
- quantcore_circuits.sim_tools.builder.multiface_params(pdk, face_stack, chip_distance: float | None = None) dict¶
KQC
Simulationstack parameters for a multi-faceface_stackon the PDK stack: both substrates are the PDK substrate (thickness, material), the vacuum gap between 1t1 and 2b1 ischip_distance(default the PDK’schip_distance), and a stack that starts on a bottom face (1b1) gets a vacuum box below it (lower_box_height: the PDK’s, orupper_box_heightwhere the PDK has none).
- quantcore_circuits.sim_tools.builder.narrow_junction_port(p: dict, width: float = JJ_PORT_WIDTH_UM, max_edge: float = JJ_PORT_MAX_EDGE_UM) dict¶
The junction port sheet as a
width-wide rectangle on the junction line (signal → ground location).KQC spans the port polygon between the whole metal edges nearest the signal and ground points. With a junction drawn on lead stubs (KQC qubits, Xmon + Quantcore Junction) those are short (≈ 8 µm) and kept. Where the junction bridges a plain gap they are the island’s and the ground’s whole edges: chip 12’s TransmonCrossFL (signal 50 µm, ground 90–1145 µm: a skewed trapezoid sheet, no qubit eigenmode), IBM pocket pads (750 µm both), and a diagonal StarQubit line has no edge at all (no polygon, AEDT skips the port). Those get the rectangle instead; the ends sit on the metal boundary (
etched_line), the current line is unchanged.
- quantcore_circuits.sim_tools.builder.net_names(sim: kqcircuits.simulations.simulation.Simulation, probes: list[tuple[str, kqcircuits.pya_resolver.pya.DPoint]], near: list[tuple[str, kqcircuits.pya_resolver.pya.DPoint]] | None = None, reach: float = 100.0) dict[int, str]¶
Label KQC’s signal excitations by probing points: the first probe inside an excitation’s metal names it.
KQC numbers signals by conductor (
Simulation.split_metal_layers_by_excitation): ports sharing a conductor share one excitation, and floating conductors follow in arbitrary order, so port k is not always net k.nearprobes that land in ground name the nearest unnamed conductor withinreachµm (bounding-box distance), e.g. a floating claw whose port tail is joined to a grounded resonator.
- quantcore_circuits.sim_tools.builder.own_face(inst, default: str) str¶
The face an instance is placed on: the first of its
face_ids(defaultif it sets none).
- quantcore_circuits.sim_tools.builder.port_face(result, p, faces: list[str], main: str, default_ab: tuple) str¶
The face the CPW at plan port
pis drawn on: the first offaces(mainfirst) with etch on both sides of the centre conductor just behind the port;mainif none has.
- quantcore_circuits.sim_tools.builder.selection_faces(design: quantcore_circuits.design.Design, result, names, pdk) set[str]¶
The KQC faces a sim group’s lines run on (always with the PDK face): each selected route’s centre line (a route’s
face_ids, or aface_idwaypoint, where KQC puts a bump connector and continues on that face), the faces each selected TSV or bump connector draws on (is_face_connector(), or any other cell that draws TSVs or bumps and is not a qubit:_draws_joins()), and the face of each selected instance placed on another face (face_ids[0]). A qubit on the PDK face that also draws a little on another face (a Flipmon’s top-chip disc and bump) does not add that face: setface_stackin the group’s settings for it.
- quantcore_circuits.sim_tools.builder.sheet_junction_port(p: dict, polygon, width: float) dict¶
Port data with the builder’s junction sheet (
junction_sheet()):polygonreplaces KQC’s; the signal / ground edges arewidthlong across the junction axis at the port’s signal / ground points.
- quantcore_circuits.sim_tools.builder.sim_face_stack(design: quantcore_circuits.design.Design, g: quantcore_circuits.design.schema.SimGroup, result, pdk, sim_params: dict) tuple[list, dict, str]¶
(face_stack, stack parameters, how)of a sim group:face_stackfrom the call (sim_params), else the group’ssettings["face_stack"](a list;"auto"= not set), else the faces its lines run on (selection_faces(),face_stack_of()). One face: the PDK’ssimulation_params()face stack with no stack parameters (the export as before); several:multiface_params()(chip_distancefrom the call, the group’s settings or the PDK).how:"set"or"auto".
- quantcore_circuits.sim_tools.builder.simulation_design(design: quantcore_circuits.design.Design, group: str, analysis: str) tuple[quantcore_circuits.design.Design, list[tuple[str, str]]]¶
Copy of
designprepared for simulatinggroup; also returns the cut (instance, port) pairs.
- quantcore_circuits.sim_tools.builder.split_large_gds_polygons(path, limit: int = GDS_MAX_POINTS, overlap_um: float = 0.01) int¶
Rewrite each polygon of the simulation GDS
pathwith more thanlimitpoints (a GDS XY record holds at most 4095) as pieces of the same conductor that overlap byoverlap_umalong the cuts, inside the original outline (a layer’s pieces that KLayout’s writer split at 8000 points, edge to edge, are rejoined first). For HFSS jobs only: every metal sheet is PEC there, so the pieces act as one conductor; Q3D’sAutoIdentifyNetskeeps overlapping objects as separate nets (AEDT 2024 R1 render). Used where simplifying bends is not enough (many holes, e.g. flux-trap rows); done on the written file, after KQC built the port polygons from the whole outlines. Layers without such a polygon are not touched; returns the number of polygons rewritten (0: file unchanged).
- quantcore_circuits.sim_tools.builder.straighten_box(result, box: kqcircuits.pya_resolver.pya.DBox, exclude: set[str], route_ab: dict, default_ab: tuple, inner: kqcircuits.pya_resolver.pya.DBox, limit: kqcircuits.pya_resolver.pya.DBox, max_out: float, max_in: float, lith: kqcircuits.pya_resolver.pya.Region, over_etching: float = 0.0) tuple[kqcircuits.pya_resolver.pya.DBox, list[str]]¶
Move box edges so every line that leaves the box is cut on a straight section (C6): the eigenmode / driven 50 Ω edge port needs that — at 90° KQC’s at-edge port, at an angle a port on the line’s own axis (
crossing_port()); on a bend or a taper KQC finds no edges and AEDT skips the port. An edge with a bad crossing moves out (up tomax_outµm from where it was, insidelimit) or in (up tomax_in, never intoinner) by the smallest step that leaves no bad crossing on it and no more elsewhere; a line whose crossing then moves to the next edge (a bend at a corner of the box) is handled on that edge in the next round. The original box is kept when nothing improves. Returns (box, notes).
- quantcore_circuits.sim_tools.builder.strip_layers(result, airbridges: bool = False, bumps: bool = True) dict¶
Remove geometry a simulation must not contain from a built layout, in place.
the ground grid (cheese) — always: FEM exports are never cheesed;
airbridges (
*airbridge_pads/*airbridge_flyover, which KQC’sSimulationwould insert as PEC pads and bridges) — unlessairbridges=True;indium bumps (
*indium_bump) whenbumps=False(a one-face simulation): with no opposite face KQC extends a bump as PEC from the face to the top of the simulation box, a pillar that shorts its island to the outer boundary (HFSS) or adds its capacitance (Q3D).
Returns
{"ground_grid_shapes", "airbridge_shapes", "airbridges"}(shape counts removed), plus"indium_bump_shapes"when bumps were removed.
- quantcore_circuits.sim_tools.builder.strip_unpaired_joins(result, face_stack, lower_box_height: float) dict[str, int]¶
Remove the TSVs and bumps that have no face to land on in
face_stack(KQC’s rule: a face’s TSVs go to the other side of its substrate, its bumps across the vacuum gap): KQC would run them as PEC to the top or bottom of the simulation box, a short to the outer boundary. Returns{"<face>_<layer>": shapes removed}.
- quantcore_circuits.sim_tools.builder.vertex_contact_patches(result, box: kqcircuits.pya_resolver.pya.DBox, faces, size: float = CONTACT_PATCH_UM) dict[str, list[kqcircuits.pya_resolver.pya.DBox]]¶
{face: [patch boxes]}joining metal pieces that touch at a single point insidebox.KQC decides nets with
Region.interacting, which counts a point contact (a polygon vertex on another piece’s boundary) as connected; Q3D’sAutoIdentifyNetsdoes not, splits the KQC net and stops with “Object … in Net ‘Net1’ and object … in Net ‘…’ are touching”. Typical source: junction metal (a Sim pad, a fab junction window) drawn exactly up to a curved island edge, e.g. a neighbour Flipmon’s trilayer window on its disc. Asizeµm square ofbase_metal_additioncentred on the contact makes the join an overlap, so AEDT agrees with KQC’s nets (it only adds metal where KQC already counted the pieces as one conductor). A patch that would also touch a third piece is left out.
- quantcore_circuits.sim_tools.builder.ALL_ANALYSES¶
- quantcore_circuits.sim_tools.builder.CAPACITANCE_ANALYSES¶
- quantcore_circuits.sim_tools.builder.CHIP_GROUP = 'chip'¶
- quantcore_circuits.sim_tools.builder.CONTACT_PATCH_UM = 0.5¶
- quantcore_circuits.sim_tools.builder.DRIVEN_ANALYSES¶
- quantcore_circuits.sim_tools.builder.EDGE_GAP_EXTENSION_UM = 1.0¶
- quantcore_circuits.sim_tools.builder.EDGE_SHIFT_STEP_UM = 2.0¶
- quantcore_circuits.sim_tools.builder.EIGENMODE_ANALYSES¶
- quantcore_circuits.sim_tools.builder.FACE_METAL_MARGIN_UM = 400.0¶
- quantcore_circuits.sim_tools.builder.FACE_ORDER = ('1b1', '1t1', '2b1', '2t1')¶
- quantcore_circuits.sim_tools.builder.GDS_MAX_POINTS = 4000¶
- quantcore_circuits.sim_tools.builder.JJ_AXIS_REACH_UM = 120.0¶
- quantcore_circuits.sim_tools.builder.JJ_PORT_MAX_EDGE_UM = 20.0¶
- quantcore_circuits.sim_tools.builder.JJ_PORT_WIDTH_UM = 10.0¶
- quantcore_circuits.sim_tools.builder.JJ_SHEET_CLEARANCE_UM = 1.0¶
- quantcore_circuits.sim_tools.builder.KQC_EDGE_TOL_UM = 0.007¶
- quantcore_circuits.sim_tools.builder.LINE_PORT_MAX_ANGLE_DEG = 80.0¶
- quantcore_circuits.sim_tools.builder.LINE_PORT_STRAIGHT_SIN = 0.002¶
- quantcore_circuits.sim_tools.builder.LINE_PORT_WALK_UM = 500.0¶
- quantcore_circuits.sim_tools.builder.SIM_SMOOTH_UM = 0.05¶
- quantcore_circuits.sim_tools.builder.TSV_JOIN_OVERLAP_UM = 0.5¶