another revision

Author: dbochkov-flexcompute

schemas/EMESimulation.json

@@ -8168,6 +8168,10 @@
           "minimum": 2,
           "type": "integer"
         },
+        "reduce_data": {
+          "default": false,
+          "type": "boolean"
+        },
         "type": {
           "default": "ModeInterpSpec",
           "enum": [
@@ -8374,10 +8378,6 @@
           "minLength": 1,
           "type": "string"
         },
-        "reduce_data": {
-          "default": false,
-          "type": "boolean"
-        },
         "size": {
           "anyOf": [
             {

schemas/ModeSimulation.json

@@ -7374,6 +7374,10 @@
           "minimum": 2,
           "type": "integer"
         },
+        "reduce_data": {
+          "default": false,
+          "type": "boolean"
+        },
         "type": {
           "default": "ModeInterpSpec",
           "enum": [
@@ -7812,10 +7816,6 @@
           "minLength": 1,
           "type": "string"
         },
-        "reduce_data": {
-          "default": false,
-          "type": "boolean"
-        },
         "size": {
           "anyOf": [
             {

schemas/Simulation.json

@@ -11002,10 +11002,6 @@
           "minLength": 1,
           "type": "string"
         },
-        "reduce_data": {
-          "default": false,
-          "type": "boolean"
-        },
         "size": {
           "anyOf": [
             {
@@ -11344,6 +11340,10 @@
           "minimum": 2,
           "type": "integer"
         },
+        "reduce_data": {
+          "default": false,
+          "type": "boolean"
+        },
         "type": {
           "default": "ModeInterpSpec",
           "enum": [
@@ -11782,10 +11782,6 @@
           "minLength": 1,
           "type": "string"
         },
-        "reduce_data": {
-          "default": false,
-          "type": "boolean"
-        },
         "size": {
           "anyOf": [
             {

schemas/TerminalComponentModeler.json

@@ -11344,10 +11344,6 @@
           "minLength": 1,
           "type": "string"
         },
-        "reduce_data": {
-          "default": false,
-          "type": "boolean"
-        },
         "size": {
           "anyOf": [
             {
@@ -11686,6 +11682,10 @@
           "minimum": 2,
           "type": "integer"
         },
+        "reduce_data": {
+          "default": false,
+          "type": "boolean"
+        },
         "type": {
           "default": "ModeInterpSpec",
           "enum": [
@@ -12124,10 +12124,6 @@
           "minLength": 1,
           "type": "string"
         },
-        "reduce_data": {
-          "default": false,
-          "type": "boolean"
-        },
         "size": {
           "anyOf": [
             {

tests/test_components/test_mode_interp.py

@@ -27,19 +27,22 @@ def test_interp_spec_valid_linear():
     spec = td.ModeInterpSpec(num_points=5, method="linear")
     assert spec.num_points == 5
     assert spec.method == "linear"
+    assert not spec.reduce_data  # default value
 
 
 def test_interp_spec_valid_cubic():
     """Test creating valid ModeInterpSpec with cubic interpolation."""
     spec = td.ModeInterpSpec(num_points=10, method="cubic")
     assert spec.num_points == 10
     assert spec.method == "cubic"
+    assert not spec.reduce_data  # default value
 
 
 def test_interp_spec_default_method():
-    """Test that default method is 'linear'."""
+    """Test that default method is 'linear' and reduce_data is False."""
     spec = td.ModeInterpSpec(num_points=5)
     assert spec.method == "linear"
+    assert not spec.reduce_data
 
 
 def test_interp_spec_cubic_needs_4_points():
@@ -117,6 +120,22 @@ def test_interp_spec_invalid_method():
         td.ModeInterpSpec(num_points=5, method="quadratic")
 
 
+def test_interp_spec_reduce_data_true():
+    """Test creating ModeInterpSpec with reduce_data=True."""
+    spec = td.ModeInterpSpec(num_points=5, method="linear", reduce_data=True)
+    assert spec.num_points == 5
+    assert spec.method == "linear"
+    assert spec.reduce_data
+
+
+def test_interp_spec_reduce_data_false():
+    """Test creating ModeInterpSpec with reduce_data=False (explicit)."""
+    spec = td.ModeInterpSpec(num_points=5, method="linear", reduce_data=False)
+    assert spec.num_points == 5
+    assert spec.method == "linear"
+    assert not spec.reduce_data
+
+
 def test_interp_spec_requires_tracking():
     """Test that ModeMonitor with interp_spec requires track_freq."""
 
@@ -291,12 +310,13 @@ def test_mode_solver_warns_num_points():
     plane = td.Box(center=(0, 0, 0), size=SIZE_2D)
 
     with AssertLogLevel("WARNING", contains_str="Interpolation will be skipped"):
-        ModeSolver(
+        ms = ModeSolver(
             simulation=sim,
             plane=plane,
             freqs=FREQS_DENSE,
             mode_spec=mode_spec,
         )
+        _ = ms.data_raw
 
 
 def test_mode_solver_interp_spec_none():
@@ -643,15 +663,19 @@ def test_mode_solver_data_interp_extrapolation_warning():
 
 
 def test_mode_solver_with_interp():
-    """Test that ModeSolver uses interpolation when interp_spec is provided."""
+    """Test that ModeSolver uses interpolation when interp_spec is provided.
+
+    With reduce_data=False (default), data_raw returns automatically interpolated data
+    with all requested frequencies.
+    """
     sim = get_simple_sim()
 
-    # Create solver with 10 frequencies
+    # Create solver with 10 frequencies, reduce_data=False (default)
     freqs = np.linspace(1e14, 2e14, 10)
     mode_spec = td.ModeSpec(
         num_modes=2,
         sort_spec=td.ModeSortSpec(track_freq="central"),
-        interp_spec=td.ModeInterpSpec(num_points=3, method="linear"),
+        interp_spec=td.ModeInterpSpec(num_points=3, method="linear", reduce_data=False),
     )
 
     solver_with_interp = ModeSolver(
@@ -664,10 +688,11 @@ def test_mode_solver_with_interp():
     # The solver should have the original 10 frequencies
     assert len(solver_with_interp.freqs) == 10
 
-    # The returned data should have 10 frequencies
+    # With reduce_data=False, data_raw automatically interpolates and returns all 10 frequencies
     data = solver_with_interp.data_raw
     assert len(data.monitor.freqs) == 10
     assert data.n_complex.shape[0] == 10
+    assert not data.reduced_data  # After interpolation, reduced_data is False
 
 
 def test_mode_solver_creates_reduced_freqs():
@@ -752,7 +777,7 @@ def test_mode_solver_interp_cheb():
     mode_spec = td.ModeSpec(
         num_modes=2,
         sort_spec=td.ModeSortSpec(track_freq="central"),
-        interp_spec=td.ModeInterpSpec(num_points=5, method="cheb"),
+        interp_spec=td.ModeInterpSpec(num_points=5, method="cheb", reduce_data=False),
     )
 
     solver = ModeSolver(
@@ -762,6 +787,8 @@ def test_mode_solver_interp_cheb():
         mode_spec=mode_spec,
     )
 
+    _ = solver._data_on_yee_grid()
+
     data = solver.data_raw
     assert len(data.monitor.freqs) == 20
     assert data.n_complex.shape[0] == 20
@@ -785,6 +812,44 @@ def test_mode_solver_without_interp_returns_full_data():
     data = solver.data_raw
     assert len(data.monitor.freqs) == 10
     assert data.n_complex.shape[0] == 10
+    assert not data.reduced_data
+
+
+def test_mode_solver_with_reduce_data_true():
+    """Test that ModeSolver with reduce_data=True returns data at reduced frequencies.
+
+    With reduce_data=True, data_raw returns data computed only at the reduced set
+    of frequencies. The monitor in the data also has only the reduced frequencies.
+    """
+    sim = get_simple_sim()
+
+    # Create solver with 20 frequencies but reduce_data=True
+    freqs = np.linspace(1e14, 2e14, 20)
+    mode_spec = td.ModeSpec(
+        num_modes=2,
+        sort_spec=td.ModeSortSpec(track_freq="central"),
+        interp_spec=td.ModeInterpSpec(num_points=5, method="linear", reduce_data=True),
+    )
+
+    solver = ModeSolver(
+        simulation=sim,
+        plane=td.Box(center=(0, 0, 0), size=SIZE_2D),
+        freqs=freqs,
+        mode_spec=mode_spec,
+    )
+
+    # With reduce_data=True, data_raw returns data at only 5 frequencies
+    data = solver.data_raw
+    assert len(data._stored_freqs) == 5  # Only the reduced frequencies
+    assert len(data.monitor.freqs) == 20  # All frequencies
+    assert data.n_complex.shape[0] == 5
+    assert data.reduced_data
+
+    # interpolated_copy will interpolate to monitor.freqs, but since the monitor
+    # only has the reduced frequencies, it just returns the same frequencies
+    data_interpolated = data.interpolated_copy
+    assert len(data_interpolated.monitor.freqs) == 20  # Still only 5 frequencies
+    assert not data_interpolated.reduced_data  # But now marked as non-reduced
 
 
 # ============================================================================
@@ -890,6 +955,71 @@ def test_mode_monitor_interp_spec_none():
     assert monitor.mode_spec.interp_spec is None
 
 
+def test_mode_solver_monitor_reduce_data_property():
+    """Test that ModeSolverMonitor.reduce_data property works correctly."""
+    freqs = np.linspace(1e14, 2e14, 10)
+
+    # With reduce_data=True
+    mode_spec = td.ModeSpec(
+        num_modes=2,
+        sort_spec=td.ModeSortSpec(track_freq="central"),
+        interp_spec=td.ModeInterpSpec(num_points=3, method="linear", reduce_data=True),
+    )
+    monitor = td.ModeSolverMonitor(
+        center=(0, 0, 0),
+        size=SIZE_2D,
+        freqs=freqs,
+        mode_spec=mode_spec,
+        name="test",
+    )
+    assert monitor.reduce_data
+
+
+def test_mode_solver_reduce_data_property():
+    """Test that ModeSolver.reduce_data property works correctly."""
+    sim = get_simple_sim()
+    freqs = np.linspace(1e14, 2e14, 10)
+    plane = td.Box(center=(0, 0, 0), size=SIZE_2D)
+
+    # With reduce_data=True
+    mode_spec_true = td.ModeSpec(
+        num_modes=2,
+        sort_spec=td.ModeSortSpec(track_freq="central"),
+        interp_spec=td.ModeInterpSpec(num_points=3, method="linear", reduce_data=True),
+    )
+    solver_true = ModeSolver(
+        simulation=sim,
+        plane=plane,
+        freqs=freqs,
+        mode_spec=mode_spec_true,
+    )
+    assert solver_true.reduce_data
+
+    # With reduce_data=False
+    mode_spec_false = td.ModeSpec(
+        num_modes=2,
+        sort_spec=td.ModeSortSpec(track_freq="central"),
+        interp_spec=td.ModeInterpSpec(num_points=3, method="linear", reduce_data=False),
+    )
+    solver_false = ModeSolver(
+        simulation=sim,
+        plane=plane,
+        freqs=freqs,
+        mode_spec=mode_spec_false,
+    )
+    assert not solver_false.reduce_data
+
+    # Without interp_spec
+    mode_spec_none = td.ModeSpec(num_modes=2, sort_spec=td.ModeSortSpec(track_freq="central"))
+    solver_none = ModeSolver(
+        simulation=sim,
+        plane=plane,
+        freqs=freqs,
+        mode_spec=mode_spec_none,
+    )
+    assert not solver_none.reduce_data
+
+
 # ============================================================================
 # WavePort interp_spec Tests
 # ============================================================================

tidy3d/components/base.py

@@ -1415,16 +1415,3 @@ 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.",
-    )