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.
Conductorhas 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, soroughnessis 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.filledis 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.
Backdrillholds 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.thicknessis 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. Seeem890_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 (seeDRS_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.
- 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).
- class Soldermask(*, name=None, thickness=None, representing=None)[source]#
Bases:
DielectricSoldermask, “SOLDERMASK_PSR4000_MPHF” in the stackup table, 1.3 mil.
Dk 3.8 and Df 0.02, typical of LPI soldermask.
- material_name: ClassVar[str | None] = 'PSR-4000 MP-HF soldermask'#
Name of the material. If not specified, the name of the class is used.
- 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%.- material_name: ClassVar[str | None] = 'EM-890 prepreg 1035 RC69%'#
Name of the material. If not specified, the name of the class is used.
- 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.- 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.
- 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%.- material_name: ClassVar[str | None] = 'EM-890 prepreg 1078 RC63%'#
Name of the material. If not specified, the name of the class is used.
- 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.
- material_name: ClassVar[str | None] = 'EM-890 core 1078'#
Name of the material. If not specified, the name of the class is used.
- 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.
- material_name: ClassVar[str | None] = 'EM-890 core 1035'#
Name of the material. If not specified, the name of the class is used.
- 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.
- 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.
- 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.
- 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.
- 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.
- class StackupRow(name, material, thickness_mil)[source]#
Bases:
objectOne row of the drawing’s stackup table.
- 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
startthrough copper layerstop, both included, top to bottom. Indices count copper layers only and may be negative, as for a via.- Return type:
- Parameters:
- via_delay(start, stop)[source]#
First-order delay in seconds of a via barrel from the middle of copper layer
startto the middle of copper layerstop. Each dielectric between contributes its thickness plus half of each copper beside it, at its own Dk: the sum of D * sqrt(Dk) / c.
- via_models(start, stop)[source]#
A model for every pair of copper layers a via’s plated barrel joins, from copper layer
starttostop(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.
- class Reference18Stackup[source]#
Bases:
Stackup18 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)
- 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:
FabricationConstraintsThe 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) andsolder_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_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.
- 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.
- via_pad(hole_mil)[source]#
Pad diameter in mm for a finished hole of
hole_milmils: the hole plus twice IPC-2221B’s minimum external annular ring.
- 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 usesnfpon 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 indiametersand no reading ofnfpremoves it. A removed pad is modeled as a pad the size of the finished hole, leaving no copper ring.- Return type:
- 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_milmils: 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 twomin_copper_hole_space.
- 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.layersbefore 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
ReferencePlanescovering 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.
- nearest_plane_height(layer)[source]#
Height in mm from routing layer
layerto 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”).
- 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:
SubstrateThe stackup, fab rules, the vias the drill charts offer, and one routing structure per impedance-table column.
Every nested
Viaclass 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 isvia_diameter(), with unused internal pads removed.- constraints: FabricationConstraints = <jitxexamples.substrates.reference_18layer.Reference18FabRules object>#
- class MicroVia_TOP_L2(*args, **kwargs)[source]#
Bases:
ViaDrill chart “TOP to L2”, 6.0 mil. Laser drilled through one 2.32 mil prepreg.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaDrill chart “L17 to BOTTOM”, 6.0 mil. Laser drilled through one 2.32 mil prepreg.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaDrill chart “TOP to L3”, 6.9 mil. Laser drilled through two dielectrics, a design choice.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaDrill chart “TOP to L3”, 8.0 mil. Laser drilled through two dielectrics, a design choice.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaDrill chart “TOP to L3”, 10.0 mil. Laser drilled through two dielectrics, a design choice.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaDrill chart “L16_SIG6 to BOTTOM”, 6.9 mil. Laser drilled through two dielectrics, a design choice.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaDrill chart “L16_SIG6 to BOTTOM”, 10.0 mil. Laser drilled through two dielectrics, a design choice.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaDrill chart “TOP to BOTTOM”, 6.0 mil, the smallest plated drill.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaDrill chart “TOP to BOTTOM”, 10.0 mil, the most used plated drill.
- 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.
- diameter: float | ViaDiameter = <jitx.via.ViaDiameter object>#
Pad diameter of the via, in mm. Can be overridden on a per-layer basis by
diameters.
- 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.
- 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.PinModelobject 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:
ViaBackdrill chart “BOTTOM to L4_GND”, must not cut L3_SIG1.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
ViaBackdrill chart “BOTTOM to L6_GND”, must not cut L5_SIG2.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
ViaBackdrill chart “BOTTOM to L8_GND_1OZ”, must not cut L7_SIG3.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
ViaBackdrill chart “BOTTOM to L13_GND”, must not cut L12_SIG4.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
ViaBackdrill chart “BOTTOM to L15_GND”, must not cut L14_SIG5.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
ViaBackdrill chart “TOP to L2_GND”, must not cut L3_SIG1.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
ViaBackdrill chart “TOP to L4_GND”, must not cut L5_SIG2.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
ViaBackdrill chart “TOP to L6_GND”, must not cut L7_SIG3.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
ViaBackdrill chart “TOP to L11_GND_1OZ”, must not cut L12_SIG4.
- 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.
- 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
diameterfor 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
1and-3name 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 aViaDiameterto set a separate pad diameter where non-functional pads are removed (seeViaDiameter.nfp).>>> diameters = {0: 0.5, (1, 2): ViaDiameter(0.5, nfp=0.2), -1: 0.5} # 4 layers
- 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.
- 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.PinModelobject 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
Backdrillis 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_layertostop_layer. Sostop_layersets the depth of a bottom backdrill (the via connects down to that layer and the stub below it is drilled out), and forBackdrillSet(top=...)start_layersets 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:
Board80 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.