clean up

Author: dbochkov-flexcompute

tests/test_components/test_absorbers.py

@@ -557,7 +557,7 @@ def test_abc_boundaries_broadband():
         _ = td.BroadbandModeABCFitterParam(frequency_sampling_points=0)
     # test frequency sampling points <= 21
     with pytest.raises(pydantic.ValidationError):
-        _ = td.BroadbandModeABCFitterParam(frequency_sampling_points=22)
+        _ = td.BroadbandModeABCFitterParam(frequency_sampling_points=102)
 
     # test basic instance
     fmin = 100e12

tests/test_plugins/smatrix/test_terminal_component_modeler.py

@@ -8,6 +8,7 @@
 import xarray as xr
 
 import tidy3d as td
+from tidy3d.components.boundary import BroadbandModeABCSpec
 from tidy3d.components.data.data_array import FreqDataArray
 from tidy3d.exceptions import SetupError, Tidy3dError, Tidy3dKeyError
 from tidy3d.plugins.microwave import (
@@ -1296,3 +1297,45 @@ def check_S_matrix(S_computed, S_expected, tol=1e-12):
     # Check power wave S matrix
     S_computed = modeler._internal_construct_smatrix(batch_data, s_param_def="power").values
     check_S_matrix(S_computed, S_power)
+
+
+def test_wave_port_to_absorber(tmp_path):
+    """Test that wave port absorber can be specified as a boolean, ABCBoundary, or ModeABCBoundary."""
+
+    # test automatic absorber
+    modeler = make_coaxial_component_modeler(
+        path_dir=str(tmp_path), port_types=(WavePort, WavePort)
+    )
+    sim = list(modeler.sim_dict.values())[0]
+
+    absorber = sim.internal_absorbers[0]
+
+    assert absorber.boundary_spec.mode_spec == modeler.ports[0].mode_spec
+    assert absorber.boundary_spec.mode_index == modeler.ports[0].mode_index
+    assert absorber.boundary_spec.plane == modeler.ports[0].geometry
+    assert absorber.boundary_spec.freq_spec == BroadbandModeABCSpec(
+        frequency_range=(np.min(modeler.freqs), np.max(modeler.freqs))
+    )
+
+    # test to_absorber()
+    absorber = modeler.ports[0].to_absorber(freq_spec=1e9)
+    assert absorber.boundary_spec.freq_spec == 1e9
+
+    absorber = modeler.ports[0].to_absorber(
+        freq_spec=BroadbandModeABCSpec(frequency_range=(1e9, 2e9))
+    )
+    assert absorber.boundary_spec.freq_spec == BroadbandModeABCSpec(frequency_range=(1e9, 2e9))
+
+    # test no automatic absorber
+    modeler = modeler.updated_copy(ports=[modeler.ports[0].updated_copy(absorber=False)])
+    sim = list(modeler.sim_dict.values())[0]
+    assert len(sim.internal_absorbers) == 0
+
+    # test custom boundary spec
+    custom_boundary_spec = td.ModeABCBoundary(plane=td.Box(size=(0.1, 0.1, 0)), freq_spec=1e9)
+    modeler = modeler.updated_copy(
+        ports=[modeler.ports[0].updated_copy(absorber=custom_boundary_spec)]
+    )
+    sim = list(modeler.sim_dict.values())[0]
+    absorber = sim.internal_absorbers[0]
+    assert absorber.boundary_spec == custom_boundary_spec

tidy3d/components/boundary.py

@@ -59,7 +59,7 @@ def _warn_num_layers(cls, val):
 DEFAULT_BROADBAND_MODE_ABC_NUM_FREQS = 15
 DEFAULT_BROADBAND_MODE_ABC_NUM_POLES = 5
 MAX_BROADBAND_MODE_ABC_NUM_POLES = 10
-MAX_BROADBAND_MODE_ABC_NUM_FREQS = 21
+MAX_BROADBAND_MODE_ABC_NUM_FREQS = 101
 
 
 class BoundaryEdge(ABC, Tidy3dBaseModel):
@@ -175,7 +175,7 @@ class BroadbandModeABCSpec(Tidy3dBaseModel):
 
     Example
     -------
-    >>> broadband_mode_abc_spec = BroadbandModeABCSpec(frequency_range=(fmin=100e12, fmax=120e12), fit_param=BroadbandModeABCFitterParam())
+    >>> broadband_mode_abc_spec = BroadbandModeABCSpec(frequency_range=(100e12, 120e12), fit_param=BroadbandModeABCFitterParam())
     """
 
     frequency_range: FreqBound = pd.Field(
@@ -273,13 +273,19 @@ def is_plane(cls, val):
         return val
 
     @classmethod
-    def from_source(cls, source: ModeSource) -> ModeABCBoundary:
+    def from_source(
+        cls,
+        source: ModeSource,
+        freq_spec: Optional[Union[pd.PositiveFloat, BroadbandModeABCSpec]] = None,
+    ) -> ModeABCBoundary:
         """Instantiate from a ``ModeSource``.
 
         Parameters
         ----------
         source : :class:`ModeSource`
             Mode source.
+        freq_spec : Optional[Union[pd.PositiveFloat, BroadbandModeABCSpec]] = None
+            Specifies the frequency at which field is absorbed. If ``None``, then the central frequency of the source is used. If ``BroadbandModeABCSpec``, then the field is absorbed over the specified frequency range.
 
         Returns
         -------
@@ -294,11 +300,14 @@ def from_source(cls, source: ModeSource) -> ModeABCBoundary:
         >>> abc_boundary = ModeABCBoundary.from_source(source=source)
         """
 
+        if freq_spec is None:
+            freq_spec = source.source_time.freq0
+
         return cls(
             plane=source.bounding_box,
             mode_spec=source.mode_spec,
             mode_index=source.mode_index,
-            freq_spec=source.source_time.freq0,
+            freq_spec=freq_spec,
         )
 
     @classmethod
@@ -1137,13 +1146,19 @@ def mode_abc(
         return cls(plus=plus, minus=minus)
 
     @classmethod
-    def mode_abc_from_source(cls, source: ModeSource):
+    def mode_abc_from_source(
+        cls,
+        source: ModeSource,
+        freq_spec: Optional[Union[pd.PositiveFloat, BroadbandModeABCSpec]] = None,
+    ):
         """One-way wave equation mode ABC boundary specification on both sides along a dimension constructed from a mode source.
 
         Parameters
         ----------
         source : :class:`ModeSource`
             Mode source.
+        freq_spec : Optional[Union[pd.PositiveFloat, BroadbandModeABCSpec]] = None
+            Specifies the frequency at which field is absorbed. If ``None``, then the central frequency of the source is used. If ``BroadbandModeABCSpec``, then the field is absorbed over the specified frequency range.
 
         Example
         -------
@@ -1152,8 +1167,8 @@ def mode_abc_from_source(cls, source: ModeSource):
         >>> source = ModeSource(size=(1, 1, 0), source_time=pulse, direction='+')
         >>> abc = Boundary.mode_abc_from_source(source=source)
         """
-        plus = ModeABCBoundary.from_source(source=source)
-        minus = ModeABCBoundary.from_source(source=source)
+        plus = ModeABCBoundary.from_source(source=source, freq_spec=freq_spec)
+        minus = ModeABCBoundary.from_source(source=source, freq_spec=freq_spec)
         return cls(plus=plus, minus=minus)
 
     @classmethod

tidy3d/plugins/smatrix/component_modelers/terminal.py

@@ -255,7 +255,9 @@ def base_sim(self) -> Simulation:
                 ] + self._shift_value_signed(wave_port)
                 port_absorber = wave_port.to_absorber(
                     snap_center=mode_src_pos,
-                    freq_spec=BroadbandModeABCSpec(frequency_range=(self.freqs, self.freqs)),
+                    freq_spec=BroadbandModeABCSpec(
+                        frequency_range=(np.min(self.freqs), np.max(self.freqs))
+                    ),
                 )
                 new_absorbers.append(port_absorber)
 

tidy3d/plugins/smatrix/ports/wave.py

@@ -8,7 +8,7 @@
 import pydantic.v1 as pd
 
 from tidy3d.components.base import cached_property, skip_if_fields_missing
-from tidy3d.components.boundary import InternalAbsorber, ModeABCBoundary
+from tidy3d.components.boundary import ABCBoundary, InternalAbsorber, ModeABCBoundary
 from tidy3d.components.data.data_array import FreqDataArray, FreqModeDataArray
 from tidy3d.components.data.monitor_data import ModeData
 from tidy3d.components.data.sim_data import SimulationData
@@ -91,10 +91,11 @@ class WavePort(AbstractTerminalPort, Box):
         description="Add a thin frame around the source during FDTD run for an improved injection.",
     )
 
-    absorber: bool = pd.Field(
+    absorber: Union[bool, ABCBoundary, ModeABCBoundary] = pd.Field(
         True,
         title="Absorber.",
-        description="Place a mode absorber in the port.",
+        description="Place a mode absorber in the port. If ``True``, an automatically generated mode absorber is placed in the port. "
+        "If ``ABCBoundary`` or ``ModeABCBoundary``, a mode absorber is placed in the port with the specified boundary conditions.",
     )
 
     def _mode_voltage_coefficients(self, mode_data: ModeData) -> FreqModeDataArray:
@@ -199,15 +200,19 @@ def to_absorber(
         center = list(self.center)
         if snap_center:
             center[self.injection_axis] = snap_center
+        if isinstance(self.absorber, (ABCBoundary, ModeABCBoundary)):
+            boundary_spec = self.absorber
+        else:
+            boundary_spec = ModeABCBoundary(
+                mode_spec=self.mode_spec,
+                mode_index=self.mode_index,
+                plane=self.geometry,
+                freq_spec=freq_spec,
+            )
         return InternalAbsorber(
             center=center,
             size=self.size,
-            boundary_spec=ModeABCBoundary(
-                mode_spec=self.mode_spec,
-                mode_index=self.mode_index,
-                plane=self.bounding_box,
-                frequency=freq_spec,
-            ),
+            boundary_spec=boundary_spec,
             direction="-"
             if self.direction == "+"
             else "+",  # absorb in the opposite direction of source