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

pyedb/dotnet/edb_core/utilities/simulation_setup.py

@@ -20,10 +20,67 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.generic.general_methods import generate_unique_name, pyedb_function_handler
 
-
-class BaseSimulationSetup(object):
+import warnings
+
+from pyedb.dotnet.edb_core.general import (
+    convert_netdict_to_pydict,
+    convert_pydict_to_netdict,
+)
+from pyedb.dotnet.edb_core.sim_setup_data.data.mesh_operation import (
+    MeshOperationLength,
+    MeshOperationSkinDepth,
+)
+from pyedb.dotnet.edb_core.sim_setup_data.data.settings import (
+    AdaptiveSettings,
+    AdvancedMeshSettings,
+    CurveApproxSettings,
+    DcrSettings,
+    DefeatureSettings,
+    HfssPortSettings,
+    HfssSolverSettings,
+    ViaSettings,
+)
+from pyedb.dotnet.edb_core.sim_setup_data.data.siw_dc_ir_settings import (
+    SiwaveDCIRSettings,
+)
+from pyedb.dotnet.edb_core.sim_setup_data.data.sweep_data import SweepData
+from pyedb.dotnet.edb_core.sim_setup_data.io.siwave import (
+    AdvancedSettings,
+    DCAdvancedSettings,
+    DCSettings,
+)
+from pyedb.generic.general_methods import generate_unique_name, is_linux
+
+
+def _parse_value(v):
+    """Parse value in C sharp format."""
+    #  duck typing parse of the value 'v'
+    if v is None or v == "":
+        pv = v
+    elif v == "true":
+        pv = True
+    elif v == "false":
+        pv = False
+    else:
+        try:
+            pv = int(v)
+        except ValueError:
+            try:
+                pv = float(v)
+            except ValueError:
+                if isinstance(v, str) and v[0] == v[-1] == "'":
+                    pv = v[1:-1]
+                else:
+                    pv = v
+    return pv
+
+
+class AdaptiveType(object):
+    (SingleFrequency, MultiFrequency, BroadBand) = range(0, 3)
+
+
+class SimulationSetup(object):
     """Provide base simulation setup.
 
     Parameters
@@ -36,10 +93,9 @@ class BaseSimulationSetup(object):
         EDB object.
     """
 
-    @pyedb_function_handler
-    def __init__(self, pedb, edb_setup=None):
+    def __init__(self, pedb, edb_object=None):
         self._pedb = pedb
-        self._edb_object = edb_setup
+        self._edb_object = edb_object
         self._setup_type = ""
         self._setup_type_mapping = {
             "kHFSS": self._pedb.simsetupdata.HFSSSimulationSettings,
@@ -59,7 +115,6 @@ class BaseSimulationSetup(object):
             "kNumSetupTypes": None,
         }
 
-        version = self._pedb.edbversion.split(".")
         if float(self._pedb.edbversion) >= 2024.2:
             self._setup_type_mapping.update(
                 {
@@ -72,7 +127,6 @@ class BaseSimulationSetup(object):
 
         self._sweep_list = {}
 
-    @pyedb_function_handler
     def _create(self, name=None):
         """Create a simulation setup."""
         if not name:
@@ -90,7 +144,6 @@ class BaseSimulationSetup(object):
         self._edb_object = self._set_edb_setup_info(edb_setup_info)
         self._update_setup()
 
-    @pyedb_function_handler
     def _set_edb_setup_info(self, edb_setup_info):
         """Create a setup object from a setup information object."""
         utility = self._pedb._edb.Utility
@@ -118,7 +171,6 @@ class BaseSimulationSetup(object):
         setup_utility = setup_type_mapping[self._setup_type]
         return setup_utility(edb_setup_info)
 
-    @pyedb_function_handler()
     def _update_setup(self):
         """Update setup in EDB."""
         if self._setup_type == "kHFSS":
@@ -185,16 +237,15 @@ class BaseSimulationSetup(object):
         else:
             sweep_data_list = self.get_sim_setup_info.SweepDataList
         for i in list(sweep_data_list):
-            temp[i.Name] = EdbFrequencySweep(self, None, i.Name, i)
+            temp[i.Name] = SweepData(self, None, i.Name, i)
         return temp
 
-    @pyedb_function_handler
     def _add_frequency_sweep(self, sweep_data):
         """Add a frequency sweep.
 
         Parameters
         ----------
-        sweep_data: EdbFrequencySweep
+        sweep_data: SweepData
         """
         self._sweep_list[sweep_data.name] = sweep_data
         if self.setup_type in ["kRaptorX", "kHFSSPI"]:
@@ -209,7 +260,6 @@ class BaseSimulationSetup(object):
         self._edb_object = self._set_edb_setup_info(edb_setup_info)
         self._update_setup()
 
-    @pyedb_function_handler
     def delete_frequency_sweep(self, sweep_data):
         """Delete a frequency sweep.
 
@@ -230,7 +280,6 @@ class BaseSimulationSetup(object):
             self._update_setup()
             return True if name in self.frequency_sweeps else False
 
-    @pyedb_function_handler()
     def add_frequency_sweep(self, name=None, frequency_sweep=None):
         """Add frequency sweep.
 
@@ -264,501 +313,698 @@ class BaseSimulationSetup(object):
 
         if not name:
             name = generate_unique_name("sweep")
-        sweep = EdbFrequencySweep(self, frequency_sweep, name)
+        sweep = SweepData(self, frequency_sweep, name)
         self._add_frequency_sweep(sweep)
         self._update_setup()
         return sweep
 
 
-class EdbFrequencySweep(object):
-    """Manages EDB methods for a frequency sweep.
-
-    Parameters
-    ----------
-    sim_setup : :class:`pyedb.dotnet.edb_core.edb_data.siwave_simulation_setup_data.SiwaveSYZSimulationSetup`
-    name : str, optional
-        Name of the frequency sweep.
-    edb_sweep_data : :class:`Ansys.Ansoft.Edb.Utility.SIWDCIRSimulationSettings`, optional
-        EDB object. The default is ``None``.
-    """
+class HfssSimulationSetup(SimulationSetup):
+    """Manages EDB methods for HFSS simulation setup."""
 
-    def __init__(self, sim_setup, frequency_sweep=None, name=None, edb_sweep_data=None):
-        self._sim_setup = sim_setup
+    def __init__(self, pedb, edb_object=None):
+        super().__init__(pedb, edb_object)
+        self._setup_type = "kHFSS"
+        self._mesh_operations = {}
 
-        if edb_sweep_data:
-            self._edb_sweep_data = edb_sweep_data
-            self._name = self._edb_sweep_data.Name
-        else:
-            if not name:
-                self._name = generate_unique_name("sweep")
-            else:
-                self._name = name
-            self._edb_sweep_data = self._pedb.simsetupdata.SweepData(self._name)
-            self.set_frequencies(frequency_sweep)
+    def create(self, name=None):
+        """Create an HFSS setup."""
+        self._name = name
+        self._create(name)
+        return self
 
     @property
-    def _edb_object(self):
-        return self._edb_sweep_data
+    def get_sim_setup_info(self):
+        """Get simulation setup information."""
+        return self._edb_object.GetSimSetupInfo()
 
     @property
-    def _pedb(self):
-        """EDB."""
-        return self._sim_setup._pedb
+    def solver_slider_type(self):
+        """Solver slider type.
+        Options are:
+        1 - ``kFast``.
+        2 - ``kMedium``.
+        3 - ``kAccurate``.
+        4 - ``kNumSliderTypes``.
 
-    @pyedb_function_handler()
-    def _update_sweep(self):
-        """Update the sweep."""
-        self._sim_setup.delete_frequency_sweep(self)
-        self._sim_setup._add_frequency_sweep(self)
-        return
+        Returns
+        -------
+        str
+        """
+        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 name(self):
-        """Name of the sweep."""
-        return self._edb_sweep_data.Name
+    def is_auto_setup(self):
+        """Flag indicating if automatic setup is enabled."""
+        return self.get_sim_setup_info.SimulationSettings.IsAutoSetup
 
-    @name.setter
-    def name(self, value):
-        self._edb_sweep_data.Name = value
-        self._update_sweep()
+    @is_auto_setup.setter
+    def is_auto_setup(self, value):
+        self.get_sim_setup_info.SimulationSettings.IsAutoSetup = value
+        self._update_setup()
 
     @property
-    def sweep_type(self):
-        """Sweep type."""
-        return
+    def hfss_solver_settings(self):
+        """Manages EDB methods for HFSS solver settings.
 
-    @property
-    def frequencies(self):
-        """List of frequency points."""
-        return list(self._edb_sweep_data.Frequencies)
+        Returns
+        -------
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.HfssSolverSettings`
+
+        """
+        return HfssSolverSettings(self)
 
     @property
-    def adaptive_sampling(self):
-        """Flag indicating if adaptive sampling is turned on.
+    def adaptive_settings(self):
+        """Adaptive Settings Class.
 
         Returns
         -------
-        bool
-            ``True`` if adaptive sampling is used, ``False`` otherwise.
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.AdaptiveSettings`
+
         """
-        return self._edb_sweep_data.AdaptiveSampling
+        return AdaptiveSettings(self)
 
     @property
-    def adv_dc_extrapolation(self):
-        """Flag indicating if advanced DC extrapolation is turned on.
+    def defeature_settings(self):
+        """Defeature settings Class.
 
         Returns
         -------
-        bool
-            ``True`` if advanced DC Extrapolation is used, ``False`` otherwise.
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.DefeatureSettings`
+
         """
-        return self._edb_sweep_data.AdvDCExtrapolation
+        return DefeatureSettings(self)
 
     @property
-    def compute_dc_point(self):
-        """Flag indicating if computing the exact DC point is turned on."""
-        return self._edb_sweep_data.ComputeDCPoint
+    def via_settings(self):
+        """Via settings Class.
 
-    @compute_dc_point.setter
-    def compute_dc_point(self, value):
-        self._edb_sweep_data.ComputeDCPoint = value
-        self._update_sweep()
+        Returns
+        -------
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.ViaSettings`
 
-    @property
-    def auto_s_mat_only_solve(self):
-        """Flag indicating if Auto SMatrix only solve is turned on."""
-        return self._edb_sweep_data.AutoSMatOnlySolve
+        """
+        return ViaSettings(self)
 
     @property
-    def enforce_causality(self):
-        """Flag indicating if causality is enforced.
+    def advanced_mesh_settings(self):
+        """Advanced mesh settings Class.
 
         Returns
         -------
-        bool
-            ``True`` if enforce causality is used, ``False`` otherwise.
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.AdvancedMeshSettings`
+
         """
-        return self._edb_sweep_data.EnforceCausality
+        return AdvancedMeshSettings(self)
 
     @property
-    def enforce_dc_and_causality(self):
-        """Flag indicating if DC point and causality are enforced.
+    def curve_approx_settings(self):
+        """Curve approximation settings Class.
 
         Returns
         -------
-        bool
-            ``True`` if enforce dc point and causality is used, ``False`` otherwise.
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.CurveApproxSettings`
+
         """
-        return self._edb_sweep_data.EnforceDCAndCausality
+        return CurveApproxSettings(self)
 
     @property
-    def enforce_passivity(self):
-        """Flag indicating if passivity is enforced.
+    def dcr_settings(self):
+        """Dcr settings Class.
 
         Returns
         -------
-        bool
-            ``True`` if enforce passivity is used, ``False`` otherwise.
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.DcrSettings`
+
         """
-        return self._edb_sweep_data.EnforcePassivity
+        return DcrSettings(self)
 
     @property
-    def freq_sweep_type(self):
-        """Sweep type.
-
-        Options are:
-        - ``"kInterpolatingSweep"``
-        - ``"kDiscreteSweep"``
-        - ``"kBroadbandFastSweep"``
+    def hfss_port_settings(self):
+        """HFSS port settings Class.
 
         Returns
         -------
-        str
-            Sweep type.
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.HfssPortSettings`
+
         """
-        return self._edb_sweep_data.FreqSweepType.ToString()
+        return HfssPortSettings(self)
 
     @property
-    def interpolation_use_full_basis(self):
-        """Flag indicating if full-basis elements is used.
+    def mesh_operations(self):
+        """Mesh operations settings Class.
 
         Returns
         -------
-        bool
-            ``True`` if full basis interpolation is used, ``False`` otherwise.
+        List of :class:`dotnet.edb_core.edb_data.hfss_simulation_setup_data.MeshOperation`
+
         """
-        return self._edb_sweep_data.InterpUseFullBasis
+        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
+
+    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.
 
-    @property
-    def interpolation_use_port_impedance(self):
-        """Flag indicating if port impedance interpolation is turned on.
+        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``.
 
         Returns
         -------
-        bool
-            ``True`` if port impedance is used, ``False`` otherwise.
+        :class:`dotnet.edb_core.edb_data.hfss_simulation_setup_data.LengthMeshOperation`
         """
-        return self._edb_sweep_data.InterpUsePortImpedance
+        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
+
+    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.
 
-    @property
-    def interpolation_use_prop_const(self):
-        """Flag indicating if propagation constants are used.
+        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``.
 
         Returns
         -------
-        bool
-            ``True`` if propagation constants are used, ``False`` otherwise.
+        :class:`dotnet.edb_core.edb_data.hfss_simulation_setup_data.LengthMeshOperation`
         """
-        return self._edb_sweep_data.InterpUsePropConst
+        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
 
-    @property
-    def interpolation_use_s_matrix(self):
-        """Flag indicating if the S matrix is used.
+    def add_frequency_sweep(self, name=None, frequency_sweep=None):
+        """Add frequency sweep.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the frequency sweep.
+        frequency_sweep : list, optional
+            List of frequency points.
 
         Returns
         -------
-        bool
-            ``True`` if S matrix are used, ``False`` otherwise.
+        :class:`pyedb.dotnet.edb_core.edb_data.simulation_setup.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"],
+        ...                           ])
         """
-        return self._edb_sweep_data.InterpUseSMatrix
+        if name in self.frequency_sweeps:
+            return False
+        if not name:
+            name = generate_unique_name("sweep")
+        return SweepData(self, frequency_sweep, name)
 
-    @property
-    def max_solutions(self):
-        """Number of maximum solutions.
+    def set_solution_single_frequency(self, frequency="5GHz", max_num_passes=10, max_delta_s=0.02):
+        """Set single-frequency solution.
+
+        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``.
 
         Returns
         -------
-        int
+        bool
+
         """
-        return self._edb_sweep_data.MaxSolutions
+        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)
 
-    @property
-    def min_freq_s_mat_only_solve(self):
-        """Minimum frequency SMatrix only solve.
+    def set_solution_multi_frequencies(self, frequencies=("5GHz", "10GHz"), max_num_passes=10, max_delta_s="0.02"):
+        """Set multi-frequency solution.
+
+        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``.
 
         Returns
         -------
-        str
-            Frequency with units.
+        bool
+
         """
-        return self._edb_sweep_data.MinFreqSMatOnlySolve
+        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
 
-    @property
-    def min_solved_freq(self):
-        """Minimum solved frequency with units.
+    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``.
 
         Returns
         -------
-        str
-            Frequency with units.
+        bool
         """
-        return self._edb_sweep_data.MinSolvedFreq
+        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
 
-    @property
-    def passivity_tolerance(self):
-        """Tolerance for passivity enforcement.
+
+class SiwaveSYZSimulationSetup(SimulationSetup):
+    """Manages EDB methods for SIwave simulation setup.
+
+    Parameters
+    ----------
+    pedb : :class:`pyedb.dotnet.edb.Edb`
+        Inherited AEDT object.
+    edb_setup : :class:`Ansys.Ansoft.Edb.Utility.SIWaveSimulationSetup`
+        Edb object.
+    """
+
+    def __init__(self, pedb, edb_setup=None):
+        super().__init__(pedb, edb_setup)
+        self._edb = self._pedb
+        self._setup_type = "kSIwave"
+        self._sim_setup_info = None
+
+    def create(self, name=None):
+        """Create a SIwave SYZ setup.
 
         Returns
         -------
-        float
+        :class:`SiwaveDCSimulationSetup`
         """
-        return self._edb_sweep_data.PassivityTolerance
+        self._name = name
+        self._create(name)
+        self.si_slider_position = 1
 
-    @property
-    def relative_s_error(self):
-        """S-parameter error tolerance.
+        return self
+
+    def get_configurations(self):
+        """Get SIwave SYZ simulation settings.
 
         Returns
         -------
-        float
+        dict
+            Dictionary of SIwave SYZ simulation settings.
         """
-        return self._edb_sweep_data.RelativeSError
+        return {
+            "pi_slider_position": self.pi_slider_position,
+            "si_slider_position": self.si_slider_position,
+            "use_custom_settings": self.use_si_settings,
+            "use_si_settings": self.use_si_settings,
+            "advanced_settings": self.advanced_settings.get_configurations(),
+        }
 
     @property
-    def save_fields(self):
-        """Flag indicating if the extraction of surface current data is turned on.
+    def advanced_settings(self):
+        """SIwave advanced settings."""
+        return AdvancedSettings(self)
 
-        Returns
-        -------
-        bool
-            ``True`` if save fields is enabled, ``False`` otherwise.
+    @property
+    def get_sim_setup_info(self):
+        """Get simulation information from the setup."""
+        if self._sim_setup_info:
+            return self._sim_setup_info
+
+        edb_setup = self._edb_object
+        edb_sim_setup_info = self._pedb.simsetupdata.SimSetupInfo[self._setup_type_mapping[self._setup_type]]()
+        edb_sim_setup_info.Name = edb_setup.GetName()
+
+        string = edb_setup.ToString().replace("\t", "").split("\r\n")
+
+        if is_linux:
+            string = string[0].split("\n")
+        keys = [i.split("=")[0] for i in string if len(i.split("=")) == 2 and "SourceTermsToGround" not in i]
+        values = [i.split("=")[1] for i in string if len(i.split("=")) == 2 and "SourceTermsToGround" not in i]
+        for val in string:
+            if "SourceTermsToGround()" in val:
+                break
+            elif "SourceTermsToGround" in val:
+                sources = {}
+                val = val.replace("SourceTermsToGround(", "").replace(")", "").split(",")
+                for v in val:
+                    source = v.split("=")
+                    sources[source[0]] = int(source[1].replace("'", ""))
+                edb_sim_setup_info.SimulationSettings.DCIRSettings.SourceTermsToGround = convert_pydict_to_netdict(
+                    sources
+                )
+                break
+        for k in keys:
+            value = _parse_value(values[keys.index(k)])
+            setter = None
+            if k in dir(edb_sim_setup_info.SimulationSettings):
+                setter = edb_sim_setup_info.SimulationSettings
+            elif k in dir(edb_sim_setup_info.SimulationSettings.AdvancedSettings):
+                setter = edb_sim_setup_info.SimulationSettings.AdvancedSettings
+
+            elif k in dir(edb_sim_setup_info.SimulationSettings.DCAdvancedSettings):
+                setter = edb_sim_setup_info.SimulationSettings.DCAdvancedSettings
+            elif "DCIRSettings" in dir(edb_sim_setup_info.SimulationSettings) and k in dir(
+                edb_sim_setup_info.SimulationSettings.DCIRSettings
+            ):
+                setter = edb_sim_setup_info.SimulationSettings.DCIRSettings
+            elif k in dir(edb_sim_setup_info.SimulationSettings.DCSettings):
+                setter = edb_sim_setup_info.SimulationSettings.DCSettings
+            elif k in dir(edb_sim_setup_info.SimulationSettings.AdvancedSettings):
+                setter = edb_sim_setup_info.SimulationSettings.AdvancedSettings
+            if setter:
+                try:
+                    setter.__setattr__(k, value)
+                except TypeError:
+                    try:
+                        setter.__setattr__(k, str(value))
+                    except:
+                        pass
+
+        return edb_sim_setup_info
+
+    def set_pi_slider(self, value):
+        """Set SIwave PI simulation accuracy level.
+        Options are:
+        - ``0``: Optimal speed
+        - ``1``:  Balanced
+        - ``2``: Optimal accuracy
+
+        .. deprecated:: 0.7.5
+           Use :property:`pi_slider_position` property instead.
+
+        """
+        warnings.warn("`set_pi_slider` is deprecated. Use `pi_slider_position` property instead.", DeprecationWarning)
+        self.pi_slider_position = value
+
+    def set_si_slider(self, value):
+        """Set SIwave SI simulation accuracy level.
+
+        Options are:
+        - ``0``: Optimal speed;
+        - ``1``:  Balanced;
+        - ``2``: Optimal accuracy```.
         """
-        return self._edb_sweep_data.SaveFields
+        self.use_si_settings = True
+        self.use_custom_settings = False
+        self.si_slider_position = value
+        self.advanced_settings.set_si_slider(value)
+
+    @property
+    def pi_slider_position(self):
+        """PI solider position. Values are from ``1`` to ``3``."""
+        return self.get_sim_setup_info.SimulationSettings.PISliderPos
+
+    @pi_slider_position.setter
+    def pi_slider_position(self, value):
+        edb_setup_info = self.get_sim_setup_info
+        edb_setup_info.SimulationSettings.PISliderPos = value
+        self._edb_object = self._set_edb_setup_info(edb_setup_info)
+        self._update_setup()
+
+        self.use_si_settings = False
+        self.use_custom_settings = False
+        self.advanced_settings.set_pi_slider(value)
 
     @property
-    def save_rad_fields_only(self):
-        """Flag indicating if the saving of only radiated fields is turned on.
+    def si_slider_position(self):
+        """SI slider position. Values are from ``1`` to ``3``."""
+        return self.get_sim_setup_info.SimulationSettings.SISliderPos
+
+    @si_slider_position.setter
+    def si_slider_position(self, value):
+        edb_setup_info = self.get_sim_setup_info
+        edb_setup_info.SimulationSettings.SISliderPos = value
+        self._edb_object = self._set_edb_setup_info(edb_setup_info)
+        self._update_setup()
+
+        self.use_si_settings = True
+        self.use_custom_settings = False
+        self.advanced_settings.set_si_slider(value)
+
+    @property
+    def use_custom_settings(self):
+        """Custom settings to use.
 
         Returns
         -------
         bool
-            ``True`` if save radiated field only is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.SaveRadFieldsOnly
+        return self.get_sim_setup_info.SimulationSettings.UseCustomSettings
+
+    @use_custom_settings.setter
+    def use_custom_settings(self, value):
+        edb_setup_info = self.get_sim_setup_info
+        edb_setup_info.SimulationSettings.UseCustomSettings = value
+        self._edb_object = self._set_edb_setup_info(edb_setup_info)
+        self._update_setup()
 
     @property
-    def use_q3d_for_dc(self):
-        """Flag indicating if the Q3D solver is used for DC point extraction.
+    def use_si_settings(self):
+        """Whether to use SI Settings.
 
         Returns
         -------
         bool
-            ``True`` if Q3d for DC point is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.UseQ3DForDC
-
-    @adaptive_sampling.setter
-    def adaptive_sampling(self, value):
-        self._edb_sweep_data.AdaptiveSampling = value
-        self._update_sweep()
-
-    @adv_dc_extrapolation.setter
-    def adv_dc_extrapolation(self, value):
-        self._edb_sweep_data.AdvDCExtrapolation = value
-        self._update_sweep()
-
-    @auto_s_mat_only_solve.setter
-    def auto_s_mat_only_solve(self, value):
-        self._edb_sweep_data.AutoSMatOnlySolve = value
-        self._update_sweep()
-
-    @enforce_causality.setter
-    def enforce_causality(self, value):
-        self._edb_sweep_data.EnforceCausality = value
-        self._update_sweep()
-
-    @enforce_dc_and_causality.setter
-    def enforce_dc_and_causality(self, value):
-        self._edb_sweep_data.EnforceDCAndCausality = value
-        self._update_sweep()
-
-    @enforce_passivity.setter
-    def enforce_passivity(self, value):
-        self._edb_sweep_data.EnforcePassivity = value
-        self._update_sweep()
-
-    @freq_sweep_type.setter
-    def freq_sweep_type(self, value):
-        edb_freq_sweep_type = self._edb_sweep_data.TFreqSweepType
-        if value in [0, "kInterpolatingSweep"]:
-            self._edb_sweep_data.FreqSweepType = edb_freq_sweep_type.kInterpolatingSweep
-        elif value in [1, "kDiscreteSweep"]:
-            self._edb_sweep_data.FreqSweepType = edb_freq_sweep_type.kDiscreteSweep
-        elif value in [2, "kBroadbandFastSweep"]:
-            self._edb_sweep_data.FreqSweepType = edb_freq_sweep_type.kBroadbandFastSweep
-        elif value in [3, "kNumSweepTypes"]:
-            self._edb_sweep_data.FreqSweepType = edb_freq_sweep_type.kNumSweepTypes
-        self._edb_sweep_data.FreqSweepType.ToString()
-
-    @interpolation_use_full_basis.setter
-    def interpolation_use_full_basis(self, value):
-        self._edb_sweep_data.InterpUseFullBasis = value
-        self._update_sweep()
-
-    @interpolation_use_port_impedance.setter
-    def interpolation_use_port_impedance(self, value):
-        self._edb_sweep_data.InterpUsePortImpedance = value
-        self._update_sweep()
-
-    @interpolation_use_prop_const.setter
-    def interpolation_use_prop_const(self, value):
-        self._edb_sweep_data.InterpUsePropConst = value
-        self._update_sweep()
-
-    @interpolation_use_s_matrix.setter
-    def interpolation_use_s_matrix(self, value):
-        self._edb_sweep_data.InterpUseSMatrix = value
-        self._update_sweep()
-
-    @max_solutions.setter
-    def max_solutions(self, value):
-        self._edb_sweep_data.MaxSolutions = value
-        self._update_sweep()
-
-    @min_freq_s_mat_only_solve.setter
-    def min_freq_s_mat_only_solve(self, value):
-        self._edb_sweep_data.MinFreqSMatOnlySolve = value
-        self._update_sweep()
-
-    @min_solved_freq.setter
-    def min_solved_freq(self, value):
-        self._edb_sweep_data.MinSolvedFreq = value
-        self._update_sweep()
-
-    @passivity_tolerance.setter
-    def passivity_tolerance(self, value):
-        self._edb_sweep_data.PassivityTolerance = value
-        self._update_sweep()
-
-    @relative_s_error.setter
-    def relative_s_error(self, value):
-        self._edb_sweep_data.RelativeSError = value
-        self._update_sweep()
-
-    @save_fields.setter
-    def save_fields(self, value):
-        self._edb_sweep_data.SaveFields = value
-        self._update_sweep()
-
-    @save_rad_fields_only.setter
-    def save_rad_fields_only(self, value):
-        self._edb_sweep_data.SaveRadFieldsOnly = value
-        self._update_sweep()
-
-    @use_q3d_for_dc.setter
-    def use_q3d_for_dc(self, value):
-        self._edb_sweep_data.UseQ3DForDC = value
-        self._update_sweep()
-
-    @pyedb_function_handler()
-    def _set_frequencies(self, freq_sweep_string="Linear Step: 0GHz to 20GHz, step=0.05GHz"):
-        self._edb_sweep_data.SetFrequencies(freq_sweep_string)
-        self._update_sweep()
-
-    @pyedb_function_handler()
-    def set_frequencies_linear_scale(self, start="0.1GHz", stop="20GHz", step="50MHz"):
-        """Set a linear scale frequency sweep.
+        return self.get_sim_setup_info.SimulationSettings.UseSISettings
 
-        Parameters
-        ----------
-        start : str, float, optional
-            Start frequency. The default is ``"0.1GHz"``.
-        stop : str, float, optional
-            Stop frequency. The default is ``"20GHz"``.
-        step : str, float, optional
-            Step frequency. The default is ``"50MHz"``.
+    @use_si_settings.setter
+    def use_si_settings(self, value):
+        edb_setup_info = self.get_sim_setup_info
+        edb_setup_info.SimulationSettings.UseSISettings = value
+        self._edb_object = self._set_edb_setup_info(edb_setup_info)
+        self._update_setup()
+
+
+class SiwaveDCSimulationSetup(SiwaveSYZSimulationSetup):
+    """Manages EDB methods for SIwave DC simulation setup.
+
+    Parameters
+    ----------
+    pedb : :class:`pyedb.dotnet.edb.Edb`
+        Inherited AEDT object.
+    edb_setup : Ansys.Ansoft.Edb.Utility.SIWDCIRSimulationSettings
+        EDB object. The default is ``None``.
+    """
+
+    def __init__(self, pedb, edb_object=None):
+        super().__init__(pedb, edb_object)
+        self._setup_type = "kSIwaveDCIR"
+        self._edb = pedb
+        self._mesh_operations = {}
+
+    def create(self, name=None):
+        """Create a SIwave DCIR setup.
 
         Returns
         -------
-        bool
-            ``True`` if correctly executed, ``False`` otherwise.
+        :class:`SiwaveDCSimulationSetup`
         """
-        self._edb_sweep_data.Frequencies = self._edb_sweep_data.SetFrequencies(start, stop, step)
-        return self._update_sweep()
+        self._name = name
+        self._create(name)
+        self.set_dc_slider(1)
+        return self
 
-    @pyedb_function_handler()
-    def set_frequencies_linear_count(self, start="1kHz", stop="0.1GHz", count=10):
-        """Set a linear count frequency sweep.
+    @property
+    def dc_ir_settings(self):
+        """DC IR settings."""
+        return SiwaveDCIRSettings(self)
 
-        Parameters
-        ----------
-        start : str, float, optional
-            Start frequency. The default is ``"1kHz"``.
-        stop : str, float, optional
-            Stop frequency. The default is ``"0.1GHz"``.
-        count : int, optional
-            Step frequency. The default is ``10``.
+    def get_configurations(self):
+        """Get SIwave DC simulation settings.
 
         Returns
         -------
-        bool
-            ``True`` if correctly executed, ``False`` otherwise.
+        dict
+            Dictionary of SIwave DC simulation settings.
         """
-        start = self._sim_setup._pedb.arg_to_dim(start, "Hz")
-        stop = self._sim_setup._pedb.arg_to_dim(stop, "Hz")
-        self._edb_sweep_data.Frequencies = self._edb_sweep_data.SetFrequencies(start, stop, count)
-        return self._update_sweep()
+        return {
+            "dc_settings": self.dc_settings.get_configurations(),
+            "dc_advanced_settings": self.dc_advanced_settings.get_configurations(),
+        }
 
-    @pyedb_function_handler()
-    def set_frequencies_log_scale(self, start="1kHz", stop="0.1GHz", samples=10):
-        """Set a log-count frequency sweep.
+    def set_dc_slider(self, value):
+        """Set DC simulation accuracy level.
 
-        Parameters
-        ----------
-        start : str, float, optional
-            Start frequency. The default is ``"1kHz"``.
-        stop : str, float, optional
-            Stop frequency. The default is ``"0.1GHz"``.
-        samples : int, optional
-            Step frequency. The default is ``10``.
+        Options are:
+
+        - ``0``: Optimal speed
+        - ``1``: Balanced
+        - ``2``: Optimal accuracy
+        """
+        self.use_custom_settings = False
+        self.dc_settings.dc_slider_position = value
+        self.dc_advanced_settings.set_dc_slider(value)
+
+    @property
+    def dc_settings(self):
+        """SIwave DC setting."""
+        return DCSettings(self)
+
+    @property
+    def dc_advanced_settings(self):
+        """Siwave DC advanced settings.
 
         Returns
         -------
-        bool
-            ``True`` if correctly executed, ``False`` otherwise.
+        :class:`pyedb.dotnet.edb_core.edb_data.siwave_simulation_setup_data.SiwaveDCAdvancedSettings`
         """
-        start = self._sim_setup._pedb.arg_to_dim(start, "Hz")
-        stop = self._sim_setup._pedb.arg_to_dim(stop, "Hz")
-        self._edb_sweep_data.Frequencies = self._edb_sweep_data.SetLogFrequencies(start, stop, samples)
-        return self._update_sweep()
+        return DCAdvancedSettings(self)
 
-    @pyedb_function_handler()
-    def set_frequencies(self, frequency_list=None, update=True):
-        """Set frequency list to the sweep frequencies.
+    @property
+    def source_terms_to_ground(self):
+        """Dictionary of grounded terminals.
+
+        Returns
+        -------
+        Dictionary
+            {str, int}, keys is source name, value int 0 unspecified, 1 negative node, 2 positive one.
+
+        """
+        return convert_netdict_to_pydict(self.get_sim_setup_info.SimulationSettings.DCIRSettings.SourceTermsToGround)
+
+    def add_source_terminal_to_ground(self, source_name, terminal=0):
+        """Add a source terminal to ground.
 
         Parameters
         ----------
-        frequency_list : list, optional
-             List of lists with four elements. The default is ``None``. If provided, each list must contain:
-              1 - frequency type (``"linear count"``, ``"log scale"``, or ``"linear scale"``)
-              2 - start frequency
-              3 - stop frequency
-              4 - step frequency or count
+        source_name : str,
+            Source name.
+        terminal : int, optional
+            Terminal to assign. Options are:
+
+             - 0=Unspecified
+             - 1=Negative node
+             - 2=Positive none
+
         Returns
         -------
         bool
-            ``True`` if correctly executed, ``False`` otherwise.
+
         """
-        if not frequency_list:
-            frequency_list = [
-                ["linear count", "0", "1kHz", 1],
-                ["log scale", "1kHz", "0.1GHz", 10],
-                ["linear scale", "0.1GHz", "10GHz", "0.1GHz"],
-            ]
-        temp = []
-        if isinstance(frequency_list, list) and not isinstance(frequency_list[0], list):
-            frequency_list = [frequency_list]
-        for i in frequency_list:
-            if i[0] == "linear count":
-                temp.extend(list(self._edb_sweep_data.SetFrequencies(i[1], i[2], i[3])))
-            elif i[0] == "linear scale":
-                temp.extend(list(self._edb_sweep_data.SetFrequencies(i[1], i[2], i[3])))
-            elif i[0] == "log scale":
-                temp.extend(list(self._edb_sweep_data.SetLogFrequencies(i[1], i[2], i[3])))
-            else:
-                return False
-        self._edb_sweep_data.Frequencies.Clear()
-        for i in temp:
-            self._edb_sweep_data.Frequencies.Add(i)
-        if update:
-            return self._update_sweep()
+        terminals = self.source_terms_to_ground
+        terminals[source_name] = terminal
+        self.get_sim_setup_info.SimulationSettings.DCIRSettings.SourceTermsToGround = convert_pydict_to_netdict(
+            terminals
+        )
+        return self._update_setup()