--amend

Author: George-Guryev-flxcmp

CHANGELOG.md

@@ -8,8 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
-- Add automatic structure extrusion for waveports defined on boundaries, controlled by the `extrude_structures` field in `WavePort`.
-- The extrusion method, implemented in `TerminalComponentModeler`, ensures that mode sources, absorbers, and PEC frames are fully contained within the extruded structures; extrusion occurs only when `extrude_structures` is set to `True`.
+- Added optional automatic extrusion of boundary waveport structures via `WavePort.extrude_structures`, ensuring mode sources, absorbers, and PEC frames are fully contained.
 - Added rectangular and radial taper support to `RectangularAntennaArrayCalculator` for phased array amplitude weighting; refactored array factor calculation for improved clarity and performance. 
 - Selective simulation capabilities to `TerminalComponentModeler` via `run_only` and `element_mappings` fields, allowing users to run fewer simulations and extract only needed scattering matrix elements.
 - Added KLayout plugin, with DRC functionality for running design rule checks in `plugins.klayout.drc`. Supports running DRC on GDS files as well as `Geometry`, `Structure`, and `Simulation` objects.

schemas/TerminalComponentModeler.json

@@ -16108,6 +16108,10 @@
           ],
           "type": "string"
         },
+        "extrude_structures": {
+          "default": false,
+          "type": "boolean"
+        },
         "frame": {
           "allOf": [
             {

tidy3d/plugins/smatrix/component_modelers/terminal.py

@@ -446,102 +446,6 @@ def get_radiation_monitor_by_name(self, monitor_name: str) -> DirectivityMonitor
                 return monitor
         raise Tidy3dKeyError(f"No radiation monitor named '{monitor_name}'.")
 
-    def get_antenna_metrics_data(
-        self,
-        port_amplitudes: Optional[dict[str, complex]] = None,
-        monitor_name: Optional[str] = None,
-    ) -> AntennaMetricsData:
-        """Calculate antenna parameters using superposition of fields from multiple port excitations.
-
-        The method computes the radiated far fields and port excitation power wave amplitudes
-        for a superposition of port excitations, which can be used to analyze antenna radiation
-        characteristics.
-
-        Parameters
-        ----------
-        port_amplitudes : dict[str, complex] = None
-            Dictionary mapping port names to their desired excitation amplitudes, ``a``. For each port,
-            :math:`\\frac{1}{2}|a|^2` represents the incident power from that port into the system.
-            If ``None``, uses only the first port without any scaling of the raw simulation data.
-            When ``None`` is passed as a port amplitude, the raw simulation data is used for that port.
-            Note that in this method ``a`` represents the incident wave amplitude
-            using the power wave definition in [2].
-        monitor_name : str = None
-            Name of the :class:`.DirectivityMonitor` to use for calculating far fields.
-            If None, uses the first monitor in `radiation_monitors`.
-
-        Returns
-        -------
-        :class:`.AntennaMetricsData`
-            Container with antenna parameters including directivity, gain, and radiation efficiency,
-            computed from the superposition of fields from all excited ports.
-        """
-        # Use the first port as default if none specified
-        if port_amplitudes is None:
-            port_amplitudes = {self.ports[0].name: None}
-
-        # Check port names, and create map from port to amplitude
-        port_dict = {}
-        for key in port_amplitudes.keys():
-            port, _ = self.network_dict[key]
-            port_dict[port] = port_amplitudes[key]
-        # Get the radiation monitor, use first as default
-        # if none specified
-        if monitor_name is None:
-            rad_mon = self.radiation_monitors[0]
-        else:
-            rad_mon = self.get_radiation_monitor_by_name(monitor_name)
-
-        # Create data arrays for holding the superposition of all port power wave amplitudes
-        f = list(rad_mon.freqs)
-        coords = {"f": f, "port": list(self.matrix_indices_monitor)}
-        a_sum = PortDataArray(
-            np.zeros((len(f), len(self.matrix_indices_monitor)), dtype=complex), coords=coords
-        )
-        b_sum = a_sum.copy()
-        # Retrieve associated simulation data
-        combined_directivity_data = None
-        for port, amplitude in port_dict.items():
-            if amplitude == 0.0:
-                continue
-            sim_data_port = self.batch_data[self._task_name(port=port)]
-            radiation_data = sim_data_port[rad_mon.name]
-
-            a, b = self.compute_wave_amplitudes_at_each_port(
-                self.port_reference_impedances, sim_data_port, s_param_def="power"
-            )
-            # Select a possible subset of frequencies
-            a = a.sel(f=f)
-            b = b.sel(f=f)
-            a_raw = a.sel(port=self.network_index(port))
-
-            if amplitude is None:
-                # No scaling performed when amplitude is None
-                scaled_directivity_data = sim_data_port[rad_mon.name]
-                scale_factor = 1.0
-            else:
-                scaled_directivity_data = self._monitor_data_at_port_amplitude(
-                    port, sim_data_port, radiation_data, amplitude
-                )
-                scale_factor = amplitude / a_raw
-            a = scale_factor * a
-            b = scale_factor * b
-
-            # Combine the possibly scaled directivity data and the power wave amplitudes
-            if combined_directivity_data is None:
-                combined_directivity_data = scaled_directivity_data
-            else:
-                combined_directivity_data = combined_directivity_data + scaled_directivity_data
-            a_sum += a
-            b_sum += b
-
-        # Compute and add power measures to results
-        power_incident = np.real(0.5 * a_sum * np.conj(a_sum)).sum(dim="port")
-        power_reflected = np.real(0.5 * b_sum * np.conj(b_sum)).sum(dim="port")
-        return AntennaMetricsData.from_directivity_data(
-            combined_directivity_data, power_incident, power_reflected
-        )
-
     def _extrude_port_structures(self, sim: Simulation) -> Simulation:
         """
         Extrude structures intersecting a port plane when a wave port lies on a structure boundary.
@@ -634,14 +538,19 @@ def _clip(i, lo, hi):
             # loop over structures and extrude those that intersect a waveport plane
             for structure in sim.structures:
                 # get geometries that intersect the plane on which the waveport is defined
-                left_geom = slice_plane_left.intersections_with(structure.geometry)
-                right_geom = slice_plane_right.intersections_with(structure.geometry)
-                shapely_geom = left_geom or right_geom or []
 
-                new_geoms = []
+                if direction == "+":
+                    shapely_geom = slice_plane_right.intersections_with(structure.geometry)
+                else:
+                    shapely_geom = slice_plane_left.intersections_with(structure.geometry)
 
+                polygon_list = []
+                for geom in shapely_geom:
+                    polygon_list = polygon_list + ClipOperation.to_polygon_list(geom)
+
+                new_geoms = []
                 # loop over identified geometries and extrude them
-                for polygon in shapely_geom:
+                for polygon in polygon_list:
                     # construct outer shell of an extruded geometry first
                     exterior_vertices = np.array(polygon.exterior.coords)
                     outer_shell = PolySlab(
@@ -676,9 +585,13 @@ def _clip(i, lo, hi):
                 )
                 new_structures.append(new_struct)
 
-        # return simulation with added extruded structures
-        return sim.updated_copy(grid_spec=GridSpec.from_grid(sim.grid), structures=new_structures)
-    
+        if not mode_sources:
+            return sim
+        else:
+            # return simulation with added extruded structures
+            return sim.updated_copy(
+                grid_spec=GridSpec.from_grid(sim.grid), structures=new_structures
+            )
+
 
 TerminalComponentModeler.update_forward_refs()
-