Fixed overlap_sort to use the same value of the conjugated_dot_product field

Added the conjugated_dot_product field to ModeSimulation and ModeSolver

Author: dmarek-flex

CHANGELOG.md

@@ -42,7 +42,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed `ElectromagneticFieldData.to_zbf()` to support single frequency monitors and apply the correct flattening order.
 - Bug in `TerminalComponentModeler.get_antenna_metrics_data` when port amplitudes are set to zero.
 - Added missing `solver_version` keyword argument to `run_async`.
-- Fixed `interpn` data array method to be compatible with extrapolation outside of data array coordinates. 
+- Fixed `interpn` data array method to be compatible with extrapolation outside of data array coordinates.
+- Fixed `overlap_sort` to use the same value of the `conjugated_dot_product` field in `ModeMonitor`, and added the `conjugated_dot_product` field to `ModeSolver` and `ModeSimulation`.
 
 ## [2.9.0] - 2025-08-04
 

schemas/ModeSimulation.json

@@ -162,9 +162,11 @@ def make_mode_solver_data():
     return mode_data_norm
 
 
-def make_mode_solver_data_smooth():
+def make_mode_solver_data_smooth(conjugated_dot_product: bool = True):
     mode_data = ModeData(
-        monitor=MODE_MONITOR_WITH_FIELDS,
+        monitor=MODE_MONITOR_WITH_FIELDS.updated_copy(
+            conjugated_dot_product=conjugated_dot_product
+        ),
         Ex=make_scalar_mode_field_data_array_smooth("Ex", rot=0.13 * np.pi),
         Ey=make_scalar_mode_field_data_array_smooth("Ey", rot=0.26 * np.pi),
         Ez=make_scalar_mode_field_data_array_smooth("Ez", rot=0.39 * np.pi),
@@ -668,7 +670,8 @@ def test_diffraction_data_use_medium():
     assert np.allclose(data.eta, np.real(td.ETA_0 / 2.0))
 
 
-def test_mode_solver_data_sort():
+@pytest.mark.parametrize("conjugated_dot_product", [True, False])
+def test_mode_solver_data_sort(conjugated_dot_product):
     # test basic matching algorithm
     arr = np.array([[1, 2, 3], [6, 5, 4], [7, 9, 8]])
     pairs, values = ModeData._find_closest_pairs(arr)
@@ -677,7 +680,7 @@ def test_mode_solver_data_sort():
 
     # test sorting function
     # get smooth data
-    data = make_mode_solver_data_smooth()
+    data = make_mode_solver_data_smooth(conjugated_dot_product=conjugated_dot_product)
     # make it unsorted
     num_modes = len(data.Ex.coords["mode_index"])
     num_freqs = len(data.Ex.coords["f"])

schemas/TerminalComponentModeler.json

@@ -1639,7 +1639,7 @@ def overlap_sort(
         frequency according to their overlap values with the modes at the previous frequency.
         That is, it attempts to rearrange modes in such a way that a given ``mode_index``
         corresponds to physically the same mode at all frequencies. Modes with overlap values over
-        ``overlap_tresh`` are considered matching and not rearranged.
+        ``overlap_thresh`` are considered matching and not rearranged.
 
         Parameters
         ----------
@@ -1664,12 +1664,20 @@ def overlap_sort(
         elif track_freq == "central":
             f0_ind = num_freqs // 2
 
+        # Normalizing the flux to 1, does not guarantee self terms of overlap integrals
+        # are also normalized to 1 when the non-conjugated product is used.
+        if self.monitor.conjugated_dot_product:
+            self_overlap = np.ones((num_freqs, num_modes))
+        else:
+            self_overlap = np.abs(self.dot(self, self.monitor.conjugated_dot_product).values)
+            threshold_array = overlap_thresh * self_overlap
+
         # Compute sorting order and overlaps with neighboring frequencies
         sorting = -np.ones((num_freqs, num_modes), dtype=int)
         overlap = np.zeros((num_freqs, num_modes))
         phase = np.zeros((num_freqs, num_modes))
         sorting[f0_ind, :] = np.arange(num_modes)  # base frequency won't change
-        overlap[f0_ind, :] = np.ones(num_modes)
+        overlap[f0_ind, :] = self_overlap[f0_ind, :]
 
         # Sort in two directions from the base frequency
         for step, last_ind in zip([-1, 1], [-1, num_freqs]):
@@ -1678,6 +1686,9 @@ def overlap_sort(
 
             # March to lower/higher frequencies
             for freq_id in range(f0_ind + step, last_ind, step):
+                # Calculate threshold array for this frequency
+                if not self.monitor.conjugated_dot_product:
+                    overlap_thresh = threshold_array[freq_id, :]
                 # Get next frequency to sort
                 data_to_sort = self._isel(f=[freq_id])
                 # Assign to the base frequency so that outer_dot will compare them
@@ -1746,15 +1757,14 @@ def _assign_coords(self, **assign_coords_kwargs):
     def _find_ordering_one_freq(
         self,
         data_to_sort: ModeData,
-        overlap_thresh: float,
+        overlap_thresh: Union[float, np.array],
     ) -> tuple[Numpy, Numpy]:
         """Find new ordering of modes in data_to_sort based on their similarity to own modes."""
-
         num_modes = self.n_complex.sizes["mode_index"]
 
         # Current pairs and their overlaps
         pairs = np.arange(num_modes)
-        complex_amps = self.dot(data_to_sort).data.ravel()
+        complex_amps = self.dot(data_to_sort, self.monitor.conjugated_dot_product).data.ravel()
         if self.monitor.store_fields_direction == "-":
             complex_amps *= -1
 
@@ -1768,7 +1778,7 @@ def _find_ordering_one_freq(
         data_template_reduced = self._isel(mode_index=modes_to_sort)
 
         amps_reduced = data_template_reduced.outer_dot(
-            data_to_sort._isel(mode_index=modes_to_sort)
+            data_to_sort._isel(mode_index=modes_to_sort), self.monitor.conjugated_dot_product
         ).to_numpy()[0, :, :]
 
         if self.monitor.store_fields_direction == "-":

tests/test_data/test_monitor_data.py

@@ -170,6 +170,12 @@ class ModeSolver(Tidy3dBaseModel):
         "primal grid nodes). Default is ``True``.",
     )
 
+    conjugated_dot_product: bool = pydantic.Field(
+        True,
+        title="Conjugated Dot Product",
+        description="Use conjugated or non-conjugated dot product for mode decomposition.",
+    )
+
     fields: tuple[EMField, ...] = pydantic.Field(
         ["Ex", "Ey", "Ez", "Hx", "Hy", "Hz"],
         title="Field Components",
@@ -1949,6 +1955,7 @@ def to_monitor(
             size=self.plane.size,
             freqs=freqs,
             mode_spec=self.mode_spec,
+            conjugated_dot_product=self.conjugated_dot_product,
             name=name,
         )
 
@@ -1981,6 +1988,7 @@ def to_mode_solver_monitor(
             freqs=self.freqs,
             direction=self.direction,
             colocate=colocate,
+            conjugated_dot_product=self.conjugated_dot_product,
             name=name,
         )
 

tidy3d/components/data/monitor_data.py

@@ -43,6 +43,7 @@
     "freqs",
     "direction",
     "colocate",
+    "conjugated_dot_product",
     "fields",
 ]
 # attributes shared between ModeSimulation class and AbstractYeeGridSimulation
@@ -136,6 +137,12 @@ class ModeSimulation(AbstractYeeGridSimulation):
         "primal grid nodes). Default is ``True``.",
     )
 
+    conjugated_dot_product: bool = pd.Field(
+        True,
+        title="Conjugated Dot Product",
+        description="Use conjugated or non-conjugated dot product for mode decomposition.",
+    )
+
     fields: tuple[EMField, ...] = pd.Field(
         ["Ex", "Ey", "Ez", "Hx", "Hy", "Hz"],
         title="Field Components",