Further refactoring

Author: daquinteroflex

tidy3d/plugins/smatrix/component_modelers/terminal.py

@@ -302,16 +302,29 @@ def run(self, path_dir: str = DEFAULT_DATA_DIR):
         return TerminalComponentModelerData(simulation=self, data=smatrix_data)
 
     ##### Backwards compatibility methods #####
+    @staticmethod
+    def _check_port_impedance_sign(Z_numpy: np.ndarray):
+        from tidy3d.plugins.smatrix.utils import _check_port_impedance_sign
 
-    def compute_power_wave_amplitudes_at_each_port(
-        self, port_reference_impedances: PortDataArray, sim_data: SimulationData
-    ) -> tuple[PortDataArray, PortDataArray]:
-        from tidy3d.plugins.smatrix.run import compute_power_wave_amplitudes_at_each_port
+        return _check_port_impedance_sign(Z_numpy)
 
-        data = compute_power_wave_amplitudes_at_each_port(
-            simulation=self, port_reference_impedances=port_reference_impedances, sim_data=sim_data
-        )
-        return data
+    @staticmethod
+    def _compute_F(Z_numpy: np.array):
+        """Helper to convert port impedance matrix to F, which is used for
+        computing generalized scattering parameters."""
+        from tidy3d.plugins.smatrix.utils import _compute_F
+
+        return _compute_F(Z_numpy)
+
+    def _construct_smatrix(self) -> TerminalPortDataArray:
+        from tidy3d.plugins.smatrix.run import construct_smatrix
+
+        return construct_smatrix(self)
+
+    def _internal_construct_smatrix(self, batch_data: typing.Any = None) -> TerminalPortDataArray:
+        from tidy3d.plugins.smatrix.run import construct_smatrix
+
+        return construct_smatrix(self)
 
     def _monitor_data_at_port_amplitude(
         self,
@@ -333,11 +346,7 @@ def _monitor_data_at_port_amplitude(
         )
         return data
 
-    def get_antenna_metrics_data(
-        self,
-        port_amplitudes: Optional[dict[str, complex]] = None,
-        monitor_name: Optional[str] = None,
-    ) -> AntennaMetricsData:
+    def _port_reference_impedances(self, batch_data) -> PortDataArray:
         from tidy3d.plugins.smatrix.data.data import (
             MicrowaveSMatrixData,
             TerminalComponentModelerData,
@@ -346,55 +355,33 @@ def get_antenna_metrics_data(
         smatrix_data = MicrowaveSMatrixData(data=self._construct_smatrix())
         data = TerminalComponentModelerData(
             simulation=self, data=smatrix_data
-        ).get_antenna_metrics_data(port_amplitudes=port_amplitudes, monitor_name=monitor_name)
+        ).port_reference_impedances
         return data
 
-    @staticmethod
-    def _check_port_impedance_sign(Z_numpy: np.ndarray):
-        from tidy3d.plugins.smatrix.utils import _check_port_impedance_sign
-
-        return _check_port_impedance_sign(Z_numpy)
-
-    @staticmethod
-    def _compute_F(Z_numpy: np.array):
-        """Helper to convert port impedance matrix to F, which is used for
-        computing generalized scattering parameters."""
-        from tidy3d.plugins.smatrix.utils import _compute_F
-
-        return _compute_F(Z_numpy)
-
     @cached_property
-    def port_reference_impedances(self) -> PortDataArray:
-        from tidy3d.plugins.smatrix.data.data import (
-            MicrowaveSMatrixData,
-            TerminalComponentModelerData,
-        )
-
-        smatrix_data = MicrowaveSMatrixData(data=self._construct_smatrix())
-        data = TerminalComponentModelerData(
-            simulation=self, data=smatrix_data
-        ).port_reference_impedances
-        return data
+    def _terminal_modeler_path(self) -> str:
+        """Where we store the  for this :class:`TerminalComponentModeler` instance after the run."""
+        return os.path.join(self.path_dir, "tcp_" + str(hash(self)) + ".hdf5")
 
-    def _port_reference_impedances(self, batch_data) -> PortDataArray:
-        from tidy3d.plugins.smatrix.data.data import (
-            MicrowaveSMatrixData,
-            TerminalComponentModelerData,
-        )
+    def _upload_terminal_modeler(self):
+        # TODO properly refactor, plugins data types should not have web methods.
+        from tidy3d.web.api.container import Job
 
-        smatrix_data = MicrowaveSMatrixData(data=self._construct_smatrix())
-        data = TerminalComponentModelerData(
-            simulation=self, data=smatrix_data
-        ).port_reference_impedances
-        return data
+        # first try loading the terminal_component_modeler from file, if it exists
+        terminal_modeler_path = self._terminal_modeler_path
 
-    @staticmethod
-    def s_to_z(
-        s_matrix: TerminalPortDataArray, reference: Union[complex, PortDataArray]
-    ) -> DataArray:
-        from tidy3d.plugins.smatrix.utils import s_to_z
+        if os.path.exists(terminal_modeler_path):
+            return Job.from_file(fname=terminal_modeler_path)
 
-        return s_to_z(s_matrix=s_matrix, reference=reference)
+        return Job(
+            simulation=self,
+            task_name=self.name,
+            folder_name=self.folder_name,
+            callback_url=self.callback_url,
+            verbose=self.verbose,
+            solver_version=self.solver_version,
+            simulation_type="microwave",
+        )
 
     @staticmethod
     def ab_to_s(
@@ -404,6 +391,24 @@ def ab_to_s(
 
         return ab_to_s(a_matrix=a_matrix, b_matrix=b_matrix)
 
+    @staticmethod
+    def compute_port_VI(
+        port_out: TerminalPortType, sim_data: SimulationData
+    ) -> tuple[FreqDataArray, FreqDataArray]:
+        from tidy3d.plugins.smatrix.utils import compute_port_VI
+
+        return compute_port_VI(port_out=port_out, sim_data=sim_data)
+
+    def compute_power_wave_amplitudes_at_each_port(
+        self, port_reference_impedances: PortDataArray, sim_data: SimulationData
+    ) -> tuple[PortDataArray, PortDataArray]:
+        from tidy3d.plugins.smatrix.run import compute_power_wave_amplitudes_at_each_port
+
+        data = compute_power_wave_amplitudes_at_each_port(
+            simulation=self, port_reference_impedances=port_reference_impedances, sim_data=sim_data
+        )
+        return data
+
     @staticmethod
     def compute_power_delivered_by_port(
         port: Union[LumpedPort, CoaxialLumpedPort], sim_data: SimulationData
@@ -420,45 +425,39 @@ def compute_power_wave_amplitudes(
 
         return compute_power_wave_amplitudes(port=port, sim_data=sim_data)
 
-    @staticmethod
-    def compute_port_VI(
-        port_out: TerminalPortType, sim_data: SimulationData
-    ) -> tuple[FreqDataArray, FreqDataArray]:
-        from tidy3d.plugins.smatrix.utils import compute_port_VI
+    def get_antenna_metrics_data(
+        self,
+        port_amplitudes: Optional[dict[str, complex]] = None,
+        monitor_name: Optional[str] = None,
+    ) -> AntennaMetricsData:
+        from tidy3d.plugins.smatrix.data.data import (
+            MicrowaveSMatrixData,
+            TerminalComponentModelerData,
+        )
 
-        return compute_port_VI(port_out=port_out, sim_data=sim_data)
+        smatrix_data = MicrowaveSMatrixData(data=self._construct_smatrix())
+        data = TerminalComponentModelerData(
+            simulation=self, data=smatrix_data
+        ).get_antenna_metrics_data(port_amplitudes=port_amplitudes, monitor_name=monitor_name)
+        return data
 
     @cached_property
-    def _terminal_modeler_path(self) -> str:
-        """Where we store the  for this :class:`TerminalComponentModeler` instance after the run."""
-        return os.path.join(self.path_dir, "tcp_" + str(hash(self)) + ".hdf5")
-
-    def _upload_terminal_modeler(self):
-        # TODO properly refactor, plugins data types should not have web methods.
-        from tidy3d.web.api.container import Job
-
-        # first try loading the terminal_component_modeler from file, if it exists
-        terminal_modeler_path = self._terminal_modeler_path
-
-        if os.path.exists(terminal_modeler_path):
-            return Job.from_file(fname=terminal_modeler_path)
-
-        return Job(
-            simulation=self,
-            task_name=self.name,
-            folder_name=self.folder_name,
-            callback_url=self.callback_url,
-            verbose=self.verbose,
-            solver_version=self.solver_version,
-            simulation_type="microwave",
+    def port_reference_impedances(self) -> PortDataArray:
+        from tidy3d.plugins.smatrix.data.data import (
+            MicrowaveSMatrixData,
+            TerminalComponentModelerData,
         )
 
-    def _construct_smatrix(self) -> TerminalPortDataArray:
-        from tidy3d.plugins.smatrix.run import _construct_smatrix
-
-        return _construct_smatrix(self)
+        smatrix_data = MicrowaveSMatrixData(data=self._construct_smatrix())
+        data = TerminalComponentModelerData(
+            simulation=self, data=smatrix_data
+        ).port_reference_impedances
+        return data
 
-    def _internal_construct_smatrix(self, batch_data: typing.Any = None) -> TerminalPortDataArray:
-        from tidy3d.plugins.smatrix.run import _construct_smatrix
+    @staticmethod
+    def s_to_z(
+        s_matrix: TerminalPortDataArray, reference: Union[complex, PortDataArray]
+    ) -> DataArray:
+        from tidy3d.plugins.smatrix.utils import s_to_z
 
-        return _construct_smatrix(self)
+        return s_to_z(s_matrix=s_matrix, reference=reference)

tidy3d/plugins/smatrix/data/data.py

@@ -179,9 +179,9 @@ def get_antenna_metrics_data(
     @cached_property
     def port_reference_impedances(self) -> PortDataArray:
         """The reference impedance used at each port for definining power wave amplitudes."""
-        from tidy3d.plugins.smatrix.run import _port_reference_impedances
+        from tidy3d.plugins.smatrix.run import port_reference_impedances
 
-        return _port_reference_impedances(self.simulation)
+        return port_reference_impedances(self.simulation)
 
     def compute_power_wave_amplitudes_at_each_port(
         self, port_reference_impedances: PortDataArray, sim_data: SimulationData

tidy3d/plugins/smatrix/run.py

@@ -12,12 +12,43 @@
 from tidy3d.plugins.smatrix.utils import _check_port_impedance_sign, _compute_F, compute_port_VI
 
 
-def _construct_smatrix(simulation) -> TerminalPortDataArray:
+def construct_smatrix(simulation, batch_data: typing.Any = None) -> TerminalPortDataArray:
     """Post process :class:`.BatchData` to generate scattering matrix."""
-    return _internal_construct_smatrix(simulation=simulation)
+    if batch_data is None:
+        batch_data = simulation.batch_data
+
+    from tidy3d.plugins.smatrix.utils import ab_to_s
+
+    port_names = [port.name for port in simulation.ports]
+
+    values = np.zeros(
+        (len(simulation.freqs), len(port_names), len(port_names)),
+        dtype=complex,
+    )
+    coords = {
+        "f": np.array(simulation.freqs),
+        "port_out": port_names,
+        "port_in": port_names,
+    }
+    a_matrix = TerminalPortDataArray(values, coords=coords)
+    b_matrix = a_matrix.copy(deep=True)
+
+    # Tabulate the reference impedances at each port and frequency
+    port_impedances = port_reference_impedances(simulation=simulation)
+
+    # loop through source ports
+    for port_in in simulation.ports:
+        sim_data = batch_data[simulation._task_name(port=port_in)]
+        a, b = compute_power_wave_amplitudes_at_each_port(simulation, port_impedances, sim_data)
+        indexer = {"f": a.f, "port_in": port_in.name, "port_out": a.port}
+        a_matrix.loc[indexer] = a
+        b_matrix.loc[indexer] = b
 
+    s_matrix = ab_to_s(a_matrix, b_matrix)
+    return s_matrix
 
-def _port_reference_impedances(simulation) -> PortDataArray:
+
+def port_reference_impedances(simulation) -> PortDataArray:
     """Tabulates the reference impedance of each port at each frequency using the
     supplied :class:`.BatchData`.
     """
@@ -109,39 +140,3 @@ def compute_power_wave_amplitudes_at_each_port(
     b.values = F_numpy * (V_numpy - np.conj(Z_numpy) * I_numpy)
 
     return a, b
-
-
-def _internal_construct_smatrix(simulation, batch_data: typing.Any = None) -> TerminalPortDataArray:
-    """Post process :class:`.BatchData` to generate scattering matrix, for internal use only."""
-    if batch_data is None:
-        batch_data = simulation.batch_data
-
-    from tidy3d.plugins.smatrix.utils import ab_to_s
-
-    port_names = [port.name for port in simulation.ports]
-
-    values = np.zeros(
-        (len(simulation.freqs), len(port_names), len(port_names)),
-        dtype=complex,
-    )
-    coords = {
-        "f": np.array(simulation.freqs),
-        "port_out": port_names,
-        "port_in": port_names,
-    }
-    a_matrix = TerminalPortDataArray(values, coords=coords)
-    b_matrix = a_matrix.copy(deep=True)
-
-    # Tabulate the reference impedances at each port and frequency
-    port_impedances = _port_reference_impedances(simulation=simulation)
-
-    # loop through source ports
-    for port_in in simulation.ports:
-        sim_data = batch_data[simulation._task_name(port=port_in)]
-        a, b = compute_power_wave_amplitudes_at_each_port(simulation, port_impedances, sim_data)
-        indexer = {"f": a.f, "port_in": port_in.name, "port_out": a.port}
-        a_matrix.loc[indexer] = a
-        b_matrix.loc[indexer] = b
-
-    s_matrix = ab_to_s(a_matrix, b_matrix)
-    return s_matrix