reference_18layer module#

18-layer reference substrate, transcribed from a production fabrication drawing.

Ground truth#

The stackup, copper weights, impedance table, drill charts, backdrill charts and fabrication notes come from the fabrication drawing of a production FPGA evaluation board: 18 copper layers on Elite Material EM-890, 65.83 mil finished, built to IPC-6012 class 2 and inspected to IPC-A-600 class 2. The drawing itself is not part of this package; its numbers are transcribed here row by row, and each constant says which table it comes from.

The drawing gives no dielectric constant, loss tangent, via pad size or general design rule. The section “Design values” below gives each of those and the method it comes from.

Unit conversions#

JITX is millimetres throughout. The drawing is in mils, so every thickness, width, gap and drill size is converted at 0.0254 mm per mil (mil()). Thicknesses are the drawing’s finished values: the outer layers are its “0.5 oz copper plus plating” row at 2.35 mil, not the 0.5 oz foil weight. Drill sizes are finished sizes (drawing note 19).

What JITX cannot hold#

Drawing requirements with no field in the API, recorded here only:

  • Copper weight and foil class. Conductor has a thickness and no weight or foil type; the foil class (STD, H-VLP, RTF) is in each copper material’s name and docstring. The drawing states no roughness, so roughness is left unset.

  • Minimum copper weight of 0.5 oz on every layer, 100% electrical test, UL 94V-0 rating, and the IPC class.

  • Finish: selective hard gold flash, 2 to 10 microinches over 125 microinches minimum nickel; hard gold edge fingers, 30 microinches gold over 150 microinches nickel minimum.

  • Bake at 225 degrees for 4 hours after fabrication.

  • Copper thieving: none on the top layer in the BGA area or under text; 30 mil square pads at 50 mil spacing on internal layers, 150 mil clear of copper features.

  • Artwork rotated 10 degrees on the working panel against fiber-weave skew.

  • Via fill material. Every via drill of 15.0 mil and under is filled with non-conductive epoxy, planarized and plated over, at least 0.0007 in of plating on the surface, with via-in-pad wrap plating per IPC-6012. Via.filled is a boolean.

  • Backdrill must-not-cut layer and manufacturing stub length. Each backdrill chart names the signal layer the backdrill must not cut and an 8.0 mil manufacturing stub. Backdrill holds diameters only; the must-not-cut layer is the via’s own end layer, and the stub length is in the via docstrings.

  • Drill tolerances: +2.0 mil / minus the full drill size on via drills.

  • Thickness tolerance. The drawing’s only thickness tolerance is at the edge fingers: 1.57 mm +/- 0.127 mm (0.062 in +/- 0.005 in) over plating. It gives none on the 65.83 mil stackup total. Material.thickness is a scalar.

  • Impedance tolerance. The impedance table gives targets and widths only.

  • The 87 ohm “FPGA differential neck width” row names a neck geometry with no parent pair; see DRS_87_Neck.

Design values#

  • Dk and Df. Elite Material’s EM-890 datasheet (EM890_DATASHEET) gives Dk and Df at 10 GHz at two resin contents, 55% and 70%, and no per-glass-style table. Each prepreg takes the value linearly interpolated at its resin content from the drawing (RC71% is extrapolated 1 point past the datasheet’s 70%). The drawing gives no resin content for the cores, so they take the datasheet’s 55% column. See em890_10ghz().

  • Soldermask Dk 3.8 and Df 0.02, typical of LPI soldermask.

  • Effective permittivity. Stripline: the mean of the two dielectrics’ Dk, the substrate-modeler skill’s mixed-dielectric rule. Outer microstrip: the quasi-static closed form in Pozar, Microwave Engineering, 4th ed., section 3.8, with soldermask left out.

  • Insertion loss: dielectric loss at 10 GHz, Pozar 4th ed. section 3.1 for stripline and section 3.8 for microstrip.

  • Clearance: 2x the trace width single-ended and 4x differential, except the 87 ohm FPGA neck, whose clearance is its own 2.8 mil pair gap so it fits between the FPGA’s vias (see DRS_87_Neck), and the ball-field structure below.

  • Ball-field structure (DRS_85_FIELD): a narrower form of DIFF-85 for the segment of a pair’s route inside a 0.92 mm ball field, from another Versal board’s breakout at that pitch (see “Ball-field geometry” in the source). The field pair comes to about 85 ohm on this stackup (see DRS_85_FIELD).

  • Uncoupled regions. The drawing gives no uncoupled geometry, but a pair splits at its pads, and without an uncoupled region JITX reports the split legs as “Missing routing structure”. Each differential structure’s uncoupled region keeps the coupled width on the same layers, with the differential clearance (each leg is still half of a pair), and declares half the differential target as its impedance. On the inner layers that value sits within 3 ohm of the drawing’s single-ended rows at the same width, interpolated linearly between the two nearest rows (extrapolated for the 75 and 100 ohm widths, which fall outside them). See _uncoupled().

  • Reference-plane width: 3x the dielectric height between the line and each plane, the substrate-modeler skill’s default.

  • Via pad diameters: the finished hole plus twice IPC-2221B’s 0.050 mm minimum external annular ring (section 9.1.1). A removed unused pad (note 9) is modeled at the hole size.

  • Tenting. Every via is filled and plated over (note 18), so tented.

  • Via type per structure. The drawing names no drilling method for its blind vias, and the substrate laser drills every one: through one prepreg (TOP to L2, L17 to BOTTOM) and two dielectrics deep (TOP to L3, L16 to BOTTOM), as a production FPGA evaluation board with this layer order laser drills its TOP to L3 span. That is a design choice; controlled-depth mechanical drilling would also reach L3. Through and backdrilled vias are mechanical, with a 10.0 mil drill for the backdrilled vias, the TOP to BOTTOM chart’s most used size.

  • Backdrill start pad (two annular rings over the backdrill), soldermask opening (two registrations) and copper clearance (two copper-to-hole spaces).

  • Via delay models. Every via carries a model for each pair of copper layers its plated barrel joins (via_models()): the barrel’s transit time from the middle of one copper to the middle of the other, each dielectric on the way at its own Dk (via_delay()). A backdrilled via’s model covers its plated span. Vias are lossless.

  • Reference18FabRules: the minimum drill and the soldermask registration are the drawing’s; each other field gives its method.

Conductor-index map#

Indices count copper layers only. 0 is TOP and -1 is BOTTOM:

TOP      = 0     L7_SIG3      = 6     L13_GND  = 12
L2_GND   = 1     L8_GND_1OZ   = 7     L14_SIG5 = 13
L3_SIG1  = 2     L9_PWR1_2OZ  = 8     L15_GND  = 14
L4_GND   = 3     L10_PWR2_2OZ = 9     L16_SIG6 = 15
L5_SIG2  = 4     L11_GND_1OZ  = 10    L17_GND  = 16 = -2
L6_GND   = 5     L12_SIG4     = 11    BOTTOM   = 17 = -1

The stackup is not symmetric (the prepreg thicknesses differ between the two halves), so it is an explicit Stackup.

MM_PER_MIL = 0.0254#

Millimetres per mil.

C_MM_PER_S = 299792458000.0#

Speed of light in mm per second.

mil(value)[source]#

value mils in millimetres.

Return type:

float

Parameters:

value (float)

EM890_DATASHEET = 'Elite Material Co., EM-890 / EM-89B datasheet, Rev 2024 July, https://www.emctw.com/upload/website/item/EM-890%20Datasheet%2020240716_24081910973.pdf'#

cavity resonator at 10 GHz, C-24/23/50.

Type:

Source of the EM-890 Dk and Df

EM890_10GHZ: tuple[tuple[float, float, float], ...] = ((0.55, 3.4, 0.0043), (0.7, 3.0, 0.0036))#

(resin content, Dk, Df) at 10 GHz, the two columns of EM890_DATASHEET.

em890_10ghz(resin_content)[source]#

Dk and Df at 10 GHz for EM-890 at resin_content (0 to 1), linear in resin content through the datasheet’s two points (the datasheet has no per-glass-style table).

Return type:

tuple[float, float]

Parameters:

resin_content (float)

class Soldermask(*, name=None, thickness=None, representing=None)[source]#

Bases: Dielectric

Soldermask, “SOLDERMASK_PSR4000_MPHF” in the stackup table, 1.3 mil.

Dk 3.8 and Df 0.02, typical of LPI soldermask.

Parameters:
material_name: ClassVar[str | None] = 'PSR-4000 MP-HF soldermask'#

Name of the material. If not specified, the name of the class is used.

dielectric_coefficient: ClassVar[float | None] = 3.8#

Dielectric constant, the Dk of a datasheet (relative permittivity).

loss_tangent: ClassVar[float | None] = 0.02#

Loss tangent, the Df (dissipation factor) of a datasheet.

class EM890Prepreg1035RC69(*, name=None, thickness=None, representing=None)[source]#

Bases: Dielectric

“EM-890_PP_1035(RC69%)X1”: one ply of 1035 glass prepreg at 69% resin.

Dk and Df: em890_10ghz() at 69%.

Parameters:
material_name: ClassVar[str | None] = 'EM-890 prepreg 1035 RC69%'#

Name of the material. If not specified, the name of the class is used.

dielectric_coefficient: ClassVar[float | None] = 3.026666666666667#

Dielectric constant, the Dk of a datasheet (relative permittivity).

loss_tangent: ClassVar[float | None] = 0.0036466666666666665#

Loss tangent, the Df (dissipation factor) of a datasheet.

class EM890Prepreg1035RC71(*, name=None, thickness=None, representing=None)[source]#

Bases: Dielectric

“EM-890_PP_1035(RC71%)X2”: two plies of 1035 glass prepreg at 71% resin.

Dk and Df: em890_10ghz() at 71%, one point past the datasheet’s 70% column.

Parameters:
material_name: ClassVar[str | None] = 'EM-890 prepreg 1035 RC71% x2'#

Name of the material. If not specified, the name of the class is used.

dielectric_coefficient: ClassVar[float | None] = 2.973333333333333#

Dielectric constant, the Dk of a datasheet (relative permittivity).

loss_tangent: ClassVar[float | None] = 0.003553333333333333#

Loss tangent, the Df (dissipation factor) of a datasheet.

class EM890Prepreg1078RC63(*, name=None, thickness=None, representing=None)[source]#

Bases: Dielectric

“EM-890_PP_1078(RC63%)X1”: one ply of 1078 glass prepreg at 63% resin.

Dk and Df: em890_10ghz() at 63%.

Parameters:
material_name: ClassVar[str | None] = 'EM-890 prepreg 1078 RC63%'#

Name of the material. If not specified, the name of the class is used.

dielectric_coefficient: ClassVar[float | None] = 3.1866666666666665#

Dielectric constant, the Dk of a datasheet (relative permittivity).

loss_tangent: ClassVar[float | None] = 0.003926666666666667#

Loss tangent, the Df (dissipation factor) of a datasheet.

class EM890Core1078(*, name=None, thickness=None, representing=None)[source]#

Bases: Dielectric

“EM-890_CORE_1078X1”: core of one ply of 1078 glass.

Dk and Df: the datasheet’s 55% column.

Parameters:
material_name: ClassVar[str | None] = 'EM-890 core 1078'#

Name of the material. If not specified, the name of the class is used.

dielectric_coefficient: ClassVar[float | None] = 3.4#

Dielectric constant, the Dk of a datasheet (relative permittivity).

loss_tangent: ClassVar[float | None] = 0.0043#

Loss tangent, the Df (dissipation factor) of a datasheet.

class EM890Core1035(*, name=None, thickness=None, representing=None)[source]#

Bases: Dielectric

“EM-890_CORE_1035X1”: core of one ply of 1035 glass.

Dk and Df: the datasheet’s 55% column.

Parameters:
material_name: ClassVar[str | None] = 'EM-890 core 1035'#

Name of the material. If not specified, the name of the class is used.

dielectric_coefficient: ClassVar[float | None] = 3.4#

Dielectric constant, the Dk of a datasheet (relative permittivity).

loss_tangent: ClassVar[float | None] = 0.0043#

Loss tangent, the Df (dissipation factor) of a datasheet.

class OuterCopper(*, name=None, thickness=None, representing=None)[source]#

Bases: Conductor

“0.5OZ_STD_COPPER_+_PLATING”: 0.5 oz standard foil plus plating, 2.35 mil finished. TOP and BOTTOM.

Parameters:
material_name: ClassVar[str | None] = '0.5 oz STD copper + plating'#

Name of the material. If not specified, the name of the class is used.

class HVLPCopperHalfOz(*, name=None, thickness=None, representing=None)[source]#

Bases: Conductor

“0.5OZ_H-VLP_COPPER”: 0.5 oz H-VLP foil, 0.62 mil. The signal layers and the 0.5 oz ground planes.

Parameters:
material_name: ClassVar[str | None] = '0.5 oz H-VLP copper'#

Name of the material. If not specified, the name of the class is used.

class HVLPCopper1Oz(*, name=None, thickness=None, representing=None)[source]#

Bases: Conductor

“1OZ_H-VLP_COPPER”: 1 oz H-VLP foil, 1.2 mil. L8_GND_1OZ and L11_GND_1OZ.

Parameters:
material_name: ClassVar[str | None] = '1 oz H-VLP copper'#

Name of the material. If not specified, the name of the class is used.

class HVLPCopper2Oz(*, name=None, thickness=None, representing=None)[source]#

Bases: Conductor

“2OZ_H-VLP_COPPER”: 2 oz H-VLP foil, 2.4 mil. L9_PWR1_2OZ.

Parameters:
material_name: ClassVar[str | None] = '2 oz H-VLP copper'#

Name of the material. If not specified, the name of the class is used.

class RTFCopper2Oz(*, name=None, thickness=None, representing=None)[source]#

Bases: Conductor

“2OZ_RTF_COPPER”: 2 oz reverse-treated foil, 2.4 mil. L10_PWR2_2OZ.

Parameters:
material_name: ClassVar[str | None] = '2 oz RTF copper'#

Name of the material. If not specified, the name of the class is used.

class StackupRow(name, material, thickness_mil)[source]#

Bases: object

One row of the drawing’s stackup table.

Parameters:
name: str#

the drawing’s for copper, glass style and neighboring layers for a dielectric.

Type:

Layer name

material: type[Material]#
thickness_mil: float#

Finished thickness from the drawing, in mils.

property thickness: float#

Thickness in mm.

STACKUP_ROWS: tuple[StackupRow, ...] = (StackupRow(name='Soldermask-Top', material=<class 'jitxexamples.substrates.reference_18layer.Soldermask'>, thickness_mil=1.3), StackupRow(name='TOP', material=<class 'jitxexamples.substrates.reference_18layer.OuterCopper'>, thickness_mil=2.35), StackupRow(name='PP 1035 RC69% TOP-L2', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1035RC69'>, thickness_mil=2.32), StackupRow(name='L2_GND', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='Core 1078 L2-L3', material=<class 'jitxexamples.substrates.reference_18layer.EM890Core1078'>, thickness_mil=2.5), StackupRow(name='L3_SIG1', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='PP 1078 RC63% L3-L4', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1078RC63'>, thickness_mil=2.63), StackupRow(name='L4_GND', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='Core 1078 L4-L5', material=<class 'jitxexamples.substrates.reference_18layer.EM890Core1078'>, thickness_mil=2.5), StackupRow(name='L5_SIG2', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='PP 1078 RC63% L5-L6', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1078RC63'>, thickness_mil=2.64), StackupRow(name='L6_GND', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='Core 1078 L6-L7', material=<class 'jitxexamples.substrates.reference_18layer.EM890Core1078'>, thickness_mil=2.5), StackupRow(name='L7_SIG3', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='PP 1078 RC63% L7-L8', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1078RC63'>, thickness_mil=2.62), StackupRow(name='L8_GND_1OZ', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopper1Oz'>, thickness_mil=1.2), StackupRow(name='Core 1035 L8-L9', material=<class 'jitxexamples.substrates.reference_18layer.EM890Core1035'>, thickness_mil=2.0), StackupRow(name='L9_PWR1_2OZ', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopper2Oz'>, thickness_mil=2.4), StackupRow(name='PP 1035 RC71% x2 L9-L10', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1035RC71'>, thickness_mil=4.24), StackupRow(name='L10_PWR2_2OZ', material=<class 'jitxexamples.substrates.reference_18layer.RTFCopper2Oz'>, thickness_mil=2.4), StackupRow(name='Core 1035 L10-L11', material=<class 'jitxexamples.substrates.reference_18layer.EM890Core1035'>, thickness_mil=2.0), StackupRow(name='L11_GND_1OZ', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopper1Oz'>, thickness_mil=1.2), StackupRow(name='PP 1078 RC63% L11-L12', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1078RC63'>, thickness_mil=2.64), StackupRow(name='L12_SIG4', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='Core 1078 L12-L13', material=<class 'jitxexamples.substrates.reference_18layer.EM890Core1078'>, thickness_mil=2.5), StackupRow(name='L13_GND', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='PP 1078 RC63% L13-L14', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1078RC63'>, thickness_mil=2.73), StackupRow(name='L14_SIG5', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='Core 1078 L14-L15', material=<class 'jitxexamples.substrates.reference_18layer.EM890Core1078'>, thickness_mil=2.5), StackupRow(name='L15_GND', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='PP 1078 RC63% L15-L16', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1078RC63'>, thickness_mil=2.75), StackupRow(name='L16_SIG6', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='Core 1078 L16-L17', material=<class 'jitxexamples.substrates.reference_18layer.EM890Core1078'>, thickness_mil=2.5), StackupRow(name='L17_GND', material=<class 'jitxexamples.substrates.reference_18layer.HVLPCopperHalfOz'>, thickness_mil=0.62), StackupRow(name='PP 1035 RC69% L17-BOTTOM', material=<class 'jitxexamples.substrates.reference_18layer.EM890Prepreg1035RC69'>, thickness_mil=2.32), StackupRow(name='BOTTOM', material=<class 'jitxexamples.substrates.reference_18layer.OuterCopper'>, thickness_mil=2.35), StackupRow(name='Soldermask-Bottom', material=<class 'jitxexamples.substrates.reference_18layer.Soldermask'>, thickness_mil=1.3))#

The drawing’s stackup table, top to bottom, thicknesses in mils.

The stackup and the via delay models both read this table, so the two cannot drift apart.

stackup_span(start, stop)[source]#

The rows from copper layer start through copper layer stop, both included, top to bottom. Indices count copper layers only and may be negative, as for a via.

Return type:

tuple[StackupRow, ...]

Parameters:
via_delay(start, stop)[source]#

First-order delay in seconds of a via barrel from the middle of copper layer start to the middle of copper layer stop. Each dielectric between contributes its thickness plus half of each copper beside it, at its own Dk: the sum of D * sqrt(Dk) / c.

Return type:

float

Parameters:
via_models(start, stop)[source]#

A model for every pair of copper layers a via’s plated barrel joins, from copper layer start to stop (negative counts from BOTTOM): via_delay() between the two, and no loss. A route may enter and leave the via on any two layers it spans, so every pair has a model.

Return type:

dict[tuple[int, int], PinModel]

Parameters:
class Reference18Stackup[source]#

Bases: Stackup

18 copper layers, 17 dielectrics and 2 soldermask layers: 37 entries.

Thickness accounting, in mils, against the drawing’s TOTAL THICKNESS:

soldermask         2 x 1.30           =  2.60
outer copper       2 x 2.35           =  4.70
0.5 oz H-VLP      12 x 0.62           =  7.44
1 oz H-VLP         2 x 1.20           =  2.40
2 oz H-VLP and RTF 2 x 2.40           =  4.80
PP 1035 RC69%      2 x 2.32           =  4.64
PP 1078 RC63%      2.63 + 2.64 + 2.62
                   + 2.64 + 2.73 + 2.75 = 16.01
PP 1035 RC71% x2   1 x 4.24           =  4.24
core 1078          6 x 2.50           = 15.00
core 1035          2 x 2.00           =  4.00
                              total   = 65.83 mil (drawing: 65.83)
name: str | None = '18-layer reference'#
layers = [Soldermask(name='Soldermask-Top', thickness=0.03302), OuterCopper(name='TOP', thickness=0.05969), EM890Prepreg1035RC69(name='PP 1035 RC69% TOP-L2', thickness=0.058927999999999994), HVLPCopperHalfOz(name='L2_GND', thickness=0.015747999999999998), EM890Core1078(name='Core 1078 L2-L3', thickness=0.0635), HVLPCopperHalfOz(name='L3_SIG1', thickness=0.015747999999999998), EM890Prepreg1078RC63(name='PP 1078 RC63% L3-L4', thickness=0.066802), HVLPCopperHalfOz(name='L4_GND', thickness=0.015747999999999998), EM890Core1078(name='Core 1078 L4-L5', thickness=0.0635), HVLPCopperHalfOz(name='L5_SIG2', thickness=0.015747999999999998), EM890Prepreg1078RC63(name='PP 1078 RC63% L5-L6', thickness=0.067056), HVLPCopperHalfOz(name='L6_GND', thickness=0.015747999999999998), EM890Core1078(name='Core 1078 L6-L7', thickness=0.0635), HVLPCopperHalfOz(name='L7_SIG3', thickness=0.015747999999999998), EM890Prepreg1078RC63(name='PP 1078 RC63% L7-L8', thickness=0.066548), HVLPCopper1Oz(name='L8_GND_1OZ', thickness=0.030479999999999997), EM890Core1035(name='Core 1035 L8-L9', thickness=0.0508), HVLPCopper2Oz(name='L9_PWR1_2OZ', thickness=0.06095999999999999), EM890Prepreg1035RC71(name='PP 1035 RC71% x2 L9-L10', thickness=0.107696), RTFCopper2Oz(name='L10_PWR2_2OZ', thickness=0.06095999999999999), EM890Core1035(name='Core 1035 L10-L11', thickness=0.0508), HVLPCopper1Oz(name='L11_GND_1OZ', thickness=0.030479999999999997), EM890Prepreg1078RC63(name='PP 1078 RC63% L11-L12', thickness=0.067056), HVLPCopperHalfOz(name='L12_SIG4', thickness=0.015747999999999998), EM890Core1078(name='Core 1078 L12-L13', thickness=0.0635), HVLPCopperHalfOz(name='L13_GND', thickness=0.015747999999999998), EM890Prepreg1078RC63(name='PP 1078 RC63% L13-L14', thickness=0.069342), HVLPCopperHalfOz(name='L14_SIG5', thickness=0.015747999999999998), EM890Core1078(name='Core 1078 L14-L15', thickness=0.0635), HVLPCopperHalfOz(name='L15_GND', thickness=0.015747999999999998), EM890Prepreg1078RC63(name='PP 1078 RC63% L15-L16', thickness=0.06985), HVLPCopperHalfOz(name='L16_SIG6', thickness=0.015747999999999998), EM890Core1078(name='Core 1078 L16-L17', thickness=0.0635), HVLPCopperHalfOz(name='L17_GND', thickness=0.015747999999999998), EM890Prepreg1035RC69(name='PP 1035 RC69% L17-BOTTOM', thickness=0.058927999999999994), OuterCopper(name='BOTTOM', thickness=0.05969), Soldermask(name='Soldermask-Bottom', thickness=0.03302)]#
IPC_MIN_ANNULAR_RING = 0.05#

IPC-2221B section 9.1.1 minimum external annular ring, in mm. Every via pad is the hole plus two of these.

BACKDRILL_OVERSIZE_MIL = 6.0#

“BACKDRILL SIZE IS DRILL+6 MIL”.

Type:

Backdrill charts’ note

SOLDER_MASK_REGISTRATION = 0.0508#

soldermask registration within diametrical true position of +/- 0.002 in.

Type:

Drawing note 10

class Reference18FabRules[source]#

Bases: FabricationConstraints

The 19 fields JITX requires. Only the four min_copper_* rules are engine-enforced.

From the drawing: min_drill_diameter (6.0 mil, the smallest drill on any drill chart) and solder_mask_registration (note 10). Every other field gives its method on its line. Capability limits JITX has no field for: blind vias two dielectrics deep need a laser that reaches L3 or L16 through 5.44 mil of PP 1035, L2 or L17 copper and 1078 core under the outer foil (stackup table), under the 6.9 mil drill, so under 1:1 before the foil; backdrilled depths need controlled-depth drilling; and note 20 says “VENDOR IS REQUIRED TO SELECT TOOLING FOR OVERDRILLING”.

min_copper_width: float = 0.06604#

Minimum permissible copper width. This constraint will be enforced by the engine for generated copper shapes and will take precedence over other constraints and rules, such as trace width.

min_copper_copper_space: float = 0.07111999999999999#

Minimum permissible copper-to-copper spacing. This constraint will be enforced by the engine for generated copper shapes and will take precedence over other constraints and rules, such as clearance.

min_copper_hole_space: float = 0.07619999999999999#

Minimum permissible copper-to-hole spacing. This constraint will be enforced by the engine for generated copper shapes and will take precedence over other constraints and rules, such as clearance.

min_copper_edge_space: float = 0.254#

Minimum permissible copper-to-board-edge spacing. This constraint will be enforced by the engine for generated copper shapes and will take precedence over other constraints and rules, such as clearance.

min_annular_ring: float = 0.05#

Minimum annular ring around a hole or via.

min_drill_diameter: float = 0.15239999999999998#

Minimum diameter of a hole either in a pad or a via.

min_hole_to_hole: float = 0.17112#

Minimum distance between two holes, such as through-hole pads or vias.

min_pitch_leaded: float = 0.3235199999999999#

Minimum distance between pad centers for leaded packages.

min_pitch_bga: float = 0.3235199999999999#

Minimum distance between pad centers for BGA packages.

max_board_width: float = 558.8#

Maximum width of a board.

max_board_height: float = 406.4#

Maximum height of a board.

min_silkscreen_width: float = 0.127#

Minimum width of silkscreen.

min_silkscreen_text_height: float = 0.8128#

Minimum height of silkscreen text.

solder_mask_registration: float = 0.0508#

Minimum distance between soldermask and the edge of a copper pad.

min_silk_solder_mask_space: float = 0.0508#

Minimum distance between silkscreen and soldermask features.

min_soldermask_bridge: float = 0.1016#

Minimum distance between two soldermask features.

min_soldermask_opening: float = 0.354#

Minimum size of a soldermask opening shape.

min_pth_pin_solder_clearance: float = 0.0508#

Minimum distance from the outer edge of a through-hole pad to the soldermask.

min_th_pad_expand_outer: float = 0.05#

Minimum through-hole pad expansion on outer layers.

via_pad(hole_mil)[source]#

Pad diameter in mm for a finished hole of hole_mil mils: the hole plus twice IPC-2221B’s minimum external annular ring.

Return type:

float

Parameters:

hole_mil (float)

via_diameter(hole_mil)[source]#

The pad of via_pad(), with unused internal pads removed: drawing note 9, “REMOVE ALL UNUSED PADS FROM INTERNAL LAYERS”. JITX uses nfp on every layer except the start layer when the via has no top backdrill, the stop layer when it has no bottom backdrill, and any intermediate layer with a trace or pour connected. A backdrilled via’s signal layer is its start or stop layer on the backdrilled side, so each backdrilled via sets that layer’s full pad in diameters and no reading of nfp removes it. A removed pad is modeled as a pad the size of the finished hole, leaving no copper ring.

Return type:

ViaDiameter

Parameters:

hole_mil (float)

BACKDRILLED_VIA_HOLE_MIL = 10.0#

10.0 mil, the most used plated size on the TOP to BOTTOM drill chart.

Type:

Drill of the backdrilled through vias

backdrill_for(hole_mil)[source]#

The backdrill for a via of hole_mil mils: diameter drill + 6 mil from the backdrill charts, with a start pad of the diameter plus two IPC rings, a soldermask opening of the diameter plus two registrations and a copper clearance of the diameter plus two min_copper_hole_space.

Return type:

Backdrill

Parameters:

hole_mil (float)

MICROSTRIP_LAYERS: tuple[int, ...] = (0, -1)#

microstrip over L2_GND and under L17_GND.

Type:

TOP and BOTTOM

STRIPLINE_LAYERS: tuple[int, ...] = (2, 4, 6, 11, 13, 15)#

stripline between two ground planes, each with a 1078 core on one side and 1078 RC63% prepreg on the other.

Only SE_50, DRS_87_Neck and DRS_100 cover all six; the drawing strikes the other structures on some of them. A caller filters by structure.layers before using a structure on these layers.

Type:

L3_SIG1, L5_SIG2, L7_SIG3, L12_SIG4, L14_SIG5 and L16_SIG6

REFERENCE_PLANES: dict[int, tuple[int, ...]] = {-1: (-2,), 0: (1,), 2: (1, 3), 4: (3, 5), 6: (5, 7), 11: (10, 12), 13: (12, 14), 15: (14, 16)}#

the adjacent ground layers in the drawing’s layer list. A design supplies ReferencePlanes covering these for any topology on one of these structures.

Type:

Reference planes of each routing layer

LOSS_FREQUENCY_HZ = 10000000000.0#

the datasheet’s Dk and Df frequency.

Type:

Frequency of the insertion loss

reference_plane_widths(layer)[source]#

Desired width of each reference plane of layer: 3x the dielectric height between the line and that plane.

Return type:

dict[int, float]

Parameters:

layer (int)

nearest_plane_height(layer)[source]#

Height in mm from routing layer layer to its nearest reference plane: the dielectric between the line and that plane, the smaller of the two for a stripline. UG863 states LPDDR4 spacing in multiples of this height (“H is the distance to the nearest ground return plane”).

Return type:

float

Parameters:

layer (int)

FIELD_PAIR_WIDTH_MIL = 3.4#

Trace width of a differential pair inside a 0.92 mm ball field.

FIELD_PAIR_GAP_MIL = 3.4#

Edge-to-edge gap of a differential pair inside a 0.92 mm ball field.

FIELD_CLEARANCE_MIL = 3.5#

the reference board’s line-to-via spacing (its line-to-line spacing is 3.4 mil, and a structure holds one clearance for every object, so the larger of the two).

Type:

Clearance inside a 0.92 mm ball field

class Reference18Substrate(*args, **kwargs)[source]#

Bases: Substrate

The stackup, fab rules, the vias the drill charts offer, and one routing structure per impedance-table column.

Every nested Via class is registered on the board. All vias are 15.0 mil or smaller, so all are filled, plated over and allowed in pads (drawing note 18), and tented: a filled, plated-over via has no open hole for soldermask to clear. Every pad is via_diameter(), with unused internal pads removed.

stackup: Stackup = Reference18Stackup()#
constraints: FabricationConstraints = <jitxexamples.substrates.reference_18layer.Reference18FabRules object>#
class MicroVia_TOP_L2(*args, **kwargs)[source]#

Bases: Via

Drill chart “TOP to L2”, 6.0 mil. Laser drilled through one 2.32 mil prepreg.

type: ClassVar[ViaType] = 2#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.15239999999999998#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class MicroVia_L17_BOTTOM(*args, **kwargs)[source]#

Bases: Via

Drill chart “L17 to BOTTOM”, 6.0 mil. Laser drilled through one 2.32 mil prepreg.

type: ClassVar[ViaType] = 2#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = -2#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.15239999999999998#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class BlindVia_TOP_L3_6p9(*args, **kwargs)[source]#

Bases: Via

Drill chart “TOP to L3”, 6.9 mil. Laser drilled through two dielectrics, a design choice.

type: ClassVar[ViaType] = 2#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 2#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.17526#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class BlindVia_TOP_L3_8p0(*args, **kwargs)[source]#

Bases: Via

Drill chart “TOP to L3”, 8.0 mil. Laser drilled through two dielectrics, a design choice.

type: ClassVar[ViaType] = 2#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 2#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.2032#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class BlindVia_TOP_L3_10p0(*args, **kwargs)[source]#

Bases: Via

Drill chart “TOP to L3”, 10.0 mil. Laser drilled through two dielectrics, a design choice.

type: ClassVar[ViaType] = 2#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 2#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class BlindVia_L16_BOTTOM_6p9(*args, **kwargs)[source]#

Bases: Via

Drill chart “L16_SIG6 to BOTTOM”, 6.9 mil. Laser drilled through two dielectrics, a design choice.

type: ClassVar[ViaType] = 2#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 15#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.17526#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(15, 16): <jitx.si.PinModel object>, (15, 17): <jitx.si.PinModel object>, (16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class BlindVia_L16_BOTTOM_10p0(*args, **kwargs)[source]#

Bases: Via

Drill chart “L16_SIG6 to BOTTOM”, 10.0 mil. Laser drilled through two dielectrics, a design choice.

type: ClassVar[ViaType] = 2#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 15#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(15, 16): <jitx.si.PinModel object>, (15, 17): <jitx.si.PinModel object>, (16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class THVia_6p0(*args, **kwargs)[source]#

Bases: Via

Drill chart “TOP to BOTTOM”, 6.0 mil, the smallest plated drill.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.15239999999999998#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (0, 3): <jitx.si.PinModel object>, (0, 4): <jitx.si.PinModel object>, (0, 5): <jitx.si.PinModel object>, (0, 6): <jitx.si.PinModel object>, (0, 7): <jitx.si.PinModel object>, (0, 8): <jitx.si.PinModel object>, (0, 9): <jitx.si.PinModel object>, (0, 10): <jitx.si.PinModel object>, (0, 11): <jitx.si.PinModel object>, (0, 12): <jitx.si.PinModel object>, (0, 13): <jitx.si.PinModel object>, (0, 14): <jitx.si.PinModel object>, (0, 15): <jitx.si.PinModel object>, (0, 16): <jitx.si.PinModel object>, (0, 17): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>, (1, 3): <jitx.si.PinModel object>, (1, 4): <jitx.si.PinModel object>, (1, 5): <jitx.si.PinModel object>, (1, 6): <jitx.si.PinModel object>, (1, 7): <jitx.si.PinModel object>, (1, 8): <jitx.si.PinModel object>, (1, 9): <jitx.si.PinModel object>, (1, 10): <jitx.si.PinModel object>, (1, 11): <jitx.si.PinModel object>, (1, 12): <jitx.si.PinModel object>, (1, 13): <jitx.si.PinModel object>, (1, 14): <jitx.si.PinModel object>, (1, 15): <jitx.si.PinModel object>, (1, 16): <jitx.si.PinModel object>, (1, 17): <jitx.si.PinModel object>, (2, 3): <jitx.si.PinModel object>, (2, 4): <jitx.si.PinModel object>, (2, 5): <jitx.si.PinModel object>, (2, 6): <jitx.si.PinModel object>, (2, 7): <jitx.si.PinModel object>, (2, 8): <jitx.si.PinModel object>, (2, 9): <jitx.si.PinModel object>, (2, 10): <jitx.si.PinModel object>, (2, 11): <jitx.si.PinModel object>, (2, 12): <jitx.si.PinModel object>, (2, 13): <jitx.si.PinModel object>, (2, 14): <jitx.si.PinModel object>, (2, 15): <jitx.si.PinModel object>, (2, 16): <jitx.si.PinModel object>, (2, 17): <jitx.si.PinModel object>, (3, 4): <jitx.si.PinModel object>, (3, 5): <jitx.si.PinModel object>, (3, 6): <jitx.si.PinModel object>, (3, 7): <jitx.si.PinModel object>, (3, 8): <jitx.si.PinModel object>, (3, 9): <jitx.si.PinModel object>, (3, 10): <jitx.si.PinModel object>, (3, 11): <jitx.si.PinModel object>, (3, 12): <jitx.si.PinModel object>, (3, 13): <jitx.si.PinModel object>, (3, 14): <jitx.si.PinModel object>, (3, 15): <jitx.si.PinModel object>, (3, 16): <jitx.si.PinModel object>, (3, 17): <jitx.si.PinModel object>, (4, 5): <jitx.si.PinModel object>, (4, 6): <jitx.si.PinModel object>, (4, 7): <jitx.si.PinModel object>, (4, 8): <jitx.si.PinModel object>, (4, 9): <jitx.si.PinModel object>, (4, 10): <jitx.si.PinModel object>, (4, 11): <jitx.si.PinModel object>, (4, 12): <jitx.si.PinModel object>, (4, 13): <jitx.si.PinModel object>, (4, 14): <jitx.si.PinModel object>, (4, 15): <jitx.si.PinModel object>, (4, 16): <jitx.si.PinModel object>, (4, 17): <jitx.si.PinModel object>, (5, 6): <jitx.si.PinModel object>, (5, 7): <jitx.si.PinModel object>, (5, 8): <jitx.si.PinModel object>, (5, 9): <jitx.si.PinModel object>, (5, 10): <jitx.si.PinModel object>, (5, 11): <jitx.si.PinModel object>, (5, 12): <jitx.si.PinModel object>, (5, 13): <jitx.si.PinModel object>, (5, 14): <jitx.si.PinModel object>, (5, 15): <jitx.si.PinModel object>, (5, 16): <jitx.si.PinModel object>, (5, 17): <jitx.si.PinModel object>, (6, 7): <jitx.si.PinModel object>, (6, 8): <jitx.si.PinModel object>, (6, 9): <jitx.si.PinModel object>, (6, 10): <jitx.si.PinModel object>, (6, 11): <jitx.si.PinModel object>, (6, 12): <jitx.si.PinModel object>, (6, 13): <jitx.si.PinModel object>, (6, 14): <jitx.si.PinModel object>, (6, 15): <jitx.si.PinModel object>, (6, 16): <jitx.si.PinModel object>, (6, 17): <jitx.si.PinModel object>, (7, 8): <jitx.si.PinModel object>, (7, 9): <jitx.si.PinModel object>, (7, 10): <jitx.si.PinModel object>, (7, 11): <jitx.si.PinModel object>, (7, 12): <jitx.si.PinModel object>, (7, 13): <jitx.si.PinModel object>, (7, 14): <jitx.si.PinModel object>, (7, 15): <jitx.si.PinModel object>, (7, 16): <jitx.si.PinModel object>, (7, 17): <jitx.si.PinModel object>, (8, 9): <jitx.si.PinModel object>, (8, 10): <jitx.si.PinModel object>, (8, 11): <jitx.si.PinModel object>, (8, 12): <jitx.si.PinModel object>, (8, 13): <jitx.si.PinModel object>, (8, 14): <jitx.si.PinModel object>, (8, 15): <jitx.si.PinModel object>, (8, 16): <jitx.si.PinModel object>, (8, 17): <jitx.si.PinModel object>, (9, 10): <jitx.si.PinModel object>, (9, 11): <jitx.si.PinModel object>, (9, 12): <jitx.si.PinModel object>, (9, 13): <jitx.si.PinModel object>, (9, 14): <jitx.si.PinModel object>, (9, 15): <jitx.si.PinModel object>, (9, 16): <jitx.si.PinModel object>, (9, 17): <jitx.si.PinModel object>, (10, 11): <jitx.si.PinModel object>, (10, 12): <jitx.si.PinModel object>, (10, 13): <jitx.si.PinModel object>, (10, 14): <jitx.si.PinModel object>, (10, 15): <jitx.si.PinModel object>, (10, 16): <jitx.si.PinModel object>, (10, 17): <jitx.si.PinModel object>, (11, 12): <jitx.si.PinModel object>, (11, 13): <jitx.si.PinModel object>, (11, 14): <jitx.si.PinModel object>, (11, 15): <jitx.si.PinModel object>, (11, 16): <jitx.si.PinModel object>, (11, 17): <jitx.si.PinModel object>, (12, 13): <jitx.si.PinModel object>, (12, 14): <jitx.si.PinModel object>, (12, 15): <jitx.si.PinModel object>, (12, 16): <jitx.si.PinModel object>, (12, 17): <jitx.si.PinModel object>, (13, 14): <jitx.si.PinModel object>, (13, 15): <jitx.si.PinModel object>, (13, 16): <jitx.si.PinModel object>, (13, 17): <jitx.si.PinModel object>, (14, 15): <jitx.si.PinModel object>, (14, 16): <jitx.si.PinModel object>, (14, 17): <jitx.si.PinModel object>, (15, 16): <jitx.si.PinModel object>, (15, 17): <jitx.si.PinModel object>, (16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class THVia_10p0(*args, **kwargs)[source]#

Bases: Via

Drill chart “TOP to BOTTOM”, 10.0 mil, the most used plated drill.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (0, 3): <jitx.si.PinModel object>, (0, 4): <jitx.si.PinModel object>, (0, 5): <jitx.si.PinModel object>, (0, 6): <jitx.si.PinModel object>, (0, 7): <jitx.si.PinModel object>, (0, 8): <jitx.si.PinModel object>, (0, 9): <jitx.si.PinModel object>, (0, 10): <jitx.si.PinModel object>, (0, 11): <jitx.si.PinModel object>, (0, 12): <jitx.si.PinModel object>, (0, 13): <jitx.si.PinModel object>, (0, 14): <jitx.si.PinModel object>, (0, 15): <jitx.si.PinModel object>, (0, 16): <jitx.si.PinModel object>, (0, 17): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>, (1, 3): <jitx.si.PinModel object>, (1, 4): <jitx.si.PinModel object>, (1, 5): <jitx.si.PinModel object>, (1, 6): <jitx.si.PinModel object>, (1, 7): <jitx.si.PinModel object>, (1, 8): <jitx.si.PinModel object>, (1, 9): <jitx.si.PinModel object>, (1, 10): <jitx.si.PinModel object>, (1, 11): <jitx.si.PinModel object>, (1, 12): <jitx.si.PinModel object>, (1, 13): <jitx.si.PinModel object>, (1, 14): <jitx.si.PinModel object>, (1, 15): <jitx.si.PinModel object>, (1, 16): <jitx.si.PinModel object>, (1, 17): <jitx.si.PinModel object>, (2, 3): <jitx.si.PinModel object>, (2, 4): <jitx.si.PinModel object>, (2, 5): <jitx.si.PinModel object>, (2, 6): <jitx.si.PinModel object>, (2, 7): <jitx.si.PinModel object>, (2, 8): <jitx.si.PinModel object>, (2, 9): <jitx.si.PinModel object>, (2, 10): <jitx.si.PinModel object>, (2, 11): <jitx.si.PinModel object>, (2, 12): <jitx.si.PinModel object>, (2, 13): <jitx.si.PinModel object>, (2, 14): <jitx.si.PinModel object>, (2, 15): <jitx.si.PinModel object>, (2, 16): <jitx.si.PinModel object>, (2, 17): <jitx.si.PinModel object>, (3, 4): <jitx.si.PinModel object>, (3, 5): <jitx.si.PinModel object>, (3, 6): <jitx.si.PinModel object>, (3, 7): <jitx.si.PinModel object>, (3, 8): <jitx.si.PinModel object>, (3, 9): <jitx.si.PinModel object>, (3, 10): <jitx.si.PinModel object>, (3, 11): <jitx.si.PinModel object>, (3, 12): <jitx.si.PinModel object>, (3, 13): <jitx.si.PinModel object>, (3, 14): <jitx.si.PinModel object>, (3, 15): <jitx.si.PinModel object>, (3, 16): <jitx.si.PinModel object>, (3, 17): <jitx.si.PinModel object>, (4, 5): <jitx.si.PinModel object>, (4, 6): <jitx.si.PinModel object>, (4, 7): <jitx.si.PinModel object>, (4, 8): <jitx.si.PinModel object>, (4, 9): <jitx.si.PinModel object>, (4, 10): <jitx.si.PinModel object>, (4, 11): <jitx.si.PinModel object>, (4, 12): <jitx.si.PinModel object>, (4, 13): <jitx.si.PinModel object>, (4, 14): <jitx.si.PinModel object>, (4, 15): <jitx.si.PinModel object>, (4, 16): <jitx.si.PinModel object>, (4, 17): <jitx.si.PinModel object>, (5, 6): <jitx.si.PinModel object>, (5, 7): <jitx.si.PinModel object>, (5, 8): <jitx.si.PinModel object>, (5, 9): <jitx.si.PinModel object>, (5, 10): <jitx.si.PinModel object>, (5, 11): <jitx.si.PinModel object>, (5, 12): <jitx.si.PinModel object>, (5, 13): <jitx.si.PinModel object>, (5, 14): <jitx.si.PinModel object>, (5, 15): <jitx.si.PinModel object>, (5, 16): <jitx.si.PinModel object>, (5, 17): <jitx.si.PinModel object>, (6, 7): <jitx.si.PinModel object>, (6, 8): <jitx.si.PinModel object>, (6, 9): <jitx.si.PinModel object>, (6, 10): <jitx.si.PinModel object>, (6, 11): <jitx.si.PinModel object>, (6, 12): <jitx.si.PinModel object>, (6, 13): <jitx.si.PinModel object>, (6, 14): <jitx.si.PinModel object>, (6, 15): <jitx.si.PinModel object>, (6, 16): <jitx.si.PinModel object>, (6, 17): <jitx.si.PinModel object>, (7, 8): <jitx.si.PinModel object>, (7, 9): <jitx.si.PinModel object>, (7, 10): <jitx.si.PinModel object>, (7, 11): <jitx.si.PinModel object>, (7, 12): <jitx.si.PinModel object>, (7, 13): <jitx.si.PinModel object>, (7, 14): <jitx.si.PinModel object>, (7, 15): <jitx.si.PinModel object>, (7, 16): <jitx.si.PinModel object>, (7, 17): <jitx.si.PinModel object>, (8, 9): <jitx.si.PinModel object>, (8, 10): <jitx.si.PinModel object>, (8, 11): <jitx.si.PinModel object>, (8, 12): <jitx.si.PinModel object>, (8, 13): <jitx.si.PinModel object>, (8, 14): <jitx.si.PinModel object>, (8, 15): <jitx.si.PinModel object>, (8, 16): <jitx.si.PinModel object>, (8, 17): <jitx.si.PinModel object>, (9, 10): <jitx.si.PinModel object>, (9, 11): <jitx.si.PinModel object>, (9, 12): <jitx.si.PinModel object>, (9, 13): <jitx.si.PinModel object>, (9, 14): <jitx.si.PinModel object>, (9, 15): <jitx.si.PinModel object>, (9, 16): <jitx.si.PinModel object>, (9, 17): <jitx.si.PinModel object>, (10, 11): <jitx.si.PinModel object>, (10, 12): <jitx.si.PinModel object>, (10, 13): <jitx.si.PinModel object>, (10, 14): <jitx.si.PinModel object>, (10, 15): <jitx.si.PinModel object>, (10, 16): <jitx.si.PinModel object>, (10, 17): <jitx.si.PinModel object>, (11, 12): <jitx.si.PinModel object>, (11, 13): <jitx.si.PinModel object>, (11, 14): <jitx.si.PinModel object>, (11, 15): <jitx.si.PinModel object>, (11, 16): <jitx.si.PinModel object>, (11, 17): <jitx.si.PinModel object>, (12, 13): <jitx.si.PinModel object>, (12, 14): <jitx.si.PinModel object>, (12, 15): <jitx.si.PinModel object>, (12, 16): <jitx.si.PinModel object>, (12, 17): <jitx.si.PinModel object>, (13, 14): <jitx.si.PinModel object>, (13, 15): <jitx.si.PinModel object>, (13, 16): <jitx.si.PinModel object>, (13, 17): <jitx.si.PinModel object>, (14, 15): <jitx.si.PinModel object>, (14, 16): <jitx.si.PinModel object>, (14, 17): <jitx.si.PinModel object>, (15, 16): <jitx.si.PinModel object>, (15, 17): <jitx.si.PinModel object>, (16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

class BackdrilledVia_TOP_L3(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “BOTTOM to L4_GND”, must not cut L3_SIG1.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 2#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {2: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=None, bottom=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588))#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
class BackdrilledVia_TOP_L5(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “BOTTOM to L6_GND”, must not cut L5_SIG2.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 4#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {4: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (0, 3): <jitx.si.PinModel object>, (0, 4): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>, (1, 3): <jitx.si.PinModel object>, (1, 4): <jitx.si.PinModel object>, (2, 3): <jitx.si.PinModel object>, (2, 4): <jitx.si.PinModel object>, (3, 4): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=None, bottom=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588))#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
class BackdrilledVia_TOP_L7(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “BOTTOM to L8_GND_1OZ”, must not cut L7_SIG3.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 6#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {6: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (0, 3): <jitx.si.PinModel object>, (0, 4): <jitx.si.PinModel object>, (0, 5): <jitx.si.PinModel object>, (0, 6): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>, (1, 3): <jitx.si.PinModel object>, (1, 4): <jitx.si.PinModel object>, (1, 5): <jitx.si.PinModel object>, (1, 6): <jitx.si.PinModel object>, (2, 3): <jitx.si.PinModel object>, (2, 4): <jitx.si.PinModel object>, (2, 5): <jitx.si.PinModel object>, (2, 6): <jitx.si.PinModel object>, (3, 4): <jitx.si.PinModel object>, (3, 5): <jitx.si.PinModel object>, (3, 6): <jitx.si.PinModel object>, (4, 5): <jitx.si.PinModel object>, (4, 6): <jitx.si.PinModel object>, (5, 6): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=None, bottom=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588))#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
class BackdrilledVia_TOP_L12(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “BOTTOM to L13_GND”, must not cut L12_SIG4.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 11#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {11: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (0, 3): <jitx.si.PinModel object>, (0, 4): <jitx.si.PinModel object>, (0, 5): <jitx.si.PinModel object>, (0, 6): <jitx.si.PinModel object>, (0, 7): <jitx.si.PinModel object>, (0, 8): <jitx.si.PinModel object>, (0, 9): <jitx.si.PinModel object>, (0, 10): <jitx.si.PinModel object>, (0, 11): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>, (1, 3): <jitx.si.PinModel object>, (1, 4): <jitx.si.PinModel object>, (1, 5): <jitx.si.PinModel object>, (1, 6): <jitx.si.PinModel object>, (1, 7): <jitx.si.PinModel object>, (1, 8): <jitx.si.PinModel object>, (1, 9): <jitx.si.PinModel object>, (1, 10): <jitx.si.PinModel object>, (1, 11): <jitx.si.PinModel object>, (2, 3): <jitx.si.PinModel object>, (2, 4): <jitx.si.PinModel object>, (2, 5): <jitx.si.PinModel object>, (2, 6): <jitx.si.PinModel object>, (2, 7): <jitx.si.PinModel object>, (2, 8): <jitx.si.PinModel object>, (2, 9): <jitx.si.PinModel object>, (2, 10): <jitx.si.PinModel object>, (2, 11): <jitx.si.PinModel object>, (3, 4): <jitx.si.PinModel object>, (3, 5): <jitx.si.PinModel object>, (3, 6): <jitx.si.PinModel object>, (3, 7): <jitx.si.PinModel object>, (3, 8): <jitx.si.PinModel object>, (3, 9): <jitx.si.PinModel object>, (3, 10): <jitx.si.PinModel object>, (3, 11): <jitx.si.PinModel object>, (4, 5): <jitx.si.PinModel object>, (4, 6): <jitx.si.PinModel object>, (4, 7): <jitx.si.PinModel object>, (4, 8): <jitx.si.PinModel object>, (4, 9): <jitx.si.PinModel object>, (4, 10): <jitx.si.PinModel object>, (4, 11): <jitx.si.PinModel object>, (5, 6): <jitx.si.PinModel object>, (5, 7): <jitx.si.PinModel object>, (5, 8): <jitx.si.PinModel object>, (5, 9): <jitx.si.PinModel object>, (5, 10): <jitx.si.PinModel object>, (5, 11): <jitx.si.PinModel object>, (6, 7): <jitx.si.PinModel object>, (6, 8): <jitx.si.PinModel object>, (6, 9): <jitx.si.PinModel object>, (6, 10): <jitx.si.PinModel object>, (6, 11): <jitx.si.PinModel object>, (7, 8): <jitx.si.PinModel object>, (7, 9): <jitx.si.PinModel object>, (7, 10): <jitx.si.PinModel object>, (7, 11): <jitx.si.PinModel object>, (8, 9): <jitx.si.PinModel object>, (8, 10): <jitx.si.PinModel object>, (8, 11): <jitx.si.PinModel object>, (9, 10): <jitx.si.PinModel object>, (9, 11): <jitx.si.PinModel object>, (10, 11): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=None, bottom=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588))#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
class BackdrilledVia_TOP_L14(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “BOTTOM to L15_GND”, must not cut L14_SIG5.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 0#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = 13#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {13: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(0, 1): <jitx.si.PinModel object>, (0, 2): <jitx.si.PinModel object>, (0, 3): <jitx.si.PinModel object>, (0, 4): <jitx.si.PinModel object>, (0, 5): <jitx.si.PinModel object>, (0, 6): <jitx.si.PinModel object>, (0, 7): <jitx.si.PinModel object>, (0, 8): <jitx.si.PinModel object>, (0, 9): <jitx.si.PinModel object>, (0, 10): <jitx.si.PinModel object>, (0, 11): <jitx.si.PinModel object>, (0, 12): <jitx.si.PinModel object>, (0, 13): <jitx.si.PinModel object>, (1, 2): <jitx.si.PinModel object>, (1, 3): <jitx.si.PinModel object>, (1, 4): <jitx.si.PinModel object>, (1, 5): <jitx.si.PinModel object>, (1, 6): <jitx.si.PinModel object>, (1, 7): <jitx.si.PinModel object>, (1, 8): <jitx.si.PinModel object>, (1, 9): <jitx.si.PinModel object>, (1, 10): <jitx.si.PinModel object>, (1, 11): <jitx.si.PinModel object>, (1, 12): <jitx.si.PinModel object>, (1, 13): <jitx.si.PinModel object>, (2, 3): <jitx.si.PinModel object>, (2, 4): <jitx.si.PinModel object>, (2, 5): <jitx.si.PinModel object>, (2, 6): <jitx.si.PinModel object>, (2, 7): <jitx.si.PinModel object>, (2, 8): <jitx.si.PinModel object>, (2, 9): <jitx.si.PinModel object>, (2, 10): <jitx.si.PinModel object>, (2, 11): <jitx.si.PinModel object>, (2, 12): <jitx.si.PinModel object>, (2, 13): <jitx.si.PinModel object>, (3, 4): <jitx.si.PinModel object>, (3, 5): <jitx.si.PinModel object>, (3, 6): <jitx.si.PinModel object>, (3, 7): <jitx.si.PinModel object>, (3, 8): <jitx.si.PinModel object>, (3, 9): <jitx.si.PinModel object>, (3, 10): <jitx.si.PinModel object>, (3, 11): <jitx.si.PinModel object>, (3, 12): <jitx.si.PinModel object>, (3, 13): <jitx.si.PinModel object>, (4, 5): <jitx.si.PinModel object>, (4, 6): <jitx.si.PinModel object>, (4, 7): <jitx.si.PinModel object>, (4, 8): <jitx.si.PinModel object>, (4, 9): <jitx.si.PinModel object>, (4, 10): <jitx.si.PinModel object>, (4, 11): <jitx.si.PinModel object>, (4, 12): <jitx.si.PinModel object>, (4, 13): <jitx.si.PinModel object>, (5, 6): <jitx.si.PinModel object>, (5, 7): <jitx.si.PinModel object>, (5, 8): <jitx.si.PinModel object>, (5, 9): <jitx.si.PinModel object>, (5, 10): <jitx.si.PinModel object>, (5, 11): <jitx.si.PinModel object>, (5, 12): <jitx.si.PinModel object>, (5, 13): <jitx.si.PinModel object>, (6, 7): <jitx.si.PinModel object>, (6, 8): <jitx.si.PinModel object>, (6, 9): <jitx.si.PinModel object>, (6, 10): <jitx.si.PinModel object>, (6, 11): <jitx.si.PinModel object>, (6, 12): <jitx.si.PinModel object>, (6, 13): <jitx.si.PinModel object>, (7, 8): <jitx.si.PinModel object>, (7, 9): <jitx.si.PinModel object>, (7, 10): <jitx.si.PinModel object>, (7, 11): <jitx.si.PinModel object>, (7, 12): <jitx.si.PinModel object>, (7, 13): <jitx.si.PinModel object>, (8, 9): <jitx.si.PinModel object>, (8, 10): <jitx.si.PinModel object>, (8, 11): <jitx.si.PinModel object>, (8, 12): <jitx.si.PinModel object>, (8, 13): <jitx.si.PinModel object>, (9, 10): <jitx.si.PinModel object>, (9, 11): <jitx.si.PinModel object>, (9, 12): <jitx.si.PinModel object>, (9, 13): <jitx.si.PinModel object>, (10, 11): <jitx.si.PinModel object>, (10, 12): <jitx.si.PinModel object>, (10, 13): <jitx.si.PinModel object>, (11, 12): <jitx.si.PinModel object>, (11, 13): <jitx.si.PinModel object>, (12, 13): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=None, bottom=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588))#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
class BackdrilledVia_L3_BOTTOM(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “TOP to L2_GND”, must not cut L3_SIG1.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 2#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {2: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(2, 3): <jitx.si.PinModel object>, (2, 4): <jitx.si.PinModel object>, (2, 5): <jitx.si.PinModel object>, (2, 6): <jitx.si.PinModel object>, (2, 7): <jitx.si.PinModel object>, (2, 8): <jitx.si.PinModel object>, (2, 9): <jitx.si.PinModel object>, (2, 10): <jitx.si.PinModel object>, (2, 11): <jitx.si.PinModel object>, (2, 12): <jitx.si.PinModel object>, (2, 13): <jitx.si.PinModel object>, (2, 14): <jitx.si.PinModel object>, (2, 15): <jitx.si.PinModel object>, (2, 16): <jitx.si.PinModel object>, (2, 17): <jitx.si.PinModel object>, (3, 4): <jitx.si.PinModel object>, (3, 5): <jitx.si.PinModel object>, (3, 6): <jitx.si.PinModel object>, (3, 7): <jitx.si.PinModel object>, (3, 8): <jitx.si.PinModel object>, (3, 9): <jitx.si.PinModel object>, (3, 10): <jitx.si.PinModel object>, (3, 11): <jitx.si.PinModel object>, (3, 12): <jitx.si.PinModel object>, (3, 13): <jitx.si.PinModel object>, (3, 14): <jitx.si.PinModel object>, (3, 15): <jitx.si.PinModel object>, (3, 16): <jitx.si.PinModel object>, (3, 17): <jitx.si.PinModel object>, (4, 5): <jitx.si.PinModel object>, (4, 6): <jitx.si.PinModel object>, (4, 7): <jitx.si.PinModel object>, (4, 8): <jitx.si.PinModel object>, (4, 9): <jitx.si.PinModel object>, (4, 10): <jitx.si.PinModel object>, (4, 11): <jitx.si.PinModel object>, (4, 12): <jitx.si.PinModel object>, (4, 13): <jitx.si.PinModel object>, (4, 14): <jitx.si.PinModel object>, (4, 15): <jitx.si.PinModel object>, (4, 16): <jitx.si.PinModel object>, (4, 17): <jitx.si.PinModel object>, (5, 6): <jitx.si.PinModel object>, (5, 7): <jitx.si.PinModel object>, (5, 8): <jitx.si.PinModel object>, (5, 9): <jitx.si.PinModel object>, (5, 10): <jitx.si.PinModel object>, (5, 11): <jitx.si.PinModel object>, (5, 12): <jitx.si.PinModel object>, (5, 13): <jitx.si.PinModel object>, (5, 14): <jitx.si.PinModel object>, (5, 15): <jitx.si.PinModel object>, (5, 16): <jitx.si.PinModel object>, (5, 17): <jitx.si.PinModel object>, (6, 7): <jitx.si.PinModel object>, (6, 8): <jitx.si.PinModel object>, (6, 9): <jitx.si.PinModel object>, (6, 10): <jitx.si.PinModel object>, (6, 11): <jitx.si.PinModel object>, (6, 12): <jitx.si.PinModel object>, (6, 13): <jitx.si.PinModel object>, (6, 14): <jitx.si.PinModel object>, (6, 15): <jitx.si.PinModel object>, (6, 16): <jitx.si.PinModel object>, (6, 17): <jitx.si.PinModel object>, (7, 8): <jitx.si.PinModel object>, (7, 9): <jitx.si.PinModel object>, (7, 10): <jitx.si.PinModel object>, (7, 11): <jitx.si.PinModel object>, (7, 12): <jitx.si.PinModel object>, (7, 13): <jitx.si.PinModel object>, (7, 14): <jitx.si.PinModel object>, (7, 15): <jitx.si.PinModel object>, (7, 16): <jitx.si.PinModel object>, (7, 17): <jitx.si.PinModel object>, (8, 9): <jitx.si.PinModel object>, (8, 10): <jitx.si.PinModel object>, (8, 11): <jitx.si.PinModel object>, (8, 12): <jitx.si.PinModel object>, (8, 13): <jitx.si.PinModel object>, (8, 14): <jitx.si.PinModel object>, (8, 15): <jitx.si.PinModel object>, (8, 16): <jitx.si.PinModel object>, (8, 17): <jitx.si.PinModel object>, (9, 10): <jitx.si.PinModel object>, (9, 11): <jitx.si.PinModel object>, (9, 12): <jitx.si.PinModel object>, (9, 13): <jitx.si.PinModel object>, (9, 14): <jitx.si.PinModel object>, (9, 15): <jitx.si.PinModel object>, (9, 16): <jitx.si.PinModel object>, (9, 17): <jitx.si.PinModel object>, (10, 11): <jitx.si.PinModel object>, (10, 12): <jitx.si.PinModel object>, (10, 13): <jitx.si.PinModel object>, (10, 14): <jitx.si.PinModel object>, (10, 15): <jitx.si.PinModel object>, (10, 16): <jitx.si.PinModel object>, (10, 17): <jitx.si.PinModel object>, (11, 12): <jitx.si.PinModel object>, (11, 13): <jitx.si.PinModel object>, (11, 14): <jitx.si.PinModel object>, (11, 15): <jitx.si.PinModel object>, (11, 16): <jitx.si.PinModel object>, (11, 17): <jitx.si.PinModel object>, (12, 13): <jitx.si.PinModel object>, (12, 14): <jitx.si.PinModel object>, (12, 15): <jitx.si.PinModel object>, (12, 16): <jitx.si.PinModel object>, (12, 17): <jitx.si.PinModel object>, (13, 14): <jitx.si.PinModel object>, (13, 15): <jitx.si.PinModel object>, (13, 16): <jitx.si.PinModel object>, (13, 17): <jitx.si.PinModel object>, (14, 15): <jitx.si.PinModel object>, (14, 16): <jitx.si.PinModel object>, (14, 17): <jitx.si.PinModel object>, (15, 16): <jitx.si.PinModel object>, (15, 17): <jitx.si.PinModel object>, (16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588), bottom=None)#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
class BackdrilledVia_L5_BOTTOM(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “TOP to L4_GND”, must not cut L5_SIG2.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 4#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {4: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(4, 5): <jitx.si.PinModel object>, (4, 6): <jitx.si.PinModel object>, (4, 7): <jitx.si.PinModel object>, (4, 8): <jitx.si.PinModel object>, (4, 9): <jitx.si.PinModel object>, (4, 10): <jitx.si.PinModel object>, (4, 11): <jitx.si.PinModel object>, (4, 12): <jitx.si.PinModel object>, (4, 13): <jitx.si.PinModel object>, (4, 14): <jitx.si.PinModel object>, (4, 15): <jitx.si.PinModel object>, (4, 16): <jitx.si.PinModel object>, (4, 17): <jitx.si.PinModel object>, (5, 6): <jitx.si.PinModel object>, (5, 7): <jitx.si.PinModel object>, (5, 8): <jitx.si.PinModel object>, (5, 9): <jitx.si.PinModel object>, (5, 10): <jitx.si.PinModel object>, (5, 11): <jitx.si.PinModel object>, (5, 12): <jitx.si.PinModel object>, (5, 13): <jitx.si.PinModel object>, (5, 14): <jitx.si.PinModel object>, (5, 15): <jitx.si.PinModel object>, (5, 16): <jitx.si.PinModel object>, (5, 17): <jitx.si.PinModel object>, (6, 7): <jitx.si.PinModel object>, (6, 8): <jitx.si.PinModel object>, (6, 9): <jitx.si.PinModel object>, (6, 10): <jitx.si.PinModel object>, (6, 11): <jitx.si.PinModel object>, (6, 12): <jitx.si.PinModel object>, (6, 13): <jitx.si.PinModel object>, (6, 14): <jitx.si.PinModel object>, (6, 15): <jitx.si.PinModel object>, (6, 16): <jitx.si.PinModel object>, (6, 17): <jitx.si.PinModel object>, (7, 8): <jitx.si.PinModel object>, (7, 9): <jitx.si.PinModel object>, (7, 10): <jitx.si.PinModel object>, (7, 11): <jitx.si.PinModel object>, (7, 12): <jitx.si.PinModel object>, (7, 13): <jitx.si.PinModel object>, (7, 14): <jitx.si.PinModel object>, (7, 15): <jitx.si.PinModel object>, (7, 16): <jitx.si.PinModel object>, (7, 17): <jitx.si.PinModel object>, (8, 9): <jitx.si.PinModel object>, (8, 10): <jitx.si.PinModel object>, (8, 11): <jitx.si.PinModel object>, (8, 12): <jitx.si.PinModel object>, (8, 13): <jitx.si.PinModel object>, (8, 14): <jitx.si.PinModel object>, (8, 15): <jitx.si.PinModel object>, (8, 16): <jitx.si.PinModel object>, (8, 17): <jitx.si.PinModel object>, (9, 10): <jitx.si.PinModel object>, (9, 11): <jitx.si.PinModel object>, (9, 12): <jitx.si.PinModel object>, (9, 13): <jitx.si.PinModel object>, (9, 14): <jitx.si.PinModel object>, (9, 15): <jitx.si.PinModel object>, (9, 16): <jitx.si.PinModel object>, (9, 17): <jitx.si.PinModel object>, (10, 11): <jitx.si.PinModel object>, (10, 12): <jitx.si.PinModel object>, (10, 13): <jitx.si.PinModel object>, (10, 14): <jitx.si.PinModel object>, (10, 15): <jitx.si.PinModel object>, (10, 16): <jitx.si.PinModel object>, (10, 17): <jitx.si.PinModel object>, (11, 12): <jitx.si.PinModel object>, (11, 13): <jitx.si.PinModel object>, (11, 14): <jitx.si.PinModel object>, (11, 15): <jitx.si.PinModel object>, (11, 16): <jitx.si.PinModel object>, (11, 17): <jitx.si.PinModel object>, (12, 13): <jitx.si.PinModel object>, (12, 14): <jitx.si.PinModel object>, (12, 15): <jitx.si.PinModel object>, (12, 16): <jitx.si.PinModel object>, (12, 17): <jitx.si.PinModel object>, (13, 14): <jitx.si.PinModel object>, (13, 15): <jitx.si.PinModel object>, (13, 16): <jitx.si.PinModel object>, (13, 17): <jitx.si.PinModel object>, (14, 15): <jitx.si.PinModel object>, (14, 16): <jitx.si.PinModel object>, (14, 17): <jitx.si.PinModel object>, (15, 16): <jitx.si.PinModel object>, (15, 17): <jitx.si.PinModel object>, (16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588), bottom=None)#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
class BackdrilledVia_L7_BOTTOM(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “TOP to L6_GND”, must not cut L7_SIG3.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 6#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {6: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(6, 7): <jitx.si.PinModel object>, (6, 8): <jitx.si.PinModel object>, (6, 9): <jitx.si.PinModel object>, (6, 10): <jitx.si.PinModel object>, (6, 11): <jitx.si.PinModel object>, (6, 12): <jitx.si.PinModel object>, (6, 13): <jitx.si.PinModel object>, (6, 14): <jitx.si.PinModel object>, (6, 15): <jitx.si.PinModel object>, (6, 16): <jitx.si.PinModel object>, (6, 17): <jitx.si.PinModel object>, (7, 8): <jitx.si.PinModel object>, (7, 9): <jitx.si.PinModel object>, (7, 10): <jitx.si.PinModel object>, (7, 11): <jitx.si.PinModel object>, (7, 12): <jitx.si.PinModel object>, (7, 13): <jitx.si.PinModel object>, (7, 14): <jitx.si.PinModel object>, (7, 15): <jitx.si.PinModel object>, (7, 16): <jitx.si.PinModel object>, (7, 17): <jitx.si.PinModel object>, (8, 9): <jitx.si.PinModel object>, (8, 10): <jitx.si.PinModel object>, (8, 11): <jitx.si.PinModel object>, (8, 12): <jitx.si.PinModel object>, (8, 13): <jitx.si.PinModel object>, (8, 14): <jitx.si.PinModel object>, (8, 15): <jitx.si.PinModel object>, (8, 16): <jitx.si.PinModel object>, (8, 17): <jitx.si.PinModel object>, (9, 10): <jitx.si.PinModel object>, (9, 11): <jitx.si.PinModel object>, (9, 12): <jitx.si.PinModel object>, (9, 13): <jitx.si.PinModel object>, (9, 14): <jitx.si.PinModel object>, (9, 15): <jitx.si.PinModel object>, (9, 16): <jitx.si.PinModel object>, (9, 17): <jitx.si.PinModel object>, (10, 11): <jitx.si.PinModel object>, (10, 12): <jitx.si.PinModel object>, (10, 13): <jitx.si.PinModel object>, (10, 14): <jitx.si.PinModel object>, (10, 15): <jitx.si.PinModel object>, (10, 16): <jitx.si.PinModel object>, (10, 17): <jitx.si.PinModel object>, (11, 12): <jitx.si.PinModel object>, (11, 13): <jitx.si.PinModel object>, (11, 14): <jitx.si.PinModel object>, (11, 15): <jitx.si.PinModel object>, (11, 16): <jitx.si.PinModel object>, (11, 17): <jitx.si.PinModel object>, (12, 13): <jitx.si.PinModel object>, (12, 14): <jitx.si.PinModel object>, (12, 15): <jitx.si.PinModel object>, (12, 16): <jitx.si.PinModel object>, (12, 17): <jitx.si.PinModel object>, (13, 14): <jitx.si.PinModel object>, (13, 15): <jitx.si.PinModel object>, (13, 16): <jitx.si.PinModel object>, (13, 17): <jitx.si.PinModel object>, (14, 15): <jitx.si.PinModel object>, (14, 16): <jitx.si.PinModel object>, (14, 17): <jitx.si.PinModel object>, (15, 16): <jitx.si.PinModel object>, (15, 17): <jitx.si.PinModel object>, (16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588), bottom=None)#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
class BackdrilledVia_L12_BOTTOM(*args, **kwargs)[source]#

Bases: Via

Backdrill chart “TOP to L11_GND_1OZ”, must not cut L12_SIG4.

type: ClassVar[ViaType] = 1#

MechanicalDrill or LaserDrill.

Type:

Type of via drilling method

start_layer: int = 11#

Starting layer for the via. Setting this to a layer index other than the top layer allows for creating buried or blind vias.

stop_layer: int = -1#

Ending layer for the via.

diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#

Pad diameter of the via, in mm. Can be overridden on a per-layer basis by diameters.

diameters: Mapping[int | tuple[int, ...], float | ViaDiameter] = {11: 0.354}#

Pad diameters of the via for specific layers. Overrides diameter for the given layers.

Each key is a conductor layer index, or a tuple of indices that share one value. An index counts from 0 at the top layer, or from -1 at the bottom layer when negative, so on a 4-layer board 1 and -3 name the same layer. Every index must exist in the design’s stackup, and each layer may appear in only one key, in either form; translating the design raises an error otherwise. A value may be a ViaDiameter to set a separate pad diameter where non-functional pads are removed (see ViaDiameter.nfp).

>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5}  # 4 layers
hole_diameter: float = 0.254#

Drilled or laser-cut hole diameter for the via, in mm.

filled: bool = True#

Whether the via is filled.

tented: set[Side] | Side | None | bool = True#

Whether the via is tented on Top, Bottom, or both sides. Untented sides will have a solder mask opening.

via_in_pad: bool = True#

Whether the via is allowed to be placed inside a component’s pads.

models: Mapping[tuple[int, int], PinModel] = {(11, 12): <jitx.si.PinModel object>, (11, 13): <jitx.si.PinModel object>, (11, 14): <jitx.si.PinModel object>, (11, 15): <jitx.si.PinModel object>, (11, 16): <jitx.si.PinModel object>, (11, 17): <jitx.si.PinModel object>, (12, 13): <jitx.si.PinModel object>, (12, 14): <jitx.si.PinModel object>, (12, 15): <jitx.si.PinModel object>, (12, 16): <jitx.si.PinModel object>, (12, 17): <jitx.si.PinModel object>, (13, 14): <jitx.si.PinModel object>, (13, 15): <jitx.si.PinModel object>, (13, 16): <jitx.si.PinModel object>, (13, 17): <jitx.si.PinModel object>, (14, 15): <jitx.si.PinModel object>, (14, 16): <jitx.si.PinModel object>, (14, 17): <jitx.si.PinModel object>, (15, 16): <jitx.si.PinModel object>, (15, 17): <jitx.si.PinModel object>, (16, 17): <jitx.si.PinModel object>}#

Specifies delay and loss models for the via, used by signal integrity constraints.

Each entry defines a model for a pair of layers. Layers are specified as layer indices. Models are assumed to be symmetric, so the order of layer indices is arbitrary. It is an error to specify multiple models for the same pair of layers.

It is recommended to not specify models with the same start and end layer. They will currently be ignored by the constraint solver (since path does not travel through the via) but this behavior may change in a future version of JITX. The models are given in terms of the same jitx.si.PinModel object used by components.

>>> class MyVia(Via):
>>>     # Other via parameters...
>>>     models = {
>>>         # Top to bottom layer (through-hole via)
>>>         (0, -1): PinModel(5e-12, 0.05),
>>>         # Top to inner layer 1 (blind via)
>>>         (0, 1): PinModel(2e-12, 0.02),
>>>         # Inner layer 1 to inner layer 2 (buried via)
>>>         (1, 2): PinModel(2e-12, 0.02),
>>>     }

Not all layer pairs need to be specified. If you know that, for example, all usages of a via will go between the top and bottom of the board, then only that model needs to be provided.

Via models can also be generated programmatically using loops. For example, to define models for all layer pairs in a multi-layer board where delay and loss scale linearly with the number of layers traversed:

>>> class MultiModelVia(Via):
>>>     # Other via parameters...
>>>
>>>     # Generate models for all layer pairs
>>>     total_layers = 4
>>>     models = {}
>>>     for i in range(total_layers):
>>>         for j in range(i + 1, total_layers):
>>>             # Model that scales with number of layers
>>>             n_layers = j - i
>>>             models[(i, j)] = PinModel(
>>>                 2e-12 * n_layers,
>>>                 0.05 * n_layers
>>>             )

When models are not provided for a via, placeholder models are automatically inserted. When using placeholder models (models with ideal delay and loss), any timing or loss constraints involving signals through these vias will be flagged as unsatisfied. This is because the placeholder model assumes some arbitrary transmission delay and loss values, which are not set by the user. For accurate signal integrity analysis, provide calculated, measured, or simulated via models for all layer pairs used in your design.

For maximum accuracy, it is recommended to simulate or measure each specific pair of layers rather than using a simplified linear model. The loop approach is most useful for initial designs or when detailed measurements are not yet available.

backdrill: BackdrillSet | Backdrill | None = BackdrillSet(top=Backdrill(diameter=0.4064, startpad_diameter=0.5064, solder_mask_opening=0.508, copper_clearance=0.5588), bottom=None)#

Backdrill specifications. If a Backdrill is used, it will be assumed to be drilled from bottom.

A backdrilled via is drilled through to the backdrilled surface, while its pads still run only from start_layer to stop_layer. So stop_layer sets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and for BackdrillSet(top=...) start_layer sets the depth of the top backdrill in the same way.

>>> class BackdrilledVia(Via):
...     type = ViaType.MechanicalDrill
...     start_layer = Side.Top
...     stop_layer = 2
...     diameter = 0.6
...     hole_diameter = 0.3
...     backdrill = BackdrillSet(
...         bottom=Backdrill(
...             diameter=0.5,
...             startpad_diameter=0.7,
...             solder_mask_opening=0.8,
...             copper_clearance=0.6,
...         )
...     )
SE_40 = RoutingStructure(name='40 ohm single-ended (SE-40)', impedance=<Quantity(40, 'ohm')>, layers={0: Layer(trace_width=0.15239999999999998, clearance=0.30479999999999996, velocity=191921525006.64664, insertion_loss=0.004569770796736285).reference({1: 0.176784}), -1: Layer(trace_width=0.15239999999999998, clearance=0.30479999999999996, velocity=191921525006.64664, insertion_loss=0.004569770796736285).reference({-2: 0.176784}), 2: Layer(trace_width=0.1016, clearance=0.2032, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.1016, clearance=0.2032, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.1016, clearance=0.2032, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.1016, clearance=0.2032, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.1016, clearance=0.2032, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905})})#

TOP and BOTTOM 6.0 mil, L3 to L14 4.0 mil.

Type:

40 ohm single-ended

SE_45 = RoutingStructure(name='45 ohm single-ended (SE-45)', impedance=<Quantity(45, 'ohm')>, layers={0: Layer(trace_width=0.12191999999999999, clearance=0.24383999999999997, velocity=193437480339.33786, insertion_loss=0.004484021993712677).reference({1: 0.176784}), -1: Layer(trace_width=0.12191999999999999, clearance=0.24383999999999997, velocity=193437480339.33786, insertion_loss=0.004484021993712677).reference({-2: 0.176784})})#

TOP and BOTTOM 4.8 mil; every inner entry is struck.

Type:

45 ohm single-ended

SE_46 = RoutingStructure(name='46 ohm single-ended (SE-46)', impedance=<Quantity(46, 'ohm')>, layers={0: Layer(trace_width=0.1143, clearance=0.2286, velocity=193865664766.80066, insertion_loss=0.004459973967525245).reference({1: 0.176784}), 2: Layer(trace_width=0.07874, clearance=0.15748, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.07874, clearance=0.15748, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.07874, clearance=0.15748, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.07874, clearance=0.15748, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.07874, clearance=0.15748, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905})})#

TOP 4.5 mil, L3 to L14 3.1 mil; BOTTOM and L16 struck.

Type:

46 ohm single-ended

SE_50 = RoutingStructure(name='50 ohm single-ended (SE-50)', impedance=<Quantity(50, 'ohm')>, layers={0: Layer(trace_width=0.09652, clearance=0.19304, velocity=194962061196.86017, insertion_loss=0.004398737057584141).reference({1: 0.176784}), -1: Layer(trace_width=0.09652, clearance=0.19304, velocity=194962061196.86017, insertion_loss=0.004398737057584141).reference({-2: 0.176784}), 2: Layer(trace_width=0.07111999999999999, clearance=0.14223999999999998, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.07111999999999999, clearance=0.14223999999999998, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.07111999999999999, clearance=0.14223999999999998, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.07111999999999999, clearance=0.14223999999999998, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.07111999999999999, clearance=0.14223999999999998, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905}), 15: Layer(trace_width=0.07111999999999999, clearance=0.14223999999999998, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({14: 0.20955, 16: 0.1905})})#

TOP and BOTTOM 3.8 mil, all six inner layers 2.8 mil.

Type:

50 ohm single-ended

DRS_75 = DifferentialRoutingStructure(name='75 ohm differential (DIFF-75)', impedance=<Quantity(75, 'ohm')>, layers={2: Layer(trace_width=0.11176, pair_spacing=0.16383, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.11176, pair_spacing=0.16383, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.11176, pair_spacing=0.16383, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.11176, pair_spacing=0.16383, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.11176, pair_spacing=0.16383, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905})}, uncoupled_region=RoutingStructure(name='DIFF-75, uncoupled', impedance=<Quantity(37.5, 'ohm')>, layers={2: Layer(trace_width=0.11176, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.11176, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.11176, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.11176, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.11176, clearance=0.44704, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905})}))#

L3 to L14 4.4/6.45/4.4 mil; outer and L16 struck.

Type:

75 ohm differential

DRS_85 = DifferentialRoutingStructure(name='85 ohm differential (DIFF-85)', impedance=<Quantity(85, 'ohm')>, layers={0: Layer(trace_width=0.1143, pair_spacing=0.18033999999999997, clearance=0.4572, velocity=193865664766.80066, insertion_loss=0.004459973967525245).reference({1: 0.176784}), -1: Layer(trace_width=0.1143, pair_spacing=0.18033999999999997, clearance=0.4572, velocity=193865664766.80066, insertion_loss=0.004459973967525245).reference({-2: 0.176784}), 2: Layer(trace_width=0.09016999999999999, pair_spacing=0.16383, clearance=0.36067999999999995, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.09016999999999999, pair_spacing=0.16383, clearance=0.36067999999999995, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.09016999999999999, pair_spacing=0.16383, clearance=0.36067999999999995, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644})}, uncoupled_region=RoutingStructure(name='DIFF-85, uncoupled', impedance=<Quantity(42.5, 'ohm')>, layers={0: Layer(trace_width=0.1143, clearance=0.4572, velocity=193865664766.80066, insertion_loss=0.004459973967525245).reference({1: 0.176784}), -1: Layer(trace_width=0.1143, clearance=0.4572, velocity=193865664766.80066, insertion_loss=0.004459973967525245).reference({-2: 0.176784}), 2: Layer(trace_width=0.09016999999999999, clearance=0.36067999999999995, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.09016999999999999, clearance=0.36067999999999995, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.09016999999999999, clearance=0.36067999999999995, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644})}))#

TOP and BOTTOM 4.5/7.1/4.5 mil, L3, L5 and L7 3.55/6.45/3.55 mil.

Type:

85 ohm differential

DRS_87_Neck = DifferentialRoutingStructure(name='87 ohm differential FPGA neck (DIFF-87-NECK)', impedance=<Quantity(87, 'ohm')>, layers={2: Layer(trace_width=0.08128, pair_spacing=0.07111999999999999, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.08128, pair_spacing=0.07111999999999999, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.08128, pair_spacing=0.07111999999999999, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.08128, pair_spacing=0.07111999999999999, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.08128, pair_spacing=0.07111999999999999, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905}), 15: Layer(trace_width=0.08128, pair_spacing=0.07111999999999999, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({14: 0.20955, 16: 0.1905})}, uncoupled_region=RoutingStructure(name='DIFF-87-NECK, uncoupled', impedance=<Quantity(43.5, 'ohm')>, layers={2: Layer(trace_width=0.08128, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.08128, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.08128, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.08128, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.08128, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905}), 15: Layer(trace_width=0.08128, clearance=0.07111999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({14: 0.20955, 16: 0.1905})}))#

3.2/2.8/3.2 mil on all six inner layers. A neck structure of its own, as a design applies it to the short necked span under the FPGA. The column names no parent pair, so no structure carries it as a neck-down.

Clearance is the neck’s own 2.8 mil pair gap, not 4x width, so the neck fits between two 10.0 mil vias at the FPGA’s 0.92 mm (36.2 mil) pitch: their full 13.9 mil pads leave a 22.3 mil gap, and the pair with its clearance on both sides needs 2.8 + 3.2 + 2.8 + 3.2 + 2.8 = 14.8 mil. At 4x width (12.8 mil) it would need 34.8 mil.

Type:

The table’s “FPGA differential neck width” column, 87 ohm

DRS_90 = DifferentialRoutingStructure(name='90 ohm differential (DIFF-90)', impedance=<Quantity(90, 'ohm')>, layers={0: Layer(trace_width=0.09906, pair_spacing=0.18033999999999997, clearance=0.39624, velocity=194796135319.28662, insertion_loss=0.004407973335296856).reference({1: 0.176784}), -1: Layer(trace_width=0.09906, pair_spacing=0.18033999999999997, clearance=0.39624, velocity=194796135319.28662, insertion_loss=0.004407973335296856).reference({-2: 0.176784}), 2: Layer(trace_width=0.08128, pair_spacing=0.16383, clearance=0.32512, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.08128, pair_spacing=0.16383, clearance=0.32512, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.08128, pair_spacing=0.16383, clearance=0.32512, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.08128, pair_spacing=0.16383, clearance=0.32512, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905})}, uncoupled_region=RoutingStructure(name='DIFF-90, uncoupled', impedance=<Quantity(45.0, 'ohm')>, layers={0: Layer(trace_width=0.09906, clearance=0.39624, velocity=194796135319.28662, insertion_loss=0.004407973335296856).reference({1: 0.176784}), -1: Layer(trace_width=0.09906, clearance=0.39624, velocity=194796135319.28662, insertion_loss=0.004407973335296856).reference({-2: 0.176784}), 2: Layer(trace_width=0.08128, clearance=0.32512, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.08128, clearance=0.32512, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.08128, clearance=0.32512, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.08128, clearance=0.32512, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905})}))#

TOP and BOTTOM 3.9/7.1/3.9 mil, L3 to L12 3.2/6.45/3.2 mil.

Type:

90 ohm differential

DRS_92 = DifferentialRoutingStructure(name='92 ohm differential (DIFF-92)', impedance=<Quantity(92, 'ohm')>, layers={0: Layer(trace_width=0.09398, pair_spacing=0.18033999999999997, clearance=0.37592, velocity=195131420337.87946, insertion_loss=0.0043893210539338486).reference({1: 0.176784}), -1: Layer(trace_width=0.09398, pair_spacing=0.18033999999999997, clearance=0.37592, velocity=195131420337.87946, insertion_loss=0.0043893210539338486).reference({-2: 0.176784}), 2: Layer(trace_width=0.07747, pair_spacing=0.16383, clearance=0.30988, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.07747, pair_spacing=0.16383, clearance=0.30988, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.07747, pair_spacing=0.16383, clearance=0.30988, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.07747, pair_spacing=0.16383, clearance=0.30988, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905})}, uncoupled_region=RoutingStructure(name='DIFF-92, uncoupled', impedance=<Quantity(46.0, 'ohm')>, layers={0: Layer(trace_width=0.09398, clearance=0.37592, velocity=195131420337.87946, insertion_loss=0.0043893210539338486).reference({1: 0.176784}), -1: Layer(trace_width=0.09398, clearance=0.37592, velocity=195131420337.87946, insertion_loss=0.0043893210539338486).reference({-2: 0.176784}), 2: Layer(trace_width=0.07747, clearance=0.30988, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.07747, clearance=0.30988, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.07747, clearance=0.30988, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.07747, clearance=0.30988, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905})}))#

TOP and BOTTOM 3.7/7.1/3.7 mil, L3 to L12 3.05/6.45/3.05 mil.

Type:

92 ohm differential

DRS_100 = DifferentialRoutingStructure(name='100 ohm differential (DIFF-100)', impedance=<Quantity(100, 'ohm')>, layers={0: Layer(trace_width=0.07619999999999999, pair_spacing=0.18033999999999997, clearance=0.30479999999999996, velocity=196426565242.89322, insertion_loss=0.004317690987297057).reference({1: 0.176784}), -1: Layer(trace_width=0.07619999999999999, pair_spacing=0.18033999999999997, clearance=0.30479999999999996, velocity=196426565242.89322, insertion_loss=0.004317690987297057).reference({-2: 0.176784}), 2: Layer(trace_width=0.06604, pair_spacing=0.16891, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.06604, pair_spacing=0.16891, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.06604, pair_spacing=0.16891, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.06604, pair_spacing=0.16891, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.06604, pair_spacing=0.16891, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905}), 15: Layer(trace_width=0.06604, pair_spacing=0.16891, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({14: 0.20955, 16: 0.1905})}, uncoupled_region=RoutingStructure(name='DIFF-100, uncoupled', impedance=<Quantity(50.0, 'ohm')>, layers={0: Layer(trace_width=0.07619999999999999, clearance=0.30479999999999996, velocity=196426565242.89322, insertion_loss=0.004317690987297057).reference({1: 0.176784}), -1: Layer(trace_width=0.07619999999999999, clearance=0.30479999999999996, velocity=196426565242.89322, insertion_loss=0.004317690987297057).reference({-2: 0.176784}), 2: Layer(trace_width=0.06604, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.06604, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.06604, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644}), 11: Layer(trace_width=0.06604, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({10: 0.201168, 12: 0.1905}), 13: Layer(trace_width=0.06604, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({12: 0.208026, 14: 0.1905}), 15: Layer(trace_width=0.06604, clearance=0.26416, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({14: 0.20955, 16: 0.1905})}))#

TOP and BOTTOM 3.0/7.1/3.0 mil, inner 2.6/6.65/2.6 mil.

Type:

100 ohm differential

DRS_85_FIELD = DifferentialRoutingStructure(name='DIFF-85 inside a 0.92 mm ball field', impedance=<Quantity(85, 'ohm')>, layers={2: Layer(trace_width=0.08635999999999999, pair_spacing=0.08635999999999999, clearance=0.08889999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.08635999999999999, pair_spacing=0.08635999999999999, clearance=0.08889999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.08635999999999999, pair_spacing=0.08635999999999999, clearance=0.08889999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644})}, uncoupled_region=RoutingStructure(name='DIFF-85-FIELD, uncoupled', impedance=<Quantity(42.5, 'ohm')>, layers={2: Layer(trace_width=0.08635999999999999, clearance=0.08889999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({1: 0.1905, 3: 0.200406}), 4: Layer(trace_width=0.08635999999999999, clearance=0.08889999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({3: 0.1905, 5: 0.201168}), 6: Layer(trace_width=0.08635999999999999, clearance=0.08889999999999999, velocity=165197266923.0466, insertion_loss=0.006794464387028364).reference({5: 0.1905, 7: 0.199644})}))#

DIFF-85’s ball-field neck, 3.4/3.4/3.4 mil with 3.5 mil clearance, on DIFF-85’s inner layers. The pair fits between two adjacent THVia_10p0 pads at 0.92 mm pitch: 2 x 3.5 + 3 x 3.4 = 17.2 mil against a 22.3 mil gap. Full DIFF-85 (3.55/6.45/3.55 with 4x width clearance) needs 41.95.

Impedance on this stackup: about 85 ohm. IPC-2141A’s edge-coupled stripline formula, scaled to the impedance table’s rows on the same layers, gives 85.6 ohm from the 87 ohm neck row (3.2/2.8/3.2, the nearest geometry) and 83.3 ohm from the 85 ohm DIFF-85 row.

BOARD_CORNER_RADIUS = 4.0#

sized for the JS4 LPDDR4 design’s parts, not the source board’s outline.

Type:

Board outline in mm

class Reference18Board[source]#

Bases: Board

80 x 80 mm board for the 18-layer reference substrate, sized for the JS4 LPDDR4 design’s parts. The signal area is inset by the fab rules’ copper-to-edge space.

shape: Shape = ArcPolygon(elements=(Arc(center=(36.0, 36.0), radius=4.0, start=0.0, arc=90.0), Arc(center=(-36.0, 36.0), radius=4.0, start=90.0, arc=90.0), Arc(center=(-36.0, -36.0), radius=4.0, start=180.0, arc=90.0), Arc(center=(36.0, -36.0), radius=4.0, start=270.0, arc=90.0)))#

The board outline shape.

signal_area: Shape | None = ArcPolygon(elements=(Arc(center=(36.0, 36.0), radius=3.746, start=0.0, arc=90.0), Arc(center=(-36.0, 36.0), radius=3.746, start=90.0, arc=90.0), Arc(center=(-36.0, -36.0), radius=3.746, start=180.0, arc=90.0), Arc(center=(36.0, -36.0), radius=3.746, start=270.0, arc=90.0)))#

Shape constraining component and routing placement area. If not provided, the board shape is used.