fix(source_time): more accurate frequency_range and central frequency

Author: weiliangjin2021

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Bug in `WavePort` when more than one mode is requested in the `ModeSpec`.
 - Solver error for named 2D materials with inhomogeneous substrates.
 - In `Tidy3dBaseModel` the hash (and cached `.json_string`) are now sensitive to changes in `.attrs`.
+- More accurate frequency range for ``GaussianPulse`` when DC is removed.
 
 ## [v2.10.0rc2] - 2025-10-01
 

tests/test_components/autograd/test_autograd.py

@@ -2555,7 +2555,7 @@ def test_background_medium():
 
 class TestTidyArrayBox:
     def test_is_tidy_box(self):
-        da = DataArray(tracer_arr, dims=map(str, range(tracer_arr.ndim)))
+        da = DataArray(tracer_arr, dims=tuple(map(str, range(tracer_arr.ndim))))
         assert is_tidy_box(da.data)
 
     def test_real(self):

tests/test_components/test_simulation.py

@@ -21,6 +21,7 @@
 from ..utils import (
     SIM_FULL,
     AssertLogLevel,
+    AssertLogStr,
     cartesian_to_unstructured,
     run_emulated,
 )
@@ -257,8 +258,12 @@ def place_box(center_offset):
             center = shift_amount * amp * sign
             if np.sum(center) < 1e-12:
                 continue
-            with AssertLogLevel(log_level):
-                place_box(tuple(center))
+            if log_level is None:
+                with AssertLogStr("WARNING", excludes_str="outside of the simulation domain"):
+                    place_box(tuple(center))
+            else:
+                with AssertLogStr("WARNING", contains_str="outside of the simulation domain"):
+                    place_box(tuple(center))
 
 
 def test_sim_size():
@@ -1593,7 +1598,7 @@ def test_warn_lumped_elements_outside_sim_bounds():
         resistance=50,
         name="resistor_inside",
     )
-    with AssertLogLevel("INFO"):
+    with AssertLogStr("WARNING", excludes_str="not completely inside"):
         sim_good = td.Simulation(
             size=sim_size,
             center=sim_center,
@@ -1612,7 +1617,7 @@ def test_warn_lumped_elements_outside_sim_bounds():
         resistance=50,
         name="resistor_touching",
     )
-    with AssertLogLevel("INFO"):
+    with AssertLogStr("WARNING", excludes_str="not completely inside"):
         sim_good = td.Simulation(
             size=sim_size,
             center=sim_center,
@@ -1631,7 +1636,7 @@ def test_warn_lumped_elements_outside_sim_bounds():
         resistance=50,
         name="resistor_outside",
     )
-    with AssertLogLevel("WARNING"):
+    with AssertLogStr("WARNING", contains_str="not completely inside"):
         sim_bad = sim_good.updated_copy(lumped_elements=[resistor_out])
     assert len(sim_bad.volumetric_structures) == 0
 
@@ -1643,7 +1648,7 @@ def test_warn_lumped_elements_outside_sim_bounds():
         resistance=50,
         name="resistor_edge",
     )
-    with AssertLogLevel("WARNING"):
+    with AssertLogStr("WARNING", contains_str="not completely inside"):
         sim_bad = sim_good.updated_copy(lumped_elements=[resistor_edge])
     assert len(sim_bad.volumetric_structures) == 0
 

tests/test_components/test_source.py

@@ -11,7 +11,7 @@
 from tidy3d.components.source.field import CHEB_GRID_WIDTH, DirectionalSource
 from tidy3d.exceptions import SetupError
 
-from ..utils import AssertLogLevel
+from ..utils import AssertLogLevel, AssertLogStr
 
 ST = td.GaussianPulse(freq0=2e14, fwidth=1e14)
 S = td.PointDipole(source_time=ST, polarization="Ex")
@@ -133,6 +133,11 @@ def test_gaussian_from_frequency_range():
     g2 = td.GaussianPulse.from_frequency_range(fmin=fmin, fmax=fmax)
     assert g2.remove_dc_component
 
+    with AssertLogLevel("WARNING", contains_str="not sufficiently large"):
+        g_small = td.GaussianPulse.from_frequency_range(
+            fmin=fmin, fmax=60e9, remove_dc_component=True
+        )
+
     # 1) broadband: assert enough amplitude at fmin and fmax
     time = np.linspace(0, 5 / fmin, 10001)
     freqs = np.linspace(fmin, fmax, 101)
@@ -150,6 +155,23 @@ def test_gaussian_from_frequency_range():
     assert abs(g.freq0 - fmin) / fmin < 1e-4
 
 
+def test_gaussian_frequency_sigma_range():
+    sigma = 4
+    # derivative Gaussian
+    g = td.GaussianPulse.from_frequency_range(fmin=1e9, fmax=10e9, remove_dc_component=True)
+    f_range = g.frequency_range_sigma(sigma=sigma)
+    peak_amp = np.abs(g.amp_freq(g.peak_frequency))
+    amp = np.array([np.abs(g.amp_freq(f)) for f in f_range])
+    assert f_range[1] > f_range[0]
+    assert np.allclose(amp / peak_amp, np.exp(-(sigma**2) / 2))
+    # freq0 from frequency_range_sigma is larger than freq0
+    assert g._freq0_sigma_centroid > g._freq0
+
+    # pure Gaussian
+    g = td.GaussianPulse.from_frequency_range(fmin=1e9, fmax=10e9, remove_dc_component=False)
+    assert np.allclose(g.frequency_range(num_fwidth=sigma), g.frequency_range_sigma(sigma=sigma))
+
+
 def test_frequency_source_width():
     """Ensure the source bandwidth has a lower bound regardless of the input frequencies."""
 
@@ -357,7 +379,7 @@ def get_pol_dir(axis, pol_angle=0, angle_theta=0, angle_phi=0):
 def test_broadband_source():
     g = td.GaussianPulse(freq0=1e12, fwidth=0.1e12)
     mode_spec = td.ModeSpec(num_modes=2)
-    fmin, fmax = g.frequency_range(num_fwidth=CHEB_GRID_WIDTH)
+    fmin, fmax = g.frequency_range_sigma(sigma=CHEB_GRID_WIDTH)
     fdiff = (fmax - fmin) / 2
     fmean = (fmax + fmin) / 2
 
@@ -659,3 +681,17 @@ def test_source_frame():
         size=(1, 1, 0),
         frame=td.PECFrame(),
     )
+
+
+def test_rf_frequency_range_miswarning():
+    """GaussianPulse with DC removed is asymmetric. More accurate frequency range
+    computation for validating if it's a photonics simulation.
+    """
+    source_time = td.GaussianPulse(freq0=400e12, fwidth=99.999e12)
+    source = td.PointDipole(center=(0, 0, 0), polarization="Ex", source_time=source_time)
+    with AssertLogStr("WARNING", excludes_str="outside of the simulation domain"):
+        sim = td.Simulation(
+            size=(1, 1, 1),
+            run_time=td.RunTimeSpec(quality_factor=1),
+            sources=[source],
+        )

tests/utils.py

@@ -1597,6 +1597,59 @@ def assert_log_level(
             )
 
 
+def assert_str_in_log(
+    records: list[tuple[int, str]],
+    log_level_test: str,
+    excludes_str: Optional[str] = None,
+    contains_str: Optional[str] = None,
+) -> None:
+    """Testing tool: Raises error if `excludes_str` appears , or `contains_str` doesn't appear at the test log level.
+    Unlike ``assert_log_level``, we don't raise error if the ``log_level_test`` is not present in the records.
+
+    Parameters
+    ----------
+    records : List[Tuple[int, str]]
+        List of (log_level: int, message: str) holding all of the captured logs.
+    log_level_test: str
+        String version of the log level for checking string (all uppercase).
+    excludes_str : str = None
+        If specified, errors if found in any of the log messages that are at level
+        ``log_level_test``.
+    contains_str : str = None
+        If specified, errors if not found in any of the log messages that are at level
+        ``log_level_test``.
+
+    Returns
+    -------
+        None
+    """
+
+    import sys
+
+    sys.stderr.write(str(records) + "\n")
+
+    # do nothing for None log level
+    if log_level_test is None:
+        return
+
+    log_level_test_int = _get_level_int(log_level_test)
+    contains_str_found = False
+    for log in records:
+        log_level, log_message = log
+        if log_level == log_level_test_int:
+            if excludes_str is not None and excludes_str in log_message:
+                raise AssertionError(
+                    f"Log record at level '{log_level_test}' contained '{excludes_str}'."
+                )
+            if contains_str is not None and contains_str in log_message:
+                contains_str_found = True
+
+    if contains_str and not contains_str_found:
+        raise AssertionError(
+            f"Log record at level '{log_level_test}' did not contain '{contains_str}'."
+        )
+
+
 class AssertLogLevelHandler:
     """Log handler used to store log records during assertion."""
 
@@ -1608,8 +1661,8 @@ def handle(self, level, level_name, message):
 
 
 @dataclasses.dataclass
-class AssertLogLevel:
-    """Context manager to check log level for records logged within its context."""
+class AbstractAssertLog:
+    """Context manager to check logs."""
 
     log_level_expected: Union[str, None]
     contains_str: str = None
@@ -1630,6 +1683,11 @@ def __enter__(self):
         td.log.handlers["assert_log_level"] = self.handler
         return self
 
+
+@dataclasses.dataclass
+class AssertLogLevel(AbstractAssertLog):
+    """Context manager to check log level for records logged within its context."""
+
     def __exit__(self, exc_type, exc_value, traceback):
         # Check the records and clean up
         assert_log_level(
@@ -1641,6 +1699,24 @@ def __exit__(self, exc_type, exc_value, traceback):
         del td.log.handlers["assert_log_level"]
 
 
+@dataclasses.dataclass
+class AssertLogStr(AbstractAssertLog):
+    """Context manager to check if log contains certain strings at the test log level for records logged within its context."""
+
+    excludes_str: str = None
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        # Check the records and clean up
+        assert_str_in_log(
+            records=self.records,
+            log_level_test=self.log_level_expected,
+            excludes_str=self.excludes_str,
+            contains_str=self.contains_str,
+        )
+        # Remove handler
+        del td.log.handlers["assert_log_level"]
+
+
 def get_test_root_dir():
     """return the root folder of test code"""
 

tidy3d/components/boundary.py

@@ -311,7 +311,7 @@ def from_source(
         """
 
         if freq_spec is None:
-            freq_spec = source.source_time.freq0
+            freq_spec = source.source_time._freq0
 
         return cls(
             plane=source.bounding_box,
@@ -528,7 +528,7 @@ def from_source(
         if medium is None:
             medium = Medium(permittivity=1.0, name="free_space")
 
-        freq0 = source.source_time.freq0
+        freq0 = source.source_time._freq0
         eps_complex = medium.eps_model(freq0)
         kmag = np.real(freq0 * np.sqrt(eps_complex * EPSILON_0 * MU_0))
 

tidy3d/components/data/sim_data.py

@@ -1157,7 +1157,7 @@ def _adjoint_src_width_single(adj_srcs: list[SourceType]) -> list[SourceType]:
         adj_srcs_process_fwidth = []
         for adj_src in adj_srcs:
             source_time = adj_src.source_time
-            freq0 = source_time.freq0
+            freq0 = source_time._freq0
 
             fwidth = np.minimum(freq0 / NUM_ADJOINT_FWIDTH_TO_ZERO, source_time.fwidth)
 
@@ -1184,16 +1184,16 @@ def _process_adjoint_sources(self, adj_srcs: list[SourceType]) -> list[AdjointSo
 
         # Group sources by frequency or port, whichever gives fewer groups
         num_ports = len(hashes_to_src_times)
-        num_unique_freqs = len({src.source_time.freq0 for src in adj_srcs_process_fwidth})
+        num_unique_freqs = len({src.source_time._freq0 for src in adj_srcs_process_fwidth})
 
         log.info(f"Found {num_ports} spatial ports and {num_unique_freqs} unique frequencies.")
 
         adjoint_infos = []
         if num_unique_freqs <= num_ports:
             log.info("Grouping adjoint sources by frequency.")
-            unique_freqs = {src.source_time.freq0 for src in adj_srcs_process_fwidth}
+            unique_freqs = {src.source_time._freq0 for src in adj_srcs_process_fwidth}
             for freq0 in unique_freqs:
-                group = [src for src in adj_srcs_process_fwidth if src.source_time.freq0 == freq0]
+                group = [src for src in adj_srcs_process_fwidth if src.source_time._freq0 == freq0]
                 post_norm = xr.DataArray(data=np.array([1 + 0j]), coords={"f": [freq0]})
                 adjoint_infos.append(
                     AdjointSourceInfo(sources=group, post_norm=post_norm, normalize_sim=True)
@@ -1247,7 +1247,7 @@ def _process_adjoint_sources_broadband(
     def _adjoint_src_width_broadband(adj_srcs: list[SourceType]) -> float:
         """Find the adjoint source fwidth that sufficiently covers all adjoint frequencies."""
 
-        adj_srcs_f0 = [adj_src.source_time.freq0 for adj_src in adj_srcs]
+        adj_srcs_f0 = [adj_src.source_time._freq0 for adj_src in adj_srcs]
         middle_f0 = 0.5 * (np.max(adj_srcs_f0) + np.min(adj_srcs_f0))
         min_f0 = np.min(adj_srcs_f0)
 
@@ -1294,7 +1294,7 @@ def _make_post_norm_amps(adj_srcs: list[SourceType]) -> xr.DataArray:
         amps_complex = []
         for src in adj_srcs:
             src_time = src.source_time
-            freqs.append(src_time.freq0)
+            freqs.append(src_time._freq0)
             amp_complex = src_time.amplitude * np.exp(1j * src_time.phase)
             amps_complex.append(amp_complex)
 

tidy3d/components/grid/grid_spec.py

@@ -2241,7 +2241,7 @@ def wavelength_from_sources(sources: list[SourceType]) -> pd.PositiveFloat:
             )
 
         # Use central frequency of sources, if any.
-        freqs = np.array([source.source_time.freq0 for source in sources])
+        freqs = np.array([source.source_time._freq0 for source in sources])
 
         # multiple sources of different central frequencies
         if not np.all(np.isclose(freqs, freqs[0])):

tidy3d/components/grid/mesher.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 import warnings
 from abc import ABC, abstractmethod
 from itertools import compress
@@ -1347,8 +1348,10 @@ def fun_scale(new_scale):
 
             # solve for new scaling factor
             # let's not raise exception here, but manually check the convergence.
+            logger = logging.getLogger("pyroots")
+            logger.setLevel(logging.CRITICAL)
             root_scalar = Brentq(raise_on_fail=False, epsilon=_ROOTS_TOL)
-            sol_scale = root_scalar(fun_scale, 1, max_scale)
+            sol_scale = root_scalar(fun_scale, xa=1, xb=max_scale)
 
             # convergence check based on pyroots API and manual evaluation of the function.
             if sol_scale.converged and abs(fun_scale(sol_scale.x0)) <= _ROOTS_TOL: