prototype interpolated_data property

Author: dbochkov-flexcompute

tests/test_components/test_mode_interp.py

@@ -8,7 +8,7 @@
 
 import tidy3d as td
 from tidy3d.plugins.mode import ModeSolver
-from tidy3d.plugins.smatrix.ports.wave import DEFAULT_WAVE_PORT_MODE_SPEC
+# from tidy3d.plugins.smatrix.ports.wave import DEFAULT_WAVE_PORT_MODE_SPEC
 
 from ..test_data.test_data_arrays import MODE_SPEC, SIZE_2D
 from ..utils import AssertLogLevel
@@ -323,11 +323,11 @@ def get_mode_solver_data():
     from tidy3d.components.data.data_array import GroupIndexDataArray, ModeDispersionDataArray
 
     from ..test_data.test_data_arrays import (
-        make_scalar_mode_field_data_array,
+        make_scalar_mode_field_data_array, SIM
     )
     from ..test_data.test_monitor_data import N_COMPLEX
 
-    freqs = np.linspace(1e14, 2e14, 5)
+    freqs = N_COMPLEX.f.data
     num_modes = len(N_COMPLEX.mode_index)
     mode_indices = np.arange(num_modes)
     mode_spec = td.ModeSpec(num_modes=num_modes, sort_spec=td.ModeSortSpec(track_freq="central"))
@@ -337,6 +337,7 @@ def get_mode_solver_data():
         freqs=freqs,
         mode_spec=mode_spec,
         name="test_monitor",
+        colocate=False,
     )
 
     # Create n_group_raw and dispersion_raw with same shape as n_complex
@@ -353,18 +354,18 @@ def get_mode_solver_data():
     # Create mode data with the right frequencies
     mode_data = td.ModeSolverData(
         monitor=monitor,
-        Ex=make_scalar_mode_field_data_array("Ex"),
-        Ey=make_scalar_mode_field_data_array("Ey"),
-        Ez=make_scalar_mode_field_data_array("Ez"),
-        Hx=make_scalar_mode_field_data_array("Hx"),
-        Hy=make_scalar_mode_field_data_array("Hy"),
-        Hz=make_scalar_mode_field_data_array("Hz"),
-        n_complex=N_COMPLEX.copy(),
+        Ex=make_scalar_mode_field_data_array("Ex", symmetry=False),
+        Ey=make_scalar_mode_field_data_array("Ey", symmetry=False),
+        Ez=make_scalar_mode_field_data_array("Ez", symmetry=False),
+        Hx=make_scalar_mode_field_data_array("Hx", symmetry=False),
+        Hy=make_scalar_mode_field_data_array("Hy", symmetry=False),
+        Hz=make_scalar_mode_field_data_array("Hz", symmetry=False),
+        n_complex=N_COMPLEX,
         n_group_raw=n_group_raw,
         dispersion_raw=dispersion_raw,
         symmetry=(0, 0, 0),
         symmetry_center=(0, 0, 0),
-        grid_expanded=td.Grid(boundaries=td.Coords(x=[0, 1], y=[0, 1], z=[0, 1])),
+        grid_expanded=SIM.discretize_monitor(monitor),
     )
     return mode_data
 
@@ -425,23 +426,24 @@ def test_mode_solver_data_interp_cheb():
         freqs=freqs_cheb,
         mode_spec=mode_spec,
         name="test_cheb",
+        colocate=False,
     )
 
-    from ..test_data.test_data_arrays import make_scalar_mode_field_data_array
+    from ..test_data.test_data_arrays import make_scalar_mode_field_data_array, SIM
     from ..test_data.test_monitor_data import N_COMPLEX
 
     mode_data = td.ModeSolverData(
         monitor=monitor,
-        Ex=make_scalar_mode_field_data_array("Ex"),
-        Ey=make_scalar_mode_field_data_array("Ey"),
-        Ez=make_scalar_mode_field_data_array("Ez"),
-        Hx=make_scalar_mode_field_data_array("Hx"),
-        Hy=make_scalar_mode_field_data_array("Hy"),
-        Hz=make_scalar_mode_field_data_array("Hz"),
+        Ex=make_scalar_mode_field_data_array("Ex", symmetry=False),
+        Ey=make_scalar_mode_field_data_array("Ey", symmetry=False),
+        Ez=make_scalar_mode_field_data_array("Ez", symmetry=False),
+        Hx=make_scalar_mode_field_data_array("Hx", symmetry=False),
+        Hy=make_scalar_mode_field_data_array("Hy", symmetry=False),
+        Hz=make_scalar_mode_field_data_array("Hz", symmetry=False),
         n_complex=N_COMPLEX.copy(),
         symmetry=(0, 0, 0),
         symmetry_center=(0, 0, 0),
-        grid_expanded=td.Grid(boundaries=td.Coords(x=[0, 1], y=[0, 1], z=[0, 1])),
+        grid_expanded=SIM.discretize_monitor(monitor),
     )
 
     # Interpolate to 50 frequencies
@@ -895,7 +897,7 @@ def test_mode_monitor_interp_spec_none():
 # ============================================================================
 
 
-def make_wave_port():
+def make_wave_port(num_interp_points=3, method="linear"):
     """Make a WavePort."""
     from tidy3d.components.microwave.path_integrals.integrals.current import (
         AxisAlignedCurrentIntegral,
@@ -907,20 +909,18 @@ def make_wave_port():
         size=(1, 1, 0),
         direction="+",
         name="port1",
-        current_integral=AxisAlignedCurrentIntegral(
-            center=(0, 0, 0),
-            size=(1, 1, 0),
-            sign="+",
-            extrapolate_to_endpoints=True,
-            snap_contour_to_grid=True,
+        mode_spec=td.MicrowaveModeSpec(
+            num_modes=1,
+            sort_spec=td.ModeSortSpec(track_freq="central"),
+            interp_spec=td.ModeInterpSpec(num_points=num_interp_points, method=method),
         ),
     )
 
 
 def test_wave_port_to_monitors_propagates_default_interp_spec():
     """Test that WavePort.to_monitors() propagates default interp_spec to ModeMonitor."""
 
-    port = make_wave_port()
+    port = make_wave_port(num_interp_points=3, method="linear")
 
     freqs = np.linspace(1e14, 2e14, 20)
     monitors = port.to_monitors(freqs=freqs)
@@ -931,14 +931,14 @@ def test_wave_port_to_monitors_propagates_default_interp_spec():
     assert monitor.mode_spec.interp_spec is not None
     assert (
         monitor.mode_spec.interp_spec.num_points
-        == DEFAULT_WAVE_PORT_MODE_SPEC.interp_spec.num_points
+        == 3
     )
-    assert monitor.mode_spec.interp_spec.method == DEFAULT_WAVE_PORT_MODE_SPEC.interp_spec.method
+    assert monitor.mode_spec.interp_spec.method == "linear"
 
 
 def test_wave_port_to_monitors_propagates_custom_interp_spec():
     """Test that WavePort.to_monitors() propagates custom interp_spec to ModeMonitor."""
-    custom_mode_spec = td.ModeSpec(
+    custom_mode_spec = td.MicrowaveModeSpec(
         num_modes=1,
         sort_spec=td.ModeSortSpec(track_freq="central"),
         interp_spec=td.ModeInterpSpec(num_points=8, method="cheb"),
@@ -958,7 +958,7 @@ def test_wave_port_to_monitors_propagates_custom_interp_spec():
 
 def test_wave_port_to_monitors_propagates_none_interp_spec():
     """Test that WavePort.to_monitors() propagates interp_spec=None to ModeMonitor."""
-    mode_spec_no_interp = td.ModeSpec(
+    mode_spec_no_interp = td.MicrowaveModeSpec(
         num_modes=1, sort_spec=td.ModeSortSpec(track_freq="central"), interp_spec=None
     )
     port = make_wave_port().updated_copy(mode_spec=mode_spec_no_interp)

tidy3d/components/base.py

@@ -1397,3 +1397,16 @@ def __getattribute__(self, name: str):
 
     _LazyProxy.__name__ = proxy_name
     return _LazyProxy
+
+
+class InterpolatableMixin(Tidy3dBaseModel):
+    """Mixin to add a `reduce_data` field to a model."""
+
+    reduce_data: bool = pydantic.Field(
+        False,
+        title="Reduce Data",
+        description="If `mode_spec.interp_spec` is defined, one can use this flag "
+        "to record fields and quatities only at interpolation source frequency points. "
+        "The :class:`.ModeMonitorData` at requested frequencies can be obtain through "
+        "the :attr:`.ModeMonitorData.interpolated_copy` property.",
+    )

tidy3d/components/data/monitor_data.py

@@ -2504,7 +2504,7 @@ def interp_in_freq(
         self,
         freqs: FreqArray,
         method: Literal["linear", "cubic", "cheb"] = "linear",
-        renormalize: Optional[bool] = False,
+        renormalize: Optional[bool] = True,
     ) -> ModeSolverData:
         """Interpolate mode data to new frequency points.
 
@@ -2524,8 +2524,11 @@ def interp_in_freq(
             frequencies), ``"cheb"`` for Chebyshev polynomial interpolation using barycentric
             formula (requires 3+ source frequencies at Chebyshev nodes).
             For complex-valued data, real and imaginary parts are interpolated independently.
-        renormalize : Optional[bool] = False
+        renormalize : Optional[bool] = True
             Whether to renormalize the mode profiles to unity power after interpolation.
+        recalculate_grid_correction : Optional[bool] = True
+            Whether to recalculate the grid correction after interpolation or use interpolated
+            grid corrections.
 
         Returns
         -------
@@ -2614,13 +2617,23 @@ def interp_in_freq(
         update_dict["monitor"] = self.monitor.updated_copy(freqs=list(freqs))
 
         updated_data = self.updated_copy(**update_dict)
-        # print(updated_data.poynting)
-        # print(updated_data._diff_area)
         if renormalize:
             updated_data._normalize_modes()
 
         return updated_data
 
+    @property
+    def interpolated_copy(self) -> ModeSolverData:
+        """Return a copy of the data with interpolated fields."""
+        if self.monitor.mode_spec.interp_spec is None or not self.monitor.reduce_data:
+            return self
+        return self.interp_in_freq(
+            freqs=self.monitor.freqs,
+            method=self.monitor.mode_spec.interp_spec.method,
+            renormalize=True,
+            monitor=self.monitor.updated_copy(reduce_data=False),
+        )
+
     @property
     def time_reversed_copy(self) -> FieldData:
         """Make a copy of the data with direction-reversed fields. In lossy or gyrotropic systems,

tidy3d/components/microwave/data/monitor_data.py

@@ -324,22 +324,6 @@ def _apply_mode_reorder(self, sort_inds_2d):
             )
         return main_data_reordered
 
-    def interp_in_freq(
-        self,
-        freqs: FreqArray,
-        method: Literal["linear", "cubic", "cheb", "nearest"] = "linear",
-        renormalize: Optional[bool] = True,
-    ) -> MicrowaveModeData:
-        """Interpolate mode data to new frequency points."""
-        main_data_interp = super().interp_in_freq(freqs, method, renormalize)
-        if self.transmission_line_data is not None:
-            update_dict = self.transmission_line_data._interp_in_freq_update_dict(freqs, method)
-            transmission_line_data_interp = self.transmission_line_data.updated_copy(**update_dict)
-            main_data_interp = main_data_interp.updated_copy(
-                transmission_line_data=transmission_line_data_interp
-            )
-        return main_data_interp
-
 
 class MicrowaveModeSolverData(ModeSolverData, MicrowaveModeData):
     """
@@ -413,3 +397,70 @@ class MicrowaveModeSolverData(ModeSolverData, MicrowaveModeData):
     monitor: MicrowaveModeSolverMonitor = pd.Field(
         ..., title="Monitor", description="Mode monitor associated with the data."
     )
+
+    def interp_in_freq(
+        self,
+        freqs: FreqArray,
+        method: Literal["linear", "cubic", "cheb", "nearest"] = "linear",
+        renormalize: Optional[bool] = True,
+    ) -> MicrowaveModeData:
+        """Interpolate mode data to new frequency points.
+
+        Interpolates all stored mode data (effective indices, field components, group indices,
+        and dispersion) from the current frequency grid to a new set of frequencies. This is
+        useful for obtaining mode data at many frequencies from computations at fewer frequencies,
+        when modes vary smoothly with frequency.
+
+        Parameters
+        ----------
+        freqs : FreqArray
+            New frequency points to interpolate to. Should generally span a similar range
+            as the original frequencies to avoid extrapolation.
+        method : Literal["linear", "cubic", "cheb"]
+            Interpolation method. ``"linear"`` for linear interpolation (requires 2+ source
+            frequencies), ``"cubic"`` for cubic spline interpolation (requires 4+ source
+            frequencies), ``"cheb"`` for Chebyshev polynomial interpolation using barycentric
+            formula (requires 3+ source frequencies at Chebyshev nodes).
+            For complex-valued data, real and imaginary parts are interpolated independently.
+        renormalize : Optional[bool] = True
+            Whether to renormalize the mode profiles to unity power after interpolation.
+
+        Returns
+        -------
+        ModeSolverData
+            New :class:`ModeSolverData` object with data interpolated to the requested frequencies.
+
+        Raises
+        ------
+        DataError
+            If interpolation parameters are invalid (e.g., too few source frequencies for the
+            chosen method, or source frequencies not at Chebyshev nodes for 'cheb' method).
+
+        Note
+        ----
+            Interpolation assumes modes vary smoothly with frequency. Results may be inaccurate
+            near mode crossings or regions of rapid mode variation. Use frequency tracking
+            (``mode_spec.sort_spec.track_freq``) to help maintain mode ordering consistency.
+
+            For Chebyshev interpolation, source frequencies must be at Chebyshev nodes of the
+            second kind within the frequency range.
+
+        Example
+        -------
+        >>> # Compute modes at 5 frequencies
+        >>> import numpy as np
+        >>> freqs_sparse = np.linspace(1e14, 2e14, 5)
+        >>> # ... create mode_solver and compute modes ...
+        >>> # mode_data = mode_solver.solve()
+        >>> # Interpolate to 50 frequencies
+        >>> freqs_dense = np.linspace(1e14, 2e14, 50)
+        >>> # mode_data_interp = mode_data.interp(freqs=freqs_dense, method='linear')
+        """
+        main_data_interp = super().interp_in_freq(freqs, method, renormalize)
+        if self.transmission_line_data is not None:
+            update_dict = self.transmission_line_data._interp_in_freq_update_dict(freqs, method)
+            transmission_line_data_interp = self.transmission_line_data.updated_copy(**update_dict)
+            main_data_interp = main_data_interp.updated_copy(
+                transmission_line_data=transmission_line_data_interp
+            )
+        return main_data_interp