pymint.constraints package
Submodules
pymint.constraints.arrayconstraint module
- class pymint.constraints.arrayconstraint.ArrayConstraint(components: List[Component], xdim: int = 1, ydim: int = 1, horizontal_spacing: float = 0, vertical_spacing: float = 0)
Bases:
LayoutConstraint
Array Constraint represents a 1D / 2D array with fixed spacings in both dimensions
- property dim: int
Returns the size of the array
- Returns:
size
- Return type:
int
- property horizontal_spacing: float
Gets the horizontal spacing between the components
- Raises:
KeyError – If the horizontal spacing is not set
- Returns:
The horizontal spacing
- Return type:
float
- property vertical_spacing: float
Gets the vertical spacing between the components
- Raises:
KeyError – If the vertical spacing is not set
- Returns:
The vertical spacing
- Return type:
float
- property xdim: int
Returns the x size of the array
- Returns:
size
- Return type:
int
- property ydim: int
Returns the y size of the array
- Returns:
size
- Return type:
int
pymint.constraints.constraint module
pymint.constraints.constraintlistener module
- class pymint.constraints.constraintlistener.ConstraintListener(device: MINTDevice)
Bases:
mintListener
Listener that is used to catch all the layout constratints from the MINT design
- enterFlowStat(ctx: FlowStatContext)
- enterHorizontalSpacingParam(ctx: HorizontalSpacingParamContext)
- enterLayerBlock(ctx: LayerBlockContext)
- enterOrientation(ctx: OrientationContext)
- enterPositionConstraintStat(ctx: PositionConstraintStatContext)
- enterSetCoordinate(ctx: SetCoordinateContext)
- enterSpacingParam(ctx: SpacingParamContext)
- enterUfname(ctx: UfnameContext)
- enterVerticalSpacingParam(ctx: VerticalSpacingParamContext)
- exitBankDeclStat(ctx: BankDeclStatContext)
- exitBankStat(ctx: BankStatContext)
- exitChannelStat(ctx: ChannelStatContext)
- exitFlowStat(ctx: FlowStatContext)
- exitGridStat(ctx: GridStatContext)
- exitLayerBlock(ctx: LayerBlockContext)
- exitNetlist(ctx: NetlistContext)
- exitNodeStat(ctx: NodeStatContext)
- exitPositionConstraintStat(ctx: PositionConstraintStatContext)
- exitSpanStat(ctx: SpanStatContext)
pymint.constraints.lengthconstraint module
- class pymint.constraints.lengthconstraint.LengthConstraint(connection: Connection, length: float)
Bases:
LayoutConstraint
Layout Constriant that will be used for specifying a fixed length for a connection
- property connections: List[Connection]
Returns the component covered by the constraint
- Returns:
constrained component
- Return type:
Component
- property length: float
Returns the length fixed by the constraint
- Returns:
length constrained
- Return type:
float
pymint.constraints.mirrorconstraint module
- class pymint.constraints.mirrorconstraint.DistanceDictionaries(groups_size: int, device: Device, undirected_netlist)
Bases:
object
Distance dictionaries are the data structures we are using to solve the mirror grouping problem. This algoithm creates dictionaries based on the distances of each of the components to the source components`that are the original decendentants of the `mirror driving component.
The datastructure essentially looks like this: —– —– | 0 : [source_node] 0: [source_node] 0: [source_node] | | 1 : [node1, node2] 1: [node1, node2] 1: [node1, node2] | | 2 : [node1, node2] 2: [node1, node2] 2: [node1, node2] | | 3 : [node1, node2] , 3: [node1, node2] , 3: [node1, node2] , … | | 4 : [node1, node2] 4: [node1, node2] 4: [node1, node2] | | 5 : [node1, node2] 5: [node1, node2] 5: [node1, node2] | | 6 : [node1, node2] 6: [node1, node2] 6: [node1, node2] | | 7 : [node1, node2] 7: [node1, node2] 7: [node1, node2] | —– —–
Its a list of dictionaries where the keys are the distances to the source. If we trim and prune this entire data structure, we will get the final list of groups that we can export.
- find_node_in_group(group_index: int, node: str) Tuple[bool, int]
Returns a tuple of (is_node_in_group, distance) return -1 as distance incase the node is not found
- Parameters:
group_index (int) – The index of the group to check
node (str) – The node to check
- Raises:
IndexError – If the group index is out of range
- Returns:
A tuple of (is_node_in_group, distance)
- Return type:
Tuple[bool, int]
- generate_groups() List[List[str]]
- is_node_in_group(group_index: int, node: str) bool
- load_group_dfs_nodes(group_index, dfs_nodes: List[str]) None
Loads the DFS nodes of a group into the dictionary.
- prune_backpaths() None
- prune_non_group_nodes() None
- prune_non_matching_nodes() None
- remove_node_from_group(group_index: int, node: str) None
- set_group_node(group_index: int, node: str, distance: int)
- set_source(group_index: int, node: str)
- trim_dictionaries(limit: int) None
Removes all the dictionarie entries that have a distance greater than or equal to the limit
- trim_uneven_distaces() None
- class pymint.constraints.mirrorconstraint.MirrorConstraint(source_component: Component, mirror_count=None, mirror_groups: List[List[Component]] = [])
Bases:
LayoutConstraint
Layout constraint when two differnt sub-netlists need to have the same layout
- add_group(components: List[Component]) None
Adds the passed componets to a new group
- Parameters:
components (List[Component]) – List of components that need to be in a
group (mirror) –
- static find_mirror_groups(driving_component: Component, device: Device, mirror_count: int) List[List[Component]]
- static generate_constraints(mirror_driving_components: List[Component], mint_device: MINTDevice) None
Generate the mirror constraints for the device
- Parameters:
mirror_driving_components (List[Component]) – components that are driving the mirror constraint
device (MINTDevice) – device to generate the constraint for
- property mirror_count: int
Number of mirror groups
- Returns:
number of mirror groups
- Return type:
int
- property mirror_groups: List[List[Component]]
Returns the mirror groups
- Returns:
Mirror groups covered by the constraint
- Return type:
List[List[Component]]
- property mirror_source: Component
Returns the mirror source component
- Returns:
mirror source
- Return type:
Component
pymint.constraints.orientationconstraint module
- class pymint.constraints.orientationconstraint.ComponentOrientation(value)
Bases:
Enum
Enum ot represent component’s relative orientation
- HORIZONTAL = 0
- VERTICAL = 1
- class pymint.constraints.orientationconstraint.OrientationConstraint
Bases:
LayoutConstraint
Layout constraint that setups relative orientations for a number of components inside a single layer
- add_component_orientation_pair(component: Component, orientation: ComponentOrientation) None
Adds a component onto the constraint
- Parameters:
component (Component) – component covered by the constraint
orientation (ComponentOrientation) – orientation to set
- property orientation_map: Dict[Component, ComponentOrientation]
Retuns the map of all the components and their corresponding orientation
- Returns:
- Dict mapping the components and
their orientations
- Return type:
Dict[Component, ComponentOrientation]
pymint.constraints.orthogonalconstraint module
- class pymint.constraints.orthogonalconstraint.OrthogonalConstraint(components: List[Component])
Bases:
LayoutConstraint
Layout constraint used to represent an orthogonal layout requirement for a sub-netlist
- static generate_constraints(orthogonal_driving_components: List[Component], device: MINTDevice) None
Generates the orthogonal constraints for the device
- Parameters:
orthogonal_driving_components (List[Union[MINTComponent, Component]]) – components that are driving the orthogonal constraint
device (MINTDevice) – device to generate the constraints for
- static traverse_node_component_neighbours(component: Component, mint_device: MINTDevice) List[Component]
Traverses the node networks to find the components covered by the constraint
- Parameters:
component (Component) – starting component
device (MINTDevice) – current device
- Returns:
list of components covered by the constraint
- Return type:
List[Component]
pymint.constraints.positionconstraint module
- class pymint.constraints.positionconstraint.PositionConstraint(component: Component, xpos: float, ypos: float, zpos: float)
Bases:
LayoutConstraint
Layout constraint that fixes the location
- get_component() Component
Returns the component constrained by the component
- Raises:
Exception – if the component is not covered by the constraint
- Returns:
returns the component covered by the constraint
- Return type:
Component
- property xpos: float
Returns the x position of the component
- Returns:
x coordinate of the component if set else returns None
- Return type:
float
- property ypos: float
Returns the y position of the component
- Returns:
y coordinate of the component if set else returns None
- Return type:
float
- property zpos: float
Returns the z position of the component
- Returns:
z coordinate of the component if set else returns None
- Return type:
float
pymint.constraints.rotationconstraint module
- class pymint.constraints.rotationconstraint.RotationConstraint(component: Component, rotation: float)
Bases:
LayoutConstraint
Layout constraint that fixed the absolute rotation of the component
- property component: Component
Returns the component covered by the constraint
- Returns:
constrianed component
- Return type:
Component
- property rotation: float
Returns the rotation fixed by the rotation
- Returns:
rotation value
- Return type:
float