"""Wire-type objects representing electrical connections between components."""
import logging
import numpy as np
from finesse.exceptions import FinesseException
from .general import Connector, borrows_nodes
from .node import NodeType, NodeDirection, SignalNode, Port
from .workspace import ConnectorWorkspace
from ..env import warn
from ..parameter import float_parameter
# from ..exceptions import FinesseException
LOGGER = logging.getLogger(__name__)
[docs]class WireWorkspace(ConnectorWorkspace):
pass
[docs]@float_parameter("delay", "Delay", validate="_check_delay", units="s")
@borrows_nodes()
class Wire(Connector):
"""A wire represents a flow of information between signal nodes. It connects two
specific signal nodes. Signal nodes have a direction associated with them: input,
output, or bidirectional. Depending on what direction each node has depends on what
the wire will setup when it is connected. The rules for node-to-node connections
are:
- input and output: a connection will be formed from the input to the output
node
- input to input or output to output: is not allowed.
- input to bidirectional: a connection will be made from the input node into
the bidirectional node
- output to bidirectional: a connection will be made from the bidirectional
node into the output node
- bidirectional to bidirectional: two connections will be made that lets
information flow in both directions between the two nodes.
When connecting ports the wire will look at the name of each node in the port
and connect nodes with the same name
Parameters
----------
name : str, optional
Name of newly created wire.
nodeA, nodeB : :class:`.SignalNode`
Signal nodes to connect together.
delay : float, optional
A delay time for the signal to flow from A to B in seconds
"""
[docs] def __init__(self, name=None, nodeA=None, nodeB=None, delay=0):
given_name = name
if (nodeA is None) != (nodeB is None):
warn(
"Cannot construct a wire with only one port connected; ignoring ports."
)
nodeA = None
nodeB = None
if nodeA is not None and nodeA.type not in (
NodeType.ELECTRICAL,
NodeType.MECHANICAL,
):
raise RuntimeError(
f"{nodeA!r} is not an electrical or mechanical port or node"
)
if nodeB is not None and nodeB.type not in (
NodeType.ELECTRICAL,
NodeType.MECHANICAL,
):
raise RuntimeError(
f"{nodeB!r} is not an electrical or mechanical port or node"
)
if name is None:
if nodeA is not None and nodeB is not None:
compA = nodeA.component.name
compB = nodeB.component.name
name = f"{compA}_{nodeA.name}__{compB}_{nodeB.name}"
else:
raise ValueError(
"Cannot create an unconnected wire without " "providing a name"
)
super().__init__(name)
self.delay = delay
if given_name is None:
self._namespace = (".wires",)
else:
# Also put into main namespace if it has a specific name
self._namespace = (".", ".wires")
self.__nodeA = None
self.__nodeB = None
if nodeA is not None and nodeB is not None:
self.connect(nodeA, nodeB)
@property
def nodeA(self):
return self.__nodeA
@property
def nodeB(self):
return self.__nodeB
def _check_delay(self, value):
if value < 0:
raise ValueError("Delay of a wire must not be negative.")
return value
[docs] def connect(self, A, B):
"""Connects two signal nodes together. One must be an INPUT and the other and
OUTPUT node. Or one or both might be BIDIRECTIONAL.
Parameters
----------
A : :class:`.SignalNode` or :class:`.Port`
First signal node or Electrical port with a single node
B : :class:`.SignalNode` or :class:`.Port`
Second signal node or Electrical port with a single node
"""
if self.nodeA is not None or self.nodeB is not None:
raise FinesseException(
f"{self!r} is already connecting {self.nodeA!r} to {self.nodeB!r}"
)
if isinstance(A, Port) and A.type == NodeType.ELECTRICAL:
if len(A.nodes) != 1:
raise FinesseException(
f"{A!r} has more than one port, please specify which to use"
)
else:
A = A.nodes[0]
if isinstance(B, Port) and B.type == NodeType.ELECTRICAL:
if len(B.nodes) != 1:
raise FinesseException(
f"{B!r} has more than one port, please specify which to use"
)
else:
B = B.nodes[0]
if not (isinstance(A, SignalNode) and isinstance(B, SignalNode)):
raise FinesseException(
f"Wires can only connect two SignalNodes, not {A!r} to {B!r}. If one is a Port type object then please specify which Node at the port to use."
)
self.__nodeA = A
self.__nodeB = B
pA = self._add_port("pA", self.nodeA.type)
A = pA._add_node("A", None, self.nodeA)
pB = self._add_port("pB", self.nodeB.type)
B = pB._add_node("B", None, self.nodeB)
if A.direction in (
NodeDirection.OUTPUT,
NodeDirection.BIDIRECTIONAL,
) and B.direction in (NodeDirection.INPUT, NodeDirection.BIDIRECTIONAL):
self._register_node_coupling("WIRE", A, B)
elif B.direction in (
NodeDirection.OUTPUT,
NodeDirection.BIDIRECTIONAL,
) and A.direction in (NodeDirection.INPUT, NodeDirection.BIDIRECTIONAL):
self._register_node_coupling("WIRE", B, A)
else:
raise FinesseException(f"Cannot connect signal nodes {A!r} to {B!r}")
def _get_workspace(self, sim):
if sim.signal:
self._eval_parameters()
# Most wires are zero delay, so don't bother refilling them all the time
refill = (
(sim.model.fsig.f.is_changing or sim.signal.any_frequencies_changing)
and self.delay.is_changing
and self.delay != 0
)
ws = WireWorkspace(self, sim)
ws.signal.add_fill_function(self.fill, refill)
return ws
else:
return None
[docs] def fill(self, ws):
# scale appropriately if input and output are different types
# scale up if going from electrical to mechanical
# scale down if going from mechanical to electrical
if (
self.nodeA.type == NodeType.ELECTRICAL
and self.nodeB.type == NodeType.MECHANICAL
):
ws.scaling = 1 / ws.sim.model_settings.x_scale
elif (
self.nodeA.type == NodeType.MECHANICAL
and self.nodeB.type == NodeType.ELECTRICAL
):
ws.scaling = ws.sim.model_settings.x_scale
else:
ws.scaling = 1
delay = np.exp(-1j * ws.values.delay * ws.sim.model_settings.fsig)
key = (ws.owner_id, 0, 0, 0)
if key in ws.sim.signal._submatrices:
ws.sim.signal._submatrices[key][:] = delay * ws.scaling