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

photonforge/{analytic_models.py → models/analytic.py}

@@ -9,9 +9,9 @@ from typing import Any, Literal
 
 import numpy
 
-from . import typing as pft
-from .cache import cache_s_matrix
-from .extension import (
+from .. import typing as pft
+from ..cache import cache_s_matrix
+from ..extension import (
     Component,
     Interpolator,
     Model,
@@ -28,8 +28,8 @@ from .extension import (
     register_model_class,
     text,
 )
-from .tidy3d_model import _ModeSolverRunner
-from .utils import C_0, route_length
+from ..utils import C_0, _angles_equal, _gather_status, route_length
+from .tidy3d import _align_and_overlap, _ModeSolverRunner
 
 _ComplexCoeff = pft.array(complex, 0, 2)
 _ComplexCoeff1D = pft.array(complex, 0, 1)
@@ -1693,27 +1693,33 @@ def _port_with_x_section(port_name, component):
 
 
 class _WaveguideModelRunner:
-    def __init__(self, runner, free_space_phase, frequencies, ports) -> None:
-        self.runner = runner
+    def __init__(self, runners, free_space_phase, frequencies, ports, overlap_mag_warning) -> None:
+        self.runners = runners
         self.free_space_phase = free_space_phase
         self.frequencies = frequencies
         self.ports = ports
+        self.overlap_mag_warning = overlap_mag_warning
         self._s_matrix = None
 
     @property
     def status(self):
-        return self.runner.status
+        return _gather_status(*self.runners)
 
     @property
     def s_matrix(self):
         if self._s_matrix is None:
-            data = self.runner.data
+            data = self.runners[0].data
             num_modes = next(iter(self.ports.values())).num_modes
+            overlap = (
+                _align_and_overlap(data, self.runners[1].data, self.overlap_mag_warning)[0]
+                if len(self.runners) > 1
+                else numpy.ones(num_modes)
+            )
             n_complex = data.n_complex.values.T
             s = numpy.exp(1j * self.free_space_phase * n_complex)
 
             elements = {
-                (f"{port_in}@{mode}", f"{port_out}@{mode}"): s[mode]
+                (f"{port_in}@{mode}", f"{port_out}@{mode}"): s[mode] * overlap[mode]
                 for port_in in self.ports
                 for port_out in self.ports
                 for mode in range(num_modes)
@@ -1936,20 +1942,38 @@ class WaveguideModel(Model):
                 port.spec.added_solver_modes = 0
 
         if n_type is str:
-            ms_port = _port_with_x_section(port_names[0], component)
+            ms_ports = (
+                _port_with_x_section(port_names[0], component),
+                _port_with_x_section(port_names[1], component),
+            )
         else:
-            ms_port = port0.copy(True)
+            ms_ports = (port0.copy(True), port1.copy(True))
             if n_type is PortSpec:
-                ms_port.spec = libcopy.deepcopy(self.n_complex)
-        runner = _ModeSolverRunner(
-            ms_port,
-            frequencies,
-            self.mesh_refinement,
-            component.technology,
-            cost_estimation=cost_estimation,
-            verbose=verbose,
+                ms_ports[0].spec = libcopy.deepcopy(self.n_complex)
+                ms_ports[1].spec = libcopy.deepcopy(self.n_complex)
+
+        rotation_fraction = (ms_ports[0].input_direction - ms_ports[1].input_direction) % 90
+        is_multiple_of_90 = rotation_fraction < 1e-12 or (90 - rotation_fraction < 1e-12)
+
+        ms_ports[1].input_direction += 180
+        if _angles_equal(ms_ports[1].input_direction, ms_ports[0].input_direction):
+            # No need for mode overlap calculation
+            ms_ports = ms_ports[:1]
+
+        runners = [
+            _ModeSolverRunner(
+                ms_port,
+                frequencies,
+                self.mesh_refinement,
+                component.technology,
+                cost_estimation=cost_estimation,
+                verbose=verbose,
+            )
+            for ms_port in ms_ports
+        ]
+        return _WaveguideModelRunner(
+            runners, free_space_phase, frequencies, component_ports, is_multiple_of_90
         )
-        return _WaveguideModelRunner(runner, free_space_phase, frequencies, component_ports)
 
     # Deprecated: kept for backwards compatibility with old phf files
     @classmethod
@@ -2057,11 +2081,11 @@ def _waveguide_transmission(
     dw = 2 * numpy.pi * (frequencies - reference_frequency)
     beta = beta0 + dw * (beta1 + dw * (beta2 / 2 + dw * beta3 / 6))
 
-    if v_piL is None:
+    if v_piL is None or v_piL == 0.0:
         beta_eo = 0.0
     else:
         beta_eo = numpy.pi * voltage / v_piL
-    t = 10 ** (total_loss / -20) * numpy.exp(1j * (beta + beta_eo) * length)
+    t = 10.0 ** (total_loss / -20.0) * numpy.exp(1j * (beta + beta_eo) * length)
     return t