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

pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.44.0"
+__version__ = "0.45.0"
 version = __version__
 
 #

pyedb/configuration/cfg_boundaries.py

@@ -79,7 +79,7 @@ class CfgBoundaries(CfgBase):
             if self.air_box_horizontal_padding:
                 self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent = float(self.air_box_horizontal_padding)
             if self.air_box_positive_vertical_padding:
-                self._pedb.hfss.hfss_extent_info.parentair_box_positive_vertical_extent = float(
+                self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent = float(
                     self.air_box_positive_vertical_padding
                 )
             if self.air_box_negative_vertical_padding:

pyedb/configuration/cfg_components.py

@@ -136,9 +136,9 @@ class CfgComponent(CfgBase):
             die_type = pascal_to_snake(ic_die_prop.die_type.name)
             temp["type"] = die_type
             if not die_type == "no_die":
-                temp["orientation"] = pascal_to_snake(ic_die_prop.die_orientation.name)
+                temp["orientation"] = ic_die_prop.die_orientation.name.lower()
                 if die_type == "wire_bond":
-                    temp["height"] = ic_die_prop.height.value
+                    temp["height"] = str(ic_die_prop.height.value)
 
             self.parent.ic_die_properties = temp
 
@@ -183,10 +183,10 @@ class CfgComponent(CfgBase):
                 uses_solder_ball = solder_ball_prop.uses_solderball
 
                 temp["uses_solder_ball"] = uses_solder_ball
-                temp["shape"] = pascal_to_snake(shape)
-                temp["diameter"] = diam
-                temp["mid_diameter"] = mid_diam
-                temp["height"] = height
+                temp["shape"] = shape.lower()
+                temp["diameter"] = str(diam)
+                temp["mid_diameter"] = str(mid_diam)
+                temp["height"] = str(height)
                 temp["material"] = material
 
                 self.parent.solder_ball_properties = temp
@@ -495,7 +495,7 @@ class CfgComponent(CfgBase):
 
         self.port_properties = kwargs.get("port_properties", {})
         self.solder_ball_properties = kwargs.get("solder_ball_properties", {})
-        self.ic_die_properties = kwargs.get("ic_die_properties", {})
+        self.ic_die_properties = kwargs.get("ic_die_properties", {"type": "no_die"})
         self.pin_pair_model = kwargs.get("pin_pair_model", [])
         self.spice_model = kwargs.get("spice_model", {})
         self.s_parameter_model = kwargs.get("s_parameter_model", {})

pyedb/configuration/cfg_general.py

@@ -34,8 +34,8 @@ class CfgGeneral:
             self.pedb.active_cell.suppress_pads = self.parent.suppress_pads
 
         def get_parameters_from_edb(self):
-            anti_pads_always_on = self.pedb.design_options.antipads_always_on
-            suppress_pads = self.pedb.design_options.suppress_pads
+            anti_pads_always_on = self.pedb.active_cell.anti_pads_always_on
+            suppress_pads = self.pedb.active_cell.suppress_pads
             data = {"anti_pads_always_on": anti_pads_always_on, "suppress_pads": suppress_pads}
             return data
 
@@ -49,6 +49,12 @@ class CfgGeneral:
             if self.parent.suppress_pads is not None:
                 self.pedb.design_options.suppress_pads = self.parent.suppress_pads
 
+        def get_parameters_from_edb(self):
+            anti_pads_always_on = self.pedb.design_options.antipads_always_on
+            suppress_pads = self.pedb.design_options.suppress_pads
+            data = {"anti_pads_always_on": anti_pads_always_on, "suppress_pads": suppress_pads}
+            return data
+
     def __init__(self, pedb, data):
         self.pedb = pedb
         if self.pedb.grpc:

pyedb/configuration/cfg_modeler.py

@@ -141,6 +141,11 @@ class CfgModeler:
                     c.pyedb_obj = obj
                     c.api.set_parameters_to_edb()
 
+        def delete_primitives(self):
+            primitives = self._pedb.layout.find_primitive(**self.parent.primitives_to_delete)
+            for i in primitives:
+                i.delete()
+
     class DotNet(Grpc):
         def __init__(self, parent):
             super().__init__(parent)
@@ -230,6 +235,8 @@ class CfgModeler:
         ]
         self.planes = [CfgPlane(**i) for i in data.get("planes", [])]
         self.components = [CfgComponent(self._pedb, None, **i) for i in data.get("components", [])]
+        self.primitives_to_delete = data.get("primitives_to_delete", {"layer_name": [], "name": [], "net_name": []})
 
     def apply(self):
         self.api.set_parameter_to_edb()
+        self.api.delete_primitives()

pyedb/configuration/cfg_operations.py

@@ -56,6 +56,9 @@ class CfgCutout(CfgBase):
             self.api = self.Grpc(self)
         else:
             self.api = self.DotNet(self)
+        self.auto_identify_nets = kwargs.get(
+            "auto_identify_nets", {"enabled": False, "resistor_below": 100, "inductor_below": 1, "capacitor_above": 1}
+        )
         self.signal_list = kwargs.get("signal_list")
         self.reference_list = kwargs.get("reference_list")
         self.extent_type = kwargs.get("extent_type")
@@ -99,7 +102,43 @@ class CfgOperations(CfgBase):
 
         def apply_on_edb(self):
             if self.parent.op_cutout:
-                polygon_points = self._pedb.cutout(**self.parent.op_cutout.get_attributes())
+                cutout_params = self.parent.op_cutout.get_attributes()
+                auto_identify_nets = cutout_params.pop("auto_identify_nets")
+                if auto_identify_nets["enabled"]:
+                    reference_list = cutout_params.get("reference_list", [])
+                    if auto_identify_nets:
+                        self._pedb.nets.generate_extended_nets(
+                            auto_identify_nets["resistor_below"],
+                            auto_identify_nets["inductor_below"],
+                            auto_identify_nets["capacitor_above"],
+                            auto_identify_nets.get("exception_list", []),
+                        )
+                        signal_nets = []
+                        for i in self._pedb.ports.values():
+                            # Positive terminal
+                            extended_net = i.net.extended_net
+                            if extended_net:
+                                temp = [i2 for i2 in extended_net.nets.keys() if i2 not in reference_list]
+                                temp = [i2 for i2 in temp if i2 not in signal_nets]
+                                signal_nets.extend(temp)
+                            else:
+                                signal_nets.append(i.net.name)
+
+                            # Negative terminal
+                            ref_net = i.ref_terminal.net if i.ref_terminal else None
+                            if ref_net is None:
+                                continue
+                            elif ref_net.name not in reference_list:
+                                extended_net = ref_net.extended_net
+                                if extended_net:
+                                    temp = [i2 for i2 in extended_net.nets.keys() if i2 not in reference_list]
+                                    temp = [i2 for i2 in temp if i2 not in signal_nets]
+                                    signal_nets.extend(temp)
+                                else:
+                                    signal_nets.append(ref_net.name)
+
+                        cutout_params["signal_list"] = signal_nets
+                polygon_points = self._pedb.cutout(**cutout_params)
                 if "pyedb_cutout" not in self._pedb.stackup.all_layers:
                     self._pedb.stackup.add_document_layer(name="pyedb_cutout")
                     self._pedb.modeler.create_polygon(

pyedb/configuration/cfg_pin_groups.py

@@ -40,7 +40,7 @@ class CfgPinGroups:
             layout_pin_groups = self._pedb.siwave.pin_groups
             for pg_name, pg_obj in layout_pin_groups.items():
                 if self._pedb.grpc:
-                    pins = pg_obj.pins
+                    pins = list(pg_obj.pins.values())
                     refdes = pins[0].component.name
                     cfg_pg = CfgPinGroup(
                         self._pedb,

pyedb/configuration/cfg_ports_sources.py

@@ -108,8 +108,27 @@ class CfgNearestPinTerminalInfo(CfgTerminalInfo):
 
 
 class CfgSources:
+    class Grpc:
+        def __init__(self, parent):
+            self.parent = parent
+            self._pedb = parent._pedb
+
+        def get_pin_group_name(self, src):
+            return src.pin_group.name
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+        def get_pin_group_name(self, src):
+            return src._edb_object.GetPinGroup().GetName()
+
     def __init__(self, pedb, sources_data):
         self._pedb = pedb
+        if self._pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
         self.sources = [CfgSource(self._pedb, **src) for src in sources_data]
 
     def apply(self):
@@ -128,7 +147,7 @@ class CfgSources:
 
             if src.terminal_type == "PinGroupTerminal":
                 refdes = ""
-                pg = self._pedb.siwave.pin_groups[src._edb_object.GetPinGroup().GetName()]
+                pg = self._pedb.siwave.pin_groups[self.api.get_pin_group_name(src)]
                 pos_term_info = {"pin_group": pg.name}
             elif src.terminal_type == "PadstackInstanceTerminal":
                 refdes = src.component.refdes if src.component else ""
@@ -136,7 +155,7 @@ class CfgSources:
 
             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()]
+                pg = self._pedb.siwave.pin_groups[self.api.get_pin_group_name(neg_term)]
                 neg_term_info = {"pin_group": pg.name}
             elif neg_term.terminal_type == "PadstackInstanceTerminal":
                 neg_term_info = {"padstack": neg_term.padstack_instance.aedt_name}
@@ -172,6 +191,26 @@ class CfgPorts:
         def get_edge_info(self, port):
             return port._edb_object.GetEdges()[0].GetParameters()
 
+        def _get_edge_port_from_edb(self, p, port_type):
+            # primitive, point = p._edb_object.GetEdges()[0].GetParameters()
+            edges = p.edges
+            primitive = None
+            point = None
+            primitive = Primitive(self._pedb, primitive)
+            point = PointData(self._pedb, point)
+
+            cfg_port = CfgEdgePort(
+                self._pedb,
+                name=p.name,
+                type=port_type,
+                primitive_name=primitive.aedt_name,
+                point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
+                horizontal_extent_factor=p.horizontal_extent_factor,
+                vertical_extent_factor=p.vertical_extent_factor,
+                pec_launch_width=p.pec_launch_width,
+            )
+            return cfg_port
+
     class DotNet(Grpc):
         def __init__(self, parent):
             super().__init__(parent)
@@ -179,6 +218,24 @@ class CfgPorts:
         def get_pin_group(self, port):
             return self._pedb.siwave.pin_groups[port._edb_object.GetPinGroup().GetName()]
 
+        def _get_edge_port_from_edb(self, p, port_type):
+            _, primitive, point = p._edb_object.GetEdges()[0].GetParameters()
+
+            primitive = Primitive(self._pedb, primitive)
+            point = PointData(self._pedb, point)
+
+            cfg_port = CfgEdgePort(
+                self._pedb,
+                name=p.name,
+                type=port_type,
+                primitive_name=primitive.aedt_name,
+                point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
+                horizontal_extent_factor=p.horizontal_extent_factor,
+                vertical_extent_factor=p.vertical_extent_factor,
+                pec_launch_width=p.pec_launch_width,
+            )
+            return cfg_port
+
     def __init__(self, pedb, ports_data):
         self._pedb = pedb
         if self._pedb.grpc:
@@ -189,6 +246,8 @@ class CfgPorts:
         for p in ports_data:
             if p["type"] == "wave_port":
                 self.ports.append(CfgEdgePort(self._pedb, **p))
+            elif p["type"] == "gap_port":
+                self.ports.append(CfgEdgePort(self._pedb, **p))
             elif p["type"] == "diff_wave_port":
                 self.ports.append(CfgDiffWavePort(self._pedb, **p))
             elif p["type"] in ["coax", "circuit"]:
@@ -205,7 +264,7 @@ class CfgPorts:
             if i.aedt_name:
                 edb_primitives[i.aedt_name] = i
         for p in self.ports:
-            if p.type in ["wave_port", "diff_wave_port"]:
+            if p.type in ["wave_port", "diff_wave_port", "gap_port"]:
                 p.set_parameters_to_edb(edb_primitives)
             else:
                 p.set_parameters_to_edb()
@@ -221,10 +280,10 @@ class CfgPorts:
                     port_type = "coax"
                 elif p.terminal_type == "PinGroupTerminal":
                     port_type = "circuit"
-                elif p.hfss_type == "Wave":
-                    port_type = "wave_port"
+                elif p.terminal_type == "EdgeTerminal":
+                    port_type = "wave_port" if p.hfss_type == "Wave" else "gap_port"
                 else:
-                    port_type = "gap_port"
+                    raise ValueError("Unknown terminal type")
             else:
                 port_type = "circuit"
 
@@ -273,22 +332,7 @@ class CfgPorts:
                     positive_terminal=pos_term_info,
                 )
             else:
-                _, primitive, point = p._edb_object.GetEdges()[0].GetParameters()
-
-                primitive = Primitive(self._pedb, primitive)
-                point = PointData(self._pedb, point)
-
-                cfg_port = CfgEdgePort(
-                    self._pedb,
-                    name=p.name,
-                    type=port_type,
-                    primitive_name=primitive.aedt_name,
-                    point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
-                    horizontal_extent_factor=p.horizontal_extent_factor,
-                    vertical_extent_factor=p.vertical_extent_factor,
-                    pec_launch_width=p.pec_launch_width,
-                )
-
+                cfg_port = self.api._get_edge_port_from_edb(p, port_type)
             self.ports.append(cfg_port)
         return self.export_properties()
 
@@ -723,8 +767,99 @@ class CfgProbe(CfgCircuitElement):
 
 
 class CfgEdgePort:
+    class Grpc:
+        def __init__(self, parent):
+            self.parent = parent
+            self._pedb = parent._pedb
+
+        def set_parameters_to_edb(self, edb_primitives):
+            from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
+            from ansys.edb.core.terminal.edge_terminal import (
+                EdgeTerminal as GrpcEdgeTerminal,
+            )
+            from ansys.edb.core.terminal.edge_terminal import (
+                PrimitiveEdge as GrpcPrimitiveEdge,
+            )
+            from ansys.edb.core.utility.value import Value as GrpcValue
+
+            from pyedb.grpc.database.ports.ports import WavePort
+
+            point_on_edge = GrpcPointData(self.parent.point_on_edge)
+            primitive = edb_primitives[self.parent.primitive_name]
+            pos_edge = GrpcPrimitiveEdge.create(primitive, point_on_edge)
+            edge_term = GrpcEdgeTerminal.create(
+                layout=primitive.layout, name=self.parent.name, net=primitive.net, edges=[pos_edge], is_ref=False
+            )
+            edge_term.impedance = GrpcValue(50)
+            wave_port = WavePort(self._pedb, edge_term)
+            wave_port.horizontal_extent_factor = self.parent.horizontal_extent_factor
+            wave_port.vertical_extent_factor = self.parent.vertical_extent_factor
+            wave_port.pec_launch_width = self.parent.pec_launch_width
+            if self.parent.type == "wave_port":
+                wave_port.hfss_type = "Wave"
+            else:
+                wave_port.hfss_type = "Gap"
+            wave_port.do_renormalize = True
+            return wave_port
+
+        def export_properties(self):
+            return {
+                "name": self.name,
+                "type": self.type,
+                "primitive_name": self.primitive_name,
+                "point_on_edge": self.point_on_edge,
+                "horizontal_extent_factor": self.horizontal_extent_factor,
+                "vertical_extent_factor": self.vertical_extent_factor,
+                "pec_launch_width": self.pec_launch_width,
+            }
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+        def set_parameters_to_edb(self, edb_primitives):
+            point_on_edge = PointData(self._pedb, x=self.parent.point_on_edge[0], y=self.parent.point_on_edge[1])
+            primitive = edb_primitives[self.parent.primitive_name]
+            pos_edge = self._pedb.edb_api.cell.terminal.PrimitiveEdge.Create(
+                primitive._edb_object, point_on_edge._edb_object
+            )
+            pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.edb_api.cell.terminal.Edge)
+            edge_term = self._pedb.edb_api.cell.terminal.EdgeTerminal.Create(
+                primitive._edb_object.GetLayout(),
+                primitive._edb_object.GetNet(),
+                self.parent.name,
+                pos_edge,
+                isRef=False,
+            )
+            edge_term.SetImpedance(self._pedb.edb_value(50))
+            wave_port = WavePort(self._pedb, edge_term)
+            wave_port.horizontal_extent_factor = self.parent.horizontal_extent_factor
+            wave_port.vertical_extent_factor = self.parent.vertical_extent_factor
+            wave_port.pec_launch_width = self.parent.pec_launch_width
+            if self.parent.type == "wave_port":
+                wave_port.hfss_type = "Wave"
+            else:
+                wave_port.hfss_type = "Gap"
+            wave_port.do_renormalize = True
+            return wave_port
+
+        def export_properties(self):
+            return {
+                "name": self.parent.name,
+                "type": self.parent.type,
+                "primitive_name": self.parent.primitive_name,
+                "point_on_edge": self.parent.point_on_edge,
+                "horizontal_extent_factor": self.parent.horizontal_extent_factor,
+                "vertical_extent_factor": self.parent.vertical_extent_factor,
+                "pec_launch_width": self.parent.pec_launch_width,
+            }
+
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
+        if self._pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
         self.name = kwargs["name"]
         self.type = kwargs["type"]
         self.primitive_name = kwargs["primitive_name"]
@@ -734,37 +869,10 @@ class CfgEdgePort:
         self.pec_launch_width = kwargs.get("pec_launch_width", "0.01mm")
 
     def set_parameters_to_edb(self, edb_primitives):
-        point_on_edge = PointData(self._pedb, x=self.point_on_edge[0], y=self.point_on_edge[1])
-        primitive = edb_primitives[self.primitive_name]
-        pos_edge = self._pedb.edb_api.cell.terminal.PrimitiveEdge.Create(
-            primitive._edb_object, point_on_edge._edb_object
-        )
-        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.edb_api.cell.terminal.Edge)
-        edge_term = self._pedb.edb_api.cell.terminal.EdgeTerminal.Create(
-            primitive._edb_object.GetLayout(), primitive._edb_object.GetNet(), self.name, pos_edge, isRef=False
-        )
-        edge_term.SetImpedance(self._pedb.edb_value(50))
-        wave_port = WavePort(self._pedb, edge_term)
-        wave_port.horizontal_extent_factor = self.horizontal_extent_factor
-        wave_port.vertical_extent_factor = self.vertical_extent_factor
-        wave_port.pec_launch_width = self.pec_launch_width
-        if self.type == "wave_port":
-            wave_port.hfss_type = "Wave"
-        else:
-            wave_port.hfss_type = "Gap"
-        wave_port.do_renormalize = True
-        return wave_port
+        return self.api.set_parameters_to_edb(edb_primitives)
 
     def export_properties(self):
-        return {
-            "name": self.name,
-            "type": self.type,
-            "primitive_name": self.primitive_name,
-            "point_on_edge": self.point_on_edge,
-            "horizontal_extent_factor": self.horizontal_extent_factor,
-            "vertical_extent_factor": self.vertical_extent_factor,
-            "pec_launch_width": self.pec_launch_width,
-        }
+        return self.api.export_properties()
 
 
 class CfgDiffWavePort:

pyedb/configuration/cfg_s_parameter_models.py

@@ -80,7 +80,7 @@ class CfgSParameters:
                 else:
                     pin_order = compdef_obj.get_properties()["pin_order"]
                     temp_comps = [i for i in cfg_components if i["definition"] == name]
-                    for model_name, model_obj in nport_models.items():
+                    for model_obj in nport_models:
                         temp_comp_list = []
                         reference_net_per_component = {}
                         for i in temp_comps:
@@ -155,6 +155,56 @@ class CfgSParameters:
                         ref_net = s_param.reference_net
                     comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
 
+        def get_data_from_db(self, cfg_components):
+            db_comp_def = self._pedb.definitions.component
+            for name, compdef_obj in db_comp_def.items():
+                nport_models = compdef_obj.component_models
+                if not nport_models:
+                    continue
+                else:
+                    pin_order = compdef_obj.get_properties()["pin_order"]
+                    temp_comps = [i for i in cfg_components if i["definition"] == name]
+                    for model_name, model_obj in nport_models.items():
+                        temp_comp_list = []
+                        reference_net_per_component = {}
+                        for i in temp_comps:
+                            s_param_model = i.get("s_parameter_model")
+                            if s_param_model:
+                                if s_param_model["model_name"] == model_name:
+                                    temp_comp_list.append(i["reference_designator"])
+                                    reference_net_per_component[i["reference_designator"]] = s_param_model[
+                                        "reference_net"
+                                    ]
+                            else:
+                                continue
+
+                        self.parent.s_parameters_models.append(
+                            CfgSParameterModel(
+                                name=model_name,
+                                component_definition=name,
+                                file_path=model_obj.reference_file,
+                                apply_to_all=False,
+                                components=temp_comp_list,
+                                reference_net_per_component=reference_net_per_component,
+                                pin_order=pin_order,
+                            )
+                        )
+
+            data = []
+            for i in self.parent.s_parameters_models:
+                data.append(
+                    {
+                        "name": i.name,
+                        "component_definition": i.component_definition,
+                        "file_path": i.file_path,
+                        "apply_to_all": i.apply_to_all,
+                        "components": i.components,
+                        "reference_net_per_component": i.reference_net_per_component,
+                        "pin_order": i.pin_order,
+                    }
+                )
+            return data
+
     def __init__(self, pedb, data, path_lib=None):
         self._pedb = pedb
         if self._pedb.grpc:

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):
@@ -149,7 +195,7 @@ class CfgSIwaveDCSetup(CfgSetup):
                 name=self.parent.name, dc_slider_position=self.parent.dc_slider_position
             )
             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"]
+            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()
@@ -168,7 +214,7 @@ class CfgSIwaveDCSetup(CfgSetup):
             )
             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.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)
@@ -216,8 +262,12 @@ class CfgHFSSSetup(CfgSetup):
             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})
+            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 (
@@ -241,6 +291,17 @@ class CfgHFSSSetup(CfgSetup):
                     }
                 )
 
+        @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)