jitxlib.via_structures package#

class ViaGroundCage(via_def)[source]#

Base class for defining the ground cage for a Via Structure

Parameters:

via_def (type[Via])

via_def: type[Via]#

Via Definition for the ground cage vias. This definition will be used to instantiate each of the needed vias.

place_via_cage(n)[source]#

User is expected to override this method and generate the via instances needed for the cage.

Parameters:

n (Net) – Net to which the vias of the cage will be connected. This would typically be ground in most applications.

class PolarViaGroundCage(via_def, count, radius, theta=0.0, skips=<factory>, pose=<factory>)[source]#

Bases: ViaGroundCage

Polar Via Ground Cage This type implements a polar-coordinate system for defining the vias of the ground cage.

Parameters:
via_def: type[Via]#

Via Definition to use for all of the via placements.

count: int#

Total number of via placements. Must be positive.

radius: float#

Radius in mm for the circular pattern of via placements. Must be positive.

theta: float = 0.0#

Starting angle for the pattern. Value in degrees. Default value is 0.0 degrees which points to the right along the X axis.

skips: list[int]#

Skipped indices in the via pattern. Each value in this collection must be in the range [0, count-1]

pose: Transform#

Change the location and placement of the ground cage with respect to the origin of the via structure. The default value is the IDENTITY transformation.

place_via_cage(n)[source]#

User is expected to override this method and generate the via instances needed for the cage.

Parameters:

n (Net) – Net to which the vias of the cage will be connected. This would typically be ground in most applications.

class AntiPad[source]#

Bases: Container

Base class for Anti-Pad constructors

place_anti_pad()[source]#
class SimpleAntiPad(shape, layers, pose=<factory>)[source]#

Bases: AntiPad

Trivial Anti-Pad Generator This Anti-Pad type generates KeepOut shapes on the passed layers and then positions them according the the pose argument.

shape: Shape#

KeepOut shape to be applied to all requested layers.

layers: LayerSet#

Set of layers where keepout will be applied.

pose: Transform#

Optional transform to apply to the antipads so that they can be positioned with respect to the via-structure’s origin. This value is Transform.identity by default.

place_anti_pad()[source]#
class InsertionPoint[source]#

Bases: Container

Base class for insertion point in the layout. NOTE: The current tool doesn’t support placing actual insertion points from code. Eventually we would like to support this.

place_insertion_point()[source]#
class InsertionPointDecorator(scale=1.0, layerName='insertpt', pose=<factory>)[source]#

Bases: InsertionPoint

Construct a custom layer decoration that indicates where an insertion point should be place manually by the user. Typically, the user would drag out from the via so that it will follow as the via structure moves.

scale: float = 1.0#
layerName: str = 'insertpt'#
pose: Transform#
place_insertion_point()[source]#
class TopoSymbol[source]#

Bases: Symbol

Dummy Symbol for the via structure TopoPin component.

p = Pin(at=(0, 0), length=3)#
class TopoPad[source]#

Bases: Pad

Dummy Pad for the TopoLP. This pad is an empty shape and only serves to be a location for identifying the TopoPin’s port in the physical design.

class TopoLP[source]#

Bases: Landpattern

Dummy Landpattern for the TopoPin construct for creating via structures.

class TopoPin[source]#

Bases: Component

Define a component for holding the via structrure’s pin definition. For a single-ended via, one of these instances is created. For a diff-pair via, two are created.

p = Port()#
class ViaStructure(ground_cages: Sequence[ViaGroundCage], antipads: Sequence[AntiPad], insertion_points: Sequence[InsertionPoint])[source]#

Bases: Circuit

Base class for ViaStructure definitions

Parameters:
generate_common_structures(common)[source]#
Parameters:

common (Net)

static create_std_insertion_points(radius)[source]#
Parameters:

radius (float)

class SingleViaStructure(via_def: type[Via], *, ground_cages: Sequence[ViaGroundCage], antipads: Sequence[AntiPad], insertion_points: Sequence[InsertionPoint])[source]#

Bases: ViaStructure

Single-Ended Signal Via structure This object constructs a Circuit definition that can generate via structure instances for single-ended signals (ie single Port nets). User must instantiate an via structure instance and net/topo it in the circuit like a normal component.

Parameters:
sig_in = Port()#
sig_out = Port()#
COMMON = Port()#
class DifferentialViaStructure(via_defs: type[Via] | tuple[type[Via], type[Via]], pitch: float, *, ground_cages: Sequence[ViaGroundCage], antipads: Sequence[AntiPad], insertion_points: Sequence[InsertionPoint])[source]#

Bases: ViaStructure

Differential Pair Via Structure This object constructs a Circuit definition that can generate a via structure instance for support a DiffPair port net. User must instantiate an instance of this via structure type and net/topo it into the circuit like a normal component instance.

Parameters:
sig_in = DiffPair()#
sig_out = DiffPair()#
COMMON = Port()#