--amend

Author: George-Guryev-flxcmp

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.
@@ -676,9 +580,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()
 
+TerminalComponentModeler.update_forward_refs()