feat (rf): FXC-2053 convenience features for lumped port setup

Author: George-Guryev-flxcmp

tests/test_plugins/smatrix/terminal_component_modeler_def.py

@@ -474,3 +474,48 @@ def make_differential_stripline_modeler():
     )
 
     return tcm
+
+
+def make_basic_filter_terminals():
+    # Frequency
+    (f_min, f_max) = (0.1e9, 8e9)
+
+    # Materials
+    med_Cu = td.LossyMetalMedium(conductivity=60, frequency_range=(f_min, f_max))
+
+    # Geometry and Structure
+    mm = 1000  # Conversion mm to micron
+    H = 0.8 * mm  # Substrate thickness
+    T = 0.035 * mm  # Metal thickness
+    WL = 0.5 * mm
+    WC = 4 * mm
+    LC = 5.3 * mm
+    LL1 = 5.8 * mm
+    LL2 = 1.2 * mm
+    LL3 = 11.1 * mm
+    Lsub = LL1 + WL + LL3
+    Wsub = 2 * (LC + WL + LL2)
+
+    geom_C = td.Box.from_bounds(rmin=(-WC / 2, 0, 0), rmax=(WC / 2, LC, T))
+    geom_L2 = td.Box.from_bounds(rmin=(-WL / 2, -LL2 - WL, 0), rmax=(WL / 2, 0, T))
+    geom_L1 = td.Box.from_bounds(rmin=(-WL / 2 - LL1, -LL2 - WL, 0), rmax=(-WL / 2, -LL2, T))
+    geom_L3 = td.Box.from_bounds(rmin=(WL / 2, -LL2 - WL, 0), rmax=(WL / 2 + LL3, -LL2, T))
+
+    geom_resonator_basic = td.GeometryGroup(geometries=[geom_C, geom_L1, geom_L2, geom_L3])
+
+    x0, y0, z0 = geom_resonator_basic.bounding_box.center  # center (x,y) with circuit
+    geom_gnd = td.Box(center=(x0, y0, -H - T / 2), size=(Lsub, Wsub, T))
+
+    str_gnd = td.Structure(geometry=geom_gnd, medium=med_Cu)
+    str_resonator_basic = td.Structure(geometry=geom_resonator_basic, medium=med_Cu)
+
+    # add second signal trace to test lateral_coord
+    geom_sign = td.Box.from_bounds(
+        rmin=(-WL / 2 - LL1, -2 * LL2 - WL, 0), rmax=(WL / 2 + LL3, -2 * LL2, T)
+    )
+    geom_resonator_modified = td.GeometryGroup(
+        geometries=[geom_C, geom_L1, geom_L2, geom_L3, geom_sign]
+    )
+    str_resonator_modified = td.Structure(geometry=geom_resonator_modified, medium=med_Cu)
+
+    return (str_gnd, str_resonator_basic, str_resonator_modified)

tests/test_plugins/smatrix/test_terminal_component_modeler.py

@@ -33,6 +33,7 @@
     make_coaxial_component_modeler,
     make_component_modeler,
     make_differential_stripline_modeler,
+    make_basic_filter_terminals,
 )
 
 mm = 1e3
@@ -555,6 +556,54 @@ def test_validate_port_voltage_axis():
         LumpedPort(center=(0, 0, 0), size=(0, 1, 2), voltage_axis=0, impedance=50)
 
 
+def test_lumped_port_from_structures():
+    """Test automatic lumped port setup between two terminal structures."""
+
+    # set up terminals of a basic filter
+    (str_gnd, str_resonator_basic, str_resonator_modified) = make_basic_filter_terminals()
+
+    # Geometry and Structure
+    mm = 1000  # Conversion mm to micron
+    WL = 0.5 * mm
+    LL1 = 5.8 * mm
+    LL2 = 1.2 * mm
+
+    # define basic parameters for automatic lumped port setup (except for signal terminal)
+    lp_options = {
+        "ground_terminal": str_gnd,
+        "lateral_coord": -1450,
+        "voltage_axis": 2,
+        "impedance": 50,
+    }
+
+    # ensure that value error is triggered if signal and ground terminals are not specified
+    with pytest.raises(ValueError):
+        LP0 = LumpedPort.from_structures(x=-WL / 2 - LL1, name="LP1", **lp_options)
+
+    # make sure the Lumped port is set correctly
+    lp_options["signal_terminal"] = str_resonator_basic
+    LP1 = LumpedPort.from_structures(x=-WL / 2 - LL1, name="LP1", **lp_options)
+    assert LP1.voltage_axis == lp_options["voltage_axis"]
+    assert np.isclose(LP1.impedance, lp_options["impedance"])
+
+    # make sure that `port_width` does not cause port geometry exceed overlap of terminals
+    lp_options["port_width"] = 1000
+    with pytest.raises(ValueError):
+        LP2 = LumpedPort.from_structures(x=-WL / 2 - LL1, name="LP1", **lp_options)
+
+    # specify lateral coordinate to select appropriate signal terminal to resolve ambiguity
+    lp_options["signal_terminal"] = str_resonator_modified
+    lp_options["lateral_coord"] = -2 * LL2 - WL / 2
+    lp_options["port_width"] = None
+    LP3 = LumpedPort.from_structures(x=-WL / 2 - LL1, name="LP3", **lp_options)
+    assert np.isclose(LP3.center[1], -2 * LL2 - WL / 2)
+
+    # test port width with lateral coords
+    lp_options["port_width"] = WL / 3
+    LP4 = LumpedPort.from_structures(x=-WL / 2 - LL1, name="LP4", **lp_options)
+    assert np.isclose(LP4.size[1], lp_options["port_width"])
+
+
 @pytest.mark.parametrize("snap_center", [None, 0.1])
 def test_converting_port_to_simulation_objects(snap_center):
     """Test that the LumpedPort can be converted into monitors and source without the grid present."""

tidy3d/components/simulation.py

@@ -5830,3 +5830,57 @@ def from_scene(cls, scene: Scene, **kwargs) -> Simulation:
         )
 
     _boundaries_for_zero_dims = validate_boundaries_for_zero_dims()
+
+    def add_padding(
+        self,
+        x: Optional[tuple[pydantic.NonNegativeFloat, pydantic.NonNegativeFloat]] = None,
+        y: Optional[tuple[pydantic.NonNegativeFloat, pydantic.NonNegativeFloat]] = None,
+        z: Optional[tuple[pydantic.NonNegativeFloat, pydantic.NonNegativeFloat]] = None,
+    ) -> Simulation:
+        """Created a copy of simulation with padded simulation domain.
+
+        Parameters
+        ----------
+        x :  Optional[tuple[pydantic.NonNegativeFloat, pydantic.NonNegativeFloat]] = None
+            Padding sizes at the left and right boundaries of the simulation along x-axis.
+        y :  Optional[tuple[pydantic.NonNegativeFloat, pydantic.NonNegativeFloat]] = None
+            Padding sizes at the left and right boundaries of the simulation along y-axis.
+        z : Optional[tuple[pydantic.NonNegativeFloat, pydantic.NonNegativeFloat]] = None
+            Padding sizes at the left and right boundaries of the simulation along z-axis.
+
+        Returns
+        -------
+        Simulation
+            Simulation with padded simulation domain.
+        """
+        box = Box(center=self.center, size=self.size)
+        rmin, rmax = box.bounds
+
+        def bound_array(arrs, idx):
+            return np.array([(a[idx] if a is not None else 0) for a in arrs])
+
+        # parse padding sizes for simulation
+        drmin = bound_array((x, y, z), 0)
+        drmax = bound_array((x, y, z), 1)
+
+        rmin = np.array(rmin) - drmin
+        rmax = np.array(rmax) + drmax
+        new_box = Box.from_bounds(rmin=rmin, rmax=rmax)
+
+        return self.updated_copy(size=new_box.size, center=new_box.center)
+
+    def add_uniform_padding(self, padding: pydantic.NonNegativeFloat) -> Simulation:
+        """Create copy of simulation with uniformly padded simulation domain.
+
+        Parameters
+        ----------
+        padding : pydantic.NonNegativeFloat
+            Padding size applied uniformly at all simulation boundaries.
+
+        Returns
+        -------
+        Simulation
+            Simulation with uniformly padded simulation domain.
+        """
+        padding_tuple = (padding, padding)
+        return self.add_padding(x=padding_tuple, y=padding_tuple, z=padding_tuple)