photonforge 1.3.1__cp310-cp310-win_amd64.whl → 1.3.2__cp310-cp310-win_amd64.whl

photonforge/__init__.py

@@ -70,17 +70,17 @@ from .utils import (
 from .parametric_utils import parametric_component, parametric_technology
 from .plotting import plot_s_matrix, tidy3d_plot
 from .netlist import component_from_netlist
-from .tidy3d_model import (
+from .models.tidy3d import (
     Tidy3DModel,
+    EMEModel,
     abort_pending_tasks,
     port_modes,
     _tidy3d_to_str,
     _tidy3d_to_bytes,
     _tidy3d_from_bytes,
 )
-from .eme_model import EMEModel
-from .circuit_model import CircuitModel
-from .analytic_models import (
+from .models.circuit import CircuitModel, DirectionalCouplerCircuitModel
+from .models.analytic import (
     ModelResult,
     TwoPortModel,
     PowerSplitterModel,
@@ -94,24 +94,29 @@ from .analytic_models import (
     AnalyticDirectionalCouplerModel,
     AnalyticMZIModel,
 )
-from .data_model import DataModel
-from .analytic_time_steppers import DelayedTimeStepper
-from .s_matrix_time_stepper import SMatrixTimeStepper
-from .circuit_time_stepper import CircuitTimeStepper
-from .source_time_steppers import (
+from .models.data import DataModel
+from .time_steppers.amplifier import OpticalAmplifierTimeStepper, ElectricalAmplifierTimeStepper
+from .time_steppers.filter import FilterTimeStepper
+from .time_steppers.analytic import DelayedTimeStepper, AnalyticWaveguideTimeStepper
+from .time_steppers.s_matrix import SMatrixTimeStepper
+from .time_steppers.circuit import CircuitTimeStepper
+from .time_steppers.math import ExpressionTimeStepper, DifferentialTimeStepper, IntegralTimeStepper
+from .time_steppers.source import (
     CWLaserTimeStepper,
     DMLaserTimeStepper,
     OpticalPulseTimeStepper,
     OpticalNoiseTimeStepper,
     WaveformTimeStepper,
 )
-from .sink_time_steppers import PhotodiodeTimeStepper
-from .modulator_time_steppers import PhaseModTimeStepper, TerminatedModTimeStepper
+from .time_steppers.sink import PhotodiodeTimeStepper
+from .time_steppers.modulator import PhaseModTimeStepper, TerminatedModTimeStepper
 from .pretty import _Tree, LayerTable, PortSpecTable, ExtrusionTable
 from .thumbnails import thumbnails
+
+from . import live_viewer
+from . import monte_carlo
 from . import parametric
 from . import stencil
-from . import monte_carlo
 
 from tidy3d.config import get_manager as _gm
 

photonforge/_backend/default_project.py

@@ -6,13 +6,97 @@ import tidy3d as _td
 
 import photonforge as _pf
 import photonforge.typing as _pft
-from photonforge.analytic_models import _add_bb_text, _bb_layer
-from photonforge.source_time_steppers import RIN as _RIN
+from photonforge.models.analytic import _add_bb_text, _bb_layer
+from photonforge.time_steppers.source import RIN as _RIN
 
 _ThermoOpticCoeff = _pft.annotate(float, label="dn/dT", units="1/K")
 _LossTemperatureCoeff = _pft.annotate(float, label="dL/dT", units="dB/μm/K")
 
 
+class _PassThroughModel(_pf.Model):
+    def __init__(
+        self,
+        *,
+        t: _pft.annotate(float, minimum=-1.0, maximum=1.0) = 1.0,
+        r: _pft.annotate(float, minimum=-1.0, maximum=1.0) = 0.0,
+    ):
+        super().__init__(t=t, r=r)
+
+    def black_box_component(
+        self,
+        num_ports: int,
+        port_spec: str | _pf.PortSpec | None = None,
+        technology: _pf.Technology | None = None,
+        name: str | None = None,
+    ) -> _pf.Component:
+        """Create a black-box component using this model for testing.
+
+        Args:
+            port_spec: Port specification used in the component. If ``None``,
+              look for ``"port_spec"`` in :attr:`config.default_kwargs`.
+            technology: Component technology. If ``None``, the default
+              technology is used.
+            name: Component name. If ``None`` a default is used.
+
+        Returns:
+            Component with ports and model.
+        """
+        model_name = self.__class__.__name__[:-5]
+        component = _pf.Component(
+            f"BB{model_name}" if name is None else name, technology=technology
+        )
+
+        width = port_spec.width
+        length = width * 8
+
+        profiles = port_spec.path_profiles_list()
+        if len(profiles) == 0:
+            profiles = [(width, 0, _bb_layer)]
+
+        for w, g, layer in profiles:
+            component.add(layer, _pf.Path((0, 0), w, g).segment((length, 0)))
+
+        _add_bb_text(component, width)
+
+        if isinstance(num_ports, tuple):
+            num_by_size = {0: [0, 0], 90: [0, 0], -90: [0, 0], 180: [0, 0]}
+            for a in num_ports:
+                num_by_size[a][1] += 1
+            for a in num_ports:
+                i, n = num_by_size[a]
+                num_by_size[a][0] += 1
+                if a == 0 or a == 180:
+                    x = 0 if a == 0 else length
+                    y = 0 if n == 1 else (-width / 4 + width / 2 * i / (n - 1))
+                else:
+                    x = (length / 2) if n == 1 else (length / 4 + length / 2 * i / (n - 1))
+                    y = (-width / 2) if a == 90 else (width / 2)
+                component.add_port(_pf.Port((x, y), a, port_spec))
+        else:
+            for i in range(num_ports):
+                a = [0, 180, 90, -90][i % 4]
+                x = [0, length, length / 2, length / 2][i % 4]
+                y = [0, 0, -width / 2, width / 2][i % 4]
+                component.add_port(_pf.Port((x, y), a, port_spec))
+
+        component.add_model(self, model_name)
+        return component
+
+    def start(self, component, frequencies, **kwargs):
+        ports = component.select_ports("electrical")
+        port_names = sorted(ports.keys())
+        t = _np.full(len(frequencies), self.parametric_kwargs["t"], dtype=complex)
+        r = _np.full(len(frequencies), self.parametric_kwargs["r"], dtype=complex)
+        elements = {
+            **{(f"{port_names[i - 1]}@0", f"{port_names[i]}@0"): t for i in range(len(port_names))},
+            **{(f"{p}@0", f"{p}@0"): r for p in port_names},
+        }
+        return _pf.SMatrix(frequencies, elements, ports)
+
+
+_pf.register_model_class(_PassThroughModel)
+
+
 @_pf.parametric_component
 def straight_waveguide(
     *,
@@ -563,9 +647,9 @@ def electrical_termination(
     r_mag = float(_np.clip(r_mag, 0.0, 1.0))  # safety clamp
 
     # attach the model
-    model = _pf.TerminationModel(r=r_mag)
+    model = _PassThroughModel(r=r_mag)
     comp = model.black_box_component(
-        _pf.virtual_port_spec(classification="electrical"), name="Electrical Termination"
+        1, _pf.virtual_port_spec(classification="electrical"), name="Electrical Termination"
     )
     comp.properties.__thumbnail__ = "electrical_termination"
     return comp
@@ -766,7 +850,7 @@ def polarization_beam_splitter(
     r_01: complex = 0.0 + 0.0j,  # reflections at P0 (mode 1)
     r_11: complex = 0.0 + 0.0j,  # reflections at P1 (mode 1)
     r_21: complex = 0.0 + 0.0j,  # reflections at P2 (mode 1)
-    mode_routing: dict[int, int] = {0: 1, 1: 2},  # mode → preferred output port in {1,2}
+    mode_routing: _pft.annotate(_Sequence[int], minItems=2, maxItems=2) = (1, 2),
 ):
     """
     Polarization Beam Splitter (PBS), three ports, two modes, no mode mixing.
@@ -787,9 +871,8 @@ def polarization_beam_splitter(
         Reflection amplitudes at P0, P1, P2 for mode 0.
     r_01, r_11, r_21 : complex
         Reflection amplitudes at P0, P1, P2 for mode 1.
-    mode_routing : dict[int, int]
-        Maps mode index → preferred output port index in {1,2}. Default {0:1, 1:2}.
-        The “other” port is the remaining one in {1,2}.
+    mode_routing : tuple[int, int]
+        Maps mode index to preferred output port index in {1,2}.
 
     Notes
     -----
@@ -804,12 +887,11 @@ def polarization_beam_splitter(
     xm = [x_0, x_1]
     t1 = [0.0 + 0.0j, 0.0 + 0.0j]
     t2 = [0.0 + 0.0j, 0.0 + 0.0j]
-    for m in (0, 1):
-        pref = mode_routing.get(m, 1)  # default to port 1 if missing
+    for m, pref in enumerate(mode_routing):
         if pref == 1:
             t1[m] = tm[m]
             t2[m] = xm[m]
-        else:  # pref == 2
+        elif pref == 2:
             t1[m] = xm[m]
             t2[m] = tm[m]
 
@@ -848,7 +930,7 @@ def polarization_splitter_grating_coupler(
     r_01: complex = 0.0 + 0.0j,  # reflections at P0 (mode 1)
     r_11: complex = 0.0 + 0.0j,  # reflections at P1 (mode 1)
     r_21: complex = 0.0 + 0.0j,  # reflections at P2 (mode 1)
-    mode_routing: dict[int, int] = {0: 1, 1: 2},  # mode → preferred output port in {1,2}
+    mode_routing: _pft.annotate(_Sequence[int], minItems=2, maxItems=2) = (1, 2),
 ):
     """
     Polarization Splitter Grating Coupler (PSGC), three ports, two modes, no mode mixing.
@@ -873,9 +955,8 @@ def polarization_splitter_grating_coupler(
         Reflection amplitudes at ports P0, P1, P2 for mode 0.
     r_01, r_11, r_21 : complex
         Reflection amplitudes at ports P0, P1, P2 for mode 1.
-    mode_routing : dict[int, int]
-        Maps mode index → preferred output port index in {1,2}. Default {0:1, 1:2}.
-        The “other” port is the remaining one.
+    mode_routing : tuple[int, int]
+        Maps mode index to preferred output port index in {1,2}.
 
     Notes
     -----
@@ -887,12 +968,11 @@ def polarization_splitter_grating_coupler(
     xm = [x_0, x_1]
     t1 = [0.0 + 0.0j, 0.0 + 0.0j]
     t2 = [0.0 + 0.0j, 0.0 + 0.0j]
-    for m in (0, 1):
-        pref = mode_routing.get(m, 1)
+    for m, pref in enumerate(mode_routing):
         if pref == 1:
             t1[m] = tm[m]
             t2[m] = xm[m]
-        else:
+        elif pref == 2:
             t1[m] = xm[m]
             t2[m] = tm[m]
 
@@ -1345,8 +1425,8 @@ def photodiode(
 def signal_source(
     *,
     frequency: _pft.Frequency = 10e9,
-    amplitude: _pft.annotate(float, units="√W") = 1,
-    offset: _pft.annotate(float, units="√W") = 0,
+    amplitude: _pft.FieldAmplitude = 1,
+    offset: _pft.FieldAmplitude = 0,
     start: _pft.Time | None = None,
     stop: _pft.Time | None = None,
     skew: _pft.Fraction = 0.5,
@@ -1388,7 +1468,7 @@ def signal_source(
         prbs: PRBS polinomial degree. Value 0 disables PRBS.
         seed: Random number generator seed to ensure reproducibility.
     """
-    model = _pf.TerminationModel()
+    model = _PassThroughModel()
     model.time_stepper = _pf.WaveformTimeStepper(
         frequency=frequency,
         amplitude=amplitude,
@@ -1407,12 +1487,308 @@ def signal_source(
         prbs=prbs,
     )
     comp = _pf.Reference(
-        model.black_box_component(_pf.virtual_port_spec(classification="electrical")), rotation=180
+        model.black_box_component(1, _pf.virtual_port_spec(classification="electrical")),
+        rotation=180,
     ).transformed_component("Source")
     comp.properties.__thumbnail__ = "source"
     return comp
 
 
+@_pf.parametric_component
+def filter(
+    *,
+    family: _typ.Literal[
+        "digital",
+        "rc",
+        "butterworth",
+        "bessel",
+        "cheby1",
+        "rectangular",
+        "gaussian",
+    ] = "rc",
+    shape: _typ.Literal["lp", "hp", "bp", "bs"] = "lp",
+    f_cutoff: _pft.Frequency
+    | _pft.annotate(_Sequence[_pft.Frequency], minItems=2, maxItems=2) = 20e9,
+    order: _pft.PositiveInt = 1,
+    ripple: _pft.Loss = 0,
+    window: str
+    | tuple[str, float]
+    | tuple[str, float, float]
+    | tuple[str, _Sequence[float]] = "hann",
+    a: _Sequence[complex] = (1.0,),
+    b: _Sequence[complex] = (),
+    taps: _pft.PositiveInt = 101,
+    insertion_loss: _pft.Loss = 0,
+):
+    """Filter time stepper for electrical signals.
+
+    Args:
+        family: Filter family.
+        shape: Filter shape.
+        f_cutoff: Cutoff frequency for low- and high-pass filter shapes. For
+          ``family=="tunable_lp_rc"``, this can be an :class:`Interpolator`
+          to provide the dependency with the input voltage. For band-pass
+          and band-stop shapes, this is a 2-value sequence with low and high
+          cutoff frequencies.
+        order: Filter order.
+        ripple: Maximum ripple for Chebyshev filters.
+        window: Window specification for rectangular filters. Please consult
+          the help for ``scipy.signal.firwin`` for valid options.
+        a: Recursive (denominator) coefficients for a digital IIR filter.
+        b: Direct (numerator) coefficients for a digital FIR or IIR filter.
+        taps: Length of rectangular or Gaussian filters.
+        insertion_loss: Insertion loss added to the filter response.
+    """
+    model = _PassThroughModel()
+    model.time_stepper = _pf.FilterTimeStepper(
+        family=family,
+        shape=shape,
+        f_cutoff=f_cutoff,
+        order=order,
+        ripple=ripple,
+        window=window,
+        a=a,
+        b=b,
+        taps=taps,
+        insertion_loss=insertion_loss,
+    )
+    comp = model.black_box_component(
+        2, _pf.virtual_port_spec(classification="electrical"), name="Filter"
+    )
+    comp.properties.__thumbnail__ = "filter"
+    return comp
+
+
+# _interp = _pf.Interpolator([0, 10], [20e9, 25e9])
+#
+#
+# @_pf.parametric_component
+# def tunable_filter(
+#     *,
+#     f_cutoff: _pf.Interpolator = _interp,
+#     insertion_loss: _pft.Loss = 0,
+#     z0: _pft.Impedance = 50.0,
+# ):
+#     """Tunable first-order LP filter time stepper for electrical signals.
+#
+#     Args:
+#         f_cutoff: Voltage-dependent cutoff frequency.
+#         insertion_loss: Insertion loss added to the filter response.
+#         z0: Characteristic impedance of the electrical port used to convert
+#           the input control field amplitude to voltage.
+#     """
+#     model = _pf.DataModel(s_array=_np.zeros((1, 3, 3)), frequencies=[1e9])
+#     model.time_stepper = _pf.FilterTimeStepper(
+#         family="tunable_lp_rc", f_cutoff=f_cutoff, insertion_loss=insertion_loss, z0=z0
+#     )
+#     comp = model.black_box_component(
+#         _pf.virtual_port_spec(classification="electrical"), name="Filter"
+#     )
+#     comp.properties.__thumbnail__ = "filter"
+#     return comp
+
+
+@_pf.parametric_component
+def optical_amplifier(
+    *,
+    gain: _pft.Gain = 15,
+    noise_figure: _pft.Gain | None = None,
+    seed: _pft.NonNegativeInt | None = None,
+):
+    r"""Optical amplifier with constant gain.
+
+    Args:
+        gain: The amplifier's power gain.
+        noise_figure: The amplifier's noise figure (NF).
+        seed: Random number generator seed to ensure reproducibility.
+    """
+    model = _pf.TwoPortModel(t=1)
+    model.time_stepper = _pf.OpticalAmplifierTimeStepper(
+        gain=gain, noise_figure=noise_figure, seed=seed
+    )
+    comp = model.black_box_component(port_spec=_pf.virtual_port_spec(), name="Optical Amplifier")
+    comp.properties.__thumbnail__ = "optical_amplifier"
+    return comp
+
+
+@_pf.parametric_component
+def electrical_amplifier(
+    *,
+    gain: _pft.Gain = 15,
+    f_3dB: _pft.annotate(_pft.Frequency | None, label="f 3dB") = None,
+    saturation_power: _pft.Power_dBm | None = None,
+    compression_power: _pft.Power_dBm | None = None,
+    ip3: _pft.annotate(_pft.Power_dBm | None, label="IP3") = None,
+    noise_figure: _pft.Gain | None = None,
+    r0: _pft.annotate(float, minimum=-1, maximum=1) = 0,
+    r1: _pft.annotate(float, minimum=-1, maximum=1) = 0,
+    seed: _pft.NonNegativeInt | None = None,
+):
+    r"""Electrical amplifier with constant gain.
+
+    Args:
+        gain: The amplifier's power gain.
+        f_3dB: -3 dB frequency cutoff for bandwidth limiting.
+        saturation_power: Output saturation power.
+        compression_power: 1 dB compression power.
+        ip3: Third order intercept point.
+        noise_figure: The amplifier's noise figure (NF).
+        r0: Reflection coefficient for the input port.
+        r1: Reflection coefficient for the output port.
+        seed: Random number generator seed to ensure reproducibility.
+    """
+    model = _PassThroughModel()
+    model.time_stepper = _pf.ElectricalAmplifierTimeStepper(
+        gain=gain,
+        f_3dB=f_3dB,
+        saturation_power=saturation_power,
+        compression_power=compression_power,
+        ip3=ip3,
+        noise_figure=noise_figure,
+        r0=r0,
+        r1=r1,
+        seed=seed,
+    )
+    comp = model.black_box_component(
+        2, port_spec=_pf.virtual_port_spec(classification="electrical"), name="Electrical Amplifier"
+    )
+    comp.properties.__thumbnail__ = "electrical_amplifier"
+    return comp
+
+
+@_pf.parametric_component
+def scaler(*, scale: float = 1.0):
+    r"""Electrical scaler: constant gain multiplier.
+
+    Args:
+        scale: Output scaling factor.
+    """
+    model = _PassThroughModel()
+    model.time_stepper = _pf.ExpressionTimeStepper(expressions={"E1": f"{scale} * E0"})
+    comp = model.black_box_component(
+        2, port_spec=_pf.virtual_port_spec(classification="electrical"), name="Scaler"
+    )
+    comp.properties.__thumbnail__ = "electrical_amplifier"
+    return comp
+
+
+@_pf.parametric_component
+def absolute(*, scale: float = 1.0):
+    r"""Absolute value of the input signal.
+
+    Args:
+        scale: Output scaling factor.
+    """
+    model = _PassThroughModel()
+    model.time_stepper = _pf.ExpressionTimeStepper(expressions={"E1": f"{scale} * abs(E0)"})
+    comp = model.black_box_component(
+        2, port_spec=_pf.virtual_port_spec(classification="electrical"), name="Absolute"
+    )
+    comp.properties.__thumbnail__ = "electrical_absolute"
+    return comp
+
+
+@_pf.parametric_component
+def adder(*, scale: float = 1.0, weight0: float = 1.0, weight1: float = 1.0):
+    r"""Electrical adder: linearly combine 2 inputs.
+
+    Args:
+        scale: Output scaling factor.
+        weight0: Weight applied to the signal from the first port.
+        weight1: Weight applied to the signal from the second port.
+    """
+    model = _PassThroughModel()
+    model.time_stepper = _pf.ExpressionTimeStepper(
+        expressions={"E2": f"{scale} * ({weight0} * E0 + {weight1} * E1)"}
+    )
+    comp = model.black_box_component(
+        (0, 0, 180), port_spec=_pf.virtual_port_spec(classification="electrical"), name="Adder"
+    )
+    comp.properties.__thumbnail__ = "electrical_adder"
+    return comp
+
+
+@_pf.parametric_component
+def multiplier(*, scale: float = 1.0, exponent0: float = 1.0, exponent1: float = 1.0):
+    r"""Electrical multiplier: compute the product of 2 inputs.
+
+    Args:
+        scale: Output scaling factor.
+        exponent0: Exponent used for the first input. Fractional values will
+          fail on negative inputs.
+        exponent1: Exponent used for the second input. Fractional values
+          will fail on negative inputs.
+    """
+    model = _PassThroughModel()
+    model.time_stepper = _pf.ExpressionTimeStepper(
+        expressions={"E2": f"{scale} * (E0^{exponent0} * E1^{exponent1})"}
+    )
+    comp = model.black_box_component(
+        (0, 0, 180), port_spec=_pf.virtual_port_spec(classification="electrical"), name="Multiplier"
+    )
+    comp.properties.__thumbnail__ = "electrical_multiplier"
+    return comp
+
+
+@_pf.parametric_component
+def differentiator(
+    *, scale: float = 1.0, scheme: _typ.Literal["backwards", "central"] = "backwards"
+):
+    r"""Derivative of the input signal.
+
+    Args:
+        scheme: Differentiation scheme.
+        scale: Output scaling factor.
+    """
+    model = _PassThroughModel()
+    model.time_stepper = _pf.DifferentialTimeStepper(scheme=scheme, scale=scale)
+    comp = model.black_box_component(
+        2, port_spec=_pf.virtual_port_spec(classification="electrical"), name="Differentiator"
+    )
+    comp.properties.__thumbnail__ = "electrical_differential"
+    return comp
+
+
+@_pf.parametric_component
+def integrator(
+    *,
+    scale: float = 1.0,
+    start_value: _pft.FieldAmplitude = 0.0,
+    limits: _pft.annotate(_Sequence[_pft.FieldAmplitude | None], minItems=2, maxItems=2) = (
+        None,
+        None,
+    ),
+    reset_trigger: _typ.Literal["fall", "rise", "both"] = "rise",
+    reset_tolerance: float = 0.0,
+):
+    r"""Integral of the input signal.
+
+    Args:
+        scale: Output scaling factor.
+        start_value: Starting output value after reset.
+        limits: Output value limits.
+        reset_trigger: Type of edge used for triggering a reset.
+        reset_tolerance: Value change tolerance for triggering a reset.
+    """
+    model = _PassThroughModel()
+    model.time_stepper = _pf.IntegralTimeStepper(
+        scale=scale,
+        start_value=start_value,
+        limits=limits,
+        output_port="E2",
+        reset_port="E1",
+        reset_trigger=reset_trigger,
+        reset_tolerance=reset_tolerance,
+    )
+    comp = model.black_box_component(
+        (0, -90, 180),
+        port_spec=_pf.virtual_port_spec(classification="electrical"),
+        name="Integrator",
+    )
+    comp.properties.__thumbnail__ = "electrical_integral"
+    return comp
+
+
 if __name__ == "__main__":
     d = dict(locals())
 

photonforge/circuit_base.py

@@ -6,9 +6,7 @@ from typing import Any, Literal
 import numpy
 import tidy3d
 
-from .analytic_models import WaveguideModel
 from .cache import cache_s_matrix
-from .eme_model import EMEModel
 from .extension import (
     Z_INF,
     Component,
@@ -24,37 +22,9 @@ from .extension import (
     frequency_classification,
     snap_to_grid,
 )
-from .tidy3d_model import _ModeSolverRunner
-from .utils import C_0
-
-
-def _gather_status(*runners: Any) -> dict[str, Any]:
-    """Create an overall status based on a collection of runners."""
-    num_tasks = 0
-    progress = 0
-    message = "success"
-    tasks = {}
-    for task in runners:
-        task_status = (
-            {"progress": 100, "message": "success"} if isinstance(task, SMatrix) else task.status
-        )
-        inner_tasks = task_status.get("tasks", {})
-        tasks.update(inner_tasks)
-        task_weight = max(1, len(inner_tasks))
-        num_tasks += task_weight
-        if message != "error":
-            if task_status["message"] == "error":
-                message = "error"
-            elif task_status["message"] == "running":
-                message = "running"
-                progress += task_weight * task_status["progress"]
-            elif task_status["message"] == "success":
-                progress += task_weight * 100
-    if message == "running":
-        progress /= num_tasks
-    else:
-        progress = 100
-    return {"progress": progress, "message": message, "tasks": tasks}
+from .models.analytic import WaveguideModel
+from .models.tidy3d import EMEModel, _ModeSolverRunner
+from .utils import C_0, _angles_equal
 
 
 def _reference_ports(component, level, cache):
@@ -131,11 +101,6 @@ def _validate_query(
     return tuple(valid_key)
 
 
-def _compare_angles(a: float, b: float) -> bool:
-    r = (a - b) % 360
-    return r <= 1e-12 or 360 - r <= 1e-12
-
-
 # Return a flattening key (for caching) if flattening is required, and
 # a bool indicating whether phase correction is required
 def _analyze_transform(
@@ -153,7 +118,7 @@ def _analyze_transform(
     )
 
     translated = not numpy.allclose(reference.origin, (0, 0), atol=1e-12)
-    rotated = not _compare_angles(reference.rotation, 0)
+    rotated = not _angles_equal(reference.rotation, 0)
 
     if not uniform and (translated or rotated):
         return (tuple(reference.origin.tolist()), reference.rotation, reference.x_reflection), None
@@ -197,7 +162,7 @@ def _analyze_transform(
     )
 
     if (fully_anisotropic and rotated) or (
-        not in_plane_isotropic and rotated and not _compare_angles(reference.rotation, 180)
+        not in_plane_isotropic and rotated and not _angles_equal(reference.rotation, 180)
     ):
         return (None, reference.rotation, reference.x_reflection), None
 

photonforge/live_viewer.py

@@ -13,7 +13,7 @@ from fastapi.responses import StreamingResponse as _sr
 from fastapi.staticfiles import StaticFiles as _sf
 from fastapi.templating import Jinja2Templates as _j2
 
-import photonforge as _pf
+from .extension import __version__
 
 
 class LiveViewer:
@@ -38,7 +38,7 @@ class LiveViewer:
         self.app = _f.FastAPI(
             title="LiveViewer server",
             description="PhotonForge LiveViewer server",
-            version=_pf.__version__,
+            version=__version__,
         )
 
         self.app.add_middleware(