Break forwards incompatible methods, pending new funct

Author: daquinteroflex

tidy3d/plugins/smatrix/component_modelers/base.py

@@ -70,7 +70,7 @@ class AbstractComponentModeler(ABC, Tidy3dBaseModel):
         "near zero frequency. Setting this to ``False`` results in an unmodified Gaussian "
         "pulse spectrum which can have a nonzero DC component.",
     )
-    
+
     @pd.validator("simulation", always=True)
     def _sim_has_no_sources(cls, val):
         """Make sure simulation has no sources as they interfere with tool."""
@@ -101,117 +101,13 @@ def _task_name(port: Port, mode_index: Optional[int] = None) -> str:
             return f"smatrix_{port.name}_{mode_index}"
         return f"smatrix_{port.name}"
 
-    @cached_property
-    def sim_dict(self) -> dict[str, Simulation]:
-        """Generate all the :class:`.Simulation` objects for the S matrix calculation."""
-
-    def to_file(self, fname: str) -> None:
-        """Exports :class:`AbstractComponentModeler` instance to .yaml, .json, or .hdf5 file
-
-        Parameters
-        ----------
-        fname : str
-            Full path to the .yaml or .json file to save the :class:`AbstractComponentModeler` to.
-
-        Example
-        -------
-        >>> modeler.to_file(fname='folder/sim.json') # doctest: +SKIP
-        """
-
-        batch_cached = self._cached_properties.get("batch")
-        if batch_cached is not None:
-            jobs_cached = batch_cached._cached_properties.get("jobs")
-            if jobs_cached is not None:
-                jobs = {}
-                for key, job in jobs_cached.items():
-                    task_id = job._cached_properties.get("task_id")
-                    jobs[key] = job.updated_copy(task_id_cached=task_id)
-                batch_cached = batch_cached.updated_copy(jobs_cached=jobs)
-            self = self.updated_copy(batch_cached=batch_cached)
-        super(AbstractComponentModeler, self).to_file(fname=fname)  # noqa: UP008
-
-    @cached_property
-    def batch(self) -> Batch:
-        """: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
-
-        # first try loading the batch from file, if it exists
-        batch_path = self._batch_path
-
-        if os.path.exists(batch_path):
-            return Batch.from_file(fname=batch_path)
-
-        return Batch(
-            simulations=self.sim_dict,
-            folder_name=self.folder_name,
-            callback_url=self.callback_url,
-            verbose=self.verbose,
-            solver_version=self.solver_version,
-        )
-
-    @cached_property
-    def batch_path(self) -> str:
-        """Path to the batch saved to file."""
-        return self.batch._batch_path(path_dir=self.path_dir)
-
-    @cached_property
-    def batch_data(self) -> BatchData:
-        """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:
-        """Check whether the supplied 'path_dir' matches the internal field value."""
-
-        if path_dir != self.path_dir and path_dir != DEFAULT_DATA_DIR:
-            raise ValueError(
-                f"'path_dir' of '{path_dir}' passed, but 'ComponentModeler.path_dir' is "
-                f"{self.path_dir}. Moving forward, only the 'ComponentModeler.path_dir' will be "
-                "used internally, please update your scripts accordingly to avoid passing this "
-                "value to methods. "
-            )
-
-        return self.path_dir
-
-    @cached_property
-    def _batch_path(self) -> str:
-        """Where we store the batch for this :class:`AbstractComponentModeler` instance after the run."""
-        return os.path.join(self.path_dir, "batch" + str(hash(self)) + ".hdf5")
-
-    def _run_sims(self, path_dir: str = DEFAULT_DATA_DIR) -> BatchData:
-        """Run :class:`.Simulation` for each port and return the batch after saving."""
-        _ = self.get_path_dir(path_dir)
-        self.batch.to_file(self._batch_path)
-        batch_data = self.batch_data
-        return batch_data
-
     def get_port_by_name(self, port_name: str) -> Port:
         """Get the port from the name."""
         ports = [port for port in self.ports if port.name == port_name]
         if len(ports) == 0:
             raise Tidy3dKeyError(f'Port "{port_name}" not found.')
         return ports[0]
 
-    @abstractmethod
-    def _construct_smatrix(self, batch_data: BatchData) -> DataArray:
-        """Post process :class:`.BatchData` to generate scattering matrix."""
-
-    @abstractmethod
-    def _internal_construct_smatrix(self, batch_data: BatchData) -> DataArray:
-        """Post process :class:`.BatchData` to generate scattering matrix, for internal use only."""
-
-    def run(self, path_dir: str = DEFAULT_DATA_DIR) -> DataArray:
-        """Solves for the scattering matrix of the system."""
-        _ = self.get_path_dir(path_dir)
-        return self._construct_smatrix()
-
-    def load(self, path_dir: str = DEFAULT_DATA_DIR) -> DataArray:
-        """Load a scattering matrix from saved :class:`.BatchData` object."""
-        return self.run(path_dir=path_dir)
-
     @staticmethod
     def inv(matrix: DataArray):
         """Helper to invert a port matrix."""
@@ -266,13 +162,4 @@ def _shift_value_signed(self, port: Union[Port, WavePort]) -> float:
         new_pos = grid_centers[shifted_index]
         return new_pos - port_position
 
-    def sim_data_by_task_name(self, task_name: str) -> SimulationData:
-        """Get the simulation data by task name, avoids emitting warnings from the ``Simulation``."""
-        log_level_cache = config.logging_level
-        config.logging_level = "ERROR"
-        sim_data = self.batch_data[task_name]
-        config.logging_level = log_level_cache
-        return sim_data
-
-
 AbstractComponentModeler.update_forward_refs()

tidy3d/plugins/smatrix/component_modelers/modal.py

@@ -72,20 +72,6 @@ class ComponentModeler(AbstractComponentModeler):
     :class:`ComponentModeler`. ``run_only`` contains the scattering matrix indices that the user wants to run as a
     source. If any indices are excluded, they will not be run."""
 
-    verbose: bool = pd.Field(
-        False,
-        title="Verbosity",
-        description="Whether the :class:`.ComponentModeler` should print status and progressbars.",
-    )
-
-    callback_url: str = pd.Field(
-        None,
-        title="Callback URL",
-        description="Http PUT url to receive simulation finish event. "
-        "The body content is a json file with fields "
-        "``{'id', 'status', 'name', 'workUnit', 'solverVersion'}``.",
-    )
-
     @pd.validator("simulation", always=True)
     def _sim_has_no_sources(cls, val):
         """Make sure simulation has no sources as they interfere with tool."""
@@ -271,80 +257,4 @@ def get_max_mode_indices(matrix_elements: tuple[str, int]) -> int:
         max_mode_index_out = get_max_mode_indices(self.matrix_indices_monitor)
         max_mode_index_in = get_max_mode_indices(self.matrix_indices_source)
 
-        return max_mode_index_out, max_mode_index_in
-
-    def _construct_smatrix(self) -> ModalPortDataArray:
-        """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: BatchData) -> ModalPortDataArray:
-        """Post process :class:`.BatchData` to generate scattering matrix, for internal use only."""
-
-        max_mode_index_out, max_mode_index_in = self.max_mode_index
-        num_modes_out = max_mode_index_out + 1
-        num_modes_in = max_mode_index_in + 1
-        port_names_out, port_names_in = self.port_names
-
-        values = np.zeros(
-            (len(port_names_out), len(port_names_in), num_modes_out, num_modes_in, len(self.freqs)),
-            dtype=complex,
-        )
-        coords = {
-            "port_out": port_names_out,
-            "port_in": port_names_in,
-            "mode_index_out": range(num_modes_out),
-            "mode_index_in": range(num_modes_in),
-            "f": np.array(self.freqs),
-        }
-        s_matrix = ModalPortDataArray(values, coords=coords)
-
-        # loop through source ports
-        for col_index in self.matrix_indices_run_sim:
-            port_name_in, mode_index_in = col_index
-            port_in = self.get_port_by_name(port_name=port_name_in)
-
-            sim_data = batch_data[self._task_name(port=port_in, mode_index=mode_index_in)]
-
-            for row_index in self.matrix_indices_monitor:
-                port_name_out, mode_index_out = row_index
-                port_out = self.get_port_by_name(port_name=port_name_out)
-
-                # directly compute the element
-                mode_amps_data = sim_data[port_out.name].copy().amps
-                dir_out = "-" if port_out.direction == "+" else "+"
-                amp = mode_amps_data.sel(
-                    f=coords["f"], direction=dir_out, mode_index=mode_index_out
-                )
-                source_norm = self._normalization_factor(port_in, sim_data)
-                s_matrix_elements = np.array(amp.data) / np.array(source_norm)
-                s_matrix.loc[
-                    {
-                        "port_in": port_name_in,
-                        "mode_index_in": mode_index_in,
-                        "port_out": port_name_out,
-                        "mode_index_out": mode_index_out,
-                    }
-                ] = s_matrix_elements
-
-        # element can be determined by user-defined mapping
-        for (row_in, col_in), (row_out, col_out), mult_by in self.element_mappings:
-            port_out_from, mode_index_out_from = row_in
-            port_in_from, mode_index_in_from = col_in
-            coords_from = {
-                "port_in": port_in_from,
-                "mode_index_in": mode_index_in_from,
-                "port_out": port_out_from,
-                "mode_index_out": mode_index_out_from,
-            }
-
-            port_out_to, mode_index_out_to = row_out
-            port_in_to, mode_index_in_to = col_out
-            coords_to = {
-                "port_in": port_in_to,
-                "mode_index_in": mode_index_in_to,
-                "port_out": port_out_to,
-                "mode_index_out": mode_index_out_to,
-            }
-            s_matrix.loc[coords_to] = mult_by * s_matrix.loc[coords_from].values
-
-        return s_matrix
+        return max_mode_index_out, max_mode_index_in