You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
753 lines
29 KiB
Python
753 lines
29 KiB
Python
from typing import Dict, Iterable, List, Tuple, Union, TypeVar, Any, Iterator, Optional, Sequence
|
|
from typing import overload, KeysView, ValuesView
|
|
import copy
|
|
import warnings
|
|
import traceback
|
|
import logging
|
|
from collections import Counter
|
|
|
|
import numpy # type: ignore
|
|
from numpy import pi
|
|
from numpy.typing import ArrayLike
|
|
|
|
from ..pattern import Pattern
|
|
from ..subpattern import SubPattern
|
|
from ..traits import PositionableImpl, Rotatable, PivotableImpl, Copyable, Mirrorable
|
|
from ..utils import AutoSlots, rotation_matrix_2d, vector2
|
|
from ..error import DeviceError
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
P = TypeVar('P', bound='Port')
|
|
D = TypeVar('D', bound='Device')
|
|
O = TypeVar('O', bound='Device')
|
|
|
|
|
|
class Port(PositionableImpl, Rotatable, PivotableImpl, Copyable, Mirrorable, metaclass=AutoSlots):
|
|
"""
|
|
A point at which a `Device` can be snapped to another `Device`.
|
|
|
|
Each port has an `offset` ((x, y) position) and may also have a
|
|
`rotation` (orientation) and a `ptype` (port type).
|
|
|
|
The `rotation` is an angle, in radians, measured counterclockwise
|
|
from the +x axis, pointing inwards into the device which owns the port.
|
|
The rotation may be set to `None`, indicating that any orientation is
|
|
allowed (e.g. for a DC electrical port). It is stored modulo 2pi.
|
|
|
|
The `ptype` is an arbitrary string, default of `unk` (unknown).
|
|
"""
|
|
__slots__ = ('ptype', '_rotation')
|
|
|
|
_rotation: Optional[float]
|
|
""" radians counterclockwise from +x, pointing into device body.
|
|
Can be `None` to signify undirected port """
|
|
|
|
ptype: str
|
|
""" Port types must match to be plugged together if both are non-zero """
|
|
|
|
def __init__(self,
|
|
offset: ArrayLike,
|
|
rotation: Optional[float],
|
|
ptype: str = 'unk',
|
|
) -> None:
|
|
self.offset = offset
|
|
self.rotation = rotation
|
|
self.ptype = ptype
|
|
|
|
@property
|
|
def rotation(self) -> Optional[float]:
|
|
""" Rotation, radians counterclockwise, pointing into device body. Can be None. """
|
|
return self._rotation
|
|
|
|
@rotation.setter
|
|
def rotation(self, val: float):
|
|
if val is None:
|
|
self._rotation = None
|
|
else:
|
|
if not numpy.size(val) == 1:
|
|
raise DeviceError('Rotation must be a scalar')
|
|
self._rotation = val % (2 * pi)
|
|
|
|
def get_bounds(self):
|
|
return numpy.vstack((self.offset, self.offset))
|
|
|
|
def set_ptype(self: P, ptype: str) -> P:
|
|
""" Chainable setter for `ptype` """
|
|
self.ptype = ptype
|
|
return self
|
|
|
|
def mirror(self: P, axis: int) -> P:
|
|
self.offset[1 - axis] *= -1
|
|
if self.rotation is not None:
|
|
self.rotation *= -1
|
|
self.rotation += axis * pi
|
|
return self
|
|
|
|
def rotate(self: P, rotation: float) -> P:
|
|
if self.rotation is not None:
|
|
self.rotation += rotation
|
|
return self
|
|
|
|
def set_rotation(self: P, rotation: Optional[float]) -> P:
|
|
self.rotation = rotation
|
|
return self
|
|
|
|
def __repr__(self) -> str:
|
|
if self.rotation is None:
|
|
rot = 'any'
|
|
else:
|
|
rot = str(numpy.rad2deg(self.rotation))
|
|
return f'<{self.offset}, {rot}, [{self.ptype}]>'
|
|
|
|
|
|
class Device(Copyable, Mirrorable):
|
|
"""
|
|
A `Device` is a combination of a `Pattern` with a set of named `Port`s
|
|
which can be used to "snap" devices together to make complex layouts.
|
|
|
|
`Device`s can be as simple as one or two ports (e.g. an electrical pad
|
|
or wire), but can also be used to build and represent a large routed
|
|
layout (e.g. a logical block with multiple I/O connections or even a
|
|
full chip).
|
|
|
|
For convenience, ports can be read out using square brackets:
|
|
- `device['A'] == Port((0, 0), 0)`
|
|
- `device[['A', 'B']] == {'A': Port((0, 0), 0), 'B': Port((0, 0), pi)}`
|
|
|
|
Examples: Creating a Device
|
|
===========================
|
|
- `Device(pattern, ports={'A': port_a, 'C': port_c})` uses an existing
|
|
pattern and defines some ports.
|
|
|
|
- `Device(name='my_dev_name', ports=None)` makes a new empty pattern with
|
|
default ports ('A' and 'B', in opposite directions, at (0, 0)).
|
|
|
|
- `my_device.build('my_layout')` makes a new pattern and instantiates
|
|
`my_device` in it with offset (0, 0) as a base for further building.
|
|
|
|
- `my_device.as_interface('my_component', port_map=['A', 'B'])` makes a new
|
|
(empty) pattern, copies over ports 'A' and 'B' from `my_device`, and
|
|
creates additional ports 'in_A' and 'in_B' facing in the opposite
|
|
directions. This can be used to build a device which can plug into
|
|
`my_device` (using the 'in_*' ports) but which does not itself include
|
|
`my_device` as a subcomponent.
|
|
|
|
Examples: Adding to a Device
|
|
============================
|
|
- `my_device.plug(subdevice, {'A': 'C', 'B': 'B'}, map_out={'D': 'myport'})`
|
|
instantiates `subdevice` into `my_device`, plugging ports 'A' and 'B'
|
|
of `my_device` into ports 'C' and 'B' of `subdevice`. The connected ports
|
|
are removed and any unconnected ports from `subdevice` are added to
|
|
`my_device`. Port 'D' of `subdevice` (unconnected) is renamed to 'myport'.
|
|
|
|
- `my_device.plug(wire, {'myport': 'A'})` places port 'A' of `wire` at 'myport'
|
|
of `my_device`. If `wire` has only two ports (e.g. 'A' and 'B'), no `map_out`,
|
|
argument is provided, and the `inherit_name` argument is not explicitly
|
|
set to `False`, the unconnected port of `wire` is automatically renamed to
|
|
'myport'. This allows easy extension of existing ports without changing
|
|
their names or having to provide `map_out` each time `plug` is called.
|
|
|
|
- `my_device.place(pad, offset=(10, 10), rotation=pi / 2, port_map={'A': 'gnd'})`
|
|
instantiates `pad` at the specified (x, y) offset and with the specified
|
|
rotation, adding its ports to those of `my_device`. Port 'A' of `pad` is
|
|
renamed to 'gnd' so that further routing can use this signal or net name
|
|
rather than the port name on the original `pad` device.
|
|
"""
|
|
__slots__ = ('pattern', 'ports', '_dead')
|
|
|
|
pattern: Pattern
|
|
""" Layout of this device """
|
|
|
|
ports: Dict[str, Port]
|
|
""" Uniquely-named ports which can be used to snap to other Device instances"""
|
|
|
|
_dead: bool
|
|
""" If True, plug()/place() are skipped (for debugging)"""
|
|
|
|
def __init__(self,
|
|
pattern: Optional[Pattern] = None,
|
|
ports: Optional[Dict[str, Port]] = None,
|
|
*,
|
|
name: Optional[str] = None,
|
|
) -> None:
|
|
"""
|
|
If `ports` is `None`, two default ports ('A' and 'B') are created.
|
|
Both are placed at (0, 0) and have default `ptype`, but 'A' has rotation 0
|
|
(attached devices will be placed to the left) and 'B' has rotation
|
|
pi (attached devices will be placed to the right).
|
|
"""
|
|
if pattern is not None:
|
|
if name is not None:
|
|
raise DeviceError('Only one of `pattern` and `name` may be specified')
|
|
self.pattern = pattern
|
|
else:
|
|
if name is None:
|
|
raise DeviceError('Must specify either `pattern` or `name`')
|
|
self.pattern = Pattern(name=name)
|
|
|
|
if ports is None:
|
|
self.ports = {
|
|
'A': Port([0, 0], rotation=0),
|
|
'B': Port([0, 0], rotation=pi),
|
|
}
|
|
else:
|
|
self.ports = copy.deepcopy(ports)
|
|
|
|
self._dead = False
|
|
|
|
@overload
|
|
def __getitem__(self, key: str) -> Port:
|
|
pass
|
|
|
|
@overload
|
|
def __getitem__(self, key: Union[List[str], Tuple[str], KeysView[str], ValuesView[str]]) -> Dict[str, Port]:
|
|
pass
|
|
|
|
def __getitem__(self, key: Union[str, Iterable[str]]) -> Union[Port, Dict[str, Port]]:
|
|
"""
|
|
For convenience, ports can be read out using square brackets:
|
|
- `device['A'] == Port((0, 0), 0)`
|
|
- `device[['A', 'B']] == {'A': Port((0, 0), 0),
|
|
'B': Port((0, 0), pi)}`
|
|
"""
|
|
if isinstance(key, str):
|
|
return self.ports[key]
|
|
else:
|
|
return {k: self.ports[k] for k in key}
|
|
|
|
def rename_ports(self: D,
|
|
mapping: Dict[str, Optional[str]],
|
|
overwrite: bool = False,
|
|
) -> D:
|
|
"""
|
|
Renames ports as specified by `mapping`.
|
|
Ports can be explicitly deleted by mapping them to `None`.
|
|
|
|
Args:
|
|
mapping: Dict of `{'old_name': 'new_name'}` pairs. Names can be mapped
|
|
to `None` to perform an explicit deletion. `'new_name'` can also
|
|
overwrite an existing non-renamed port to implicitly delete it if
|
|
`overwrite` is set to `True`.
|
|
overwrite: Allows implicit deletion of ports if set to `True`; see `mapping`.
|
|
|
|
Returns:
|
|
self
|
|
"""
|
|
if not overwrite:
|
|
duplicates = (set(self.ports.keys()) - set(mapping.keys())) & set(mapping.values())
|
|
if duplicates:
|
|
raise DeviceError(f'Unrenamed ports would be overwritten: {duplicates}')
|
|
|
|
renamed = {mapping[k]: self.ports.pop(k) for k in mapping.keys()}
|
|
if None in renamed:
|
|
del renamed[None]
|
|
|
|
self.ports.update(renamed) # type: ignore
|
|
return self
|
|
|
|
def check_ports(self: D,
|
|
other_names: Iterable[str],
|
|
map_in: Optional[Dict[str, str]] = None,
|
|
map_out: Optional[Dict[str, Optional[str]]] = None,
|
|
) -> D:
|
|
"""
|
|
Given the provided port mappings, check that:
|
|
- All of the ports specified in the mappings exist
|
|
- There are no duplicate port names after all the mappings are performed
|
|
|
|
Args:
|
|
other_names: List of port names being considered for inclusion into
|
|
`self.ports` (before mapping)
|
|
map_in: Dict of `{'self_port': 'other_port'}` mappings, specifying
|
|
port connections between the two devices.
|
|
map_out: Dict of `{'old_name': 'new_name'}` mappings, specifying
|
|
new names for unconnected `other_names` ports.
|
|
|
|
Returns:
|
|
self
|
|
|
|
Raises:
|
|
`DeviceError` if any ports specified in `map_in` or `map_out` do not
|
|
exist in `self.ports` or `other_names`.
|
|
`DeviceError` if there are any duplicate names after `map_in` and `map_out`
|
|
are applied.
|
|
"""
|
|
if map_in is None:
|
|
map_in = {}
|
|
|
|
if map_out is None:
|
|
map_out = {}
|
|
|
|
other = set(other_names)
|
|
|
|
missing_inkeys = set(map_in.keys()) - set(self.ports.keys())
|
|
if missing_inkeys:
|
|
raise DeviceError(f'`map_in` keys not present in device: {missing_inkeys}')
|
|
|
|
missing_invals = set(map_in.values()) - other
|
|
if missing_invals:
|
|
raise DeviceError(f'`map_in` values not present in other device: {missing_invals}')
|
|
|
|
missing_outkeys = set(map_out.keys()) - other
|
|
if missing_outkeys:
|
|
raise DeviceError(f'`map_out` keys not present in other device: {missing_outkeys}')
|
|
|
|
orig_remaining = set(self.ports.keys()) - set(map_in.keys())
|
|
other_remaining = other - set(map_out.keys()) - set(map_in.values())
|
|
mapped_vals = set(map_out.values())
|
|
mapped_vals.discard(None)
|
|
|
|
conflicts_final = orig_remaining & (other_remaining | mapped_vals)
|
|
if conflicts_final:
|
|
raise DeviceError(f'Device ports conflict with existing ports: {conflicts_final}')
|
|
|
|
conflicts_partial = other_remaining & mapped_vals
|
|
if conflicts_partial:
|
|
raise DeviceError(f'`map_out` targets conflict with non-mapped outputs: {conflicts_partial}')
|
|
|
|
map_out_counts = Counter(map_out.values())
|
|
map_out_counts[None] = 0
|
|
conflicts_out = {k for k, v in map_out_counts.items() if v > 1}
|
|
if conflicts_out:
|
|
raise DeviceError(f'Duplicate targets in `map_out`: {conflicts_out}')
|
|
|
|
return self
|
|
|
|
def build(self, name: str) -> 'Device':
|
|
"""
|
|
Begin building a new device around an instance of the current device
|
|
(rather than modifying the current device).
|
|
|
|
Args:
|
|
name: A name for the new device
|
|
|
|
Returns:
|
|
The new `Device` object.
|
|
"""
|
|
pat = Pattern(name)
|
|
pat.addsp(self.pattern)
|
|
new = Device(pat, ports=self.ports)
|
|
return new
|
|
|
|
def as_interface(self,
|
|
name: str,
|
|
in_prefix: str = 'in_',
|
|
out_prefix: str = '',
|
|
port_map: Optional[Union[Dict[str, str], Sequence[str]]] = None
|
|
) -> 'Device':
|
|
"""
|
|
Begin building a new device based on all or some of the ports in the
|
|
current device. Do not include the current device; instead use it
|
|
to define ports (the "interface") for the new device.
|
|
|
|
The ports specified by `port_map` (default: all ports) are copied to
|
|
new device, and additional (input) ports are created facing in the
|
|
opposite directions. The specified `in_prefix` and `out_prefix` are
|
|
prepended to the port names to differentiate them.
|
|
|
|
By default, the flipped ports are given an 'in_' prefix and unflipped
|
|
ports keep their original names, enabling intuitive construction of
|
|
a device that will "plug into" the current device; the 'in_*' ports
|
|
are used for plugging the devices together while the original port
|
|
names are used for building the new device.
|
|
|
|
Another use-case could be to build the new device using the 'in_'
|
|
ports, creating a new device which could be used in place of the
|
|
current device.
|
|
|
|
Args:
|
|
name: Name for the new device
|
|
in_prefix: Prepended to port names for newly-created ports with
|
|
reversed directions compared to the current device.
|
|
out_prefix: Prepended to port names for ports which are directly
|
|
copied from the current device.
|
|
port_map: Specification for ports to copy into the new device:
|
|
- If `None`, all ports are copied.
|
|
- If a sequence, only the listed ports are copied
|
|
- If a mapping, the listed ports (keys) are copied and
|
|
renamed (to the values).
|
|
|
|
Returns:
|
|
The new device, with an empty pattern and 2x as many ports as
|
|
listed in port_map.
|
|
|
|
Raises:
|
|
`DeviceError` if `port_map` contains port names not present in the
|
|
current device.
|
|
`DeviceError` if applying the prefixes results in duplicate port
|
|
names.
|
|
"""
|
|
if port_map:
|
|
if isinstance(port_map, dict):
|
|
missing_inkeys = set(port_map.keys()) - set(self.ports.keys())
|
|
orig_ports = {port_map[k]: v for k, v in self.ports.items() if k in port_map}
|
|
else:
|
|
port_set = set(port_map)
|
|
missing_inkeys = port_set - set(self.ports.keys())
|
|
orig_ports = {k: v for k, v in self.ports.items() if k in port_set}
|
|
|
|
if missing_inkeys:
|
|
raise DeviceError(f'`port_map` keys not present in device: {missing_inkeys}')
|
|
else:
|
|
orig_ports = self.ports
|
|
|
|
ports_in = {f'{in_prefix}{name}': port.deepcopy().rotate(pi)
|
|
for name, port in orig_ports.items()}
|
|
ports_out = {f'{out_prefix}{name}': port.deepcopy()
|
|
for name, port in orig_ports.items()}
|
|
|
|
duplicates = set(ports_out.keys()) & set(ports_in.keys())
|
|
if duplicates:
|
|
raise DeviceError(f'Duplicate keys after prefixing, try a different prefix: {duplicates}')
|
|
|
|
new = Device(name=name, ports={**ports_in, **ports_out})
|
|
return new
|
|
|
|
def plug(self: D,
|
|
other: O,
|
|
map_in: Dict[str, str],
|
|
map_out: Optional[Dict[str, Optional[str]]] = None,
|
|
*,
|
|
mirrored: Tuple[bool, bool] = (False, False),
|
|
inherit_name: bool = True,
|
|
set_rotation: Optional[bool] = None,
|
|
) -> D:
|
|
"""
|
|
Instantiate the device `other` into the current device, connecting
|
|
the ports specified by `map_in` and renaming the unconnected
|
|
ports specified by `map_out`.
|
|
|
|
Examples:
|
|
=========
|
|
- `my_device.plug(subdevice, {'A': 'C', 'B': 'B'}, map_out={'D': 'myport'})`
|
|
instantiates `subdevice` into `my_device`, plugging ports 'A' and 'B'
|
|
of `my_device` into ports 'C' and 'B' of `subdevice`. The connected ports
|
|
are removed and any unconnected ports from `subdevice` are added to
|
|
`my_device`. Port 'D' of `subdevice` (unconnected) is renamed to 'myport'.
|
|
|
|
- `my_device.plug(wire, {'myport': 'A'})` places port 'A' of `wire` at 'myport'
|
|
of `my_device`. If `wire` has only two ports (e.g. 'A' and 'B'), no `map_out`,
|
|
argument is provided, and the `inherit_name` argument is not explicitly
|
|
set to `False`, the unconnected port of `wire` is automatically renamed to
|
|
'myport'. This allows easy extension of existing ports without changing
|
|
their names or having to provide `map_out` each time `plug` is called.
|
|
|
|
Args:
|
|
other: A device to instantiate into the current device.
|
|
map_in: Dict of `{'self_port': 'other_port'}` mappings, specifying
|
|
port connections between the two devices.
|
|
map_out: Dict of `{'old_name': 'new_name'}` mappings, specifying
|
|
new names for ports in `other`.
|
|
mirrored: Enables mirroring `other` across the x or y axes prior
|
|
to connecting any ports.
|
|
inherit_name: If `True`, and `map_in` specifies only a single port,
|
|
and `map_out` is `None`, and `other` has only two ports total,
|
|
then automatically renames the output port of `other` to the
|
|
name of the port from `self` that appears in `map_in`. This
|
|
makes it easy to extend a device with simple 2-port devices
|
|
(e.g. wires) without providing `map_out` each time `plug` is
|
|
called. See "Examples" above for more info. Default `True`.
|
|
set_rotation: If the necessary rotation cannot be determined from
|
|
the ports being connected (i.e. all pairs have at least one
|
|
port with `rotation=None`), `set_rotation` must be provided
|
|
to indicate how much `other` should be rotated. Otherwise,
|
|
`set_rotation` must remain `None`.
|
|
|
|
Returns:
|
|
self
|
|
|
|
Raises:
|
|
`DeviceError` if any ports specified in `map_in` or `map_out` do not
|
|
exist in `self.ports` or `other_names`.
|
|
`DeviceError` if there are any duplicate names after `map_in` and `map_out`
|
|
are applied.
|
|
`DeviceError` if the specified port mapping is not achieveable (the ports
|
|
do not line up)
|
|
"""
|
|
if self._dead:
|
|
logger.error('Skipping plug() since device is dead')
|
|
return self
|
|
|
|
if (inherit_name
|
|
and not map_out
|
|
and len(map_in) == 1
|
|
and len(other.ports) == 2):
|
|
out_port_name = next(iter(set(other.ports.keys()) - set(map_in.values())))
|
|
map_out = {out_port_name: next(iter(map_in.keys()))}
|
|
|
|
if map_out is None:
|
|
map_out = {}
|
|
map_out = copy.deepcopy(map_out)
|
|
|
|
self.check_ports(other.ports.keys(), map_in, map_out)
|
|
translation, rotation, pivot = self.find_transform(other, map_in, mirrored=mirrored,
|
|
set_rotation=set_rotation)
|
|
|
|
# get rid of plugged ports
|
|
for ki, vi in map_in.items():
|
|
del self.ports[ki]
|
|
map_out[vi] = None
|
|
|
|
self.place(other, offset=translation, rotation=rotation, pivot=pivot,
|
|
mirrored=mirrored, port_map=map_out, skip_port_check=True)
|
|
return self
|
|
|
|
def place(self: D,
|
|
other: O,
|
|
*,
|
|
offset: vector2 = (0, 0),
|
|
rotation: float = 0,
|
|
pivot: vector2 = (0, 0),
|
|
mirrored: Tuple[bool, bool] = (False, False),
|
|
port_map: Optional[Dict[str, Optional[str]]] = None,
|
|
skip_port_check: bool = False,
|
|
) -> D:
|
|
"""
|
|
Instantiate the device `other` into the current device, adding its
|
|
ports to those of the current device (but not connecting any ports).
|
|
|
|
Mirroring is applied before rotation; translation (`offset`) is applied last.
|
|
|
|
Examples:
|
|
=========
|
|
- `my_device.place(pad, offset=(10, 10), rotation=pi / 2, port_map={'A': 'gnd'})`
|
|
instantiates `pad` at the specified (x, y) offset and with the specified
|
|
rotation, adding its ports to those of `my_device`. Port 'A' of `pad` is
|
|
renamed to 'gnd' so that further routing can use this signal or net name
|
|
rather than the port name on the original `pad` device.
|
|
|
|
Args:
|
|
other: A device to instantiate into the current device.
|
|
offset: Offset at which to place `other`. Default (0, 0).
|
|
rotation: Rotation applied to `other` before placement. Default 0.
|
|
pivot: Rotation is applied around this pivot point (default (0, 0)).
|
|
Rotation is applied prior to translation (`offset`).
|
|
mirrored: Whether `other` should be mirrored across the x and y axes.
|
|
Mirroring is applied before translation and rotation.
|
|
port_map: Dict of `{'old_name': 'new_name'}` mappings, specifying
|
|
new names for ports in `other`. New names can be `None`, which will
|
|
delete those ports.
|
|
skip_port_check: Can be used to skip the internal call to `check_ports`,
|
|
in case it has already been performed elsewhere.
|
|
|
|
Returns:
|
|
self
|
|
|
|
Raises:
|
|
`DeviceError` if any ports specified in `map_in` or `map_out` do not
|
|
exist in `self.ports` or `other_names`.
|
|
`DeviceError` if there are any duplicate names after `map_in` and `map_out`
|
|
are applied.
|
|
"""
|
|
if self._dead:
|
|
logger.error('Skipping place() since device is dead')
|
|
return self
|
|
|
|
if port_map is None:
|
|
port_map = {}
|
|
|
|
if not skip_port_check:
|
|
self.check_ports(other.ports.keys(), map_in=None, map_out=port_map)
|
|
|
|
ports = {}
|
|
for name, port in other.ports.items():
|
|
new_name = port_map.get(name, name)
|
|
if new_name is None:
|
|
continue
|
|
ports[new_name] = port
|
|
|
|
for name, port in ports.items():
|
|
p = port.deepcopy()
|
|
p.mirror2d(mirrored)
|
|
p.rotate_around(pivot, rotation)
|
|
p.translate(offset)
|
|
self.ports[name] = p
|
|
|
|
sp = SubPattern(other.pattern, mirrored=mirrored)
|
|
sp.rotate_around(pivot, rotation)
|
|
sp.translate(offset)
|
|
self.pattern.subpatterns.append(sp)
|
|
return self
|
|
|
|
def find_transform(self: D,
|
|
other: O,
|
|
map_in: Dict[str, str],
|
|
*,
|
|
mirrored: Tuple[bool, bool] = (False, False),
|
|
set_rotation: Optional[bool] = None,
|
|
) -> Tuple[numpy.ndarray, float, numpy.ndarray]:
|
|
"""
|
|
Given a device `other` and a mapping `map_in` specifying port connections,
|
|
find the transform which will correctly align the specified ports.
|
|
|
|
Args:
|
|
other: a device
|
|
map_in: Dict of `{'self_port': 'other_port'}` mappings, specifying
|
|
port connections between the two devices.
|
|
mirrored: Mirrors `other` across the x or y axes prior to
|
|
connecting any ports.
|
|
set_rotation: If the necessary rotation cannot be determined from
|
|
the ports being connected (i.e. all pairs have at least one
|
|
port with `rotation=None`), `set_rotation` must be provided
|
|
to indicate how much `other` should be rotated. Otherwise,
|
|
`set_rotation` must remain `None`.
|
|
|
|
Returns:
|
|
- The (x, y) translation (performed last)
|
|
- The rotation (radians, counterclockwise)
|
|
- The (x, y) pivot point for the rotation
|
|
|
|
The rotation should be performed before the translation.
|
|
"""
|
|
s_ports = self[map_in.keys()]
|
|
o_ports = other[map_in.values()]
|
|
|
|
s_offsets = numpy.array([p.offset for p in s_ports.values()])
|
|
o_offsets = numpy.array([p.offset for p in o_ports.values()])
|
|
s_types = [p.ptype for p in s_ports.values()]
|
|
o_types = [p.ptype for p in o_ports.values()]
|
|
|
|
s_rotations = numpy.array([p.rotation if p.rotation is not None else 0 for p in s_ports.values()])
|
|
o_rotations = numpy.array([p.rotation if p.rotation is not None else 0 for p in o_ports.values()])
|
|
s_has_rot = numpy.array([p.rotation is not None for p in s_ports.values()], dtype=bool)
|
|
o_has_rot = numpy.array([p.rotation is not None for p in o_ports.values()], dtype=bool)
|
|
has_rot = s_has_rot & o_has_rot
|
|
|
|
if mirrored[0]:
|
|
o_offsets[:, 1] *= -1
|
|
o_rotations *= -1
|
|
if mirrored[1]:
|
|
o_offsets[:, 0] *= -1
|
|
o_rotations *= -1
|
|
o_rotations += pi
|
|
|
|
type_conflicts = numpy.array([st != ot and st != 'unk' and ot != 'unk'
|
|
for st, ot in zip(s_types, o_types)])
|
|
if type_conflicts.any():
|
|
ports = numpy.where(type_conflicts)
|
|
msg = 'Ports have conflicting types:\n'
|
|
for nn, (k, v) in enumerate(map_in.items()):
|
|
if type_conflicts[nn]:
|
|
msg += f'{k} | {s_types[nn]}:{o_types[nn]} | {v}\n'
|
|
msg = ''.join(traceback.format_stack()) + '\n' + msg
|
|
warnings.warn(msg, stacklevel=2)
|
|
|
|
rotations = numpy.mod(s_rotations - o_rotations - pi, 2 * pi)
|
|
if not has_rot.any():
|
|
if set_rotation is None:
|
|
DeviceError('Must provide set_rotation if rotation is indeterminate')
|
|
rotations[:] = set_rotation
|
|
else:
|
|
rotations[~has_rot] = rotations[has_rot][0]
|
|
|
|
if not numpy.allclose(rotations[:1], rotations):
|
|
rot_deg = numpy.rad2deg(rotations)
|
|
msg = f'Port orientations do not match:\n'
|
|
for nn, (k, v) in enumerate(map_in.items()):
|
|
msg += f'{k} | {rot_deg[nn]:g} | {v}\n'
|
|
raise DeviceError(msg)
|
|
|
|
pivot = o_offsets[0].copy()
|
|
rotate_offsets_around(o_offsets, pivot, rotations[0])
|
|
translations = s_offsets - o_offsets
|
|
if not numpy.allclose(translations[:1], translations):
|
|
msg = f'Port translations do not match:\n'
|
|
for nn, (k, v) in enumerate(map_in.items()):
|
|
msg += f'{k} | {translations[nn]} | {v}\n'
|
|
raise DeviceError(msg)
|
|
|
|
return translations[0], rotations[0], o_offsets[0]
|
|
|
|
def translate(self: D, offset: vector2) -> D:
|
|
"""
|
|
Translate the pattern and all ports.
|
|
|
|
Args:
|
|
offset: (x, y) distance to translate by
|
|
|
|
Returns:
|
|
self
|
|
"""
|
|
self.pattern.translate_elements(offset)
|
|
for port in self.ports.values():
|
|
port.translate(offset)
|
|
return self
|
|
|
|
def rotate_around(self: D, pivot: vector2, angle: float) -> D:
|
|
"""
|
|
Translate the pattern and all ports.
|
|
|
|
Args:
|
|
offset: (x, y) distance to translate by
|
|
|
|
Returns:
|
|
self
|
|
"""
|
|
self.pattern.rotate_around(pivot, angle)
|
|
for port in self.ports.values():
|
|
port.rotate_around(pivot, angle)
|
|
return self
|
|
|
|
def mirror(self: D, axis: int) -> D:
|
|
"""
|
|
Translate the pattern and all ports across the specified axis.
|
|
|
|
Args:
|
|
axis: Axis to mirror across (x=0, y=1)
|
|
|
|
Returns:
|
|
self
|
|
"""
|
|
self.pattern.mirror(axis)
|
|
for p in self.ports.values():
|
|
p.mirror(axis)
|
|
return self
|
|
|
|
def set_dead(self: D) -> D:
|
|
"""
|
|
Disallows further changes through `plug()` or `place()`.
|
|
This is meant for debugging:
|
|
```
|
|
dev.plug(a, ...)
|
|
dev.set_dead() # added for debug purposes
|
|
dev.plug(b, ...) # usually raises an error, but now skipped
|
|
dev.plug(c, ...) # also skipped
|
|
dev.pattern.visualize() # shows the device as of the set_dead() call
|
|
```
|
|
|
|
Returns:
|
|
self
|
|
"""
|
|
self._dead = True
|
|
return self
|
|
|
|
def rename(self: D, name: str) -> D:
|
|
"""
|
|
Renames the pattern and returns the device
|
|
|
|
Args:
|
|
name: The new name
|
|
|
|
Returns:
|
|
self
|
|
"""
|
|
self.pattern.name = name
|
|
return self
|
|
|
|
def __repr__(self) -> str:
|
|
s = f'<Device {self.pattern} ['
|
|
for name, port in self.ports.items():
|
|
s += f'\n\t{name}: {port}'
|
|
s += ']>'
|
|
return s
|
|
|
|
|
|
def rotate_offsets_around(offsets: ArrayLike, pivot: ArrayLike, angle: float) -> numpy.ndarray:
|
|
offsets -= pivot
|
|
offsets[:] = (rotation_matrix_2d(angle) @ offsets.T).T
|
|
offsets += pivot
|
|
return offsets
|