pyedb 0.43.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

pyedb/configuration/cfg_setup.py

@@ -32,6 +32,59 @@ class CfgSetup:
     """
 
     class Common:
+        class Grpc:
+            def __init__(self, parent):
+                self.parent = parent
+
+            def apply_freq_sweep(self, edb_setup):
+                for i in self.parent.parent.freq_sweep:
+                    f_set = []
+                    freq_string = []
+                    for f in i.get("frequencies", []):
+                        if isinstance(f, dict):
+                            increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
+                            f_set.append([f["distribution"], f["start"], f["stop"], increment])
+                        else:
+                            freq_string.append(f)
+                    discrete_sweep = True
+                    if i["type"] == "interpolation":
+                        discrete_sweep = False
+                    if freq_string:
+                        for _sweep in freq_string:
+                            _sw = _sweep.split(" ")
+                            edb_setup.add_sweep(
+                                name=i["name"],
+                                distribution=_sw[0],
+                                start_freq=_sw[1],
+                                stop_freq=_sw[2],
+                                step=_sw[3],
+                                discrete=discrete_sweep,
+                            )
+                    else:
+                        edb_setup.add_sweep(i["name"], frequency_set=f_set, discrete=discrete_sweep)
+
+        class DotNet(Grpc):
+            def __init__(self, parent):
+                super().__init__(parent)
+
+            @staticmethod
+            def set_frequency_string(sweep, freq_string):
+                sweep.frequency_string = freq_string
+
+            def apply_freq_sweep(self, edb_setup):
+                for i in self.parent.parent.freq_sweep:
+                    f_set = []
+                    freq_string = []
+                    for f in i.get("frequencies", []):
+                        if isinstance(f, dict):
+                            increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
+                            f_set.append([f["distribution"], f["start"], f["stop"], increment])
+                        else:
+                            freq_string.append(f)
+                    sweep = edb_setup.add_sweep(i["name"], frequency_set=f_set, sweep_type=i["type"])
+                    if len(freq_string) > 0:
+                        self.parent.api.set_frequency_string(sweep, freq_string)
+
         @property
         def pyedb_obj(self):
             return self.parent.pyedb_obj
@@ -39,24 +92,17 @@ class CfgSetup:
         def __init__(self, parent):
             self.parent = parent
             self.pedb = parent.pedb
+            if self.pedb.grpc:
+                self.api = self.Grpc(self)
+            else:
+                self.api = self.DotNet(self)
 
         def _retrieve_parameters_from_edb_common(self):
             self.parent.name = self.pyedb_obj.name
             self.parent.type = self.pyedb_obj.type
 
         def _apply_freq_sweep(self, edb_setup):
-            for i in self.parent.freq_sweep:
-                f_set = []
-                freq_string = []
-                for f in i.get("frequencies", []):
-                    if isinstance(f, dict):
-                        increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
-                        f_set.append([f["distribution"], f["start"], f["stop"], increment])
-                    else:
-                        freq_string.append(f)
-                sweep = edb_setup.add_sweep(i["name"], frequency_set=f_set, sweep_type=i["type"])
-                if len(freq_string) > 0:
-                    sweep.frequency_string = freq_string
+            self.api.apply_freq_sweep(edb_setup)
 
     class Grpc(Common):
         def __init__(self, parent):
@@ -148,9 +194,8 @@ class CfgSIwaveDCSetup(CfgSetup):
             edb_setup = self.pedb.create_siwave_dc_setup(
                 name=self.parent.name, dc_slider_position=self.parent.dc_slider_position
             )
-            edb_setup.dc_settings.dc_slider_position = self.parent.dc_slider_position
-            dc_ir_settings = self.parent.dc_ir_settings
-            edb_setup.dc_ir_settings.export_dc_thermal_data = dc_ir_settings["export_dc_thermal_data"]
+            edb_setup.settings.dc.dc_slider_pos = self.parent.dc_slider_position
+            edb_setup.settings.export_dc_thermal_data = self.parent.dc_ir_settings.get("export_dc_thermal_data", False)
 
         def retrieve_parameters_from_edb(self):
             self._retrieve_parameters_from_edb_common()
@@ -163,6 +208,14 @@ class CfgSIwaveDCSetup(CfgSetup):
         def __init__(self, parent):
             super().__init__(parent)
 
+        def set_parameters_to_edb(self):
+            edb_setup = self.pedb.create_siwave_dc_setup(
+                name=self.parent.name, dc_slider_position=self.parent.dc_slider_position
+            )
+            edb_setup.dc_settings.dc_slider_position = self.parent.dc_slider_position
+            dc_ir_settings = self.parent.dc_ir_settings
+            edb_setup.dc_ir_settings.export_dc_thermal_data = dc_ir_settings.get("export_dc_thermal_data", False)
+
     def __init__(self, pedb, pyedb_obj, **kwargs):
         super().__init__(pedb, pyedb_obj, **kwargs)
         self.type = "siwave_dc"
@@ -202,6 +255,57 @@ class CfgHFSSSetup(CfgSetup):
                     net_layer_list=i.get("nets_layers_list", {}),
                 )
 
+        def retrieve_parameters_from_edb(self):
+            self._retrieve_parameters_from_edb_common()
+            single_frequency_adaptive_solution = self.pyedb_obj.settings.general.single_frequency_adaptive_solution
+            self.parent.f_adapt = single_frequency_adaptive_solution.adaptive_frequency
+            self.parent.max_num_passes = single_frequency_adaptive_solution.max_passes
+            self.parent.max_mag_delta_s = float(single_frequency_adaptive_solution.max_delta)
+            self.parent.freq_sweep = []
+            setup_sweeps = self.sort_sweep_data(self.pyedb_obj.sweep_data)
+            for setup_name, sweeps in setup_sweeps.items():
+                sw_name = sweeps[0].name
+                sw_type = sweeps[0].type.name.lower().split("_")[0]
+                freq_strings = [f.frequency_string for f in sweeps]
+                self.parent.freq_sweep.append({"name": sw_name, "type": sw_type, "frequencies": freq_strings})
+
+            self.parent.mesh_operations = []
+            from ansys.edb.core.simulation_setup.mesh_operation import (
+                LengthMeshOperation as GrpcLengthMeshOperation,
+            )
+
+            for mesh_op in self.pyedb_obj.mesh_operations:
+                if isinstance(mesh_op, GrpcLengthMeshOperation):
+                    mop_type = "length"
+                else:
+                    mop_type = "skin"
+                self.parent.mesh_operations.append(
+                    {
+                        "name": mesh_op.name,
+                        "type": mop_type,
+                        "max_elements": mesh_op.max_elements,
+                        "max_length": mesh_op.max_length,
+                        "restrict_length": mesh_op.restrict_max_length,
+                        "refine_inside": mesh_op.refine_inside,
+                        "nets_layers_list": mesh_op.net_layer_info,
+                    }
+                )
+
+        @staticmethod
+        def sort_sweep_data(sweep_data):
+            """grpc sweep data contains all sweeps for each setup, we need to sort thwm by setup"""
+            setups = {}
+            for sweep in sweep_data:
+                if sweep.name not in setups:
+                    setups[sweep.name] = [sweep]
+                else:
+                    setups[sweep.name].append(sweep)
+            return setups
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
         def retrieve_parameters_from_edb(self):
             self._retrieve_parameters_from_edb_common()
             adaptive_frequency_data_list = list(self.pyedb_obj.adaptive_settings.adaptive_frequency_data_list)[0]
@@ -226,10 +330,6 @@ class CfgHFSSSetup(CfgSetup):
                     }
                 )
 
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
     def __init__(self, pedb, pyedb_obj, **kwargs):
         super().__init__(pedb, pyedb_obj, **kwargs)
         self.type = "hfss"
@@ -254,9 +354,56 @@ class CfgHFSSSetup(CfgSetup):
 
 
 class CfgSetups:
+    class Grpc:
+        def __init__(self, parent):
+            self.parent = parent
+            self._pedb = parent.pedb
+
+        def retrieve_parameters_from_edb(self):
+            self.parent.setups = []
+            for _, setup in self._pedb.setups.items():
+                if setup.type.name.lower() == "hfss":
+                    hfss = CfgHFSSSetup(self._pedb, setup)
+                    hfss.api.retrieve_parameters_from_edb()
+                    self.parent.setups.append(hfss)
+                elif setup.type.name.lower() == "si_wave_dcir":
+                    siwave_dc = CfgSIwaveDCSetup(self._pedb, setup)
+                    siwave_dc.api.retrieve_parameters_from_edb()
+                    self.parent.setups.append(siwave_dc)
+                elif setup.type.name.lower() == "si_wave":
+                    siwave_ac = CfgSIwaveACSetup(self._pedb, setup)
+                    siwave_ac.api.retrieve_parameters_from_edb()
+                    self.parent.setups.append(siwave_ac)
+                elif setup.type.name.lower() == "raptor_x":
+                    pass
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+        def retrieve_parameters_from_edb(self):
+            self.parent.setups = []
+            for _, setup in self._pedb.setups.items():
+                if setup.type == "hfss":
+                    hfss = CfgHFSSSetup(self._pedb, setup)
+                    hfss.api.retrieve_parameters_from_edb()
+                    self.parent.setups.append(hfss)
+                elif setup.type == "siwave_dc":
+                    siwave_dc = CfgSIwaveDCSetup(self._pedb, setup)
+                    siwave_dc.api.retrieve_parameters_from_edb()
+                    self.parent.setups.append(siwave_dc)
+                elif setup.type == "siwave_ac":
+                    siwave_ac = CfgSIwaveACSetup(self._pedb, setup)
+                    siwave_ac.api.retrieve_parameters_from_edb()
+                    self.parent.setups.append(siwave_ac)
+
     def __init__(self, pedb, setups_data):
         self.pedb = pedb
         self.setups = []
+        if self.pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
         for stp in setups_data:
             if stp["type"].lower() == "hfss":
                 self.setups.append(CfgHFSSSetup(self.pedb, None, **stp))
@@ -273,17 +420,4 @@ class CfgSetups:
         return [i.to_dict() for i in self.setups]
 
     def retrieve_parameters_from_edb(self):
-        self.setups = []
-        for _, setup in self.pedb.setups.items():
-            if setup.type == "hfss":
-                hfss = CfgHFSSSetup(self.pedb, setup)
-                hfss.api.retrieve_parameters_from_edb()
-                self.setups.append(hfss)
-            elif setup.type == "siwave_dc":
-                siwave_dc = CfgSIwaveDCSetup(self.pedb, setup)
-                siwave_dc.api.retrieve_parameters_from_edb()
-                self.setups.append(siwave_dc)
-            elif setup.type == "siwave_ac":
-                siwave_ac = CfgSIwaveACSetup(self.pedb, setup)
-                siwave_ac.api.retrieve_parameters_from_edb()
-                self.setups.append(siwave_ac)
+        self.api.retrieve_parameters_from_edb()

pyedb/configuration/cfg_stackup.py

@@ -164,6 +164,50 @@ class CfgStackup:
         def __init__(self, parent):
             super().__init__(parent)
 
+        def __apply_layers(self):
+            """Apply layer settings to the current design"""
+            layers = list()
+            layers.extend(self.parent.layers)
+
+            removal_list = []
+            lc_signal_layers = []
+            for name, obj in self._pedb.stackup.all_layers.items():
+                if obj.type == "dielectric":
+                    removal_list.append(name)
+                elif obj.type == "signal":
+                    lc_signal_layers.append(obj.id)
+            for l in removal_list:
+                self._pedb.stackup.remove_layer(l)
+
+            # update all signal layers
+            id_name = {i[0]: i[1] for i in self._pedb.stackup.layers_by_id}
+            signal_idx = 0
+            for l in layers:
+                if l.type == "signal":
+                    layer_id = lc_signal_layers[signal_idx]
+                    layer_name = id_name[layer_id]
+                    attrs = l.get_attributes()
+                    self._pedb.stackup.layers[layer_name].update(**attrs)
+                    signal_idx = signal_idx + 1
+
+            # add all dielectric layers. Dielectric layers must be added last. Otherwise,
+            # dielectric layer will occupy signal and document layer id.
+            prev_layer_clone = None
+            l = layers.pop(0)
+            if l.type == "signal":
+                prev_layer_clone = self._pedb.stackup.layers[l.name]
+            else:
+                attrs = l.get_attributes()
+                prev_layer_clone = self._pedb.stackup.add_layer_top(**attrs)
+            for idx, l in enumerate(layers):
+                if l.type == "dielectric":
+                    attrs = l.get_attributes()
+                    prev_layer_clone = self._pedb.stackup.add_layer_below(
+                        base_layer_name=prev_layer_clone.name, **attrs
+                    )
+                elif l.type == "signal":
+                    prev_layer_clone = self._pedb.stackup.layers[l.name]
+
     def __init__(self, pedb: Edb, data):
         self._pedb = pedb
         if self._pedb.grpc:

pyedb/configuration/configuration.py

@@ -205,6 +205,8 @@ class Configuration:
                 self.parent.cfg_data.components.retrieve_parameters_from_edb()
                 components = []
                 for i in self.parent.cfg_data.components.components:
+                    if i.type == "io":
+                        components.append(i.get_attributes())
                     components.append(i.get_attributes())
 
                 if kwargs.get("components", False):
@@ -306,6 +308,14 @@ class Configuration:
             file_path = file_path if isinstance(file_path, Path) else Path(file_path)
             file_path = file_path.with_suffix(".json") if file_path.suffix == "" else file_path
 
+            for comp in data["components"]:
+                for key, value in comp.items():
+                    try:
+                        json.dumps(value)
+                        print(f"Key '{key}' is serializable.")
+                    except TypeError as e:
+                        print(f"Key '{key}' failed: {e}")
+
             with open(file_path, "w") as f:
                 if file_path.suffix == ".json":
                     json.dump(data, f, ensure_ascii=False, indent=4)
@@ -472,9 +482,6 @@ class Configuration:
         # Configure package definitions
         self.cfg_data.package_definitions.apply()
 
-        # Configure operations
-        self.cfg_data.operations.apply()
-
         # Modeler
         self.cfg_data.modeler.apply()
 
@@ -484,6 +491,9 @@ class Configuration:
         # Configure probes
         self.cfg_data.probes.apply()
 
+        # Configure operations
+        self.cfg_data.operations.apply()
+
         return True
 
     def _load_stackup(self):

pyedb/dotnet/database/cell/primitive/path.py

@@ -341,6 +341,18 @@ class Path(Primitive):
             polygon_data = self._edb.geometry.polygon_data.dotnetobj(convert_py_list_to_net_list(points), False)
             self._edb_object.SetCenterLine(polygon_data)
 
+    def get_center_line_polygon_data(self):
+        """Gets center lines of the path as a PolygonData object."""
+        edb_object = self._edb_object.GetCenterLine()
+        return self._pedb.pedb_class.database.geometry.polygon_data.PolygonData(self._pedb, edb_object=edb_object)
+
+    def set_center_line_polygon_data(self, polygon_data):
+        """Sets center lines of the path from a PolygonData object."""
+        if not self._edb_object.SetCenterLine(polygon_data._edb_object):
+            raise ValueError
+        else:
+            return True
+
     @property
     def corner_style(self):
         """:class:`PathCornerType`: Path's corner style."""

pyedb/dotnet/database/edb_data/design_options.py

@@ -19,6 +19,7 @@
 # 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 warnings
 
 
 class EdbDesignOptions:
@@ -51,8 +52,25 @@ class EdbDesignOptions:
             ``True`` if antipad is always on, ``False`` otherwise.
 
         """
-        return self._active_cell.GetAntiPadsAlwaysOn()
+        warnings.warn("Use new property :func:`anti_pads_always_on` instead.", DeprecationWarning)
+        return self.anti_pads_always_on
 
     @antipads_always_on.setter
     def antipads_always_on(self, value):
+        self.anti_pads_always_on = value
+
+    @property
+    def anti_pads_always_on(self):
+        """Whether to always turn on antipad.
+
+        Returns
+        -------
+        bool
+            ``True`` if antipad is always on, ``False`` otherwise.
+
+        """
+        return self._active_cell.GetAntiPadsAlwaysOn()
+
+    @anti_pads_always_on.setter
+    def anti_pads_always_on(self, value):
         self._active_cell.SetAntiPadsAlwaysOn(value)

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -35,6 +35,7 @@ from pyedb.dotnet.database.general import (
     snake_to_pascal,
 )
 from pyedb.dotnet.database.geometry.polygon_data import PolygonData
+from pyedb.generic.data_handlers import float_units
 from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
@@ -1958,15 +1959,18 @@ class EDBPadstackInstance(Primitive):
         pad_shape = padstack_pad.geometry_type
         params = padstack_pad.parameters_values
         polygon_data = padstack_pad._polygon_data_dotnet
+        pad_offset = [float_units(padstack_pad.offset_x), float_units(padstack_pad.offset_y)]
 
         def _rotate(p):
             x = p[0] * math.cos(rotation) - p[1] * math.sin(rotation)
             y = p[0] * math.sin(rotation) + p[1] * math.cos(rotation)
             return [x, y]
 
-        def _translate(p):
-            x = p[0] + padstack_center[0]
-            y = p[1] + padstack_center[1]
+        def _translate(p, t=None):
+            if t is None:
+                t = padstack_center
+            x = p[0] + t[0]
+            y = p[1] + t[1]
             return [x, y]
 
         rect = None
@@ -2092,7 +2096,8 @@ class EDBPadstackInstance(Primitive):
 
         if rect is None or len(rect) != 4:
             return False
-        path = self._pedb.modeler.Shape("polygon", points=rect)
+        offset_rect = [_translate(p, _rotate(pad_offset)) for p in rect]
+        path = self._pedb.modeler.Shape("polygon", points=offset_rect)
         pdata = self._pedb.modeler.shape_to_polygon_data(path)
         new_rect = []
         for point in pdata.Points:

pyedb/dotnet/database/geometry/point_data.py

@@ -35,3 +35,29 @@ class PointData:
                 self._pedb.edb_value(x),
                 self._pedb.edb_value(y),
             )
+
+    @property
+    def x(self):
+        """X value of point."""
+        return self._edb_object.X.ToString()
+
+    @x.setter
+    def x(self, value):
+        self._edb_object.X = self._pedb.edb_value(value)
+
+    @property
+    def x_evaluated(self):
+        return self._edb_object.X.ToDouble()
+
+    @property
+    def y(self):
+        """Y value of point."""
+        return self._edb_object.Y.ToString()
+
+    @y.setter
+    def y(self, value):
+        self._edb_object.Y = self._pedb.edb_value(value)
+
+    @property
+    def y_evaluated(self):
+        return self._edb_object.Y.ToDouble()

pyedb/dotnet/database/geometry/polygon_data.py

@@ -89,8 +89,10 @@ class PolygonData:
     def create_from_points(self, points, closed=True):
         list_of_point_data = []
         for pt in points:
-            list_of_point_data.append(PointData(self._pedb, x=pt[0], y=pt[1]))
-        return self._pedb.edb_api.geometry.api_class.PolygonData(list_of_point_data, closed)
+            list_of_point_data.append(PointData(self._pedb, x=pt[0], y=pt[1])._edb_object)
+        return self._pedb.edb_api.geometry.api_class.PolygonData(
+            convert_py_list_to_net_list(list_of_point_data), closed
+        )
 
     def create_from_bounding_box(self, points):
         bbox = BBox(self._pedb, point_1=points[0], point_2=points[1])
@@ -133,3 +135,12 @@ class PolygonData:
     def point_in_polygon(self, x: Union[str, float], y: Union[str, float]) -> bool:
         """Determines whether a point is inside the polygon."""
         return self._edb_object.PointInPolygon(self._pedb.point_data(x, y))
+
+    def get_point(self, index):
+        """Gets the point at the index as a PointData object."""
+        edb_object = self._edb_object.GetPoint(index)
+        return self._pedb.pedb_class.database.geometry.point_data.PointData(self._pedb, edb_object)
+
+    def set_point(self, index, point_data):
+        """Sets the point at the index from a PointData object."""
+        self._edb_object.SetPoint(index, point_data)

pyedb/dotnet/database/nets.py

@@ -308,11 +308,21 @@ class EdbNets(CommonNets):
                 val_value = cmp.rlc_values
                 if refdes in exception_list:
                     pass
-                elif val_type == "Inductor" and val_value[1] < inductor_below:
+                elif (
+                    val_type == "Inductor"
+                    and self._pedb.edb_value(val_value[1]).ToDouble() <= self._pedb.edb_value(inductor_below).ToDouble()
+                ):
                     pass
-                elif val_type == "Resistor" and val_value[0] < resistor_below:
+                elif (
+                    val_type == "Resistor"
+                    and self._pedb.edb_value(val_value[0]).ToDouble() <= self._pedb.edb_value(resistor_below).ToDouble()
+                ):
                     pass
-                elif val_type == "Capacitor" and val_value[2] > capacitor_above:
+                elif (
+                    val_type == "Capacitor"
+                    and self._pedb.edb_value(val_value[2]).ToDouble()
+                    >= self._pedb.edb_value(capacitor_above).ToDouble()
+                ):
                     pass
                 else:
                     continue

pyedb/dotnet/database/padstack.py

@@ -1153,7 +1153,7 @@ class EdbPadstacks(object):
             Name of the net. The default is ``""``.
         via_name : str, optional
             The default is ``""``.
-        rotation : float, optional
+        rotation : float, str, optional
             Rotation of the padstack in degrees. The default
             is ``0``.
         fromlayer :
@@ -1175,7 +1175,11 @@ class EdbPadstacks(object):
                 padstack = self.definitions[pad].edb_padstack
         position = self._edb.geometry.point_data(position[0], position[1])
         net = self._pedb.nets.find_or_create_net(net_name)
-        rotation = self._get_edb_value(rotation * math.pi / 180)
+        rotation = (
+            self._get_edb_value(rotation * math.pi / 180)
+            if not isinstance(rotation, str)
+            else self._get_edb_value(rotation)
+        )
         sign_layers_values = {i: v for i, v in self._pedb.stackup.signal_layers.items()}
         sign_layers = list(sign_layers_values.keys())
         if not fromlayer:

pyedb/dotnet/database/utilities/simulation_setup.py

@@ -96,8 +96,6 @@ class SimulationSetup(object):
         if self._edb_object:
             self._name = self._edb_object.GetName()
 
-        self._sweep_list = {}
-
     @property
     def sim_setup_info(self):
         return SimSetupInfo(self._pedb, sim_setup=self, edb_object=self._edb_object.GetSimSetupInfo())
@@ -239,7 +237,7 @@ class SimulationSetup(object):
         """List of frequency sweeps."""
         return {i.name: i for i in self.sim_setup_info.sweep_data_list}
 
-    def add_sweep(self, name, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
+    def add_sweep(self, name: str = None, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
         """Add frequency sweep.
 
         Parameters
@@ -292,15 +290,7 @@ class SimulationSetup(object):
         sweep_data: SweepData
         """
         warnings.warn("Use new property :func:`add_sweep_data` instead.", DeprecationWarning)
-        self._sweep_list[sweep_data.name] = sweep_data
-        edb_setup_info = self.sim_setup_info
-
-        if self._setup_type in ["kSIwave", "kHFSS", "kRaptorX", "kHFSSPI"]:
-            for _, v in self._sweep_list.items():
-                edb_setup_info.SweepDataList.Add(v._edb_object)
-
-        self._edb_object = self._set_edb_setup_info(edb_setup_info)
-        self._update_setup()
+        return self.sim_setup_info.add_sweep_data(sweep_data)
 
     def delete_frequency_sweep(self, sweep_data):
         """Delete a frequency sweep.
@@ -310,17 +300,17 @@ class SimulationSetup(object):
             sweep_data : EdbFrequencySweep.
         """
         name = sweep_data.name
-        if name in self._sweep_list:
-            self._sweep_list.pop(name)
+        if name in self.sweeps:
+            self.sweeps.pop(name)
 
         fsweep = []
-        if self.frequency_sweeps:
-            fsweep = [val for key, val in self.frequency_sweeps.items() if not key == name]
+        if self.sweeps:
+            fsweep = [val for key, val in self.sweeps.items() if not key == name]
             self.sim_setup_info._edb_object.SweepDataList.Clear()
             for i in fsweep:
                 self.sim_setup_info._edb_object.SweepDataList.Add(i._edb_object)
             self._update_setup()
-            return True if name in self.frequency_sweeps else False
+            return False if name in self.sweeps else True
 
     def add_frequency_sweep(self, name=None, frequency_sweep=None):
         """Add frequency sweep.

pyedb/dotnet/database/utilities/siwave_simulation_setup.py

@@ -95,6 +95,8 @@ class SiwaveSimulationSetup(SimulationSetup):
             self._edb_object = self._simulation_setup_builder(sim_setup_info._edb_object)
             self._update_setup()
 
+        self._siwave_sweeps_list = []
+
     def create(self, name=None):
         """Create a SIwave SYZ setup.
 
@@ -248,6 +250,34 @@ class SiwaveSimulationSetup(SimulationSetup):
         self._edb_object = self._set_edb_setup_info(edb_setup_info)
         self._update_setup()
 
+    def add_sweep(self, name: str = None, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
+        """Add frequency sweep.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the frequency sweep. The default is ``None``.
+        frequency_set : list, optional
+            List of frequency points. The default is ``None``.
+        sweep_type : str, optional
+            Sweep type. The default is ``"interpolation"``. Options are ``"discrete"``,"discrete"``.
+        Returns
+        -------
+
+        Examples
+        --------
+        >>> setup1 = edbapp.create_siwave_syz_setup("setup1")
+        >>> setup1.add_sweep(name="sw1", frequency_set=["linear count", "1MHz", "100MHz", 10])
+        """
+        sweep_data = SimulationSetup.add_sweep(self, name, frequency_set, sweep_type, **kwargs)
+        self._siwave_sweeps_list.append(sweep_data)
+        return sweep_data
+
+    @property
+    def sweeps(self):
+        """List of frequency sweeps."""
+        return {i.name: i for i in self._siwave_sweeps_list}
+
 
 class SiwaveDCSimulationSetup(SimulationSetup):
     """Manages EDB methods for SIwave DC simulation setup."""