gplugins 1.3.5__tar.gz → 1.3.7__tar.gz

{gplugins-1.3.5 → gplugins-1.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gplugins
-Version: 1.3.5
+Version: 1.3.7
 Summary: gdsfactory plugins
 Keywords: python
 Author-email: gdsfactory <contact@gdsfactory.com>
@@ -29,6 +29,7 @@ Requires-Dist: matplotlib ; extra == "docs"
 Requires-Dist: jupyter-book~=1.0 ; extra == "docs"
 Requires-Dist: pyvista[all]<=0.43.8 ; extra == "docs"
 Requires-Dist: bokeh ; extra == "docs"
+Requires-Dist: scikit-learn ; extra == "docs"
 Requires-Dist: femwell~=0.1.11 ; extra == "femwell"
 Requires-Dist: meshwell~=1.0.7 ; extra == "femwell"
 Requires-Dist: jinja2 ; extra == "gfviz"
@@ -58,20 +59,11 @@ Requires-Dist: jaxlib>=0.4.26 ; extra == "meow"
 Requires-Dist: flax>=0.8.2 ; extra == "meow"
 Requires-Dist: meow-sim>=0.13,<0.14 ; extra == "meow"
 Requires-Dist: tidy3d>=2.8.2,<2.9 ; extra == "meow"
-Requires-Dist: jax>=0.4.26 ; extra == "sax"
-Requires-Dist: jaxlib>=0.4.26 ; extra == "sax"
-Requires-Dist: flax>=0.8.2 ; extra == "sax"
 Requires-Dist: sax>=0.13.1,<0.15.0 ; extra == "sax"
-Requires-Dist: scikit-learn ; extra == "sax"
-Requires-Dist: pyvis<=0.3.1 ; extra == "sax"
-Requires-Dist: ray ; extra == "sax"
 Requires-Dist: bokeh ; extra == "schematic"
 Requires-Dist: ipywidgets ; extra == "schematic"
 Requires-Dist: natsort ; extra == "schematic"
 Requires-Dist: tidy3d>=2.8.2,<2.9 ; extra == "tidy3d"
-Requires-Dist: meshio ; extra == "tidy3d"
-Requires-Dist: numpy ; extra == "tidy3d"
-Requires-Dist: meshwell~=1.0.7 ; extra == "tidy3d"
 Requires-Dist: gdstk ; extra == "tidy3d"
 Requires-Dist: vlsir ; extra == "vlsir"
 Requires-Dist: vlsirtools ; extra == "vlsir"
@@ -90,7 +82,7 @@ Provides-Extra: schematic
 Provides-Extra: tidy3d
 Provides-Extra: vlsir
 
-# gplugins 1.3.5
+# gplugins 1.3.7
 
 [![docs](https://github.com/gdsfactory/gplugins/actions/workflows/pages.yml/badge.svg)](https://gdsfactory.github.io/gplugins/)
 [![PyPI](https://img.shields.io/pypi/v/gplugins)](https://pypi.org/project/gplugins/)

{gplugins-1.3.5 → gplugins-1.3.7}/README.md

@@ -1,4 +1,4 @@
-# gplugins 1.3.5
+# gplugins 1.3.7
 
 [![docs](https://github.com/gdsfactory/gplugins/actions/workflows/pages.yml/badge.svg)](https://gdsfactory.github.io/gplugins/)
 [![PyPI](https://img.shields.io/pypi/v/gplugins)](https://pypi.org/project/gplugins/)

{gplugins-1.3.5 → gplugins-1.3.7}/gplugins/__init__.py

@@ -1,6 +1,6 @@
 """gplugins - gdsfactory plugins."""
 
-__version__ = "1.3.5"
+__version__ = "1.3.7"
 
 import pathlib
 

{gplugins-1.3.5 → gplugins-1.3.7}/gplugins/common/base_models/component.py

@@ -2,6 +2,7 @@ from functools import cached_property
 from hashlib import md5
 from typing import TypeAlias
 
+import shapely
 import gdsfactory as gf
 import numpy as np
 from gdsfactory.component import Component
@@ -15,7 +16,6 @@ from pydantic import (
 )
 from shapely import MultiPolygon, Polygon
 
-from gplugins.gmsh.parse_gds import cleanup_component
 
 from ..types import AnyShapelyPolygon, GFComponent
 
@@ -24,6 +24,69 @@ from gdsfactory.pdk import get_layer_stack, get_layer, get_layer_name
 Coordinate: TypeAlias = tuple[float, float]
 
 
+def round_coordinates(geom, ndigits=4):
+    """Round coordinates to n_digits to eliminate floating point errors."""
+
+    def _round_coords(x, y, z=None):
+        x = round(x, ndigits)
+        y = round(y, ndigits)
+
+        if z is not None:
+            z = round(x, ndigits)
+
+        return [c for c in (x, y, z) if c is not None]
+
+    return shapely.ops.transform(_round_coords, geom)
+
+
+def fuse_polygons(component, layer, round_tol=4, simplify_tol=1e-4, offset_tol=None):
+    """Take all polygons from a layer, and returns a single (Multi)Polygon shapely object."""
+    layer_region = layer.get_shapes(component)
+
+    # Convert polygons to shapely
+    # TODO: do all polygon processing in KLayout at the gplugins level for speed
+    shapely_polygons = []
+    for klayout_polygon in layer_region.each_merged():
+        exterior_points = [
+            (point.x / 1000, point.y / 1000)
+            for point in klayout_polygon.each_point_hull()
+        ]
+        interior_points = []
+        for hole_index in range(klayout_polygon.holes()):
+            holes_points = [
+                (point.x / 1000, point.y / 1000)
+                for point in klayout_polygon.each_point_hole(hole_index)
+            ]
+            interior_points.append(holes_points)
+
+        shapely_polygons.append(
+            round_coordinates(
+                shapely.geometry.Polygon(shell=exterior_points, holes=interior_points),
+                round_tol,
+            )
+        )
+
+    return shapely.ops.unary_union(shapely_polygons).simplify(
+        simplify_tol, preserve_topology=False
+    )
+
+
+def cleanup_component(component, layer_stack, round_tol=2, simplify_tol=1e-2):
+    """Process component polygons before meshing."""
+    layer_stack_dict = layer_stack.to_dict()
+
+    return {
+        layername: fuse_polygons(
+            component,
+            layer["layer"],
+            round_tol=round_tol,
+            simplify_tol=simplify_tol,
+        )
+        for layername, layer in layer_stack_dict.items()
+        if layer["layer"] is not None
+    }
+
+
 def move_polar_rad_copy(
     pos: Coordinate, angle: float, length: float
 ) -> NDArray[np.float64]:
@@ -227,6 +290,9 @@ class LayeredComponentBase(BaseModel):
     def get_port_layers(self, port: gf.Port) -> tuple[str, ...]:
         layer_name = get_layer_name(port.layer)
 
+        if "_intent" in layer_name:
+            layer_name = layer_name.replace("_intent", "")
+
         derived_layers = []
         for l_name, level in self.layer_stack.layers.items():
             if layer_name in str(level.layer):
@@ -234,9 +300,6 @@ class LayeredComponentBase(BaseModel):
 
         return derived_layers
 
-
-
-
         # return ("core",)
         # return tuple(
         #     k for k, v in self.layer_stack.layers.items() if port.layer in v.layer

{gplugins-1.3.5 → gplugins-1.3.7}/gplugins/common/utils/get_sparameters_path.py

@@ -31,8 +31,7 @@ def _get_sparameters_path(
     dirpath: PathType | None = PATH.sparameters,
     **kwargs,
 ) -> Path:
-    """Return Sparameters npz filepath hashing simulation settings for \
-            a consistent unique name.
+    """Return Sparameters npz filepath hashing simulation settings for a consistent unique name.
 
     Args:
         component: component or component factory.
@@ -47,7 +46,7 @@ def _get_sparameters_path(
 
     dirpath = pathlib.Path(dirpath)
     dirpath = (
-        dirpath / component.function_name
+        dirpath / component.name
         if hasattr(component, "function_name")
         else dirpath
     )

{gplugins-1.3.5 → gplugins-1.3.7}/gplugins/gmeep/get_meep_geometry.py

@@ -58,12 +58,9 @@ def get_meep_geometry_from_component(
         layer = level.layer
 
         if isinstance(layer, LogicalLayer):
-            assert isinstance(layer.layer, tuple | LayerEnum)
-            layer_tuple = cast(tuple[int, int], tuple(layer.layer))
+            layer_tuple = gf.get_layer_tuple(layer.layer)
         elif isinstance(layer, DerivedLayer):
-            assert level.derived_layer is not None
-            assert isinstance(level.derived_layer.layer, tuple | LayerEnum)
-            layer_tuple = cast(tuple[int, int], tuple(level.derived_layer.layer))
+            layer_tuple = gf.get_layer_tuple(level.derived_layer.layer)
         else:
             raise ValueError(f"Layer {layer!r} is not a DerivedLayer or LogicalLayer")
 

{gplugins-1.3.5 → gplugins-1.3.7}/gplugins/gmeep/write_sparameters_meep.py

@@ -54,8 +54,7 @@ def remove_simulation_kwargs(d: dict[str, Any]) -> dict[str, Any]:
 def parse_port_eigenmode_coeff(
     port_name: str, ports: dict[str, Port], sim_dict: dict, port_mode: int = 0
 ):
-    """Returns the coefficients relative to whether the wavevector is entering or \
-            exiting simulation.
+    """Returns the coefficients relative to whether the wavevector is entering or exiting simulation.
 
     Args:
         port_index: index of port.
@@ -320,7 +319,7 @@ def write_sparameters_meep(
     filepath = filepath or get_sparameters_path(
         component=component,
         dirpath=dirpath,
-        layer_stack=layer_stack,
+        layer_stack=layer_stack.to_dict(),
         **sim_settings,
     )
 
@@ -605,8 +604,8 @@ settings_write_sparameters_meep = set(sig.parameters.keys()).union(
 )
 
 if __name__ == "__main__":
-    wavelength_start = 1.26
-    wavelength_stop = 1.36
+    wavelength_start = 1.5
+    wavelength_stop = 1.6
     sim_settings = dict(
         wavelength_start=wavelength_start, wavelength_stop=wavelength_stop
     )
@@ -621,8 +620,9 @@ if __name__ == "__main__":
     sp = write_sparameters_meep(
         c,
         run=True,
-        animate=True,
+        #animate=True,
         is_3d=False,
+        ymargin=3,
         plot_args={
             "eps_parameters": {"contour": True},
             "field_parameters": {

{gplugins-1.3.5 → gplugins-1.3.7}/gplugins/gmeep/write_sparameters_meep_mpi.py

@@ -45,7 +45,7 @@ def write_sparameters_meep_mpi(
     cores: int = core_materials,
     filepath: PathType | None = None,
     dirpath: PathType | None = None,
-    temp_dir: Path = temp_dir_default,
+    temp_dir: Path|str = temp_dir_default,
     temp_file_str: str = "write_sparameters_meep_mpi",
     live_output: bool = False,
     overwrite: bool = False,
@@ -152,6 +152,7 @@ def write_sparameters_meep_mpi(
         filepath.unlink()
 
     # Save all the simulation arguments for later retrieval
+    temp_dir = Path(temp_dir)
     temp_dir.mkdir(exist_ok=True, parents=True)
     tempfile = temp_dir / temp_file_str
     filepath_json = tempfile.with_suffix(".json")
@@ -178,7 +179,7 @@ def write_sparameters_meep_mpi(
         "if __name__ == '__main__':\n",
         f"\twith open(\"{parameters_file}\", 'rb') as inp:\n",
         "\t\tparameters_dict = pickle.load(inp)\n\n",
-        f"\tcomponent = import_gds({str(component_file)!r}, read_metadata=True)\n",
+        f"\tcomponent = import_gds({str(component_file)!r})\n",
         f"\tfilepath_json = pathlib.Path({str(filepath_json)!r})\n",
         "\tlayer_stack = LayerStack.parse_raw(filepath_json.read_text())\n",
         f"\twrite_sparameters_meep(component=component, overwrite={overwrite}, "
@@ -254,6 +255,7 @@ if __name__ == "__main__":
         temp_dir="./test/",
         filepath="instance_dict.csv",
         resolution=20,
+        is_3d=False,
     )
     sp = np.load(filepath)
     print(list(sp.keys()))

{gplugins-1.3.5 → gplugins-1.3.7}/pyproject.toml

@@ -25,7 +25,7 @@ license = {file = "LICENSE"}
 name = "gplugins"
 readme = "README.md"
 requires-python = ">=3.11"
-version = "1.3.5"
+version = "1.3.7"
 
 [project.optional-dependencies]
 dev = [
@@ -36,7 +36,7 @@ dev = [
   "pyswarms"
 ]
 devsim = ["devsim", "pyvista<=0.43.8", "tidy3d>=2.8.2,<2.9"]
-docs = ["jupytext", "matplotlib", "jupyter-book~=1.0", "pyvista[all]<=0.43.8", "bokeh"]
+docs = ["jupytext", "matplotlib", "jupyter-book~=1.0", "pyvista[all]<=0.43.8", "bokeh", "scikit-learn"]
 femwell = ["femwell~=0.1.11", "meshwell~=1.0.7"]
 gfviz = ["jinja2", "fastapi", "shapely", "natsort"]
 gmsh = [
@@ -61,16 +61,13 @@ meow = [
   "tidy3d>=2.8.2,<2.9"
 ]
 sax = [
-  "jax>=0.4.26",
-  "jaxlib>=0.4.26",
-  "flax>=0.8.2",
-  "sax>=0.13.1,<0.15.0",
-  "scikit-learn",
-  "pyvis<=0.3.1",
-  "ray"
+  "sax>=0.13.1,<0.15.0"
 ]
 schematic = ["bokeh", "ipywidgets", "natsort"]
-tidy3d = ["tidy3d>=2.8.2,<2.9", "meshio", "numpy", "meshwell~=1.0.7", "gdstk"]
+tidy3d = [
+  "tidy3d>=2.8.2,<2.9",
+  "gdstk"
+]
 vlsir = ["vlsir", "vlsirtools"]
 
 [tool.codespell]
@@ -192,7 +189,7 @@ message_template = "Bump to {new_version}"
 tag_template = "v{new_version}"
 
 [tool.tbump.version]
-current = "1.3.5"
+current = "1.3.7"
 regex = '''
   (?P<major>\d+)
   \.

gplugins-1.3.5/gplugins/sax/build_model.py

@@ -1,344 +0,0 @@
-import copy
-from pathlib import Path
-
-import jax.numpy as jnp
-import ray
-from gdsfactory.technology import LayerStack
-from gdsfactory.typings import PortSymmetries
-from tqdm.contrib.itertools import product
-
-from gplugins.sax.interpolators import nd_nd_interpolation
-from gplugins.sax.mlp import mlp_regression
-from gplugins.sax.parameter import (
-    LayerStackThickness,
-    LithoParameter,
-    NamedParameter,
-)
-
-
-class Model:
-    def __init__(
-        self,
-        trainable_component: callable,
-        layer_stack: LayerStack,
-        trainable_parameters: None
-        | (dict[str, LayerStackThickness | NamedParameter]) = None,
-        non_trainable_parameters: None
-        | (dict[str, LayerStackThickness | NamedParameter]) = None,
-        simulation_settings: dict[str, float | str | int | Path] | None = None,
-        num_modes: int = 2,
-        port_symmetries: PortSymmetries | None = None,
-        address: str | None = None,
-        dashboard_port: int = 8265,
-        num_cpus: int | None = None,
-        num_cpus_per_task: int = 1,
-        # num_gpus_per_task: int = 0,
-        restart_cluster: bool = False,
-        *args,
-        **kwargs,
-    ) -> None:
-        """Utility class which simplifies the execution of simulations to build compact models for circuit simulations.
-
-        Aims to be agnostic to the specific simulator being used.
-
-        It contains shared utilities for the different types of Models:
-            - Optional simulation hyperparameter tuning routine (TODO)
-            - Looping over training variables to generate training examples.
-            - Consistent formatting of training examples for model building.
-            - Interface with Ray clusters for distributed processing (even locally, this is beneficial)
-
-        Other functionality such as
-            - Simulation setup, execution, caching/loading
-            - Assembly of simulation results into S-parameters
-        is solver-dependent, and hence resides in child classes.
-
-        Todo:
-            - more consistent ordering of input/output data
-            - more JAX, less pure Python
-            - reuse Ray cluster across different model instances for simultaneous training
-
-        Attributes:
-            trainable_component: callable wrapping component associated with model
-            layer_stack: complete layer_stack associated with model
-            trainable parameters: parameters that are model features that need to be learned (e.g. width, layer thicknesses, wavelength, materials properties)
-            non_trainable_parameters: parameters for input_dict whose effect on S-parameters is known and does not need to be trained (e.g. length for a waveguide)
-            simulation_settings: simulation parameters that can impact model quality (e.g. resolution, domain size). Set their converged property to True to skip convergence tuning.
-            sim_settings: other simulation settings the solver can use
-            num_modes: number of modes to consider for each port in S-parameter calculation.
-            port_symmetries: as defined in FDTD solvers. Dict establishing equivalency between S-parameters.
-                e.g. {"o1@0,o1@0": ["o2@0,o2@0", "o3@0,o3@0", "o4@0,o4@0"]} means that S22 = S33 = S44 are the same as S11,
-                and hence the output vector for model training will only contain the key S11 to reduce the number of variables to fit.
-            address: of the Ray cluster to connect to. Defaults to finding a local running instance.
-            dashboard_port: IP address of the dashboard to monitor the cluster
-            num_cpus: available to the cluster (if not autoscaling)
-            num_cpus_per_task: number of CPUs to assign to each task
-            num_gpus_per_task: number of GPUs to assign to each task
-            restart_cluster: if instantiating multiple models in the same Python session, whether to restart the cluster.
-        """
-        self.trainable_component = trainable_component
-        self.layer_stack = layer_stack
-        self.trainable_parameters = trainable_parameters or {}
-        self.non_trainable_parameters = non_trainable_parameters or {}
-        self.simulation_settings = simulation_settings or {}
-        self.num_modes = num_modes
-
-        # Extract inputs and outputs vector size data
-        self.size_inputs = len(self.trainable_parameters)
-        self.num_ports = len(
-            trainable_component(self.get_nominal_dict()).ports.filter(
-                port_type="optical"
-            )
-        )
-
-        # Extract input and output vector label data
-        self.input_vector_labels = list(self.trainable_parameters) + list(
-            self.non_trainable_parameters.keys()
-        )
-
-        # self.size_outputs = self.num_ports * self.num_modes
-        self.port_symmetries = port_symmetries
-
-        # Cluster resources
-        self.num_cpus_per_task = num_cpus_per_task
-        # self.num_gpus_per_task = num_gpus_per_task
-        if restart_cluster and ray.is_initialized():
-            ray.shutdown()
-        if not ray.is_initialized():
-            ray.init(dashboard_port=dashboard_port, num_cpus=num_cpus)
-
-    """
-    PARAMETERS
-    """
-
-    def get_nominal_dict(self):
-        """Return input_dict of nominal parameter values."""
-        return {
-            name: parameter.nominal_value
-            for name, parameter in self.trainable_parameters.items()
-        }
-
-    def get_random_dict(self):
-        """Return input_dict of randomly sampled parameter values."""
-        return {
-            name: parameter.sample()
-            for name, parameter in self.trainable_parameters.items()
-        }
-
-    def parse_input_dict(self, input_dict):
-        """Separates between LayerStackThickness, NamedParameter, and LithoParameter inputs.
-
-        Args:
-            input_dict: key needs to match the keys in self.trainable_parameters
-                values are the new values to assign to these parameters.
-        """
-        param_dict = {}
-        layer_stack_param_dict = {}
-        litho_param_dict = {}
-        for key, value in input_dict.items():
-            if type(self.trainable_parameters[key]) is NamedParameter:
-                param_dict[key] = value
-            elif type(self.trainable_parameters[key]) is LayerStackThickness:
-                layer_stack_param_dict[key] = value
-            elif type(self.trainable_parameters[key]) is LithoParameter:
-                litho_param_dict[key] = value
-        return param_dict, layer_stack_param_dict, litho_param_dict
-
-    def perturb_layer_stack(self, layer_stack_param_dict):
-        """Returns a temporary LayerStack with a new thickness value for the (current) LayerStackThickness objects in layer_stack_param_dict.
-
-        Args:
-            layer_stack_param_dict: key needs to match a key in self.trainable_parameters having for value a LayerStackThickness object
-                                    value is the thickness to assign to this parameter
-        """
-        perturbed_layer_stack = copy.deepcopy(self.layer_stack)
-        for key, thickness in layer_stack_param_dict.items():
-            LayerStackThickness_obj = self.trainable_parameters[key]
-            perturbed_layer_stack.layers[
-                LayerStackThickness_obj.layername
-            ].thickness = thickness
-        return perturbed_layer_stack
-
-    def perturb_geometry(self, current_component, litho_param_dict):
-        """Returns a temporary Component on which all the morphological operations contained in the current litho_param_dict have been applied.
-
-        Args:
-            current_component: the current component, with params_dict already applied
-            litho_param_dict: key needs to match a key in self.trainable_parameters having for value a LithoParameter object
-                                    value is the input to the LithoParameter transformation attribute
-        """
-        for key, value in litho_param_dict.items():
-            lithoParameter_obj = self.trainable_parameters[key]
-            current_component = lithoParameter_obj.get_transformation(
-                current_component, value
-            )
-        return current_component
-
-    """
-    QUEUING
-    """
-
-    def define_output_vector_labels(self):
-        """Uses number of component ports, number of modes solved for, and port_symmetries to define smallest output vector."""
-        output_vector_labels_iter = product(
-            range(1, self.num_ports + 1),
-            range(self.num_modes),
-            range(1, self.num_ports + 1),
-            range(self.num_modes),
-        )
-        output_vector_labels = []
-        for output_label in output_vector_labels_iter:
-            output_key1 = f"o{output_label[0]}@{output_label[1]}"
-            output_key2 = f"o{output_label[2]}@{output_label[3]}"
-            if output_key1 != output_key2:
-                output_key = f"{output_key1},{output_key2}"
-                output_vector_labels.append(output_key)
-
-        if self.port_symmetries:
-            for value_list in self.port_symmetries.values():
-                for value in value_list:
-                    output_vector_labels.remove(value)
-
-        return output_vector_labels
-
-    def arange_inputs(self, type="arange"):
-        """Prepares input vectors for spanning simulation space.
-
-        Arguments:
-            type: str, arange or corners. Defines the iterator function to use with parameter objects.
-
-        Returns:
-            ranges_dict: dict, with keys parameter names and values arrays of containing all unique parameter values.
-        """
-        if type == "arange":
-            ranges_dict = {
-                name: parameter.arange()
-                for name, parameter in self.trainable_parameters.items()
-            }
-        elif type == "corners":
-            ranges_dict = {
-                name: parameter.corners()
-                for name, parameter in self.trainable_parameters.items()
-            }
-        else:
-            raise ValueError("Type should be arange or corners.")
-
-        return ranges_dict
-
-    def get_output_from_inputs(self, labels, values, remote_function):
-        """Get one output vector from a set of inputs.
-
-        How to map parameters to simulation inputs depends on the target simulator.
-
-        Arguments:
-            labels: keys of the parameters
-            values: values of the parameters
-            remote_function: ray remote function object to use for the simulation
-
-        Returns:
-            remote function ID for delayed execution
-            the remote function returns new_inputs, output_vectors
-            new_inputs is an array containing derived inputs (e.g. wavelength in FDTD broadband simulation)
-            output_vectors is a vector of reals representing the output to model (neff, s-params, etc.)
-        """
-        return NotImplementedError
-
-    def get_all_inputs_outputs(self, type="arange"):
-        """Get all outputs given all sets of inputs.
-
-        get_output_from_inputs and remote_function are defined in the child class.
-        """
-        # Define possible parameter values
-        ranges_dict = self.arange_inputs(type=type)
-        # For all combinations of parameter values
-        input_ids = list(product(*ranges_dict.values()))
-        output_ids = [
-            self.get_output_from_inputs(
-                ranges_dict.keys(), values, self.remote_function
-            )
-            for values in product(*ranges_dict.values())
-        ]
-        # Execute the jobs
-        results = ray.get(output_ids)
-
-        # Parse the outputs into input and output vectors
-        input_vectors = []
-        output_vectors = []
-        for input_example, output_example in zip(
-            input_ids, results
-        ):  # TODO no for loops!
-            input_vector = list(input_example)
-            input_vector.extend(output_example[0])
-            input_vectors.append(input_vector)
-            output_vectors.append(output_example[1])
-
-        return (
-            jnp.array(input_vectors),
-            jnp.array(output_vectors),
-        )
-
-    """
-    MODELS
-    """
-
-    def set_nd_nd_interp(self) -> None:
-        """Returns ND-ND interpolator.
-
-        Returns:
-            self.inference: [callable giving an output_vector given an input_vector]
-            list is of length 2*output_vector length, first output_vector entries are real, second imaginary
-        """
-        input_vectors, output_vectors = self.get_all_inputs_outputs()
-        self.inference = nd_nd_interpolation(input_vectors, output_vectors)
-
-    def set_mlp_interp(self) -> None:
-        """Returns multilayer perceptron interpolator.
-
-        Returns:
-            self.inference: [callable giving an output_vector given an input_vector]
-            list is of length 2*output_vector length, first output_vector entries are real, second imaginary
-        """
-        input_vectors, output_vectors = self.get_all_inputs_outputs()
-        self.inference = mlp_regression(input_vectors, output_vectors)
-
-    def input_dict_to_input_vector(self, input_dict):
-        """Convert an input_dict with trainable and non-trainable parameters to an input vector on which inference can be performed.
-
-        Find faster way!
-        """
-        return_array = [
-            value
-            for key, value in input_dict.items()
-            if key in self.trainable_parameters.keys()
-        ]
-        return jnp.array(return_array)
-
-    def validate(self, num_samples=1):
-        """Validates the model by calculating random points within the interpolation range, and comparing to predictions."""
-        calculated_outputs_ids = []
-        inferred_outputs = []
-        validation_inputs = []
-        for _index in range(num_samples):
-            validation_inputs_local = self.get_random_dict()
-            validation_inputs.append(validation_inputs_local)
-            calculated_outputs_ids.append(
-                self.get_output_from_inputs(
-                    validation_inputs_local.keys(),
-                    validation_inputs_local.values(),
-                    self.remote_function,
-                )
-            )
-            inferred_outputs_local = [
-                self.inference[mode](validation_inputs_local.values())
-                for mode in range(self.num_modes)
-            ]
-            inferred_outputs.append(inferred_outputs_local)
-
-        # Execute the jobs
-        calculated_outputs_results = ray.get(calculated_outputs_ids)
-
-        # Parse the outputs into input and output vectors
-        calculated_outputs = [
-            calculated_output_vector[1]
-            for calculated_output_vector in calculated_outputs_results
-        ]
-        return validation_inputs, calculated_outputs, inferred_outputs