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

pyedb/configuration/cfg_ports_sources.py

@@ -33,9 +33,33 @@ from pyedb.dotnet.database.geometry.point_data import PointData
 class CfgTerminalInfo(CfgBase):
     CFG_TERMINAL_TYPES = ["pin", "net", "pin_group", "nearest_pin", "coordinates"]
 
+    class Grpc:
+        def __init__(self, parent):
+            self.parent = parent
+            self._pedb = parent._pedb
+
+        def update_contact_radius(self, radius):
+            from ansys.edb.core.utility.value import Value as GrpcValue
+
+            self.parent.contact_radius = GrpcValue(radius).value
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+        def update_contact_radius(self, radius):
+            self.parent.contact_radius = self._pedb.edb_value(radius).ToDouble()
+
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        if "pin" in kwargs:
+        if self._pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
+
+        if kwargs.get("padstack"):
+            self.type = "padstack"
+        elif "pin" in kwargs:
             self.type = "pin"
         elif "net" in kwargs:
             self.type = "net"
@@ -52,7 +76,7 @@ class CfgTerminalInfo(CfgBase):
 
         self.contact_type = kwargs.get("contact_type", "default")  # options are full, center, quad, inline
         contact_radius = "0.1mm" if kwargs.get("contact_radius") is None else kwargs.get("contact_radius")
-        self.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
+        self.api.update_contact_radius(contact_radius)
         self.num_of_contact = kwargs.get("num_of_contact", 4)
         self.contact_expansion = kwargs.get("contact_expansion", 1)
 
@@ -60,7 +84,7 @@ class CfgTerminalInfo(CfgBase):
         return {self.type: self.value}
 
 
-class CfgCoordianteTerminalInfo(CfgTerminalInfo):
+class CfgCoordinateTerminalInfo(CfgTerminalInfo):
     def __init__(self, pedb, **kwargs):
         super().__init__(pedb, **kwargs)
 
@@ -108,14 +132,14 @@ class CfgSources:
                 pos_term_info = {"pin_group": pg.name}
             elif src.terminal_type == "PadstackInstanceTerminal":
                 refdes = src.component.refdes if src.component else ""
-                pos_term_info = {"pin": src.padstack_instance.component_pin}
+                pos_term_info = {"padstack": src.padstack_instance.aedt_name}
 
             neg_term = self._pedb.terminals[src.ref_terminal.name]
             if neg_term.terminal_type == "PinGroupTerminal":
                 pg = self._pedb.siwave.pin_groups[neg_term._edb_object.GetPinGroup().GetName()]
                 neg_term_info = {"pin_group": pg.name}
             elif neg_term.terminal_type == "PadstackInstanceTerminal":
-                neg_term_info = {"pin": neg_term.padstack_instance.component_pin}
+                neg_term_info = {"padstack": neg_term.padstack_instance.aedt_name}
 
             cfg_src = CfgSource(
                 self._pedb,
@@ -137,9 +161,30 @@ class CfgSources:
 
 
 class CfgPorts:
+    class Grpc:
+        def __init__(self, parent):
+            self.parent = parent
+            self._pedb = parent._pedb
+
+        def get_pin_group(self, port):
+            return self._pedb.siwave.pin_groups[port._edb_object.pin_group.name]
+
+        def get_edge_info(self, port):
+            return port._edb_object.GetEdges()[0].GetParameters()
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+        def get_pin_group(self, port):
+            return self._pedb.siwave.pin_groups[port._edb_object.GetPinGroup().GetName()]
+
     def __init__(self, pedb, ports_data):
         self._pedb = pedb
-
+        if self._pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
         self.ports = []
         for p in ports_data:
             if p["type"] == "wave_port":
@@ -156,6 +201,9 @@ class CfgPorts:
         for i in self._pedb.layout.primitives:
             if i.aedt_name:
                 edb_primitives[i.aedt_name] = i
+        for i in self._pedb.layout.padstack_instances:
+            if i.aedt_name:
+                edb_primitives[i.aedt_name] = i
         for p in self.ports:
             if p.type in ["wave_port", "diff_wave_port"]:
                 p.set_parameters_to_edb(edb_primitives)
@@ -171,6 +219,8 @@ class CfgPorts:
             if not p.ref_terminal:
                 if p.terminal_type == "PadstackInstanceTerminal":
                     port_type = "coax"
+                elif p.terminal_type == "PinGroupTerminal":
+                    port_type = "circuit"
                 elif p.hfss_type == "Wave":
                     port_type = "wave_port"
                 else:
@@ -180,11 +230,11 @@ class CfgPorts:
 
             if p.terminal_type == "PinGroupTerminal":
                 refdes = ""
-                pg = self._pedb.siwave.pin_groups[p._edb_object.GetPinGroup().GetName()]
+                pg = self.api.get_pin_group(p)
                 pos_term_info = {"pin_group": pg.name}
             elif p.terminal_type == "PadstackInstanceTerminal":
                 refdes = p.component.refdes if p.component else ""
-                pos_term_info = {"pin": p.padstack_instance.component_pin}
+                pos_term_info = {"padstack": p.padstack_instance.aedt_name}
             elif p.terminal_type == "PointTerminal":
                 refdes = ""
                 pos_term_info = {"coordinates": {"layer": p.layer.name, "point": p.location, "net": p.net.name}}
@@ -192,10 +242,11 @@ class CfgPorts:
             if port_type == "circuit":
                 neg_term = self._pedb.terminals[p.ref_terminal.name]
                 if neg_term.terminal_type == "PinGroupTerminal":
-                    pg = self._pedb.siwave.pin_groups[neg_term._edb_object.GetPinGroup().GetName()]
+                    pg = self.api.get_pin_group(neg_term)
+                    # pg = self._pedb.siwave.pin_groups[neg_term._edb_object.GetPinGroup().GetName()]
                     neg_term_info = {"pin_group": pg.name}
                 elif neg_term.terminal_type == "PadstackInstanceTerminal":
-                    neg_term_info = {"pin": neg_term.padstack_instance.component_pin}
+                    neg_term_info = {"padstack": neg_term.padstack_instance.aedt_name}
                 elif neg_term.terminal_type == "PointTerminal":
                     neg_term_info = {
                         "coordinates": {
@@ -269,7 +320,7 @@ class CfgCircuitElement(CfgBase):
 
         pos = kwargs["positive_terminal"]  # {"pin" : "A1"}
         if list(pos.keys())[0] == "coordinates":
-            self.positive_terminal_info = CfgCoordianteTerminalInfo(self._pedb, **pos)
+            self.positive_terminal_info = CfgCoordinateTerminalInfo(self._pedb, **pos)
         else:
             self.positive_terminal_info = CfgTerminalInfo(self._pedb, **pos)
             if not self.positive_terminal_info.reference_designator:
@@ -279,7 +330,7 @@ class CfgCircuitElement(CfgBase):
         if len(neg) == 0:
             self.negative_terminal_info = None
         elif list(neg.keys())[0] == "coordinates":
-            self.negative_terminal_info = CfgCoordianteTerminalInfo(self._pedb, **neg)
+            self.negative_terminal_info = CfgCoordinateTerminalInfo(self._pedb, **neg)
         elif list(neg.keys())[0] == "nearest_pin":
             self.negative_terminal_info = CfgNearestPinTerminalInfo(self._pedb, **neg)
         else:
@@ -306,6 +357,11 @@ class CfgCircuitElement(CfgBase):
                 self._pedb.nets.find_or_create_net(net_name)
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
 
+        elif pos_type == "padstack":
+            for pds in self._pedb.layout.padstack_instances:
+                if pds.aedt_name == pos_value:
+                    pos_objs.update({pos_value: pds})
+                    break
         elif pos_type == "pin":
             pins = {
                 pos_value: self._pedb.components.instances[self.positive_terminal_info.reference_designator].pins[
@@ -403,6 +459,11 @@ class CfgCircuitElement(CfgBase):
                     )  # terminal type pin or net
                     # create pin group
                     neg_obj = self._create_pin_group(pins, self.negative_terminal_info.reference_designator, True)
+                elif neg_type == "padstack":
+                    for pds in self._pedb.layout.padstack_instances:
+                        if pds.aedt_name == neg_value:
+                            neg_obj = {neg_value: pds}
+                            break
                 elif neg_type == "pin":
                     terminal_name = f"{self.negative_terminal_info.reference_designator}_{neg_value}"
                     neg_obj = {
@@ -412,9 +473,8 @@ class CfgCircuitElement(CfgBase):
                     }
                 else:
                     raise Exception(f"Wrong negative terminal type {neg_type}.")
-                self.neg_terminal = [
-                    j.create_terminal(i) if not j.terminal else j.terminal for i, j in neg_obj.items()
-                ][0]
+                neg_term = [j.create_terminal(i) if not j.terminal else j.terminal for i, j in neg_obj.items()][0]
+                self.neg_terminal = neg_term
 
     def _get_pins(self, terminal_type, terminal_value, reference_designator):
         terminal_value = terminal_value if isinstance(terminal_value, list) else [terminal_value]

pyedb/configuration/cfg_s_parameter_models.py

@@ -125,6 +125,36 @@ class CfgSParameters:
         def __init__(self, parent):
             super().__init__(parent)
 
+        def apply(self):
+            for s_param in self.parent.s_parameters_models:
+                fpath = s_param.file_path
+                if not Path(fpath).anchor:
+                    fpath = str(Path(self.parent.path_libraries) / fpath)
+                comp_def = self._pedb.definitions.component[s_param.component_definition]
+                if s_param.pin_order:
+                    comp_def.set_properties(pin_order=s_param.pin_order)
+                comp_def.add_n_port_model(fpath, s_param.name)
+                comp_list = dict()
+                if s_param.apply_to_all:
+                    comp_list.update(
+                        {
+                            refdes: comp
+                            for refdes, comp in comp_def.components.items()
+                            if refdes not in s_param.components
+                        }
+                    )
+                else:
+                    comp_list.update(
+                        {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
+                    )
+
+                for refdes, comp in comp_list.items():
+                    if refdes in s_param.reference_net_per_component:
+                        ref_net = s_param.reference_net_per_component[refdes]
+                    else:
+                        ref_net = s_param.reference_net
+                    comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
+
     def __init__(self, pedb, data, path_lib=None):
         self._pedb = pedb
         if self._pedb.grpc:

pyedb/configuration/cfg_setup.py

@@ -148,9 +148,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["export_dc_thermal_data"]
 
         def retrieve_parameters_from_edb(self):
             self._retrieve_parameters_from_edb_common()
@@ -163,6 +162,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["export_dc_thermal_data"]
+
     def __init__(self, pedb, pyedb_obj, **kwargs):
         super().__init__(pedb, pyedb_obj, **kwargs)
         self.type = "siwave_dc"
@@ -202,6 +209,42 @@ 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 = []
+            for sw in self.pyedb_obj.sweep_data:
+                self.parent.freq_sweep.append({"name": sw.name, "type": sw.type, "frequencies": sw.frequency_string})
+
+            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,
+                    }
+                )
+
+    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 +269,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 +293,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 +359,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/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/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])

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."""

pyedb/grpc/database/components.py

@@ -2280,7 +2280,7 @@ class Components(object):
                 if not pin.net.is_null:
                     if pin.net.name:
                         pingroup.net = pin.net
-                        return group_name
+                        return group_name, PinGroup(self._pedb, pingroup)
         return False
 
     def create_pin_group_on_net(self, reference_designator, net_name, group_name=None):