pyedb 0.13.dev0__py3-none-any.whl → 0.14.0__py3-none-any.whl

pyedb/dotnet/edb_core/{edb_data/hfss_simulation_setup_data.py → sim_setup_data/data/settings.py}

@@ -20,508 +20,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.clr_module import Tuple
-from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
-from pyedb.dotnet.edb_core.utilities.simulation_setup import (
-    BaseSimulationSetup,
-    EdbFrequencySweep,
+from pyedb.dotnet.edb_core.sim_setup_data.data.adaptive_frequency_data import (
+    AdaptiveFrequencyData,
 )
-from pyedb.generic.general_methods import generate_unique_name, pyedb_function_handler
-
-
-class AdaptiveType(object):
-    (SingleFrequency, MultiFrequency, BroadBand) = range(0, 3)
-
-
-class MeshOperation(object):
-    """Mesh Operation Class."""
-
-    def __init__(self, parent, mesh_operation):
-        self._parent = parent
-        self.mesh_operation = mesh_operation
-        self._mesh_op_mapping = {
-            "kMeshSetupBase": mesh_operation.TMeshOpType.kMeshSetupBase,
-            "kMeshSetupLength": mesh_operation.TMeshOpType.kMeshSetupLength,
-            "kMeshSetupSkinDepth": mesh_operation.TMeshOpType.kMeshSetupSkinDepth,
-            "kNumMeshOpTypes": mesh_operation.TMeshOpType.kNumMeshOpTypes,
-        }
-
-    @property
-    def enabled(self):
-        """Whether if mesh operation is enabled.
-
-        Returns
-        -------
-        bool
-            ``True`` if mesh operation is used, ``False`` otherwise.
-        """
-        return self.mesh_operation.Enabled
-
-    @property
-    def mesh_operation_type(self):
-        """Mesh operation type.
-        Options:
-        0- ``kMeshSetupBase``
-        1- ``kMeshSetupLength``
-        2- ``kMeshSetupSkinDepth``
-        3- ``kNumMeshOpTypes``.
-
-        Returns
-        -------
-        int
-        """
-        return self.mesh_operation.MeshOpType.ToString()
-
-    @property
-    def mesh_region(self):
-        """Mesh region name.
-
-        Returns
-        -------
-        str
-            Name of the mesh region.
-        """
-        return self.mesh_operation.MeshRegion
-
-    @property
-    def name(self):
-        """Mesh operation name.
-
-        Returns
-        -------
-        str
-        """
-        return self.mesh_operation.Name
-
-    @property
-    def nets_layers_list(self):
-        """List of nets and layers.
-
-        Returns
-        -------
-        list
-           List of lists with three elements. Each list must contain:
-           1- net name
-           2- layer name
-           3- bool.
-           Third element is represents whether if the mesh operation is enabled or disabled.
-
-        """
-        return self.mesh_operation.NetsLayersList
-
-    @nets_layers_list.setter
-    def nets_layers_list(self, values):
-        temp = []
-        for net, layers in values.items():
-            for layer in layers:
-                temp.append(Tuple[str, str, bool](net, layer, True))
-        self.mesh_operation.NetsLayersList = convert_py_list_to_net_list(temp)
-
-    @property
-    def refine_inside(self):
-        """Whether to turn on refine inside objects.
-
-        Returns
-        -------
-        bool
-            ``True`` if refine inside objects is used, ``False`` otherwise.
-
-        """
-        return self.mesh_operation.RefineInside
-
-    @enabled.setter
-    def enabled(self, value):
-        self.mesh_operation.Enabled = value
-        self._parent._update_setup()
-
-    @mesh_region.setter
-    def mesh_region(self, value):
-        self.mesh_operation.MeshRegion = value
-        self._parent._update_setup()
-
-    @name.setter
-    def name(self, value):
-        self.mesh_operation.Name = value
-        self._parent._update_setup()
-
-    @refine_inside.setter
-    def refine_inside(self, value):
-        self.mesh_operation.RefineInside = value
-        self._parent._update_setup()
-
-    @property
-    def max_elements(self):
-        """Maximum number of elements.
-
-        Returns
-        -------
-        str
-        """
-        return self.mesh_operation.MaxElems
-
-    @property
-    def restrict_max_elements(self):
-        """Whether to restrict maximum number  of elements.
-
-        Returns
-        -------
-        bool
-        """
-        return self.mesh_operation.RestrictMaxElem
-
-    @max_elements.setter
-    def max_elements(self, value):
-        self.mesh_operation.MaxElems = str(value)
-        self._parent._update_setup()
-
-    @restrict_max_elements.setter
-    def restrict_max_elements(self, value):
-        """Whether to restrict maximum number  of elements.
-
-        Returns
-        -------
-        bool
-        """
-        self.mesh_operation.RestrictMaxElem = value
-        self._parent._update_setup()
-
-
-class MeshOperationLength(MeshOperation, object):
-    """Mesh operation Length class.
-    This class is accessible from Hfss Setup in EDB and add_length_mesh_operation method.
-
-    Examples
-    --------
-    >>> mop = edbapp.setups["setup1a"].add_length_mesh_operation({"GND": ["TOP", "BOTTOM"]})
-    >>> mop.max_elements = 3000
-    """
-
-    def __init__(self, parent, mesh_operation):
-        MeshOperation.__init__(self, parent, mesh_operation)
-
-    @property
-    def max_length(self):
-        """Maximum length of elements.
-
-        Returns
-        -------
-        str
-        """
-        return self.mesh_operation.MaxLength
-
-    @property
-    def restrict_length(self):
-        """Whether to restrict length of elements.
-
-        Returns
-        -------
-        bool
-        """
-        return self.mesh_operation.RestrictLength
-
-    @max_length.setter
-    def max_length(self, value):
-        self.mesh_operation.MaxLength = value
-        self._parent._update_setup()
-
-    @restrict_length.setter
-    def restrict_length(self, value):
-        """Whether to restrict length of elements.
-
-        Returns
-        -------
-        bool
-        """
-        self.mesh_operation.RestrictLength = value
-        self._parent._update_setup()
-
-
-class MeshOperationSkinDepth(MeshOperation, object):
-    """Mesh operation Skin Depth class.
-    This class is accessible from Hfss Setup in EDB and assign_skin_depth_mesh_operation method.
-
-    Examples
-    --------
-    >>> mop = edbapp.setups["setup1a"].add_skin_depth_mesh_operation({"GND": ["TOP", "BOTTOM"]})
-    >>> mop.max_elements = 3000
-    """
-
-    def __init__(self, parent, mesh_operation):
-        MeshOperation.__init__(self, parent, mesh_operation)
-
-    @property
-    def skin_depth(self):
-        """Skin depth value.
-
-        Returns
-        -------
-        str
-        """
-        return self.mesh_operation.SkinDepth
-
-    @skin_depth.setter
-    def skin_depth(self, value):
-        self.mesh_operation.SkinDepth = value
-        self._parent._update_setup()
-
-    @property
-    def surface_triangle_length(self):
-        """Surface triangle length value.
-
-        Returns
-        -------
-        str
-        """
-        return self.mesh_operation.SurfTriLength
-
-    @surface_triangle_length.setter
-    def surface_triangle_length(self, value):
-        self.mesh_operation.SurfTriLength = value
-        self._parent._update_setup()
-
-    @property
-    def number_of_layer_elements(self):
-        """Number of layer elements.
-
-        Returns
-        -------
-        str
-        """
-        return self.mesh_operation.NumLayers
-
-    @number_of_layer_elements.setter
-    def number_of_layer_elements(self, value):
-        self.mesh_operation.NumLayers = str(value)
-        self._parent._update_setup()
-
-
-class HfssPortSettings(object):
-    """Manages EDB methods for HFSS port settings."""
-
-    def __init__(self, parent):
-        self._parent = parent
-
-    @property
-    def _hfss_port_settings(self):
-        return self._parent.get_sim_setup_info.SimulationSettings.HFSSPortSettings
-
-    @property
-    def max_delta_z0(self):
-        """Maximum change to Z0 in successive passes.
-
-        Returns
-        -------
-        float
-        """
-        return self._hfss_port_settings.MaxDeltaZ0
-
-    @max_delta_z0.setter
-    def max_delta_z0(self, value):
-        self._hfss_port_settings.MaxDeltaZ0 = value
-        self._parent._update_setup()
-
-    @property
-    def max_triangles_wave_port(self):
-        """Maximum number of triangles allowed for wave ports.
-
-        Returns
-        -------
-        int
-        """
-        return self._hfss_port_settings.MaxTrianglesWavePort
-
-    @max_triangles_wave_port.setter
-    def max_triangles_wave_port(self, value):
-        self._hfss_port_settings.MaxTrianglesWavePort = value
-        self._parent._update_setup()
-
-    @property
-    def min_triangles_wave_port(self):
-        """Minimum number of triangles allowed for wave ports.
-
-        Returns
-        -------
-        int
-        """
-        return self._hfss_port_settings.MinTrianglesWavePort
-
-    @min_triangles_wave_port.setter
-    def min_triangles_wave_port(self, value):
-        self._hfss_port_settings.MinTrianglesWavePort = value
-        self._parent._update_setup()
-
-    @property
-    def enable_set_triangles_wave_port(self):
-        """Whether to enable setting of minimum and maximum mesh limits for wave ports.
-
-        Returns
-        -------
-        bool
-            ``True`` if triangles wave port  is used, ``False`` otherwise.
-        """
-        return self._hfss_port_settings.SetTrianglesWavePort
-
-    @enable_set_triangles_wave_port.setter
-    def enable_set_triangles_wave_port(self, value):
-        self._hfss_port_settings.SetTrianglesWavePort = value
-        self._parent._update_setup()
-
-
-class HfssSolverSettings(object):
-    """Manages EDB methods for HFSS solver settings."""
-
-    def __init__(self, sim_setup):
-        self._parent = sim_setup
-
-    @property
-    def _hfss_solver_settings(self):
-        return self._parent.get_sim_setup_info.SimulationSettings.HFSSSolverSettings
-
-    @property
-    def enhanced_low_freq_accuracy(self):
-        """Whether to enable legacy low-frequency sampling.
-
-        Returns
-        -------
-        bool
-            ``True`` if low frequency accuracy is used, ``False`` otherwise.
-        """
-        return self._hfss_solver_settings.EnhancedLowFreqAccuracy
-
-    @enhanced_low_freq_accuracy.setter
-    def enhanced_low_freq_accuracy(self, value):
-        self._hfss_solver_settings.EnhancedLowFreqAccuracy = value
-        self._parent._update_setup()
-
-    @property
-    def order_basis(self):
-        """Order of the basic functions for HFSS.
-        - 0=Zero.
-        - 1=1st order.
-        - 2=2nd order.
-        - 3=Mixed.
-
-        Returns
-        -------
-        int
-            Integer value according to the description."""
-        mapping = {0: "zero", 1: "first", 2: "second", 3: "mixed"}
-        return mapping[self._hfss_solver_settings.OrderBasis]
-
-    @order_basis.setter
-    def order_basis(self, value):
-        mapping = {"zero": 0, "first": 1, "second": 2, "mixed": 3}
-        self._hfss_solver_settings.OrderBasis = mapping[value]
-        self._parent._update_setup()
-
-    @property
-    def relative_residual(self):
-        """Residual for use by the iterative solver.
-
-        Returns
-        -------
-        float
-        """
-        return self._hfss_solver_settings.RelativeResidual
-
-    @relative_residual.setter
-    def relative_residual(self, value):
-        self._hfss_solver_settings.RelativeResidual = value
-        self._parent._update_setup()
-
-    @property
-    def solver_type(self):
-        """Get solver type to use (Direct/Iterative/Auto) for HFSS.
-        Options:
-        1- ``kAutoSolver``.
-        2- ``kDirectSolver``.
-        3- ``kIterativeSolver``.
-        4- ``kNumSolverTypes``.
-
-        Returns
-        -------
-        str
-        """
-        mapping = {"kAutoSolver": "auto", "kDirectSolver": "direct", "kIterativeSolver": "iterative"}
-        solver_type = self._hfss_solver_settings.SolverType.ToString()
-        return mapping[solver_type]
-
-    @solver_type.setter
-    def solver_type(self, value):
-        mapping = {
-            "auto": self._hfss_solver_settings.SolverType.kAutoSolver,
-            "direct": self._hfss_solver_settings.SolverType.kDirectSolver,
-            "iterative": self._hfss_solver_settings.SolverType.kIterativeSolver,
-        }
-        self._hfss_solver_settings.SolverType = mapping[value]
-        self._parent._update_setup()
-
-    @property
-    def use_shell_elements(self):
-        """Whether to enable use of shell elements.
-
-        Returns
-        -------
-        bool
-            ``True`` if shall elements are used, ``False`` otherwise.
-        """
-        return self._hfss_solver_settings.UseShellElements
-
-    @use_shell_elements.setter
-    def use_shell_elements(self, value):
-        self._hfss_solver_settings.UseShellElements = value
-        self._parent._update_setup()
-
-
-class AdaptiveFrequencyData(object):
-    """Manages EDB methods for adaptive frequency data."""
-
-    def __init__(self, adaptive_frequency_data):
-        self._adaptive_frequency_data = adaptive_frequency_data
-
-    @property
-    def adaptive_frequency(self):
-        """Adaptive frequency for the setup.
-
-        Returns
-        -------
-        str
-            Frequency with units.
-        """
-        return self._adaptive_frequency_data.AdaptiveFrequency
-
-    @adaptive_frequency.setter
-    def adaptive_frequency(self, value):
-        self._adaptive_frequency_data.AdaptiveFrequency = value
-
-    @property
-    def max_delta(self):
-        """Maximum change of S-parameters between two consecutive passes, which serves as
-        a stopping criterion.
-
-        Returns
-        -------
-        str
-        """
-        return self._adaptive_frequency_data.MaxDelta
-
-    @max_delta.setter
-    def max_delta(self, value):
-        self._adaptive_frequency_data.MaxDelta = str(value)
-
-    @property
-    def max_passes(self):
-        """Maximum allowed number of mesh refinement cycles.
-
-        Returns
-        -------
-        int
-        """
-        return self._adaptive_frequency_data.MaxPasses
-
-    @max_passes.setter
-    def max_passes(self, value):
-        self._adaptive_frequency_data.MaxPasses = value
 
 
 class AdaptiveSettings(object):
@@ -714,7 +215,6 @@ class AdaptiveSettings(object):
         self.adaptive_settings.UseMaxRefinement = value
         self._parent._update_setup()
 
-    @pyedb_function_handler()
     def add_adaptive_frequency_data(self, frequency=0, max_num_passes=10, max_delta_s=0.02):
         """Add a setup for frequency data.
 
@@ -740,7 +240,6 @@ class AdaptiveSettings(object):
         self.adaptive_settings.AdaptiveFrequencyDataList.Add(low_freq_adapt_data)
         return self._parent._update_setup()
 
-    @pyedb_function_handler()
     def add_broadband_adaptive_frequency_data(
         self, low_frequency=0, high_frequency=10e9, max_num_passes=10, max_delta_s=0.02
     ):
@@ -928,9 +427,68 @@ class DefeatureSettings(object):
         """
         return self._defeature_settings.UseDefeatureAbsLength
 
-    @use_defeature_abs_length.setter
-    def use_defeature_abs_length(self, value):
-        self._defeature_settings.UseDefeatureAbsLength = value
+    @use_defeature_abs_length.setter
+    def use_defeature_abs_length(self, value):
+        self._defeature_settings.UseDefeatureAbsLength = value
+        self._parent._update_setup()
+
+
+class AdvancedMeshSettings(object):
+    """Manages EDB methods for advanced mesh settings."""
+
+    def __init__(self, parent):
+        self._parent = parent
+
+    @property
+    def _advanced_mesh_settings(self):
+        return self._parent.get_sim_setup_info.SimulationSettings.AdvancedMeshSettings
+
+    @property
+    def layer_snap_tol(self):
+        """Layer snap tolerance. Attempt to align independent stackups in the mesher.
+
+        Returns
+        -------
+        str
+
+        """
+        return self._advanced_mesh_settings.LayerSnapTol
+
+    @layer_snap_tol.setter
+    def layer_snap_tol(self, value):
+        self._advanced_mesh_settings.LayerSnapTol = value
+        self._parent._update_setup()
+
+    @property
+    def mesh_display_attributes(self):
+        """Mesh display attributes. Set color for mesh display (i.e. ``"#000000"``).
+
+        Returns
+        -------
+        str
+        """
+        return self._advanced_mesh_settings.MeshDisplayAttributes
+
+    @mesh_display_attributes.setter
+    def mesh_display_attributes(self, value):
+        self._advanced_mesh_settings.MeshDisplayAttributes = value
+        self._parent._update_setup()
+
+    @property
+    def replace_3d_triangles(self):
+        """Whether to turn on replace 3D triangles.
+
+        Returns
+        -------
+        bool
+            ``True`` if replace 3D triangles is used, ``False`` otherwise.
+
+        """
+        return self._advanced_mesh_settings.Replace3DTriangles
+
+    @replace_3d_triangles.setter
+    def replace_3d_triangles(self, value):
+        self._advanced_mesh_settings.Replace3DTriangles = value
         self._parent._update_setup()
 
 
@@ -1042,65 +600,6 @@ class ViaSettings(object):
         self._parent._update_setup()
 
 
-class AdvancedMeshSettings(object):
-    """Manages EDB methods for advanced mesh settings."""
-
-    def __init__(self, parent):
-        self._parent = parent
-
-    @property
-    def _advanced_mesh_settings(self):
-        return self._parent.get_sim_setup_info.SimulationSettings.AdvancedMeshSettings
-
-    @property
-    def layer_snap_tol(self):
-        """Layer snap tolerance. Attempt to align independent stackups in the mesher.
-
-        Returns
-        -------
-        str
-
-        """
-        return self._advanced_mesh_settings.LayerSnapTol
-
-    @layer_snap_tol.setter
-    def layer_snap_tol(self, value):
-        self._advanced_mesh_settings.LayerSnapTol = value
-        self._parent._update_setup()
-
-    @property
-    def mesh_display_attributes(self):
-        """Mesh display attributes. Set color for mesh display (i.e. ``"#000000"``).
-
-        Returns
-        -------
-        str
-        """
-        return self._advanced_mesh_settings.MeshDisplayAttributes
-
-    @mesh_display_attributes.setter
-    def mesh_display_attributes(self, value):
-        self._advanced_mesh_settings.MeshDisplayAttributes = value
-        self._parent._update_setup()
-
-    @property
-    def replace_3d_triangles(self):
-        """Whether to turn on replace 3D triangles.
-
-        Returns
-        -------
-        bool
-            ``True`` if replace 3D triangles is used, ``False`` otherwise.
-
-        """
-        return self._advanced_mesh_settings.Replace3DTriangles
-
-    @replace_3d_triangles.setter
-    def replace_3d_triangles(self, value):
-        self._advanced_mesh_settings.Replace3DTriangles = value
-        self._parent._update_setup()
-
-
 class CurveApproxSettings(object):
     """Manages EDB methods for curve approximate settings."""
 
@@ -1273,382 +772,179 @@ class DcrSettings(object):
         self._parent._update_setup()
 
 
-class HfssSimulationSetup(BaseSimulationSetup):
-    """Manages EDB methods for HFSS simulation setup."""
-
-    def __init__(self, pedb, edb_object=None):
-        super().__init__(pedb, edb_object)
-        self._setup_type = "kHFSS"
-        self._mesh_operations = {}
+class HfssPortSettings(object):
+    """Manages EDB methods for HFSS port settings."""
 
-    @pyedb_function_handler
-    def create(self, name=None):
-        """Create an HFSS setup."""
-        self._name = name
-        self._create(name)
-        return self
+    def __init__(self, parent):
+        self._parent = parent
 
     @property
-    def get_sim_setup_info(self):
-        """Get simulation setup information."""
-        return self._edb_object.GetSimSetupInfo()
+    def _hfss_port_settings(self):
+        return self._parent.get_sim_setup_info.SimulationSettings.HFSSPortSettings
 
     @property
-    def solver_slider_type(self):
-        """Solver slider type.
-        Options are:
-        1 - ``kFast``.
-        2 - ``kMedium``.
-        3 - ``kAccurate``.
-        4 - ``kNumSliderTypes``.
+    def max_delta_z0(self):
+        """Maximum change to Z0 in successive passes.
 
         Returns
         -------
-        str
+        float
         """
-        return self.get_sim_setup_info.SimulationSettings.TSolveSliderType.ToString()
-
-    @solver_slider_type.setter
-    def solver_slider_type(self, value):
-        """Set solver slider type."""
-        solver_types = {
-            "kFast": self.get_sim_setup_info.SimulationSettings.TSolveSliderType.k25DViaWirebond,
-            "kMedium": self.get_sim_setup_info.SimulationSettings.TSolveSliderType.k25DViaRibbon,
-            "kAccurate": self.get_sim_setup_info.SimulationSettings.TSolveSliderType.k25DViaMesh,
-            "kNumSliderTypes": self.get_sim_setup_info.SimulationSettings.TSolveSliderType.k25DViaField,
-        }
-        self.get_sim_setup_info.SimulationSettings.TSolveSliderType = solver_types[value]
-        self._update_setup()
-
-    @property
-    def is_auto_setup(self):
-        """Flag indicating if automatic setup is enabled."""
-        return self.get_sim_setup_info.SimulationSettings.IsAutoSetup
+        return self._hfss_port_settings.MaxDeltaZ0
 
-    @is_auto_setup.setter
-    def is_auto_setup(self, value):
-        self.get_sim_setup_info.SimulationSettings.IsAutoSetup = value
-        self._update_setup()
+    @max_delta_z0.setter
+    def max_delta_z0(self, value):
+        self._hfss_port_settings.MaxDeltaZ0 = value
+        self._parent._update_setup()
 
     @property
-    def hfss_solver_settings(self):
-        """Manages EDB methods for HFSS solver settings.
+    def max_triangles_wave_port(self):
+        """Maximum number of triangles allowed for wave ports.
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.HfssSolverSettings`
-
+        int
         """
-        return HfssSolverSettings(self)
-
-    @property
-    def adaptive_settings(self):
-        """Adaptive Settings Class.
-
-        Returns
-        -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.AdaptiveSettings`
+        return self._hfss_port_settings.MaxTrianglesWavePort
 
-        """
-        return AdaptiveSettings(self)
+    @max_triangles_wave_port.setter
+    def max_triangles_wave_port(self, value):
+        self._hfss_port_settings.MaxTrianglesWavePort = value
+        self._parent._update_setup()
 
     @property
-    def defeature_settings(self):
-        """Defeature settings Class.
+    def min_triangles_wave_port(self):
+        """Minimum number of triangles allowed for wave ports.
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.DefeatureSettings`
-
+        int
         """
-        return DefeatureSettings(self)
-
-    @property
-    def via_settings(self):
-        """Via settings Class.
-
-        Returns
-        -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.ViaSettings`
+        return self._hfss_port_settings.MinTrianglesWavePort
 
-        """
-        return ViaSettings(self)
+    @min_triangles_wave_port.setter
+    def min_triangles_wave_port(self, value):
+        self._hfss_port_settings.MinTrianglesWavePort = value
+        self._parent._update_setup()
 
     @property
-    def advanced_mesh_settings(self):
-        """Advanced mesh settings Class.
+    def enable_set_triangles_wave_port(self):
+        """Whether to enable setting of minimum and maximum mesh limits for wave ports.
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.AdvancedMeshSettings`
-
+        bool
+            ``True`` if triangles wave port  is used, ``False`` otherwise.
         """
-        return AdvancedMeshSettings(self)
-
-    @property
-    def curve_approx_settings(self):
-        """Curve approximation settings Class.
-
-        Returns
-        -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.CurveApproxSettings`
+        return self._hfss_port_settings.SetTrianglesWavePort
 
-        """
-        return CurveApproxSettings(self)
+    @enable_set_triangles_wave_port.setter
+    def enable_set_triangles_wave_port(self, value):
+        self._hfss_port_settings.SetTrianglesWavePort = value
+        self._parent._update_setup()
 
-    @property
-    def dcr_settings(self):
-        """Dcr settings Class.
 
-        Returns
-        -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.DcrSettings`
+class HfssSolverSettings(object):
+    """Manages EDB methods for HFSS solver settings."""
 
-        """
-        return DcrSettings(self)
+    def __init__(self, sim_setup):
+        self._parent = sim_setup
 
     @property
-    def hfss_port_settings(self):
-        """HFSS port settings Class.
-
-        Returns
-        -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.HfssPortSettings`
-
-        """
-        return HfssPortSettings(self)
+    def _hfss_solver_settings(self):
+        return self._parent.get_sim_setup_info.SimulationSettings.HFSSSolverSettings
 
     @property
-    def mesh_operations(self):
-        """Mesh operations settings Class.
+    def enhanced_low_freq_accuracy(self):
+        """Whether to enable legacy low-frequency sampling.
 
         Returns
         -------
-        List of :class:`dotnet.edb_core.edb_data.hfss_simulation_setup_data.MeshOperation`
-
+        bool
+            ``True`` if low frequency accuracy is used, ``False`` otherwise.
         """
-        if self._mesh_operations:
-            return self._mesh_operations
-        settings = self.get_sim_setup_info.SimulationSettings.MeshOperations
-        self._mesh_operations = {}
-        for i in list(settings):
-            if i.MeshOpType == i.TMeshOpType.kMeshSetupLength:
-                self._mesh_operations[i.Name] = MeshOperationLength(self, i)
-            elif i.MeshOpType == i.TMeshOpType.kMeshSetupSkinDepth:
-                self._mesh_operations[i.Name] = MeshOperationSkinDepth(self, i)
-            elif i.MeshOpType == i.TMeshOpType.kMeshSetupBase:
-                self._mesh_operations[i.Name] = MeshOperationSkinDepth(self, i)
-
-        return self._mesh_operations
-
-    @pyedb_function_handler()
-    def add_length_mesh_operation(
-        self,
-        net_layer_list,
-        name=None,
-        max_elements=1000,
-        max_length="1mm",
-        restrict_elements=True,
-        restrict_length=True,
-        refine_inside=False,
-        mesh_region=None,
-    ):
-        """Add a mesh operation to the setup.
-
-        Parameters
-        ----------
-        net_layer_list : dict
-            Dictionary containing nets and layers on which enable Mesh operation. Example ``{"A0_N": ["TOP", "PWR"]}``.
-        name : str, optional
-            Mesh operation name.
-        max_elements : int, optional
-            Maximum number of elements. Default is ``1000``.
-        max_length : str, optional
-            Maximum length of elements. Default is ``1mm``.
-        restrict_elements : bool, optional
-            Whether to restrict number of elements. Default is ``True``.
-        restrict_length : bool, optional
-            Whether to restrict length of elements. Default is ``True``.
-        mesh_region : str, optional
-            Mesh region name.
-        refine_inside : bool, optional
-            Whether to refine inside or not.  Default is ``False``.
+        return self._hfss_solver_settings.EnhancedLowFreqAccuracy
 
-        Returns
-        -------
-        :class:`dotnet.edb_core.edb_data.hfss_simulation_setup_data.LengthMeshOperation`
-        """
-        if not name:
-            name = generate_unique_name("skin")
-        mesh_operation = MeshOperationLength(self, self._pedb.simsetupdata.LengthMeshOperation())
-        mesh_operation.mesh_region = mesh_region
-        mesh_operation.name = name
-        mesh_operation.nets_layers_list = net_layer_list
-        mesh_operation.refine_inside = refine_inside
-        mesh_operation.max_elements = str(max_elements)
-        mesh_operation.max_length = max_length
-        mesh_operation.restrict_length = restrict_length
-        mesh_operation.restrict_max_elements = restrict_elements
-        self.mesh_operations[name] = mesh_operation
-        return mesh_operation if self._update_setup() else False
-
-    @pyedb_function_handler()
-    def add_skin_depth_mesh_operation(
-        self,
-        net_layer_list,
-        name=None,
-        max_elements=1000,
-        skin_depth="1um",
-        restrict_elements=True,
-        surface_triangle_length="1mm",
-        number_of_layers=2,
-        refine_inside=False,
-        mesh_region=None,
-    ):
-        """Add a mesh operation to the setup.
+    @enhanced_low_freq_accuracy.setter
+    def enhanced_low_freq_accuracy(self, value):
+        self._hfss_solver_settings.EnhancedLowFreqAccuracy = value
+        self._parent._update_setup()
 
-        Parameters
-        ----------
-        net_layer_list : dict
-            Dictionary containing nets and layers on which enable Mesh operation. Example ``{"A0_N": ["TOP", "PWR"]}``.
-        name : str, optional
-            Mesh operation name.
-        max_elements : int, optional
-            Maximum number of elements. Default is ``1000``.
-        skin_depth : str, optional
-            Skin Depth. Default is ``1um``.
-        restrict_elements : bool, optional
-            Whether to restrict number of elements. Default is ``True``.
-        surface_triangle_length : bool, optional
-            Surface Triangle length. Default is ``1mm``.
-        number_of_layers : int, str, optional
-            Number of layers. Default is ``2``.
-        mesh_region : str, optional
-            Mesh region name.
-        refine_inside : bool, optional
-            Whether to refine inside or not.  Default is ``False``.
+    @property
+    def order_basis(self):
+        """Order of the basic functions for HFSS.
+        - 0=Zero.
+        - 1=1st order.
+        - 2=2nd order.
+        - 3=Mixed.
 
         Returns
         -------
-        :class:`dotnet.edb_core.edb_data.hfss_simulation_setup_data.LengthMeshOperation`
-        """
-        if not name:
-            name = generate_unique_name("length")
-        mesh_operation = MeshOperationSkinDepth(self, self._pedb.simsetupdata.SkinDepthMeshOperation())
-        mesh_operation.mesh_region = mesh_region
-        mesh_operation.name = name
-        mesh_operation.nets_layers_list = net_layer_list
-        mesh_operation.refine_inside = refine_inside
-        mesh_operation.max_elements = max_elements
-        mesh_operation.skin_depth = skin_depth
-        mesh_operation.number_of_layer_elements = number_of_layers
-        mesh_operation.surface_triangle_length = surface_triangle_length
-        mesh_operation.restrict_max_elements = restrict_elements
-        self.mesh_operations[name] = mesh_operation
-        return mesh_operation if self._update_setup() else False
-
-    @pyedb_function_handler()
-    def add_frequency_sweep(self, name=None, frequency_sweep=None):
-        """Add frequency sweep.
+        int
+            Integer value according to the description."""
+        mapping = {0: "zero", 1: "first", 2: "second", 3: "mixed"}
+        return mapping[self._hfss_solver_settings.OrderBasis]
 
-        Parameters
-        ----------
-        name : str, optional
-            Name of the frequency sweep.
-        frequency_sweep : list, optional
-            List of frequency points.
+    @order_basis.setter
+    def order_basis(self, value):
+        mapping = {"zero": 0, "first": 1, "second": 2, "mixed": 3}
+        self._hfss_solver_settings.OrderBasis = mapping[value]
+        self._parent._update_setup()
+
+    @property
+    def relative_residual(self):
+        """Residual for use by the iterative solver.
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.EdbFrequencySweep`
-
-        Examples
-        --------
-        >>> setup1 = edbapp.create_hfss_setup("setup1")
-        >>> setup1.add_frequency_sweep(frequency_sweep=[
-        ...                           ["linear count", "0", "1kHz", 1],
-        ...                           ["log scale", "1kHz", "0.1GHz", 10],
-        ...                           ["linear scale", "0.1GHz", "10GHz", "0.1GHz"],
-        ...                           ])
+        float
         """
-        if name in self.frequency_sweeps:
-            return False
-        if not name:
-            name = generate_unique_name("sweep")
-        return EdbFrequencySweep(self, frequency_sweep, name)
+        return self._hfss_solver_settings.RelativeResidual
 
-    @pyedb_function_handler()
-    def set_solution_single_frequency(self, frequency="5GHz", max_num_passes=10, max_delta_s=0.02):
-        """Set single-frequency solution.
+    @relative_residual.setter
+    def relative_residual(self, value):
+        self._hfss_solver_settings.RelativeResidual = value
+        self._parent._update_setup()
 
-        Parameters
-        ----------
-        frequency : str, float, optional
-            Adaptive frequency. The default is ``5GHz``.
-        max_num_passes : int, optional
-            Maximum number of passes. The default is ``10``.
-        max_delta_s : float, optional
-            Maximum delta S. The default is ``0.02``.
+    @property
+    def solver_type(self):
+        """Get solver type to use (Direct/Iterative/Auto) for HFSS.
+        Options:
+        1- ``kAutoSolver``.
+        2- ``kDirectSolver``.
+        3- ``kIterativeSolver``.
+        4- ``kNumSolverTypes``.
 
         Returns
         -------
-        bool
-
+        str
         """
-        self.adaptive_settings.adapt_type = "kSingle"
-        self.adaptive_settings.adaptive_settings.AdaptiveFrequencyDataList.Clear()
-        return self.adaptive_settings.add_adaptive_frequency_data(frequency, max_num_passes, max_delta_s)
+        mapping = {"kAutoSolver": "auto", "kDirectSolver": "direct", "kIterativeSolver": "iterative"}
+        solver_type = self._hfss_solver_settings.SolverType.ToString()
+        return mapping[solver_type]
 
-    @pyedb_function_handler()
-    def set_solution_multi_frequencies(self, frequencies=("5GHz", "10GHz"), max_num_passes=10, max_delta_s="0.02"):
-        """Set multi-frequency solution.
+    @solver_type.setter
+    def solver_type(self, value):
+        mapping = {
+            "auto": self._hfss_solver_settings.SolverType.kAutoSolver,
+            "direct": self._hfss_solver_settings.SolverType.kDirectSolver,
+            "iterative": self._hfss_solver_settings.SolverType.kIterativeSolver,
+        }
+        self._hfss_solver_settings.SolverType = mapping[value]
+        self._parent._update_setup()
 
-        Parameters
-        ----------
-        frequencies : list, tuple, optional
-            List or tuple of adaptive frequencies. The default is ``5GHz``.
-        max_num_passes : int, optional
-            Maximum number of passes. Default is ``10``.
-        max_delta_s : float, optional
-            Maximum delta S. The default is ``0.02``.
+    @property
+    def use_shell_elements(self):
+        """Whether to enable use of shell elements.
 
         Returns
         -------
         bool
-
+            ``True`` if shall elements are used, ``False`` otherwise.
         """
-        self.adaptive_settings.adapt_type = "kMultiFrequencies"
-        self.adaptive_settings.adaptive_settings.AdaptiveFrequencyDataList.Clear()
-        for i in frequencies:
-            if not self.adaptive_settings.add_adaptive_frequency_data(i, max_num_passes, max_delta_s):
-                return False
-        return True
-
-    @pyedb_function_handler()
-    def set_solution_broadband(
-        self, low_frequency="5GHz", high_frequency="10GHz", max_num_passes=10, max_delta_s="0.02"
-    ):
-        """Set broadband solution.
-
-        Parameters
-        ----------
-        low_frequency : str, float, optional
-            Low frequency. The default is ``5GHz``.
-        high_frequency : str, float, optional
-            High frequency. The default is ``10GHz``.
-        max_num_passes : int, optional
-            Maximum number of passes. The default is ``10``.
-        max_delta_s : float, optional
-            Maximum Delta S. Default is ``0.02``.
+        return self._hfss_solver_settings.UseShellElements
 
-        Returns
-        -------
-        bool
-        """
-        self.adaptive_settings.adapt_type = "kBroadband"
-        self.adaptive_settings.adaptive_settings.AdaptiveFrequencyDataList.Clear()
-        if not self.adaptive_settings.add_broadband_adaptive_frequency_data(
-            low_frequency, high_frequency, max_num_passes, max_delta_s
-        ):  # pragma no cover
-            return False
-        return True
+    @use_shell_elements.setter
+    def use_shell_elements(self, value):
+        self._hfss_solver_settings.UseShellElements = value
+        self._parent._update_setup()