Source code for ansys.aedt.toolkits.antenna.backend.antenna_models.common

# -*- coding: utf-8 -*-
#
# Copyright (C) 2023 - 2025 ANSYS, Inc. and/or its affiliates.
# SPDX-License-Identifier: MIT
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

import copy
import math
import os

import ansys.aedt.core.generic.constants as constants
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.toolkits.antenna.backend.antenna_models.parameters import InputParameters
from ansys.aedt.toolkits.antenna.backend.antenna_models.parameters import Property
from ansys.aedt.toolkits.antenna.backend.antenna_models.parameters import SynthesisParameters
from ansys.aedt.toolkits.antenna.backend.models import properties


class CommonAntenna(object):
    """Provides base methods common to the antenna toolkit."""

    antenna_type = ""

    def __init__(self, default_input_parameters, *args, **kwargs):
        self._app = args[0]
        self._input_parameters = InputParameters(default_input_parameters)

        for k, v in kwargs.items():
            if k in default_input_parameters:
                setattr(self._input_parameters, k, copy.deepcopy(v))
            else:
                raise AttributeError(
                    f"{k} is not a valid parameter for this antenna. \n"
                    f"Accepted parameters are {str(list(default_input_parameters.keys()))}"
                )

        if self._input_parameters.length_unit is None:
            self._input_parameters.length_unit = properties.antenna.synthesis.length_unit

        if self._app:
            self._input_parameters.name = self._check_antenna_name(self._input_parameters.name)

        self.synthesis_parameters = SynthesisParameters()
        self.synthesis_parameters.name = self._input_parameters.name

        self.object_list = {}
        self.boundaries = {}
        self.excitations = {}
        self.mesh_operations = {}

    @property
    def material(self):
        """Material assigned.

        Returns
        -------
        str
        """
        return self._input_parameters.material

    @material.setter
    def material(self, value):
        self._input_parameters.material = value
        if self.object_list:
            parameters = self.synthesis()
            self.update_synthesis_parameters(parameters)
            self.set_variables_in_hfss()

    @property
    def frequency(self):
        """Center frequency.

        Returns
        -------
        float
        """
        return self._input_parameters.frequency

    @frequency.setter
    def frequency(self, value):
        self._input_parameters.frequency = value
        parameters = self.synthesis()
        self.update_synthesis_parameters(parameters)
        if self.object_list:
            self.set_variables_in_hfss()

    @property
    def frequency_unit(self):
        """Frequency units.

        Returns
        -------
        str
        """
        return self._input_parameters.frequency_unit

    @frequency_unit.setter
    def frequency_unit(self, value):
        self._input_parameters.frequency_unit = value
        parameters = self.synthesis()
        self.update_synthesis_parameters(parameters)
        if self.object_list:
            self.set_variables_in_hfss()

    @property
    def outer_boundary(self):
        """Outer boundary.

        Returns
        -------
        str
        """
        return self._input_parameters.outer_boundary

    @outer_boundary.setter
    def outer_boundary(self, value):
        self._input_parameters.outer_boundary = value
        if self.object_list:
            self._app.create_open_region(
                str(self.frequency) + self.frequency_unit,
                value,
            )

    @property
    def length_unit(self):
        """Length unit.

        Returns
        -------
        str
        """
        return self._input_parameters.length_unit

    @length_unit.setter
    def length_unit(self, value):
        self._input_parameters.length_unit = value
        parameters = self.synthesis()
        self.update_synthesis_parameters(parameters)
        if self.object_list:
            self.set_variables_in_hfss()

    @property
    def coordinate_system(self):
        """Reference coordinate system.

        Returns
        -------
        str
        """
        return self._input_parameters.coordinate_system

    @coordinate_system.setter
    def coordinate_system(self, value):
        self._input_parameters.coordinate_system = value
        for antenna_obj in self.object_list:
            self.object_list[antenna_obj].history().properties[
                "Coordinate System"
            ] = self._input_parameters.coordinate_system

    @property
    def name(self):
        """Antenna name.

        Returns
        -------
        str
        """
        return self._input_parameters.name

    @name.setter
    def name(self, value):
        if value != self.name and self.object_list:
            for antenna_obj in self.object_list:
                self.object_list[antenna_obj].group_name = value
            if len(list(self._app.modeler.oeditor.GetObjectsInGroup(self.name))) == 0:
                self._app.modeler.oeditor.Delete(["NAME:Selections", "Selections:=", self.name])
        self._input_parameters.name = value

    @property
    def origin(self):
        """Antenna origin.

        Returns
        -------
        list
        """
        return self._input_parameters.origin

    @origin.setter
    def origin(self, value):
        self._input_parameters.origin = value
        if self.object_list:
            parameters = self.synthesis()
            self.update_synthesis_parameters(parameters)
            self.set_variables_in_hfss()

    @pyaedt_function_handler()
    def create_lattice_pair(self, lattice_height=None, bottom_extend=False):
        """Create a lattice pair box.

        Parameters
        ----------
        lattice_height : str, optional
            Height of the lattice pair box.
        bottom_extend : bool, optional
            Whether to extend the lattice pair in the bottom side. The default is ``False``.

        Returns
        -------
        :class:`ansys.aedt.core.modeler.object3d.Object3d`
            3D object.

        Examples
        --------
        >>> from ansys.aedt.core import Hfss
        >>> from ansys.aedt.toolkits.antenna.backend.antenna_models.horn import Conical
        >>> hfss = Hfss()
        >>> horn = hfss.add_from_toolkit(Conical, draw=True)
        >>> horn = horn.create_lattice_pair(lattice_height="20mm")
        """
        if not lattice_height:
            lightSpeed = constants.SpeedOfLight  # m/s
            freq_hz = constants.unit_converter(self.frequency, "Freq", self.frequency_unit, "Hz")
            wavelength = lightSpeed / freq_hz
            lattice_height = str(wavelength / 10.0) + "meter"

        self.synthesis_parameters.add_parameter("lattice_height", lattice_height)

        hfss_parameter = self.synthesis_parameters.lattice_height.hfss_variable
        self._app[hfss_parameter] = self.synthesis_parameters.lattice_height.value

        bounding_box = self._app.modeler.get_group_bounding_box(self.name)
        bounding_dim = [
            abs(bounding_box[0] - bounding_box[3]),
            abs(bounding_box[1] - bounding_box[4]),
            abs(bounding_box[2] - bounding_box[5]),
        ]

        if bottom_extend:
            lattice_box = self._app.modeler.create_box(
                origin=[
                    str(bounding_box[0]) + self._app.modeler.model_units,
                    str(bounding_box[1]) + self._app.modeler.model_units,
                    str(bounding_box[2]) + self._app.modeler.model_units + "-" + hfss_parameter,
                ],
                sizes=[
                    str(bounding_dim[0]) + self._app.modeler.model_units,
                    str(bounding_dim[1]) + self._app.modeler.model_units,
                    str(bounding_dim[2]) + self._app.modeler.model_units + "+2*" + hfss_parameter,
                ],
                material="vacuum",
            )
        else:
            lattice_box = self._app.modeler.create_box(
                origin=[
                    str(bounding_box[0]) + self._app.modeler.model_units,
                    str(bounding_box[1]) + self._app.modeler.model_units,
                    str(bounding_box[2]) + self._app.modeler.model_units,
                ],
                sizes=[
                    str(bounding_dim[0]) + self._app.modeler.model_units,
                    str(bounding_dim[1]) + self._app.modeler.model_units,
                    str(bounding_dim[2]) + self._app.modeler.model_units + "+" + hfss_parameter,
                ],
                material="vacuum",
            )

        lattice1 = self._app.assign_lattice_pair(face_couple=[lattice_box.bottom_face_x.id, lattice_box.top_face_x.id])
        self.boundaries[lattice1.name] = lattice1
        lattice2 = self._app.assign_lattice_pair(face_couple=[lattice_box.bottom_face_y.id, lattice_box.top_face_y.id])
        self.boundaries[lattice2.name] = lattice2

        self.object_list[lattice_box.name] = lattice_box

        return lattice_box

    @pyaedt_function_handler()
    def create_3dcomponent(self, component_file=None, component_name=None, replace=False):
        """Create a 3D component of the antenna.

        Parameters
        ----------
        component_file : str, optional
            Full path to the A3DCOMP file. The default is the ``ansys.aedt.core`` folder.
        component_name : str, optional
            Name of the component. The default is the antenna name.
        replace : bool, optional
            Whether to eplace the antenna with a 3D component. The default is ``False``.

        Returns
        -------
        str
            Path of the 3D component file or
            :class:`ansys.aedt.core.modeler.components_3d.UserDefinedComponent`.

        Examples
        --------
        >>> from ansys.aedt.core import Hfss
        >>> from ansys.aedt.toolkits.antenna.backend.antenna_models.horn import Conical
        >>> hfss = Hfss()
        >>> horn = hfss.add_from_toolkit(Conical, draw=True)
        >>> horn = horn.create_3dcomponent()
        """
        if not component_file:
            component_file = os.path.join(self._app.working_directory, self.name + ".a3dcomp")
        if not component_name:
            component_name = self.name

        parameters = []
        for p in self.synthesis_parameters.__dict__.values():
            if isinstance(p, Property):
                parameters.append(p.hfss_variable)

        boundaries = list(self.boundaries.keys())
        if not boundaries:
            boundaries = [""]

        self._app.modeler.create_3dcomponent(
            input_file=component_file,
            name=component_name,
            variables_to_include=parameters,
            assignment=list(self.object_list.keys()),
            boundaries=boundaries,
            excitations=list(self.excitations.keys()),
            coordinate_systems=[self.coordinate_system],
            reference_coordinate_system=self.coordinate_system,
            component_outline="None",
        )

        if replace:
            user_defined_component = self._app.modeler.replace_3dcomponent(
                name=component_name,
                variables_to_include=parameters,
                assignment=list(self.object_list.keys()),
                boundaries=boundaries,
                excitations=list(self.excitations.keys()),
                coordinate_systems=[self.coordinate_system],
                reference_coordinate_system=self.coordinate_system,
            )
            if self._app.modeler.oeditor.GetObjectsInGroup(self.name).count == 0:
                self._app.modeler.oeditor.Delete(["NAME:Selections", "Selections:=", self.name])
            return user_defined_component
        return component_file

    @pyaedt_function_handler()
    def duplicate_along_line(self, vector, num_clones=2):
        """Duplicate the object along a line.

        Parameters
        ----------
        vector : list
            List of ``[x1 ,y1, z1]`` coordinates for the vector.
        num_clones : int, optional
            Number of clones. The default is ``2``.

        Returns
        -------
        dict
            Dictionary with the list of new objects.

        Examples
        --------
        >>> from ansys.aedt.core import Hfss
        >>> from ansys.aedt.toolkits.antenna.backend.antenna_models.horn import Conical
        >>> hfss = Hfss()
        >>> horn = hfss.add_from_toolkit(Conical, draw=True)
        >>> new_horn = horn.duplicate_along_line([10, 0, 0], 2)
        """
        new_objects = {}
        for i in range(0, num_clones - 1):
            new_objects["antenna" + str(i)] = []
        for component in self.object_list:
            _, output = self._app.modeler.duplicate_along_line(component, vector, num_clones)
            for i in range(0, num_clones - 1):
                new_objects["antenna" + str(i)].append(output[i])

        return new_objects

    @pyaedt_function_handler()
    def _update_parameters(self, parameters, length_unit):
        for param in parameters:
            self._app[param] = str(parameters[param]) + length_unit
        return True

    @pyaedt_function_handler()
    def synthesis(self):
        pass

    @pyaedt_function_handler()
    def _check_antenna_name(self, antenna_name=None):
        """Check if antenna name is repeated or assign a random antenna name."""
        if (
            not antenna_name
            or len(list(self._app.modeler.oeditor.GetObjectsInGroup(antenna_name))) > 0
            or any(antenna_name in variables for variables in list(self._app.variable_manager.variables.keys()))
        ):
            antenna_name = generate_unique_name(self.antenna_type)
            if self._app:
                while len(list(self._app.modeler.oeditor.GetObjectsInGroup(antenna_name))) > 0:
                    antenna_name = generate_unique_name(self.antenna_type)
        return antenna_name

    @pyaedt_function_handler()
    def update_synthesis_parameters(self, new_params):
        """Update the synthesis parameter from the antenna list."""
        for k, v in new_params.items():
            if hasattr(self.synthesis_parameters, k):
                param = getattr(self.synthesis_parameters, k)
                param.value = float(round(v, 6))
            else:
                self.synthesis_parameters.add_parameter(k, v)

    @pyaedt_function_handler()
    def set_variables_in_hfss(self, not_used=None):
        """Create HFSS design variables."""
        if not not_used:
            not_used = []
        for p in self.synthesis_parameters.__dict__.values():
            if isinstance(p, Property) and p.hfss_variable not in not_used:
                properties.antenna.parameters_hfss[p.name] = p.hfss_variable
                if "angle" in p.hfss_variable:
                    self._app[p.hfss_variable] = str(p.value) + "deg"
                elif "ratio" in p.hfss_variable:
                    self._app[p.hfss_variable] = str(p.value)
                else:
                    self._app[p.hfss_variable] = str(p.value) + self.length_unit

    @pyaedt_function_handler()
    def init_model(self):
        """Create a radiation boundary."""
        if self._input_parameters.outer_boundary:
            self._app.create_open_region(str(self.frequency) + self.frequency_unit, self.outer_boundary)

    @pyaedt_function_handler()
    def setup_hfss(self):
        """Set up an antenna in HFSS."""

        for obj_name in self.object_list.keys():
            if obj_name.startswith("PerfE") or obj_name.startswith("gnd_") or obj_name.startswith("ant_"):
                bound = self._app.assign_perfecte_to_sheets(obj_name)
                bound.name = "PerfE_" + obj_name
                self.boundaries[bound.name] = bound
            elif obj_name.startswith("coax"):
                obj = self.object_list[obj_name]
                face_id = obj.faces[0].edges[0].id
                for face in obj.faces:
                    if len(face.edges) == 2:
                        face_id = face.id
                        break
                coax_bound = self._app.assign_perfecte_to_sheets(face_id)
                coax_bound.name = "PerfE_" + obj_name
                self.boundaries[coax_bound.name] = coax_bound
                break

        port_count = 1
        for item in list(self.object_list.keys()):
            terminal_references = []
            port_lump = port = port_cap = None
            if "port_lump_{}".format(self.name) in item:
                port_lump = self.object_list[item]
                terminal_references = [
                    i
                    for i in port_lump.touching_objects
                    if self._app.modeler[i]
                    and (
                        self._app.modeler[i].object_type == "Sheet"
                        or self._app.materials[self._app.modeler[i].material_name].is_conductor()
                    )
                ]
                if len(terminal_references) > 1:
                    axis_dir = [[], []]
                    for edge in port_lump.edges:
                        if terminal_references[1] in self._app.modeler.get_bodynames_from_position(edge.midpoint):
                            axis_dir[1] = edge.midpoint
                        elif terminal_references[0] in self._app.modeler.get_bodynames_from_position(edge.midpoint):
                            axis_dir[0] = edge.midpoint
                    terminal_references = terminal_references[1:]

            elif "port_{}".format(self.name) in item:
                port = self.object_list[item]
                for item_cap in list(self.object_list.keys()):
                    if "port_cap_{}".format(self.name) in item_cap:
                        port_cap = self.object_list[item_cap]

            if port_lump:
                port1 = self._app.lumped_port(
                    assignment=item,
                    reference=terminal_references,
                    impedance=50,
                    name="port_" + self.name + "_" + str(port_count),
                    renormalize=True,
                    deembed=False,
                )

                self.excitations[port1.name] = port1
                port_count += 1
            elif port:
                if self._app.solution_type == "Terminal" and port_cap:
                    terminal_references = port_cap.name
                port1 = self._app.wave_port(
                    assignment=port,
                    reference=terminal_references,
                    name="port_" + self.name + "_" + str(port_count),
                )
                self.excitations[port1.name] = port1
                port_count += 1

        return True



[docs]
class TransmissionLine(object):
    """Provides base methods common to transmission line calculations.

    Parameters
    ----------
    frequency : float, optional
        Center frequency. The default is ``10.0``.
    frequency_unit : str, optional
        Frequency units. The default is ``"GHz"``.

    Returns
    -------
    :class:`aedt.toolkits.antenna.common.TransmissionLine`
        Transmission line calculator object.

    Examples
    --------
    >>> from ansys.aedt.toolkits.antenna.backend.antenna_models.common import TransmissionLine
    >>> tl_calc = TransmissionLine(frequency=2)
    >>> tl_calc.stripline_calculator(substrate_height=10, permittivity=2.2, impedance=60)
    """

    def __init__(self, frequency=10, frequency_unit="GHz"):
        self.frequency = frequency
        self.frequency_unit = frequency_unit


[docs]
    @pyaedt_function_handler()
    def microstrip_calculator(self, substrate_height, permittivity, impedance=50.0, electrical_length=150.0):
        """Use the micro strip line calculator to calculate line width and length.

        Parameters
        ----------
        substrate_height : float
            Substrate height.
        permittivity : float
            Substrate permittivity.
        impedance : str, optional
            Impedance. The default is ``50.0``.
        electrical_length : str, optional
            Electrical length in degrees. The default is ``150.0``.

        Returns
        -------
        tuple
            Line width and length.
        """

        z0 = impedance
        e0 = permittivity
        h0 = substrate_height

        A_us = z0 / 60.0 * math.sqrt((e0 + 1.0) / 2.0) + (e0 - 1.0) / (e0 + 1.0) * (0.23 + 0.11 / e0)
        B_us = 377.0 * math.pi / (2.0 * z0 * math.sqrt(e0))

        w_over_subH_1 = 8.0 * math.exp(A_us) / (math.exp(2.0 * A_us) - 2.0)
        w_over_subH_2 = (
            2.0
            / math.pi
            * (
                B_us
                - 1.0
                - math.log(2.0 * B_us - 1.0)
                + (e0 - 1.0) / (2.0 * e0) * (math.log(B_us - 1.0) + 0.39 - 0.61 / e0)
            )
        )

        ustrip_width = w_over_subH_1 * h0
        if w_over_subH_1 < 2.0:
            ustrip_width = w_over_subH_1 * h0

        if w_over_subH_2 >= 2:
            ustrip_width = w_over_subH_2 * h0

        er_eff = (e0 + 1.0) / 2.0 + (e0 - 1.0) / 2.0 * 1.0 / (math.sqrt(1.0 + 12.0 * h0 / ustrip_width))
        f = constants.unit_converter(self.frequency, "Freq", self.frequency_unit, "Hz")

        k0 = 2.0 * math.pi * f / 3.0e8

        ustrip_length = math.radians(electrical_length) / (math.sqrt(er_eff) * k0)

        return ustrip_width, ustrip_length



[docs]
    @pyaedt_function_handler()
    def stripline_calculator(self, substrate_height, permittivity, impedance=50.0):
        """Use the strip line calculator to calculate line width.

        Parameters
        ----------
        substrate_height : float
            Substrate height.
        permittivity : float
            Substrate permittivity.
        impedance : str, optional
            Impedance. The default is ``50.0``.

        Returns
        -------
        float
            Line width.
        """

        x = 30.0 * math.pi / (math.sqrt(permittivity) * impedance) - 0.441

        if math.sqrt(permittivity) * impedance <= 120:
            w_over_h = x
        else:
            w_over_h = 0.85 - math.sqrt(0.6 - x)

        width = w_over_h * substrate_height
        return width



[docs]
    @pyaedt_function_handler()
    def suspended_strip_calculator(self, wavelength, w1, substrate_height, permittivity):
        """Use the suspended strip line calculator to calculate effective permittivity.

        Parameters
        ----------
        wavelength : float
        w1 : float
        substrate_height : float
            Substrate in meter.
        permittivity : float
            Dielectric permittivity

        Returns
        -------
        float
            Effective permittivity.
        """
        Hfrac = 16.0  # H_as_fraction_of_wavelength 1/H
        H = (wavelength / math.sqrt(permittivity) + substrate_height * Hfrac) / Hfrac
        heigth_ratio = substrate_height / (H - substrate_height)
        a = math.pow(0.8621 - 0.125 * math.log(heigth_ratio), 4.0)
        b = math.pow(0.4986 - 0.1397 * math.log(heigth_ratio), 4.0)

        Width_to_height_ratio = w1 / (H - substrate_height)
        sqrt_er_eff = math.pow(
            1.0 + heigth_ratio * (a - b * math.log(Width_to_height_ratio)) * (1.0 / math.sqrt(permittivity) - 1.0),
            -1.0,
        )
        effective_permittivity = math.pow(sqrt_er_eff, 2.0)

        if (permittivity >= 6.0) and (permittivity <= 10.0):
            effective_permittivity = effective_permittivity * 1.15  # about 15% larger than calculated
        if permittivity > 10:
            effective_permittivity = effective_permittivity * 1.25  # about 25% lager then calculated

        if effective_permittivity >= (permittivity + 1.0) / 2.0:
            effective_permittivity = (permittivity + 1.0) / 2.0

        return effective_permittivity





[docs]
class StandardWaveguide(object):
    """Provides base methods common to standard waveguides.

    Parameters
    ----------
    frequency : float, optional
        Center frequency. The default is ``10.0``.
    frequency_unit : str, optional
        Frequency units. The default is ``"GHz"``.

    Returns
    -------
    :class:`aedt.toolkits.antenna.common.StandardWaveguide`
        Standard waveguide object.

    Examples
    --------
    >>> from ansys.aedt.toolkits.antenna.common import StandardWaveguide
    >>> wg_calc = StandardWaveguide()
    >>> wg_dim = wg_calc.get_waveguide_dimensions("WR-75")
    """

    wg = {}
    wg["WR-2300"] = [23.0, 11.5, 0.15]
    wg["WR-2100"] = [21.0, 10.5, 0.125]
    wg["WR-1800"] = [18.0, 9.0, 0.125]
    wg["WR-1500"] = [15.0, 7.5, 0.125]
    wg["WR-1150"] = [11.5, 5.75, 0.125]
    wg["WR-975"] = [9.75, 4.875, 0.125]
    wg["WR-770"] = [7.7, 3.850, 0.125]
    wg["WR-650"] = [6.5, 3.25, 0.08]
    wg["WR-510"] = [5.1, 2.55, 0.08]
    wg["WR-430"] = [4.3, 2.15, 0.08]
    wg["WR-340"] = [3.4, 1.7, 0.08]
    wg["WR-284"] = [2.84, 1.34, 0.08]
    wg["WR-229"] = [2.29, 1.145, 0.064]
    wg["WR-187"] = [1.872, 0.872, 0.064]
    wg["WR-159"] = [1.53, 0.795, 0.064]
    wg["WR-137"] = [1.372, 0.622, 0.064]
    wg["WR-112"] = [1.122, 0.497, 0.064]
    wg["WR-102"] = [1.02, 0.51, 0.064]
    wg["WR-90"] = [0.9, 0.4, 0.05]
    wg["WR-75"] = [0.75, 0.375, 0.05]
    wg["WR-62"] = [0.622, 0.311, 0.04]
    wg["WR-51"] = [0.51, 0.255, 0.04]
    wg["WR-42"] = [0.42, 0.17, 0.04]
    wg["WR-34"] = [0.34, 0.17, 0.04]
    wg["WR-28"] = [0.28, 0.14, 0.04]
    wg["WR-22"] = [0.224, 0.112, 0.04]
    wg["WR-19"] = [0.188, 0.094, 0.04]
    wg["WR-15"] = [0.148, 0.074, 0.04]
    wg["WR-12"] = [0.122, 0.061, 0.04]
    wg["WR-10"] = [0.1, 0.05, 0.04]
    wg["WR-8"] = [0.08, 0.04, 0.02]
    wg["WR-7"] = [0.065, 0.0325, 0.02]
    wg["WR-5"] = [0.0510, 0.0255, 0.02]

    def __init__(self, frequency=10, frequency_unit="GHz"):
        self.frequency = frequency
        self.frequency_unit = frequency_unit

    @property
    def waveguide_list(self):
        """Standard waveguide list."""
        return self.wg.keys()


[docs]
    @pyaedt_function_handler()
    def get_waveguide_dimensions(self, name, units="mm"):
        """Get waveguide dimensions.

        Parameters
        ----------
        name : str
            Waveguide name.
        units : str
           Dimension units. The default is ``mm``.

        Returns
        -------
        list
            Waveguide dimensions.
        """

        if name in self.wg:
            wg_dim = []
            for dbl in self.wg[name]:
                wg_dim.append(constants.unit_converter(dbl, "Length", "in", units))
            return wg_dim
        else:
            return False



[docs]
    @pyaedt_function_handler()
    def find_waveguide(self, freq, units="GHz"):  # pragma: no cover
        """Find the closest standard waveguide for the operational frequency.

        Parameters
        ----------
        freq : float
            Operational frequency.
        units : str
           Input frequency units. The default is ``"GHz"``.

        Returns
        -------
        str
            Waveguide name.
        """

        freq = constants.unit_converter(freq, "Frequency", units, "GHz")
        op_freq = freq * 0.8

        if op_freq >= 140:
            wg_name = "WR-5"
        elif op_freq >= 110:
            wg_name = "WR-7"
        elif op_freq >= 90:
            wg_name = "WR-8"
        elif op_freq >= 75:
            wg_name = "WR-10"
        elif op_freq >= 60:
            wg_name = "WR-12"
        elif op_freq >= 50:
            wg_name = "WR-15"
        elif op_freq >= 40:
            wg_name = "WR-19"
        elif op_freq >= 33:
            wg_name = "WR-22"
        elif op_freq >= 26.50:
            wg_name = "WR-28"
        elif op_freq >= 22:
            wg_name = "WR-34"
        elif op_freq >= 18:
            wg_name = "WR-42"
        elif op_freq >= 15:
            wg_name = "WR-51"
        elif op_freq >= 12.4:
            wg_name = "WR-62"
        elif op_freq >= 10:
            wg_name = "WR-75"
        elif op_freq >= 8.2:
            wg_name = "WR-90"
        elif op_freq >= 6.95:
            wg_name = "WR-102"
        elif op_freq >= 7.05:
            wg_name = "WR-112"
        elif op_freq >= 5.85:
            wg_name = "WR-137"
        elif op_freq >= 4.9:
            wg_name = "WR-159"
        elif op_freq >= 3.95:
            wg_name = "WR-187"
        elif op_freq >= 3.3:
            wg_name = "WR-229"
        elif op_freq >= 2.6:
            wg_name = "WR-284"
        elif op_freq >= 2.2:
            wg_name = "WR-340"
        elif op_freq >= 1.70:
            wg_name = "WR-430"
        elif op_freq >= 1.45:
            wg_name = "WR-510"
        elif op_freq >= 1.12:
            wg_name = "WR-650"
        elif op_freq >= 0.96:
            wg_name = "WR-770"
        elif op_freq >= 0.75:
            wg_name = "WR-975"
        elif op_freq >= 0.64:
            wg_name = "WR-1150"
        elif op_freq >= 0.49:
            wg_name = "WR-1500"
        elif op_freq >= 0.41:
            wg_name = "WR-1800"
        elif op_freq >= 0.35:
            wg_name = "WR-2100"
        elif op_freq > 0:
            wg_name = "WR-2300"
        else:
            wg_name = None
        return wg_name