Warn if too many frequencies; too many modes; or too many grid points in mode source or monitor

Author: momchil-flex

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- Warnings for too many frequencies in monitors; too many modes requested in a ``ModeSpec``; too many number of grid points in a mode monitor or mode source.
 
 ### Changed
 

tests/test_components/test_monitor.py

@@ -208,7 +208,7 @@ def test_monitor_colocate(log_capture):
 
     monitor = td.FieldMonitor(
         size=(td.inf, td.inf, td.inf),
-        freqs=np.linspace(0, 200e12, 10001),
+        freqs=np.linspace(0, 200e12, 1001),
         name="test",
         interval_space=(1, 2, 3),
     )
@@ -217,14 +217,40 @@ def test_monitor_colocate(log_capture):
 
     monitor = td.FieldMonitor(
         size=(td.inf, td.inf, td.inf),
-        freqs=np.linspace(0, 200e12, 10001),
+        freqs=np.linspace(0, 200e12, 1001),
         name="test",
         interval_space=(1, 2, 3),
         colocate=False,
     )
     assert monitor.colocate is False
 
 
+@pytest.mark.parametrize("freqs, log_level", [(np.arange(2500), "WARNING"), (np.arange(100), None)])
+def test_monitor_num_freqs(log_capture, freqs, log_level):
+    """test default colocate value, and warning if not set"""
+
+    monitor = td.FieldMonitor(
+        size=(td.inf, td.inf, td.inf),
+        freqs=freqs,
+        name="test",
+        colocate=True,
+    )
+    assert_log_level(log_capture, log_level)
+
+
+@pytest.mark.parametrize("num_modes, log_level", [(101, "WARNING"), (100, None)])
+def test_monitor_num_modes(log_capture, num_modes, log_level):
+    """test default colocate value, and warning if not set"""
+
+    monitor = td.ModeMonitor(
+        size=(td.inf, 0, td.inf),
+        freqs=np.linspace(1e14, 2e14, 100),
+        name="test",
+        mode_spec=td.ModeSpec(num_modes=num_modes),
+    )
+    assert_log_level(log_capture, log_level)
+
+
 def test_diffraction_validators():
 
     # ensure error if boundaries are not periodic

tests/test_components/test_simulation.py

@@ -1594,6 +1594,51 @@ def test_warn_large_epsilon(log_capture, size, num_struct, log_level):
     assert_log_level(log_capture, log_level)
 
 
+@pytest.mark.parametrize("dl, log_level", [(0.1, None), (0.005, "WARNING")])
+def test_warn_large_mode_monitor(log_capture, dl, log_level):
+    """Make sure we get a warning if the epsilon grid is too large."""
+
+    sim = td.Simulation(
+        size=(2.0, 2.0, 2.0),
+        grid_spec=td.GridSpec.uniform(dl=dl),
+        run_time=1e-12,
+        sources=[
+            td.ModeSource(
+                size=(0.1, 0.1, 0),
+                direction="+",
+                source_time=td.GaussianPulse(freq0=1, fwidth=0.1),
+            )
+        ],
+        monitors=[
+            td.ModeMonitor(
+                size=(td.inf, 0, td.inf), freqs=[1], name="test", mode_spec=td.ModeSpec()
+            )
+        ],
+    )
+    sim.validate_pre_upload()
+    assert_log_level(log_capture, log_level)
+
+
+@pytest.mark.parametrize("dl, log_level", [(0.1, None), (0.005, "WARNING")])
+def test_warn_large_mode_source(log_capture, dl, log_level):
+    """Make sure we get a warning if the epsilon grid is too large."""
+
+    sim = td.Simulation(
+        size=(2.0, 2.0, 2.0),
+        grid_spec=td.GridSpec.uniform(dl=dl),
+        run_time=1e-12,
+        sources=[
+            td.ModeSource(
+                size=(td.inf, td.inf, 0),
+                direction="+",
+                source_time=td.GaussianPulse(freq0=1, fwidth=0.1),
+            )
+        ],
+    )
+    sim.validate_pre_upload()
+    assert_log_level(log_capture, log_level)
+
+
 def test_dt():
     """make sure dt is reduced when there is a medium with eps_inf < 1."""
     sim = td.Simulation(

tests/test_package/test_log.py

@@ -70,7 +70,7 @@ def test_logging_warning_capture():
     # 1 warning: too long run_time
     run_time = 10000 / fwidth
 
-    # 1 warning: frequency outside of source frequency range
+    # 2 warnings: frequency outside of source frequency range; too many points
     mode_mnt = td.ModeMonitor(
         center=(0, 0, 0),
         size=(domain_size, 0, domain_size),
@@ -79,7 +79,7 @@ def test_logging_warning_capture():
         name="mode",
     )
 
-    # 1 warning: too high num_freqs
+    # 2 warnings: too high num_freqs; too many points
     mode_source = td.ModeSource(
         size=(domain_size, 0, domain_size),
         source_time=source_time,
@@ -214,7 +214,7 @@ def test_logging_warning_capture():
     sim.validate_pre_upload()
     warning_list = td.log.captured_warnings()
     print(json.dumps(warning_list, indent=4))
-    assert len(warning_list) == 30
+    assert len(warning_list) == 32
     td.log.set_capture(False)
 
     # check that capture doesn't change validation errors

tidy3d/components/monitor.py

@@ -20,6 +20,8 @@
 
 BYTES_REAL = 4
 BYTES_COMPLEX = 8
+WARN_NUM_FREQS = 2000
+WARN_NUM_MODES = 100
 
 
 class Monitor(Box, ABC):
@@ -146,6 +148,19 @@ def _freqs_non_empty(cls, val):
             raise ValidationError("'freqs' must not be empty.")
         return val
 
+    @pydantic.validator("freqs", always=True)
+    def _warn_num_freqs(cls, val, values):
+        """Warn if number of frequencies is too large."""
+        if len(val) > WARN_NUM_FREQS:
+            log.warning(
+                f"A large number ({len(val)}) of frequencies detected in monitor "
+                f"'{values['name']}'. This can lead to solver slow-down and increased cost. "
+                "Consider decreasing the number of frequencies in the monitor. This may become a "
+                "hard limit in future Tidy3D versions.",
+                custom_loc=["freqs"],
+            )
+        return val
+
     @cached_property
     def frequency_range(self) -> FreqBound:
         """Frequency range of the array ``self.freqs``.
@@ -256,14 +271,13 @@ class AbstractFieldMonitor(Monitor, ABC):
     @pydantic.validator("colocate", always=True)
     def warn_set_colocate(cls, val):
         """If ``colocate`` not provided, set to true, but warn that behavior has changed."""
-        with log as consolidated_logger:
-            if val is None:
-                consolidated_logger.warning(
-                    "Default value for the field monitor 'colocate' setting has changed to "
-                    "'True' in Tidy3D 2.4.0. All field components will be colocated to the grid "
-                    "boundaries. Set to 'False' to get the raw fields on the Yee grid instead."
-                )
-                return True
+        if val is None:
+            log.warning(
+                "Default value for the field monitor 'colocate' setting has changed to "
+                "'True' in Tidy3D 2.4.0. All field components will be colocated to the grid "
+                "boundaries. Set to 'False' to get the raw fields on the Yee grid instead."
+            )
+            return True
         return val
 
 
@@ -334,6 +348,20 @@ def _bend_axis(self) -> Axis:
         direction = self.unpop_axis(0, in_plane, axis=self.normal_axis)
         return direction.index(1)
 
+    @pydantic.validator("mode_spec", always=True)
+    def _warn_num_modes(cls, val, values):
+        """Warn if number of modes is too large."""
+        if val.num_modes > WARN_NUM_MODES:
+            log.warning(
+                f"A large number ({val.num_modes}) of modes requested in monitor "
+                f"'{values['name']}'. This can lead to solver slow-down and increased cost. "
+                "Consider decreasing the number of modes and using 'ModeSpec.target_neff' "
+                "to target the modes of interest. This may become a hard limit in future "
+                "Tidy3D versions.",
+                custom_loc=["mode_spec", "num_modes"],
+            )
+        return val
+
 
 class FieldMonitor(AbstractFieldMonitor, FreqMonitor):
     """:class:`Monitor` that records electromagnetic fields in the frequency domain.

tidy3d/components/simulation.py

@@ -30,8 +30,9 @@
 from .structure import Structure
 from .source import SourceType, PlaneWave, GaussianBeam, AstigmaticGaussianBeam, CustomFieldSource
 from .source import CustomCurrentSource, CustomSourceTime
-from .source import TFSF, Source
+from .source import TFSF, Source, ModeSource
 from .monitor import MonitorType, Monitor, FreqMonitor, SurfaceIntegrationMonitor
+from .monitor import AbstractModeMonitor, FieldMonitor
 from .monitor import PermittivityMonitor, DiffractionMonitor, AbstractFieldProjectionMonitor
 from .data.dataset import Dataset
 from .data.data_array import SpatialDataArray
@@ -64,6 +65,7 @@
 MAX_CELLS_TIMES_STEPS = 1e16
 WARN_MONITOR_DATA_SIZE_GB = 10
 MAX_SIMULATION_DATA_SIZE_GB = 50
+WARN_MODE_NUM_CELLS = 1e5
 
 # number of grid cells at which we warn about slow Simulation.epsilon()
 NUM_CELLS_WARN_EPSILON = 100_000_000
@@ -996,6 +998,7 @@ def validate_pre_upload(self, source_required: bool = True) -> None:
         log.begin_capture()
         self._validate_size()
         self._validate_monitor_size()
+        self._validate_modes_size()
         self._validate_datasets_not_none()
         self._validate_tfsf_structure_intersections()
         # self._validate_run_time()
@@ -1058,6 +1061,43 @@ def _validate_monitor_size(self) -> None:
                 f"a maximum of {MAX_SIMULATION_DATA_SIZE_GB:.2f}GB are allowed."
             )
 
+    def _validate_modes_size(self) -> None:
+        """Warn if mode sources or monitors have a large number of points."""
+
+        def warn_mode_size(monitor: AbstractModeMonitor, msg_header: str, custom_loc: List):
+            """Warn if a mode component has a large number of points."""
+            num_cells = np.prod(self.discretize_monitor(monitor).num_cells)
+            if num_cells > WARN_MODE_NUM_CELLS:
+                consolidated_logger.warning(
+                    msg_header + f"has a large number ({num_cells:1.2e}) of grid points. "
+                    "This can lead to solver slow-down and increased cost. "
+                    "Consider making the size of the component smaller, as long as the modes "
+                    "of interest decay by the plane boundaries.",
+                    custom_loc=custom_loc,
+                )
+
+        with log as consolidated_logger:
+            for src_ind, source in enumerate(self.sources):
+                if isinstance(source, ModeSource):
+                    # Make a monitor so we can call ``discretize_monitor``
+                    monitor = FieldMonitor(
+                        center=source.center,
+                        size=source.size,
+                        name="tmp",
+                        freqs=[source.source_time.freq0],
+                        colocate=False,
+                    )
+                    msg_header = f"Mode source at sources[{src_ind}] "
+                    custom_loc = ["sources", src_ind]
+                    warn_mode_size(monitor=monitor, msg_header=msg_header, custom_loc=custom_loc)
+
+        with log as consolidated_logger:
+            for mnt_ind, monitor in enumerate(self.monitors):
+                if isinstance(monitor, AbstractModeMonitor):
+                    msg_header = f"Mode monitor '{monitor.name}' "
+                    custom_loc = ["monitors", mnt_ind]
+                    warn_mode_size(monitor=monitor, msg_header=msg_header, custom_loc=custom_loc)
+
     @cached_property
     def monitors_data_size(self) -> Dict[str, float]:
         """Dictionary mapping monitor names to their estimated storage size in bytes."""

tidy3d/components/source.py

@@ -33,6 +33,8 @@
 DATA_SPAN_TOL = 1e-8
 # width of Chebyshev grid used for broadband sources (in units of pulse width)
 CHEB_GRID_WIDTH = 1.5
+# Number of frequencies in a broadband source above which to issue a warning
+WARN_NUM_FREQS = 20
 
 
 class SourceTime(ABC, Tidy3dBaseModel):
@@ -743,12 +745,11 @@ def _warn_if_large_number_of_freqs(cls, val):
         if val is None:
             return val
 
-        if val >= 20:
+        if val >= WARN_NUM_FREQS:
             log.warning(
                 f"A large number ({val}) of frequency points is used in a broadband source. "
-                "This can slow down simulation time and is only needed if the mode fields are "
-                "expected to have a very sharp frequency dependence. 'num_freqs' < 20 is "
-                "sufficient in most cases.",
+                "This can lead to solver slow-down and increased cost, and even introduce "
+                "numerical noise. This may become a hard limit in future Tidy3D versions.",
                 custom_loc=["num_freqs"],
             )