Leaving this so far, less ambitious refactor now

Author: daquinteroflex

tidy3d/plugins/smatrix/component_modelers/base.py

@@ -206,7 +206,7 @@ def batch_data(self):
         """The :class:`.BatchData` associated with the simulations run for this component modeler."""
         return self.batch.run(path_dir=self.path_dir)
 
-    def get_path_dir(self, path_dir: str) -> None:
+    def get_path_dir(self, path_dir: str) -> str:
         """Check whether the supplied 'path_dir' matches the internal field value."""
 
         if path_dir != self.path_dir and path_dir != DEFAULT_DATA_DIR:

tidy3d/plugins/smatrix/component_modelers/terminal.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import os
 from typing import Optional, Union
 
 import numpy as np
@@ -22,7 +21,6 @@
 from tidy3d.constants import C_0, OHM
 from tidy3d.exceptions import SetupError, Tidy3dError, Tidy3dKeyError, ValidationError
 from tidy3d.log import log
-from tidy3d.plugins.smatrix.component_modelers.base import DEFAULT_DATA_DIR
 from tidy3d.plugins.smatrix.data.terminal import PortDataArray, TerminalPortDataArray
 from tidy3d.plugins.smatrix.ports.base_lumped import AbstractLumpedPort
 from tidy3d.plugins.smatrix.ports.coaxial_lumped import CoaxialLumpedPort
@@ -327,41 +325,6 @@ def _source_time(self):
             fmin=min(self.freqs), fmax=max(self.freqs), remove_dc_component=self.remove_dc_component
         )
 
-    def _construct_smatrix(self) -> TerminalPortDataArray:
-        """Post process :class:`.BatchData` to generate scattering matrix."""
-        return self._internal_construct_smatrix(batch_data=self.batch_data)
-
-    def _internal_construct_smatrix(self, batch_data) -> TerminalPortDataArray:
-        """Post process :class:`.BatchData` to generate scattering matrix, for internal use only."""
-
-        port_names = [port.name for port in self.ports]
-
-        values = np.zeros(
-            (len(self.freqs), len(port_names), len(port_names)),
-            dtype=complex,
-        )
-        coords = {
-            "f": np.array(self.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 = self._port_reference_impedances(batch_data=batch_data)
-
-        # loop through source ports
-        for port_in in self.ports:
-            sim_data = batch_data[self._task_name(port=port_in)]
-            a, b = self.compute_power_wave_amplitudes_at_each_port(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 = self.ab_to_s(a_matrix, b_matrix)
-        return s_matrix
-
     @pd.validator("simulation")
     def _validate_3d_simulation(cls, val):
         """Error if :class:`.Simulation` is not a 3D simulation"""
@@ -453,60 +416,40 @@ def get_radiation_monitor_by_name(self, monitor_name: str) -> DirectivityMonitor
                 return monitor
         raise Tidy3dKeyError(f"No radiation monitor named '{monitor_name}'.")
 
-    def run(self, path_dir: str = DEFAULT_DATA_DIR) -> TerminalComponentModelerData:
-        """Solves for the scattering matrix of the system."""
-        _ = self.get_path_dir(path_dir)
-        _ = self._upload_terminal_modeler()
-        _ = self._construct_smatrix()
-
-    @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")
+    # Backwards compatible methods
+    @staticmethod
+    def compute_port_VI(
+        port_out: TerminalPortType, sim_data: SimulationData
+    ) -> tuple[FreqDataArray, FreqDataArray]:
+        return compute_port_VI(port_out=port_out, sim_data=sim_data)
 
-    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 compute_power_wave_amplitudes_at_each_port(
+        self, port_reference_impedances: PortDataArray, sim_data: SimulationData
+    ) -> tuple[PortDataArray, PortDataArray]:
+        return TerminalComponentModelerData().compute_power_wave_amplitudes_at_each_port(
+            port_reference_impedances=port_reference_impedances, sim_data=sim_data
         )
 
+    def _construct_smatrix(self) -> TerminalPortDataArray:
+        pass
+
+    def _internal_construct_smatrix(self, batch_data: BatchData) -> TerminalPortDataArray:
+        pass
+
     @cached_property
     def batch(self):
         """:class:`.Batch` associated with this component modeler."""
-        # TODO properly refactor, plugins data types should not have web methods.
-        from tidy3d.web.api.container import Batch
-
-        if self.batch_cached is not None:
-            return self.batch_cached
+        from tidy3d.plugins.smatrix.web import batch
 
-        # first try loading the batch from file, if it exists
-        batch_path = self._batch_path
+        return batch(self)
 
-        if os.path.exists(batch_path):
-            return Batch.from_file(fname=batch_path)
+    @cached_property
+    def batch_path(self) -> str:
+        """Path to the batch saved to file."""
 
-        return Batch(
-            simulations=self.sim_dict,
-            folder_name=self.folder_name,
-            callback_url=self.callback_url,
-            verbose=self.verbose,
-            solver_version=self.solver_version,
-            simulation_type="microwave",
-        )
+    @cached_property
+    def batch_data(self):
+        """The :class:`.BatchData` associated with the simulations run for this component modeler."""
 
 
 class SMatrixData:
@@ -741,10 +684,74 @@ def compute_power_wave_amplitudes_at_each_port(
         V_numpy = np.where(negative_real_Z, -V_numpy, V_numpy)
         Z_numpy = np.where(negative_real_Z, -Z_numpy, Z_numpy)
 
-        F_numpy = TerminalComponentModeler._compute_F(Z_numpy)
+        F_numpy = _compute_F(Z_numpy)
 
         # Equation 4.67 - Pozar - Microwave Engineering 4ed
         a.values = F_numpy * (V_numpy + Z_numpy * I_numpy)
         b.values = F_numpy * (V_numpy - np.conj(Z_numpy) * I_numpy)
 
         return a, b
+
+
+def _construct_smatrix(batch_data) -> TerminalPortDataArray:
+    """Post process :class:`.BatchData` to generate scattering matrix."""
+    return _internal_construct_smatrix(batch_data=batch_data)
+
+
+def _internal_construct_smatrix(simulation: TerminalComponentModeler) -> TerminalPortDataArray:
+    """Post process :class:`.BatchData` to generate scattering matrix, for internal use only."""
+
+    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 = simulation._port_reference_impedances(batch_data=batch_data)
+
+    # 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(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
+
+
+# @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",
+#     )

tidy3d/plugins/smatrix/web.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+
+def run_local(
+    simulation: TerminalComponentModeler, path_dir: str = DEFAULT_DATA_DIR
+) -> TerminalComponentModelerData:
+    """Solves for the scattering matrix of the system."""
+    path_dir = simulation.get_path_dir(path_dir)
+    batch_data = batch(simulation)
+    smatrix_batch_data = _construct_smatrix(batch_data)
+    smatrix_data = SMatrixData(a=smatrix_batch_data)
+    terminal_component_modeler_data = TerminalComponentModelerData(
+        simulation=simulation, data=(smatrix_data,)
+    )
+    return terminal_component_modeler_data
+
+
+def batch(simulation: TerminalComponentModeler):
+    """:class:`.Batch` associated with this component modeler."""
+    # TODO properly refactor, plugins data types should not have web methods.
+    from tidy3d.web.api.container import Batch
+
+    if simulation.batch_cached is not None:
+        return simulation.batch_cached
+
+    # first try loading the batch from file, if it exists
+    batch_path = simulation._batch_path
+
+    if os.path.exists(batch_path):
+        return Batch.from_file(fname=batch_path)
+
+    return Batch(
+        simulations=simulation.sim_dict,
+        folder_name=simulation.folder_name,
+        callback_url=simulation.callback_url,
+        verbose=simulation.verbose,
+        solver_version=simulation.solver_version,
+        simulation_type="microwave",
+    )