REFACTOR: Delete ML patch class (#5916)

Co-authored-by: pyansys-ci-bot <92810346+pyansys-ci-bot@users.noreply.github.com>

Author: Samuelopez-ansys

doc/changelog.d/5916.miscellaneous.md

@@ -0,0 +1 @@
+Delete ML patch class

pyproject.toml

@@ -65,7 +65,6 @@ integration-tests = [
 ]
 tests = [
     "ipython>=7.30.0,<9.1",
-    "joblib>=1.0.0,<1.5",
     "matplotlib>=3.5.0,<3.11",
     "mock>=5.1.0,<5.3",
     "numpy>=1.20.0,<2.3",
@@ -78,8 +77,6 @@ tests = [
     "pyvista[io]>=0.38.0,<0.45",
     "ansys-tools-visualization-interface; python_version >= '3.10'",
     "tables; python_version >= '3.10'",
-    # Never directly imported but required when loading ML related file see #4713
-    "scikit-learn>=1.0.0,<1.7",
     "scikit-rf>=0.30.0,<1.7",
     "pytest-timeout>=2.3.0,<2.4",
 ]
@@ -115,8 +112,6 @@ all = [
     "fast-simplification>=0.1.7",
     "ansys-tools-visualization-interface; python_version >= '3.10'",
     "tables; python_version >= '3.10'",
-    # Never directly imported but required when loading ML related file see #4713
-    "scikit-learn>=1.0.0,<1.7",
     "scikit-rf>=0.30.0,<1.7",
 ]
 installer = [
@@ -128,8 +123,6 @@ installer = [
     "pyvista[io]>=0.38.0,<0.45",
     "fast-simplification>=0.1.7",
     "ansys-tools-visualization-interface; python_version >= '3.10'",
-    # Never directly imported but required when loading ML related file see #4713
-    "scikit-learn>=1.0.0,<1.7",
     "scikit-rf>=0.30.0,<1.7",
     "jupyterlab>=3.6.0,<4.4",
     "ipython>=7.30.0,<9.1",

src/ansys/aedt/core/misc/patch_svr_model_100MHz_1GHz.joblib

@@ -22,10 +22,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import os
-
 from ansys.aedt.core import constants
-from ansys.aedt.core import pyaedt_path
 from ansys.aedt.core.generic.file_utils import generate_unique_name
 from ansys.aedt.core.generic.general_methods import pyaedt_function_handler
 from ansys.aedt.core.modules.material_lib import Material
@@ -691,78 +688,6 @@ def add_patch(
         created_patch.aedt_object.group_name = f"Layer_{self._name}"
         return created_patch
 
-    @pyaedt_function_handler()
-    def ml_patch(
-        self,
-        frequency,
-        patch_width,
-        patch_position_x=0,
-        patch_position_y=0,
-        patch_name=None,
-        axis="X",
-    ):
-        """Create a new parametric patch using machine learning algorithm rather than analytic formulas.
-
-        Parameters
-        ----------
-        frequency : float, None
-            Frequency value for patch calculation in Hz.
-        patch_width : float
-            Patch width.
-        patch_position_x : float, optional
-            Patch start x position.
-        patch_position_y : float, optional
-            Patch start y position.
-        patch_name : str, optional
-            Patch name.
-        axis : str, optional
-            Line orientation axis.
-
-        Returns
-        -------
-        :class:`ansys.aedt.core.modeler.advanced_cad.stackup_3d.MachineLearningPatch`
-
-        Examples
-        --------
-
-        >>> from ansys.aedt.core import Hfss
-        >>> from ansys.aedt.core.modeler.advanced_cad.stackup_3d import Stackup3D
-        >>> hfss = Hfss()
-        >>> my_stackup = Stackup3D(hfss, 2.5e9)
-        >>> gnd = my_stackup.add_ground_layer("gnd")
-        >>> my_stackup.add_dielectric_layer("diel1", thickness=1.5, material="Duroid (tm)")
-        >>> top = my_stackup.add_signal_layer("top")
-        >>> my_patch = top.ml_patch(frequency=None, patch_width=51, patch_name="MLPatch")
-        >>> my_stackup.resize_around_element(my_patch)
-
-        """
-        if not patch_name:
-            patch_name = generate_unique_name(f"{self._name}_patch", n=3)
-        lst = self._stackup._layer_name
-        for i in range(len(lst)):
-            if lst[i] == self._name:
-                if self._stackup.stackup_layers[lst[i - 1]].type == "dielectric":
-                    below_layer = self._stackup.stackup_layers[lst[i - 1]]
-                    break
-                else:
-                    self._app.logger.error("The layer below the selected one must be of dielectric type")
-                    return False
-        created_patch = MachineLearningPatch(
-            self._app,
-            frequency,
-            patch_width,
-            signal_layer=self,
-            dielectric_layer=below_layer,
-            patch_position_x=patch_position_x,
-            patch_position_y=patch_position_y,
-            patch_name=patch_name,
-            axis=axis,
-        )
-        self._obj_3d.append(created_patch.aedt_object)
-        self._stackup._object_list.append(created_patch)
-        created_patch.aedt_object.group_name = f"Layer_{self._name}"
-        return created_patch
-
     @pyaedt_function_handler()
     def add_trace(
         self,
@@ -3378,119 +3303,3 @@ def points_on_layer(self):
         """
         bb = self._aedt_object.bounding_box
         return [[bb[0], bb[1]], [bb[0], bb[4]], [bb[3], bb[4]], [bb[3], bb[1]]]
-
-
-class MachineLearningPatch(Patch, object):
-    """MachineLearningPatch Class in Stackup3D. Create an antenna whose length is predicted by a
-    machine learning algorithm.
-
-    The machine learning algorithm determines the length according to resonant frequency,
-    patch width, substrat thickness and relative permittivity. The other parameter have no or only a minor influence.
-    We can consider that the patch thickness has no influence as long as it is lower than 50 um,
-    for machine learning training is set to 35 um. The patch conductivity and other dielectric properties are
-    respectively those of copper and duroid (tm) for the machine learning training, but predictions work
-    regardless of the dielectric or the conductor. The predictions are, in the most of cases, better than the
-    predictions with formula used in the class Patch. The machine learning model used, is Support Vector Regression,
-    it is a classic model in the non-linear prediction, it can be used for other non-linear application.
-    Two models were created, one from 0.1 GHz to 1 GHz and another from 1 GHz to 10 GHz. The example of the creation of
-    these models is available in a PyAEDT example named Machine_learning_applied_to_Patch. The two databases and models
-    are available in PyAEDT in misc.
-
-    It is preferable to use the ml_patch method in the class Layer3D than directly the class constructor.
-
-    Parameters
-    ----------
-    application : :class:`ansys.aedt.core.hfss.Hfss`
-        HFSS design or project where the variable is to be created.
-    frequency : float, None
-        The patch frequency, it is used in prediction formulas. If it is None, the patch frequency will be that of the
-        layer or of the stackup. From 0.1 to 10 GHz.
-    dx : float
-        The patch width. From O.5 to 1.5 of the optimal width value : c0 * 1000/(2 * f * sqrt((er  + 1)/2))
-    signal_layer : :class:`ansys.aedt.core.modeler.advanced_cad.stackup_3d.Layer3D`
-        The signal layer where the patch will be drawn.
-    dielectric_layer : :class:`ansys.aedt.core.modeler.advanced_cad.stackup_3d.Layer3D`
-        The dielectric layer between the patch and the ground layer. Its permittivity and thickness are used in
-        prediction formulas. Thickness must be from 0.003 to 0.05 of the wavelength in vacuum and relative permittivity
-        from 1 to 12.
-    patch_position_x : float, optional
-        Patch x position, by default it is 0.
-    patch_position_y : float, optional
-        Patch y position, by default it is 0.
-    patch_name : str, optional
-        Patch name, by  default "patch".
-    reference_system : str, None, optional
-        Coordinate system of the patch. By default, None.
-    axis : str, optional
-        Patch length axis, by default ``"X"``.
-
-    Examples
-    --------
-
-    >>> from ansys.aedt.core import Hfss
-    >>> from ansys.aedt.core.modeler.advanced_cad.stackup_3d import Stackup3D
-    >>> hfss = Hfss()
-    >>> my_stackup = Stackup3D(hfss, 2.5e9)
-    >>> gnd = my_stackup.add_ground_layer("gnd")
-    >>> my_stackup.add_dielectric_layer("diel1", thickness=1.5, material="Duroid (tm)")
-    >>> top = my_stackup.add_signal_layer("top")
-    >>> my_patch = top.ml_patch(frequency=None, patch_width=51, patch_name="MLPatch")
-    >>> my_stackup.resize_around_element(my_patch)
-
-    """
-
-    def __init__(
-        self,
-        application,
-        frequency,
-        dx,
-        signal_layer,
-        dielectric_layer,
-        patch_position_x=0,
-        patch_position_y=0,
-        patch_name="patch",
-        reference_system=None,
-        axis="X",
-    ):
-        Patch.__init__(
-            self,
-            application,
-            frequency,
-            dx,
-            signal_layer,
-            dielectric_layer,
-            dy=None,
-            patch_position_x=patch_position_x,
-            patch_position_y=patch_position_y,
-            patch_name=patch_name,
-            reference_system=reference_system,
-            axis=axis,
-        )
-        self.predict_length()
-
-    def predict_length(self):
-        try:
-            import joblib
-            import numpy as np
-        except ImportError:  # pragma: no cover
-            raise ImportError("Package Joblib and Numpy are required to run ML.")
-        training_file = None
-        if 1e9 >= self.frequency.numeric_value >= 1e8:
-            training_file = os.path.join(pyaedt_path, "misc", "patch_svr_model_100MHz_1GHz.joblib")
-        elif 1e10 >= self.frequency.numeric_value > 1e9:
-            training_file = os.path.join(pyaedt_path, "misc", "patch_svr_model_1GHz_10GHz.joblib")
-        else:  # pragma: no cover
-            self.application.logger.error("This ML algorithm can only predict patch antennas from 100 MHz to 10 GHz.")
-        if training_file:
-            model = joblib.load(training_file)
-            list_for_array = [
-                [
-                    self.frequency.numeric_value,
-                    self.width.numeric_value,
-                    self._permittivity.numeric_value,
-                    self.dielectric_layer.thickness.numeric_value,
-                ]
-            ]
-            array_for_prediction = np.array(list_for_array, dtype=np.float32)
-            length = model.predict(array_for_prediction)[0]
-            self.length.expression = self.application.value_with_units(length)

src/ansys/aedt/core/misc/patch_svr_model_1GHz_10GHz.joblib

@@ -159,14 +159,6 @@ def test_06_hide_variables(self):
         assert self.st.dielectric_x_position.hide_variable(False)
         assert self.st.dielectric_x_position.read_only_variable(False)
 
-    def test_07_ml_patch(self):
-        top = self.st.stackup_layers["top"]
-        gnd = self.st.stackup_layers["gnd1"]
-        width = 1e3 * 3e8 / (2 * 1e9 * ((2.2 + 1) / 2) ** (1 / 2))
-        patch2 = top.ml_patch(1e9, patch_width=width, patch_position_x=0, patch_position_y=0)
-        patch2.create_lumped_port(gnd, opposite_side=True)
-        assert self.st.resize_around_element(patch2)
-
     def test_08_duplicated_parametrized_material(self):
         diel = self.st.stackup_layers["diel1"]
         assert diel.duplicated_material.permittivity